Keras 中长短期记忆模型的 5 步生命周期

作者： Jason Brownlee 发布于 2020 年 8 月 27 日归类于长短期记忆网络 37

使用 Keras 在 Python 中创建和评估深度学习神经网络非常容易，但您必须遵循严格的模型生命周期。

在这篇文章中，您将了解在 Keras 中创建、训练和评估长短期记忆 (LSTM) 循环神经网络的分步生命周期，以及如何使用训练好的模型进行预测。

阅读本文后，你将了解：

如何在 Keras 中定义、编译、拟合和评估 LSTM。
如何为回归和分类序列预测问题选择标准默认值。
如何将所有这些结合起来，在 Keras 中开发和运行您的第一个 LSTM 循环神经网络。

购买我的新书《使用 Python 的长短期记忆网络》，即可启动您的项目，其中包括分步教程和所有示例的 Python 源代码文件。

让我们开始吧。

2017 年 6 月更新：修复了输入大小调整示例中的错别字。

The 5 Step Life-Cycle for Long Short-Term Memory Models in Keras

Keras 中长短期记忆模型的 5 步生命周期
图片作者：docmonstereyes，保留部分权利。

概述

下面是 Keras 中 LSTM 模型生命周期的 5 个步骤概述，我们将逐一介绍。

定义网络
编译网络
拟合网络
评估网络
进行预测

环境

本教程假定您已安装 Python SciPy 环境。您可以使用 Python 2 或 3。

本教程假定您已安装 Keras v2.0 或更高版本，并使用 TensorFlow 或 Theano 后端。

本教程还假定您已安装 scikit-learn、Pandas、NumPy 和 Matplotlib。

接下来，让我们看看一个标准的时间序列预测问题，我们可以将其作为本次实验的背景。

如果您需要帮助设置 Python 环境，请参阅此帖子

如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境

需要 LSTM 帮助进行序列预测吗？

参加我的免费7天电子邮件课程，了解6种不同的LSTM架构（附代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

步骤 1. 定义网络

第一步是定义您的网络。

神经网络在 Keras 中被定义为一系列层。这些层的容器是 Sequential 类。

第一步是创建 Sequential 类的实例。然后您可以创建层并按照它们应该连接的顺序添加它们。由记忆单元组成的 LSTM 循环层称为 LSTM()。通常跟在 LSTM 层后面并用于输出预测的全连接层称为 Dense()。

例如，我们可以分两步完成

model = Sequential()
model.add(LSTM(2))
model.add(Dense(1))

model = Sequential()

模型。添加(LSTM(2))

模型。添加(Dense(1))

但我们也可以通过创建层数组并将其传递给 Sequential 的构造函数来一步完成。

layers = [LSTM(2), Dense(1)]
model = Sequential(layers)

1 2	层 = [LSTM(2), Dense(1)] 模型 = Sequential(层)

网络中的第一层必须定义预期的输入数量。输入必须是三维的，由样本、时间步长和特征组成。

样本。这是您数据中的行。
时间步长。这是特征的过去观测值，例如滞后变量。
特征。这是您数据中的列。

假设您的数据已作为 NumPy 数组加载，您可以使用 NumPy 中的 reshape() 函数将 2D 数据集转换为 3D 数据集。如果您希望列成为一个特征的时间步长，您可以使用

data = data.reshape((data.shape[0], data.shape[1], 1))

1	数据 = 数据。重塑((数据。形状[0], 数据。形状[1], 1))

如果您希望 2D 数据中的列成为具有一个时间步长的特征，您可以使用

data = data.reshape((data.shape[0], 1, data.shape[1]))

1	数据 = 数据。重塑((数据。形状[0], 1, 数据。形状[1]))

您可以指定 input_shape 参数，它需要一个包含时间步长数和特征数的元组。例如，如果我们有一个单变量时间序列，每行有两个滞后观测值，有两个时间步长和一个特征，它将按如下方式指定

model = Sequential()
model.add(LSTM(5, input_shape=(2,1)))
model.add(Dense(1))

model = Sequential()

模型。添加(LSTM(5, 输入形状=(2,1)))

模型。添加(Dense(1))

LSTM 层可以通过将它们添加到 Sequential 模型中来堆叠。重要的是，当堆叠 LSTM 层时，我们必须为每个输入输出一个序列而不是单个值，以便后续的 LSTM 层可以具有所需的 3D 输入。我们可以通过将 return_sequences 参数设置为 True 来实现这一点。例如

model = Sequential()
model.add(LSTM(5, input_shape=(2,1), return_sequences=True))
model.add(LSTM(5))
model.add(Dense(1))

model = Sequential()

模型。添加(LSTM(5, 输入形状=(2,1), 返回序列=真))

模型。添加(LSTM(5))

模型。添加(Dense(1))

将 Sequential 模型视为一个管道，您的原始数据从一端输入，预测结果从另一端输出。

这在 Keras 中是一个有用的容器，因为传统上与层相关的关注点也可以分离出来并作为单独的层添加，清楚地显示它们在从输入到预测的数据转换中的作用。

例如，转换层中每个神经元的求和信号的激活函数可以提取出来并作为名为 Activation 的类似层对象添加到 Sequential 中。

model = Sequential()
model.add(LSTM(5, input_shape=(2,1)))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model = Sequential()

模型。添加(LSTM(5, 输入形状=(2,1)))

模型。添加(Dense(1))

模型。添加(激活('sigmoid'))

激活函数的选择对输出层最为重要，因为它将定义预测的格式。

例如，下面是一些常见的预测建模问题类型以及您可以在输出层中使用的结构和标准激活函数

回归：线性激活函数，或“linear”，神经元数量与输出数量匹配。
二元分类（2 类）：逻辑激活函数，或“sigmoid”，输出层有一个神经元。
多类别分类（>2 类）：Softmax 激活函数，或“softmax”，每个类别值一个输出神经元，假设采用独热编码输出模式。

步骤 2. 编译网络

一旦我们定义了网络，我们必须对其进行编译。

编译是一个提高效率的步骤。它将我们定义的简单层序列转换为一系列高效的矩阵变换，其格式旨在根据 Keras 的配置在您的 GPU 或 CPU 上执行。

将编译视为网络的预计算步骤。定义模型后始终需要它。

编译需要指定许多参数，这些参数专门用于训练您的网络。具体来说，用于训练网络的优化算法和用于评估网络的损失函数由优化算法最小化。

例如，下面是一个编译定义模型并指定随机梯度下降 (sgd) 优化算法和均方误差 (mean_squared_error) 损失函数的情况，用于回归类型问题。

model.compile(optimizer='sgd', loss='mean_squared_error')

1	模型。编译(优化器='sgd', 损失='mean_squared_error')

或者，优化器可以在提供给编译步骤作为参数之前创建和配置。

algorithm = SGD(lr=0.1, momentum=0.3)
model.compile(optimizer=algorithm, loss='mean_squared_error')

1 2	算法 = SGD(学习率=0.1, 动量=0.3) 模型。编译(优化器=算法, 损失='mean_squared_error')

预测建模问题的类型对可以使用的损失函数类型施加了限制。

例如，下面是一些针对不同预测模型类型的标准损失函数

回归：均方误差或“mean_squared_error”。
二元分类（2 类）：对数损失，也称为交叉熵或“binary_crossentropy”。
多类别分类（>2 类）：多类别对数损失或“categorical_crossentropy”。

最常见的优化算法是随机梯度下降，但 Keras 还支持一系列其他最先进的优化算法，这些算法在很少或没有配置的情况下也能很好地工作。

由于它们的整体性能更好，最常用的优化算法可能是

随机梯度下降，或“sgd”，需要调整学习率和动量。
ADAM，或“adam”，需要调整学习率。
RMSprop，或“rmsprop”，需要调整学习率。

最后，除了损失函数之外，您还可以指定在拟合模型时要收集的指标。通常，最有用的额外指标是分类问题的准确性。要收集的指标以数组形式按名称指定。

例如：

model.compile(optimizer='sgd', loss='mean_squared_error', metrics=['accuracy'])

1	模型。编译(优化器='sgd', 损失='mean_squared_error', 指标=['accuracy'])

步骤 3. 拟合网络

网络编译完成后，就可以进行拟合，这意味着在训练数据集上调整权重。

拟合网络需要指定训练数据，包括输入模式矩阵 X 和匹配的输出模式数组 y。

网络使用反向传播算法进行训练，并根据编译模型时指定的优化算法和损失函数进行优化。

反向传播算法要求网络训练指定数量的 epoch 或训练数据集的曝光次数。

每个 epoch 可以划分为输入-输出模式对组，称为批次。这定义了网络在每个 epoch 内更新权重之前接触到的模式数量。这也是一种效率优化，确保一次不会将太多输入模式加载到内存中。

拟合网络的最小示例如下

history = model.fit(X, y, batch_size=10, epochs=100)

1	历史 = 模型。拟合(X, y, 批次大小=10, epoch数=100)

拟合完成后，将返回一个历史对象，它提供了模型在训练期间性能的摘要。这包括损失以及在编译模型时指定的任何其他指标，每个 epoch 都会记录。

训练可能需要很长时间，从几秒到几小时到几天，具体取决于网络的大小和训练数据的大小。

默认情况下，每个 epoch 都会在命令行上显示一个进度条。这可能会给您带来太多噪音，或者可能导致您的环境出现问题，例如您在交互式笔记本或 IDE 中。

您可以通过将 verbose 参数设置为 2 来将显示的信息量减少到每个 epoch 仅显示损失。您可以通过将 verbose 设置为 1 来关闭所有输出。例如

history = model.fit(X, y, batch_size=10, epochs=100, verbose=0)

1	历史 = 模型。拟合(X, y, 批次大小=10, epoch数=100, 详细程度=0)

步骤 4. 评估网络

网络训练完成后，即可进行评估。

网络可以在训练数据上进行评估，但这不会提供网络作为预测模型性能的有用指示，因为它之前已经看到了所有这些数据。

我们可以评估网络在测试期间未见的单独数据集上的性能。这将提供网络在未来对未见数据进行预测的性能估计。

模型评估所有测试模式的损失，以及编译模型时指定的任何其他指标，例如分类准确率。返回评估指标列表。

例如，对于使用准确率指标编译的模型，我们可以在新数据集上按如下方式评估它

loss, accuracy = model.evaluate(X, y)

1	损失, 准确率 = 模型。评估(X, y)

与拟合网络一样，提供了详细输出以了解评估模型的进度。我们可以通过将 verbose 参数设置为 0 来关闭它。

loss, accuracy = model.evaluate(X, y, verbose=0)

1	损失, 准确率 = 模型。评估(X, y, 详细程度=0)

步骤 5. 进行预测

一旦我们对拟合模型的性能感到满意，我们就可以使用它对新数据进行预测。

这就像在模型上调用 predict() 函数并提供一组新的输入模式一样简单。

例如：

predictions = model.predict(X)

1	预测 = 模型。预测(X)

预测将以网络输出层提供的格式返回。

在回归问题中，这些预测可以直接以问题格式提供，由线性激活函数提供。

对于二元分类问题，预测可能是第一个类别的概率数组，可以通过四舍五入转换为 1 或 0。

对于多类别分类问题，结果可能以概率数组的形式出现（假设是独热编码的输出变量），可能需要使用 argmax() NumPy 函数转换为单个类别输出预测。

或者，对于分类问题，我们可以使用 predict_classes() 函数，它会自动将模糊预测转换为清晰的整数类别值。

predictions = model.predict_classes(X)

1	预测 = 模型。预测类别(X)

与拟合和评估网络一样，提供了详细输出以了解模型进行预测的进度。我们可以通过将 verbose 参数设置为 0 来关闭它。

predictions = model.predict(X, verbose=0)

1	预测 = 模型。预测(X, 详细程度=0)

端到端工作示例

让我们用一个小型工作示例将所有这些联系起来。

这个例子将使用一个学习 10 个数字序列的简单问题。我们将向网络显示一个数字，例如 0.0，并期望它预测 0.1。然后显示 0.1 并期望它预测 0.2，依此类推到 0.9。

定义网络：我们将构建一个 LSTM 神经网络，在可见层中具有 1 个输入时间步和 1 个输入特征，在 LSTM 隐藏层中具有 10 个记忆单元，在全连接输出层中具有 1 个神经元，并带有线性（默认）激活函数。
编译网络：我们将使用高效的 ADAM 优化算法，采用默认配置和均方误差损失函数，因为它是一个回归问题。
拟合网络：我们将对网络进行 1,000 个 epoch 的拟合，并使用等于训练集中模式数量的批处理大小。我们还将关闭所有详细输出。
评估网络。我们将在训练数据集上评估网络。通常，我们会在测试集或验证集上评估模型。
进行预测。我们将对训练输入数据进行预测。同样，通常我们会在不知道正确答案的数据上进行预测。

完整的代码列表如下。

# Example of LSTM to learn a sequence
from pandas import DataFrame
from pandas import concat
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# create sequence
length = 10
sequence = [i/float(length) for i in range(length)]
print(sequence)
# create X/y pairs
df = DataFrame(sequence)
df = concat([df.shift(1), df], axis=1)
df.dropna(inplace=True)
# convert to LSTM friendly format
values = df.values
X, y = values[:, 0], values[:, 1]
X = X.reshape(len(X), 1, 1)
# 1. define network
model = Sequential()
model.add(LSTM(10, input_shape=(1,1)))
model.add(Dense(1))
# 2. compile network
model.compile(optimizer='adam', loss='mean_squared_error')
# 3. fit network
history = model.fit(X, y, epochs=1000, batch_size=len(X), verbose=0)
# 4. evaluate network
loss = model.evaluate(X, y, verbose=0)
print(loss)
# 5. make predictions
predictions = model.predict(X, verbose=0)
print(predictions[:, 0])

# LSTM 学习序列的示例

from pandas import DataFrame

从 pandas 导入 concat

from keras.models import Sequential

from keras.layers import Dense

来自 keras.层导入 LSTM

# 创建序列

长度 = 10

序列 = [i/浮点数(长度) for i in 范围(长度)]

打印(序列)

# 创建 X/y 对

df = 数据帧(序列)

df = 连接([df。移位(1), df], 轴=1)

df。删除空值(原地=真)

# 转换为 LSTM 友好格式

值 = df。值

X, y = 值[:, 0], 值[:, 1]

X = X。重塑(长度(X), 1, 1)

# 1. 定义网络

model = Sequential()

模型。添加(LSTM(10, 输入形状=(1,1)))

模型。添加(Dense(1))

# 2. 编译网络

模型。编译(优化器='adam', 损失='mean_squared_error')

# 3. 拟合网络

历史 = 模型。拟合(X, y, epoch数=1000, 批次大小=长度(X), 详细程度=0)

# 4. 评估网络

损失 = 模型。评估(X, y, 详细程度=0)

print(loss)

# 5. 进行预测

预测 = 模型。预测(X, 详细程度=0)

打印(预测[:, 0])

运行此示例将产生以下输出，显示 10 个数字的原始输入序列、网络在对整个序列进行预测时的均方误差损失以及每个输入模式的预测。

注意：由于算法或评估过程的随机性，或数值精度的差异，您的结果可能会有所不同。考虑多次运行示例并比较平均结果。

输出为了可读性进行了间隔。

我们可以看到序列学习得很好，特别是如果我们将预测四舍五入到小数点后第一位。

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

4.54527471447e-05

[ 0.11612834 0.20493418 0.29793766 0.39445466 0.49376178 0.59512401
0.69782174 0.80117452 0.90455914]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

4.54527471447e-05

[ 0.11612834 0.20493418 0.29793766 0.39445466 0.49376178 0.59512401

0.69782174 0.80117452 0.90455914]

进一步阅读

总结

在这篇文章中，您发现了使用 Keras 库的 LSTM 循环神经网络的 5 步生命周期。

具体来说，你学到了：

如何在 Keras 中定义、编译、拟合、评估 LSTM 网络并进行预测。
如何为分类和回归问题选择激活函数和输出层配置。
如何在 Keras 中开发和运行您的第一个 LSTM 模型。

您对 Keras 中的 LSTM 模型或这篇文章有任何疑问吗？
请在评论中提出您的问题，我将尽力回答。

关于此主题的更多信息

如何在 Python 中为机器学习结果计算 Bootstrap 置信区间

如何在 Keras 中学习使用 LSTM 回显随机整数