Neural networks can be a difficult concept to understand. I think it’s mainly because they can be used for so many different things like classification, identification or just regression. In this article, I will walk you through how to set up a simple way to forecast time series with LSTM model.
Before getting started with the coding part to forecast time series with LSTM first let’s go through some of the major concepts involved for all the beginners who are reading this article.
What is Time Series Forecasting?
Time series forecasting is a technique for predicting events through a time sequence. The technique is used in many fields of study, from geology to behaviour to economics. Techniques predict future events by analyzing trends from the past, assuming that future trends will hold similar to historical trends.
What is LSTM?
LSTM stands for Short Term Long Term Memory. It is a model or an architecture that extends the memory of recurrent neural networks. Typically, recurrent neural networks have “short-term memory” in that they use persistent past information for use in the current neural network. Essentially, the previous information is used in the current task. This means that we do not have a list of all of the previous information available for the neural node.
Forecast Time Series with LSTM
I hope you have understood what time series forecasting means and what are LSTM models. Now I will be heading towards creating a machine learning model to forecast time series with LSTM in Machine Learning.
For this task to forecast time series with LSTM, I will start by importing all the necessary packages we need:
import numpy import matplotlib.pyplot as plt import pandas import math from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error # fix random seed for reproducibility numpy.random.seed(7)
Now let’s load the data, and prepare the data so that we can use it on the LSTM model, you can download the dataset I am using in this task from here:
# load the dataset dataframe = pandas.read_csv('airline-passengers.csv', usecols=, engine='python') dataset = dataframe.values dataset = dataset.astype('float32') # normalize the dataset scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(dataset)
Now, I will split the data into training sets and test sets:
# split into train and test sets train_size = int(len(dataset) * 0.67) test_size = len(dataset) - train_size train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:] print(len(train), len(test))
Time Series with LSTM
Now before training the data on the LSTM model, we need to prepare the data so that we can fit it on the model, for this task I will define a helper function:
# convert an array of values into a dataset matrix def create_dataset(dataset, look_back=1): dataX, dataY = ,  for i in range(len(dataset)-look_back-1): a = dataset[i:(i+look_back), 0] dataX.append(a) dataY.append(dataset[i + look_back, 0]) return numpy.array(dataX), numpy.array(dataY)
Now, we need to reshape the data before applying it into the LSTM model:
# reshape into X=t and Y=t+1 look_back = 1 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back) # reshape input to be [samples, time steps, features] trainX = numpy.reshape(trainX, (trainX.shape, 1, trainX.shape)) testX = numpy.reshape(testX, (testX.shape, 1, testX.shape))
Now as all the tasks are completed concerning data preparation to fit into the LSTM model, it time to fit the data on the model and let’s train the model:
# create and fit the LSTM network model = Sequential() model.add(LSTM(4, input_shape=(1, look_back))) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
Now, let’s make predictions and visualize the time series trends by using the matplotlib package in python:
# make predictions trainPredict = model.predict(trainX) testPredict = model.predict(testX) # invert predictions trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY]) # calculate root mean squared error trainScore = math.sqrt(mean_squared_error(trainY, trainPredict[:,0])) testScore = math.sqrt(mean_squared_error(testY, testPredict[:,0])) # shift train predictions for plotting trainPredictPlot = numpy.empty_like(dataset) trainPredictPlot[:, :] = numpy.nan trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict # shift test predictions for plotting testPredictPlot = numpy.empty_like(dataset) testPredictPlot[:, :] = numpy.nan testPredictPlot[len(trainPredict)+(look_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()
I hope you liked this article on forecasting time series with LSTM model. Feel free to ask you valuable questions in the comments section below. You can also follow me on Medium to learn every topic of Machine Learning.