博士带你学LSTM|如何使用学习曲线来诊断你的LSTM模型的行为？（附代码）

LSTM是一种时间递归神经网络，适合于处理和预测时间序列中间隔和延迟相对较长的重要事件。在自然语言处理、语言识别等一系列的应用上都取得了很好的效果。

《Long Short Term Memory Networks with Python》是澳大利亚机器学习专家Jason Brownlee的著作，里面详细介绍了LSTM模型的原理和使用。

该书总共分为十四个章节，具体如下：

第一章：什么是LSTMs？

第二章：怎么样训练LSTMs？

第三章：怎么样准备LSTMs的数据？

第四章：怎么样在Keras中开发LSTMs？

第五章：序列预测建模

第六章：如何开发一个Vanilla LSTM模型？

第七章：怎么样开发Stacked LSTMs？

第八章：开发CNN LSTM模型（本期内容）

第九章：开发Encoder-Decoder LSTMs

第十章：开发Bidirectional LSTMs

第十一章：开发生成LSTMs

第十二章：诊断和调试LSTMs（本期内容）

第十三章：怎么样用LSTMs做预测？（下周一发布）

第十四章：更新LSTMs模型

本文的作者对此书进行了翻译整理之后，分享给大家，本文是第十二期内容。

第一期内容为：一万字纯干货|机器学习博士手把手教你入门LSTM（附代码资料）

第二期内容为：干货推荐|如何基于时间的反向传播算法来训练LSTMs？

第三期内容为：干货推荐|如何准备用于LSTM模型的数据并进行序列预测？（附代码）

第四期内容为：机器学习博士带你入门|一文学会如何在Keras中开发LSTMs（附代码）

第五期内容为：初学者如何避免在序列预测问题中遇到的陷阱？

第六期内容为：如何开发和评估Vanilla LSTM模型？

第七期内容为：博士带你学LSTM|怎么样开发Stacked LSTMs？（附代码）

第八期内容为：博士带你学LSTM|手把手教你开发CNN LSTM模型，并应用在Keras中（附代码）

第九期内容为：博士带你学LSTM|开发Encoder-Decoder LSTM模型的简单教程（附代码）

第十期内容为：博士带你学LSTM|开发Bidirectional LSTM模型的简单教程（附代码）

第十一期内容为：博士带你学LSTM|怎么开发一个LSTM模型来生成形状？（附代码）

我们还将继续推出一系列的文章来介绍里面的详细内容，和大家一起来共同学习，支持答疑！支持答疑！支持答疑！重要的事情说三遍！您在学习过程中遇到相关问题，都可在文章底部给我们留言！一定会回复你的！

本文有18000字左右，阅读需30分钟，建议收藏学习。


12.0 前言

12.0.1 课程目标

本课程的目标是学习怎么样调优LSTM超参数。完成本课程之后，你将会学到：

  • 怎么样开发一个针对你的LSTM模型学习能力的健壮的评估；

  • 怎么样使用学习曲线来诊断你的LSTM模型的行为；

  • 怎么样调整LSTM模型的框架、结构和学习行为。

12.0.2 课程概览

本课程被分为5个部分，它们是：

  1. 评估LSTM模型；

  2. 诊断过拟合和欠拟合；

  3. 调优问题的框架；

  4. 调优模型结构；

  5. 调优学习行为。

让我们开始吧！

12.1 评估LSTM模型

在本章节中，你将发现用于开发对未知数据的LSTM模型的学习能力的文件估计的过程。

12.1.1 初学者的错误

你将模型拟合到你的训练数据并在测试数据集上进行评估，然后报告该学习能力。也许你用K折交叉验证来评估模型，然后报告模型的学习能力。这是初学者犯的错误。

看起来你做的是正确的事情，但是一个关键问题是你没有考虑过：深度学习模型是随机的。人工神经网络（如LSTM）在数据集上使用的随机性，例如在随机梯度下降期间每个训练周期的随机初始权重和数据的随机洗牌。这意味着，每次相同的模型适合于相同的数据，它可以给出不同的预测，进而具有不同的整体技能。

12.1.2 评估模型学习能力

我们没有所有可能的数据；如果我们做了，我们就不需要做预测。我们有一个有限的数据样本，从中我们需要发现最好的模型。

我通过将数据分割成两个部分，即对数据的第一部分进行模型或者特定模型配置，并使用拟合模型对其余部分进行预测，然后评估这些预测的技巧。这被称为训练-测试分割，我们使用这一技巧来估计模型在预测新数据时在实践中的表现。例如，这里有一些伪代码用于使用训练-测试分割来评估模型：

  1. train, test = random_split(data)

  2. model = fit(train.X, train.y)

  3. predictions = model.predict(test.X)

  4. skill = compare(test.y, predictions)

表 12.1 评估模型技能的伪代码

如果你有很多的数据或者一个很慢的模型来训练，训练-测试分割是一个很好的方法，但是，由于数据中的随机性（模型的方差），模型的技能得分将是嘈杂的。这意味着相同的模型在不同数据上的拟合将会给不同模型技能分数。如果我们有资源，我们将会使用k折交叉验证。但是，在深度学习中使用大数据集合训练模型的速度慢，这通常是不可能的。

12.1.3 评估一个随机模型的技能

随机模型，如深度神经网络，添加一个额外的随机性来源。这种附加的随机性使得模型在学习时具有更高的灵活性，但可以使模型不太稳定（例如，当同一模型在同一数据上训练时会有不同的结果）。这是不同的模型方差，当不同的数据训练相同的模型时，给出不同的结果。

为了得到一个随机模型的技能的鲁棒估计，我们必须考虑这个额外的方差来源，我们必须控制它。一种稳健的方法是重复多次随机模型的评估实验。例如：

  1. scores = list()

  2. for i in repeats:

  3. train, test = random_split(data)

  4. model = fit(train.X, train.y)

  5. predictions = model.predict(test.X)

  6. skill = compare(test.y, predictions)

  7. scores.append(skill)

  8. final_skill = mean(scores)

表 12.2 评估随机模型技能的伪代码

这是我推荐的用于评估深度学习模型的模型技能的伪代码。

12.1.4 神经网络有多步稳定？

这取决于你的问题，取决于网络，以及它的配置。我建议进行敏感性分析来找出答案。在同一数据上对同一模型进行多次评估（30,100次或者数千次），只改变了随机数生成器的种子。然后回顾所产生的技能得分的平均值和标准差。标准差（平均得分与平均分数的距离）会让你知道你的模型有多不稳定。

12.1.5 多少次循环？

我建议至少30次，或许100次，甚至是上千次，限制的因素只有你的时间和电脑的资源（例如，平均技能的标准错误）。更严格地说，我将推荐一个实验，该实验着眼于估计模型技能对重复次数和标准误差计算的影响（平均估计性能与真实基础种群平均值的差异）。

12.1.6 模型估计之后

评估你的模型是达到目的的一种手段。它帮助你选择使用哪个模型以及使用哪些超参数来配置它。一旦你选择了一个模型，你就必须初始化它。这包括将模型拟合在所有可能的数据上，并保存在以后用于预测新数据的位置上，我们不知道实际结果。在后面的章节中，我们将更详细地介绍模型最终的过程。

12.2 诊断欠拟合和过拟合

在本章节中，你将会发现如何在训练期间使用LSTM模型的学习曲线图来诊断多拟合和欠拟合。

12.2.1 在Keras中训练历史

你可以通过回顾模型的性能来了解模型的行为。通过调用fit()函数来训练LSTM模型。此函数返回一个名为history的变量，它包括损失的踪迹以及在编译模型期间指定的任何其他度量。这些分数记录在每一个周期的末尾。

  1. ...

  2. history = model.fit(...)

表 12.3 在拟合一个LSTM模型之后分配历史的例子

例如，如果你的模型被编译来优化对数损失（binary_crossentropy）并衡量每个周期的准确率，那么对数损失和准确率将被计算并记录在每个训练周期的历史轨迹中。每一个分数由调用fit()函数返回。默认情况下，当拟合模型被称为损失和准确率时，损失被称为acc。

  1. ...

  2. model.compile(loss= 'binary_crossentropy' , optimizer= adam , metrics=[ 'accuracy' ])

  3. history = model.fit(X, Y, epochs=100)

  4. print(history.history[ 'loss' ])

  5. print(history.history[ 'acc' ])

表 12.4 在拟合LSTM模型之后打印历史的例子

Keras还允许你指定一个单独的验证数据集，同时也可以使用相同的损失和度量来评估模型。这可以通过在fit()函数上设置validation_split参数来实现，将训练数据的一部分用作验证数据集（特别是0到1之间的常量）。

  1. ...

  2. history = model.fit(X, Y, epochs=100, validation_split=0.33)

表 12.5 在训练数据子集计算验证损失的例子历史

这也可以通过设置验证数据参数和传递X和y数据集的元组来完成。

  1. ...

  2. history = model.fit(X, Y, epochs=100, validation_data=(valX, valY))

表 12.6 在新数据集上包含验证损失的例子历史

在验证数据集上评估的度量使用相同的名称和val_前缀。

  1. ...

  2. model.compile(loss= binary_crossentropy , optimizer= adam , metrics=[ accuracy ])

  3. history = model.fit(X, Y, epochs=100, validation_split=0.33)

  4. print(history.history[ 'loss' ])

  5. print(history.history[ 'acc' ])

  6. print(history.history[ 'val_loss' ])

  7. print(history.history[ 'val_acc' ])

表 12.7 打印训练和验证损失和准确率的例子

12.2.2 诊断图

你的LSTM模型的训练历史可以用来诊断模型的行为。可以使用Matplotlib库绘制模型的性能。例如，你可以将训练损失和测试损失计分如下：

  1. from matplotlib import pyplot

  2. ...

  3. history = model.fit(X, Y, epochs=100, validation_data=(valX, valY)) pyplot.plot(history.history[ loss ])

  4. pyplot.plot(history.history[ val_loss ])

  5. pyplot.title( 'model train vs validation loss' )

  6. pyplot.ylabel( 'loss' )

  7. pyplot.xlabel( 'epoch' )

  8. pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )

  9. pyplot.show()

表 12.8 显示训练和验证损失和准确率的例子

创建和审阅这些图可以帮助你了解可能的新配置以尝试从模型中获得更好的性能。接下来，我们来看一些例子。我们将考虑在损失最小化的训练和验证集的模型技能。

12.2.3 欠拟合

欠拟合模型是一个在训练集上表现很好，但是在测试集上表现很差的模型。这可以从训练损失低于验证损失的图中诊断，验证损失有一个趋势，表明进一步的改进是可能的。下面提供了一个小型的LSTM模型。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from numpy import array

  6. # return training data

  7. def get_train():

  8. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  9. seq = array(seq)

  10. X, y = seq[:, 0], seq[:, 1]

  11. X = X.reshape((len(X), 1, 1))

  12. return X, y

  13. # return validation data

  14. def get_val():

  15. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  16. seq = array(seq)

  17. X, y = seq[:, 0], seq[:, 1]

  18. X = X.reshape((len(X), 1, 1))

  19. return X, y

  20. # define model

  21. model = Sequential()

  22. model.add(LSTM(10, input_shape=(1,1)))

  23. model.add(Dense(1, activation= 'linear' ))

  24. # compile model

  25. model.compile(loss= 'mse' , optimizer= 'adam')

  26. # fit model

  27. X,y = get_train()

  28. valX, valY = get_val()

  29. history = model.fit(X, y, epochs=100, validation_data=(valX, valY), shuffle=False)

  30. # plot train and validation loss

  31. pyplot.plot(history.history[ 'loss' ])

  32. pyplot.plot(history.history[ 'val_loss' ])

  33. pyplot.title( 'model train vs validation loss' )

  34. pyplot.ylabel( 'loss' )

  35. pyplot.xlabel( 'epoch' )

  36. pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )

  37. pyplot.show()

表 12.9 欠拟合LSTM显示训练和验证损失的例子

运行例子产生训练和验证损失的图，该图显示了一个欠拟合的模型。在这种情况下，表现将会通过增加训练的周期增加。

图 12.1 需要更多训练的欠拟合诊断模型线图

另一方面，如果训练集上的性能优于验证集，性能已经趋于稳定，则模型可能欠拟合。下面是一个存储单元不足的欠拟合的模型。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from numpy import array

  6. # return training data

  7. def get_train():

  8. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  9. seq = array(seq)

  10. X, y = seq[:, 0], seq[:, 1]

  11. X = X.reshape((5, 1, 1))

  12. return X, y

  13. # return validation data

  14. def get_val():

  15. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  16. seq = array(seq)

  17. X, y = seq[:, 0], seq[:, 1]

  18. X = X.reshape((len(X), 1, 1))

  19. return X, y

  20. # define model

  21. model = Sequential()

  22. model.add(LSTM(1, input_shape=(1,1)))

  23. model.add(Dense(1, activation= 'linear' ))

  24. # compile model

  25. model.compile(loss= 'mae' , optimizer= 'sgd' )

  26. # fit model

  27. X,y = get_train()

  28. valX, valY = get_val()

  29. history = model.fit(X, y, epochs=300, validation_data=(valX, valY), shuffle=False)

  30. # plot train and validation loss

  31. pyplot.plot(history.history[ 'loss' ])

  32. pyplot.plot(history.history[ 'val_loss' ])

  33. pyplot.title( 'model train vs validation loss' )

  34. pyplot.ylabel( 'loss' )

  35. pyplot.xlabel( 'epoch' )

  36. pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )

  37. pyplot.show()

表 12.10 一个欠拟合LSTM显示训练和验证损失的例子

运行这个例子显示了欠拟合模型供应不足的特征。在这种情况下，可以通过增加模型的容量来提高性能，例如隐藏层中的存储单元的数目或者隐藏层的数目。

图 12.2 需要较大模型的欠拟合模型的诊断图

12.2.4 刚好拟合

刚好拟合的情况是模型的性能在训练集和测试集上都很好。这可以从训练和验证损失减少和稳定在同一个点附近的图中被诊断出来。下面的小例子演示了一个适合的LSTM模型。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from numpy import array

  6. # return training data

  7. def get_train():

  8. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  9. seq = array(seq)

  10. X, y = seq[:, 0], seq[:, 1]

  11. X = X.reshape((5, 1, 1))

  12. return X, y

  13. # return validation data

  14. def get_val():

  15. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  16. seq = array(seq)

  17. X, y = seq[:, 0], seq[:, 1]

  18. X = X.reshape((len(X), 1, 1))

  19. return X, y

  20. # define model

  21. model = Sequential()

  22. model.add(LSTM(10, input_shape=(1,1)))

  23. model.add(Dense(1, activation= 'linear' ))

  24. # compile model

  25. model.compile(loss= 'mse' , optimizer= 'adam' )

  26. # fit model

  27. X,y = get_train()

  28. valX, valY = get_val()

  29. history = model.fit(X, y, epochs=800, validation_data=(valX, valY), shuffle=False)

  30. # plot train and validation loss

  31. pyplot.plot(history.history[ 'loss' ])

  32. pyplot.plot(history.history[ 'val_loss' ])

  33. pyplot.title( 'model train vs validation loss' )

  34. pyplot.ylabel( 'loss' )

  35. pyplot.xlabel( 'epoch' )

  36. pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )

  37. pyplot.show()

表 12.11 刚好拟合显示训练和验证损失的例子

运行例子创建了一个显示训练和验证损失相遇的线图。理想情况下，我们希望看到模型性能，如果可能的话，虽然在很多的数据上这可能是不可能的挑战性问题。

图 12.3 刚好拟合模型的诊断线图

12.2.5 过拟合

过拟合模型是在训练集上的性能是良好的，并持续改善，而验证集上的性能提高到一个点，然后开始下降。这可以从训练损失斜率下降，验证损失斜率下降，达到拐点，并开始再次上升的情节中被诊断出来。下面的例子演示了一个过拟合的LSTM模型。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from numpy import array

  6. # return training data

  7. def get_train():

  8. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  9. seq = array(seq)

  10. X, y = seq[:, 0], seq[:, 1]

  11. X = X.reshape((5, 1, 1))

  12. return X, y

  13. # return validation data

  14. def get_val():

  15. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  16. seq = array(seq)

  17. X, y = seq[:, 0], seq[:, 1]

  18. X = X.reshape((len(X), 1, 1))

  19. return X, y

  20. # define model

  21. model = Sequential()

  22. model.add(LSTM(10, input_shape=(1,1)))

  23. model.add(Dense(1, activation= 'linear' ))

  24. # compile model

  25. model.compile(loss= 'mse' , optimizer= 'adam' )

  26. # fit model

  27. X,y = get_train()

  28. valX, valY = get_val()

  29. history = model.fit(X, y, epochs=1200, validation_data=(valX, valY), shuffle=False)

  30. # plot train and validation loss

  31. pyplot.plot(history.history[ 'loss' ][500:])

  32. pyplot.plot(history.history[ 'val_loss' ][500:])

  33. pyplot.title( 'model train vs validation loss' )

  34. pyplot.ylabel( 'loss' )

  35. pyplot.xlabel( 'epoch' )

  36. pyplot.legend([ 'train' , 'validation' ], loc= 'upper right' )

  37. pyplot.show()

表 12.12 一个拟合LSTM显示训练和验证损失的例子

图 12.4 显示过拟合的诊断线图

12.2.6 多次运行

LSTM是随机的，这意味着每一次运行的时候你都会得到一个不同的诊断图。重复多次的诊断运行是有用的（例如5,10或30）。然后，可以从每次运行中绘制出训练和验证轨迹，以得出随着时间推移模型的行为的更稳健的思想。下面的例子运行相同的实验多次，然后绘制每一次运行的训练轨迹和验证损失。

图 12.5 多次运行模型的诊断线图

12.3 构建调参问题

本节概述了调整序列预测问题框架要考虑的最大杠杆作用的区域。

12.3.1 值缩放

评估不同数据值缩放方案对你的模型技能的影响。请记住在第一个隐藏层和/或输出层上更新激活函数，以处理作为输入或预测输出的值的范围。尝试的一些方案包括：

  • 规范化值；

  • 标准化值；

12.3.2 值编码

评估不同值编码对你模型技能的影响。标签序列，如字符或单词，通常是整数编码和one hot编码。假设这是对序列预测问题最熟练的方法。尝试一些编码方案包括：

  • 实值编码；

  • 整数编码

  • one hot编码。

12.3.3 稳定性

当使用一系列实际值，如时间序列时，考虑使序列平稳。

  • 删除趋势。如果该系列包含均值的方差（例如趋势），则可以使用差分。

  • 删除季节性。如果该系列包含周期性的周期（例如季节性），则可以使用季节性调整。

  • 删除方差。如果该系列包含一个递增或递减的方差，可可以使用日志或者Box-Cox变换。

12.3.4 输入序列长度

输入序列长度的选择困难 针对你的问题域，尽管有时它可能是你选择LSTM框架的一部分。评估使用不同输入序列长度对你模型技能的影响。记住，输入序列的长度也会影响在更新权重时用于估计误差梯度的时间的反向传播。它可以影响模型学习的速度和所学的知识。

12.3.5 序列模型类型

对于给定的序列预测问题有4个主要的模型序列类型：

  • One-to-one；

  • One-to-many；

  • Many-to-one；

  • Many-to-many。

Keras支持所有这些类型。使用每个序列模型类型来对问题进行构建，并评估模型技能，以帮助为你的问题选择框架。

12.4 模型结构调优

本节概述了调整LSTM模型结构时最大杠杆作用的一些方面。

12.4.1 结构

正如我们所看到的，有许多的LSTM体系结构可供选择。一些体系结构适用于某些序列预测问题，尽管大多数是足够的，以使它们适合于序列预测问题。测试你对结构实用性的假设。在你的序列预测问题中，评估本书中列出的每一个LSTM结构的技能（也许超出了）。

12.4.2 存储单元

对于给定的序列预测问题或者LSTM体系结构，我们不能知道存储单元的最佳数目是多少。必须在LSTM隐藏层中测试一组不同的存储单元，以查看哪些工作最有效。

  • 尝试网格搜索存储单元的数目为100s、10s或者更细；

  • 尝试事宜在研究论文中引用的单元数量；

  • 尝试随机搜索1到1000之间的单元格数量。

我经常看到像100或1000那样的原先存储单元。我想这些都是一时兴起选择的。下面是网格搜索的第一个隐藏LSTM层中存储单元1,5或10的数目的小例子，其中有少量的重复（5）。你可以用这个作为你自己试验的模板。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from pandas import DataFrame

  6. from numpy import array

  7. # return training data

  8. def get_train():

  9. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  10. seq = array(seq)

  11. X, y = seq[:, 0], seq[:, 1]

  12. X = X.reshape((5, 1, 1))

  13. return X, y

  14. # return validation data

  15. def get_val():

  16. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  17. seq = array(seq)

  18. X, y = seq[:, 0], seq[:, 1]

  19. X = X.reshape((len(X), 1, 1))

  20. return X, y

  21. # fit an LSTM model

  22. def fit_model(n_cells):

  23. # define model

  24. model = Sequential()

  25. model.add(LSTM(n_cells, input_shape=(1,1)))

  26. model.add(Dense(1, activation= 'linear' ))

  27. # compile model

  28. model.compile(loss= 'mse' , optimizer= 'adam' )

  29. # fit model

  30. X,y = get_train()

  31. history = model.fit(X, y, epochs=500, shuffle=False, verbose=0)

  32. # evaluate model

  33. valX, valY = get_val()

  34. loss = model.evaluate(valX, valY, verbose=0)

  35. return loss

  36. # define scope of search

  37. params = [1, 5, 10]

  38. n_repeats = 5

  39. # grid search parameter values

  40. scores = DataFrame()

  41. for value in params:

  42. # repeat each experiment multiple times

  43. loss_values = list()

  44. for i in range(n_repeats):

  45. loss = fit_model(value)

  46. loss_values.append(loss)

  47. print( '>%d/%d param=%f, loss=%f' % (i+1, n_repeats, value, loss))

  48. # store results for this parameter

  49. scores[str(value)] = loss_values

  50. # summary statistics of results

  51. print(scores.describe())

  52. # box and whisker plot of results

  53. scores.boxplot()

  54. pyplot.show()

表 12.14 网格搜索存储单元的数量的例子

运行例子打印搜索每次迭代的过程。每一个存储单元的结果的汇总统计在末尾显示。

  1. >1/5 param=1.000000, loss=0.047335

  2. >2/5 param=1.000000, loss=0.146885

  3. >3/5 param=1.000000, loss=0.104599

  4. >4/5 param=1.000000, loss=0.345472

  5. >5/5 param=1.000000, loss=0.115182

  6. >1/5 param=5.000000, loss=0.020112

  7. >2/5 param=5.000000, loss=0.084113

  8. >3/5 param=5.000000, loss=0.042612

  9. >4/5 param=5.000000, loss=0.070742

  10. >5/5 param=5.000000, loss=0.038660

  11. >1/5 param=10.000000, loss=0.040568

  12. >2/5 param=10.000000, loss=0.009704

  13. >3/5 param=10.000000, loss=0.064492

  14. >4/5 param=10.000000, loss=0.017800

  15. >5/5 param=10.000000, loss=0.012813

  16. 1 5 10

  17. count 5.000000 5.000000 5.000000

  18. mean 0.151895 0.051248 0.029075

  19. std 0.114033 0.025801 0.023202

  20. min 0.047335 0.020112 0.009704

  21. 25% 0.104599 0.038660 0.012813

  22. 50% 0.115182 0.042612 0.017800

  23. 75% 0.146885 0.070742 0.040568

  24. max 0.345472 0.084113 0.064492

表 12.15 网格搜索存储单元的数量输出的例子

最后结果的箱线图被创建来比较每种不同的模型配置的模型技能分布。

图 12.6 调整存储单元结果的箱线图

12.4.3 隐藏层

与存储单元的数目一样，对于给定的序列预测问题或LSTM体系结构，我们不能知道LSTM隐藏层的最佳数量。当你有很多数据时，越深越好。

  • 尝试一起网格搜索层数和存储单元；

  • 尝试使用堆叠LSTM层在研究论文中引用的模式；

  • 尝试一起随机搜索层数和存储单元。

创建深度卷积神经网络（CNNs）是有模式的。我没有看见过任何复杂的模式，LSTM超出encoder-decoder模式。我认为这是一个有待探索的大问题。你能设计出总体上工作良好的stacked LSTM吗？

12.4.4 权重初始化

Keras的LSTM层默认使用 glorot_uniform做权重的初始化。总体来说，这个权重初始化运行得很好，但是我已经使用LSTM的正常类型权重初始化取得了很大的成功。评估不同的权重初始化方案对您的模型技能的影响。Keras提供了一个很好的权重初始化列表供您尝试。至少，比较这始终方法的技巧：

  • random_uniform

  • random_normal

  • glorot_uniform

  • glorot_normal

12.4.5 激活函数

激活函数（技术上是传递神经元的加权激活时的传递函数）通常由输入层或输出层的框架和尺度来固定。例如，LSTM使用sigmoid激活函数作为输入并且因此输入通常在0-1的刻度中。序列预测问题的分类或者回归性质决定了在输出层中使用激活函数的类型。挑战LSTM层中默认的sigmoid激活函数。也许在重新调整输入值的同时，尝试使用其他的方法。例如，尝试：

  • sigmoid

  • tanh

  • relu

此外，挑战在一个stacked LSTM中所有的LSTM层是否需要使用相同的激活函数。在实践中，我很少看到一个模型比使用sigmoid更好，但是这个假设应该需要得到证实。

12.5 调优学习行为

本章节概述了调整LSTM模型学习行为时的最大杠杆作用的一些方面。

12.5.1 优化算法

梯度下降的一个很好的默认实现是用Adam算法。这是因为它结合AdaGrad和RMSProp方法的最佳属性自动为模型中的每个参数（权重）使用自定义学习率。此外，在Keras中使用每个配置参数的最佳实践初始值实现Adam。

然而，挑战Adam是你的模型的正确的梯度下降算法。用不同的梯度下降算法评估模型的性能。现代算法的一些思想包括：

  • Adam

  • RMSprop

  • Adagrad

12.5.2 学习率

学习率控制权重更新多少，作为在每个批次结束时响应估计的梯度。这会对模型的学习率和模型之间的权衡产生很大的影响。考虑使用经典随机梯度下降（SGD）优化器，并探索不同的学习率和动量值，你可以评估不同的学习率的制度。

  • 网格搜索学习速率值（例如0.1， 0.001、0.0001）；

  • 学习速率衰减的周期（epoch）的实验（例如通过回调）；

  • 训练模型更新与训练的学习率越来越小的实验。

学习率和周期（通过训练样本的传递次数）紧密耦合。一般来说，学习率（例如0.0001）越小，就需要更多的训练周期。这是一个线性关系，所以反过来也是正确的，在更大的学习率需要更少的周期（例如0.1）。

12.5.3 批次大小

批次大小是模型权重更新之间的样本数。一个磨的默认批次大小是32个样本。

批次大小典型的选择是从1到几千，例如批次大小为32是一个好的默认值，利用矩阵成绩加速到矩阵向量乘积的值大于10。

— Practical Recommendations For Gradient-based Training Of Deep Architectures, 2012.

序列预测问题的数据量和帧的大小可能取决于批次大小的选择。然而，挑战你的最佳猜想并尝试一些替代的配置。

  • 随机梯度下降的批次大小为1；

  • 批次大小为n，其中n是批次梯度下降的样本数；

  • 网格搜索批大小为2的平方，从2到256不等。

较大的批次大小通吃会导致模型更快收敛，但可能会导致一个不太理想的权重集。批次大小为1（随机梯度下降）更新后，每个样本往往导致非常嘈杂的学习过程。下面是网格搜索的一个小例子，该批次大小为1、2和3，具有少量的重复（5）。你可以用这个例子作为自己试验的模板。

  1. from keras.models import Sequential

  2. from keras.layers import Dense

  3. from keras.layers import LSTM

  4. from matplotlib import pyplot

  5. from pandas import DataFrame

  6. from numpy import array

  7. # return training data

  8. def get_train():

  9. seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]

  10. seq = array(seq)

  11. X, y = seq[:, 0], seq[:, 1]

  12. X = X.reshape((5, 1, 1))

  13. return X, y

  14. # return validation data

  15. def get_val():

  16. seq = [[0.5, 0.6], [0.6, 0.7], [0.7, 0.8], [0.8, 0.9], [0.9, 1.0]]

  17. seq = array(seq)

  18. X, y = seq[:, 0], seq[:, 1]

  19. X = X.reshape((len(X), 1, 1))

  20. return X, y

  21. # fit an LSTM model

  22. def fit_model(n_batch):

  23. # define model

  24. model = Sequential()

  25. model.add(LSTM(10, input_shape=(1,1)))

  26. model.add(Dense(1, activation= 'linear' ))

  27. # compile model

  28. model.compile(loss= 'mse' , optimizer= 'adam' )

  29. # fit model

  30. X,y = get_train()

  31. history = model.fit(X, y, epochs=500, shuffle=False, verbose=0, batch_size=n_batch)

  32. # evaluate model

  33. valX, valY = get_val()

  34. loss = model.evaluate(valX, valY, verbose=0)

  35. return loss

  36. # define scope of search

  37. params = [1, 2, 3]

  38. n_repeats = 5

  39. # grid search parameter values

  40. scores = DataFrame()

  41. for value in params:

  42. # repeat each experiment multiple times

  43. loss_values = list()

  44. for i in range(n_repeats):

  45. loss = fit_model(value)

  46. loss_values.append(loss)

  47. print( '>%d/%d param=%f, loss=%f' % (i+1, n_repeats, value, loss))

  48. # store results for this parameter

  49. scores[str(value)] = loss_values

  50. # summary statistics of results

  51. print(scores.describe())

  52. # box and whisker plot of results

  53. scores.boxplot()

  54. pyplot.show()

表 12.16 网格搜索批次大小的例子

运行这个例子打印搜索每次迭代的进度。最后对每个配置结果进行汇总统计。

  1. >1/5 param=1.000000, loss=0.000524

  2. >2/5 param=1.000000, loss=0.003064

  3. >3/5 param=1.000000, loss=0.000918

  4. >4/5 param=1.000000, loss=0.001103

  5. >5/5 param=1.000000, loss=0.002519

  6. >1/5 param=2.000000, loss=0.000851

  7. >2/5 param=2.000000, loss=0.000069

  8. >3/5 param=2.000000, loss=0.000339

  9. >4/5 param=2.000000, loss=0.000048

  10. >5/5 param=2.000000, loss=0.001156

  11. >1/5 param=3.000000, loss=0.013446

  12. >2/5 param=3.000000, loss=0.001138

  13. >3/5 param=3.000000, loss=0.006436

  14. >4/5 param=3.000000, loss=0.002005

  15. >5/5 param=3.000000, loss=0.011653

  16. 1 2 3

  17. count 5.000000 5.000000 5.000000

  18. mean 0.001626 0.000493 0.006936

  19. std 0.001102 0.000492 0.005541

  20. min 0.000524 0.000048 0.001138

  21. 25% 0.000918 0.000069 0.002005

  22. 50% 0.001103 0.000339 0.006436

  23. 75% 0.002519 0.000851 0.011653

  24. max 0.003064 0.001156 0.013446

表 12.17 网格搜索批次大小输出的例子

最后结果的箱线图创建来用于比较每个不同配置的模型技能的分布。

图 12.7 调整批次大小结果的箱线图

12.5.4 正则化

在某些序列预测问题上，LSTM可以快速收敛，甚至过拟合。为了解决这个问题，可以使用正则化方法。Dropout在训练过程随机跳过神经元，迫使该层中的其他神经元来收拾残局。它简单有效。从dropout开始。Dropout率在0（不dropout）和1（完全dropout）之间，可以在通过两个不同的参数在LSTM层上设置：

  • dropout。dropout应用于输入连接。

  • recurrent_dropout。dropout应用于循环连接。

例如：

  1. model.add(LSTM(..., dropout=0.4))

表 12.18 用输入连接dropout添加一层的例子

一些需要去尝试的例子包括：

  • 网格搜索不同的dropout百分比；

  • 在输入、隐藏和输出层中进行dropout实验。

LSTM还支持其他形式的正则化，如权重规则化，施加压力以减少网络权重的大小。同样，这些参数可以在LSTM层上设置：

  • 偏置正则化：对偏置的正则化；

  • 核正则化：对输入权重的正则化；

  • 循环正则化：对循环权重的正则化。

你可以使用正则化类，如L1、L2或者L1L2正则化，而不是dropout的百分比。我建议使用L1L2，使用0和1之间的值，也允许模拟T1和T2方法。例如，你可以试试：

  • L1L2(0.0, 0.0)，例如，基准线或者无正则化；

  • L1L2(0.01, 0.0)，例如，L1;

  • L1L2(0.0, 0.01)，例如，L2;

  • L1L2(0.01, 0.01)，例如，L1L2也称为弹性网。

  1. model.add(LSTM(..., kernel_regularizer=L1L2(0.01, 0.01)))

表 12.19 用输入权重正则化添加一层的例子

在实践中，我们发现输入连接上的dropout和输入权重的正则化，从而导致更好的执行模型。

12.5.5 早停

训练周期的数量调优会非常的耗时间。另外一种方法是使大量的训练周期（epoch）称为可能。然后设置一些东西来检查模型在训练和验证数据集上的性能，如果模型看起来开始过度学习，停止训练。因此，早期停止是一种正则化，以抑制过度拟合。

你可以在Keras的早期停止实验中用一个EarlyStopping回调。它需要你指定一些参数配置，例如用于监视的度量（例如val-损失），在所观察到的次数上没有到的监视度量的改进（例如100）。在对模型进行训练时，将回调列表提供给fit()函数。例如：

  1. from keras.callbacks import EarlyStopping

  2. es = EarlyStopping(monitor= val_loss , min_delta=100)

  3. model.fit(..., callbacks=[es])

表 12.20 使用EarlyStopping回调的例子

赞 (0)

相关推荐