In [2]:
# How to predict a timeseries using Multi Layer Perceptron in Keras
def Snippet_393():
print()
print(format('How to predict a timeseries using Multi Layer Perceptron in Keras','*^92'))
# load libraries
import pandas, time
import numpy as np
from keras.layers.core import Dense, Dropout
from keras.optimizers import RMSprop
from keras.models import Sequential
import matplotlib.pyplot as plt
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')
# 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 = 3
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);
# -------------------------------------
# setup a MLP network in keras
# -------------------------------------
model = Sequential()
model.add(Dense(units = 128, input_dim=step_back, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units = 64, input_dim=step_back, 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=200, 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 = np.array(model.predict(X_train))
trainPredict = np.reshape(trainPredict, (len(trainPredict), 1))
testPredict = np.array(model.predict(X_test))
testPredict = np.reshape(testPredict, (len(testPredict), 1))
# 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(dataset)
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
print(); print("Execution Time %s seconds: " % (time.time() - start_time))
Snippet_393()
