In [2]:
# How to predict a timeseries using GRU in Keras
def Snippet_399():
print()
print(format('How to predict a timeseries using GRU in Keras','*^92'))
# load libraries
import pandas, time
import numpy as np
from keras.layers.recurrent import GRU
from keras.layers.core import Dense, Dropout
from keras.optimizers import RMSprop
from keras.models import Sequential
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
start_time = time.time()
# load the dataset
dataframe = pandas.read_csv('international-airline-passengers.csv', usecols=[1],
engine='python', skipfooter=3)
dataset = dataframe.values; dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
train_dataset, test_dataset = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# Window -> X timestep back
step_back = 1
X_train, Y_train = [], []
for i in range(len(train_dataset)-step_back - 1):
a = train_dataset[i:(i+step_back), 0]
X_train.append(a)
Y_train.append(train_dataset[i + step_back, 0])
X_train = np.array(X_train); Y_train = np.array(Y_train);
X_test, Y_test = [], []
for i in range(len(test_dataset)-step_back - 1):
a = test_dataset[i:(i+step_back), 0]
X_test.append(a)
Y_test.append(test_dataset[i + step_back, 0])
X_test = np.array(X_test); Y_test = np.array(Y_test);
print(X_train); print(Y_train); print(X_test); print(Y_test);
# -----------------------------------------------------------
# reshape input to be [samples, time steps, features]
# -----------------------------------------------------------
X_train = np.reshape(X_train, (X_train.shape[0], 1, X_train.shape[1]))
X_test = np.reshape(X_test, (X_test.shape[0], 1, X_test.shape[1]))
# -------------------------------------
# setup a LSTM network in keras
# -------------------------------------
model = Sequential()
model.add(GRU(32, input_shape=(1, step_back)))
model.add(Dense(units = 512, activation = 'relu'))
model.add(Dropout(0.2))
model.add(Dense(units = 1, activation = 'linear'))
model.summary()
model.compile(loss='mean_squared_error', optimizer=RMSprop(lr = 0.01))
model.fit(X_train, Y_train, epochs=20, batch_size=2, verbose=2)
# Estimate model performance
print()
trainScore = model.evaluate(X_train, Y_train, verbose=1)
print('Train Score: %.2f MSE (%.2f RMSE)' % (trainScore, np.sqrt(trainScore)))
testScore = model.evaluate(X_test, Y_test, verbose=1)
print('Test Score: %.2f MSE (%.2f RMSE)' % (testScore, np.sqrt(testScore)))
# Evaluate the skill of the Trained model
trainPredict = model.predict(X_train)
testPredict = model.predict(X_test)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
testPredict = scaler.inverse_transform(testPredict)
# shift train predictions for plotting
trainPredictPlot = np.empty_like(dataset)
trainPredictPlot[:, :] = np.nan
trainPredictPlot[step_back:len(trainPredict)+step_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = np.empty_like(dataset)
testPredictPlot[:, :] = np.nan
testPredictPlot[len(trainPredict)+(step_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
print(); print("Execution Time %s seconds: " % (time.time() - start_time))
Snippet_399()
