理解如何准备序列数据以输入到 LSTM 模型可能很困难。
通常,关于如何为 LSTM 模型定义输入层存在困惑。
关于如何将可能是 1D 或 2D 数字矩阵的序列数据转换为 LSTM 输入层所需的 3D 格式也存在困惑。
在本教程中,您将学习如何定义 LSTM 模型的输入层,以及如何为 LSTM 模型重塑已加载的输入数据。
完成本教程后,您将了解:
- 如何定义 LSTM 输入层。
- 如何为 LSTM 模型重塑一维序列数据并定义输入层。
- 如何为 LSTM 模型重塑多个并行序列数据并定义输入层。
通过我的新书《使用 Python 的长短期记忆网络》**启动您的项目**,其中包括**分步教程**和所有示例的 **Python 源代码**文件。
让我们开始吧。

如何在 Keras 中重塑长短期记忆网络的输入数据
图片由 全球景观论坛 提供,保留部分权利。
教程概述
本教程分为4个部分,它们是:
- LSTM 输入层
- 单输入样本的 LSTM 示例
- 多输入特征的 LSTM 示例
- LSTM 输入技巧
LSTM 输入层
LSTM 输入层通过网络第一个隐藏层上的“_input_shape_”参数指定。
这可能会让初学者感到困惑。
例如,下面是一个具有一个隐藏 LSTM 层和一个密集输出层的网络的示例。
1 2 3 |
model = Sequential() 模型。添加(LSTM(32)) 模型。添加(密集(1)) |
在此示例中,LSTM() 层必须指定输入数据的形状。
每个 LSTM 层的输入必须是三维的。
此输入数据的三个维度是:
- **样本**。一个序列是一个样本。一个批次由一个或多个样本组成。
- **时间步长**。一个时间步长是样本中的一个观察点。
- **特征**。一个特征是在一个时间步长进行的一次观察。
这意味着输入层在拟合模型和进行预测时期望一个 3D 数据数组,即使数组的特定维度包含单个值,例如一个样本或一个特征。
在定义 LSTM 网络的输入层时,网络假定您有一个或多个样本,并要求您指定时间步长和特征的数量。您可以通过向“_input_shape_”参数指定一个元组来完成此操作。
例如,下面的模型定义了一个输入层,该层预期 1 个或更多样本、50 个时间步长和 2 个特征。
1 2 3 |
model = Sequential() 模型。添加(LSTM(32, input_shape=(50, 2))) 模型。添加(密集(1)) |
现在我们知道了如何定义 LSTM 输入层以及 3D 输入的期望,让我们看一些如何为 LSTM 准备数据的示例。
单输入样本的 LSTM 示例
考虑您有一个具有多个时间步长和一个特征的序列的情况。
例如,这可能是一个包含 10 个值的序列
1 |
0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 |
我们可以将这个数字序列定义为一个 NumPy 数组。
1 2 |
from numpy import array 数据 = 数组([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]) |
然后,我们可以在 NumPy 数组上使用 _reshape()_ 函数将这个一维数组重塑为一个三维数组,其中包含 1 个样本、10 个时间步长和每个时间步长 1 个特征。
当对数组调用 _reshape()_ 函数时,它接受一个参数,该参数是一个定义数组新形状的元组。我们不能传递任何数字元组;重塑必须均匀地重新组织数组中的数据。
1 |
数据 = 数据。重塑((1, 10, 1)) |
重塑后,我们可以打印数组的新形状。
1 |
print(data.shape) |
综合所有这些,完整的示例如下所示。
1 2 3 4 |
from numpy import array 数据 = 数组([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]) 数据 = 数据。重塑((1, 10, 1)) print(data.shape) |
运行示例会打印单个样本新的 3D 形状。
1 |
(1, 10, 1) |
此数据现在可以作为输入(_X_)与 input_shape 为 (10, 1) 的 LSTM 一起使用。
1 2 3 |
model = Sequential() 模型。添加(LSTM(32, input_shape=(10, 1))) 模型。添加(密集(1)) |
多输入特征的 LSTM 示例
考虑您有多个并行序列作为模型输入的情况。
例如,这可能是两个包含 10 个值的并行序列
1 2 |
序列 1:0.1、0.2、0.3、0.4、0.5、0.6、0.7、0.8、0.9、1.0 序列 2:1.0、0.9、0.8、0.7、0.6、0.5、0.4、0.3、0.2、0.1 |
我们可以将这些数据定义为 2 列 10 行的矩阵
1 2 3 4 5 6 7 8 9 10 11 12 |
from numpy import array 数据 = 数组([ [0.1, 1.0], [0.2, 0.9], [0.3, 0.8], [0.4, 0.7], [0.5, 0.6], [0.6, 0.5], [0.7, 0.4], [0.8, 0.3], [0.9, 0.2], [1.0, 0.1]]) |
此数据可以被视为 1 个样本、10 个时间步长和 2 个特征。
它可以重塑为如下所示的 3D 数组
1 |
数据 = 数据。重塑(1, 10, 2) |
综合所有这些,完整的示例如下所示。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from numpy import array 数据 = 数组([ [0.1, 1.0], [0.2, 0.9], [0.3, 0.8], [0.4, 0.7], [0.5, 0.6], [0.6, 0.5], [0.7, 0.4], [0.8, 0.3], [0.9, 0.2], [1.0, 0.1]]) 数据 = 数据。重塑(1, 10, 2) print(data.shape) |
运行示例会打印单个样本新的 3D 形状。
1 |
(1, 10, 2) |
此数据现在可以作为输入(_X_)与 input_shape 为 (10, 2) 的 LSTM 一起使用。
1 2 3 |
model = Sequential() 模型。添加(LSTM(32, input_shape=(10, 2))) 模型。添加(密集(1)) |
更长的示例
有关准备数据的完整端到端示例,请参阅此帖子
LSTM 输入技巧
本节列出了一些提示,可帮助您为 LSTM 准备输入数据。
- LSTM 输入层必须是 3D 的。
- 3 个输入维度的含义是:样本、时间步长和特征。
- LSTM 输入层通过第一个隐藏层上的 _input_shape_ 参数定义。
- _input_shape_ 参数接受一个包含两个值的元组,这些值定义了时间步长和特征的数量。
- 样本数量假定为 1 或更多。
- NumPy 数组上的 _reshape()_ 函数可用于将您的 1D 或 2D 数据重塑为 3D。
- _reshape()_ 函数接受一个元组作为参数,该元组定义了新形状。
进一步阅读
如果您想深入了解此主题,本节提供了更多资源。
总结
在本教程中,您学习了如何定义 LSTM 的输入层以及如何重塑序列数据以输入到 LSTM。
具体来说,你学到了:
- 如何定义 LSTM 输入层。
- 如何为 LSTM 模型重塑一维序列数据并定义输入层。
- 如何为 LSTM 模型重塑多个并行序列数据并定义输入层。
你有什么问题吗?
在下面的评论中提出你的问题,我会尽力回答。
对维度解释得很好!只是想说这个解释也适用于 Tensorflow 中的 LSTM 模型。
谢谢,Steven。
嗨,Jason,
非常感谢您的解释。
我有一个困惑如下:
假设我们有多个并行序列作为模型输入。第一步是将这些数据定义为 M 列 N 行的矩阵。要实现 3D(样本、时间步长和特征),这意味着样本:1 个样本,时间步长:矩阵的行数,特征:矩阵的列数?必须是这样吗?期待您的回复。谢谢!
抱歉,我不确定我是否理解您的问题。
如果您有并行时间序列,那么每个序列都需要相同数量的时间步长,并表示为单独的特征(例如,一个时间点的一次观察)。
这有帮助吗?
同意 Yuan 的观点
嗨,Yuan,
我明白了你的问题。你怀疑我们是否可以说行数是时间步长,列数是特征。是的,你也可以这样理解。
也就是说,样本、时间步长和特征分别等同于样本、行数和列数。
你好先生,
我使用你的多元代码测试了 lstm 模型。它运行良好,但我没有理解为什么 lstm 的一行会从训练和测试数据集中隐藏。如果我测试测试集中的两行,则得到一个预测作为输出。以及日期时间输出这个预测结果?
请帮帮我。
提前感谢。
阿扎德
抱歉,我没跟上。
您能否详细说明您的问题?
嗨 Jason,你的文章非常鼓舞人心。
我现在正在从事贷款风险控制工作。我每个时期都有客户还款时间差。我正在尝试使用时间序列模型对之前的时间差进行预测,以预测客户是否会逾期。
假设我有 10000 个客户,每个客户有 6 个时期的还款时间差。正如您在文章中写的,我的输入数据最初是 (10000*6)。在我将其发送到 LSTM 模型之前,我应该将其重塑为 10000*6*1 的 3D 数据集吗?这是正确的做法吗?如果您对这个问题有任何其他经验,也请告诉我。
听起来会是 [10000, 6, 1]
嗨,我认为 wanghy 想做贷款风险预测。
客户应该为每笔贷款支付 6 期还款。
因此,如果您使用 [10000,6,1] 训练模型,
在完成 3 次还款后,如何输入数据进行预测?
也许您可以基于零个或更多输入时间步长进行一步预测,并使用零填充来填充输入?
例如:
谢谢 jason
我仍然对时间步长感到困惑。
假设客户为每笔贷款支付 240 期还款(20 年),并且贷款风险与最近一年的还款有关。
那么,训练数据应该是 [行数, 12, 1] 而不是 [行数, 240, 1],对吗?
有时,时间步长和特征的值非常大,例如 1024、512。
当内存不足时,如何选择时间步长值?
这解释得很好
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
试错法是一个很好的方法,尝试不同问题的框架,看看哪个效果最好。
非常感谢
先生,我正在研究预测问题,我有一个 8000 个元素的 1D 列实验数据,以及沿空间坐标分布的 3D 数据,如 [x y z 值]。现在我很困惑如何使用我的 1D 数据和 3D 数据进行预测。
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
非常感谢您提供的所有解释!
我尝试理解重塑参数的效果以及在 spyder/变量浏览器中的效果。但是我不明白数据窗口中显示的结果。
我使用了另一个教程中的代码
数据 = 数组([
[0.1, 1.0],
[0.2, 0.9],
[0.3, 0.8],
[0.4, 0.7],
[0.5, 0.6],
[0.6, 0.5],
[0.7, 0.4],
[0.8, 0.3],
[0.9, 0.2],
[1.0, 0.1]])
data_re = data.reshape(1, 10, 2)
在 spyder 的变量浏览器中检查结果时,我看到了数组的 3 个维度,但无法将其与参数样本、时间步长、特征连接起来。
在 data_re 的轴 0 上,我看到了完整的数据集
在 data_re 的轴 1 上,我在第 1 列中得到 0.1 和 1.0
在 data_re 的轴 2 上,我看到了轴 0 的第 1 列转置到第 1 行
您能给我一些关于如何解释它的提示吗?
此致,
奥利弗。
没有命名的参数,我用这些名称来指代维度,因为 LSTM 模型就是这样使用数据的。
很抱歉造成困惑。
嗨,Jason,
非常感谢这篇文章(实际上是整个系列)!Keras 的文档在很多方面都不太清楚。
我一直在尝试实现一个模型,该模型接收多个多元时间序列样本作为输入。问题是,序列的长度,即“时间步长”维度,对于不同的样本是不同的。我尝试单独对每个样本训练模型然后合并(但这样每个 LSTM 都会非常容易过拟合)。另一个想法是将样本缩放到相同的时间步长,但这会带来每个样本时间步长的缩放因子,这也不是很理想。
有没有办法为 LSTM 提供具有动态时间步长的样本?也许使用更低级别的 API?
此致,
佐贺
我经常使用的一种方法是将所有序列填充到相同的长度,并在前端使用掩码层来忽略被掩码的时间步长。
嗨 Jason,
感谢这篇精彩的文章。
我这里有同样的问题。也就是样本有许多不同的长度。
我没有理解你说的意思。
“我经常使用的一种方法是将所有序列填充到相同的长度,并在前端使用掩码层来忽略被掩码的时间步长。”
你能提供更多细节吗?
或者提供文章解释如何解决这个问题。
先谢谢您了。
这些示例将向您展示如何截断和填充序列数据
https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
嗨,Jason,
非常感谢您的 LSTM 教程。我正在尝试从 10 个不同的并行时间序列预测一个时间序列。它们都是不同的 1D 序列。因此,我的 X_train 的形状是 (50000,10),Y_train 的形状是 (50000,1)。如果我想使用例如 100 个时间步长或回溯 100,我无法弄清楚如何重塑我的数据集和 LSTM 的输入形状。
谢谢。
这篇文章将帮助您将序列构建为监督学习问题
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
尊敬的先生
我想使用 LSTM RNN GRU 来检查观看电影的人面部表情的变化。想检查他的心理状态,无论是厌倦还是有兴趣继续看这部电影,或者他在什么时间点感到厌倦。您能帮我如何开始做这件事吗?
这听起来是个很棒的问题。我建议从收集大量的训练数据开始。
然后考虑在 LSTM 的前端使用 CNN。
你好,
我总共有大约 12,000 条推文用于情感分类。您认为 16GB CPU 内存足够吗?
当然可以。
嗨 Jason
感谢您的简单解释。
但是,我有一个疑问。如果不知道时间步数怎么办?您将如何处理?
这就是我们使用嵌入层的原因吗?
我打算将其用于 IMDB 电影评论数据集的情感分析。
您可以通过填充/截断强制所有输入序列的长度相同。
您也可以使用不指定输入长度的模型,例如
https://machinelearning.org.cn/develop-encoder-decoder-model-sequence-sequence-prediction-keras/
嗨,Jason,
我终于理解了输入形状的要求。
一个小问题:batch_size 将是组内一定数量的样本,例如,如果我们有 100 个样本,我们可以将其分成 10 个批次。批处理有助于加快训练时间,对吗?
没错,权重更新和状态重置发生在每个批次结束时。
嗨,Jason,
关于样本(reshape 中的第一个参数):如果我有两个具有不同值数量的序列(假设一个有 10 个值,另一个有 8 个),并且希望它们被视为两个不同的样本(而不是 2 个特征),是否需要零填充?
序列 1:0.1、0.2、0.3、0.4、0.5、0.6、0.7、0.8、0.9、1.0
系列 2:1.0、0.9、0.8、0.7、0.6、0.5、0.4、0.3、0.0、0.0
如果我这样做
数据 = data.reshape(2, 10, 1)
它会将其理解为 2 个不同的样本吗?
是的,填充到 10 个时间步长。
是的,你的重塑看起来不错。
探索前置和后置填充,看看它对你的模型是否会产生影响。
有了这个输入,模型会理解两个不同的序列吗?
为什么不使用 (1, 10, 2) 形状?
你可以把它们看作是两个特征,就像你建议的那样,我以为它们是独立的样本。
嗨,Jason,
非常感谢本教程!
我正在努力理解 LSTM 数据的输入形状(时间步长和特征数量)。请问,在 iris 数据集的上下文中,它们各自会是什么?
我是否可以说在 iris 数据集中,时间步长可以是 2、3、5、6——只要它能将数据集整齐地分成等量的行(iris 有 150 行)。
特征的数量将是列的数量(除了目标列/类别)吗?
非常感谢!
Iris 数据集不是序列分类问题。它没有时间步长,只有样本和特征。
你好!
首先,非常感谢您的帖子,我学到了很多。
我的问题是,我不确定如何处理下一类问题:多个特征的多个序列。
例如,根据之前的购买情况预测用户可能花费的金额(这里我可以考虑不同的特征,例如之前的金额、产品、星期几等)。如果我有一个包含 1000 个用户数据的数据集,并且我想预测每个用户的金额,应该如何解决?
我可以使用一个 lstm 适用于所有用户,还是每个用户都将拥有一个模型/lstm?
我明白一个 lstm 适用于所有用户可能会看到更有趣的东西……但我不知道如何组织不同用户的输入……因为两个序列的示例(1,10,2)我不知道如何应用……我想为每个序列包含更多特征……
我非常迷茫……
提前感谢你
也许可以从建模单个用户开始?
谢谢!
通过建模单个用户,您是指每个用户一个 LSTM 吗?
有些用户有 200 笔购买,但其他用户只有 10 笔……这足够吗?
我会试试的!
谢谢!
或者每个样本一个用户。
我也有同样的问题。这快把我逼疯了!
日期时间 用户 ID 特征 1 特征 2 特征 3 …
2018-01-01 0 1 2 3 …
2018-01-20 0 3 49 15 …
2018-01-01 1 1 5 8 …
20118-02-25 1 3 5 15 …
目标
用户 ID 目标
0 0
1 1
我想我有两种方法:一种是使用 DL 模型(可能是 LSTM),但我不确定如何组织训练集。另一种方法是通过用户 ID 对特征进行分组并应用类别特征(之前进行 one-hot 编码)的计数,然后应用决策树模型
您是如何解决的??
您可能需要在建模之前转换数据。
例如,按天、周或月间隔的用户先前操作序列和用户目标输出。也许输入序列使用零填充。
嗨,Jason,
感谢您的教程和书籍!
我不确定如何设计下表的输入形状或数据框
日期,产品,商店,是否有促销,属性1,属性2,数量(t)
前三列是关键。我们有 20 家商店的 50000 种产品,我想用 LSTM 预测至少提前 14 天的(每种产品每家商店的)数量。
3D 输入的良好起点是什么?
我正在考虑是否可以从日期(因为有重复)创建新特征,例如星期几、月份中的日期、一年中的月份等 + 现有特征 + 数量(t),数量(t+1)…
提前感谢您的帮助!
此致,
去掉日期,你就有了 6 个特征,这有帮助吗?
好的,谢谢。如果销售额存在季节性和趋势,我是否也应该在训练 LSTM 之前将其删除?
是的,我建议这样做。
你好!
非常感谢您提供了大量关于 LSTM 的教程
我正在尝试使用您的示例在 keras 中构建一个 LSTM,并不断遇到形状问题。
我有一个包含不同商品价格的时间序列数据集,并尝试预测时间 t+1 的 item4 价格
Item4 是一个滞后值,因此您可以使用之前的价格集来预测下一个。
数据集有 400 个顺序观测值。
变量:日期时间 price1 price2 price3 item4_price
由于数据变量具有统一的观测间隔且没有缺失值,因此我将删除日期时间变量。
所以现在我有 4 个变量和 400 个观测值。
trainX = train[:, 0:-1] #使用前 3 个变量
trainY = train[:,-1] #使用最后一个变量
所以现在 trainX 数据集有 price1 price2 和 price3 变量(我的理解是这意味着 keras 中有 3 个“特征”)
trainY 是预测器数据集,只包含 item4_price
trainX = numpy.reshape(trainX, (1, 400, 3)) #重塑,这意味着有 1 个样本,400 个时间戳和 3 个特征
model = Sequential()
model.add(LSTM(5, input_shape=(1, 400, 3), return_sequences=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
无论我做什么,都会不断收到各种形状错误。我尝试过切换,甚至省略了第一个维度。
我想知道您是否可以指出我理解 keras/lstm 形状时一直遗漏了什么。
我也不知道 trainY 集是否需要整形?我也尝试过整形,但 python 也对此不满意。
告诉我你的想法!
谢谢,
维克
或许可以从一个系列开始,真正弄清楚需要什么。
你尝试过这个教程吗
https://machinelearning.org.cn/prepare-univariate-time-series-data-long-short-term-memory-networks/
布朗利博士,您好,
我之前读过那个教程,感觉自己理解得很好。
但是,当将我学到的知识以之前描述的方式应用到问题中时,我发现遇到了一些麻烦。
所以我希望我只是忽略了一些东西,但目前我真的不确定是什么。我正在做的事情看起来合理吗?
谢谢!
也许吧,但我不像你那样了解你的问题,也没有固定的方法来解决任何机器学习问题。
我鼓励你集思广益,尝试一系列方法,看看哪种效果最好。
嗨,Jason,
我已阅读本教程,但我的输入大小为 1762 X 4,输出大小为 1762 X 1。
我按照如下操作,但 y 训练的形状是 (1394, 4),它应该是 (1394,1)。
你能帮帮我吗?
抱歉,我无法为您调试代码。我实在没有这个能力,相信您能理解。
也许可以将您的错误发布到 stackoverflow 或 cross validated 吗?
我收到了一个异常:“ValueError: Input arrays should have the same number of samples as target arrays. Found 1 input samples and 21 target samples”。
=>打印 X_train
[[ 0.15699646 -1.59383227]
[-0.31399291 -0.03680409]
[ 0.15699646 -1.59383227]
[-0.31399291 0.78456757]
[ 0.15699646 -1.59383227]
[ 4.39590078 -1.59383227]
[-0.31399291 1.38764971]
[-0.31399291 -0.03680409]
[-0.31399291 -0.32252408]
[-0.31399291 0.6081381 ]
[-0.31399291 -0.32252408]
[-0.31399291 1.38764971]
[-0.31399291 0.78456757]
[-0.31399291 -0.03680409]
[-0.31399291 0.78456757]
[ 0.15699646 1.24889926]
[-0.31399291 -0.32252408]
[-0.31399291 1.24889926]
[-0.31399291 -0.69488163]
[-0.31399291 -0.69488163]
[-0.31399291 0.6081381 ]]
=>打印 y_train
0 1
1 1
2 1
3 1
4 1
5 1
6 1
7 0
8 0
9 0
10 0
11 0
12 0
13 0
14 1
15 1
16 1
17 1
18 0
19 0
20 0
名称:out,数据类型:int64
=>打印(y_train.shape)
(21,)
=>打印 X_train.shape
(21, 2)
=>打印 X_test.shape
(8, 2)
我已将输入重塑为 3 维输入。我遵循了您的步骤。
=>X_train = X_train.reshape(1,21, 2)
打印(X_train.shape)
(1, 21, 2)
=>
model = Sequential()
model.add(LSTM(32, input_shape=(21, 2)))
model.add(Dense(1))
model.compile(optimizer=’rmsprop’,loss=’categorical_crossentropy’,metrics=[‘categorical_accuracy’])
history = model.fit(X_train,y_train,batch_size =13, epochs = 14)
—————————————————————————
ValueError 回溯 (最近一次调用)
in ()
—-> 1 history = model.fit(X_train,y_train,batch_size =13, epochs = 14)
/home/siji/anaconda2/lib/python2.7/site-packages/keras/models.pyc 中的 fit(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, **kwargs)
891 class_weight=class_weight,
892 sample_weight=sample_weight,
–> 893 initial_epoch=initial_epoch)
894
895 def evaluate(self, x, y, batch_size=32, verbose=1,
/home/siji/anaconda2/lib/python2.7/site-packages/keras/engine/training.pyc 中的 fit(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, **kwargs)
1553 class_weight=class_weight,
1554 check_batch_axis=False,
-> 1555 batch_size=batch_size)
1556 # 准备验证数据。
1557 do_validation = False
/home/siji/anaconda2/lib/python2.7/site-packages/keras/engine/training.pyc 中的 _standardize_user_data(self, x, y, sample_weight, class_weight, check_batch_axis, batch_size)
1419 for (ref, sw, cw, mode)
1420 in zip(y, sample_weights, class_weights, self._feed_sample_weight_modes)]
-> 1421 _check_array_lengths(x, y, sample_weights)
1422 _check_loss_and_target_compatibility(y,
1423 self._feed_loss_fns,
/home/siji/anaconda2/lib/python2.7/site-packages/keras/engine/training.pyc 中的 _check_array_lengths(inputs, targets, weights)
249 ‘输入数组应与目标数组具有相同数量的样本。’
250 ‘找到 ’ + str(list(set_x)[0]) + ‘ 个输入样本 ’
–> 251 ‘和 ’ + str(list(set_y)[0]) + ‘ 个目标样本。’)
252 if len(set_w) > 1
253 raise ValueError(‘所有 sample_weight 数组应具有 ’
ValueError: 输入数组应与目标数组具有相同数量的样本。找到 1 个输入样本和 21 个目标样本。
请帮我解决这个问题。我是这个领域的新手。哪里出错了?
也许可以把示例缩短到几行,以帮助发现故障?
嗨,Jason,
我正在尝试理解 input_shape,但我认为我对时间步变量完全感到困惑。我有一个多元时间序列,包含 18,000 个样本和 720 个特征。我创建了一个 10 个滞后观测数据集来预测接下来的 5 个时间步,所以我的数据集从 t-10 到 t+5,其中特征数据集从 t-10 到 t,标签数据集从 t+1 到 t+5。
假设我用 15,000 个样本进行训练,reshape 函数的值将是多少?我认为它应该是 [15000, 1, 7200 (720 个特征 * 10)]。关于时间步,值“1”是正确的,还是应该是滞后观测的数量,即 10?
先谢谢您了。
通常,我建议大约 200-400 个时间步。
以下是一些关于如何处理非常长的时间序列的更多建议
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
还有这里
https://machinelearning.org.cn/prepare-univariate-time-series-data-long-short-term-memory-networks/
嗨,Jason!
非常感谢所有关于 LSTM 的教程,我学到了很多。
我正在尝试实现论文《Dropout improves Recurrent Neural Networks for Handwriting Recognition》中的 LSTM 架构,以解决手写识别问题。
基本上,我必须训练网络,输入可变大小的图像(不同的宽度和高度,但总是 3 个通道),并预测图像中写入的单词。我不明白如何处理可变大小的图像?我是否可以将图像视为某些序列(例如,一个 50x30 的图像视为 50 个序列,每个序列有 30 个特征?)作者说我输入一个 2x2 大小的图像块,以 4 个不同的方向扫描(多向多维 LSTM)。
我在这里需要指定什么:input_size (样本, 时间步, 特征)?“样本”是指我训练集中所有图像的数量,还是 2x2 迷你块的数量?时间步和特征呢?我不明白,这非常令人困惑。您能提供任何想法帮助我吗?我是这个领域的新手,我被这个问题困住了。
非常感谢 🙂
我建议将输入填充到固定大小。
嗨,Jason!
非常感谢您关于 LSTM 的教程!
我正在尝试使用 LSTM 和 ARIMA 预测轨迹。阅读本教程后,我有一些问题。
(1) 如果我们想用 LSTM 进行预测工作,是否必须将时间序列转换为滞后观测?
(2) 将时间序列转换为监督学习问题后,预测是否只与“阶数”或“滞后”有关,而不是与“时间”有关(像 ARIMA 那样)?为什么输入不是时间/日期?数据的时间间隔是否必须均匀?
非常感谢!
不,LSTM 可以直接处理时间步。
观测的顺序足以满足模型的需求,如果时间步间隔一致,则不需要绝对日期/时间信息。
你好 Jason!祝贺你的 LSTM 输入教程!
你能回答三个问题吗?
我正在处理 500 个大小不一的样本。我的疑问与这些 500 个样本在这个 3 维输入中的组织方式有关,主要与样本维度有关。
“特征”维度已经定义为大小 26,“时间步”维度将是大小 100,但“样本”维度我仍然不知道它的值将是多少。
疑问 1:在这些具有不同大小的样本中,要确定“样本”维度,我是否必须基于较大的样本,而对于其他样本,我在额外空间中填充 0(零)值?
疑问 2:在“样本”维度中,我是否可以有多行代表同一个样本?
疑问 3:由于样本大小不一,是否有可能性使用 4 个维度,例如:“样本”x“样本部分”x“时间步”x“特征”?
谢谢您的关注!
一个样本就是一个序列。
每个样本必须具有相同的长度,您可以使用零填充来实现这一点,并使用掩码层来忽略填充的观测值。
我想这个教程会更清楚地说明这一点
https://machinelearning.org.cn/prepare-univariate-time-series-data-long-short-term-memory-networks/
嗨,Jason,
谢谢你这么好的教程!这真的很有帮助!
我不确定我是否正确理解模型
样本序列在 LSTM 中确实很重要,因为当前样本的状态受到序列中上一个样本的影响。
如果是这种情况,你能告诉我如何处理以下情况吗?
我的轨迹数据间隔不均匀。间隔从秒到天不等。我想出的解决方案是插值或添加时间特征。你认为准备数据的好方法是什么?
假设上一个问题已解决,如果我的数据包含不同人的轨迹,我该如何组织输入?例如,一个人的轨迹是 (100, 5, 2),另一个人的轨迹是 (200, 5, 2)。如何在同一个模型中训练这两个序列?
非常感谢!
谢谢。
也许你可以插值数据?
也许你可以使用零填充和一个掩码输入层来忽略零?
我在这里有更多关于为 LSTM 准备数据的建议
https://machinelearning.org.cn/faq/single-faq/how-do-i-prepare-my-data-for-an-lstm
如果每个轨迹都是一个样本,并且样本是独立的,那么可以考虑使用批量大小为 1,或者在每个样本结束时重置。比较此模型与不经常重置状态的模型的性能。
你好 Jason 博士,您做得很好!我对我的网络数据形状有点困惑:我有 300 个不同的样本,下一个样本总是以 1 分钟的步长测量,所以总共有 300 个时间步,每个文件包含 1 列,2,000 行。当我说我想减少“特征”(行)时,我想到我的输入形状因此必须是 (1,300,2000),然后我可以用 LSTM 解码器减少到例如 200。 关于时间步长,值“1”是否正确,或者它应该是滞后观测的数量,即 10?
一个样本怎么会有 300 个时间步,1 列和 2k 行?抱歉,我听不懂。
抱歉我表达不清,1 个样本有 2000 行,都在一列中,所以只测量一种值,即温度。我总共有 300 个样本,它们记录之间的时间间隔是 1 分钟。
我还是没明白。
这 2000 行是针对一个特征在时间上相关的吗?还是这 2000 行是在一个时间点上的独立特征?
我想如果我理解你的意思,这 2000 行与一次测量有关(所以我每秒测量温度 2000 次)。但是当你用 LSTM 自动编码器来看待它时,我试图减少“特征”以便从中学习并进行预测。我不知道 LSTM 编码器-解码器的形状应该是 (1, 300, 2000) 还是 (2000, 300, 1),但是对于后者我得到了奇怪的结果,第一个更接近真实数据。哪个是正确的?
编码器的输入将是 [300, ?, 2000],其中 ? 代表您希望建模的时间步长。
编码器-解码器不适用于所有序列预测问题,它适用于输出长度与输入不同的序列。如果您正在进行简单的序列分类/回归,它可能不适用。
嗨 Jason,这个例子真的很好。除此之外,我有一个关于我的数据的问题。我有一个以 1 秒采样率测量温度值,采样频率为 10,000。所以我在 1 秒内测量 10,000 个不同的值,但单位相同(比如力)。我以一定的时间间隔重复这个过程。那么我是否有 10,000 个不同的特征,还是只有一个特征作为输入维度?
听起来每个时间步有 10K 个特征。
这意味着一个时间步可以有 1 万个特征?
一个 NLP 问题可能有 10 万个或更多的特征。
杰森的教程很棒……但我的 RNN 模型重塑有问题……
这是我的代码
import numpy as np
来自 keras.datasets 导入 imdb
来自 keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
来自 keras.layers 导入 Bidirectional
来自 keras.preprocessing 导入 sequence
# 设置随机种子以保证结果可复现
np.random.seed(7)
train = np.loadtxt(“featwithsignalsTRAIN.txt”, delimiter=”,”)
test = np.loadtxt(“featwithsignalsTEST.txt”, delimiter=”,”)
x_train = train[:,[2,3,4,5,6,7]]
x_test = test[:,[2,3,4,5,6,7]]
y_train = train[:,8]
y_test = test[:,8]
# 创建模型
model = Sequential()
model.add(LSTM(20, input_shape=(10,6)))
model.add(Dense(1415684, activation = ‘sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(x_train, y_train, epochs = 2)
什么问题?
数据集重塑问题……
这是我的数据集的一个样本
我的数据集样本(患者编号、毫秒时间、X Y Z 的归一化、峰度、偏度、俯仰、滚转和偏航、标签),依此类推。
1,15,-0.248010047716,0.00378335508419,-0.0152548459993,-86.3738760481,0.872322164158,-3.51314800063,0
1,31,-0.248010047716,0.00378335508419,-0.0152548459993,-86.3738760481,0.872322164158,-3.51314800063,0
1,46,-0.267422664673,0.0051143782875,-0.0191247001961,-85.7662354031,1.0928406847,-4.08015176908,0
1,62,-0.267422664673,0.0051143782875,-0.0191247001961,-85.7662354031,1.0928406847,-4.08015176908,0
是的,你到底遇到了什么问题?
我甚至不知道如何重塑我的数据集以适应 RNN 模型。
你能帮我吗?
这里有更多关于该主题的帮助
https://machinelearning.org.cn/faq/single-faq/how-do-i-prepare-my-data-for-an-lstm
我不知道该怎么做!
慢慢来,一步一步地。
这是我完成的
train = np.loadtxt(“featwithsignalsTRAIN.txt”, delimiter=”,”)
test = np.loadtxt(“featwithsignalsTEST.txt”, delimiter=”,”)
x_train = train[:,[2,3,4,5,6,7]]
x_test = test[:,[2,3,4,5,6,7]]
y_train = train[:,8]
y_test = test[:,8]
model = Sequential()
model.add(LSTM(64,activation=’relu’,batch_input_shape=(100, 10, 1),
stateful=True,
return_sequences=False))
model.add(Dense(1, activation=’linear’))
model.compile(loss='mean_squared_error', optimizer='adam')
这是真的吗?
干得不错。
你说的“真”是什么意思?
我们的工作是找到一个在进行预测时能给出“足够好”结果的模型。这需要仔细的实验。
谢谢你。我尝试了以下代码
np.random.seed(7)
train = np.loadtxt(“featwithsignalsTRAIN.txt”, delimiter=”,”)
test = np.loadtxt(“featwithsignalsTEST.txt”, delimiter=”,”)
x_train = train[:,[2,3,4,5,6,7]]
x_test = test[:,[2,3,4,5,6,7]]
y_train = train[:,8]
y_test = test[:,8]
x_train = x_train.reshape((-1,1,6))
model = Sequential()
model.add(LSTM(64,activation=’relu’,input_shape=(1, 6)))
model.add(Dense(1, activation=’softmax’))
model.compile(loss=’binary_crossentropy’,
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train, batch_size = 128, epochs = 10, verbose = 2)
但是它的准确率很低,损失很高
第 1/20 周期 – 63秒 – 损失:15.0343 – 准确率:0.0570
第 2/20 周期 – 60秒 – 损失:15.0343 – 准确率:0.0570
第 3/20 周期 – 60秒 – 损失:15.0343 – 准确率:0.0570
第 4/20 周期 – 60秒 – 损失:15.0343 – 准确率:0.0570
也许可以尝试其他配置,这里有一些想法
https://machinelearning.org.cn/improve-deep-learning-performance/
model.add(LSTM(32)) 中的 32 是什么意思?
这意味着该层中有 32 个 LSTM 单元。
如果您在文章中添加了这些信息,那会很好。
感谢您的建议,您可以从这里开始学习 LSTM 的基础知识
https://machinelearning.org.cn/start-here/#lstm
层是否可以任意确定?还是有规定?
通常先是任意的,然后通过实验确认它适合问题(即,用你的数据集测试)
嗨,Jason,
感谢您出色的教程。它帮助我使用 LSTM 模型预测时间序列数据序列。
但是,我有一个关于如何确定 look_back 时间步长的问题。
例如,有一个时间序列序列 X1, X2, X3, …, Xn。当我应用 ARIMA 预测 Xn+1 时,我可以使用 ACF 和 PCF 来确定参数 pi 和 qi。pi 的数量表示 look_back 时间步。然后,可以使用 ARIMA 方程来预测 Xn+1。
但是对于 LSTM,我不知道如何确定 look_back 时间步长,换句话说,时间序列序列的重塑大小。有没有办法在为 LSTM 重塑时间序列序列数据时获得适当的 look_back 时间步长?您能给我一些建议吗?
非常感谢。
苏子
查看 ACF/PACF 图可能是了解重要滞后观测数量的一个很好的开始。
感谢您的快速回复。
我仍然对您的建议感到困惑。您是说我需要绘制 ACF/PACF 来找出应用 LSTM 的时间滞后数吗?
我不认为 ACF/PACF 可以用于确定 LSTM 的 look_back 时间步。这两个标准解释了时间序列的线性相关性。
对于那些非线性相关的时间序列序列,ACF/PACF 不会截断或拖尾,并且 ARIMA 无法用于建模它们。
然后我使用 LSTM 对非线性相关时间序列序列进行建模,LSTM 在这方面表现出色。不幸的是,ACF/PACF 无法在应用 LSTM 时找到时间滞后。
在应用 LSTM 进行时间序列预测之前,我必须决定重塑大小。但是,我在互联网上找不到任何关于如何确定它的信息。有没有任何书籍或教程可以帮助我解决这个问题?
非常感谢。
是的,这是一个有用的指南/起点。
我在这里有很多关于为 LSTM 准备数据的建议
https://machinelearning.org.cn/faq/single-faq/how-do-i-prepare-my-data-for-an-lstm
嗨,Jason,
感谢这篇文章,并澄清了我们有些人难以理解的维度。
但是,我的问题是关于我在问答中没有找到任何人问过的问题
你为什么要将 32 个单元放在输入 LSTM 层中?
我的意思是,如果您在 10 个时间步中的每个时间步都有 2 个特征,并且有一个样本示例,我们为什么要让第一个输入层中的神经元超过 10 个?
据我理解 LSTM,每个神经元都会接收一个特定时间步的特征(在 Colah 博客的单元格图像中,它被表示为 Xt,你肯定知道)。
如果你用“t”馈送第一个,然后继续“t+1,t+2,t+3…t+10”,那么在 t+17(例如第 17 个神经元)的情况下,我们将使用哪个时间步?
在全连接 ANN 中,第一个输入层的神经元数量与我们拥有的特征数量相同。我是不是遗漏了什么,或者如果我们选择输入层是 LSTM 层,是否有任何规则来选择神经元数量?
感谢您的关注,并感谢纠正我可能不理解的任何错误。
隐藏层中单元的数量与输入或输出时间步的数量无关。
我们通过试错来配置神经网络,这里有更多信息
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
Jason 再次你好,
感谢您的快速回复。
请允许我介绍一些数字
Input_shape = (300, 10, 2)
Batch_size = 1
输入/第一个 LSTM 层中的单元数 = 32
所以,正如你所说,如果输入 LSTM 层(我假设它是我们使用的第一层)中的单元与时间步无关,那么我们每次通过“Xt”向该层输入一批数据时,我们将输入 300 个样本中的一行(一个样本),具有 10 列,我们将执行两次:一次用于第一个特征,另一次用于第二个特征,重要的一点是,这种输入将馈送到构成 LSTM 层的 32 个单元中的每一个单元。我明白了吗?
我感到困惑,因为在正常的全连接 ANN 中,第一层(输入层)的节点数量与我们拥有的特征数量相同,这样我们就可以在每个节点中输入每个特征。
如果你能为我澄清这一点,你将帮我一个大忙,因为其他地方没有太多关于这些细节的深入见解。
提前感谢,
如果您的批量大小为 1,那么每个批量将包含一个样本(序列)。
是的,序列将暴露给第一个隐藏层中的每个单元。
嗨,Jason,
好的,完美。现在我几乎明白了所有要点。
谢谢您的好意,
嗨,Jason,
我想我与 Eriz 有着相同的问题,但我不确定我是否正确理解了他的解释,所以如果你能告诉我我是否理解正确,那就太好了。
所以问题是:数据如何馈送到 LSTM/RNN 的第一层?(我希望没有区别)
让我们以 Eriz 的例子:第一层有 32 个单元,输入形状为 (300,10,2)
我这样理解 Eriz
对于一个例子 e(来自 300 个例子),第一层中的所有 32 个单元都获得了例子 e 的长度为 10 的时间序列。并且对于每个特征,一个接一个地分别进行(在这种情况下是两次),然后网络处理下一个例子。
这正确吗?
另外,如果我们看这个典型的 RNN 插图
http://www.wildml.com/wp-content/uploads/2015/09/rnn.jpg
我是不是对的,在这种情况下,图像中的变量 t 的范围是 1 <= x <= 10?(因为时间序列的长度)
非常感谢您,因为我找不到关于这如何工作的详细描述。
隐藏层中的 32 个单元是独立的,不相互作用。
对于给定单元,它一次接收一个时间步的数据,包含 2 个特征。这会持续到所有 10 个时间步都已显示,然后最终激活被传递到下一层。
这有帮助吗?
有点。我现在明白了单个单元格会发生什么。
你说所有单元都是独立的。这是否意味着每个单元都以你第二句话描述的方式接收相同的数据(一个示例的完整时间序列)?
再次感谢您的努力。
是的。层中的单元不交互,每个单元都接收完整的输入。
你好 Jason,感谢您的文章和书籍……我有一些关于形状的未解答问题。由于我有一个 2D 多元数据,例如:(样本 = 1024,特征 = 6),并使用十 (10) 个滞后创建一个监督学习数据集,形状将是 (样本 = 1024,特征 = 60)。
问题是:LSTM 的形状是(样本,时间步,特征),所以它将是 data.reshape(1024, 10, 60)?我不明白为什么有些教程使用类似 (1, 10, 1) 的东西,以及如何在新的形状上重塑/分割训练/测试。步骤是:
1 – 转换为监督问题。
2 – 重塑整个 2D 数据集,还是在这里分割然后再重塑?
3 – Y 的形状如何进行预测?
我只需要一个包含这些关键点的步骤……感谢您出色的帖子。
根据您的描述,无需担心滞后,时间步会处理这个问题。
形状将是 (1024, 10, 6)
Jason,您好,再次感谢您的回复。在您关于单个和多个特征的示例中,您说
——考虑一个 2 列 10 行的矩阵,这些数据可以被框定为 1 个样本,10 个时间步和 2 个特征。
所以,这个“1 个样本”让我抓狂。当我有一个像行与列(样本,特征)这样的 2D 数据时,我以为样本数将是 2D 矩阵的行数;所以它总是(样本,特征)——>(样本,时间步,特征)。在您的示例中,行变成了时间步,我无法理解此帖子中的 sample = 1。为什么是一个样本?为什么行在这里变成了时间步,而在其他示例中又变成了样本?
另一个问题是:在重新调整输入数据后,如何重新调整 X_train、y_train 和用于预测的新数据。
一开始确实很有挑战性。
这样想:你正在将一个 2D 数据集投影到一个 3D 空间中。
嗨,曼努埃尔,
抱歉在多年后才提出这个问题。希望您已经找到了答案。您能分享您的观察结果吗?
你好,
为什么我们需要将数据重塑为 LSTM 的 3 个维度
谢谢你
因为 LSTM 期望输入数据是三维的。
嗨,非常感谢您的这篇文章,它帮助我理解了 Keras 和整体输入方面的问题。
我真的很困惑如何准备输出数据。总的来说,输出
在某一点我们使用
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=64)
我的输入形状是 (25000, 15),我该如何准备整体输出?
为什么?你到底遇到了什么问题?
谢谢分享。我对手填充和“滑动窗口”方法感到困惑。假设数据集包含两个序列 s1,s2,并且 time_step 设置为 3,那么 s1=(1,2,3,4,5) 应该有 2 个子序列:[(1,2,3), (2,3,4)],s2=(6,7,8,9,10,11,12) 应该有 4 个子序列:[(6,7,8), (7,8,9), (8,9,10), (9,10,11)]。这 6 个子序列的长度都等于 time_step,因此它可以重塑为 3D 张量 (6, 3, 1),而无需填充 s1 和 s2 到相同长度。如果所有序列的长度都大于 time_step,那么我们不需要将序列填充到相同长度。我说的对吗?
只有当时间步数不同和/或时间步观测值缺失时才需要填充。
嗨,感谢您精彩的文章!
假设我有一个形状为 (10,2) 的归一化二维数组数据
但是当我想将数据重塑为 (10,3,2) 的三维数组时,我得到一个错误信息
“ValueError: 无法将大小为 20 的数组重塑为形状 (10,3,2)”
似乎之前的二维数组在将其重塑为三维数组之前,将数据的样本数 10 乘以输入维度 2,这可能是导致错误的原因?
提前感谢,
您需要更多数据才能从 (10,2) 到 (10,3,2),仔细想想,甚至可以画一张图。您正在发明原始数据中不存在的维度。
你需要 (10,6) 才能得到 (10,3,2)
好的,我想我明白了,我应该实际上用时间步长来划分样本,因为这样做最终解决了我的问题!谢谢 Jason!
好的,我明白了。那么,先用滞后 t-n 重新构建数据是否解决了问题?
如果您允许,我有一个问题:我有 20 个主题(类别),每个主题有 700 个文件,每个文件代表一个文档,但采用词嵌入表示(每个文件的大小:词数 X 300 个特征)。我想训练一个 LSTM 网络,这可能吗?以及如何操作?
您可以在这里开始使用 LSTM 和文本数据
https://machinelearning.org.cn/start-here/#nlp
非常感谢,我会查阅的……
我还有另一个问题,所以对于我的问题,您的书《深度学习自然语言处理》中是否有 LSTM 的内容,因为我不仅想使用词嵌入,还想考虑词的顺序。
或者我还需要您的书《使用 Python 的长短期记忆网络》吗?
抱歉打扰您的提问,但我真的卡住了,没有人可以帮助我解决这个问题。
提前感谢……
此致,
我在《深度学习自然语言处理》中给出了使用 LSTM 以及 MLP 和 CNN 等其他网络解决 NLP 问题的示例。
谢谢,Jason,你的精彩博客文章!
我有一个关于输入形状的问题,我找不到确切的答案。我不知道这个问题与这篇博客文章有多大关系,但很乐意听到您对我的问题的回答
我有一个训练集,其中包含图像序列(假设 n 是序列中图像的数量,c、h、w 是通道、高度和宽度)。我用输入形状 (n,c,h,w) 训练了一个 CNN-LSTM。
现在,要通过这个网络进行预测,似乎我必须每次向它输入数据序列(而不是单个帧)。也就是说,每有一个新帧,我都需要更新序列并将其输入网络以获得结果。
然而,我之前以为在处理 RNN 或 LSTM 时,我们可以一次输入一个帧(因为循环性),而不是输入整个序列。这种印象是错误的吗?
所以,简而言之,当拥有一个用于实时预测的 LSTM 网络时,我们是否需要向网络输入序列,或者是否存在可以输入单个信号/帧/数据点的情况?
非常感谢!
是的,您可以一次输入一帧视频,让 CNN 解释帧,然后 LSTM 将序列组合起来并解释它们。
我的 LSTM 书中有一个这方面的例子。我在这里有一个如何在 Keras 中做到这一点的总结
https://machinelearning.org.cn/cnn-long-short-term-memory-networks/
谢谢!我之前阅读过您的另一篇博文(现在又读了一遍)。但我仍然不明白如何一次输入一帧。输入大小怎么办?
您是说我可以有一个 CNN 和一个独立的 LSTM。一次向 CNN 输入一帧,然后按顺序向 LSTM 输入?这意味着,我再次必须自己创建序列才能输入网络?
我不明白的是,训练网络的 input-shape 被定义为 (n, c, h, w),当 n 不是 1 时,我如何输入形状为 (1,c,h,w) 的输入?
顺便说一下,我已经将我的 CNN 封装在 TimeDistributed 层中。我的代码如下
model.add(TimeDistributed(Conv2D(24, (5, 5), padding=’same’, activation=’relu’, kernel_constraint = maxnorm(3), kernel_initializer=’he_normal’), input_shape=(5,1, 125, 150)))
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides = (2,2))))
model.add(TimeDistributed(Dropout(0.4)))
model.add(TimeDistributed(Conv2D(36, (5, 5), activation=’relu’, padding=’same’, kernel_constraint=maxnorm(3))))
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides = (2,2))))
model.add(TimeDistributed(Dropout(0.6)))
model.add(TimeDistributed(Conv2D(50, (5, 5), padding=’same’, activation=’relu’, kernel_constraint = maxnorm(3))))
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides = (2,2))))
model.add(TimeDistributed(Dropout(0.4)))
model.add(TimeDistributed(Conv2D(70, (5, 5), padding=’same’, activation=’relu’, kernel_constraint = maxnorm(3))))
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides = (2,2))))
model.add(TimeDistributed(Dropout(0.5)))
model.add(TimeDistributed(Flatten()))
# 定义 LSTM 模型
model.add(LSTM(128, return_sequences=True))
model.add(LSTM(32))
model.add(Dense(2, activation=’sigmoid’))
不,它是一个模型。CNN 的大小是一个图像的大小。图像按序列暴露给模型,例如
[样本数, 帧数, 宽度, 高度, 通道数]
谢谢,Jason,你的精彩帖子!
我是在阅读您的帖子之前创建了一个模型,我发现我犯了一个错误。我交换了时间步和特征。这会对模型性能产生多大影响?
此致!
模型是随着时间的推移而学习的。时间是模型理解序列的关键。
嗨,感谢您的精彩文章 🙂
LSTM 网络中我有一点不明白的地方——
如果每个时间步的输出都应该预测下一个输入,
为什么输入向量维度(与特征数量相关)不等于输出向量维度(与层中的单元数量相关)
反过来。
一个步骤的输出可以作为下一个步骤的输入。
也许这会有帮助。
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
嗨,Jason,
非常感谢您的帖子——它真的很有用!
我只是想向您阐述我的问题,以确认您认为本教程中概述的方法适合我
我有两列数据——一列是共振能量,另一列是相应的中子宽度。我想将 70% 的数据输入网络,即共振能量和中子中子值。然后要求网络预测剩余 30% 未见共振能量的中子宽度值。
我想要一个 LSTM 层,因为它可能有助于在当前预测中使用以前的计算。
所以我认为我有两个输入和一个输出。
如果我有 300 个 [共振能量,中子宽度] 值(即 300 行数据),那么我的重塑是
reshape(1, 300, 2) 还是 reshape(1, 300, 1)?我不确定第二列是否在技术上是一个特征,因为它应该是输出。
另外,由于每个共振能量都与同一行中的中子宽度相关,我是否需要显式配对?还是应该使用某种键值对?
(这也是第一次实验,我还希望然后使用共振能量和中子宽度来预测另一个变量,但本质上与此问题中描述的方式完全相同,只是新实验包含一个额外的特征)
听起来您有 300 个时间步的 1 个输入特征。
您可以有一个 [1,300,1] 的样本,但这不足以训练模型。
也许您可以将输入样本分割成 5 或 10 个时间步的更小子序列?
也许这个工作示例会更清楚地说明问题
https://machinelearning.org.cn/prepare-univariate-time-series-data-long-short-term-memory-networks/
非常感谢您的迅速回复。
啊,我的数据在这里
https://pastebin.com/index/9qwJU3AQ
我已阅读您提供的链接,但我不清楚我的数据是否允许我像您的文章中提到的那样删除时间变量。如果是这样,我或许可以拥有 [1,300,1] 的样本,而不是 [1,300,2]。
我有一个疑问,我的测试集(占我样本的 30%)获得了“测试分数:0.00 MSE (0.01 RMSE)”的分数,样本不足是否真的会表现出如此低的 RMSE 分数?如果有什么不同的话,这难道不是表明预测几乎太好(或过拟合)了吗?
抱歉,最后一个问题,从本教程中阅读——如果使用 LSTM 层,是否仍然可以使用 look_back?(在您的其他教程中创建数据集时经常使用的参数)。如果我理解正确,LSTM 层本质上允许在确定当前计算时检查以前的计算,但 look_back 确定在每个时间步计算时可以考虑多少个以前的时间步?
我没有能力为您塑造数据。我相信您拥有塑造数据以用于 LSTM 模型所需的一切。
“look-back”指的是在单个样本中馈入模型的先前时间步长的数据量。例如,[样本数,时间步长,特征数] 中的“时间步长”。
嗨,Jason,
当然,听起来不错,我会尝试一下。
我有一个快速问题,当我在您的许多教程中绘制结果时,您倾向于使用以下几行
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back)+1:len(dataset)-1, :] = testPredict
所以第一行只是创建了像数据集一样的 numpy 矩阵,
但第二行是否用 nan 值填充它?(如果是,为什么,或者它只是一个检查?)
第三行然后移动测试预测图?
非常感谢
你的解释似乎是正确的。
嗨,Jason,
感谢您的帖子。我从中受益匪浅。
我有一个关于我的 LSTM 分类模型的问题。
我的输入数据是 4842 个样本,34 个时间步,254 个特征。换句话说,它是 (4842,34,254)。
我已经用适当的参数训练了它。虽然在验证数据上取得了 98% 的良好准确率,但在测试数据(来自独立数据)上却获得了约 20% 的低准确率。
我的第一个想法是过拟合,但我也尝试了回调函数,如 earlystopping 或 reducelronplateau。它并没有给我带来更好的结果。
您能就此问题给我任何建议吗?
非常感谢!
是的,听起来像是过拟合。
我这里有一系列可以尝试的想法
https://machinelearning.org.cn/improve-deep-learning-performance/
嗨,Jason,
我从您的博客文章中学到了很多。对于这篇特定的文章,我有三个具体问题。
Q1: 我们如何决定构造函数 LSTM 的第一个参数的值?您使用了 LSTM (32, …)。这个 32 的值是如何为这里要解决的代表性问题决定的?对于词嵌入输入,200 到 500 之间的值合理吗?
Q3: 这个参数的意义是什么?它是 LSTM 单元的数量,是否应该与 Keras 模型的输入层维度值匹配(在词嵌入的情况下,值在 200 到 500 之间)?
Q3: 如果选择 500 作为此参数的值,性能会受到什么影响?
谢谢和问候
第一个隐藏层中的节点数通过试错或调优来确定,此处有更多信息
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
我就是不明白重塑。我不知道如何计算数组并将其输入批量大小或对其进行训练数据。我为此困了一整天,一直在谷歌搜索。非常感谢任何人的帮助
也许可以回到基础,学习如何使用重塑函数
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
你好 Jason,感谢你的精彩解释
你能帮我解决这个问题吗
https://stackoverflow.com/questions/52317804/recurrent-neural-network-using-different-time-steps-with-keras
也许你可以用一句话给我总结一下?
嗨,Jason,
我有多维时间序列数据,样本大小为 200,000,有 50 个维度。
我想在正常数据上训练一个序列到序列的自编码器,以便以后用于检测异常。我想尝试使用 LSTM 自编码器来完成这项任务,使用 keras 网站上的示例
https://blog.keras.org.cn/building-autoencoders-in-keras.html
inputs = Input(shape=(时间步长, input_dim))
encoded = LSTM(latent_dim)(inputs)
decoded = RepeatVector(时间步长)(encoded)
decoded = LSTM(input_dim, return_sequences=True)(decoded)
sequence_autoencoder = Model(inputs, decoded)
encoder = Model(inputs, encoded)
我困惑如何转换我的数据。
当生成序列时,假设时间步长为 100:我应该将这 20 万数据转换为 100 个单独的序列,还是使用滑动窗口生成我的序列?
非常感谢您的帮助。
是的,您将长序列分割成子序列。
无需重叠,但如果您愿意,可以重叠并查看是否能提高检测效果。
嗨,Jason,
精彩的教程。我有一个问题想问。
我总共有 3 个序列。
序列 1:形状为 800×2500(800 个观测值和 2500 个特征)。它属于类别 1。
序列 2:形状为 1000×2500。它属于类别 2。
序列 3:形状为 600×2500。它属于类别 3。
我已经将这 3 个序列组合成 1 个数组,该数组具有 2400×2500 个特征。我想在这个数组上训练一个 LSTM 网络。希望它能学习这些序列的模式,并根据任何长度(?x 2500)的新测试序列预测类别(1,2 或 3)。
我的输入形状应该是什么?它应该是 (1,2400,2500) 吗?
每个序列都是一个独立的样本,时间步长必须用零填充以匹配。
形状将是:[3, 1000, 2500]
在 3 个样本上训练模型听起来没用,您可能需要 3 千或 3 百万个样本。
此外,1000 个时间步可能有点长,最好是 200-400 个。
model.fit(trainX,trainY,epochs=100,verbose=0)
ValueError: 检查输入时出错:预期 lstm_2_input 的形状为 (3, 1),但得到形状为 (1, 1) 的数组。发生此错误。
我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨,Jason,
非常感谢您的教程。我有一个关于 Conv2D 的问题
我想开发一个用于二值图像分类的模型,大小为 (256*256)
我将图像放入长度为 (10000) 的 numpy 列表中,每个索引都有 np.array (256*256)
当我使用 input_shape = (256,256,1) 开始拟合模型时,我得到了错误
我应该如何定义输入形状
谢谢你
2D CNN 将需要形状为:行 x 列 x 通道 的输入。[256,256,1] 听起来是对的。
你好,谢谢你的教程。
我正在努力理解 LSTM 自动编码器的数据输入,但我迷茫了。
我想使用自动编码器进行时间序列异常检测(跌倒检测)。
数据集 (Dataset)
500 个样本(来自陀螺仪的数据——走路、跳跃、跑步……)
每个样本 600-10000 个时间步(6-100 秒)。
3 个特征。
一个样本(一个文件)的例子
时间 x y z
1 1.3 9.6 1.3
2 1.2 9.3 1.5
3 0.9 8.0 -2
. . . .
. . . .
. . . .
1000 1.4 9.8 2
想法
训练自动编码器以重现正常数据(走路、跳跃、跑步……)。
异常检测:重现错误。
我想在 2 秒时间窗口(200 个时间步)内检查异常(跌倒)-> 重现每 2 秒的窗口并检查重现错误。
问题
您能解释一下如何为这项任务准备数据集吗?(维度、数据集结构……)
我应该使用多大的批次和时间步长(seq_length)?
我应该随机生成批次,还是从数据集的开头生成?(批次 1:0 – batch_size,批次 2:batch_size-batch_size*2……)-> 我看到有人在每次迭代中生成随机批次。这会不会导致一些数据被多次使用,而另一些数据根本没有被使用?
谢谢你。
我这里有一个准备活动识别数据或 LSTM 的示例,可能有用
https://machinelearning.org.cn/how-to-model-human-activity-from-smartphone-data/
您好,非常感谢您的教程。我正在做一些项目,但阅读完本教程后仍然卡住了。以下是描述
我有一个两列的 dataframe,都是文本——一列是标题,另一列是对应的标签。
唯一标签计数约为 40k,所以 One-Hot 编码就排除了。
我将 word2vec 用于两者,大小为 150,训练并使用创建的模型对标题和标签进行编码。
例如,对于 hello world
我将它们分割,然后使用它们各自大小为 150 的词向量,将它们相加并归一化以创建一个表示 hello world 的向量。
所以我的 dataframe 中的两列都已更改,每行中的每列都有一个向量。
dataframe.shape 显示 (len, 2),其中 len 是 dataframe 的长度
然后我做了
X = df[‘title’].values
y = df[‘label’].values
我得到了两个 numpy.ndarray,它们的形状如下
X.shape –> (len,)
X[0].shape –> (150,)
y.shape –> (len,)
y[0].shape –> (150,)
在此之后,我被网络的输入和输出形状卡住了。
我尝试了 LSTM,我得到了错误,LSTM 期望 3 个维度,但得到了数组
我尝试了 Dense 层,仍然得到形状错误。
基本上,我正在努力解决网络的输入和输出应该是什么。
任何这方面的帮助都将不胜感激。如果需要,我可以提供更多细节和代码。
你说的用 word2vec 处理标签是什么意思?那是不是意味着你正在预测一个向量,然后将其映射到单词?听起来很奇怪。
我建议在前端嵌入,输出端使用 softmax,并使用 4 万个独热编码向量。
嗨 jason,谢谢你的教程。
我正在尝试将 3 列(3316 行)合并的编码文本 Train_data 和 Train_Labels 分类为 1-9 类(3316 行)输入 LSTM 网络。
Train_input 最后一列是 50 维的词嵌入向量的输出,(3316,50)
Train_input 第一和第二列是单词——独热编码文本数据 (3316,2)
合并三列后,形状为 (samples=1, time_steps=3316, features=3)
TraIN_LABELS 将上述 train_data 分类为 1-9 类。使用标签编码器进行编码。
train_input=(1,3316,3), train_label=(1,3316,9) 在这个数据形状下遇到错误
重塑标签为 (1,3316,3) 失败
如何重塑标签以馈送到 LSTM?
标签通常是 1D 数组,每个输入样本有一个元素。
谢谢你的回复,jason。
LSTM 网络返回错误,因为“预期密集 3 维形状,而不是接收到
(3316,)” 当给出 1D 数组时。
有没有其他方法可以输入?我在重塑训练数据时犯了什么错误吗?
非常感谢您的解释!
您能解释一下如何将多输入馈送到 LSTM 吗,比如说
您有:data = data.reshape(1, 10, 2)
数据 = 数组([
[0.1, 1.0],
[0.2, 0.9],
[0.3, 0.8],
[0.4, 0.7],
[0.5, 0.6],
[0.6, 0.5],
[0.7, 0.4],
[0.8, 0.3],
[0.9, 0.2],
[1.0, 0.1]])
并且 model.add(LSTM(32, input_shape=(10, 2)))
那么在 epoch 的第一次迭代中,第一列中的值:0.1,0.2,….. 1.0 将被馈送到 LSTM 输入门的 xt, xt+1,…, xt+9。第二列:1.0, 0.9…0.1,它们也会被馈送到 xt,xt+1,…,xt+9 吗?还是会被馈送到 LSTM 的另一个输入门:xxt, xxt+1,….,xxt+9 ?
不完全是,如果有一个样本,并且您的批大小是一个样本,那么第一个输入样本中的所有时间步都将在 epoch 1 中馈送到模型。
抱歉,我还是不清楚!
那么 model.add(LSTM(32, input_shape=(10, 2)))
input_shape(10,2) 中的数字 2 是什么意思?
(10,2) 表示每个样本将有 10 个时间步和 2 个特征。
您好 Jason,非常感谢您的精彩文章。
我理解了文章并制作了一个数据集,如下所示。
x_train_shape : (35849, 100, 3)
y_train_shape : (35849, )
x_validation_shape : (8963, 100, 3)
y_validation_shape : (8963, )
x_train_shape : (11204, 100, 3)
y_train_shape : (11204, )
这是一个三通道的时间序列传感器数据。
而且,数据的实际形式如下。
(2067, 1976, 1964)
(2280, 1994, 1952)
(2309, 1976, 1968)
.
.
.
(2020, 2160, 1979)
(1994, 2181, 2064)
我按每个通道的 [窗口大小:100,步长:15] 对特定部分的数据进行了标记。
例如,如果特定部分是从 251 到 750,则会生成 27 段切割数据,如下所示。
251~350, 266~365, 281~380, …, 641~740
利用这些数据,我能够通过 DFN 和 CNN 进行学习,以有效地执行。
然而,当我使用 LSTM 进行学习时,学习没有进展,损失没有减少,准确率约为 50%。
所以我想听听您对这种现象的看法,您在这个领域有广泛而深入的知识。
我应该改变数据结构吗?
或者,有没有适合这种数据结构的特定包含 LSTM 的模型结构?
或者,您有什么新的意见吗?
非常感谢您对我的问题的关注。
LSTM 通常不擅长时间序列预测。您可能需要仔细调整模型。
谢谢你的回复。
昨晚,我思考了很多。我终于弄清楚为什么我的数据集不适合这个模型了。
这是因为一个数据单元不能影响决策。
所以我将寻找一种方法来增加 LSTM 上的数据处理单元。
通过您的资料和回复,我思考了很多。
再次非常感谢。
干得不错。
你好,
我真的对输入形状感到困惑。假设我有一个关于房屋信息的数据集。
特征是 [大小,房间数,楼层数]
我的数据集包含 4 个样本,如下所示
dataX = [[200, 3, 1], [150, 1, 1], [270, 4, 2], [320, 3, 2]]。例如,dataX[0] 是 0 号房屋,大小为 200,3 个房间,1 层。
现在我想训练我的 LSTM。Are (samples, time_step, feature) 与我在这里定义的那些不同吗?我的意思是我有 4 个样本,3 个特征!你如何告诉 LSTM?例如,您能告诉我前 2 或 3 个时间步中哪些数据被馈送到 LSTM 吗?
非常感谢。🙂
大小、房间数和楼层都是“特征”。特征=3
如果您有 3 栋房屋,这些就是“样本”。样本=3
但您没有提及任何时间步。如果您没有时间步(随时间的观察),LSTM 是一个糟糕的选择,我建议使用 MLP。
你好 Jason,
首先,感谢您的所有工作。非常感谢您在所有教程中给予我们的支持!
另一方面,我有一个问题。对于 LSTM,我们需要一个 3D 数组(样本,特征,时间步)。但我仍然不明白“时间步”是什么意思?它与 loop_back 变量相同吗?
谢谢,
时间步是随时间(例如分钟、小时等)进行的观察(特征)。或者,它们可以是序列中的项目,如句子中的单词。
这有帮助吗?
和大家一样,我要感谢您这篇以及其他有用的文章。
我需要将 ConvLSTM2D 的输出连接到 LSTM!
ConvLSTM2D 的输出是 (samples, time, output_row, output_col, filters),其中 return_sequences 为 True。
我在这里很困惑,这个 5D 输入如何馈送到 LSTM!
如果能提供任何帮助,我将不胜感激!
您确定 ConvLSTM2D 的输出如您所描述的那样吗?
如果是这样,也许您可以使用 lambda 来展平行/列和过滤器。
你好 Jason,
我有一个 n,p 行的数据框(n 用于不同的样本,p 用于 q 个时间步和 r 个静态特征 p = q+r)。对于每一行,我有 q 个感兴趣的测量值和 r 个静态特征。
基本上,我想进行时间序列分类,它也基于静态特征。
据我了解,输入形状应该是 (n,q,r),但我无法将我的数据框从 (n,p) 转换为 (n,q,r),因为 p = q+r
非常感谢您的帮助!
我不明白您说的 p = q+r 是什么意思?
亲爱的 Jason,
为什么在将数据馈送到 LSTM 之前需要在 numpy 中重塑数据。为什么 Keras 不自动执行此操作?
如果我有一个包含 10 个值的序列,并且我想预测第 11 个值,我猜 Keras LSTM 已经在一个大小为 (1,10) 的 numpy 数组中拥有所有信息,以完成预测第 11 个值的任务。为什么我需要将其重塑为 (1,10,1)?
致敬
吉多
为什么——这是 API 的预期。不要与它作对,满足它。
嗨,Jason,
感谢您的精彩文章。
我在填充方面有问题。
我使用预训练的句子嵌入(维度:300),
我的应用程序中一个样本表示一个文档。
现在我的文档中有可变数量的句子。
(不是具有可变单词长度的句子序列)
例如,doc1:[sent1, sent2]
doc2:[sent1]
doc3:[sent1, sent2, sent3]
可变句子序列中的零填充意味着在 word_index 序列后填充 0
但预训练的句子嵌入不能将句子映射到索引
我如何将句子数量填充到固定大小?
它只是在每个时间步填充 300 个零,并使用掩码层跳过这些零吗?
例如,pad_sent = np.zeros((1,300))
doc1:[sent1, sent2, pad_sent]
doc2:[sent1, pad_sent, pad_sent]
doc3:[sent1, sent2, sent3]
谢谢你。
填充值可以映射到嵌入中的“未知”索引,通常也为 0。
您好 Jason,希望您还没有回答过这个问题。为了为 LSTM 输入准备 x 数据,
数据被重塑为 3D 数组。y 数据是否也应该进行类似的操作?它是否也应该被分成子序列,以便输出与输入同步?
如果是这样,应该在用 one-hot 编码转换数据之前完成吗?或者
one-hot 编码是之后进行的吗?感谢您的所有帮助。
不,除非您正在预测序列输出。
如果您正在预测多类别标签,则使用 one-hot 编码。
嗨,Jason,
很棒的文章——每当需要精简的解释时,我都会来这里。谢谢!
关于输入形状——我使用 LSTM 一段时间了,没有任何问题,但现在我尝试使用 1D 卷积层来加速处理,现在我遇到了麻烦——您能看出以下代码有什么问题吗?(这里使用了虚拟数据)
#加载包
import numpy as np
import pandas as pd
来自 keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, GRU, TimeDistributed
from keras.layers import Conv1D, MaxPooling1D, Flatten, GlobalAveragePooling1D
from keras.layers import Conv2D, MaxPooling2D
from keras.utils import np_utils
nfeat, kernel, timeStep, length, fs = 36, 8, 20, 100, 100
#数据(虚拟)
data = np.random.rand(length*fs,nfeat)
classes = 0*data[:,0]
classes[:int(length/2*fs)] = 1
#分割矩阵
#数据
X = np.asarray([data[i*timeStep:(i + 1)*timeStep,:] for i in range(0,length * fs // timeStep)])
#类别
Y = np.asarray([classes[i*timeStep:(i + 1)*timeStep] for i in range(0,length * fs // timeStep)])
#拆分为训练集和测试集
from sklearn.model_selection import train_test_split
trainX, testX, trainY, testY = train_test_split(X,Y,test_size=0.2,random_state=0)
#one-hot-encoding
trainY_OHC = np_utils.to_categorical(trainY)
trainY_OHC.shape, trainX.shape
#使用简单的 1D 卷积网络设置模型
model = Sequential()
model.add(Conv1D(8,10,activation=’relu’,input_shape=(timeStep,nfeat)))
model.add(MaxPooling1D(3))
model.add(Flatten())
model.add(Dense(10,activation=’tanh’))
model.add(Dense(2,activation=’softmax’))
model.summary()
# 编译模型
model.compile(loss=’mse’,optimizer=’Adam’ ,metrics=[‘accuracy’])
#训练模型
model.fit(trainX,trainY_OHC,epochs=5,batch_size=4,validation_split=0.2)
我收到了一个拟合错误
ValueError: Error when checking target: expected dense_17 to have 2 dimensions, but got array with shape (400, 20, 2)
我看不出这里有什么问题?!
我怀疑您的输出变量 y 不符合模型对每个样本 2 个值的期望。相反,您提供了 [400,20,2]
你好 Jason,
感谢本教程。您的教程是救命稻草!我有一个简单的疑问。
我已将 597 个 .wav 文件中的语音特征提取到数组中。每个数组的形状为 Nx40,其中 N 在 500-1100 之间变化。换句话说,对于 597 个 .wav 文件中的每一个,我都有一个 N 行(在 500-1100 之间变化)和 40 列(40 个声学特征)的数组。
1. 那么,我的 3D 输入形状到 LSTM 应该是什么?是 (1, ?, 40),其中 ? = N 吗?
2. 如果是 (1, ?, 40),那么我是否应该选择一个特定的长度并填充其余的?
真的被这个问题困住了。任何回复都将对我非常有帮助。谢谢!
听起来您有将近 600 个样本,500-1100 个时间步,大约 40 个特征。
我建议填充时间步,并以 [600, 1100, 40] 左右的形状开始,然后尝试截断时间步,看看它如何影响模型。
嗨,Jason,
我有一个时间序列数据集,包含 38,000 名不同的患者,每位患者记录了一小时的 30 个生理参数。如果我想为每位患者提取 48 小时的数据,那么理论上每位患者将有 48 行,每行包含 30 个特征的每小时观测值!假设我想为其他 29,000 名患者提取类似的数据,那么我最终将得到超过十万行(即 29,000 * 48 行)。那么我的输入形状应该是 (30,000, 48, 30) 吗?
也许是这样,我不确定我理解“每小时 48 小时”是什么意思。也许可以尝试您的方法?
输出层形状应该是什么?特别是,如果我只有一个样本,我需要将其重塑为三维吗?例如,如果我的输入数据形状为 [m,n],输出也为 [m,n] 形状。我需要将输入更改为 [m,1,n] 形状吗?另外,如果我使用 return_sequences=False,我可以保持输出形状为 [m,n] 吗?我正在处理时间序列数据。以下是不同时间步长的输入和输出示例
输入:输出
[1,2] [3,4]
[2,3] [4,5]
[4,5] [6,7]
谢谢你
对于普通模型,输出形状通常为 [样本,特征],对于编码器-解码器模型,输出形状为 [样本,时间步,特征]。
嗨,Jason,
你的文章太好了。我想把它应用到我的数据集中。
我有 3000 个样本和 88 个特征(列)。其中,我有 20 个特征,称为 A、B、C、D 等。对于它们中的每一个,我有 3 列 A1、A2、A3、B1、B2、B3、C1、C2、C3 等作为滞后列。因此,有 20+20*3 = 80 个带滞后的特征列
还有 8 个没有滞后值的其他特征。
如何将其转换为 3D 数组的形状以作为输入馈送到 LSTM 模型?
非常感谢您的回复。
好问题,这会有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,jason
我想编写 LSTM 的输入门、输出门和遗忘门功能的代码。帮帮我,先生
抱歉,我没有从头开始编写 LSTM 单元的示例,感谢您的建议。
先生,
我们直接使用 LSTM 函数处理数据。相反,我们可以通过创建自己的 LSTM 函数来编写输入门、遗忘门和输出门的代码
我建议使用 Keras,而不是从头开始编写 LSTM,因为它几乎肯定会有 bug 且效率较低。
嗨
非常感谢,您的文章确实帮助我理解了 LSTM
我正在努力理解如何加载多个样本。这运行良好
samples = np.array([
[0.1, 1.0],
[0.2, 0.9],
[0.3, 0.8],
[0.4, 0.7],
[0.5, 0.6],
[0.6, 0.5],
[0.7, 0.4],
[0.8, 0.3],
[0.9, 0.2],
[1.0, 0.1]])
samples = samples.reshape(1, 10, 2)
但是,我应该如何呈现数据以使用 (2,10,2) 或 (3,10,2)?它是一个数组的数组吗?
最终我想能够从 hdf5 文件到 numpy 数组再到这个 3D 形状,但我很难告诉我的模型有不止一个样本,即使我只是将数据作为玩具示例制作和输入。有什么建议吗?
将更多数据加载到内存中,然后重塑它。
也许我不理解您遇到的问题。
此外,这可能有助于理解心态
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
我想我解释得不太好。感谢您抽出时间回复。我想我的问题是,如果我有多个样本并且我正在尝试使用 reshape,我的数据应该是什么样子?
我的意思是,目前“samples”是一个 numpy 数组,表示一个包含 2 个特征和 10 个时间步的示例。实际上,“samples”应该是一个包含许多示例的数据集。我不明白如何编写它才能使其能够被重塑。samples 应该是一个 numpy 数组列表吗?还是它需要是一个数组的数组或其他什么?我尝试了两种方法,但似乎都不奏效。
阅读这篇 https://machinelearning.org.cn/gentle-introduction-n-dimensional-arrays-python-numpy/ 建议我可能需要使用 vstack?
是的,vstack、dstack 或 hstack 都可以。
我不知道,我没有您的代码/数据,而且它完全取决于您的数据。
如果您遇到麻烦,请尝试在一个单独的 python 文件中摆弄一些人为设计的样本,直到您弄对为止。
嗨!
我有一个这样的数据框 https://imgur.com/a/hmg2Ng4
如果我想为 LSTM 使用时间分量,我认为我的序列将由 date_col 组成。
但是,如果我选择 date_col,我将得到一个新信息的数组。我的意思是,它不是典型的行序列,我认为这更复杂。
我的序列将是 [day1,day2,day3],并且在每一天中,我都有一个包含 [product1,product2,product3] 的数组,每个产品都有 [feat1, feat2]。
对于第一天:[[feat1,feat2],[feat1,feat2],[feat1,feat2]]
序列将是
[ [[feat1,feat2],[feat1,feat2],[feat1,feat2]],
[[feat1,feat2],[feat1,feat2],[feat1,feat2]],
[[feat1,feat2],[feat1,feat2],[feat1,feat2]] ]
这正确吗?这会与神经网络一起工作吗?
我发现我写得很糟糕。
“我的序列将是 [day1,day2,day3],并且在每一天中,我都有一个包含 [product1,product2,product3] 的数组,每个产品都有 [feat1, feat2]。”
当我说 productX 时,我想说 idX
也许可以。
我认为这个解释将帮助您培养使用 LSTM 进行数据预处理的直觉
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
您好 Jason。感谢您的信息丰富的文章。它们对我帮助很大。
我想知道您是否可以给我关于设置 LSTM 模型的建议。我正在处理当 RFID 读取器读取无源 RFID 标签时测量的三个特征。我理解在设置模型之前,我需要确定每个输入将处理多少个时间步。假设我将该数字设置为 32 个时间步。这意味着我的输入形状将是 (32, 3)。我不清楚的是,我是否需要为读取发生的时间戳添加一个特征。标签读取可以以任何速率发生。可能每秒读取一次,这意味着我的 (32, 3) 输入实例将跨越 32 秒,或者可能每分钟读取一次,这意味着我的 (32, 3) 输入实例将跨越 32 分钟。最重要的是,读取速率不会是恒定的。我可能会在 1 秒内获得 3 次读取,然后等待 30 秒才能获得第四次读取。
LSTM 需要知道这些吗,或者简单地给它时间排序的读取序列,而不必知道这 32 次读取发生的实际时间跨度就足够了吗?
如果我必须向我的数据添加一个时间戳,则输入形状将变为 (32, 4)。作为一个后续问题,LSTM 是否要求我定义特征输入之间的固定时间步长?我的意思是,我是否被迫在输入特征列表之间选择一个例如 1 秒的时间跨度?如果我是,并且我只在 0 秒、4 秒和 6 秒时有读取,那么我是否必须按如下方式生成我的 (32, 4) 输入值
(0, x0, y0, z0)
(1, missing, missing, missing)
(2, missing, missing, missing)
(3, missing, missing, missing)
(4, x4, y4, z4)
(5, missing, missing, missing)
(6, x6, y6, z6)
.....
或者
是否不需要对输入之间的时间做出任何假设,所以我可以直接堆叠它们而无需插入缺失值,例如
(0, x0, y0, z0)
(4, x4, y4, z4)
(6, x6, y6, z6)
您能提供的任何输入都将不胜感激。
谢谢你。
也许可以尝试按原样建模,然后尝试使用填充/缺失值,看看模型技能是否有任何差异。
还可以尝试其他模型类型。LSTM 在时间序列方面大多表现不佳。
谢谢 Jason。听到您说 LSTM 在时间序列方面表现不佳,我感到很惊讶。我正在尝试实现的是一个二进制序列分类模型,使用我上面描述的设置。如果您认为 LSTM 并非我所描述的正确方法,您认为哪种模型最有效?我想在新读取数据传入时处理数据,并在每次获得新读取时给出分类输出。
我原计划使用您的帖子《使用 Keras 在 Python 中进行 LSTM 循环神经网络的序列分类》作为我的起点,但现在您让我担心我走错了路。
LSTM 可以很好地用于时间序列分类。
通常,我建议采用以下过程
https://machinelearning.org.cn/how-to-develop-a-skilful-time-series-forecasting-model/
您好,Jason。我想在 LSTM 层之前添加一个全连接层,但不知道如何重塑数据。输入数据 (train_x) 是 3D (batch_size,time_step,input_dim),我首先想将数据重塑为 2D,以便应用于全连接层。在操作全连接层之后,我必须将全连接层的 2D 输出重塑为 3D,以便应用于 LSTM 层。我正在使用 Keras 函数 API,但我找不到一个可以做到这一点的重塑层 (keras.layers.reshape 无法做到这一点)。您有什么想法吗?
全连接层不能将 3D 数据作为输入,它必须是 [样本,特征]。
所以我想转换数据的形状,也许这不是一个正确的想法。
但非常感谢您的耐心帮助。
您好 Jason,当您写道:“如何为 LSTM 模型重塑多个并行序列数据并定义输入层”时
这句话是指文本+标签数据吗?例如,带有并行 IOB(内部-外部-开始)标签的命名实体识别的文本数据?例如
Alex I-PER
is O
going O
to O
Los B-LOC
Angeles I-LOC
如果您在这篇文章中谈论的是不同的东西,您是否有关于准备此类并行文本序列数据的其他文章?
该示例通常指数字序列。
对于词汇中的词编码,我建议从这里开始
https://machinelearning.org.cn/start-here/#nlp
抱歉,我没有处理标签数据的示例。
嗨,Jason,
我有点困惑 model.add(LSTM(32)) 这部分。数字 32 代表 32 个神经元吗?或者更具体地说,是 LSTM 的 32 个记忆单元吗?
谢谢
Steven
是的,32 是隐藏层中的单元数。第一隐藏层中的每个单元都会接收所有输入。
嗨,Jason,
我正在进行犯罪预测项目。我有一个数据集,行是日期(时间戳),列是区域(特征)。每个单元格包含特定区域发生的犯罪数量。
总行数 = 1825 天的每个区域的犯罪计数或 5 年
这是数据集。
日期\区域 111 112 113 114
0 5 2 2 0
1 3 3 9 0
2 5 4 8 0
3 4 4 3 0
4 9 11 9 0
我想使用滑动窗口进行预测,它将以 100 天作为输入并预测
第 101 天的输出,即每个区域的犯罪数量。
在这里,我将考虑前 3 行(0-2)作为输入并预测输出,即第 4 行(3)
我将数据框移动 -3
问题
1) X_train 形状,y_train 形状是什么?
(1,1825,4)
这里样本 = 1(?),时间步 = 1825 行,特征 = 4 列
我说的对吗?
样本究竟是什么?
2) model.add(LSTM(4, batch_input_shape=(1,1825,1),
activation=’relu’,return_sequences=True,))
batch_input_shape 的输入将是什么 [Batch_size, sequence_length, features]??
batch_input_shape 应该与 X_train 形状相同吗?
sequence_length
我浪费了两天时间试图找出这两者之间的关系。
请帮忙。
也许可以从这篇帖子开始准备滑动窗口
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
然后在这里更好地理解如何将滑动窗口重塑为 3D
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
您好 Jason,感谢您的教程,
我有一个问题,我有一个时间序列数据集,大约有 38,000 名患者,每位患者记录了一小时的 38 个生理参数,每位患者至少记录了 25 小时的参数,为了澄清
患者 1:特征 1,特征 2,…… 特征 38,小时 1,标签
特征 1,特征 2,…… 特征 38,小时 2,标签
………………………………,小时 25,标签
患者 2:特征 1,特征 2,…… 特征 38,小时 1,标签
特征 1,特征 2,……,特征 38,小时 2,标签
………………………………,小时 25,标签
…….
患者 38000:……
该模型应该尽快预测患者是否患有该疾病。
我的问题是我将如何塑造我的输入数组?我不明白样本会是什么
(样本,时间步,特征)->(?,例如 7 小时?,38)还是什么?
也许这会有进一步的帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
重塑如何影响训练/目标数据。
dataset = dataset.reshape(1,36,66)
train_data = dataset[:,0:32,:65]
train_targets = dataset[:,0:32,65:]
test_data = dataset[:,32:,:65]
test_targets = dataset[:,32:,65:]
def build_model()
model = Sequential()
model.add(LSTM(32,input_shape=(32,65)))
model.add(Dense(1))
model.compile(optimizer=’rmsprop’, loss=’mse’, metrics=[‘mae’])
return model
model = build_model()
model.fit(train_data, train_targets,
epochs=30, batch_size=16, verbose=0)
test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)
我收到以下信息:ValueError: Error when checking target: expected dense_40 to have 2 dimensions, but got array with shape (1, 32, 1)
如果我重塑目标
train_targets = train_targets.reshape(32,1)
test_targets = test_targets.reshape(4,1)
我收到以下信息
ValueError: Input arrays should have the same number of samples as target arrays. Found 1 input samples and 32 target samples.
看来我赢不了。我该怎么做?谢谢
每个输入样本必须有一个输出样本。
您好 Jason,您能帮我重塑 LSTM 的数据吗?
我有一个数据集,形状为 (4615, 9),4618 个输入,9 个特征和 3 个类别(标签)需要预测。
我想重塑我的数据,使输入形状有 5 个时间步。我尝试这样做
X = np.reshape(X, (923,5,X_train.shape[1]))
但我在 train_test_split 时遇到了错误。
我只能让它使用一个时间步工作 X_test = np.reshape(X_test, (X_test.shape[0],1,X_test.shape[1]))
🙁
也许这会使事情更清楚
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
感谢您的教程。我正在尝试构建一个水文模型,它可以预测提前期为 10 天的径流,但我对如何调整数据形状感到困惑。首先,我假设我会移动 x 和 y 数据以反映滞后,并最终得到每个 355 (365-10) 个样本。假设我有 4 个特征——x 的基本形状将是 (355, 4)。355 是代表样本数量还是时间步数量?它们在我看来是相同的,但我认为我需要将数据重塑为 (1, 355, 4) 或 (355,1, 4)。或者可能是 (5, 355/5, 1)——等等。或者,我是否需要生成单独的滞后(1)序列以生成类似 (100, 355, 4) 的东西?
也许这有助于理解样本和时间步之间的区别
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨 Jason
您是否有关于如何使用 LSTM 和/或 CNN 进行时间序列预测时使用同期条件上下文的示例/建议(例如,根据给定周的价格以及销售和价格的历史记录预测下周的产品销售)。与多元预测的区别在于,预测周的条件上下文是已知的。谢谢!
您可以根据需要构建任何输入的预测问题。
先生,如果我使用 LSTMs(编码器-解码器模型)来总结文章,我会输入句子向量,编码器将其编码为固定大小的向量,但我想知道
1) 模型如何知道它必须保留哪些关键词或句子来总结,然后解码器如何处理句子?
2) 我可以使用神经语言模型来重新构架句子吗?
但我不知道如何解决问题 (1)
感谢您的博文!
模型将学习哪些词在文本中很重要。
抱歉,我不明白您的第二个问题。也许您可以详细说明一下?
先生,简单来说,我可以使用神经语言建模来使用 LSTM 总结文本吗?
不。您可以使用神经文本摘要模型来总结文本。单独的语言模型是文本摘要模型的一部分。
先生,我可以使用编码器-解码器网络来总结文本吗?
是的
https://machinelearning.org.cn/encoder-decoder-models-text-summarization-keras/
尊敬的先生,非常感谢您的帖子,如果您有决策树回归的源代码来预测时间序列数据
谢谢。
我没有关于这个特定情况的教程。
据我理解,样本是数据框中的行数(可以是整个数据集或其子集);特征是独立变量(x 变量)。我对时间步感到困惑。我的理解正确吗?我有一个时间序列数据集,包含 10 个特征,600 个观测值(行)。我如何设置输入形状?有不同的方法吗?谢谢!
也许这会使它更清楚
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
感谢您的贡献 Jason,我已经多次访问您的博客,它们总是让我对概念有更好的理解。
无论如何,我想知道如何处理每个标签在不规则间隔观察到的特征。我还没有找到如何处理这个问题的解决方案。也许我忽略了什么。
我是否需要将时间步长划分为非常小的间隔,如果未在该时间步长观察到,则将观测值设置为 0?我是否会计算一个规则间隔并添加一个偏移特征?还是其他什么?
提前感谢。
您可以标准化数据的形状,使所有样本具有相同的形状,然后使用零填充和掩码层来忽略填充值。
文本分类问题的重塑是否类似?当有 30000 个样本,每个样本有 300 个特征时,如何重塑 input_shape?此外,当它实际上不是时间序列数据时,时间步长在这里的含义是什么?
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
还有这个。
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
你好 jason,
非常感谢您精彩的教程。有一点我不太明白。如果我有 7000 个数据集(样本),每个数据集包含 3 个长度为 3000 时间步的时间序列,现在我想对每个数据集(异常检测)(对于每个样本)使用 LSTM 进行二元分类,
我的问题是,我该如何进行?我的输入会是什么样子?因为 (7000, 3000, 2) 对 LSTM 来说太大了。我的时间序列长度非常大(3000)。我也读过这个教程,但我的问题是,我想在训练中使用所有信息。
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
其次,每个样本(包含 2 个时间序列的数据集)彼此独立。
提前感谢
也许可以尝试动态 RNN?
我的博客上可能有编码器-解码器的示例。
Jason,感谢您的快速回复。但是您能更详细地解释一下吗?
我们不是将动态 RNN 用于可变长度序列吗?而且正如我之前所说,我想使用 LSTM 而不是 RNN。
其次,我不知道我的输入应该是什么样子(在大时间序列的情况下),如果您能解释一下,我将不胜感激。
是的,动态 RNN 可以用于可变长度输入。
是的,LSTM 是 RNN。动态 LSTM 是动态 RNN。
您可以在此处了解有关如何准备输入的更多信息
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
再次感谢,但我之前已经阅读了您提供的链接。但我的问题是,我知道在我这种情况下,小时间序列的输入应该是什么样子(7000,时间步数,2)。但在这个例子中,我的每个时间序列都有 3000 个时间步(每个 7000 个样本)。
所以,我的问题是如何将这种输入形状(7000,3000,2)最优地馈送到 LSTM 中,因为正如您之前在一个教程中提到的,LSTM 的时间序列最佳长度应该小于 400 个时间步。我的情况很特殊,因为每个数据集(每个 7000 个样本)彼此独立,我的任务是将它们分类为异常或非异常,但是每个时间序列的长度为 3000,这会降低模型的准确性。
非常感谢您的时间。
天真地看,你不能。你必须修剪时间步长。
或者,你可以,但你必须使用动态 LSTM。
非常感谢 🙂
您好,先生,
我的模型有以下数据,
Xtrain 形状:(62, 30, 100)
Ytrain 形状:(62, 1, 100)
Xtrain 形状:(16, 30, 100)
Ytrain 形状:(16, 1, 100)
在执行以下操作时,
model = Sequential()
model.add(LSTM(units=100, return_sequences= True, input_shape=(x_train.shape[1],100)))
model.add(LSTM(units=100, return_sequences=True))
model.add(LSTM(units=100))
model.add(Dense(units=100))
我收到 ValueError: Error when checking target: expected dense_1 to have 2 dimensions, but got array with shape (62, 1, 100)
请对此进行澄清。
修正
Xtrain 形状:(62, 30, 100)
Ytrain 形状:(62, 1, 100)
Xtest 形状:(16, 30, 100)
Ytest 形状:(16, 1, 100)
目标 (y) 必须是 2D 数组,而不是 3D 数组
lstm 单元像 lstm(32, input-shape) 一样是什么?它们与时间步、特征或嵌入有什么关系?
单元数量与输入时间步和特征的数量无关。
每个单元接收所有输入。
嗨,Jason,
我是机器学习新手,我对 Dense 层和 Dense 输出有些困惑,下面两个示例有什么区别,如下所示,我将特征数量设置为 1 来预测,但示例 2 为什么像 LSTM 和输出 Dense 32 一样添加 Dense。
这对我非常重要,你能帮我吗
谢谢您。
1)
model = Sequential()
model.add(LSTM(32, input_shape=(10, 2)))
model.add(Dense(1))
2)
model = Sequential()
model.add(Dense(32, input_shape=(16,)))
model.add(Dense(32))
第一个示例输出一个包含 1 个元素的向量,第二个示例输出一个包含 32 个元素的向量。
嗨,Jason,
我有一个数据集,包含 3 个特征,每个特征由一个 200 维向量表示。
([200d],[200d],[200d]), 标签。
我想知道如何为 LSTM 重塑数据?
谢谢
抱歉,我不明白。您是指 3 个时间步和每个时间步 200 个特征吗。
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
没错。3 个时间步,每个时间步 200 个特征。
[0.4 0.3 …0.1],[0.56 0.22 ….0.5],[0.66 0.43..0.7] , 标签 =+1
实际上,每个时间步都以向量形式具有一个特征。我在 Keras 中遇到了数据类型错误。它期望浮点数。
错误是“”
无法将字符串转换为浮点数”
也许可以先尝试将字符串数据转换为浮点数?
如果数据是字符串格式的数字,您可以在 numpy 数组上使用 .astype() 或类似的方法。
如果不是,也许可以研究整数编码、one-hot 编码、词袋或词语分词器。
假设我有一个 GRU 网络。我希望每个输入都以向量形式。大多数
我见过的情况都是整数形式。我该怎么做
才能给 GRU 提供向量形式的输入?
非常感谢,Jason
可以,每个时间步一个特征向量。请看这里
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
我不得不写这段代码
model = Sequential()
model.add(LSTM(4, input_shape=(1,4))
model.add(Dense(4, activation=’relu’))
model.add(Dense(1, activation=’sigmoid’)
但我看到了以下错误
文件“”,第 5 行
model.add(Dense(4, activation=’relu’))
^
SyntaxError: invalid syntax
我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨,Jason,
我有一个这样的数据集。
2000-01 x1= [1, 2, 3, 4; x2=[5, 6, 9, 8; y=[4, 6, 3, 8;
5, 6, 7, 8; 1, 6, 5, 4; 8, 5, 2, 9;
4, 6, 0, 9;] 8, 4, 3, 5;] 7, 5, 3, 6;]
2000-02 x1= [1, 6, 5, 4; x2=[5, 6, 9, 8; y=[4, 6, 3, 8;
5, 6, 7, 8; 7, 5, 3, 6; 8, 5, 2, 9;
8, 4, 3, 5;] 8, 4, 3, 5;] 5, 6, 9, 8;]
2000-03 x1= [5, 6, 5, 4; x2=[5, 6, 9, 8;
9, 6, 7, 8; 7, 5, 3, 6;
1, 4, 3, 5;] 8, 4, 3, 5;]
我想知道我是否可以使用 LSTM 和 2000-03 年的数据来预测 y。如果可以,我想知道如何为 LSTM 重塑数据?
谢谢你。
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
您好,Jason。感谢您的精彩解释。
您能帮我理解以下问题吗
1. 时间步长为 1 的 LSTM——它是一个简单的 MLP 还是仍然使用隐藏状态/单元状态?时间戳为 1 时,状态初始值是多少?
2. LSTM 自动编码器时间步长选择的建议?
数据示例:索引——周数,特征 1——每周访问次数,特征 2——每周假期数量,特征 3——房间访问次数。
可能有点相似,尽管模型在样本之间保持状态。
尝试不同数量的时间步长,并使用能为您带来最大技能的数量。
嗨,Jason,
您有关于 LSTM 每个门输入数据形状如何变化的博客吗?
假设您的输入形状是 (1000,10,36),并将其传递给 LSTM(64),那么 LSTM 每个门的输出形状会是什么(即在遗忘门、输入门和输出门之后)
我们无法配置每个门,只能配置一个层中所有节点的输入。
给出的示例重塑错误。
它的形状应该是 (2,10,1) 而不是 (1,10,2),因为有 2 个序列,每个序列有 10 个时间戳观测值,在给定时间只有一个特征。
不。每个序列都会成为每个时间步的一个独立特征。
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
我明白如何创建 LSTM 所需的 3D 形状。现在我有 200 个样本,每个样本有 600 个时间步和 7 个特征。
[200,600,7]
X_train, X_test, y_train, y_test = train_test_split(dataset,test_size = 0.30)
X_train[140,600,7]
X_test[60,600,7]
y_train[140,600,1]
y_test[60,600,1]
#构建 LSTM
model = Sequential()
model.add(LSTM(100, input_shape=(450, 11)))
model.add(Dense(1))
model.add(Activation(‘softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=Adam(0.001), metrics[‘accuracy’])
model.summary()
model.fit(X_train,y_train, batch_size=88, epochs=40, validation_split=0.2)
我收到以下错误消息
ValueError: 检查目标时出错:预计 activation_10 具有 2 个维度,但得到的数组形状为 (140, 600, 1)。我似乎无法拟合模型。
希望您能帮我找到错误。
您必须指定与您的数据匹配的 input_shape。
我以为这个匹配:model.add(LSTM(100, input_shape=(450, 11)))
但是您说您的数据形状是:[200,600,7]
[200,600,7]
X_train, X_test, y_train, y_test = train_test_split(dataset,test_size = 0.30)
X_train[140,600,7]
X_test[60,600,7]
y_train[140,600,1]
y_test[60,600,1]
#构建 LSTM
model = Sequential()
model.add(LSTM(100, input_shape=(600, 7)))
model.add(Dense(1))
model.add(Activation(‘softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=Adam(0.001), metrics[‘accuracy’])
model.summary()
model.fit(X_train,y_train, batch_size=140, epochs=40, validation_split=0.2)
ValueError: 检查目标时出错:预计 activation_10 具有 2 个维度,但得到的数组形状为 (140, 600, 1)。我似乎无法拟合模型。
我仍然得到相同的 ValueError。
y 必须是 2d,而不是 3d。
但是每个样本都有 600 个输出作为标签。(60,600,1)
例如
x_train(1,600,7) 第一个样本有 600 个时间步和 7 个特征,这将帮助神经网络识别某些模式。
y_train(1,600,1) 第一个样本的 600 个标签。我应该这样重塑它吗?(1,600)
错误提示模型期望输出具有 2d 形状——错误甚至告诉您它期望的形状。
谢谢。我查阅了您博客中提到的所有示例。
https://machinelearning.org.cn/start-here/#deep_learning_time_series
看起来我正在处理多变量 LSTM 的多个输入。我有一个问题。
# 将多变量序列分割成样本
def split_sequences(sequences, n_steps)
X, y = list(), list()
for i in range(len(sequences))
# 找到此模式的末尾
end_ix = i + n_steps
# 检查我们是否超出了数据集
if end_ix > len(sequences)
break
# 收集模式的输入和输出部分
seq_x, seq_y = sequences[i:end_ix, :-1], sequences[end_ix-1, -1]
X.append(seq_x)
y.append(seq_y)
return array(X), array(y)
# 定义输入序列
in_seq1 = array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])
# 转换为 [行, 列] 结构
in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))
# 水平堆叠列
dataset = hstack((in_seq1, in_seq2, out_seq))
# 选择时间步数
n_steps = 3
# 转换为输入/输出
X, y = split_sequences(dataset, n_steps)
在您发布的示例中。它从原始的 9 行 2 列序列创建了一个 3D 形状(7,3,2)。
在实践中,它将如何工作?我的想法是给一个固定大小的 2D 张量 (100,3),并作为输出得到 (100,) 100 个输出。我相信 LSTM 是一个一个输出地预测的。对吗?
这意味着如果我想得到 100 个输出,我将需要用这些 2D 张量 (100,3) 喂给神经网络 -> 将其重塑为例如 (90,10 个时间步,3 个特征) 的 3D 形状,并将所有输出连接到一个数组中,直到我得到 90 个输出?
好问题,您可以在这里了解 LSTM 的输入形状
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
我读过您的其他博客,它们对我这个机器学习初学者非常有帮助。我以前没有使用过 LSTM,这是我第一次。
我目前正在尝试训练视频序列数据以对所涉及的情绪进行分类。然而,通过查看数据,我对如何建模我的 LSTM 有点困惑。
我的数据包括从 615 个短视频片段中的每个片段连续 90 帧中提取的单个特征(长度为 8192 的向量)。视频片段具有相同的采样率。
每个样本(每个视频)的标签是一个 6 X 1 的向量(6 种不同的情绪)
我知道在建模 LSTM 时,我不需要关心 615,因为它是样本的数量。但是我该如何处理 90 帧呢?这是 LSTM 的时间步数吗?
您能告诉我应该如何将数据输入到 LSTM 以及 LSTM 的输入形状吗?
是这样吗
8192 将是 [样本,时间步,特征] 输入数据中的特征。
嗨 Jason
非常感谢您的回复。我成功地构建并编译了一个模型。
这是我构建的模型
x=Input(shape=(90,8192))
lstm=LSTM(100, activation= ‘relu’)(x)
lstm = Dropout(rate = 0.5)(lstm)
output1=Dense(1, activation=’softmax’)(lstm)
output2=Dense(1, activation=’softmax’)(lstm)
output3=Dense(1, activation=’softmax’)(lstm)
output4=Dense(1, activation=’softmax’)(lstm)
output5=Dense(1, activation=’softmax’)(lstm)
output6=Dense(1, activation=’softmax’)(lstm)
model =Model(x,[output1,output2,output3,output4,output5,output6])
model.compile(optimizer=”Adam”,loss=[“binary_crossentropy”,”binary_crossentropy”,”binary_crossentropy”,”binary_crossentropy”,”binary_crossentropy”,”binary_crossentropy”],metrics=[‘accuracy’])
8192 是 InceptionV3 从视频中每一帧提取的扁平化特征输出的形状。
Y_train 的形状 = (543,6,1)
我现在面临的问题是我的模型准确率不会超过 30。
我尝试在 softmax 单元之前添加不同形状的密集层,也尝试了不同 lstm 单元形状。改变批处理大小或优化器也没有提高准确性。
您能看看我的模型并帮助我找出我犯的错误吗?
我还尝试改变了 Dropout 率
干得好。
也许这里的一些方法能帮助您调试和提高模型性能
https://machinelearning.org.cn/start-here/#better
嗨,Jason,
感谢您持续发布高质量的文章。我有一个关于重塑 LSTM 训练数据维度的问题。我的数据有 11 个特征和 544 个观测值。如果我将时间步长设置为 1,我的样本数是 544/1 = 544,并且数据的维度正确设置为:dim(data) = c(544, 1, 11)。然而,当我将时间步长设置为例如 7,样本数设置为 544/7 时,数据的维度并没有被 dim(data) = c(544/7, 7, 11) 设置,我得到了错误
dims [product 5929] 与对象长度 [5984] 不匹配。
根据您常见问题解答中的一个问题,我假设样本数 X 时间步长 = 数据中的行数。您能告诉我这里出了什么问题吗?
谢谢,
Rahul
不客气。
将时间步长设置为 1 似乎是个奇怪的举动。
这将有助于区分时间步长和样本
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
谢谢您的回复。我确实按照这个链接并了解到,对于不相交的观测块,样本数 X 时间步数 = 数据中的行数。由于我的数据是每日时间序列,并且我想将每一行视为一个训练实例或样本,所以我将时间步数保持为 1,因此,样本数 = 544/1 = 544。但是,如果我想将时间步数更改为任何其他值,我就会收到我之前帖子中提到的错误。
也许本教程中描述的函数能帮助您准备数据
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
谢谢你,Jason,的回复。
不客气。
嗨,Jason,
您能否澄清如何使用 dim() 函数在 R 中重塑数据以匹配 LSTM 的要求?如果我添加第三个维度,它是否就是时间步长?此外,为什么时间步长 = 1 是一个奇怪的举动?我将不胜感激您的帮助。
抱歉,我没有 R 中 LSTM 的示例。也许可以尝试在 stackoverflow 上发布您的问题?
极好的指导。
清晰明了。
谢谢你。
不客气。
嗨,Jason,
我读了 https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input,但对时间步长仍然不清楚。
例如,我使用过去 7 天的数据来预测今天的值(价格)。
每天有 6 个特征的一条记录(我们称之为 feature1 – feature5 和 price)。
假设我有 1000 天的数据。
现在我将 [i:i+7] 作为我的 X,[i+7+1][price] 作为我的 y。因此,X 的形状是 993*7*6,y 的形状是 993。
X 的形状是否与 [样本][时间步][特征] 匹配?
或者我应该在每行中创建 42 个特征,例如 t-1, t-2, ..., t-7?那么时间步长是 1,特征是 42?
是的,第一种方法听起来合理。尽管 1000 个时间步太多了,可以考虑减少到 200-400。
谢谢你的回复。
你说的减少到 200-400 是什么意思?你是说 7 天的数据太少了?也许我应该使用,例如,过去 500 天的数据作为我的 X?
抱歉,我的意思是也许可以改变问题的框架,使其最大时间步长为 200-400,据报道这在实践中是 LSTM 的合理限制。
明白了。谢谢。
不客气!
您将如何重塑数据以适应 1D conv 模型?它与 LSTM [样本,时间步,特征] 相同吗?
是的,一样!
亲爱的杰森。
我的问题是,假设我有一个模型 lstm/dropout/LSTM/dropout/flatten/dense
那么这里的隐藏层数量将是 5,即 dropout/LSTM/dropout/flatten/dense
如果我的数据有 2000 个特征,62 个样本,我可以将其重塑为 62,1,2000 吗?
输入 LSTM 神经元/单元的数量应该是 2000 还是不是?
此致 Srirupa
输入的形状与 LSTM 层中的节点数是分开的。
输入形状必须与数据集中的时间步长和特征数量匹配
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
谢谢你,Jason。
现在这个问题的答案是什么
假设我有一个模型 lstm/dropout/LSTM/dropout/flatten/dense
那么这里的隐藏层数量将是 5,即 dropout/LSTM/dropout/flatten/dense
此致 Srirupa
只计算有权重的层。
Jason..每次都感谢您的回复。
继续上一个问题..这意味着假设我有一个 lstm(128)/dropout(0.2)/lstm(64)/dropout(0.2)/flatten()/dense(1)..除了 dropout 和输入 lstm 层之外,是否应该有 3 个隐藏层?
请务必回复..这对我真的很有帮助
此致 Srirupa
尊敬的 Jason,我的上述问题有意义吗,还是完全错误?
此致 Srirupa
不客气。
我就是这样计数的。
嗨,Jason,
我有 n 个样本,每个样本有 49 个时间步(过去观测值)和 2 个特征(x 和 y 坐标)。我希望网络学习下一个时间步(第 50 个),以便它可以预测下一个 x 和 y 坐标。我实现了一个 LSTM 网络,但它没有学习。我认为问题出在输出的形状。我是否必须重塑我的目标集,使其形状为 (n_samples, 2),或者我必须修改输出密集层并将层大小设置为 2?我不明白如何告诉我的网络输出是 2D……
是的,您可以将模型配置为具有 2 个输出特征,例如输出层中有 2 个节点。
这意味着每个样本的目标将是一个向量,而不是一个值。例如,y 的形状是 [n, 2]
你好 Jason,
我目前正在使用 LSTM 架构处理一些视频骨架数据。我以与上述相同的方式准备了我的数据(多个数组、144 个特征和不同视频序列的不同帧数)。然而,我不太确定如何重塑我的训练数据以用于输入张量。问题是,通常在处理不同视频样本具有不同帧数的视频序列时,重塑训练数据(视频样本)的适当方法是什么?我当时在想,由于输入时间步长是固定的,也许一种方法是为每个视频序列采样相同数量的视频帧,代价是会丢失一些信息。我想向您请教一下您的看法,如果可能的话。非常感谢。
从上述代码中描述的想法来看,我的理解是,也许唯一的方法是使用预定义的时间步长来为每个视频序列采样帧,然后从那里开始。
是的,截断/采样到相同数量的帧将是一个简单的首要尝试。
嗨,Jason,
我最近正在用 Keras 编写关于 LSTM 模型的代码,但我对数据形状有一些疑问。我的数据是这样的
[list([[1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 3, 6, 5, 5, 4, 4, 12]])
list([[13, 14, 15, 16, 17, 18, 1, 19], [16, 14, 18, 1, 20, 14, 21, 22]])
list([[1, 2, 23, 6, 24, 25, 7, 26, 27], [28, 28, 29, 30, 31, 23, 1, 4, 6, 7, 25, 26], [32, 29, 33, 34, 17, 33, 1, 23, 6, 7, 35, 26]])]
第一行/列表是关于一个病人的诊断,它包含两次就诊,第一次就诊包含 1,2,3,4,5,6,7,8 个诊断,第二次就诊包含 9,…,12 个诊断。对于不同的病人,就诊次数不同,每次就诊的诊断代码长度也不同。
我应该如何用这些数据构建一个 LSTM 模型?期待您的回复!
我相信这将有助于解决 LSTM 数据形状问题
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
你好先生,
我正在尝试使用不同长度的多个时间序列来训练 LSTM 模型。为了训练目的,我以 25 毫秒的窗口大小分割了每个片段。对于每个这样的片段,我提取 5 个特征。
所以,总而言之,#样本 = #音频片段,#时间步长 = #片段(每个文件不同),#特征 = 5(固定)。
我的疑问
1) 我是否需要通过填充或将较长的文件分成较小的部分来固定 #时间步长?
2) 如果不需要,那么我应该以哪种数据类型来组织 3D 输入?
此外,样本,即片段,在 LSTM 中是否被认为是相互独立的?
LSTM 在一个批次内的样本之间具有记忆/状态。
对于可变长度输入,我建议填充到固定长度并使用掩码层。
https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
此外,这将有助于塑造数据
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
你好,解释得很好,但我正在为一个问题而苦恼,如果我们将样本假定为 1,但我的因变量的形状例如是 (50000,1),那么如何重塑以匹配样本维度?我不能将样本更改为 50000,因为那将超出矩阵的整数值,请告诉我该怎么做。
好问题,这会有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
你好。Jason。非常感谢。
我正在为一个问题而苦恼,如果我的训练集是 [样本=1,时间步=6,特征=6],并且我将 LSTM 输入形状设置为 (样本=1,时间步=6,特征=1),那么其余特征是被忽略了,还是重复直到第 6 个特征?
它不会允许您那样重塑数据,会抛出错误。
你好 Jason,感谢您的这篇帖子。我从中学习了很多。
我被一个问题困扰着。
我的数据集是用户每天每个小时测量的数值。例如
ID | 00:00 | 01:00 | … | 23:00
1 | v1 | v2 | … | v24
2 | v1 | v2 | … | v24
…
我正在做时间序列分类。
如果我想使用每小时数据(每天 24 个值)来对 ID 进行分类,那么输入形状会是 (样本数, 24, 1) 吗?
或者应该是 (样本数, 1, 24)?
我阅读了大部分评论,但有点困惑。如果神经元数量与输入时间戳无关,那是否意味着网络将根据时间戳馈送数据?
例如,如果时间戳是 24,特征是 2,每个 RNN 神经元将被馈送 24 次,并且每次会馈送 2 个特征?
好问题,这会有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
好文章,Jason。非常感谢!
谢谢!
我有一个问题。数据及其形状与神经网络之间有什么关系。例如,如果我的数据形状为 (45,1,700),那么神经网络应该如何预测输出?
好问题,我在这里回答
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
你好 Jason,感谢您的这篇帖子。
我正在研究一个文本分类模型,我使用 Keras 功能 API,我想将 CNN 多通道文本(大小 (0.768))的三个扁平输出与一个额外的特征向量连接起来,该向量每个单词有 16 个特征,然后将此向量馈送到 LSTM 网络。我有点困惑如何重塑这个向量。
请看这个例子
https://machinelearning.org.cn/cnn-long-short-term-memory-networks/
目标是训练一个模型,该模型可以根据患者入住 ICU 后 48 小时内的四项生理测量数据预测患者的死亡率。
描述和数据
数据下载链接:https://www.dropbox.com/s/si0acy6z67wk0y9/Midterm2.zip?dl=0
在 train 文件夹中,您会找到四个 csv 文件(Heart.csv、Temperature.csv、Respiration.csv、Glucose.csv),其中包含同一医院中入住 ICU 的 2000 名患者的四项生理测量数据。行表示患者,列表示患者每小时的生理测量数据。有 48 列,表示患者入住 ICU 后的前 48 小时。50% 的患者在 ICU 中存活,其余 50% 在前 48 小时后的某个时间死亡。
类别标签存储在 y_train.csv 中(1:存活,0:死亡)。y_train.csv 只有一列,表示类别标签。假设 y_train.csv 和测量 csv 文件中患者的顺序相同。
首先,您需要将这四个文件加载到一个形状为 (2000,48,4) 的 numpy 张量 x_train 中,其形式为(#训练样本数,#时间步数,#特征数)。这里 #时间步数是 48,#特征数 = 4(四项生理指标)。这可以通过不同的方式完成。一种方法是首先创建一个形状为 (2000,48,4) 的空 x_train 张量。加载每个 csv 文件,并简单地将数据沿最终轴复制到 x_train。例如,x_train[:,:,0] 可以存储心脏测量数据,x_train[:,:,0] 可以存储温度测量数据等等。此外,将类别标签加载到形状为 (2000,) 的 y_train 张量中。
在 test 文件夹中,您还会找到四个 csv 文件(Heart.csv、Temperature.csv、Respiration.csv、Glucose.csv),其中包含相同的 400 名测试患者的四项生理测量数据。您需要将这四个文件加载到形状为 (400,48,4) 的 x_test 张量中。类别标签存储在 y_test.csv 中(1:存活,0:死亡)。此外,将类别标签加载到形状为 (400,) 的 y_test 张量中。y_test.csv 只有一列,表示类别标签。假设 y_test.csv 和测量 csv 文件中患者的顺序相同。
模型
创建一个包含以下层的 Keras CNN 模型
• 1D CNN 层
• ReLU 激活层。
• 窗口大小 = 4,步长 = 1 的 1D MaxPooling 层。
• 扁平化层。
• 输出密集层,带一个节点和 sigmoid 激活。
• 使用二元交叉熵作为损失函数
• 使用早停准则,耐心 = 3。
超参数优化
在上述模型中,对以下超参数进行超参数优化。每个超参数的不同选项都已显示。只需一种超参数优化方法即可。
• 核长度 = 3, 5。
• 核数 = 6, 32, 64, 92。
• 批量大小 = 20, 30, 50。
• 优化器 = Adam, SGD, RMSprop。
• 学习率 = 1*lr, 0.1*lr, 10*lr,其中 lr 是 Keras 中优化器的默认学习率。
也许这里的一些想法能帮助你
https://machinelearning.org.cn/start-here/#better
也许比较线性模型?
也许比较其他机器学习模型?
也许这里的一些想法能帮助你
https://machinelearning.org.cn/machine-learning-performance-improvement-cheat-sheet/
嗨,
首先,您的所有文章都非常有帮助,谢谢!
我遇到了一个问题,即使重塑(reshape)顺利进行,我仍然收到一个错误,提示测试数据在维度上与训练数据不匹配。
因此我有一个 [5000,140] 的数据框。通过 80/20 的拆分,我得到了 train_data=(4000,140) 和 test_data=(1000,140)。通过重塑,如果我理解正确的话,这应该变成 train_data=(1,4000,140) 和 test_data=(1,1000,140)?
现在即使重塑是正确的,在运行自编码器时,我在 validation_data 处收到了一个错误,提示训练数据和测试数据的时间步长不相等,但它必须相等。这是什么意思?我如何正确重塑维度以避免此错误?
自编码器的输出形状与其他预测模型不同,因为您正在尝试重建输入,请参阅此示例
https://machinelearning.org.cn/lstm-autoencoders/
Jason,很棒的帖子。我有一个问题。我的数据集是 600 个时间序列的两个特征。所以是 (600,2) 维数组。我按照您的建议将其重塑为 (1,600,2) 或 (3,200,2)。这是我的 X_train。我不确定我的 y_train 应该是什么?
根据 LSTM 的结构,这必须是一个单值(对于 (1,600,2))或 3 个值(3,200,2)。这个数组中应该有什么精确的值?
我正在尝试开发一个模型来对给定序列的值进行分类。非常感谢您的任何指导。
目标 (y) 是您想要预测或分类的每个样本的输出。
非常感谢您及时回复,Jason。
如果我理解正确,当我的测试数据是 (1,600,2) 时,y_train 应该是 (1,),其中包含类标签作为元素。当我按照您的建议将其拆分为 (3,200,2) 时,我该如何处理这个问题?
我的类标签在这里不起作用,因为它们代表一个包含 600 个时间步的完整类。
我希望我已正确解释了情况,期待您的回复。
抱歉,我不太明白。
此外,只有一个或三个样本的数据集听起来不适合训练 LSTM 模型。
尊敬的先生,我是一名计算机科学学生,专攻软件工程,目前正在做我的毕业设计。我的项目是预测给定聚合物的生命周期(直到它断裂),所以我的数据集中有 3 列:在特定小时内施加到聚合物上的力,它给我们聚合物上的应力,所以输出是一个数值,即应力值(非线性回归)。我尝试使用 CNN,但没有成功,所以我正在尝试使用 LSTM 网络,但我的数据结构需要随机分割,就像 train_test_split 函数那样,但我看到的所有 LSTM 网络都使用手动模式,允许数据按顺序分割,这样更容易将时间序列附加到训练和测试数据中,所以我很好奇 LSTM 是否适用于这个回归问题,以及如何将时间序列附加到 train_test_split 函数(ndarrays)的输出变量的教程,要知道我尝试将它们转换为数组和列表,但不幸的是总是出现错误,我真的需要答案,很抱歉我的英语不是我的母语,谢谢
LSTM 假设数据是序列,如果您没有序列,那么它不是一个合适的方法。
这个教程会有帮助
https://machinelearning.org.cn/when-to-use-mlp-cnn-and-rnn-neural-networks/
谢谢你
不客气。
你好 Jason,感谢您对我们所有人的支持。
我想知道我是否可以使用 LSTM 来预测以下情况的结果。
我的数据集结构如下
DVICE_NO MSE. CR. 年龄
————————————
3 13 0.1 70
1 26 0.5 67
2 … … …
. … … …
. … … …
1 20 0 87
3 26 1 66
2 12 1.2 90
3 27 1.8 88
MSE 范围从 0 到 30 (0..30),CR 范围从 0 到 5 (0..5),年龄范围从 30 到 45 (30..45)。
如您所见,对于同一设备,我们有不同的行(例如在下表中,我们有关于设备#3 的三个不同的读数)。我的目标是使用 LSTM 来预测我们数据集中所有设备的未来读数;换句话说,设备#3 的 MSE 和 CDR 是什么?
您能否帮我了解这是否适用,如果适用,我需要什么数据准备才能馈送到 LSTM。
提前感谢
LSTM 可能适用,也许可以尝试一下,并将其结果与其他算法(如 MLP、CNN 和其他机器学习算法)进行比较。
先生,
我有一个数据集,包含 444 行和 81 列(特征)。我需要将其输入到 LSTM。我如何将此数据转换为 3D 数据以输入到 LSTM 模型中。
恳请您的回复。
好问题,这会教您如何操作
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
我有一个疑问。双向 RNN (GRU/LSTM) 的输入和输出维度是否可能相等?
例如,如果输入层维度是 (128,16,128),后面跟着一个隐藏层维度为 32 的双向 GRU,并且我们得到的输出也等于输入,即 (128,16,128)?
您可以按任何您喜欢的方式设计模型。
嗨,Jason,
感谢您的迅速回复。我尝试了,但当我使用 32 个隐藏单元在 Bi-GRU 中时,对于输入维度 (None, 64,16),我得到的输出维度是 (None, 64,32)。
如果您想控制模型的输出步数,也许编码器-解码器类型的模型更适合您。
我正在使用如下所示的代码
output = Bidirectional(GRU(32, return_sequences=True), merge_mode=’mul’)(input)
你好
请帮助我解决以下问题
import keras
来自 keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout, LSTM
from keras.optimizers import Adam
import pandas as pd
# 数据集导入
dataset = pd.read_csv('C:\\Users\\Fatima\\Downloads\\train_subject1_raw01.csv') # 您需要相应地更改目录
# print(dataset.head(10))
X = dataset.iloc[:,:32].values
y = dataset.iloc[:,32:33].values
# 数据归一化
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X = sc.fit_transform(X)
# print(X)
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder()
y = ohe.fit_transform(y).toarray()
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2)
print("train size: {}".format(X_train.shape))
print("train Label size: {}".format(y_train.shape))
print("test size: {}".format(X_test.shape))
print("test Label size: {}".format(y_test.shape))
X_train = X_train.reshape(1, 97893, 32)
y_train = y_train.reshape(1,97893 ,3)
X_test = X_test.reshape(1,24474,32)
y_test = y_test.reshape(1,24474,3)
print("train size: {}".format(X_train.shape))
print("train Label size: {}".format(y_train.shape))
print("test size: {}".format(X_test.shape))
print("test Label size: {}".format(y_test.shape))
# 初始化分类器网络
classifier = Sequential()
classifier.add(LSTM(128, input_shape=(X_train.shape[1:]), return_sequences=True))
classifier.add(Dropout(0.2))
# 添加第二个 LSTM 网络层
classifier.add(LSTM(128))
# 添加一个密集隐藏层
classifier.add(Dense(64, activation='relu'))
classifier.add(Dropout(0.2))
# 添加输出层
classifier.add(Dense(3, activation='softmax'))
# 编译网络
classifier.compile( loss='categorical_crossentropy',
optimizer=Adam(lr=0.001, decay=1e-6),
metrics=['accuracy'] )
print(classifier.summary())
# 将数据拟合到模型
# classifier.fit(X_train, y_train,epochs=3,validation_data=(X_test, y_test))
print("train size: {}".format(X_train.shape))
print("train Label size: {}".format(y_train.shape))
print("test size: {}".format(X_test.shape))
print("test Label size: {}".format(y_test.shape))
classifier.fit(X_train, y_train, batch_size =batch_size, epochs = 1, verbose = 5)
test_loss, test_acc = classifier.evaluate(X_test, y_test)
print('Test Loss: {}'.format(test_loss))
print('Test Accuracy: {}'.format(test_acc))
错误发生于
classifier.fit(X_train, y_train, batch_size =64, epochs = 1, verbose = 5)
ValueError: 形状 (None, 97893, 3) 和 (None, 3) 不兼容
这是我在这里回答的一个常见问题
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
嗨,jason
请帮我看看这些代码。
# 导入库
import math
from math import sqrt
import numpy as np
from numpy import concatenate
import pandas as pd
from pandas import DataFrame
from pandas import concat
from pandas import read_csv
from sklearn.preprocessing import MinMaxScaler
# from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import mean_squared_error
来自 keras.models import Sequential
from keras.layers import Dense, LSTM
import matplotlib.pyplot as plt
from matplotlib import pyplot
# plt.style.use('fivethirtyeight')
# 加载数据集
dataset = read_csv('feature5_ctu_nil_targ.csv', header=0, index_col=0)
values = dataset.values
print(dataset.shape)
# 确保所有数据都是浮点型
values = values.astype('float32')
# 归一化特征
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# 将数据集分为 75/25 用于训练和测试
training_dataset_length = math.ceil(len(dataset) * .75)
print(training_dataset_length)
train = values[:training_dataset_length, :]
test = values[training_dataset_length:, :]
# 分割输入和输出
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
# 将输入重塑为 3D [样本, 时间步, 特征]
# n_features=5
train_X = np.reshape(train_X, (train_X.shape[0], 1, train_X.shape[1]))
# train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
# train_y = train_y.reshape((train_y.shape[0], 1, train_y.shape[1]))
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
# test_X = np.reshape(test_X (test_X.shape[0], 1, test_X.shape[1]))
# test_y = test_y.reshape((test_y.shape[0], 1, test_y.shape[1]))
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)
# print(train_y.shape)
# 设计网络
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(LSTM(units=30, return_sequences=True))
model.add(LSTM(units=30))
model.add(Dense(units=1))
model.compile(loss='mae', optimizer='adam')
model.summary()
# 拟合网络
history = model.fit(train_X, train_y, epochs=10, batch_size=50, validation_data=(test_X, test_y), verbose=2, shuffle=False)
# 绘制历史记录
'''pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history[‘val_loss’], label=’测试’)
pyplot.legend()
pyplot.show()'''
'''# 检查预测值
predictions = model.predict(test_X)
# 撤销缩放
predictions = scaler.inverse_transform(predictions)
# 计算 RMSE 分数
rmse=np.sqrt(np.mean(((predictions- test_y)**2)))
print(rmse)'''
# 进行预测
yhat = model.predict(test_X)
test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))
# 反向缩放以进行预测
inv_yhat = concatenate((yhat, test_X[:, 1:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
# 反向缩放以获得实际值
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_X[:, 1:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]
# 计算 RMSE
rmse = sqrt(mean_squared_error(inv_y, inv_yhat))
print('Test RMSE: %.3f' % rmse)
ValueError: 运算数形状 (81367,3) (4,) (81367,3) 不兼容,无法进行广播
也许这些提示会有帮助
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
嗨,Jason,
感谢您的精彩帖子。我有一个包含 5000 名患者的数据集。每位患者的生物信号已记录 60 秒,频率为 80Hz,即我有 5000 个单变量样本,每个样本包含 4800 个数据点。我想将我的时间序列分类为两个类别(死亡率 vs 非死亡率)。如果我想使用 LSTM 或 CNN 进行分类,您能告诉我应该如何构建 X_train 以及 input_shape 是什么样的吗?据我所知,LSTM 的时间步长应该在 200-400 之间。假设我选择 200。以下两种情况中哪一种是正确的?
1) 我是否必须将每个信号分成 200 个片段?由于每个片段将有 24 个数据点 (4800/200 = 24),我是否必须将每个片段转换为一个单一数字(例如通过对 24 个值求平均)?是否可以这样说
X_train = (5000, 200)
input_shape = (5000, 200, 1)?
2) 我是否必须将每个患者的信号分成 24 个样本(每个样本包含 200 个数据点)?是否可以这样说
X_train = (24*5000, 200)
input_shape = (24*5000, 200, 1)?
我将不胜感激您的帮助。
也许这些提示会有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
我尽量避免发表看法,因为没有一种最佳方法来构建预测问题。相反,请尝试几种不同的数据构建方法,并发现哪种方法效果好或最佳。
嗨,jason
能否将输入层而不是第一个隐藏层作为输入?
谢谢
不,输入层不是隐藏层。
您好 Jason,感谢您的 LSTM 教程。
我尝试将这些概念应用到一个非常简单的例子上。
我获得了某只股票 5 年的收盘价(即 1500 个值),并尝试预测第二天股票的收盘价
我想考虑前 10 个样本来预测第二天。
因此,时间序列是一个特征,而 Y(目标)是相同时间序列,但向后移动了一天
X= [2.376227, 2.376227, 2.360171, …, 4.983 , 4.973 , 5.004 ]
Y= [ 2.376227, 2.360171, …, 4.983 , 4.973 , 5.004 ]
然后,在对两者进行归一化并进行训练集和测试集分割后
X_scaled, Y_scaled -> X_scaled_train, Y_scaled_train
现在我必须在将 X_scaled_train 传递给 LSTM 之前对其进行重塑,但不需要对 Y_scaled_train 进行重塑(对吗?)。
....
每个 LSTM 层的输入必须是三维的。
此输入数据的三个维度是:
• 样本。一个序列就是一个样本。一个批次由一个或多个样本组成。
• 时间步。一个时间步是样本中的一个观测点。
• 特征。一个特征是时间步长中的一个观测值。
....
在这种情况下,1500 个样本应该重塑为 150 (1500/10)
X_scaled_train = np.reshape(X_scaled_train, (150, 10, 1))
构建模型
1
2
3 model = Sequential()
model.add(LSTM(32, input_shape=(10, 1)))
model.add(Dense(1))
optimizer = tf.keras.optimizers.Adam(learning_rate=2e-04)
model.compile(loss=tf.keras.losses.Huber(),optimizer=optimizer,metrics=["mae"])
.....
拟合模型
history = model.fit(X_scaled_train,y_scaled_train,epochs=100,batch_size = 1,callbacks = [early_stopping])
请问这个过程是否正确?
非常感谢。
抱歉,内容太长,我无法阅读。您可以尝试一下,看看结果是否符合您的预期。
你好 Jason!感谢您的工作!!我有一个问题:在我的工作中,我有一个数据框,其中每一行都包含患者多年来的记录,每一列都是一个特征。输出是 0 或 1,取决于患者是否患有该疾病。
例如,对于 2 年和 5 个特征:X 是 [[1 2 3 4 5], [1 3 5 6 4]],输出是 [0 1]
我的目标是通过 LSTM 预测下一个患者是否会患有该疾病,但我不明白我应该如何重塑数据。对于 10 年和 5 个特征,我的 y 有 10 个值(每年一个),我应该将 X 塑造成什么形状?
我认为这篇文章可以给您一些启发:https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
请注意 n_steps(时间步数)和 n_features
你好 Jason,感谢您的精彩教程。
您有一个关于使用 LSTM 进行人类活动识别的教程。在该示例中,输入形状是 (128,9)。这意味着 128 个时间步和 9 个特征。批处理大小等于 64。据我所知,它表示在每个过程中,64 个样本被输入到网络中,每个样本包含 128 个时间步和 9 个特征。我说的对吗?
在该教程中,提到有一个 50% 的重叠窗口,因为 128/64 = 2。我在这里对重叠的含义感到困惑。当每个过程中有 64 个样本被馈送到层时,窗口重叠是如何发生的?
再次感谢您的时间。
您对批处理的理解是正确的。
重叠是时间序列特有的概念。想象一下你有时间 1, 2, 3 等。你有一个大小为 10 的窗口。显然,第一个数据窗口是 1 到 10,但第二个数据窗口呢?在 50% 重叠的情况下,是 6 到 15。在 0% 重叠的情况下,你使用 11 到 20。
嗨 Jason
我修改了代码以使其与我的数据兼容(一个包含 405 个时间步和 920 个特征的 csv 文件)
当我运行代码时,在 epoch 1 后,损失为 nan,输出向量完全为 nan
我用一个小文件(包含 405 个时间步和 4 个特征的 csv 文件)测试过,它工作正常。
如果可能,您能帮我一下吗?
尊敬的Jason博士,
感谢您的教程。
LSTM 模型的输入数据是 3D 的,如简单示例所示
数组的形状为
样本数 = 批量大小 = 1
时间步数 = 行数 = 10
特征数 = 列数 = 1
澄清问题
(1)样本数 = 批量大小 = 1 – 这是一步预测吗?
如果
2(a) 样本数 = 批量大小 = 2 是一步提前预测吗?
2(b) 即使批量大小 = 2,我们也能预测一步提前吗?
2(c) 设置一个模型,batch_size >= 2 – LSTM 的 input_shape 有 3 个参数。
model.add(LSTM(32, input_shape=(2, 10, 1)))
谢谢你,
悉尼的Anthony
这里的批次大小应该是你的 LSTM 在隐藏层中应该记住多少。你总是得到一步提前预测,但批次大小告诉你何时应该重置隐藏状态。
亲爱的 Jason 和团队,
非常感谢所有这些内容,这是我在互联网上看到过的最好的网站。
我有一个关于我想解决的问题的疑问。我有一个具有周期性的信号(随时间变化的电压),我想用神经网络检测当这个周期减少一定百分比时,以便我可以激活一个执行器(开关执行器)。我读过您的关于 LSTM 的书,我认为我可以使用序列分类 LSTM 架构。这有意义吗?
另外我不知道如何为拟合模型的 x 和 y 输入准备数据。我的猜测是 x 将是随时间变化的电压,y 将是该执行器的布尔值(即当周期减少时)。这正确吗?
非常感谢,来自西班牙的问候!
你好,米格尔…以下资源可能对你有所帮助
https://machinelearning.org.cn/how-to-develop-lstm-models-for-multi-step-time-series-forecasting-of-household-power-consumption/
你好。我有一个与这些问题相关的问题。我有一系列数据,一个样本的每个输入由4个不同的时间序列组成。作为输出,我有一个与输入长度相同的每个样本的一个时间序列。当我重新排列矩阵时,输入自然比输出多4倍的行。Keras给出了错误“ValueError: 数据基数不明确
x 大小:504
y 大小:126
请确保所有数组包含相同数量的样本。”
我如何解决这个问题?行数必须相同,但每个样本我有4个输入行和1个输出行。
谢谢。
你好,奥默…以下讨论可能对你有所帮助
https://stackoverflow.com/questions/62253289/valueerror-data-cardinality-is-ambiguous
早上好,先生,感谢您的解释。
我的问题是:如何处理多个具有不同时间步长的样本?我应该重新塑形它们吗?然后,如果我将模型应用于实际生活,会怎样?时间步长的长度必须匹配,还是仅仅是一个训练问题?
你好,Alessia…以下资源可能对你有所帮助
https://machinelearning.org.cn/use-timesteps-lstm-networks-time-series-forecasting/
非常感谢。
此外,我应该使用什么函数或程序来连接每个样本并重新塑形数组?
嗨
使用:data = data.reshape(-1, 10, 2) 也正确吗?
尊敬的Jason博士,
我一直在学习和工作中运用您的示例和解释。
我有一个关于形状的问题,这就是我回到基础知识的原因,但我仍然没有找到我的答案,并希望分享我的示例。
我有一个多通道多步输入
(1000个样本,20个时间步,4个特征)。
使用LSTM和CNN训练这个3D输入时效果很好,但我想知道是否可以提高模型的速度并节省一些资源,因为这四个特征中有3个在样本内部没有变化。
想象一下,只有第一个特征在所有20个时间步长内发生变化(曲线)(例如带噪声的正弦曲线),但所有其他3个特征相对恒定(温度,压力,湿度)。
曲线 = [0,18,36,54,72 …. 344]
特征_温度 = [10,10,10,10,11…10]
特征_压力 = [990,991,991,991,….,991]
特征_湿度 = [60,60,60,60…..60]
我在想
有没有办法用混合输入(1000,20,1)和(1000,1,3)来馈送模型?我希望馈送曲线和特征的平均值。
我在想是否可以直接将特征的平均值作为每个曲线的最后时间步添加,但我担心这不是真正的方法。
非常感谢您的课程、书籍、博客文章,当然还有回复
你好,M. Ramos…以下资源可能对你有所帮助
https://www.kaggle.com/code/shivajbd/input-and-output-shape-in-lstm-keras
你好!
首先,非常感谢您的工作!这提供了大量的学习材料,使我能够学习这部分内容。
我正在为系统辨识做LSTM。我首先描述系统辨识任务,使用数值积分(例如,四阶Runge-Kutta积分器)离散化具有控制输入的非线性状态空间模型(ODE:xdot = f(x, u, t)),这将获得每个状态的时间序列数据。
在此之前,我大致使用NARX-MLP进行系统辨识并取得了良好的预测精度。当我想用LSTM替换预测模型时,我遇到了一些问题
1. 在NARX-MLP中,预测模型是xk = fnn(xk-1, …, xk-na, uk-1, …, uk-nb),其中fnn通过MLP近似。这只需要通过滑动窗口转换状态时间序列并实现监督训练。动态模型通过滑动窗口和静态MLP近似。但是LSTM可以自己学习时间依赖性,我们还需要使用滑动窗口吗?我看到作者提到“多对一”具有更好的性能。这是否意味着仍然可以使用滑动窗口?
2. 如果我使用滑动窗口,那么我如何将这些时间序列转换为合法的LSTM输入?以单状态单控制输入为例,在时间t=tk,设na=nb=2,那么:特征=(xk-1, xk-2, uk-1, uk-2);标签=xk。所有序列数据都转换为这种形式。在pytorch中,LSTM输入数据格式是:(batch, seq_len, hidden_size)。这里,seq_len是2还是1?
写了很多,再次感谢!
你好,文超…不客气!以下地点是利用深度学习进行时间序列预测的一个很好的起点
https://machinelearning.org.cn/start-here/#deep_learning_time_series
感谢您的解释。
我仍然有疑问。
我有12个不同的时间序列数据集,时间间隔相同,均为0.002秒,每个数据集的行数不同。
这是传感器数据。
我的方法是创建一个新列来标识每个数据集,并将所有数据集组合起来,以建立一个可以正确预测0和1输出的通用模型。
我的训练数据形状是(5111548,60)。
你能告诉我LSTM的输入数据形状应该是什么吗?你能告诉我这个问题还有其他方法吗?
谢谢你
你好,Vins…不客气!以下讨论可能会提供一些想法
https://datascience.stackexchange.com/questions/117009/how-to-arrange-multiple-multivariate-time-series-of-different-length-before-pass