# Time Series Prediction¶

## Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras¶

Time series prediction problems are a difficult type of predictive modeling problem.

Unlike **regression predictive modeling**, time series also adds the complexity of a sequence dependence among the input variables.

A powerful type of neural network designed to handle **sequence dependence** are called recurrent neural networks. The **Long Short-Term Memory Networks** or LSTM network is a type of **recurrent neural network** used in deep learning because very large architectures can be successfully trained.

In this post you will discover how to develop LSTM networks in Python using the **Keras** deep learning library to address a demonstration time series prediction problem.

After completing this tutorial you will know how to implement and develop LSTM networks for your own time series prediction problems and other more general sequence problems. You will know:

- About the international airline passengers time series prediction problem.
- How to develop LSTM networks for regression, window and time-step based framing of time series prediction problems.
- How to develop and make predictions using LSTM networks that maintain state (memory) across very long sequences.

We will develop a number of LSTMs for a standard time series prediction problem. The problem and the chosen configuration for the LSTM networks are for demonstration purposes only, they are not optimized. These examples will show you exactly how you can develop your own LSTM networks for time series predictive modeling problems.

Let’s get started.

Update: The estimates of model error were updated to show error in the original units (converted to RMSE and inverted the scale transform).

### Problem Description¶

The problem we are going to look at in this post is the international airline passengers prediction problem.

This is a problem where given a year and a month, the task is to predict the number of international airline passengers in units of 1000. The data ranges from January 1949 to December 1960 or 12 years, with 144 observations.

The dataset is available for free from the DataMarket webpage as a CSV download with the filename “international-airline-passengers.csv“.

Below is a sample of the first few lines of the file.

```
"Month","International airline passengers: monthly totals in thousands. Jan 49 ? Dec 60"
"1949-01",112
"1949-02",118
"1949-03",132
"1949-04",129
"1949-05",121
```

We can load this dataset easily using the **Pandas** library. We are not interested in the date, given that **each observation is separated by the same interval of one month**. Therefore when we load the dataset we can exclude the first column.

The downloaded dataset also has footer information that we can exclude with the skipfooter argument to pandas.read_csv() set to 3 for the 3 footer lines. Once loaded we can easily plot the whole dataset. The code to load and plot the dataset is listed below.

```
import pandas
import matplotlib.pyplot as plt
dataset = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
plt.plot(dataset)
plt.show()
```

You can see an upward trend in the dataset over time.

You can also see **some periodicity to the dataset that probably corresponds to the northern hemisphere summer holiday period** .

Plot of the Airline Passengers Dataset

We are going to keep things simple and work with the data as-is.

Normally, it is a good idea to **investigate various data preparation techniques to rescale the data and to make it stationary** .

### Long Short-Term Memory Networks¶

The Long Short-Term Memory or LSTM network is a recurrent neural network that is trained **using Backpropagation Through Time and overcomes the vanishing gradient problem** .

As such it can be used to create large recurrent networks, that in turn can be used to address difficult sequence problems in machine learning and achieve state-of-the-art results.

Instead of neurons, LSTM networks have **memory blocks that are connected into layers** .

A block has components that make it smarter than a classical neuron and a memory for recent sequences. A block contains **gates** that manage the block’s state and output. A block operates upon an **input sequence** and each gate within a block uses the **sigmoid activation units** to control whether they are triggered or not, making the change of state and addition of information flowing through the block conditional. // 这一段都没懂是什么。

There are three types of gates within a unit:

**Forget Gate**: conditionally decides what information to throw away from the block.**Input Gate**: conditionally decides which values from the input to update the memory state.**Output Gate**: conditionally decides what to output based on input and the memory of the block.

Each unit is like a mini-state machine where the gates of the units have weights that are learned during the training procedure.

You can see how you may achieve a sophisticated learning and memory from a layer of LSTMs, and it is not hard to imagine how higher-order abstractions may be layered with multiple such layers.

### LSTM Network For Regression¶

We can phrase the problem as a regression problem.

That is, given the number of passengers (in units of thousands) this month, what is the number of passengers next month.

We can write a simple function to convert our single column of data into a two-column dataset. The first column containing this month’s (t) passenger count and the second column containing next month’s (t+1) passenger count, to be predicted.

Before we get started, let’s first import all of the functions and classes we intend to use. This assumes a working SciPy environment with the Keras deep learning library installed.

```
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
```

Before we do anything, it is a good idea to **fix the random number seed to ensure our results are reproducible** .

```
# fix random seed for reproducibility
numpy.random.seed(7)
```

We can also use the code from the previous section to load the dataset as a Pandas dataframe. We can then extract the NumPy array from the dataframe and **convert the integer values to floating point values which are more suitable for modeling with a neural network** .

```
# load the dataset
dataframe = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
```

LSTMs are **sensitive to the scale of the input data**, specifically when the sigmoid (default) or tanh activation functions are used. It can be a good practice to rescale the data to the range of 0-to-1, also called **normalizing**. We can easily normalize the dataset using the MinMaxScaler preprocessing class from the scikit-learn library.

// sensitive to the scala of the input data 是什么意思？

```
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
```

After we model our data and estimate the skill of our model on the training dataset, we need to get an idea of the **skill of the model on new unseen data**. For a normal classification or regression problem we would do this using **cross validation** .

With time series data, the sequence of values is important. A simple method that we can use is to **split the ordered dataset into train and test datasets** . The code below calculates the index of the split point and separates the data into the training datasets with 67% of the observations that we can use to train our model, leaving the **remaining 33% for testing the model** .

```
# 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))
```

Now we can define a function to create a new dataset as described above.

The function takes two arguments, the **dataset** which is a NumPy array that we want to convert into a dataset and the **look_back** which is the number of previous time steps to use as input variables to predict the next time period, in this case, defaulted to 1. // 没懂这一段是什么意思？

This default will create a dataset where X is the number of passengers at a given time (t) and Y is the number of passengers at the next time (t + 1).

It can be configured and we will by constructing a differently shaped dataset in the next section.

```
# 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)
```

Let’s take a look at the effect of this function on the first few rows of the dataset (shown in the unnormalized form for clarity).

```
X Y
112 118
118 132
132 129
129 121
121 135
```

If you compare these first 5 rows to the original dataset sample listed in the previous section, you can see the X=t and Y=t+1 pattern in the numbers.

Let’s use this function to prepare the train and test datasets ready for modeling.

```
# 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)
```

The LSTM network expects the input data (X) to be provided with a specific array structure in the form of: `[samples, time steps, features]`

. // form 看得有点晕，可能是线代没学好的原因。

Currently, our data is in the form: [samples, features] and we are framing the problem as one time step for each sample. We can transform the prepared train and test input data into the expected structure using **numpy.reshape()** as follows:

```
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
```

We are now ready to design and fit our LSTM network for this problem.

The network has a visible layer with 1 input, **a hidden layer with 4 LSTM blocks or neurons** and an output layer that makes a single value prediction. The default **sigmoid activation function** is used for the LSTM blocks. The network is trained for **100 epochs and a batch size of 1** is used.

```
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_dim=look_back))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, nb_epoch=100, batch_size=1, verbose=2)
```

// 这儿一堆式子背后的原因

Once the model is fit, we can estimate the performance of the model on the train and test datasets. This will give us a point of comparison for new models.

Note that we **invert the normalization using the same scaler object to get mean errors in squared units (thousands of passengers per month)** . // 虾米

```
# Estimate model performance
trainScore = model.evaluate(trainX, trainY, verbose=0)
trainScore = math.sqrt(trainScore)
trainScore = scaler.inverse_transform(numpy.array([[trainScore]]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = model.evaluate(testX, testY, verbose=0)
testScore = math.sqrt(testScore)
testScore = scaler.inverse_transform(numpy.array([[testScore]]))
print('Test Score: %.2f RMSE' % (testScore))
```

Once the model is fit, we can estimate the performance of the model on the train and test datasets. This will give us a point of comparison for new models.

Note that we **invert the normalization using the same scaler object** to get mean errors in squared units (thousands of passengers per month).

```
# Estimate model performance
trainScore = model.evaluate(trainX, trainY, verbose=0) // model.evaluate 是在做什么？
trainScore = math.sqrt(trainScore)
trainScore = scaler.inverse_transform(numpy.array([[trainScore]]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = model.evaluate(testX, testY, verbose=0)
testScore = math.sqrt(testScore)
testScore = scaler.inverse_transform(numpy.array([[testScore]]))
print('Test Score: %.2f RMSE' % (testScore))
```

Finally, we can generate predictions using the model for both the train and test dataset to get a visual indication of the skill of the model.

Because of how the dataset was prepared, we must shift the predictions so that they aline on the x-axis with the original dataset. Once prepared, **the data is plotted** , showing the original dataset in blue, the predictions for the train dataset in green and the predictions on the unseen test dataset in red.

```
# generate predictions for training
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# 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(dataset)
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
```

## Long short-term memory¶

Long short-term memory (LSTM) is a **recurrent neural network (RNN)** architecture (an artificial neural network) proposed in 1997 by Sepp Hochreiter and Jürgen Schmidhuber.[2] Like most RNNs, an LSTM network is universal in the **sense that given enough network units it can compute anything a conventional computer can compute**, provided it has the proper **weight matrix**, which may be viewed as its program. Unlike traditional RNNs, an LSTM network is well-suited to **learn from experience to classify, process and predict time series when there are very long time lags of unknown size between important events** . This is one of the main reasons why LSTM outperforms alternative RNNs and Hidden Markov Models and other sequence learning methods in numerous applications. For example, LSTM achieved the best known results in unsegmented connected handwriting recognition,[3] and in 2009 won the ICDAR handwriting competition. LSTM networks have also been used for automatic speech recognition, and were a major component of a network that in 2013 achieved a record 17.7% phoneme error rate on the classic TIMIT natural speech dataset.[4] As of 2016, major technology companies including Google, Apple, Microsoft, and Baidu are using LSTM networks as fundamental components in new products.[5][6]

// weight matrix 是什么？ // long time lags of unknown size between important events 是指什么？

### Architecture¶

A LSTM network is an artificial neural network that contains LSTM blocks instead of, or in addition to, **regular network units**. A LSTM block may be described as a “smart” network unit that can **remember a value for an arbitrary length of time**. A LSTM block contains gates that determine when the input is significant enough to remember, when it should continue to remember or forget the value, and when it should output the value.

A typical implementation of a LSTM block is shown to the right. The four units shown at the bottom of the figure are **sigmoid units** \(y = s(\sum w_i x_i)\) , where s is some **squashing function** , such as the logistic function. The left-most of these units computes a value which is conditionally fed as **an input value to the block’s memory**. The other three units serve as gates to determine when values are allowed to flow into or out of the block’s memory. The second unit from the left (on the bottom row) is the “input gate”. When it outputs a value close to zero, it zeros out the value from the left-most unit, effectively blocking that value from entering into the next layer. The third unit from the left is the “forget gate”. When it outputs a value close to zero, the block will effectively forget whatever value it was remembering. The right-most unit (on the bottom row) is the “output gate”. It determines when the unit should output the value in its memory. The units containing the \(\Pi\) symbol compute **the product of their inputs** \(y=\Pi x_{i}\). These units have no weights. The unit with the \(\Sigma\) symbol computes **a linear function of its inputs** \(y=\sum w_{i}x_{i}\). The output of this unit is not **squashed** so that it can **remember the same value for many time-steps without the value decaying** . This value is fed back in so that the block can “remember” it (as long as the forget gate allows). Typically, this value is also fed into the 3 **gating units** to help them make gating decisions.

// squashing function / this unit is not squashed

// 图中有4个 sigmoid units 和3个 gating units。为什么 input 也是 sigmoid？

### Training¶

To minimize LSTM’s total error on a set of training sequences, iterative gradient descent such as backpropagation through time can be used to **change each weight in proportion to its derivative with respect to the error** . A major problem with gradient descent for standard RNNs is that **error gradients vanish exponentially quickly with the size of the time lag between important events** , as first realized in 1991. With LSTM blocks, however, when error values are back-propagated from the output, the error becomes trapped in the memory portion of the block. This is referred to as an **“error carousel”** , which continuously feeds error back to each of the gates until they become trained to **cut off the value** . Thus, regular backpropagation is effective at training an LSTM block to **remember values for very long durations** .

LSTM can also be trained by a combination of artificial evolution for **weights to the hidden units** , and pseudo-inverse or support vector machines for weights to the output units. In reinforcement learning applications LSTM can be trained by policy gradient methods, evolution strategies or genetic algorithms.

### Applications¶

Applications of LSTM include:

- Robot control
- Time series prediction
- Speech recognition
- Rhythm learning
- Music composition
- Grammar learning
- Handwriting recognition
- Human action recognition
- Protein Homology Detection

// Time series prediction & Rhythm learning & Music composition

### See also¶

- Artificial neural network https://en.wikipedia.org/wiki/Artificial_neural_network
- Prefrontal Cortex Basal Ganglia Working Memory (PBWM) https://en.wikipedia.org/wiki/PBWM
- Recurrent neural network https://en.wikipedia.org/wiki/Recurrent_neural_network
- Time series https://en.wikipedia.org/wiki/Time_series
- Long-term potentiation https://en.wikipedia.org/wiki/Long-term_potentiation

## Understanding LSTM Networks¶

By Christopher Olah, @Google Brain

http://colah.github.io/posts/2015-08-Understanding-LSTMs/

### Recurrent Neural Networks¶

**Humans don’t start their thinking from scratch every second** . As you read this essay, you understand each word based on your understanding of previous words. You don’t throw everything away and start thinking from scratch again. Your thoughts have persistence.

Traditional neural networks can’t do this, and it seems like a major shortcoming. For example, imagine you want to classify what kind of event is happening at every point in a movie. It’s unclear how a traditional neural network could **use its reasoning about previous events in the film to inform later ones** .

Recurrent neural networks address this issue. They are **networks with loops in them, allowing information to persist** .

In the above diagram, a chunk of neural network, \(A\), looks at some input \(x_t\) and outputs a value \(h_t\). **A loop allows information to be passed from one step of the network to the next** .

These loops make recurrent neural networks seem kind of mysterious. However, if you think a bit more, it turns out that they aren’t all that different than a normal neural network. A recurrent neural network can **be thought of as multiple copies of the same network, each passing a message to a successor** . Consider what happens if we unroll the loop:

An unrolled recurrent neural network.

// QUESTION: seccessor 是什么

This chain-like nature reveals that recurrent neural networks are **intimately related to sequences and lists** . They’re the natural architecture of neural network to use for such data.

And they certainly are used! In the last few years, there have been incredible success applying RNNs to a variety of problems: speech recognition, language modeling, translation, image captioning… The list goes on. I’ll leave discussion of the amazing feats one can achieve with RNNs to Andrej Karpathy’s excellent blog post, The Unreasonable Effectiveness of Recurrent Neural Networks . But they really are pretty amazing.

Essential to these successes is the use of “LSTMs,” a very special kind of recurrent neural network which works, for many tasks, much much better than the standard version. **Almost all exciting results based on recurrent neural networks are achieved with them** . It’s these LSTMs that this essay will explore.

### The Problem of Long-Term Dependencies¶

One of the appeals of RNNs is the idea that they might be able to **connect previous information to the present task** , such as using previous video frames might inform the understanding of the present frame. If RNNs could do this, they’d be extremely useful. But can they? It depends.

Sometimes, we only need to look at recent information to perform the present task. For example, consider a language model trying to predict the next word based on the previous ones. If we are trying to predict the last word in “the clouds are in the sky,” we don’t need any further context – it’s pretty obvious the next word is going to be sky. In such cases, where **the gap between the relevant information and the place** that it’s needed is small, RNNs can learn to use the past information.

But there are also cases where we need more context. Consider trying to predict the last word in the text “I grew up in France… I speak fluent *French*.” Recent information suggests that the next word is probably the name of a language, but if we want to narrow down which language, we need the context of France, from further back. It’s entirely possible for the gap between the relevant information and the point where it is needed to become very large.

Unfortunately, as that gap grows, RNNs become unable to learn to connect the information.

In theory, RNNs are absolutely capable of handling such “long-term dependencies.” A human could carefully pick parameters for them to solve toy problems of this form. Sadly, in practice, RNNs don’t seem to be able to learn them. The problem was explored in depth by Hochreiter (1991) [German] and Bengio, et al. (1994), who found some pretty fundamental reasons why it might be difficult.

Thankfully, LSTMs don’t have this problem!

### LSTM Networks¶

Long Short Term Memory networks – usually just called “LSTMs” – are a special kind of RNN, capable of learning long-term dependencies. They were introduced by Hochreiter & Schmidhuber (1997), and were refined and popularized by many people in following work.1 They work tremendously well on a large variety of problems, and are now widely used.

**LSTMs are explicitly designed to avoid the long-term dependency problem** . Remembering information for long periods of time is practically their default behavior, not something they struggle to learn!

**All recurrent neural networks have the form of a chain of repeating modules of neural network** . In standard RNNs, this repeating module will have a very simple structure, such as a single **tanh** layer.

// QUESTION tanh 可以做什么

LSTMs also have this chain like structure, but the repeating module has a different structure. Instead of having a single neural network layer, there are **four, interacting in a very special way** .

Don’t worry about the details of what’s going on. We’ll walk through the LSTM diagram step by step later. For now, let’s just try to get comfortable with the notation we’ll be using.

In the above diagram, each line carries an entire vector, from the output of one node to the inputs of others. The pink circles represent pointwise operations, like vector addition, while the yellow boxes are learned neural network layers. Lines merging denote concatenation, while a line forking denote its content being copied and the copies going to different locations.

### The Core Idea Behind LSTMs¶

The key to LSTMs is the **cell state** , the horizontal line running through the top of the diagram.

The cell state is kind of like a conveyor belt. It runs **straight down the entire chain, with only some minor linear interactions** . It’s very easy for information to just flow along it unchanged.

The LSTM does have the ability to remove or add information to the cell state, carefully regulated by structures called **gates**.

Gates are a way to optionally let information through. They are composed out of a sigmoid neural net layer and a pointwise multiplication operation.

The sigmoid layer outputs numbers between zero and one, describing how much of each component should be let through. A value of zero means “let nothing through,” while a value of one means “let everything through!”

An LSTM has three of these gates, to protect and control the cell state.

### Step-by-Step LSTM Walk Through¶

The first step in our LSTM is to decide **what information we’re going to throw away from the cell state** . This decision is made **by a sigmoid layer** called the “forget gate layer.” It looks at \(h_(t-1)\) and \(x_t\), and outputs a number between \(0\) and \(1\) for each number in the cell state \(C_(t-1)\) . A \(1\) represents “completely keep this” while a 0 represents “completely get rid of this.”

Let’s go back to our example of a language model trying to predict the next word based on all the previous ones. In such a problem, **the cell state might include the gender of the present subject** , so that the correct pronouns can be used. **When we see a new subject, we want to forget the gender of the old subject** .

The next step is to decide what new information we’re going to store in the cell state. This has two parts. First, a sigmoid layer called the “input gate layer” decides which values we’ll update. Next, a tanh layer creates **a vector** of new candidate values, \(\tilde{C_t}\) , that could be added to the state. In the next step, we’ll combine these two to create an update to the state.

In the example of our language model, we’d want to add the gender of the new subject to the cell state, to replace the old one we’re forgetting.

It’s now time to update the old cell state, Ct−1Ct−1, into the new cell state CtCt. The previous steps already decided what to do, we just need to actually do it.

**We multiply the old state by ftft, forgetting the things we decided to forget earlier. Then we add it∗C̃ tit∗C~t. This is the new candidate values, scaled by how much we decided to update each state value.**

In the case of the language model, this is where we’d actually drop the information about the old subject’s gender and add the new information, as we decided in the previous steps.

Finally, we need to decide what we’re going to output. This output will be based on our cell state, but will be a filtered version. First, we run a **sigmoid layer which decides what parts of the cell state we’re going to output** . Then, we put the cell state through \(tanh\) (to push the values to be between -1 and 1) and multiply it by the output of the sigmoid gate, so that we only output the parts we decided to.

### Variants on Long Short Term Memory¶

## 智能运维中的时间序列¶

LSTM(RNN)

- Moving Average Based 增强版动态阈值，考虑整体历史值，赋予合适的权重。

RNN 的记忆作用，类似寄存器的记忆能力，自身输出作为自己的输入

引入控制门，预防梯度消失和梯度爆炸

遗忘门，如果当前输入很低，就遗忘上一次的输入。

jupyter

基于相关性的RCA 寻找相关 metric