Exp4-Prediction-Batch 1-24 hour.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "from pandas import Series\n",
    "from pandas import concat\n",
    "from pandas import read_csv\n",
    "from pandas import datetime\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM\n",
    "from math import sqrt\n",
    "from matplotlib import pyplot\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hardcode all variables\n",
    "batch_size_exp = 1\n",
    "epoch_exp = 7\n",
    "neurons_exp = 10\n",
    "predict_values_exp = 24\n",
    "lag_exp=24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# frame a sequence as a supervised learning problem\n",
    "def timeseries_to_supervised(data, lag=1):\n",
    "    df = DataFrame(data)\n",
    "    columns = [df.shift(i) for i in range(1, lag+1)]\n",
    "    columns.append(df)\n",
    "    df = concat(columns, axis=1)\n",
    "    df.fillna(0, inplace=True)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a differenced series\n",
    "def difference(dataset, interval=1):\n",
    "    diff = list()\n",
    "    for i in range(interval, len(dataset)):\n",
    "        value = dataset[i] - dataset[i - interval]\n",
    "        diff.append(value)\n",
    "    return Series(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# invert differenced value\n",
    "def inverse_difference(history, yhat, interval=1):\n",
    "    return yhat + history[-interval]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale train and test data to [-1, 1]\n",
    "def scale(train, test):\n",
    "    # fit scaler\n",
    "    scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "    scaler = scaler.fit(train)\n",
    "    # transform train\n",
    "    train = train.reshape(train.shape[0], train.shape[1])\n",
    "    train_scaled = scaler.transform(train)\n",
    "    # transform test\n",
    "    test = test.reshape(test.shape[0], test.shape[1])\n",
    "    test_scaled = scaler.transform(test)\n",
    "    return scaler, train_scaled, test_scaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inverse scaling for a forecasted value\n",
    "def invert_scale(scaler, X, value):\n",
    "    new_row = [x for x in X] + [value]\n",
    "    array = np.array(new_row)\n",
    "    array = array.reshape(1, len(array))\n",
    "    inverted = scaler.inverse_transform(array)\n",
    "    return inverted[0, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit an LSTM network to training data\n",
    "def fit_lstm(train, batch_size, nb_epoch, neurons):\n",
    "    X, y = train[:, 0:-1], train[:, -1]\n",
    "    X = X.reshape(X.shape[0], 1, X.shape[1])\n",
    "    model = Sequential()\n",
    "    model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))\n",
    "    model.add(Dense(1))\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "    for i in range(nb_epoch):\n",
    "        model.fit(X, y, epochs=1, batch_size=batch_size, verbose=1, shuffle=False)\n",
    "        model.reset_states()\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a one-step forecast\n",
    "def forecast_lstm(model, batch_size, X):\n",
    "    X = X.reshape(1, 1, len(X))\n",
    "    #print(X)\n",
    "    yhat = model.predict(X, batch_size=1)\n",
    "    return yhat[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Air temperature | ('C)</th>\n",
       "      <th>Pressure | (atm)</th>\n",
       "      <th>Wind speed | (m/s)</th>\n",
       "      <th>Wind direction | (deg)</th>\n",
       "      <th>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2007-01-01 00:00:00</th>\n",
       "      <td>10.926</td>\n",
       "      <td>0.979103</td>\n",
       "      <td>9.014</td>\n",
       "      <td>229</td>\n",
       "      <td>33688.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 01:00:00</th>\n",
       "      <td>9.919</td>\n",
       "      <td>0.979566</td>\n",
       "      <td>9.428</td>\n",
       "      <td>232</td>\n",
       "      <td>37261.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 02:00:00</th>\n",
       "      <td>8.567</td>\n",
       "      <td>0.979937</td>\n",
       "      <td>8.700</td>\n",
       "      <td>236</td>\n",
       "      <td>30502.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 03:00:00</th>\n",
       "      <td>7.877</td>\n",
       "      <td>0.980053</td>\n",
       "      <td>8.481</td>\n",
       "      <td>247</td>\n",
       "      <td>28419.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 04:00:00</th>\n",
       "      <td>7.259</td>\n",
       "      <td>0.979867</td>\n",
       "      <td>8.383</td>\n",
       "      <td>256</td>\n",
       "      <td>27370.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Air temperature | ('C)  Pressure | (atm)  \\\n",
       "DateTime                                                        \n",
       "2007-01-01 00:00:00                  10.926          0.979103   \n",
       "2007-01-01 01:00:00                   9.919          0.979566   \n",
       "2007-01-01 02:00:00                   8.567          0.979937   \n",
       "2007-01-01 03:00:00                   7.877          0.980053   \n",
       "2007-01-01 04:00:00                   7.259          0.979867   \n",
       "\n",
       "                     Wind speed | (m/s)  Wind direction | (deg)  \\\n",
       "DateTime                                                          \n",
       "2007-01-01 00:00:00               9.014                     229   \n",
       "2007-01-01 01:00:00               9.428                     232   \n",
       "2007-01-01 02:00:00               8.700                     236   \n",
       "2007-01-01 03:00:00               8.481                     247   \n",
       "2007-01-01 04:00:00               8.383                     256   \n",
       "\n",
       "                     Power generated by system | (kW)  \n",
       "DateTime                                               \n",
       "2007-01-01 00:00:00                           33688.1  \n",
       "2007-01-01 01:00:00                           37261.9  \n",
       "2007-01-01 02:00:00                           30502.9  \n",
       "2007-01-01 03:00:00                           28419.2  \n",
       "2007-01-01 04:00:00                           27370.3  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' Loading data '''\n",
    "import pandas as pd\n",
    "series = pd.read_excel('AL_WIND_07_12.xlsx',index_col=\"DateTime\")\n",
    "series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2007-01-01 00:00:00</th>\n",
       "      <td>33688.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 01:00:00</th>\n",
       "      <td>37261.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 02:00:00</th>\n",
       "      <td>30502.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 03:00:00</th>\n",
       "      <td>28419.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 04:00:00</th>\n",
       "      <td>27370.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Power generated by system | (kW)\n",
       "DateTime                                             \n",
       "2007-01-01 00:00:00                           33688.1\n",
       "2007-01-01 01:00:00                           37261.9\n",
       "2007-01-01 02:00:00                           30502.9\n",
       "2007-01-01 03:00:00                           28419.2\n",
       "2007-01-01 04:00:00                           27370.3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Drop all the features as we will not be having any in production'''\n",
    "del series['Air temperature | (\\'C)']\n",
    "del series['Pressure | (atm)']\n",
    "del series['Wind speed | (m/s)']\n",
    "del series['Wind direction | (deg)']\n",
    "series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-12-31 09:00:00</th>\n",
       "      <td>6110.57</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 10:00:00</th>\n",
       "      <td>6251.34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 11:00:00</th>\n",
       "      <td>6899.17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 12:00:00</th>\n",
       "      <td>4514.49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 13:00:00</th>\n",
       "      <td>1561.25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Power generated by system | (kW)\n",
       "DateTime                                             \n",
       "2012-12-31 09:00:00                           6110.57\n",
       "2012-12-31 10:00:00                           6251.34\n",
       "2012-12-31 11:00:00                           6899.17\n",
       "2012-12-31 12:00:00                           4514.49\n",
       "2012-12-31 13:00:00                           1561.25"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "  series = series[:-1]\n",
    "series.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform data to be stationary\n",
    "raw_values = series.values\n",
    "diff_values = difference(raw_values, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform data to be supervised learning\n",
    "supervised = timeseries_to_supervised(diff_values, lag_exp)\n",
    "supervised_values = supervised.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split data into train and test-sets\n",
    "train, test = supervised_values[0:-predict_values_exp], supervised_values[-predict_values_exp:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\envs\\tensorflow\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by MinMaxScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "# transform the scale of the data\n",
    "scaler, train_scaled, test_scaled = scale(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 229s 4ms/step - loss: 0.0141\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 147s 3ms/step - loss: 0.0137\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 133s 3ms/step - loss: 0.0136\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 139s 3ms/step - loss: 0.0134\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 134s 3ms/step - loss: 0.0133\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 143s 3ms/step - loss: 0.0133\n",
      "Epoch 1/1\n",
      "52525/52525 [==============================] - 140s 3ms/step - loss: 0.0132\n"
     ]
    }
   ],
   "source": [
    "# fit the model\n",
    "lstm_model = fit_lstm(train_scaled, batch_size_exp, epoch_exp, neurons_exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hour=1, Predicted=25900.606203, Expected=20005.800000\n",
      "Hour=2, Predicted=18741.940436, Expected=19870.600000\n",
      "Hour=3, Predicted=17186.347509, Expected=23296.700000\n",
      "Hour=4, Predicted=19970.544958, Expected=36275.400000\n",
      "Hour=5, Predicted=32694.307580, Expected=41119.700000\n",
      "Hour=6, Predicted=38784.901734, Expected=45831.200000\n",
      "Hour=7, Predicted=45244.571537, Expected=38451.600000\n",
      "Hour=8, Predicted=38394.014570, Expected=38107.700000\n",
      "Hour=9, Predicted=39446.226575, Expected=36325.100000\n",
      "Hour=10, Predicted=37718.859102, Expected=37641.300000\n",
      "Hour=11, Predicted=37562.185911, Expected=36876.500000\n",
      "Hour=12, Predicted=35527.747579, Expected=35723.600000\n",
      "Hour=13, Predicted=33548.336445, Expected=28221.500000\n",
      "Hour=14, Predicted=27813.484924, Expected=22650.000000\n",
      "Hour=15, Predicted=22153.684828, Expected=14845.100000\n",
      "Hour=16, Predicted=14229.969710, Expected=11449.700000\n",
      "Hour=17, Predicted=10919.903027, Expected=11637.200000\n",
      "Hour=18, Predicted=11501.872963, Expected=6465.350000\n",
      "Hour=19, Predicted=6812.684614, Expected=5802.110000\n",
      "Hour=20, Predicted=6693.225097, Expected=6110.570000\n",
      "Hour=21, Predicted=7342.619033, Expected=6251.340000\n",
      "Hour=22, Predicted=7725.498266, Expected=6899.170000\n",
      "Hour=23, Predicted=8367.495436, Expected=4514.490000\n",
      "Hour=24, Predicted=5876.067964, Expected=1561.250000\n"
     ]
    }
   ],
   "source": [
    "# walk-forward validation on the test data\n",
    "predictions = list()\n",
    "expectations = list()\n",
    "test_pred = list()\n",
    "for i in range(len(test_scaled)):\n",
    "    # make one-step forecast\n",
    "    X, y = test_scaled[i, 0:-1], test_scaled[i, -1]\n",
    "    yhat = forecast_lstm(lstm_model, 1, X)#batch_size_exp to 1\n",
    "    '''# Start Debug prints\n",
    "    print(\"X: %\", X)\n",
    "    print(\"yhat: %\", yhat)\n",
    "    # End Debug prints'''\n",
    "    # Replacing value in test scaled with the predicted value.\n",
    "    test_pred = [yhat] + test_pred \n",
    "    if i+1<len(test_scaled):\n",
    "        test_scaled[i+1] = np.concatenate((test_pred, test_scaled[i+1, i+1:]),axis=0)\n",
    "    # invert scaling\n",
    "    yhat = invert_scale(scaler, X, yhat)\n",
    "    # invert differencing\n",
    "    yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)\n",
    "    # store forecast\n",
    "    predictions.append(yhat)\n",
    "    expected = raw_values[len(train) + i + 1]\n",
    "    expectations.append(expected)\n",
    "    print('Hour=%d, Predicted=%f, Expected=%f' % (i+1, yhat, expected))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Percent Error:  32.88181266987708\n"
     ]
    }
   ],
   "source": [
    "expectations = np.array(expectations)\n",
    "predictions = np.array(predictions)\n",
    "print(\"Mean Absolute Percent Error: \", (np.mean(np.abs((expectations - predictions) / expectations))*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# line plot of observed vs predicted\n",
    "pyplot.plot(raw_values[-predict_values_exp:], label=\"True\")\n",
    "pyplot.plot(predictions, label=\"Predicted\")\n",
    "pyplot.legend(loc='upper right')\n",
    "pyplot.xlabel(\"Number of hours\")\n",
    "pyplot.ylabel(\"Power generated by system (kW)\")\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}