# 七、TensorFlow 和 Keras 中的用于时间序列数据的 RNN

时间序列数据是一系列值，以不同的时间间隔记录或测量。作为序列，RNN 架构是从这些数据训练模型的最佳方法。在本章中，我们将使用示例时间序列数据集来展示如何使用 TensorFlow 和 Keras 构建 RNN 模型。

我们将在本章中介绍以下主题：

*   航空公司乘客（`airpass`）时间序列数据集：
    *   描述和下载数据集
    *   可视化数据集
*   在 TensorFlow 中预处理 RNN 的数据集
*   TensorFlow 中用于时间序列数据的 RNN：
    *   TensorFlow 中的`SimpleRNN`
    *   TensorFlow 中的 LSTM
    *   TensorFlow 中的 GRU
*   在 Keras 中为 RNN 预处理数据集
*   Keras 中用于时间序列数据的 RNN：
    *   Keras 的`SimpleRNN`
    *   Keras 的 LSTM
    *   Keras 的 GRU

让我们从了解样本数据集开始。

您可以按照 Jupyter 笔记本中的代码`ch-07a_RNN_TimeSeries_TensorFlow`。

# 航空公司乘客数据集

为了简洁起见，我们选择了一个名为国际航空公司乘客（航空通票）的非常小的数据集。该数据包含从 1949 年 1 月到 1960 年 12 月的每月总乘客数量。数据集中的数字是指数千的数量。该数据集最初由 Box 和 Jenkins 在 1976 年的工作中使用。它作为 **时间序列数据集库**（**TSDL**）的一部分与 Rob Hyndman 教授的各种其他时间序列数据集一起收集。在澳大利亚莫纳什大学。后来，TSDL 被转移到 [DataMarket](http://datamarket.com)。

[您可以从此链接下载数据集](https://datamarket.com/data/set/22u3/international-airline-passengers-monthly-totals-in-thousands-jan-49-dec-60)。

# 加载 airpass 数据集

我们将数据集保存为数据集根目录（`~/datasets`）中`ts-data`文件夹中的 CSV 文件，并使用以下命令将数据加载到 pandas 数据框中：

```py
filepath = os.path.join(datasetslib.datasets_root,
                        'ts-data',
                        'international-airline-passengers-cleaned.csv'
                       ) 
dataframe = pd.read_csv(filepath,usecols=[1],header=0)
dataset = dataframe.values
dataset = dataset.astype(np.float32)
```

从 NumPy 数组中的数据框中提取值并转换为`np.float32`：

```py
dataset = dataframe.values
dataset = dataset.astype(np.float32)
```

# 可视化 airpass 数据集

让我们看一下数据集的外观：

```py
plt.plot(dataset,label='Original Data')
plt.legend()
plt.show()
```

`airpass`数据集的图如下所示：

![](img/305f4a94-92a4-4164-9ec2-473cc7225413.png)Airline Passengers Dataset

# 用于 TensorFlow RNN 模型的数据集预处理

为了使其为学习模型做好准备，通过应用 MinMax 缩放来正则化数据集，该缩放使数据集值介于 0 和 1 之间。您可以尝试根据数据的性质对数据应用不同的缩放方法。

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

我们使用自己开发的实用函数将数据集拆分为训练和测试数据集。必须拆分数据而不对数据集进行混洗，因为改组数据集会破坏序列。维护数据序列对于训练时间序列模型非常重要。

```py
train,test=tsu.train_test_split(normalized_dataset,train_size=0.67)
```

然后我们将训练和测试数据集转换为有监督的机器学习集。让我们试着理解监督学习集的含义。假设我们有一系列数据：`1,2,3,4,5`。我们想要了解生成数据集的概率分布。为了做到这一点，我们可以假设时间步长`t`的值是从时间步长`t-1`到`tk`的值的结果，其中`k`是窗口大小。为简化起见，假设窗口大小为 1。因此，时间步长`t`的值（称为输入特征）是时间步长值`t-1`的结果，被称为目标。让我们重复一遍所有时间步骤，我们得到下表：

| 输入值或特征 | 输出值或目标 |
| --- | --- |
| 1 | 2 |
| 2 | 3 |
| 3 | 4 |
| 4 | 5 |

我们展示的示例只有一个变量值，它将转换为特征和目标。当目标值取决于一个变量时，它被称为单变量时间序列。同样的逻辑可以应用于多变量时间序列，其中目标取决于多个变量。我们使用`x`来表示输入特征，使用`y`来表示输出目标。

考虑到这一背景，为了将`airpass`数据转换为监督机器学习数据，我们设置了以下超参数：

1.  设置用于学习或预测下一个时间步的过去时间步数：

```py
n_x=1  
```

1.  设置学习或预测的未来时间步长的数量：

```py
n_y=1 
```

1.  设置用于学习的`x`变量的数量；由于当前示例是单变量的，因此设置为 1：

```py
n_x_vars = 1  
```

1.  设置要预测的`y`变量的数量；由于当前示例是单变量的，因此设置为 1：

```py
n_y_vars = 1  
```

1.  最后，我们通过应用本节开头所述的逻辑将训练和测试数据集转换为`X`和`Y`集：

```py
X_train, Y_train, X_test, Y_test = tsu.mvts_to_xy(train,
                                  test,n_x=n_x,n_y=n_y)
```

现在数据已经过预处理并可以输入到我们的模型中，让我们使用 TensorFlow 准备一个`SimpleRNN`模型。

# TensorFlow 中的简单 RNN

在 TensorFlow 中定义和训练简单 RNN 的工作流程如下：

1.  定义模型的超参数：

```py
state_size = 4
n_epochs = 100
n_timesteps = n_x 
learning_rate = 0.1
```

这里新的超参数是`state_size`。`state_size`表示 RNN 单元的权重向量的数量。

1.  为模型定义`X`和`Y`参数的占位符。`X`占位符的形状为`(batch_size, number_of_input_timesteps, number_of_inputs)`，`Y`占位符的形状为`(batch_size, number_of_output_timesteps, number_of_outputs)`。对于`batch_size`，我们使用`None`，以便我们以后可以输入任意大小的批次。

```py
X_p = tf.placeholder(tf.float32, [None, n_timesteps, n_x_vars], 
    name='X_p') 
Y_p = tf.placeholder(tf.float32, [None, n_timesteps, n_y_vars], 
    name='Y_p')
```

1.  将输入占位符`X_p`转换为长度等于时间步数的张量列表，在此示例中为`n_x`或 1：

```py
# make a list of tensors of length n_timesteps
rnn_inputs = tf.unstack(X_p,axis=1)
```

1.  使用`tf.nn.rnn_cell.BasicRNNCell`创建一个简单的 RNN 单元：

```py
cell = tf.nn.rnn_cell.BasicRNNCell(state_size)
```

1.  TensorFlow 提供`static_rnn`和`dynamic_rnn`便利方法（以及其他方法）分别创建静态和动态 RNN。创建静态 RNN：

```py
rnn_outputs, final_state = tf.nn.static_rnn(cell, 
                                            rnn_inputs,
                                            dtype=tf.float32
                                           )
```

静态 RNN 在编译时创建单元，即展开循环。动态 RNN 创建单元，即在运行时展开循环 。在本章中，我们仅展示了`static_rnn`的示例，但是一旦获得静态 RNN 的专业知识，就应该探索`dynamic_rnn`。

`static_rnn`方法采用以下参数：

*   `cell`：我们之前定义的基本 RNN 单元对象。它可能是另一种单元，我们将在本章中进一步看到。
*   `rnn_inputs`：形状`(batch_size, number_of_inputs)`的张量列表。
*   `dtype`：初始状态和预期输出的数据类型。

1.  定义预测层的权重和偏差参数：

```py
W = tf.get_variable('W', [state_size, n_y_vars])
b = tf.get_variable('b', [n_y_vars], 
    initializer=tf.constant_initializer(0.0))
```

1.  将预测层定义为密集线性层：

```py
predictions = [tf.matmul(rnn_output, W) + b \
                for rnn_output in rnn_outputs]
```

1.  输出 Y 是张量的形状；将其转换为张量列表：

```py
y_as_list = tf.unstack(Y_p, num=n_timesteps, axis=1)
```

1.  将损失函数定义为预测标签和实际标签之间的均方误差：

```py
mse = tf.losses.mean_squared_error
losses = [mse(labels=label, predictions=prediction) 
          for prediction, label in zip(predictions, y_as_list)
         ]
```

1.  将总损失定义为所有预测时间步长的平均损失：

```py
total_loss = tf.reduce_mean(losses)
```

1.  定义优化器以最小化`total_loss`：

```py
optimizer = tf.train.AdagradOptimizer(learning_rate).minimize(total_loss)
```

1.  现在我们已经定义了模型，损耗和优化器函数，让我们训练模型并计算训练损失：

```py
with tf.Session() as tfs:
    tfs.run(tf.global_variables_initializer())
    epoch_loss = 0.0
    for epoch in range(n_epochs):
        feed_dict={X_p: X_train.reshape(-1, n_timesteps, 
                                        n_x_vars), 
                   Y_p: Y_train.reshape(-1, n_timesteps, 
                                        n_x_vars)
                  }
        epoch_loss,y_train_pred,_=tfs.run([total_loss,predictions,
                                optimizer], feed_dict=feed_dict)
    print("train mse = {}".format(epoch_loss))
```

我们得到以下值：

```py
train mse = 0.0019413739209994674
```

1.  让我们在测试数据上测试模型：

```py
feed_dict={X_p: X_test.reshape(-1, n_timesteps,n_x_vars), 
           Y_p: Y_test.reshape(-1, n_timesteps,n_y_vars)
          }
test_loss, y_test_pred = tfs.run([total_loss,predictions], 
                                 feed_dict=feed_dict
                                )
print('test mse = {}'.format(test_loss))
print('test rmse = {}'.format(math.sqrt(test_loss)))
```

我们在测试数据上得到以下 mse 和 rmse（均方根误差）：

```py
test mse = 0.008790395222604275
test rmse = 0.09375710758446143
```

这非常令人印象深刻。

这是一个非常简单的例子，只用一个变量值预测一个时间步。在现实生活中，输出受到多个特征的影响，并且需要预测不止一个时间步。后一类问题被称为多变量多时间步进预测问题。这些问题是使用循环神经网络进行更好预测的积极研究领域。

现在让我们重新调整预测和原始值并绘制原始值（请在笔记本中查找代码）。

我们得到以下绘图：

![](img/b83815e7-8ee4-469a-a23a-8a71b9c46b30.png)

令人印象深刻的是，在我们的简单示例中，预测数据几乎与原始数据相匹配。对这种准确预测的一种可能解释是，单个时间步的预测基于来自最后一个时间步的单个变量的预测，因此它们总是在先前值的附近。

尽管如此，前面示例的目的是展示在 TensorFlow 中创建 RNN 的方法。现在让我们使用 RNN 变体重新创建相同的示例。

# TensorFlow 中的 LSTM

由于爆炸和消失梯度的问题，简单的 RNN 架构并不总是有效，因此使用了改进的 RNN 架构，例如 LSTM 网络。 TensorFlow 提供 API 来创建 LSTM RNN 架构。

在上一节中展示的示例中，要将简单 RNN 更改为 LSTM 网络，我们所要做的就是更改单元类型，如下所示：

```py
cell = tf.nn.rnn_cell.LSTMCell(state_size)
```

其余代码保持不变，因为 TensorFlow 会为您在 LSTM 单元内创建门。

笔记本`ch-07a_RNN_TimeSeries_TensorFlow`中提供了 LSTM 模型的完整代码。

然而，对于 LSTM，我们必须运行 600 个周期的代码才能使结果更接近基本 RNN。原因是 LSTM 需要学习更多参数，因此需要更多的训练迭代。对于我们的简单示例，它似乎有点过分，但对于较大的数据集，与简单的 RNN 相比，LSTM 显示出更好的结果。

具有 LSTM 架构的模型的输出如下：

```py
train mse = 0.0020806745160371065
test mse = 0.01499235536903143
test rmse = 0.12244327408653947
```

![](img/5dd03142-e42f-4e1c-bf60-19e31475b853.png)

# TensorFlow 中的 GRU

要将最后一节中的 LSTM 示例更改为 GRU 网络， 按如下方式更改单元类型，TensorFlow 将为您处理其余部分：

```py
cell = tf.nn.rnn_cell.GRUCell(state_size)
```

笔记本`ch-07a_RNN_TimeSeries_TensorFlow`中提供了 GRU 模型的完整代码。

对于小`airpass`数据集，GRU 在相同数量的周期中表现出更好的表现。在实践中，GRU 和 LSTM 表现出相当的表现。就执行速度而言，与 LSTM 相比，GRU 模型训练和预测更快。

GRU 模型的完整代码在 Jupyter 笔记本中提供。GRU 模型的结果如下：

```py
train mse = 0.0019633215852081776
test mse = 0.014307591132819653
test rmse = 0.11961434334066987
```

![](img/2d9ac55a-7f30-406b-934d-3cba2d9c6a91.png)

我们鼓励您探索 TensorFlow 中可用的其他选项来创建循环神经网络。现在让我们在 TensorFlow 的一个高级库中尝试相同的示例。

对于下一节，您可以按照 Jupyter 笔记本中的代码`ch-07b_RNN_TimeSeries_Keras`。

# 用于 Keras RNN 模型的数据集预处理

与使用较低级别 TensorFlow 类和方法构建相比，在 Keras 中构建 RNN 网络要简单得多。对于 Keras，我们预先处理数据，如前面部分所述，以获得受监督的机器学习时间序列数据集：`X_train, Y_train, X_test, Y_test`。

从这里开始，预处理有所不同。对于 Keras，输入必须是`(samples, time steps, features)`形状。当我们将数据转换为监督机器学习格式时，在重塑数据时，我们可以将时间步长设置为 1，从而将所有输入时间步长作为特征，或者我们可以设置时间步长为实际的时间步数，从而为每个时间步长提供特征集。换句话说，我们之前获得的`X_train`和`X_test`数据集可以重新整形为以下方法之一：

方法 1：`n`时间步长与`1`特征：

```py
X_train.reshape(X_train.shape[0], X_train.shape[1],1)
```

方法 2：`1`时间步长`n`特征：

```py
X_train.reshape(X_train.shape[0], 1, X_train.shape[1])
```

在本章中，我们将对特征大小为 1 的数据集进行整形，因为我们只使用一个变量作为输入：

```py
# reshape input to be [samples, time steps, features]
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1],1)
X_test = X_test.reshape(X_test.shape[0], X_train.shape[1], 1)
```

# Keras 中的简单 RNN

通过添加具有内部神经元数量和输入张量形状的`SimpleRNN`层，可以在 Keras 中轻松构建 RNN 模型，不包括样本维数。以下代码创建，编译和拟合`SimpleRNN`：

```py
# create and fit the SimpleRNN model
model = Sequential()
model.add(SimpleRNN(units=4, input_shape=(X_train.shape[1], 
    X_train.shape[2])))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, Y_train, epochs=20, batch_size=1)
```

由于我们的数据集很小，我们使用`batch_size`为 1 并训练 20 次迭代，但对于较大的数据集，您需要调整这些和其他超参数的值。

该模型的结构如下：

```py
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
simple_rnn_1 (SimpleRNN)     (None, 4)                 24        
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 5         
=================================================================
Total params: 29
Trainable params: 29
Non-trainable params: 0
```

训练的结果如下：

```py
Epoch 1/20
95/95 [==============================] - 0s - loss: 0.0161     
Epoch 2/20
95/95 [==============================] - 0s - loss: 0.0074     
Epoch 3/20
95/95 [==============================] - 0s - loss: 0.0063     
Epoch 4/20
95/95 [==============================] - 0s - loss: 0.0051     

-- epoch 5 to 14 removed for the sake of brevity --

Epoch 14/20
95/95 [==============================] - 0s - loss: 0.0021     
Epoch 15/20
95/95 [==============================] - 0s - loss: 0.0020     
Epoch 16/20
95/95 [==============================] - 0s - loss: 0.0020     
Epoch 17/20
95/95 [==============================] - 0s - loss: 0.0020     
Epoch 18/20
95/95 [==============================] - 0s - loss: 0.0020         
Epoch 19/20
95/95 [==============================] - 0s - loss: 0.0020     
Epoch 20/20
95/95 [==============================] - 0s - loss: 0.0020     
```

损失从 0.0161 开始，平稳在 0.0020。让我们做出预测并重新调整预测和原件。我们使用 Keras 提供的函数来计算均方根误差：

```py
from keras.losses import mean_squared_error as k_mse
from keras.backend import sqrt as k_sqrt
import keras.backend as K

# make predictions
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)

# invert predictions
y_train_pred = scaler.inverse_transform(y_train_pred)
y_test_pred = scaler.inverse_transform(y_test_pred)

#invert originals
y_train_orig = scaler.inverse_transform(Y_train)
y_test_orig = scaler.inverse_transform(Y_test)

# calculate root mean squared error
trainScore = k_sqrt(k_mse(y_train_orig[:,0],
                          y_train_pred[:,0])
                   ).eval(session=K.get_session())
print('Train Score: {0:.2f} RMSE'.format(trainScore))

testScore = k_sqrt(k_mse(y_test_orig[:,0],
                         y_test_pred[:,0])
                  ).eval(session=K.get_session())
print('Test Score: {0:.2f} RMSE'.format(testScore))
```

我们得到以下结果：

```py
Train Score: 23.27 RMSE
Test Score: 54.13 RMSE
```

![](img/93bcf886-fc39-4e77-8fa0-d72af7ac310b.png)

我们可以看到，这不像我们在 TensorFlow 部分得到的那样完美；但是，这种差异是因为超参数值。我们留给您尝试不同的超参数值来调整此 Keras 模型以获得更好的结果。

# Keras 中的 LSTM

创建 LSTM 模型只需添加 LSTM 层而不是`SimpleRNN`层，如下所示：

```py
model.add(LSTM(units=4, input_shape=(X_train.shape[1], X_train.shape[2])))
```

模型结构如下所示：

```py
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
lstm_1 (LSTM)                (None, 4)                 96        
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 5         
=================================================================
Total params: 101
Trainable params: 101
Non-trainable params: 0
_________________________________________________________________
```

笔记本`ch-07b_RNN_TimeSeries_Keras`中提供了 LSTM 模型的完整代码。

由于 LSTM 模型具有更多需要训练的参数，对于相同数量的迭代（20 个周期），我们得到更高的误差分数。我们留给您探索周期和其他超参数的各种值，以获得更好的结果：

```py
Train Score: 32.21 RMSE
Test Score: 84.68 RMSE
```

![](img/b64ddef8-5b68-44b8-842e-779177ef1557.png)

# Keras 中的 GRU

使用 TensorFlow 和 Keras 的一个优点是它们可以轻松创建模型。与 LSTM 一样，创建 GRU 模型只需添加 GRU 层而不是 LSTM 或`SimpleRNN`层，如下所示：

```py
model.add(GRU(units=4, input_shape=(X_train.shape[1], X_train.shape[2])))
```

模型结构如下：

```py
Layer (type)                 Output Shape              Param #   
=================================================================
gru_1 (GRU)                  (None, 4)                 72        
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 5         
=================================================================
Total params: 77
Trainable params: 77
Non-trainable params: 0
```

笔记本`ch-07b_RNN_TimeSeries_Keras`中提供了 GRU 模型的完整代码。

正如预期的那样，GRU 模型显示出与 LSTM 几乎相同的表现，我们让您尝试使用不同的超参数值来优化此模型：

```py
Train Score: 31.49 RMSE
Test Score: 92.75 RMSE
```

![](img/f5e8871e-1511-408f-ab58-0b3e3b79644d.png)

# 总结

时间序列数据是基于序列的数据，因此 RNN 模型是从时间序列数据中学习的相关架构。在本章中，您学习了如何使用 TensorFlow（一个低级库）和 Keras（一个高级库）创建不同类型的 RNN 模型。我们只介绍了`SimpleRNN`，LSTM 和 GRU，但您应该探索可以使用 TensorFlow 和 Keras 创建的许多其他 RNN 变体。

在下一章中，我们将使用当前章节和前几章中构建的基础为各种**自然语言处理**（**NLP**）任务创建文本数据的 RNN 模型。

