diff --git a/4_ES_RNN.ipynb b/4_ES_RNN.ipynb
new file mode 100644
index 0000000..b4921b7
--- /dev/null
+++ b/4_ES_RNN.ipynb
@@ -0,0 +1,1172 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# ES-RNN model \n",
+ "\n",
+ "In this notebook, we demonstrate how to:\n",
+ "- prepare time series data for training a RNN forecasting model\n",
+ "- get data in the required shape for the keras API\n",
+ "- implement an ES-RNN model in keras to predict the next 3 steps ahead (time *t+1* to *t+3*) in the time series. This model uses recent values of load as the model input. The model will be trained to output a vector, the elements of which are ordered predictions for future time steps.\n",
+ "- enable early stopping to reduce the likelihood of model overfitting\n",
+ "- evaluate the model on a test dataset\n",
+ "\n",
+ "The data in this example is taken from the GEFCom2014 forecasting competition1 . It consists of 3 years of hourly electricity load and temperature values between 2012 and 2014. The task is to forecast future values of electricity load.\n",
+ "\n",
+ "1 Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli and Rob J. Hyndman, \"Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond\", International Journal of Forecasting, vol.32, no.3, pp 896-913, July-September, 2016."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import warnings\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import datetime as dt\n",
+ "from collections import UserDict, deque\n",
+ "from IPython.display import Image\n",
+ "%matplotlib inline\n",
+ "\n",
+ "from common.utils import load_data, mape, TimeSeriesTensor, create_evaluation_df\n",
+ "\n",
+ "pd.options.display.float_format = '{:,.2f}'.format\n",
+ "np.set_printoptions(precision=2)\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Load data into Pandas dataframe"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " load \n",
+ " temp \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 2012-01-01 00:00:00 \n",
+ " 2,698.00 \n",
+ " 32.00 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 01:00:00 \n",
+ " 2,558.00 \n",
+ " 32.67 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 02:00:00 \n",
+ " 2,444.00 \n",
+ " 30.00 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 03:00:00 \n",
+ " 2,402.00 \n",
+ " 31.00 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 04:00:00 \n",
+ " 2,403.00 \n",
+ " 32.00 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " load \n",
+ " temp \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 2014-12-31 19:00:00 \n",
+ " 4,012.00 \n",
+ " 18.00 \n",
+ " \n",
+ " \n",
+ " 2014-12-31 20:00:00 \n",
+ " 3,856.00 \n",
+ " 16.67 \n",
+ " \n",
+ " \n",
+ " 2014-12-31 21:00:00 \n",
+ " 3,671.00 \n",
+ " 17.00 \n",
+ " \n",
+ " \n",
+ " 2014-12-31 22:00:00 \n",
+ " 3,499.00 \n",
+ " 15.33 \n",
+ " \n",
+ " \n",
+ " 2014-12-31 23:00:00 \n",
+ " 3,345.00 \n",
+ " 15.33 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " tensor \n",
+ " target \n",
+ " X \n",
+ " \n",
+ " \n",
+ " feature \n",
+ " y \n",
+ " load \n",
+ " \n",
+ " \n",
+ " time step \n",
+ " t+1 \n",
+ " t+2 \n",
+ " t+3 \n",
+ " t-5 \n",
+ " t-4 \n",
+ " t-3 \n",
+ " t-2 \n",
+ " t-1 \n",
+ " t \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 2012-01-01 05:00:00 \n",
+ " 0.18 \n",
+ " 0.23 \n",
+ " 0.29 \n",
+ " 0.22 \n",
+ " 0.18 \n",
+ " 0.14 \n",
+ " 0.13 \n",
+ " 0.13 \n",
+ " 0.15 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 06:00:00 \n",
+ " 0.23 \n",
+ " 0.29 \n",
+ " 0.35 \n",
+ " 0.18 \n",
+ " 0.14 \n",
+ " 0.13 \n",
+ " 0.13 \n",
+ " 0.15 \n",
+ " 0.18 \n",
+ " \n",
+ " \n",
+ " 2012-01-01 07:00:00 \n",
+ " 0.29 \n",
+ " 0.35 \n",
+ " 0.37 \n",
+ " 0.14 \n",
+ " 0.13 \n",
+ " 0.13 \n",
+ " 0.15 \n",
+ " 0.18 \n",
+ " 0.23 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Image('./images/es_rnn.png')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from keras.models import Model\n",
+ "from keras.layers import Input, GRU, Dense, Lambda\n",
+ "from keras.callbacks import EarlyStopping"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "LATENT_DIM = 5\n",
+ "BATCH_SIZE = 48\n",
+ "EPOCHS = 1000\n",
+ "m = 24"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In the next cell we define custom \"Exponential Smoothing+Normalization\" and \"Denormalization\" layers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from keras import backend as K\n",
+ "from keras.layers import Layer\n",
+ "\n",
+ "# Exponential Smoothing + Normalization\n",
+ "class ES(Layer):\n",
+ "\n",
+ " def __init__(self, horizon, m, batch_size, time_steps, **kwargs):\n",
+ " self.horizon = horizon\n",
+ " self.m = m\n",
+ " self.batch_size = batch_size\n",
+ " self.time_steps = time_steps\n",
+ " \n",
+ " super(ES, self).__init__(**kwargs)\n",
+ "\n",
+ " # initialization of the learned parameters of exponential smoothing\n",
+ " def build(self, input_shape):\n",
+ " self.alpha = self.add_weight(name='alpha', shape=(1,),\n",
+ " initializer='uniform', trainable=True)\n",
+ " self.gamma = self.add_weight(name='gamma', shape=(1,),\n",
+ " initializer='uniform', trainable=True)\n",
+ " self.init_seasonality = self.add_weight(name='init_seasonality', shape=(self.m,),\n",
+ " initializer='uniform', trainable=True)\n",
+ " self.init_seasonality_list = [K.slice(self.init_seasonality,(i,),(1,)) for i in range(self.m)]\n",
+ " self.seasonality_queue = deque(self.init_seasonality_list, self.m)\n",
+ " self.level = K.zeros((1,))\n",
+ " \n",
+ " super(ES, self).build(input_shape) \n",
+ "\n",
+ " def call(self, x):\n",
+ "\n",
+ " # extract time-series from feature vector\n",
+ " n_examples = K.int_shape(x)[0]\n",
+ " if n_examples is None:\n",
+ " n_examples = self.batch_size\n",
+ " x1 = K.slice(x,(0,0,0),(1,self.time_steps,1))\n",
+ " x1 = K.reshape(x1,(self.time_steps,))\n",
+ " x2 = K.slice(x,(1,self.time_steps-1,0),(n_examples-1,1,1))\n",
+ " x2 = K.reshape(x2,(n_examples-1,))\n",
+ " ts = K.concatenate([x1,x2])\n",
+ " \n",
+ " x_norm = [] # normalized values of time-series\n",
+ " ls = [] # coeffients for denormalization of forecasts\n",
+ " \n",
+ " l_t_minus_1 = self.level\n",
+ " \n",
+ " for i in range(n_examples+self.time_steps-1):\n",
+ " \n",
+ " # compute l_t\n",
+ " y_t = ts[i]\n",
+ " s_t = self.seasonality_queue.popleft()\n",
+ " l_t = self.alpha * y_t / s_t + (1 - self.alpha) * l_t_minus_1\n",
+ " \n",
+ " # compute s_{t+m}\n",
+ " s_t_plus_m = self.gamma * y_t / l_t + (1 - self.gamma) * s_t\n",
+ " \n",
+ " self.seasonality_queue.append(s_t_plus_m)\n",
+ " \n",
+ " # normalize y_t\n",
+ " x_norm.append(y_t / (s_t * l_t))\n",
+ "\n",
+ " l_t_minus_1 = l_t\n",
+ "\n",
+ " if i >= self.time_steps-1:\n",
+ " l = [l_t]*self.horizon\n",
+ " l = K.concatenate(l)\n",
+ " s = [self.seasonality_queue[i] for i in range(self.horizon)] # we assume here that horizon < m\n",
+ " s = K.concatenate(s)\n",
+ " ls_t = K.concatenate([K.expand_dims(l), K.expand_dims(s)])\n",
+ " ls.append(K.expand_dims(ls_t,axis=0)) \n",
+ " \n",
+ " self.level = l_t\n",
+ " x_norm = K.concatenate(x_norm)\n",
+ "\n",
+ " # create x_out\n",
+ " x_out = []\n",
+ " for i in range(n_examples):\n",
+ " norm_features = K.slice(x_norm,(i,),(self.time_steps,))\n",
+ " norm_features = K.expand_dims(norm_features,axis=0)\n",
+ " x_out.append(norm_features)\n",
+ "\n",
+ " x_out = K.concatenate(x_out, axis=0)\n",
+ " x_out = K.expand_dims(x_out)\n",
+ "\n",
+ " # create tensor of denormalization coefficients \n",
+ " denorm_coeff = K.concatenate(ls, axis=0)\n",
+ " return [x_out, denorm_coeff]\n",
+ "\n",
+ " def compute_output_shape(self, input_shape):\n",
+ " return [(input_shape[0], input_shape[1], input_shape[2]), (input_shape[0], self.horizon, 2)]\n",
+ " \n",
+ "class Denormalization(Layer):\n",
+ " \n",
+ " def __init__(self, **kwargs):\n",
+ " super(Denormalization, self).__init__(**kwargs)\n",
+ "\n",
+ " def build(self, input_shape):\n",
+ " super(Denormalization, self).build(input_shape) \n",
+ "\n",
+ " def call(self, x):\n",
+ " return x[0] * x[1][:,:,0] * x[1][:,:,1]\n",
+ "\n",
+ " def compute_output_shape(self, input_shape):\n",
+ " return input_shape[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Since Denormalization layer has inputs from two previous layers, we need to use functional API of Keras"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model_input = Input(shape=(None, 1))\n",
+ "[normalized_input, denormalization_coeff] = ES(HORIZON, m, BATCH_SIZE, T)(model_input)\n",
+ "gru_out = GRU(LATENT_DIM)(normalized_input)\n",
+ "model_output_normalized = Dense(HORIZON)(gru_out)\n",
+ "model_output = Denormalization()([model_output_normalized, denormalization_coeff])\n",
+ "model = Model(inputs=model_input, outputs=model_output)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.compile(optimizer='RMSprop', loss='mse')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "__________________________________________________________________________________________________\n",
+ "Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ "input_2 (InputLayer) (None, None, 1) 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "es_2 (ES) [(None, None, 1), (N 26 input_2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "gru_2 (GRU) (None, 5) 105 es_2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "dense_2 (Dense) (None, 3) 18 gru_2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "denormalization_2 (Denormalizat (None, 3) 0 dense_2[0][0] \n",
+ " es_2[0][1] \n",
+ "==================================================================================================\n",
+ "Total params: 149\n",
+ "Trainable params: 149\n",
+ "Non-trainable params: 0\n",
+ "__________________________________________________________________________________________________\n"
+ ]
+ }
+ ],
+ "source": [
+ "model.summary()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "earlystop = EarlyStopping(monitor='val_loss', min_delta=0, patience=20)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "running fit_loop\n",
+ "Train on 23328 samples, validate on 1488 samples\n",
+ "Epoch 1/1000\n",
+ "23328/23328 [==============================] - 11s 467us/step - loss: 0.2172 - val_loss: 0.1665\n",
+ "Epoch 2/1000\n",
+ "23328/23328 [==============================] - 4s 167us/step - loss: 0.2023 - val_loss: 1.1562\n",
+ "Epoch 3/1000\n",
+ "23328/23328 [==============================] - 5s 204us/step - loss: 0.5497 - val_loss: 0.1464\n",
+ "Epoch 4/1000\n",
+ "23328/23328 [==============================] - 4s 185us/step - loss: 0.7730 - val_loss: 0.1916\n",
+ "Epoch 5/1000\n",
+ "23328/23328 [==============================] - 7s 279us/step - loss: 0.0935 - val_loss: 0.0583\n",
+ "Epoch 6/1000\n",
+ "23328/23328 [==============================] - 6s 254us/step - loss: 0.0376 - val_loss: 0.0457\n",
+ "Epoch 7/1000\n",
+ "23328/23328 [==============================] - 5s 221us/step - loss: 0.0163 - val_loss: 0.0188\n",
+ "Epoch 8/1000\n",
+ "23328/23328 [==============================] - 5s 211us/step - loss: 0.0020 - val_loss: 0.0154\n",
+ "Epoch 9/1000\n",
+ "23328/23328 [==============================] - 6s 240us/step - loss: 0.0014 - val_loss: 0.0139\n",
+ "Epoch 10/1000\n",
+ "23328/23328 [==============================] - 6s 242us/step - loss: 0.0013 - val_loss: 0.0128\n",
+ "Epoch 11/1000\n",
+ "23328/23328 [==============================] - 6s 241us/step - loss: 0.0013 - val_loss: 0.0119\n",
+ "Epoch 12/1000\n",
+ "23328/23328 [==============================] - 6s 236us/step - loss: 0.0012 - val_loss: 0.0111\n",
+ "Epoch 13/1000\n",
+ "23328/23328 [==============================] - 5s 213us/step - loss: 0.0011 - val_loss: 0.0104\n",
+ "Epoch 14/1000\n",
+ "23328/23328 [==============================] - 5s 232us/step - loss: 0.0011 - val_loss: 0.0098\n",
+ "Epoch 15/1000\n",
+ "23328/23328 [==============================] - 6s 240us/step - loss: 0.0010 - val_loss: 0.0092\n",
+ "Epoch 16/1000\n",
+ "23328/23328 [==============================] - 6s 241us/step - loss: 9.9943e-04 - val_loss: 0.0087\n",
+ "Epoch 17/1000\n",
+ "23328/23328 [==============================] - 5s 220us/step - loss: 9.6632e-04 - val_loss: 0.0084\n",
+ "Epoch 18/1000\n",
+ "23328/23328 [==============================] - 5s 200us/step - loss: 9.4413e-04 - val_loss: 0.0082\n",
+ "Epoch 19/1000\n",
+ "23328/23328 [==============================] - 5s 196us/step - loss: 9.3430e-04 - val_loss: 0.0081\n",
+ "Epoch 20/1000\n",
+ "23328/23328 [==============================] - 4s 187us/step - loss: 9.2975e-04 - val_loss: 0.0079\n",
+ "Epoch 21/1000\n",
+ "23328/23328 [==============================] - 5s 203us/step - loss: 9.2745e-04 - val_loss: 0.0078\n",
+ "Epoch 22/1000\n",
+ "23328/23328 [==============================] - 4s 183us/step - loss: 9.2416e-04 - val_loss: 0.0077\n",
+ "Epoch 23/1000\n",
+ "23328/23328 [==============================] - 5s 193us/step - loss: 9.2364e-04 - val_loss: 0.0075\n",
+ "Epoch 24/1000\n",
+ "23328/23328 [==============================] - 4s 184us/step - loss: 9.2472e-04 - val_loss: 0.0072\n",
+ "Epoch 25/1000\n",
+ "23328/23328 [==============================] - 4s 173us/step - loss: 9.2271e-04 - val_loss: 0.0070\n",
+ "Epoch 26/1000\n",
+ "23328/23328 [==============================] - 4s 182us/step - loss: 9.2935e-04 - val_loss: 0.0069\n",
+ "Epoch 27/1000\n",
+ "23328/23328 [==============================] - 5s 202us/step - loss: 9.3293e-04 - val_loss: 0.0069\n",
+ "Epoch 28/1000\n",
+ "23328/23328 [==============================] - 4s 186us/step - loss: 9.3747e-04 - val_loss: 0.0068\n",
+ "Epoch 29/1000\n",
+ "23328/23328 [==============================] - 4s 169us/step - loss: 9.3997e-04 - val_loss: 0.0068\n",
+ "Epoch 30/1000\n",
+ "23328/23328 [==============================] - 4s 171us/step - loss: 9.4134e-04 - val_loss: 0.0067\n",
+ "Epoch 31/1000\n",
+ "23328/23328 [==============================] - 5s 194us/step - loss: 9.4315e-04 - val_loss: 0.0067\n",
+ "Epoch 32/1000\n",
+ "23328/23328 [==============================] - 4s 191us/step - loss: 9.4429e-04 - val_loss: 0.0067\n",
+ "Epoch 33/1000\n",
+ "23328/23328 [==============================] - 5s 208us/step - loss: 9.4499e-04 - val_loss: 0.0066\n",
+ "Epoch 34/1000\n",
+ "23328/23328 [==============================] - 5s 200us/step - loss: 9.4609e-04 - val_loss: 0.0066\n",
+ "Epoch 35/1000\n",
+ "23328/23328 [==============================] - 5s 207us/step - loss: 9.4652e-04 - val_loss: 0.0066\n",
+ "Epoch 36/1000\n",
+ "23328/23328 [==============================] - 4s 181us/step - loss: 9.4553e-04 - val_loss: 0.0067\n",
+ "Epoch 37/1000\n",
+ "23328/23328 [==============================] - 4s 173us/step - loss: 9.4340e-04 - val_loss: 0.0066\n",
+ "Epoch 38/1000\n",
+ "23328/23328 [==============================] - 4s 168us/step - loss: 9.4337e-04 - val_loss: 0.0066\n",
+ "Epoch 39/1000\n",
+ "23328/23328 [==============================] - 4s 171us/step - loss: 9.4323e-04 - val_loss: 0.0066\n",
+ "Epoch 40/1000\n",
+ "23328/23328 [==============================] - 4s 177us/step - loss: 9.4267e-04 - val_loss: 0.0066\n",
+ "Epoch 41/1000\n",
+ "23328/23328 [==============================] - 4s 178us/step - loss: 9.4105e-04 - val_loss: 0.0067\n",
+ "Epoch 42/1000\n",
+ "23328/23328 [==============================] - 4s 183us/step - loss: 9.3991e-04 - val_loss: 0.0067\n",
+ "Epoch 43/1000\n",
+ "23328/23328 [==============================] - 5s 206us/step - loss: 9.4007e-04 - val_loss: 0.0066\n",
+ "Epoch 44/1000\n",
+ "23328/23328 [==============================] - 5s 204us/step - loss: 9.4000e-04 - val_loss: 0.0066\n",
+ "Epoch 45/1000\n",
+ "23328/23328 [==============================] - 5s 209us/step - loss: 9.3964e-04 - val_loss: 0.0066\n",
+ "Epoch 46/1000\n",
+ "23328/23328 [==============================] - 4s 175us/step - loss: 9.3826e-04 - val_loss: 0.0066\n",
+ "Epoch 47/1000\n",
+ "23328/23328 [==============================] - 5s 219us/step - loss: 9.3876e-04 - val_loss: 0.0067\n",
+ "Epoch 48/1000\n",
+ "23328/23328 [==============================] - 4s 180us/step - loss: 9.3734e-04 - val_loss: 0.0067\n",
+ "Epoch 49/1000\n",
+ "23328/23328 [==============================] - 4s 192us/step - loss: 9.3785e-04 - val_loss: 0.0066\n",
+ "Epoch 50/1000\n",
+ "23328/23328 [==============================] - 4s 191us/step - loss: 9.3705e-04 - val_loss: 0.0066\n",
+ "Epoch 51/1000\n",
+ "23328/23328 [==============================] - 4s 192us/step - loss: 9.3795e-04 - val_loss: 0.0066\n",
+ "Epoch 52/1000\n",
+ "23328/23328 [==============================] - 6s 246us/step - loss: 9.3733e-04 - val_loss: 0.0067\n",
+ "Epoch 53/1000\n",
+ "23328/23328 [==============================] - 5s 231us/step - loss: 9.3450e-04 - val_loss: 0.0066\n",
+ "Epoch 54/1000\n",
+ "23328/23328 [==============================] - 6s 276us/step - loss: 9.3418e-04 - val_loss: 0.0066\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model.fit(train_inputs['X'],\n",
+ " train_inputs['target'],\n",
+ " batch_size=BATCH_SIZE,\n",
+ " shuffle=False,\n",
+ " epochs=EPOCHS,\n",
+ " validation_data=(valid_inputs['X'], valid_inputs['target']),\n",
+ " callbacks=[earlystop],\n",
+ " verbose=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Evaluate the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "look_back_dt = dt.datetime.strptime(test_start_dt, '%Y-%m-%d %H:%M:%S') - dt.timedelta(hours=T-1)\n",
+ "test = energy.copy()[test_start_dt:test_end_dt][['load']]\n",
+ "test[['load']] = scaler.transform(test)\n",
+ "test_inputs = TimeSeriesTensor(test, 'load', HORIZON, tensor_structure)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "predictions = model.predict(test_inputs['X'], batch_size=BATCH_SIZE)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0.53, 0.65, 0.73],\n",
+ " [0.5 , 0.58, 0.64],\n",
+ " [0.48, 0.53, 0.57],\n",
+ " ...,\n",
+ " [0.53, 0.55, 0.68],\n",
+ " [0.6 , 0.75, 0.92],\n",
+ " [0.71, 0.86, 0.99]], dtype=float32)"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "predictions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " timestamp \n",
+ " h \n",
+ " prediction \n",
+ " actual \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 2014-10-31 16:00:00 \n",
+ " t+1 \n",
+ " 3,687.90 \n",
+ " 3,437.00 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2014-10-31 17:00:00 \n",
+ " t+1 \n",
+ " 3,613.06 \n",
+ " 3,466.00 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 2014-10-31 18:00:00 \n",
+ " t+1 \n",
+ " 3,537.20 \n",
+ " 3,374.00 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 2014-10-31 19:00:00 \n",
+ " t+1 \n",
+ " 3,318.07 \n",
+ " 3,315.00 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 2014-10-31 20:00:00 \n",
+ " t+1 \n",
+ " 3,290.50 \n",
+ " 3,142.00 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_df = eval_df[(eval_df.timestamp<'2014-11-08') & (eval_df.h=='t+1')][['timestamp', 'actual']]\n",
+ "for t in range(1, HORIZON+1):\n",
+ " plot_df['t+'+str(t)] = eval_df[(eval_df.timestamp<'2014-11-08') & (eval_df.h=='t+'+str(t))]['prediction'].values\n",
+ "\n",
+ "fig = plt.figure(figsize=(15, 8))\n",
+ "ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)\n",
+ "ax = fig.add_subplot(111)\n",
+ "ax.plot(plot_df['timestamp'], plot_df['t+1'], color='blue', linewidth=4.0, alpha=0.75)\n",
+ "ax.plot(plot_df['timestamp'], plot_df['t+2'], color='blue', linewidth=3.0, alpha=0.5)\n",
+ "ax.plot(plot_df['timestamp'], plot_df['t+3'], color='blue', linewidth=2.0, alpha=0.25)\n",
+ "plt.xlabel('timestamp', fontsize=12)\n",
+ "plt.ylabel('load', fontsize=12)\n",
+ "ax.legend(loc='best')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "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.6.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/images/es_rnn.png b/images/es_rnn.png
new file mode 100644
index 0000000..6d3725a
Binary files /dev/null and b/images/es_rnn.png differ