notebooks/rolling_forecast.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Rolling Forecast:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: TkAgg\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import datetime\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import pytz\n",
    "from keras.models import load_model\n",
    "from keras import backend as K\n",
    "\n",
    "# Setup for Latex Export: https://matplotlib.org/users/pgf.html. Need to import before pyplot\n",
    "def figsize(scale):\n",
    "    fig_width_pt = 469.755                          # Get this from LaTeX using \\the\\textwidth\n",
    "    inches_per_pt = 1.0/72.27                       # Convert pt to inch\n",
    "    golden_mean = (np.sqrt(5.0)-1.0)/2.0            # Aesthetic ratio (you could change this)\n",
    "    fig_width = fig_width_pt*inches_per_pt*scale    # width in inches\n",
    "    fig_height = fig_width*golden_mean              # height in inches\n",
    "    fig_size = [fig_width,fig_height]\n",
    "    return fig_size\n",
    "\n",
    "import matplotlib as mpl\n",
    "mpl.use('pgf')\n",
    "pgf_with_rc_fonts = {\n",
    "    \"text.usetex\": True,\n",
    "    \"font.family\": \"serif\",\n",
    "    \"axes.labelsize\": 10,               # LaTeX default is 10pt font.\n",
    "    \"font.size\": 10,\n",
    "    \"legend.fontsize\": 8,               # Make the legend/label fonts a little smaller\n",
    "    \"xtick.labelsize\": 8,\n",
    "    \"ytick.labelsize\": 8,\n",
    "    \"figure.figsize\": figsize(0.9),     # default fig size of 0.9 textwidth\n",
    "    #\"font.serif\": [],                   # use latex default serif font\n",
    "    #\"font.sans-serif\": [\"DejaVu Sans\"], # use a specific sans-serif font\n",
    "}\n",
    "mpl.rcParams.update(pgf_with_rc_fonts)\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from tabulate import tabulate\n",
    "\n",
    "# Import custom module functions\n",
    "module_path = os.path.abspath(os.path.join('../'))\n",
    "if module_path not in sys.path:\n",
    "    sys.path.append(module_path)\n",
    "\n",
    "from lstm_load_forecasting import data, lstm\n",
    "\n",
    "from ast import literal_eval\n",
    "\n",
    "from dateutil.tz import tzutc\n",
    "\n",
    "%matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Settings "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "timezone = pytz.timezone('Europe/Zurich')\n",
    "starting = timezone.localize(datetime.datetime(2017,2,1,0,0,0,0))\n",
    "path = os.path.join('../Data', 'fulldataset.csv')\n",
    "res_path = os.path.abspath('../results/')\n",
    "model_dir = os.path.abspath('../models/')\n",
    "date = '20170616'\n",
    "# Quite important for the rolling forecast. 1 gives not much better performance than dynamic forecast, 20 is already too much.\n",
    "# 10 gave 4.0 and 4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 4 (ENTSOE + Calendar):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 8/48 [====>.........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/40 [=====>........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/24 [=========>....................] - ETA: 0s"
     ]
    }
   ],
   "source": [
    "model_id = 4\n",
    "# Lets use the same as in the model run\n",
    "epochs = 10 # At 10: 283 and 4.2\n",
    "\n",
    "df4 = data.load_dataset(path=path, modules=['actual', 'entsoe', 'calendar'])\n",
    "df4_scaled = df4.copy()\n",
    "df4_scaled = df4_scaled.dropna()\n",
    "\n",
    "# Get all float type columns\n",
    "floats = [key for key in dict(df4_scaled.dtypes) if dict(df4_scaled.dtypes)[key] in ['float64']]\n",
    "scaler = StandardScaler()\n",
    "scaled_columns = scaler.fit_transform(df4_scaled[floats])\n",
    "df4_scaled[floats] = scaled_columns\n",
    "\n",
    "df4_train = df4_scaled.loc[(df4_scaled.index < starting )].copy()\n",
    "df4_test = df4_scaled.loc[df4_scaled.index >= starting].copy()\n",
    "y_train = df4_train['actual'].copy()\n",
    "X_train = df4_train.drop('actual', 1).copy()\n",
    "y_test = df4_test['actual'].copy()\n",
    "X_test = df4_test.drop('actual', 1).copy()\n",
    "\n",
    "valid_results_4 = pd.read_csv(os.path.join(res_path, 'notebook_04/', str('04_results_' + date + '.csv')), delimiter=';')\n",
    "test_results_4 = pd.read_csv(os.path.join(res_path, 'notebook_04/', str('04_test_results' + date + '.csv')), delimiter=';')\n",
    "test_results_4 = test_results_4.sort_values('Mean absolute error', ascending=True)\n",
    "best_model_4 = test_results_4.loc[0]['Model name']\n",
    "\n",
    "config = valid_results_4.loc[valid_results_4['model_name'] == best_model_4]\n",
    "batch_size = int(config['batch_train'].values[0])\n",
    "size = int(y_test.shape[0] / batch_size)\n",
    "\n",
    "layers = literal_eval(config['config'].values[0])\n",
    "layers = layers['layers']\n",
    "\n",
    "# Load model\n",
    "notebook = 'notebook_0' + str(model_id)\n",
    "mod_name = config['model_name'].values[0]\n",
    "filename = os.path.join(model_dir, notebook, (mod_name +'.h5'))\n",
    "model4 = load_model(filename)\n",
    "model4.reset_states()\n",
    "\n",
    "# Loop through window\n",
    "starting_loc = starting\n",
    "starting_utc = starting.astimezone(pytz.utc)\n",
    "ending_utc = df4_test.tail(1).index[0]\n",
    "ending_loc = ending_utc.tz_convert('Europe/Zurich')\n",
    "day_changes = pd.date_range(start=starting_loc, end=ending_loc, freq='24h', tz=\"Europe/Zurich\")\n",
    "\n",
    "predictions = pd.DataFrame(index=pd.date_range(start=starting_loc, end=ending_loc, normalize=True, freq='60min', tz='Europe/Zurich'))\n",
    "predictions.index = predictions.index.tz_convert('utc')\n",
    "\n",
    "for idx, hour in enumerate(day_changes):\n",
    "    if idx == 0:\n",
    "        pass\n",
    "    else:\n",
    "        # Select the actual values from the previous day and retrain the model with that new data\n",
    "        dh = df4_test.loc[(df4_test.index >= hour - pd.DateOffset(days=1)) & (df4_test.index < hour)]\n",
    "        y_train = dh['actual']\n",
    "        X_train = dh.drop('actual', 1)\n",
    "        history = lstm.train_model(model=model4, mode='fit', y=y_train, X=X_train, \n",
    "                                   batch_size=batch_size, timesteps=1, epochs=epochs, rearrange=False, validation_split=0,\n",
    "                                   verbose=0, early_stopping=False)\n",
    "    # Select the input data for the next 2 days and create multistep forecast\n",
    "    df = df4_test.loc[(df4_test.index >= hour) & (df4_test.index < hour + pd.DateOffset(days=2))]\n",
    "    df = df.drop('actual', 1)\n",
    "    X_predict = df\n",
    "    scaled_predictions = lstm.get_predictions(model=model4, X=X_predict, batch_size=batch_size, timesteps=1, verbose=1)\n",
    "    hour_utc = hour.tz_convert('utc')\n",
    "    # Combine and store results\n",
    "    window = pd.date_range(start=hour_utc, periods=len(scaled_predictions), freq='60min', tz='UTC')\n",
    "    result = pd.DataFrame(data={\"model4\": scaled_predictions.flatten()}, index=window)\n",
    "    predictions = predictions.combine_first(result)\n",
    "\n",
    "mu = scaler.mean_[0]\n",
    "sigma = scaler.scale_[0]\n",
    "model4_predictions = mu + sigma*predictions\n",
    "\n",
    "K.clear_session()\n",
    "import tensorflow as tf\n",
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 5 (Calendar + Weather)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 8/48 [====>.........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/40 [=====>........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/24 [=========>....................] - ETA: 0s"
     ]
    }
   ],
   "source": [
    "model_id = 5\n",
    "epochs = 10 # At 10: 262.5 and 3.9\n",
    "\n",
    "df5 = data.load_dataset(path=path, modules=['actual', 'calendar', 'weather'])\n",
    "df5_scaled = df5.copy()\n",
    "df5_scaled = df5_scaled.dropna()\n",
    "\n",
    "# Get all float type columns\n",
    "floats = [key for key in dict(df5_scaled.dtypes) if dict(df5_scaled.dtypes)[key] in ['float64']]\n",
    "scaler = StandardScaler()\n",
    "scaled_columns = scaler.fit_transform(df5_scaled[floats])\n",
    "df5_scaled[floats] = scaled_columns\n",
    "\n",
    "df5_train = df5_scaled.loc[(df5_scaled.index < starting )].copy()\n",
    "df5_test = df5_scaled.loc[df5_scaled.index >= starting].copy()\n",
    "y_train = df5_train['actual'].copy()\n",
    "X_train = df5_train.drop('actual', 1).copy()\n",
    "y_test = df5_test['actual'].copy()\n",
    "X_test = df5_test.drop('actual', 1).copy()\n",
    "\n",
    "valid_results_5 = pd.read_csv(os.path.join(res_path, 'notebook_05/', str('05_results_' + date + '.csv')), delimiter=';')\n",
    "test_results_5 = pd.read_csv(os.path.join(res_path, 'notebook_05/', str('05_test_results' + date + '.csv')), delimiter=';')\n",
    "test_results_5 = test_results_5.sort_values('Mean absolute error', ascending=True)\n",
    "best_model_5 = test_results_5.loc[0]['Model name']\n",
    "\n",
    "config = valid_results_5.loc[valid_results_5['model_name'] == best_model_5]\n",
    "batch_size = int(config['batch_train'].values[0])\n",
    "size = int(y_test.shape[0] / batch_size)\n",
    "\n",
    "layers = literal_eval(config['config'].values[0])\n",
    "layers = layers['layers']\n",
    "\n",
    "# Load model\n",
    "notebook = 'notebook_0' + str(model_id)\n",
    "mod_name = config['model_name'].values[0]\n",
    "filename = os.path.join(model_dir, notebook, (mod_name +'.h5'))\n",
    "model5 = load_model(filename)\n",
    "model5.reset_states()\n",
    "\n",
    "# Loop through window\n",
    "starting_loc = starting\n",
    "starting_utc = starting.astimezone(pytz.utc)\n",
    "ending_utc = df5_test.tail(1).index[0]\n",
    "ending_loc = ending_utc.tz_convert('Europe/Zurich')\n",
    "day_changes = pd.date_range(start=starting_loc, end=ending_loc, freq='24h', tz=\"Europe/Zurich\")\n",
    "\n",
    "predictions = pd.DataFrame(index=pd.date_range(start=starting_loc, end=ending_loc, normalize=True, freq='60min', tz='Europe/Zurich'))\n",
    "predictions.index = predictions.index.tz_convert('utc')\n",
    "\n",
    "for idx, hour in enumerate(day_changes):\n",
    "    if idx == 0:\n",
    "        pass\n",
    "    else:\n",
    "        # Select the actual values from the previous day and retrain the model with that new data\n",
    "        dh = df5_test.loc[(df5_test.index >= hour - pd.DateOffset(days=1)) & (df5_test.index < hour)]\n",
    "        y_train = dh['actual']\n",
    "        X_train = dh.drop('actual', 1)\n",
    "        history = lstm.train_model(model=model5, mode='fit', y=y_train, X=X_train, \n",
    "                                   batch_size=batch_size, timesteps=1, epochs=epochs, rearrange=False, validation_split=0,\n",
    "                                   verbose=0, early_stopping=False)\n",
    "    # Select the input data for the next 2 days and create multistep forecast\n",
    "    df = df5_test.loc[(df5_test.index >= hour) & (df5_test.index < hour + pd.DateOffset(days=2))]\n",
    "    df = df.drop('actual', 1)\n",
    "    X_predict = df\n",
    "    scaled_predictions = lstm.get_predictions(model=model5, X=X_predict, batch_size=batch_size, timesteps=1, verbose=1)\n",
    "    hour_utc = hour.tz_convert('utc')\n",
    "    # Combine and store results\n",
    "    window = pd.date_range(start=hour_utc, periods=len(scaled_predictions), freq='60min', tz='UTC')\n",
    "    result = pd.DataFrame(data={\"model5\": scaled_predictions.flatten()}, index=window)\n",
    "    predictions = predictions.combine_first(result)\n",
    "\n",
    "mu = scaler.mean_[0]\n",
    "sigma = scaler.scale_[0]\n",
    "model5_predictions = mu + sigma*predictions\n",
    "\n",
    "K.clear_session()\n",
    "import tensorflow as tf\n",
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 6 (All) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 8/48 [====>.........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/40 [=====>........................] - ETA: 0sWarnining: Division \"sample_size/batch_size\" not a natural number.\n",
      "Dropped the last 7 of 47 number of obs.\n",
      " 8/24 [=========>....................] - ETA: 0s"
     ]
    }
   ],
   "source": [
    "model_id = 6\n",
    "epochs = 10 # At 10: 274 and 4.1\n",
    "\n",
    "df6 = data.load_dataset(path=path, modules=['all'])\n",
    "df6_scaled = df6.copy()\n",
    "df6_scaled = df6_scaled.dropna()\n",
    "\n",
    "# Get all float type columns\n",
    "floats = [key for key in dict(df6_scaled.dtypes) if dict(df6_scaled.dtypes)[key] in ['float64']]\n",
    "scaler = StandardScaler()\n",
    "scaled_columns = scaler.fit_transform(df6_scaled[floats])\n",
    "df6_scaled[floats] = scaled_columns\n",
    "\n",
    "df6_train = df6_scaled.loc[(df6_scaled.index < starting )].copy()\n",
    "df6_test = df6_scaled.loc[df6_scaled.index >= starting].copy()\n",
    "y_train = df6_train['actual'].copy()\n",
    "X_train = df6_train.drop('actual', 1).copy()\n",
    "y_test = df6_test['actual'].copy()\n",
    "X_test = df6_test.drop('actual', 1).copy()\n",
    "\n",
    "valid_results_6 = pd.read_csv(os.path.join(res_path, 'notebook_06/', str('06_results_' + date + '.csv')), delimiter=';')\n",
    "test_results_6 = pd.read_csv(os.path.join(res_path, 'notebook_06/', str('06_test_results' + date + '.csv')), delimiter=';')\n",
    "test_results_6 = test_results_6.sort_values('Mean absolute error', ascending=True)\n",
    "best_model_6 = test_results_6.loc[0]['Model name']\n",
    "\n",
    "config = valid_results_6.loc[valid_results_6['model_name'] == best_model_6]\n",
    "batch_size = int(config['batch_train'].values[0])\n",
    "size = int(y_test.shape[0] / batch_size)\n",
    "\n",
    "layers = literal_eval(config['config'].values[0])\n",
    "layers = layers['layers']\n",
    "\n",
    "# Load model\n",
    "notebook = 'notebook_0' + str(model_id)\n",
    "mod_name = config['model_name'].values[0]\n",
    "filename = os.path.join(model_dir, notebook, (mod_name +'.h5'))\n",
    "model6 = load_model(filename)\n",
    "model6.reset_states()\n",
    "\n",
    "# Loop through window\n",
    "starting_loc = starting\n",
    "starting_utc = starting.astimezone(pytz.utc)\n",
    "ending_utc = df6_test.tail(1).index[0]\n",
    "ending_loc = ending_utc.tz_convert('Europe/Zurich')\n",
    "day_changes = pd.date_range(start=starting_loc, end=ending_loc, freq='24h', tz=\"Europe/Zurich\")\n",
    "\n",
    "predictions = pd.DataFrame(index=pd.date_range(start=starting_loc, end=ending_loc, normalize=True, freq='60min', tz='Europe/Zurich'))\n",
    "predictions.index = predictions.index.tz_convert('utc')\n",
    "\n",
    "for idx, hour in enumerate(day_changes):\n",
    "    if idx == 0:\n",
    "        pass\n",
    "    else:\n",
    "        # Select the actual values from the previous day and retrain the model with that new data\n",
    "        dh = df6_test.loc[(df6_test.index >= hour - pd.DateOffset(days=1)) & (df6_test.index < hour)]\n",
    "        y_train = dh['actual']\n",
    "        X_train = dh.drop('actual', 1)\n",
    "        history = lstm.train_model(model=model6, mode='fit', y=y_train, X=X_train, \n",
    "                                   batch_size=batch_size, timesteps=1, epochs=epochs, rearrange=False, validation_split=0,\n",
    "                                   verbose=0, early_stopping=False)\n",
    "    # Select the input data for the next 2 days and create multistep forecast\n",
    "    df = df6_test.loc[(df6_test.index >= hour) & (df6_test.index < hour + pd.DateOffset(days=2))]\n",
    "    df = df.drop('actual', 1)\n",
    "    X_predict = df\n",
    "    scaled_predictions = lstm.get_predictions(model=model6, X=X_predict, batch_size=batch_size, timesteps=1, verbose=1)\n",
    "    hour_utc = hour.tz_convert('utc')\n",
    "    # Combine and store results\n",
    "    window = pd.date_range(start=hour_utc, periods=len(scaled_predictions), freq='60min', tz='UTC')\n",
    "    result = pd.DataFrame(data={\"model6\": scaled_predictions.flatten()}, index=window)\n",
    "    predictions = predictions.combine_first(result)\n",
    "\n",
    "mu = scaler.mean_[0]\n",
    "sigma = scaler.scale_[0]\n",
    "model6_predictions = mu + sigma*predictions\n",
    "\n",
    "K.clear_session()\n",
    "import tensorflow as tf\n",
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rolling ARMA 1 + 2 forecast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "timezone = pytz.timezone('Europe/Zurich')\n",
    "starting = timezone.localize(datetime.datetime(2017,2,1,0,0,0,0))\n",
    "arma_fc = pd.read_csv(os.path.join('../data', 'arma_rolling_fc.csv'))\n",
    "arma_forecasts = pd.DataFrame(data={\"arma_forecast\": arma_fc['x'].values}, index=pd.date_range(starting, periods=arma_fc.shape[0], freq='60min'))\n",
    "arma_fc2 = pd.read_csv(os.path.join('../data', 'arma_rolling_fc2.csv'))\n",
    "arma_forecasts2 = pd.DataFrame(data={\"arma_forecast2\": arma_fc2['x'].values}, index=pd.date_range(starting, periods=arma_fc2.shape[0], freq='60min'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{lrrrrrr}\n",
      "\\hline\n",
      "      &   entsoe &    arima &   arima2 &   m4-entsoe-cal &   m5-cal-weather &   m6-all \\\\\n",
      "\\hline\n",
      " MSE  & 426230.2 & 217798.2 & 386985.6 &        130055.0 &         124582.2 & 120620.2 \\\\\n",
      " MAE  &    516.9 &    373.6 &    492.7 &           283.0 &            267.7 &    271.5 \\\\\n",
      " MAPE &      7.7 &      5.5 &      7.3 &             4.2 &              4.0 &      4.0 \\\\\n",
      "\\hline\n",
      "\\end{tabular}\n"
     ]
    }
   ],
   "source": [
    "def mean_absolute_percentage_error(y_true, y_pred): \n",
    "    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100\n",
    "dfc = data.load_dataset(path=path, modules=['actual', 'entsoe'])\n",
    "forecasts = model4_predictions\n",
    "forecasts = forecasts.join(model5_predictions)\n",
    "forecasts = forecasts.join(model6_predictions)\n",
    "forecasts = forecasts.join(dfc)\n",
    "forecasts = forecasts.join(arma_forecasts)\n",
    "forecasts = forecasts.join(arma_forecasts2)\n",
    "forecasts = forecasts.dropna()\n",
    "results = {}\n",
    "results[''] = ['MSE', 'MAE', 'MAPE']\n",
    "results['entsoe'] = [mean_squared_error(forecasts['actual'], forecasts['entsoe']), \n",
    "                     mean_absolute_error(forecasts['actual'], forecasts['entsoe']),\n",
    "                     mean_absolute_percentage_error(forecasts['actual'], forecasts['entsoe'])\n",
    "                    ]\n",
    "results['arima'] = [mean_squared_error(forecasts['actual'], forecasts['arma_forecast']), \n",
    "                          mean_absolute_error(forecasts['actual'], forecasts['arma_forecast']),\n",
    "                          mean_absolute_percentage_error(forecasts['actual'], forecasts['arma_forecast'])\n",
    "                         ]\n",
    "results['arima2'] = [mean_squared_error(forecasts['actual'], forecasts['arma_forecast2']), \n",
    "                          mean_absolute_error(forecasts['actual'], forecasts['arma_forecast2']),\n",
    "                          mean_absolute_percentage_error(forecasts['actual'], forecasts['arma_forecast2'])\n",
    "                         ]\n",
    "results['m4-entsoe-cal'] = [mean_squared_error(forecasts['actual'], forecasts['model4']), \n",
    "                          mean_absolute_error(forecasts['actual'], forecasts['model4']),\n",
    "                          mean_absolute_percentage_error(forecasts['actual'], forecasts['model4'])\n",
    "                         ]\n",
    "results['m5-cal-weather'] = [mean_squared_error(forecasts['actual'], forecasts['model5']), \n",
    "                          mean_absolute_error(forecasts['actual'], forecasts['model5']),\n",
    "                          mean_absolute_percentage_error(forecasts['actual'], forecasts['model5'])\n",
    "                         ]\n",
    "results['m6-all'] = [mean_squared_error(forecasts['actual'], forecasts['model6']), \n",
    "                     mean_absolute_error(forecasts['actual'], forecasts['model6']),\n",
    "                     mean_absolute_percentage_error(forecasts['actual'], forecasts['model6'])\n",
    "                    ]\n",
    "print(tabulate(results, headers='keys', numalign=\"right\", tablefmt='latex', floatfmt=\".1f\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plt.figure()\n",
    "#plt.plot(forecasts.index, forecasts['entsoe'], label='ENTSOE Forecast')\n",
    "plt.plot(forecasts.index, forecasts['arma_forecast'], label='ARIMA (0,1,5)')\n",
    "plt.plot(forecasts.index, forecasts['actual'], label='Actual Load')\n",
    "#plt.plot(forecasts.index, forecasts['model4'], label='Model 4 (ENTSO-E and Calendar)')\n",
    "plt.plot(forecasts.index, forecasts['model5'], label='Model 5 (Calendar and Weather)')\n",
    "#plt.plot(forecasts.index, forecasts['model6'], label='Model 6 (All)')\n",
    "plt.title('Forecast Comparison: Rolling Forecast')\n",
    "plt.ylabel('Electricity load (in MW)')\n",
    "plt.xlabel('Date')\n",
    "plt.legend(loc='upper right')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}