序列分类是一个预测建模问题,其中您有一些跨空间或时间的输入序列,任务是预测序列的类别。
这个问题很困难,因为序列的长度可能不同,可能包含非常大的输入符号词汇表,并且可能要求模型学习输入序列中符号之间的长期上下文或依赖关系。
在这篇文章中,您将了解如何使用 Keras 深度学习库在 Python 中为序列分类问题开发 LSTM 循环神经网络模型。
阅读本文后,你将了解:
- 如何为序列分类问题开发 LSTM 模型
- 如何通过使用 dropout 减少 LSTM 模型中的过拟合
- 如何将 LSTM 模型与擅长学习空间关系的卷积神经网络结合起来
通过我的新书《自然语言处理深度学习》启动您的项目,包括分步教程和所有示例的 Python 源代码文件。
让我们开始吧。
- 2016 年 7 月:首次发布
- 2016 年 10 月更新:更新了 Keras 1.1.0 和 TensorFlow 0.10.0 的示例
- 2017 年 3 月更新:更新了 Keras 2.0.2、TensorFlow 1.0.1 和 Theano 0.9.0 的示例
- 2018 年 5 月更新:更新了代码以使用最新的 Keras API,感谢 Jeremy Rutman
- 2022 年 7 月更新:更新了 TensorFlow 2.x 的代码,并添加了一个使用双向 LSTM 的示例

使用 Python 和 Keras 中的 LSTM 循环神经网络进行序列分类
图片由 photophilde 提供,保留部分权利。
问题描述
您将在本教程中用于演示序列学习的问题是 IMDB 电影评论情感分类问题。每个电影评论都是一个可变单词序列,必须对每个电影评论的情感进行分类。
大型电影评论数据集(通常称为 IMDB 数据集)包含 25,000 条高度两极分化的电影评论(好或坏)用于训练,以及相同数量的评论用于测试。问题是确定给定电影评论是积极情感还是消极情感。
该数据由 斯坦福大学研究人员收集,并用于 2011 年的一篇论文中,其中数据以 50/50 的比例用于训练和测试。准确率达到 88.89%。
Keras 提供了对 IMDB 数据集的内置访问。imdb.load_data() 函数允许您以适合在神经网络和深度学习模型中使用的格式加载数据集。
单词已被整数替换,这些整数表示数据集中每个单词的有序频率。因此,每个评论中的句子都由一个整数序列组成。
词嵌入
您将把每个电影评论映射到一个实数向量域,这是一种处理文本时流行的技术——称为词嵌入。这是一种将单词编码为高维空间中的实值向量的技术,其中单词在含义上的相似性转化为向量空间中的接近性。
Keras 提供了一种方便的方法,通过嵌入层将单词的正整数表示转换为词嵌入。
您将把每个单词映射到 32 长度的实值向量。您还将把我们感兴趣的建模单词总数限制在最常见的 5000 个单词之内,其余的归零。最后,每个评论中的序列长度(单词数)各不相同,因此您将把每个评论限制为 500 个单词,截断长评论并用零值填充短评论。
现在您已经定义了问题以及如何准备和建模数据,您已准备好开发一个 LSTM 模型来分类电影评论的情感。
需要 LSTM 帮助进行序列预测吗?
参加我的免费7天电子邮件课程,了解6种不同的LSTM架构(附代码)。
点击注册,同时获得该课程的免费PDF电子书版本。
用于序列分类的简单 LSTM
您可以为 IMDB 问题快速开发一个小型 LSTM,并获得良好的准确性。
让我们首先导入此模型所需的类和函数,并将随机数生成器初始化为常数值,以确保您可以轻松重现结果。
1 2 3 4 5 6 7 8 9 |
import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) |
您需要加载 IMDB 数据集。您将数据集限制为前 5,000 个单词。您还将数据集分为训练集 (50%) 和测试集 (50%)。
1 2 3 |
# 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) |
接下来,您需要截断并填充输入序列,使它们都具有相同的长度以进行建模。模型将学习零值不携带任何信息。序列在内容方面长度不同,但需要等长向量才能在 Keras 中执行计算。
1 2 3 4 |
# 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) |
您现在可以定义、编译和拟合您的 LSTM 模型。
第一层是嵌入层,它使用 32 长度的向量来表示每个单词。下一层是具有 100 个记忆单元(智能神经元)的 LSTM 层。最后,因为这是一个分类问题,您将使用一个具有单个神经元和 sigmoid 激活函数的全连接输出层,用于问题中的两个类别(好和坏)进行 0 或 1 预测。
由于这是一个二元分类问题,因此使用对数损失作为损失函数(Keras 中的 binary_crossentropy)。使用高效的 ADAM 优化算法。模型只拟合了两个 epoch,因为它很快就会过度拟合问题。使用 64 条评论的大批量大小来分散权重更新。
1 2 3 4 5 6 7 8 9 |
# 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=64) |
一旦拟合,您可以评估模型在未见过评论上的性能。
1 2 3 |
# 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
为了完整性,这里是 IMDB 数据集上此 LSTM 网络的完整代码列表。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
# IMDB 数据集中的序列分类 LSTM import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) # 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) # 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, epochs=3, batch_size=64) # 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
注意:由于算法或评估过程的随机性,或数值精度的差异,您的结果可能会有所不同。考虑多次运行示例并比较平均结果。
运行此示例将产生以下输出。
1 2 3 4 5 6 7 |
Epoch 1/3 391/391 [==============================] - 124s 316ms/step - loss: 0.4525 - accuracy: 0.7794 Epoch 2/3 391/391 [==============================] - 124s 318ms/step - loss: 0.3117 - accuracy: 0.8706 Epoch 3/3 391/391 [==============================] - 126s 323ms/step - loss: 0.2526 - accuracy: 0.9003 准确率:86.83% |
您可以看到,这个经过少量调整的简单 LSTM 在 IMDB 问题上取得了接近最先进的结果。重要的是,这是一个模板,您可以用来将 LSTM 网络应用于您自己的序列分类问题。
现在,让我们看看这个简单模型的一些扩展,您可能也希望将它们应用于您自己的问题。
带有 Dropout 的 LSTM 用于序列分类
像 LSTM 这样的循环神经网络通常存在过拟合问题。
Dropout 可以使用 Dropout Keras 层在层之间应用。您可以通过在嵌入层和 LSTM 层之间以及 LSTM 和密集输出层之间添加新的 Dropout 层来轻松实现这一点。例如:
1 2 3 4 5 6 |
model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Dropout(0.2)) model.add(LSTM(100)) model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) |
上面带有 Dropout 层的完整代码示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# 带有 Dropout 的 LSTM 用于 IMDB 数据集中的序列分类 import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Dropout from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) # 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) # 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Dropout(0.2)) model.add(LSTM(100)) model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, epochs=3, batch_size=64) # 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
注意:由于算法或评估过程的随机性,或数值精度的差异,您的结果可能会有所不同。考虑多次运行示例并比较平均结果。
运行此示例会提供以下输出。
1 2 3 4 5 6 7 |
Epoch 1/3 391/391 [==============================] - 117s 297ms/step - loss: 0.4721 - accuracy: 0.7664 Epoch 2/3 391/391 [==============================] - 125s 319ms/step - loss: 0.2840 - accuracy: 0.8864 Epoch 3/3 391/391 [==============================] - 135s 346ms/step - loss: 0.3022 - accuracy: 0.8772 准确率:85.66% |
您可以看到 dropout 对训练产生了预期的影响,收敛趋势略慢,并且在这种情况下,最终准确率较低。模型可能需要再训练几个 epoch,并且可能会获得更高的技能(尝试一下看看)。
另外,可以将 dropout 精确地单独应用于内存单元的输入和循环连接。
Keras 通过 LSTM 层的参数提供了此功能,其中 **dropout** 用于配置输入 dropout,**recurrent_dropout** 用于配置循环 dropout。例如,您可以修改第一个示例以如下方式将 dropout 添加到输入和循环连接:
1 2 3 4 |
model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2)) model.add(Dense(1, activation='sigmoid')) |
下面列出了带有更精确的 LSTM dropout 的完整代码,以供参考。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
# 带有 dropout 的 LSTM 用于 IMDB 数据集中的序列分类 import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) # 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) # 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, epochs=3, batch_size=64) # 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
注意:由于算法或评估过程的随机性,或数值精度的差异,您的结果可能会有所不同。考虑多次运行示例并比较平均结果。
运行此示例会提供以下输出。
1 2 3 4 5 6 7 |
Epoch 1/3 391/391 [==============================] - 220s 560ms/step - loss: 0.4605 - accuracy: 0.7784 Epoch 2/3 391/391 [==============================] - 219s 560ms/step - loss: 0.3158 - accuracy: 0.8773 Epoch 3/3 391/391 [==============================] - 219s 559ms/step - loss: 0.2734 - accuracy: 0.8930 准确率:86.78% |
您可以看到,LSTM 特有的 dropout 对网络收敛的影响比层级 dropout 更显著。与上面一样,epoch 数量保持不变,并且可以增加以查看模型技能是否能进一步提升。
Dropout 是对抗 LSTM 模型过拟合的强大技术,两种方法都值得尝试。不过,您可能会通过 Keras 中提供的门控特定 dropout 获得更好的结果。
用于序列分类的双向 LSTM
有时,反向使用序列效果更好。在这种情况下,您只需在使用 Python 语法 `x[::-1]` 反转向量 `x`,然后再用它来训练您的 LSTM 网络。
有时,正向或反向顺序都不能完美地工作,但将它们结合起来会产生更好的结果。在这种情况下,您将需要一个**双向 LSTM 网络**。
双向 LSTM 网络只是两个独立的 LSTM 网络;一个使用正向序列输入,另一个使用反向序列输入。然后将两个 LSTM 网络的输出连接起来,然后馈送到网络的后续层。在 Keras 中,您可以使用 `Bidirectional()` 函数克隆一个 LSTM 层,用于正向-反向输入并连接它们的输出。例如:
1 2 3 4 |
model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Bidirectional(LSTM(100, dropout=0.2, recurrent_dropout=0.2))) model.add(Dense(1, activation='sigmoid')) |
由于您创建了不止一个,而是两个各有 100 个单元的 LSTM,因此该网络的训练时间将是原来的两倍。根据问题,这种额外的成本可能是合理的。
下面列出了在最后一个示例中添加双向 LSTM 的完整代码,以供参考。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
# 带有 dropout 的 LSTM 用于 IMDB 数据集中的序列分类 import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Bidirectional from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) # 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) # 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Bidirectional(LSTM(100, dropout=0.2, recurrent_dropout=0.2))) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, epochs=3, batch_size=64) # 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
注意:由于算法或评估过程的随机性,或数值精度的差异,您的结果可能会有所不同。考虑多次运行示例并比较平均结果。
运行此示例会提供以下输出。
1 2 3 4 5 6 7 |
Epoch 1/3 391/391 [==============================] - 405s 1s/step - loss: 0.4960 - accuracy: 0.7532 Epoch 2/3 391/391 [==============================] - 439s 1s/step - loss: 0.3075 - accuracy: 0.8744 Epoch 3/3 391/391 [==============================] - 430s 1s/step - loss: 0.2551 - accuracy: 0.9014 准确率:87.69% |
似乎您只能获得轻微的改进,但训练时间显著延长。
LSTM 和卷积神经网络用于序列分类
卷积神经网络擅长学习输入数据的空间结构。
IMDB 评论数据在评论的单词序列中确实具有一维空间结构,CNN 可能能够识别出好坏情感的不变特征。然后,这些学习到的空间特征可能被 LSTM 层作为序列学习。
您可以轻松地在嵌入层之后添加一维 CNN 和最大池化层,然后将合并的特征馈送给 LSTM。您可以使用一组相对较小的 32 个特征和较小的滤波器长度 3。池化层可以使用标准长度 2 将特征图大小减半。
例如,您可以按如下方式创建模型:
1 2 3 4 5 6 |
model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')) model.add(MaxPooling1D(pool_size=2)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) |
以下是包含 CNN 和 LSTM 层的完整代码列表,以供参考。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
# LSTM 和 CNN 用于 IMDB 数据集中的序列分类 import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Conv1D from tensorflow.keras.layers import MaxPooling1D from tensorflow.keras.layers import Embedding from tensorflow.keras.preprocessing import sequence # 设置随机种子以保证结果可复现 tf.random.set_seed(7) # 加载数据集,但只保留前 n 个单词,其余归零 top_words = 5000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # 截断并填充输入序列 max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) # 创建模型 embedding_vecor_length = 32 model = Sequential() model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length)) model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')) model.add(MaxPooling1D(pool_size=2)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) model.fit(X_train, y_train, epochs=3, batch_size=64) # 模型的最终评估 scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100)) |
注意:由于算法或评估过程的随机性,或数值精度的差异,您的结果可能会有所不同。考虑多次运行示例并比较平均结果。
运行此示例会提供以下输出。
1 2 3 4 5 6 7 |
Epoch 1/3 391/391 [==============================] - 65s 163ms/step - loss: 0.4213 - accuracy: 0.7950 Epoch 2/3 391/391 [==============================] - 66s 168ms/step - loss: 0.2490 - accuracy: 0.9026 Epoch 3/3 391/391 [==============================] - 73s 188ms/step - loss: 0.1979 - accuracy: 0.9261 准确率:88.45% |
您可以看到,您取得了比第一个示例稍好的结果,尽管权重更少,训练时间更快。
您可能会期望,如果这个示例进一步扩展以使用 dropout,甚至可以取得更好的结果。
资源
如果您有兴趣深入研究序列预测或此特定示例,以下是一些资源。
- 应用于 IMDB 数据集的 LSTMs 的 Theano 教程
- Keras 代码示例,用于在 IMDB 数据集上使用 LSTM 和 CNN。
- 带有循环神经网络的监督序列标注,Alex Graves 2012 年的书(和 PDF 预印本)。
总结
在这篇文章中,您学习了如何开发用于序列分类预测建模问题的 LSTM 网络模型。
具体来说,你学到了:
- 如何为 IMDB 电影评论情感分类问题开发一个简单的单层 LSTM 模型
- 如何使用层级和 LSTM 特定的 dropout 扩展您的 LSTM 模型以减少过拟合
- 如何将卷积神经网络的空间结构学习特性与 LSTM 的序列学习结合起来
您对使用 LSTM 进行序列分类或本文有任何疑问吗?请在评论中提出您的问题,我将尽力回答。
太棒了!
谢谢 Atlant。
您是如何得到 16,750 的?25,000 / 64 个批次是 390。
谢谢!
我对 LSTM 的输入/输出维度感到困惑,特别是在 keras 库中。为什么 keras 返回 2D 输出而其输入是 3D?我知道它可以使用“return_sequence = True”返回 3D 输出,但如果 return_sequence = False,它如何处理 3D 并生成 2D 输出?例如,如果输入数据形状为 (32, 16, 20),32 批量大小,16 时间步,20 特征,输出形状为 (32, 100),32 批量大小,100 隐藏状态;keras 如何处理 3d 输入并返回 2d 输出。此外,如果输入和隐藏状态没有精确的维度,如何连接它们?
嗨 Hajar…您可能会发现以下内容有帮助
https://machinelearning.org.cn/reshape-input-data-long-short-term-memory-networks-keras/
嗨,我有一个问题,如果有人能回答的话。我有表格数据。多个列(即 4 列)有文本数据。就像这里一样。https://github.com/IBM/KPA_2021_shared_task。我将如何将这些表格数据转换为矩阵并对其应用 lstm 模型。
LSTMs 不适用于表格数据,它们需要序列数据。
这可能有帮助
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
嗨,Jason,
祝贺兄弟,持续提供出色且易于适应/理解的课程。我只是好奇想了解无监督和强化神经网络,您有任何教程吗?
此致,
Sahil
谢谢 Sahil。
抱歉,目前还没有关于无监督学习或强化学习与神经网络的教程。不过很快就会有。
嗨,您在这里发布的东西很棒,谢谢。
这种网络架构是否适用于根据股票价格的时间序列数据预测股票的盈利能力。
例如,使用每日股票价格和交易量的 5 分钟间隔数据(从上午 9:30 到下午 1 点),并与当天剩余交易日股票价格上涨超过 0.5% 的“是”或“否”配对?
每个交易日是一个样本,整个数据集例如是过去 1000 个交易日。
如果这种网络架构不适用,您会建议测试其他哪些架构?
再次感谢这个超级资源。
谢谢 Søren。
当然,值得一试,但我不是股票市场专家。
那么,本教程的最终结果是一个模型。您能给我一个示例,说明如何使用此模型预测新的评论,特别是使用训练数据中不存在的新词汇吗?非常感谢。
Naufal,我没有示例,但新示例需要使用相同的整数对单词进行编码,并将这些整数嵌入到相同的单词映射中。
感谢 Jason 的精彩文章。
为了预测,我做了以下事情,如果我做错了请纠正。你说要嵌入……我没明白。如何做到这一点。
text = numpy.array(['this is excellent sentence'])
#print(text.shape)
tk = keras.preprocessing.text.Tokenizer( nb_words=2000, lower=True,split=" ")
tk.fit_on_texts(text)
prediction = model.predict(numpy.array(tk.texts_to_sequences(text)))
print(prediction)
感谢 Jason 的精彩文章。
为了预测,我做了以下事情,如果我做错了请纠正。你说要嵌入……我没明白。如何做到这一点。
text = numpy.array(['this is excellent sentence'])
#print(text.shape)
tk = keras.preprocessing.text.Tokenizer( nb_words=2000, lower=True,split=" ")
tk.fit_on_texts(text)
prediction = model.predict(sequence.pad_sequences(tk.texts_to_sequences(text),maxlen=max_review_length))
print(prediction)
您可以使用以下代码来预测新评论的情绪。
但是,它会简单地跳过词汇表之外的单词。
另外,您可以在训练前尝试增加“top_words”值,以便覆盖更多单词。
感谢分享!
Embed 指的是词嵌入层
https://keras.org.cn/layers/embeddings/
def conv_to_proper_format(sentence)
>>sentence=text.text_to_word_sequence(sentence,filters='!"#$%&()*+,-./:;?@[\\]^_`{|}~\t\n',lower=True,split=" ")
>>sentence=numpy.array([word_index[word] if word in word_index else 0 for word in sentence])#编码成整数序列
>>sentence[sentence>5000]=2
>>L=500-len(sentence)
>>sentence=numpy.pad(sentence, (L,0), 'constant')
>>sentence=sentence.reshape(1,-1)
>>return sentence
使用此函数将您的评论转换为正确的格式,然后 model.predict(review1) 将给出答案。
你好 Jason!很棒的教程!
当我尝试本教程时,我从 imdb.load_data 收到错误消息
TypeError: load_data() 接收到意外的关键字参数 'test_split'
我尝试复制粘贴整个源代码,但这一行仍然有相同的错误。
您能想到有什么根本原因导致它无法为我执行吗?
很抱歉听到这个消息,Joey。这看起来像是 Keras v1.0.7 的一个变化。
如果我使用 1.0.7 版本运行,也会遇到相同的错误。我看到 API 文档仍然在此处引用 test_split 参数:https://keras.org.cn/datasets/#imdb-movie-reviews-sentiment-classification
我看到该参数已从函数中删除
https://github.com/fchollet/keras/blob/master/keras/datasets/imdb.py
选项 1)您可以从函数中删除该参数以使用默认的测试 50/50 分割。
选项 2)您可以将 Keras 降级到 1.0.6 版本
请记住,您可以在命令行上检查您的 Keras 版本,方法是
我将考虑更新示例以使其与最新 Keras 兼容。
我成功了!非常感谢 Jason 的帮助!
很高兴听到这个消息,Joey。
我已将帖子中的示例更新为与 Keras 1.1.0 和 TensorFlow 0.10.0 匹配。
你好,Jason。
一个快速问题
根据我的理解,前面填充零就像标记“START”。否则就像标记“END”。我应该如何决定是“前”填充还是“后”填充?这有关系吗?
谢谢。
Chong,我想我不太明白这个问题,抱歉。
考虑在您的问题上尝试两种填充方法,看看哪种效果最好。
你好,Jason。
谢谢你的回复。
在“带有 Dropout 的 LSTM 序列分类”一节中,我还有另一个快速问题。
model.add(Embedding(top_words, embedding_vector_length, input_length=max_review_length, dropout=0.2))
model.add(Dropout(0.2))
…
这里我看到两个 dropout 层。第二个很容易理解:对于每个时间步,它只是随机停用输出嵌入向量中 20% 的数字。
第一个让我困惑:它对输入进行 dropout 吗?对于每个时间步,嵌入层的输入应该只是 top_words 的一个索引。换句话说,输入是一个单一数字。我们如何对其进行 dropout?(或者您的意思是丢弃 20% 时间步的输入索引?)
很好的问题,我相信它会从嵌入层到隐藏层的输入节点中删除权重。
您可以在此处了解有关 dropout 的更多信息
https://machinelearning.org.cn/dropout-regularization-deep-learning-models-keras/
Embedding 层中应用的 dropout 能否理解为随机删除句子中的某个词,从而强制分类不依赖于任何词?
我认为没有理由不能——一时兴起。
你为什么说输入是一个数字?它应该是一个转换为词嵌入的句子。例如,如果嵌入向量的长度是 50,句子最多有 500 个单词,这将是一个 (500,50) 矩阵。我认为,它所做的是从总共 50 个嵌入向量中删除一些特征。
你好,
这可能是一个迟来的回复,但我希望分享我对前向填充的思考。前向填充而不是后向填充的原因是,对于像 LSTM 这样的循环神经网络,根据链式法则,较早出现的词获得的更新较少,而最近出现的词对权重更新的影响更大。在序列开头填充零将使后面的内容更好地学习。
李
感谢分享!
嗨 Jason
感谢您对这些复杂主题提供如此简单的解释。
在本教程中,Embedding 层用作输入层,因为数据是单词序列。
我正在解决一个问题,其中我有一个图像序列作为示例,并且每个示例都分配了一个特定的标签。序列中的图像数量因示例而异。我有以下问题
1) 我可以使用 LSTM 层作为输入层吗?
2) 如果输入层是 LSTM 层,是否仍然需要指定 max_len(这是一个约束,说明一个示例可以拥有的最大图像数量)
提前感谢。
有趣的问题,Harish。
我建议您考虑多种不同的方式来表示这个问题,然后尝试几种看看哪种有效。
我的直觉是,在前端对图像数据使用 CNN,然后中间使用 LSTM,后端使用一些密集层来将表示转换为预测。
希望这能有所帮助。
非常感谢 Jason。
您能告诉我如何在不填充的情况下处理此问题中不同长度的序列吗?如果需要填充,如何选择填充图像序列的最大长度。
可变长度的序列需要填充。
根据您可用于评估的所有数据选择最大长度。
感谢您的时间和建议,Jason。
您能解释一下掩码输入层是什么意思以及如何在 Keras 中使用它来处理填充吗?
嗨 Harish,
我正在处理类似的问题,想知道您是否继续处理这个问题?什么奏效了,什么没有奏效?
提前感谢
嗨,Jason,
感谢本教程。太有帮助了!我想将它应用到我自己的问题中。我正在处理一个问题,其中我有一个声学样本序列。序列长度不同,我了解每个序列中产生信号的个体/实体的身份。由于这些序列具有时间元素(每个序列都是时间序列,属于同一序列的序列也与时间相关),我认为 LSTM 是可行的方法。
根据我的理解,本教程中的 Embedding 层用于为数据集添加额外的维度,因为 LSTM 层接收 3D 输入数据。
我的问题是,在我的问题中,将 LSTM 层用作第一层是否明智,因为 Embedding 不适用于我的非整数声学样本?我知道为了将 LSTM 用作我的第一层,我必须以有意义的方式重塑我的数据,以使其满足 LSTM 层的输入要求。我已经填充了我的序列,所以我的数据集目前是一个 2D 张量。然而,用零填充并不理想,因为一些原始声学样本值为零,表示零压级。所以我手动使用了不同的数字进行填充。
我计划在我的 Sequential 模型的末尾使用一组 LSTM 层和一个 Dense 层。
附:我是 Keras 新手。非常感谢您能提供的任何建议。
谢谢你
Gciniwe,我很高兴它有用。
很好的问题,很难回答。我建议您查阅一些关于基于音频的 LSTM 和 CNN 应用的文献,看看使用了哪些表示。我见过的示例(遗憾地)微不足道。
尝试将 LSTM 作为第一层,但也要尝试使用 CNN (1D) 然后 LSTM 以获得更多提取结构的机会。或许也可以尝试 Dense 然后 LSTM。我会在输出层使用一个或多个 Dense。
祝你好运,我非常期待听到你的成果。
嗨 Gciniwe
很高兴看到我也在处理类似的问题。我从事语音和图像处理。我有一个小疑问。请问您是如何选择填充值的?因为在图像中,我们也会有零,无法理解如何进行填充。
提前感谢
当我运行上面的代码时,我得到了以下错误
:MemoryError: 分配失败
导致错误的 Apply 节点:Alloc(TensorConstant{(1L, 1L, 1L) of 0.0}, TensorConstant{24}, Elemwise{Composite{((i0 * i1) // i2)}}[(0, 0)].0, TensorConstant{280})
拓扑排序索引:145
输入类型:[TensorType(float32, (True, True, True)), TensorType(int64, scalar), TensorType(int64, scalar), TensorType(int64, scalar)]
输入形状:[(1L, 1L, 1L), (), (), ()]
输入步幅:[(4L, 4L, 4L), (), (), ()]
输入值:[array([[[ 0.]]], dtype=float32), array(24L, dtype=int64), array(-450L, dtype=int64), array(280L, dtype=int64)]
输出客户端:[[IncSubtensor{Inc;:int64:}(Alloc.0, Subtensor{::int64}.0, Constant{24}), IncSubtensor{InplaceInc;int64::}(Alloc.0, IncSubtensor{Inc;:int64:}.0, Constant{0}), forall_inplace,cpu,grad_of_scan_fn}(TensorConstant{24}, Elemwise{tanh}.0, Subtensor{int64:int64:int64}.0, Alloc.0, Elemwise{Composite{(i0 – sqr(i1))}}.0, Subtensor{int64:int64:int64}.0, Subtensor{int64:int64:int64}.0,
有什么想法吗?我正在使用 theano 0.8.2 和 keras 1.0.8
Nick,很抱歉听到这个消息,我没有见过这个错误。
也许可以尝试 Theano 后端,看看是否有任何不同?
我遇到了同样的问题,我不知道如何解决它。
嗨,Jason,
我有一个问题。我可以使用 RNN LSTM 进行时间序列销售分析吗?我每天只有一年的销售额作为输入。所以总数据点约为 278 个,我想预测未来 6 个月。这么多的数据点是否足以使用 RNN 技术?您能否解释一下 LSTM 和 GRU 之间有什么区别,以及何时使用 LSTM 或 GRU?
Deepak 你好,我的建议是尝试在你的问题上使用 LSTM 看看。
您最好使用更简单的统计方法来预测 60 个月的销售数据。
杰森,这太棒了。谢谢!
我也很想看到一些无监督学习,了解它是如何工作的以及它的应用。
你好 Corne,
我倾向于不写关于无监督技术的教程(特征选择除外),因为我发现像聚类这样的方法在预测建模问题中并不实用。
感谢您撰写本教程。它非常有帮助。为什么 LSTM 不需要对其特征值进行归一化?
Jeff,很好的问题。
通常,当数据缩放到传递函数范围时,神经网络可以获得更好的性能。在这种情况下,我们在 LSTM 中使用 sigmoid 函数,因此我们发现通过将输入数据归一化到 0-1 范围可以获得更好的性能。
希望这能有所帮助。
嗨 Jason,感谢您的精彩教程!
我正在尝试对数据进行归一化,基本上将 X 中的每个元素除以最大值(在这种情况下为 5000),因为 X 在 [0, 5000] 范围内。我得到了更差的性能。有什么想法吗?谢谢!
不。尝试其他缩放方法。
嗨,Jason!您的教程非常有帮助。但我仍然对在 LSTM 单元中使用 dropout 有一个问题。dropout_W 和 dropout_U 的实际效果有什么区别?在大多数情况下,我应该将它们设置为相同的值吗?您能推荐一些与此主题相关的论文吗?非常感谢!
Lau,我建议你参考 API
https://keras.org.cn/layers/recurrent/#lstm
通常,我建议测试不同的值,看看哪个有效。在实践中,将它们设置为相同的值可能是一个很好的起点。
你好,
感谢这篇精彩的文章。我对数据编码有一个问题:“单词已被整数替换,这些整数表示数据集中每个单词的有序频率”。
“有序频率”到底是什么意思?例如,最常用的词最终被编码为 0 还是 4999?
很好的问题,Jeff。
我相信最常见的词是 1。
我认为 0 被保留用于填充或当我们想要截断低频词时。
感谢您非常有用的帖子。
我有一个问题。
在最后一个例子(CNN&LSTM)中,很明显我们获得了更快的训练时间,但是我们如何知道 CNN 适合这里作为 LSTM 的前置层呢?这里所谓的空间结构是什么意思?所以,如果我理解如何判断数据集 X 是否具有空间结构,那么这会是建议在基于序列的问题中在 LSTM 层之前使用 CNN 的合适线索吗?
谢谢,
Mazen
嗨 Mazen,
空间结构就是词的顺序。对于 CNN 来说,它们只是一串数字,但我们知道这个序列具有结构——词(用于表示词的数字)及其顺序很重要。
模型选择很困难。通常,您希望选择在性能和复杂性(易于理解、维护、再训练、投入生产使用)方面达到最佳平衡的模型。
是的,如果问题具有某种空间结构(图像、文本等),请尝试使用保留该结构的方法,例如卷积神经网络(CNN)。
嗨 Jason,很棒的帖子!
我一直在尝试使用您的实验来对来自几个博客的文本进行性别分类。然而,我得到的准确率很低,接近50%。您对如何预处理我的数据以适应模型有什么建议吗?每个博客文本大约有6000个单词,我正在研究如何预处理以应用于您的模型。
谢谢
哇,很酷的项目,Eduardo。
我想知道你是否可以将问题简化到只处理文章的第一句话或第一段。
我想知道你是否可以使用一个好的词嵌入。
我还想知道你是否可以使用CNN而不是LSTM来进行分类——或者至少比较一下单独的CNN与CNN + LSTM,并深入研究哪种效果最好。
总的来说,这里有很多关于提高深度学习问题性能的建议
https://machinelearning.org.cn/improve-deep-learning-performance/
嗨,Jason,
感谢您花费时间提供这个非常有用的教程。
我想知道您是否会考虑在每次训练迭代(epoch)之前随机打乱数据?
谢谢
嗨,Emma,
很好的问题。数据会在每次迭代(epoch)之前通过 fit() 函数自动打乱。
请在此处查看有关 fit() 函数中 shuffle 参数的更多信息
https://keras.org.cn/models/sequential/
嗨,Jason,
您能展示一下如何将所有单词转换为整数,以便它们可以输入 Keras 模型吗?
在 IMDB 中,它们直接使用整数,但我的问题是,我有很多行文本,我必须对它们进行分类(多类别问题)。
此外,在使用 LSTM+CNN 时,我遇到了一个错误
错误 (theano.gof.opt): 优化失败,原因:local_abstractconv_check
错误 (theano.gof.opt): 节点:AbstractConv2d{border_mode=’half’, subsample=(1, 1), filter_flip=True, imshp=(None, None, None, None), kshp=(None, None, None, None)}(DimShuffle{0,2,1,x}.0, DimShuffle{3,2,0,1}.0)
错误 (theano.gof.opt): 堆栈跟踪
错误 (theano.gof.opt): 堆栈跟踪 (最近一次调用)
文件 “C:\Anaconda2\lib\site-packages\theano\gof\opt.py”,第 1772 行,在 process_node 中
replacements = lopt.transform(node)
文件 “C:\Anaconda2\lib\site-packages\theano\tensor\nnet\opt.py”,第 402 行,在 local_abstractconv_check 中
node.op.__class__.__name__)
AssertionError: AbstractConv2d Theano 优化失败:没有可用的实现支持所请求的选项。您是否从优化器中排除了 “conv_dnn” 和 “conv_gemm”?如果在 GPU 上,cuDNN 是否可用并且 GPU 是否支持它?如果在 CPU 上,您是否安装了 Theano 可以链接的 BLAS 库?
我正在 Windows 上使用 Theano 后端和仅 CPU 运行 Keras。
谢谢
嗨,Jason,
您能告诉我IMDB数据库是如何存储数据的吗?是文本还是向量?
谢谢。
嗨,Thang Le,IMDB数据集最初是文本。
这些词被转换为整数(每个词一个整数),我们将数据建模为固定长度的整数向量。因为我们使用固定长度的向量,我们必须将数据截断和/或填充到这个固定长度。
谢谢你,Jason!
那么当我们调用 (X_train, y_train), (X_test, y_test) = imdb.load_data() 时,X_train[i] 会是一个向量。如果它是向量,我该如何将我的文本数据转换为向量以在此处使用?
嗨,Le Thang,好问题。
你可以将每个字符转换为一个整数。然后每个输入都将是一个整数向量。之后,你可以使用一个嵌入层将你的整数向量转换为投影空间中的实值向量。
嗨,Jason,
据我理解,X_train 是电影评论中作为输入的变长词序列,那么 Y_train 代表什么呢?
谢谢!
嗨,Quan Xiu,Y 是输出变量,Y_train 是训练数据集的输出变量。
对于这个数据集,输出值是电影情感值(正面或负面情感)。
谢谢你,Jason。
那么当我们把 X_test 作为输入时,输出会与 y_test 进行比较来计算准确率,对吗?
是的,Quan Xiu,模型做出的预测会与 y_test 进行比较。
这个LSTM网络的性能低于TFIDF + 逻辑回归
https://gist.github.com/prinsherbert/92313f15fc814d6eed1e36ab4df1f92d
你确定隐藏状态不是以非常昂贵的方式简单地计算单词吗?
确实如此,这个例子并没有针对最佳性能进行调优,Herbert。
这留下了一个相当重要的问题:它是否真的学习了比词频计数更复杂的特征?LSTM 通常会这样做吗?显然有关于这个主题的文献,但我认为你的帖子在 LSTM 的能力方面有些误导。如果能看到一个 LSTM 优于 TFIDF 的例子,并提供所需数据类型和大小的 ধারণা,那将是非常棒的。(尽管感谢您的快速回复 :)
LSTMs 只有在它们真正记住上下文信息时才有用,而不是仅仅拟合简单模型并花费很长时间来做这件事。
我同意,Herbert。
LSTMs 很难使用。最初,我想分享如何开始使用这项技术。我打算回到这个例子,测试新的配置,以便从该方法中获得更多/最大的收益。
那太棒了!如果能了解良好性能所需的数据大小(当然,还有成千上万的其他开放问题),那也会很不错 :)
非常感谢您的帖子,Jason。它很有帮助。
我有一些简短的问题。首先,我选择模型的超参数时感到紧张,例如向量长度(32)、嵌入单元数量(500)、LSTM单元数量(100)、最常用词数量(5000)。这取决于数据集,不是吗?我们如何选择参数?
其次,我有一个关于每日新闻的数据集,用于预测股票市场的价格走势。但是,每条新闻的单词数量似乎比IMDB数据集中的每个评论都多。平均每条新闻约2000个单词,您能推荐我如何选择近似的超参数吗?
谢谢,(附注:抱歉我的英语如有任何错误)
嗨,Huy,
我们必须做出选择。最佳实践是对这些参数中的每一个进行网格搜索,并选择最佳性能和模型鲁棒性。
也许你只使用最常见的 n 个词。
也许你可以使用文章的投影或嵌入。
也许你可以先对文本使用一些经典的 NLP 方法。
感谢您的快速回复,
我是深度学习新手,选择相关参数似乎真的很难。
您是如何得到 16,750 的?25,000 / 64 个批次是 390。
谢谢!
根据我的理解,训练时,迭代次数(epoch)通常超过100次才能评估监督机器学习结果。但是,在您的示例或 Keras 示例中,只有3-15次迭代。您能解释一下吗?
谢谢,
迭代次数因算法和问题而异。Huy,没有固定的规则,让结果来指导一切。
那么,我们如何选择合适的迭代次数(epochs)呢?
在你的问题上进行试错,并仔细观察训练和验证数据集的学习率。
我正在寻找 Keras 上 LSTM 网络在已知/公共数据集上的基准测试。
您能否分享此帖子中的示例是在何种硬件配置(GPU/CPU/RAM 等)上运行的?
谢谢
我使用了 AWS,配置为 g2.2xlarge。
在 Keras 中是否可能获取分类器在每个词通过网络传播时的输出?
嗨,Mike,你一次只能做一个预测。
不确定如何查看权重传播过程——我还没有用 Keras 这样做过。
你好,
要将您的二元分类模型用于多标签分类,需要进行哪些更改?
还有,如果输入数据是原始文本格式而不是像 IMDB 那样的数字格式,您会采取哪些步骤来处理数据集使其与 IMDB 兼容?
Jason,干得好。
我非常喜欢它……
如果您能告诉我如何使用 LSTM 循环神经网络进行序列聚类(无监督学习任务),我将不胜感激。
抱歉,我没有将 LSTM 用于聚类。我无法为您提供好的建议。
嗨,Jason,
您的书对我很有帮助。我有一个关于时间序列分类器的问题。假设我有 8 类时间序列数据,每类有 200 个训练数据和 50 个验证数据,我如何使用 scikit-learn 包或其他工具,根据每类所有 50 个验证数据来估计分类准确率(例如对数最大似然)?如果您能给我一些建议,我将不胜感激。提前非常感谢。
此致,
Ryan
嗨,Ryan,sklearn 支持的分类度量列表可能有助于作为起点
https://scikit-learn.cn/stable/modules/classes.html#classification-metrics
Logloss 是一个非常有用的度量,用于评估学习算法在多类分类问题上的性能
https://scikit-learn.cn/stable/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss
希望这些能作为一个开始有所帮助。
嗨,Jason,非常感谢。我将尝试这个对数损失。
告诉我进展如何。
嗨,Jason,
对于将文本转换为整数以进行正确和更好的分类,词袋模型(Bags of words)还是词嵌入(word embedding)哪个方法更好?
我对此有点困惑。
提前感谢
嗨,Shashank,词嵌入目前很流行。我建议两种都试一试,看看哪种表示方法最适合你。
嗨 Jason,感谢您的教程,我发现它们非常清晰有用,但是当我想用它解决另一个问题设置时,我有一个小问题..
正如您在帖子中指出的,单词被嵌入为向量,我们将向量序列输入模型进行分类.. 正如您提到的 CNN 处理词向量内部的隐式空间关系(希望我理解正确),所以我有两个与此操作相关的问题
1. 嵌入层是特定于单词的吗,也就是说,Keras 有自己的词汇和相似性定义来处理我们输入的单词序列吗?
2. 如果我有一个二维矩阵序列,比如一张图像,我应该如何转换它们以满足 CNN 层或直接 LSTM 层的所需输入形状?例如,结合您关于时间序列数据的教程,我得到一个大小为 (5000, 5, 14, 13) 的 trainX,其中 5000 是样本长度,5 是 look_back(或 time_step),而这里我有一个矩阵而不是单个值,但我认为我应该在这里使用我特定的嵌入技术,这样我就可以在 CNN 或 LSTM 层之前传递一个矩阵而不是一个向量….
抱歉,如果我的问题描述不清,但我的意图确实是为了获取数据中存在的时空连接……所以我想将一个矩阵序列作为单个样本输入到我的模型中……并且输出将是一个矩阵……
感谢您的耐心!
33202176/33213513 [============================>.] – ETA: 0s 19800064/33213513 [================>………….] – ETA: 207s – ETA: 194s____________________________________________________________________________________________________
层(类型)输出形状参数 # 连接到
====================================================================================================
embedding_1 (嵌入) (None, 500, 32) 160000 embedding_input_1[0][0]
____________________________________________________________________________________________________
lstm_1 (LSTM) (None, 100) 53200 embedding_1[0][0]
____________________________________________________________________________________________________
dense_1 (密集) (None, 1) 101 lstm_1[0][0]
====================================================================================================
总参数:213301
____________________________________________________________________________________________________
无
Epoch 1/3
内核已终止,正在重启
pip install -U numpy
解决了问题
感谢分享!
嗨,Jason,
感谢这篇好文章。由于 IMDb 数据非常大,我尝试用垃圾邮件数据集替换它。我应该对原始代码进行哪些更改才能运行它?我已经在 stack-overflow 上问过这个问题,但目前还没有答案。http://stackoverflow.com/questions/41322243/how-to-use-keras-rnn-for-text-classification-in-a-dataset ?
有什么帮助吗?
好主意!
我建议您将每个单词编码为一个唯一的整数。然后您就可以将其用作嵌入层的输入。
嗨,Jason,
感谢您的帖子。它真的很有帮助。当我运行此代码时,我是否需要为 tensorflow 配置才能使用 GPU,或者它是否会自动选择 GPU(如果可用)?
这些示例很小,在 CPU 上运行速度很快,不需要 GPU。
我在 CPU 上试过,运行良好。我计划复制这个过程,并为不同的用例扩展您的方法。与此相比,它的维度更高。您有没有关于使用 GPU 的教程?我可以在 GPU 上实现相同的代码吗,还是格式完全不同?
相同的代码,后端的使用由您正在使用的 Theano 或 TensorFlow 后端控制。
Jason,
感谢有趣的教程!您对如何将训练用于分类序列的 LSTM 反过来用于生成新序列有什么想法吗?也就是说,既然它“知道”一个正面评论听起来像什么,能否用它来生成新的、原创的正面评论?(请忽略这种设置可能存在的邪恶用途 :)
有几个有趣的例子,LSTM 被训练来学习序列以生成新序列……但是,它们没有分类的概念,或者不理解什么是“好”序列与“坏”序列,不像您的模型。所以,我本质上对合并这两种方法感兴趣——用一些“好”和“坏”序列训练 LSTM,然后让它生成新的“好”序列。
任何想法或指点都将非常受欢迎!
我自己没有研究过这个。我没有任何现成的妙语,我认为这需要仔细思考。
这篇帖子可能有助于解决问题的另一方面,即文本生成
https://machinelearning.org.cn/text-generation-lstm-recurrent-neural-networks-python-keras/
我很乐意听听你的进展。
谢谢,如果你有任何疯狂的想法,请告诉我 :)
我正在考虑的一种普通的做法是,让分类器简单地“剔除”不想要的输入,然后只将想要的输入馈送到一个新的 LSTM 中,该 LSTM 可以使用您的另一篇帖子中的方法来生成更多类似的序列。
这似乎不太理想,因为它感觉我正在丢弃一些关于什么构成不想要的序列的知识……但是,另一方面,我在选择分类器算法方面有更大的自由度。
感谢您的本教程。
关于变长问题,尽管其他人已经问过,我还有一个问题。
如果我的数据集长度偏差很大,比如说,有些文本只有10个词,有些有100000个词。因此,如果我只选择1000作为我的maxlen,我会丢失很多信息。
如果我选择100000作为maxlen,我将消耗过多的计算能力。
有没有其他方法来处理这个问题?(不进行填充或截断)
另外,您能写一个关于如何在 RNN 中使用 word2vec 预训练嵌入的教程吗?
不是 word2vec 本身,而是如何使用 word2vec 的结果。
基于计数的词表示丢失了太多的语义信息。
很好的问题,Albert。
关于长序列问题,我目前没有现成的答案。这需要进一步研究。
很乐意尝试制作使用 word2vec 表示的教程。
我只有生物学背景,但我可以重现结果。太棒了。
很高兴听到,Charles。
嗨 Jason,我注意到您提到了针对 Tensorflow 0.10.0 更新的示例。我只能看到 Keras 代码,是不是我错过了什么?
谢谢。
嗨,Jax,
Keras 运行在 Theano 和 TensorFlow 之上。使用 Keras 需要其中一个。
我只是留下了一个注释,说明该示例已在更新版本的 Keras 上使用更新版本的 TensorFlow 后端进行了测试。
我不确定我是否理解这里的循环和序列如何工作。
我期望你会为每个评论输入一个序列的独热向量,其中每个独热向量代表一个单词。这样,你就不需要评论的最大长度(也不需要填充),我可以看到你如何一次一个词地使用循环。
但我理解你是一次性输入整个评论,所以它看起来像是前馈。
你能解释一下吗?
嗨,Kakaio,
是的,我们确实一次输入一个评论。这是我们用于多层感知机(MLP)的输入结构。
在内部,将 LSTM 网络视为根据评论中的词序列构建状态,并从该序列学习适当的情感。
LSTM 如何利用循环在词序列上建立状态?你是一次性将所有序列输入 LSTM,没有时间步。
嗨,Kakaop,完全正确。这个例子没有利用循环。
通过本教程,我如何预测测试值并将其写入文件?这些预测值是否以编码格式生成?
各位,这是一篇非常清晰实用的文章,感谢提供的 Keras 代码。但是我似乎找不到任何运行训练好的模型进行预测的示例代码。imdb.py 中没有,它只进行评估。有没有人能提供一些预测的示例代码?
嗨,Bruce,
你可以用所有训练数据拟合模型,然后使用以下方法预测新输入:
这有帮助吗?
那不是难点。不过,我可能已经弄清楚我需要知道什么了。那就是获取 model.predict 返回的结果,并将数组中的最后一个项作为分类。有没有人不同意?
嗨,这是一个很棒的教程。
我有一个关于你模型的问题。
我是 RNN 的新手,所以这个问题可能很愚蠢。
在你的设置中,输入词嵌入层对于序列分类而不是预测下一个词至关重要吗?
通常,词嵌入(或类似的投影)是 NLP 问题的良好表示。
嗨,Jason,
很棒的教程。对我帮助很大。
我注意到在第一部分,你在模型上调用了 fit(),其中包含 "validation_data=(X_test, y_test)"。这在最终代码摘要中没有。所以我想知道这只是一个错误,还是你后来忘记了。
但话又说回来,使用测试数据集进行验证对我来说似乎是错误的。你对此有何看法?
模型此时不使用测试数据,它只是在其上进行评估。这有助于了解模型的运行情况。
如果代码使用100个单元的LSTM,而句子长度为200,会发生什么?这意味着只有句子中的前100个词作为输入,而最后100个词将被忽略吗?
不,隐藏层中的单元数量和序列长度是不同的配置参数。
如果你愿意,可以使用1个单元和2K的序列长度,但模型不会学习它。
希望这能有所帮助。
嗨,Jason,
在最后一部分,LSTM层返回一个序列,对吗?之后密集层只接受一个参数。密集层怎么知道它应该接受最后一个参数?或者它甚至会接受最后一个参数吗?
不,在这种情况下,每个 LSTM 单元只返回一个值,而不是一个序列。
嗨,Jason,
非常有趣和有用的文章。感谢您撰写如此有用的文章。我有幸阅读了您其他非常有用的文章。
只是想问一下,我们如何编码新的测试数据,使其与程序所需的格式相同。我想转换过程中没有涉及字典。那么我们如何进行这种转换呢?例如,考虑一个样本句子“Very interesting article on sequence classification”。其编码后的数字表示是什么?
提前感谢
很好的问题。
您可以将字符编码为整数(整数编码),然后将整数编码为布尔向量(独热编码)。
Jason,很棒的文章。我想继续 Prashanth 的问题,如何预处理用户输入。如果我们使用 CountVectorizer(),当然,它会将其转换为所需的格式,但单词将不再与以前相同。甚至一个新单词也会创建额外的元素。您能否解释一下,如何预处理用户输入,使其与训练好的模型相似。提前感谢。
你可以分配一个包含100万个单词的字母表,所有整数从1到100万,然后对你看到的任何单词使用该编码。
其思想是在你的编码方案中有一个缓冲区。
另外,如果你删除所有低频词,这会给你更多的缓冲区。通常25K个词就足够了。
您的回答确实解开了我许多疑问。非常感谢您的快速回复。我现在对接下来该怎么做有了一些想法。
很高兴听到这个消息,Manish。
我的数据集只是一个向量特征,例如 [1, 0.5, 1, 1, 2, 1] -> y 只是 0,1 二进制或类别,例如 0,1,2,3。我想使用 LSTM 进行二进制或类别分类,我该怎么做呢?我只添加了 LSTM 和 Dense,但是 LSTM 需要 3 维输入,而 Dense 只需要 2 维。我知道我需要时间序列,我尝试了更多,但一无所获。你能解释并告诉我怎么做吗?拜托了,非常感谢
你可能需要考虑一个 seq2seq 结构,其中包含用于输入序列的编码器和用于输出序列的解码器。
像这样
我有一个关于这个的教程已计划发布。
希望这能有所帮助。
谢谢,我会努力找出答案,然后回复你。
不客气。
嗨,我在您的另一篇文章中有一个问题,关于为什么我使用函数 model.evaluate(x_test, y_test) 来获取模型在用训练数据集训练后的准确率分数,但在某些情况下它返回的结果 >1,我不知道为什么,这让我无法相信这个函数。您能为我解释一下原因吗?
抱歉,我不理解你的问题,你是否可以重新表述一下?
我不知道函数 evaluate 返回的结果大于 1,但我认为它应该只在 0 到 1 之间(model.evaluate(x_test, y_test),其中 model 是我之前用训练数据集训练过的)。
嗨,Jason,你能一步一步地解释你的代码吗?我跟着这个教程:https://blog.keras.org.cn/building-autoencoders-in-keras.html,但我有些困惑,不理解。:(。
如果您对该帖子有疑问,我建议您联系作者。
亲爱的 Joson
我是深度学习新手,打算在 keras 或 tensorflow 上进行语料库分析。您能帮助我或给我一些基本教程吗?
致敬
Mazhar Ali
抱歉,我只有 Keras 的教程
https://machinelearning.org.cn/start-here/#deeplearning
感谢您的友好解释。
我从您的书中得到了很多帮助。
您愿意在 IMDB LSTM 示例中添加 fit_generator 和批归一化的示例吗?
有人告诉我使用 fit_generator 函数来处理大量数据。
如果有一个例子,对购书者将非常有帮助。
我希望将来能添加这类示例。感谢您的建议。
嗨 Jason
我想知道在哪里可以读到更多关于 dropout 和 recurrent_dropout 的内容。你有没有一些论文或资料可以探索一下?
谢谢!
我这里有一个关于 dropout 的教程
https://machinelearning.org.cn/dropout-regularization-deep-learning-models-keras/
我计划很快在博客上发布一篇关于循环 dropout 的文章。
嗨,Jason,
我的数据集形状有问题
x_train = numpy.random.random((100, 3))
y_train = uti.to_categorical(numpy.random.randint(10, size=(100, 1)), num_classes=10)
model = Sequential()
model.add(Conv1D(2,2,activation=’relu’,input_shape=x_train.shape))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(x_train,y_train, epochs=150)
我尝试创建随机数据集,并将其传递给 Conv1D,但我不知道为什么,Conv1D 接受了我的形状(我认为它自动设置了 None 值),但 fit 不接受(我认为是因为 Conv1D 接受了 3 维)。我收到此错误:
ValueError: Error when checking model input: expected conv1d_1_input to have 3 dimensions, but got array with shape (100, 3)
您的输入数据必须是3维的,即使其中一两个维度宽度为1。
嗨,Jason,
感谢这篇精彩的文章!
我想就我的数据集训练提供一些建议。我拥有的数据是按时间测量的一维数据,每个实例都有一个二进制标签。
感谢您的博客,我成功地构建了一个 LSTM,并且它在分类主导类方面做得很好。主要问题是 0 和 1 的比例非常高。1 的数量大约是 0 的 0.03 倍。在大多数情况下,当这些测量值很高时,1 就会出现。因此,我认为如果模型能够看到过去 “p” 次测量值,LSTM 模型就可以做出更好的预测。直观地,它会识别测量值异常增加并将其行为与输出 1 相关联。
了解一些这些基本背景知识后,您能否建议一个结构,该结构可能
1.) 有助于利用异常高测量值与输出 1 的结构
2.) 有助于处理低暴露的 1 实例
感谢任何帮助或参考资料!
祝好!
嗨,Len,
也许你可以使用一些用于不平衡数据集的重采样方法。
https://machinelearning.org.cn/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/
嗨,这是一个很棒的教程!
只是想知道:既然您用零填充,为什么不将 Embedding 层的 mask_zero 标志设置为 True 呢?
如果不这样做,填充符号会影响成本函数的计算,不是吗?
这是一个好建议。也许我写这个例子的时候那个标志还不存在。
如果你发现有益,请告诉我。
嗨,Jason,
很棒的教程!帮助很大。
不过我有一个理论问题。序列分类仅仅基于 LSTM 的最后一个状态,还是必须将密集层用于所有隐藏单元(在这种情况下是 100 个 LSTM)?序列分类仅仅基于最后一个状态是否可能?我看到的大多数实现都使用密集层和 softmax 进行序列分类。
我们确实需要密集层来解释 LSTM 所学到的东西。
LSTM 正在根据输入时间步和内部状态来建模问题。
嗨,Jason,
你能告诉我 LSTM 中的 time_step 吗?举个例子或者其他容易理解的方式。如果我的数据是 2 维的,[[1,2]…[1,3]] 输出:[1,…0],那么使用 keras,LSTM 层需要 3 维,所以我只能将输入数据重塑为 time_step = 1 的 3 维,可以这样训练吗?time_step > 1 会更好吗?我想知道 LSTM 中 time_step 的含义,非常感谢你阅读我的问题。
你可以这样做,但最好在时间步中提供序列信息。
LSTM 正在开发一个关于先前时间步观察值的函数。
嗨,Jason,
首先,感谢您的精彩解释。
我正在考虑根据您在另一篇文章中的解释设置一个 aws g2.2xlarge 实例。您是否有基准(例如,上述示例之一的 1 个 epoch 的时间),以便我可以与我当前的硬件进行比较?
抱歉,我没有任何执行时间基准。
在使用 LSTM 时,我通常从大型 AWS 实例中获得巨大收益,因为可以访问更多的内存(更大的数据集)。
在 GPU 上运行 CNNs 比在 GPU 上运行 LSTMs 收益更大。
嗨,Jason,
我也对填充问题感到好奇。我认为 pad_sequence 是获得固定长度序列的方法。然而,除了填充零,我们实际上可以缩放数据吗?
那么,问题是 1) 如果缩放序列会扭曲句子的含义,考虑到句子被表示为序列,以及 2) 如何选择一个好的缩放因子。
谢谢你。
很好的问题。
通常,缩短单词序列长度的好方法是首先删除低频词,然后将序列截断到所需的长度或填充到该长度。
对于使用 LSTM,为什么我们仍然需要将输入序列缩放为固定大小?为什么不构建像 seq2seq 这样的模型,只是多输入到一输出?
即使使用 seq2seq,你也必须将输入数据向量化。
我看到了从 IMDB 加载的数据,它已经被编码为数字。
为什么我们还需要另一个嵌入层来进行编码?
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
print X_train[1]
输出如下:
[1, 194, 1153, 194, 2, 78, 228, 5, 6, 1463, 4369,…
嵌入是一种更具表现力的表示,可以带来更好的性能。
感谢 Jason 的文章和回答评论。我可以使用这种方法来解决我在 Stack Overflow 问题中描述的问题吗?请看一下。
http://stackoverflow.com/questions/43987060/pattern-recognition-or-named-entity-recognition-for-information-extraction-in-nl/43991328#43991328
也许吧,我建议寻找一些现有的研究来模板化解决方案。
感谢 Jason 的文章。我用 keras 实现了一个 CNN 后面接 LSTM 神经网络模型用于句子分类。但是经过 1 或 2 个 epoch 后,我的训练准确率和验证准确率停滞在某个数字,并且不再变化。就像它卡在某个局部最小值或其他原因一样。我该怎么做才能解决这个问题?如果我的模型只使用 CNN,那么训练和验证准确率都会收敛到很好的准确率。你能在这方面帮助我吗?我无法识别问题。
这是训练和验证准确率。
Epoch 1/20
1472/1500 [============================>.] -8s – loss: 0.5327 – acc: 0.8516 – val_loss: 0.3925 – val_acc: 0.8460
Epoch 2/20
1500/1500 [==============================] – 10s – loss: 0.3733 – acc: 0.8531 – val_loss: 0.3755 – val_acc: 0.8460
Epoch 3/20
1500/1500 [==============================] – 8s – loss: 0.3695 – acc: 0.8529 – val_loss: 0.3764 – val_acc: 0.8460
Epoch 4/20
1500/1500 [==============================] – 8s – loss: 0.3700 – acc: 0.8531 – val_loss: 0.3752 – val_acc: 0.8460
Epoch 5/20
1500/1500 [==============================] – 8s – loss: 0.3706 – acc: 0.8528 – val_loss: 0.3763 – val_acc: 0.8460
Epoch 6/20
1500/1500 [==============================] – 8s – loss: 0.3703 – acc: 0.8528 – val_loss: 0.3760 – val_acc: 0.8460
Epoch 7/20
1500/1500 [==============================] – 8s – loss: 0.3700 – acc: 0.8528 – val_loss: 0.3764 – val_acc: 0.8460
Epoch 8/20
1500/1500 [==============================] – 8s – loss: 0.3697 – acc: 0.8531 – val_loss: 0.3752 – val_acc: 0.8460
Epoch 9/20
1500/1500 [==============================] – 8s – loss: 0.3708 – acc: 0.8530 – val_loss: 0.3758 – val_acc: 0.8460
Epoch 10/20
1500/1500 [==============================] – 8s – loss: 0.3703 – acc: 0.8527 – val_loss: 0.3760 – val_acc: 0.8460
Epoch 11/20
1500/1500 [==============================] – 8s – loss: 0.3698 – acc: 0.8531 – val_loss: 0.3753 – val_acc: 0.8460
Epoch 12/20
1500/1500 [==============================] – 8s – loss: 0.3699 – acc: 0.8531 – val_loss: 0.3758 – val_acc: 0.8460
Epoch 13/20
1500/1500 [==============================] – 8s – loss: 0.3698 – acc: 0.8531 – val_loss: 0.3753 – val_acc: 0.8460
Epoch 14/20
1500/1500 [==============================] – 10s – loss: 0.3700 – acc: 0.8533 – val_loss: 0.3769 – val_acc: 0.8460
Epoch 15/20
1500/1500 [==============================] – 9s – loss: 0.3704 – acc: 0.8532 – val_loss: 0.3768 – val_acc: 0.8460
Epoch 16/20
1500/1500 [==============================] – 8s – loss: 0.3699 – acc: 0.8531 – val_loss: 0.3756 – val_acc: 0.8460
Epoch 17/20
1500/1500 [==============================] – 8s – loss: 0.3699 – acc: 0.8531 – val_loss: 0.3753 – val_acc: 0.8460
Epoch 18/20
1500/1500 [==============================] – 8s – loss: 0.3696 – acc: 0.8531 – val_loss: 0.3753 – val_acc: 0.8460
Epoch 19/20
1500/1500 [==============================] – 8s – loss: 0.3696 – acc: 0.8531 – val_loss: 0.3757 – val_acc: 0.8460
Epoch 20/20
1500/1500 [==============================] – 8s – loss: 0.3701 – acc: 0.8531 – val_loss: 0.3754 – val_acc: 0.8460
我在这里提供了一些想法,帮助您提高深度学习项目的性能。
https://machinelearning.org.cn/improve-deep-learning-performance/
Jason,感谢您的精彩帖子。
我是 DL 的初学者。
如果我需要将一些行为特征纳入此分析,例如:年龄、性别、邮政编码、时间 (DD:HH)、季节 (春/夏/秋/冬)… 您能给我一些实现提示吗?
不胜感激
每个都是输入数据上的不同特征。
请记住,输入数据必须结构化为 [样本数, 时间步数, 特征数]。
我的数据形状是 (8000,30),我需要使用 30 个时间步。
我这样做:
model.add(LSTM(200, input_shape=(timesteps,train.shape[1])))
但当我运行代码时,它给我一个错误:
ValueError: Error when checking input: expected lstm_20_input to have 3 dimensions, but got array with shape (8000, 30)
如何将训练数据的形状更改为您提到的格式
记住,输入数据必须是 [样本数, 时间步数, 特征数] 的结构。(8000,30,30)
这篇文章将帮助您处理 LSTM 数据形状的问题。
https://machinelearning.org.cn/reshape-input-data-long-short-term-memory-networks-keras/
你好,
我怎样才能使用我自己的数据,而不是 IMDB 来进行训练?
谢谢
Kadir
您需要将文本数据编码为整数。
你好杰森博士,
非常感谢您的博文。它们无疑是互联网上最好的文章之一。
不过我有一个疑问。在您描述的第一个例子中,为什么您使用验证数据集作为 x_test 和 y_test?我只是觉得有点困惑。
提前感谢
谢谢。
我这样做是为了在模型拟合时了解模型的技能。您不需要这样做。
我按照您说的在 CNN+RNN 上添加了 dropout,准确率达到了 87.65%。我仍然不清楚为什么将两者结合起来,因为我以为 CNN 是用于图像或视频等 2D+ 输入的。但无论如何,您的教程为我深入研究 RNN 提供了一个很好的起点。非常感谢!
很高兴听到这个消息。
感谢这篇帖子。
如果我理解正确,在嵌入层之后,训练数据中的每个样本(每个评论)都被转换为一个 32x500 的矩阵。从音频频谱图类比来看,它是一个 32 维的频谱,具有 500 个时间帧。
有了上述等效或类比,我可以使用音频原始频谱图作为输入和类别标签(无论是好是坏的音频质量)来执行音频波形分类,代码与此帖子中的完全相同(除了嵌入层)。这是正确的吗?
此外,我想知道为什么输入长度必须相同,即帖子中的 500。如果我在在线训练的背景下进行,每次只有一个样本被输入到模型中(批量大小为 1),那么应该不用担心样本长度不同对吧?也就是说,每个样本(长度不同,无需填充)及其目标被一个接一个地用于训练模型,并且不用担心长度不同。这仅仅是 Keras 中实现的问题,还是理论上每个样本的输入长度都应该相同?
你好 Fred,
是的,试试看。
向量化输入要求所有输入具有相同的长度(为了后端库的效率)。您可以使用零填充(甚至掩码)来满足此要求。
我认为大小参数在网络定义中是固定的。您可以从批量到批量进行操作,在过程中重新定义+编译您的网络,但这效率不高。
谢谢你的回复,我会尝试的。
我只是想知道 RNN 或 LSTM 在理论上是否要求每个输入都具有相同的长度。
据我所知,RNN 优于 DNN 的优势之一是它接受变长输入。
如果这个要求是为了 Keras 中的效率问题,并且零(如果使用零填充)被认为是零信息,那对我来说没什么困扰。在音频频谱图的情况下,您会推荐零填充原始波形(一维)还是频谱图(二维)?根据您帖子的类比,选择应该是前者。
你好 Fred,
理论上 LSTM 不需要填充,它只是高效实现的一个限制,需要向量化输入。
对于大多数应用程序来说,这可能是一个公平的权衡。
嗨,Jason,
在 RNN(Keras 实现)中是否有办法控制 LSTM 的注意力?
我有一个数据集,其中 100 个时间序列输入作为序列输入。我希望 LSTM 更重视最后 10 个时间序列输入。
可以做到吗?
提前感谢。
是的,但您必须编写一个自定义层来实现注意力。
我希望很快能介绍 LSTM 的注意力模型。
嗨,Jason,
构建并保存模型后,我想用它来对新文本进行预测,但我不知道如何预处理纯文本以便用于预测。我搜索了一下,找到了这种方法:
text = np.array([‘这是一个随机句子’])
tk = keras.preprocessing.text.Tokenizer( nb_words=2000, lower=True,split=" ")
predictions = loaded_model.predict(np.array(tk.fit_on_texts(text)))
但这对我不起作用,并显示以下错误:
ValueError: 检查时出错:embedding_1_input 需要有 2 个维度,但得到的数组形状为 ()
您能告诉我预处理文本的正确方法吗?任何帮助都将不胜感激。
谢谢
通常,您需要对单词进行整数编码。
谢谢回复
我这样转换了我的字符串:
text = ‘这是一部值得一看的好电影’
import keras.preprocessing.text
text = keras.preprocessing.text.one_hot(text, 5000, lower=True, split=” “)
text = [text]
text = sequence.pad_sequences(text, 500)
predictions = loaded_model.predict(text)
但得到的输出是:[[ 0.10996077]]
它不应该接近 1 吗?
非常感谢。
抱歉,我不明白。你为什么期望输出为 1?你预测的是什么?
我理解的是,1 是积极情绪的标签,由于我使用积极的陈述进行预测,所以我期望输出为 1。
我在上一个评论中犯了一个错误,使用了 model.predict() 来获取类别标签,获取标签的正确方法是 model.predict_classes(),但它仍然没有给出正确的类别标签。
所以我的问题是,我将文本转换为独热向量是否犯了错误,还是这样做的正确方法。
非常感谢。
只要您在数据准备和另一端的解释方面保持一致,就应该没问题。
您能做一个关于预处理文本数据集,然后使用词嵌入作为输入的教程吗?谢谢!
好建议。它在我的列表上名列前茅!
我们能否将序列标注问题应用于连续变量?我拥有客户在到期日内、缓冲期内和缓冲期外偿还债务的数据集。在此基础上,我想根据客户的好坏程度给他们打分。这是否可以使用序列标注来实现?
也许吧,我不确定我是否理解您的数据集。您能给出一个单案例示例吗?
你好 Jason,很棒的教程!
我有的数据如下
文本 字母数字 标签
“foo” A1034 A
“bar” A1234 B
我已经将 LSTM 模型从文本列映射到标签列。但是,我需要将字母数字列与文本作为额外特征添加到我的 LSTM 模型中。我如何在 Keras 中做到这一点?
考虑独热编码。
您好,这真的太棒了,很高兴这个教程是我在 LSTM 上的第一个实际项目。我需要在您的代码中使用 f-measure、假阳性和 AUC,而不是“准确率”。您有什么办法可以获取它们吗?
先谢谢您了。
Sajad,
您可以进行预测,然后使用预测数组和预期值来计算 sklearn 中的这些分数
https://scikit-learn.cn/stable/modules/classes.html#sklearn-metrics-metrics
我有一个关于 Keras 内置嵌入层的问题。
我用 word2vec 模型完成了词嵌入,该模型基于词语的语义相似性工作——在相同上下文中的词语更相似。我想知道 Keras 嵌入层是否也遵循 w2v 模型,还是有自己的算法将词语映射到向量?
它根据什么语义将词语映射到向量?
好问题,这里有更多相关内容
https://keras.org.cn/layers/embeddings/
谢谢 Jason!
我查阅了大部分关于这个的文档,但没有一个提到这种内置词嵌入过程背后的语义。
我想知道它,因为我现在一直认为这个方法内部的过程可能会导致准确率低下!
如果您找到任何相关信息,请随时告知我。
我建议阅读这里的代码
https://github.com/fchollet/keras/blob/master/keras/layers/embeddings.py#L11
嗨,Jason,
精彩的文章。我正在尝试使用 CNN 对时间序列数据进行建模,并将其输入到 LSTM 进行监督学习。我有一个二维矩阵,其中列代表之前的 n 个时间步,行代表每个时间步访问的不同价格水平。
价格 柱0 柱1 柱2 柱3 柱4 柱5 ...
0 0 0 1 1 0 0
1 1 0 1 1 0 1
2 1 1 1 1 1 1
3 1 1 0 1 1 0
4 0 0 0 0 1 0
…
这个矩阵将代表价格数据
高 低
柱0 3 1
柱1 3 2
柱2 2 0
柱3 3 0
柱4 4 2
柱5 2 1
您能告诉我如何将您的 1-d CNN 调整为 2-d CNN 吗?
嗨,Jason,
对我来说是很棒的帖子。
但我想问您:嵌入层中的向量长度,您说“第一层是嵌入层,使用 32 长度向量来表示每个单词”,为什么您选择 32 而不是其他数字,比如 64 或 128,您能给我一些最佳实践,或者您选择的原因吗?
非常感谢您。
反复试验。您可以尝试其他表示法,看看哪种最适合您的问题。
谢谢 Jason。
不客气。
@Jason,
“序列分类是一个预测建模问题,其中您有一些跨空间或时间的输入序列,任务是预测序列的类别。”
这很鼓舞人心。我正在考虑使用序列分类来处理 IRIS 数据集。
您认为它有效吗?
鸢尾花数据集不是一个序列分类问题。它只是一个分类问题。
@Jason,
你的意思是
我不能将 LSTM 用于 IRIS 分类吗?我正在研究类似 IRIS 的数据集。所以我正在探索所有可能的分类器。您的网站上就有一个。此外,
我尝试了 SKLearn 中的 RBM,它不起作用,因为我的输入不是像 MNIST 数据集那样的二元输入(即使在 SKLearn 的 preprocessing.binarizer() 函数之后)。我认为他们说 SKLearn 中的 RBM 适用于 [0,1] 范围内的数据是错误的,它只适用于 0 和 1。
(顺便说一下,我将我的代码发给您供参考)
我还尝试了概率神经网络(PNN),它只产生了 78% 的准确率,很低,而且无法增加 PNN 的层数,因为它是一个单层网络(来自 Neupy)。
现在我转向 RNN,但你这么说了。
不,鸢尾花数据集不是一个序列分类问题,LSTM 会很不合适。
@Jason,
您有什么建议吗?我需要您的专家意见。
我尝试了 sklearn 中的 RBM,但它不起作用。
你说 RNN 不会奏效。
我认为 CNN 显然也不适合。
还剩下 DBN 和 VAE 吗?
我希望以三种不同的方式对 IRIS 进行分类。我只做了一种。
考虑 SVM、CART 和 kNN。
@Jason,
谢谢你。我已经尝试了 kNN 和 SVM。它们都表现良好,取得了不错的结果。
我感觉深度学习方法能为我的数据集带来更好的结果。您在深度学习方面还有其他建议吗?这是我的数据集
https://www.dropbox.com/s/4xsshq7nnlhd31h/P7_all_Data.csv?dl=0
你可以尝试多层感知机神经网络。
Jason,
我确实尝试了多层感知机。结果很好。
我想使用超过 3 层的深度神经网络。
你认为卷积神经网络怎么样?
我最初认为这不可能。但是,现在我又重新考虑了。
你想怎么做都可以。CNN 是为空间输入设计的,而鸢尾花数据集没有空间输入。
你好 Jason,我想问一下 Dropout 的用途是什么,它会降低准确率,这是否意味着 Dropout 对机器学习不利?谢谢!
Dropout 可以在某些问题上提高模型的性能。
请参阅这篇关于 dropout 的文章
https://machinelearning.org.cn/dropout-regularization-deep-learning-models-keras/
嘿 Jason!很棒的帖子 :) 真的帮助我度过了这个夏天的实习期。我只想听听您对几件事的看法。
1. 我总共训练了大约 40 万份文档,准确率达到了 98% 左右。当我的模型表现“太好”时,我总是很警惕。这是否是由于庞大数据集造成的合理因果关系?
2. 当我想到 CNN + 最大池化词向量 (Glove) 时,我认为这个操作基本上是将 3 个词的词向量混合在一起(可能形成短语表示)。我的思考过程正确吗?
3. 我仍然不太清楚 LSTM 学习了什么。我知道它不是一个典型的 seq-2-seq 问题,那么那 100 个 LSTM 单元包含什么?
再次非常感谢您的精彩教程! :)
很高兴听到这个消息,Daniel。
也许您想在保留集上测试模型,以查看模型技能是真实的还是过拟合的。
差不多就是这样,池化会做一些很好的非线性事情,这些事情可能无法干净地与词向量/词语关联起来。
它们包含输入和输入序列中先前项的函数。这肯定很复杂。
你好 Jason,
我想知道 LSTM 层中的 100 个神经元如何能够接受 500 个向量/词?我以为 LSTM 层的大小应该与输入序列的长度相等!
好问题,不,层不需要具有相同数量的单元。
例如,如果我有一个长度为 5 的向量作为单个神经元的输入,那么该神经元将有 5 个权重,每个元素一个。我们不需要 5 个神经元来处理 5 个输入元素(尽管我们可以),这些考虑是分开且解耦的。
谢谢你的回复。
但在这里,我们已经将每个输入都视为一个向量而不是一个标量!这是否意味着在这种情况下,每个神经元将接收 5 个向量,每个向量都是 32 维的?那么每个神经元将有 5*32=160 个权重?如果是这样,这相对于让每个神经元只处理一个词/向量有什么优势?
对于 MLP,词向量如您所说地连接起来,每个神经元都会接收大量输入。
另一方面,LSTM 将每个词作为序列中的一个输入,并逐个处理它们。
这个想法被称为“分布式表示”,其中所有神经元接收所有输入,并且它们有选择地学习关注不同的部分。
这是神经网络的关键。
嗨,Jason,
假设我们有 500 个序列,每个序列包含 100 个元素。
如果我们将它嵌入到 32 维向量中,每个序列将得到一个 100*32 的矩阵。
现在假设我们的项目中只使用一个 LSTM 层(20)。我有点困惑在实践中。
我知道我们有一个隐藏层,其中有 20 个 LSTM 单元并行。我想知道 Keras 如何将序列提供给模型。它是否一次将相同的 32 维向量按顺序提供给所有 LSTM 单元,并且一次迭代在时间 [t+100] 结束?(这种方式我认为所有单元在训练后都会给出相同(复制)的值,并且这相当于只有一个单元),或者它是否将 32 维向量 20 个 20 个地按顺序提供给模型,并且迭代在时间 [t+5] 结束?
在此先感谢,
Sajad
好问题。
所以,这 100 个时间步作为输入传递给模型,包含 500 个样本和 1 个特征,类似 [500, 100, 1]。
嵌入层会将每个时间步转换为一个 32 维向量。
LSTM 将一次处理一个时间步的序列,即一次处理一个 32 维嵌入。
每个记忆单元都将获得完整的输入。它们都尝试对问题进行建模。从更深层传播的错误会促使隐藏的 LSTM 层以特定方式学习输入序列,例如对序列进行分类。每个单元将学习略有不同的东西。
这有帮助吗?
感谢您清晰的回答。
1) 我正在使用 LSTM 进行恶意软件检测,所以我有一系列恶意软件活动。另外,我想了解更多关于 Keras 中的 Embedding 层。在我的项目中,我需要将元素转换为整数数字以馈送 Keras 的 Embedding 层。我猜 Embedding 是一个冻结的神经网络层,以一种能体现不同元素之间有意义关系的方式,将序列的元素转换为向量,对吗?我想知道在我的项目中使用 Embedding 是否存在任何逻辑问题。
2) 你知道关于 Keras 中 Embedding 的任何参考资料(书籍、论文、网站等)(学术/非学术)吗?我需要绘制一个图来描述 Embedding 训练网络。
感谢您的耐心等待,
Sajad
Embedding 在模型拟合时会学习权重。
如果你愿意,可以使用 word2vec 或 glove 运行的预训练权重。为你的任务学习自定义权重通常会更好。
我计划下个月发布几篇关于学习到的嵌入层如何工作的文章。目前,这可能是一个很好的起点:
https://en.wikipedia.org/wiki/Word_embedding
Keras Embedding 层仅仅是权重——为输入词汇表中的每个词学习到的向量。非常简单明了。
谢谢你,Jason。
太棒了,我正在等待你关于嵌入的文章。
谢谢 Sajad。
嘿 Jason,这篇文章对我很有帮助。
我有一个问题,我想知道如何设置隐藏层中 LSTM 单元的数量?
样本数量(序列)和隐藏单元数量之间是否存在任何关系?
我有 400 个序列,每个序列包含 5000 个元素。我应该使用多少个 LSTM 单元?我知道我应该用不同数量的隐藏单元来测试模型,但我正在寻找隐藏单元数量的上限和下限。
Saho,
没有分析方法可以配置神经网络。我建议试错法、网格搜索、随机搜索或复制其他模型的配置。
干得好!如果我想将此代码应用于简单句子序列分类,该怎么做?我们该如何处理数据?
.
谢谢你
当然可以。
我建议花时间清理数据,然后将其整数编码以供模型使用。我建议在模型前端使用一个嵌入层。
谢谢……我如何用我自己的由简单句子组成的数据替换 IMDB 数据?我该如何相应地修改程序?
加载文本数据,清理文本数据,然后将您的词语编码为整数。
可以从 Keras Tokenizer 开始了解。
https://keras.org.cn/preprocessing/text/#tokenizer
嗨,Jason!首先感谢您精彩的网站!
现在问题来了:在我的案例中,我正在尝试解决一个任务分类问题。每个任务都由 57 条时间序列描述,每条时间序列有 74 个时间步。在训练阶段,我有 10 个不同类别的 100 个任务示例。
这样,我创建了一个 [100,74,57] 的输入和一个 [100,1] 的输出,其中包含每个任务的标签。
也就是说,我有一个多元时间序列到多标签分类的问题。
您会建议哪种学习结构?我意识到我可能需要收集/生成更多数据,但我对 Python 和深度学习都是新手,在为多元时间序列 -> 多标签分类创建小型运行示例时遇到了一些麻烦。
谢谢!
对于多类别分类,您需要对输出变量进行独热编码,以便维度为 [100,10],然后在输出层使用 softmax 激活函数来预测所有 10 个类别的输出概率。
对于具体的模型,可以尝试带滑动窗口的 MLPs,然后可能是一些 RNNs,比如 LSTMs,看看它们是否能表现更好。
感谢您的教程。我的问题是分类一个数据包(每次都捕获许多特征)是正常还是异常。我想将 LSTM 应用于我自己的问题。我的数据是矩阵:X_train(4000,41),Y_train(4000,1),X_test(1000,41),Y_test(1000,1) – Y 是标签。41 个特征中的一个时间特征,其他是输入变量。我认为,我必须从 41 个特征中提取时间特征,这正确吗?Keras 中有这个过程吗?
首先,我困惑如何以有意义的方式重塑数据,使其满足 LSTM 层输入的各项要求。我期望我的数据如下:
x_train.shape = (4000,1,41) #简单起见,我将时间步长设置为1,稍后会将其更改为 > 1,以便在时间步长内对多个数据包进行分类
y_train.shape = (4000,1,1)
如何将我的数据转换为上述结构?
其次,我认为 Embedding 层不适合我的问题,对吗?我的模型是这样构建的:
model = Sequential()
model.add(LSTM(64, input_dim=41, input_length=41)) # 例如,64 个 LSTM 单元
model.add(Dense(1, activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(X_train, Y_train, epochs=20, batch_size=100)
我是 LSTM 新手,您能为我的问题提供一些建议吗?非常感谢!
听起来您有 40K 个时间步,这些时间步需要被分成 100 个样本,每个样本包含 400 个时间步的子序列。
那么您的输入将是:[100, 400, 41]。
输入形状将是 (400, 41)。
这有帮助吗?
谢谢 Jason。这意味着 batch_size=100。对吗?我可以这样设置我的第一层:
model.add(LSTM(64, input_dim=41, input_length=400)) #隐藏层1:64
或
model.add(LSTM(64, batch_input_shape=(100, 1, 41), stateful=True))
哪个是正确的?如何在第一行代码中设置 time_step。
你能帮我解决这个问题吗?非常感谢
您可以这样设置数据的时间步 (x) 和特征 (y) 的形状:
input_shape=(x, y)
感谢您的热情,
我尝试按照您的评论使用我的数据构建模型,但我遇到了错误
timesteps=2
train_x=np.array([train_x[i:i+timesteps] for i in range(len(train_x)-timesteps)]) #train_x.shape=(119998, 2, 41)
train_y=np.array([train_y[i:i+timesteps] for i in range(len(train_y)-timesteps)]) #train_y.shape=(119998, 2, 1)
input_dim=41 #特征
#1.定义网络
model=Sequential()
model.add(LSTM(100,input_shape=(timesteps,input_dim)))
model.add(Dense(1,activation=’sigmoid’))
#2.编译网络
model.compile(loss=’binary_crossentropy’,optimizer=’adam’,metrics=[‘accuracy’])
#3.拟合模型
model.fit(train_x,train_y, epochs=100, batch_size=10,)
错误
文件“test_data.py”,第53行,位于
model.fit(train_x,train_y, nb_epoch=100, batch_size=10,)
文件“/home/keras/models.py”,第870行,位于fit
initial_epoch=initial_epoch)
文件“/home/keras/engine/training.py”,第1435行,位于fit
batch_size=batch_size)
文件“/home/keras/engine/training.py”,第1315行,位于_standardize_user_data
exception_prefix=’target’)
文件“/home/engine/training.py”,第127行,位于_standardize_input_data
str(array.shape))
ValueError:检查目标时出错:dense_1 预期有 2 个维度,但得到形状为 (119998, 2, 1) 的数组
可能我的输出形状有问题?我该如何修复?
谢谢你
您的网络输出需要 1 个特征。将 y 重塑为 (119998, 1)。
嗨,Jason,
我将我的输出形状替换为
train_y=np.array(train_y[:119998]) #train_y.shape=(119998, 1)
终于成功了!
我还有个问题,Keras 支持在 GPU 上实现吗?
谢谢
很高兴听到。
Keras 运行在 Theano 和 TensorFlow 之上。这些底层数学库提供了对 GPU 的支持。
你好,Jason。
我认为我准备 LSTM 输入数据时可能错了。
我的输入和标签如下:train_x(4000,41) 和 train_y(4000,1)
之前,我用了
timesteps=2
train_x=np.array([train_x[i:i+timesteps] for i in range(len(train_x)-timesteps)]) #train_x.shape=(119998, 2, 41)
train_y=np.array(train_y[:119998]) #train_y.shape=(119998, 1)
===> 这是错误的,因为行是重叠的,并且 train_y 可能被错误地取了。
现在,我这样纠正了
train_x = reshape(int(train_x.shape[0]/timesteps), timesteps, train_x.shape[1])
在我的数据中,每个实例都有多个特征,所以我想保持特征不变,这意味着在同一时间有多个特征。
请帮我纠正我对输入数据的误解。
train_y = reshape(int(train_y.shape[0]/timesteps), train_y.shape[1]) # 错误:IndexError: tuple index out of range ???
我还在考虑时间特征是否包含在输入数据中(因为我读过一篇文章:https://machinelearning.org.cn/time-series-prediction-lstm-recurrent-neural-networks-python-keras/)。
我读了您在 machinelearningmastery.com 上的许多文章,所以我可能有些困惑。
非常感谢
抱歉,我不太明白您的序列预测问题。
您能给我一个简单的例子吗,比如一个样本?
我的数据有 n 个数据包,每个数据包有 f 个特征(其中一个特征是时间),例如:
f1 f2 f3 … 标签
pkt1 2 3 3 0
pkt2 1 3 5 1
pkt3 2 3 2 1
pkt4 5 3 1 0
pkt5 5 3 2 1
....
例如:timesteps=2,每个子序列有2行。形状调整后,像这样:
[[[2 3 3 0]
[3 5 1 1]]
[[3 5 1 1]
[2 3 2 1]]
…. ]
或者:分离
[[[2 3 3 0]
[3 5 1 1]]
[[2 3 2 1]
[5 3 1 0]]
… ]
当从该输入数据中分离标签时,我看到如果 timesteps=1,标签将与每一行匹配,很容易获取。但是如果 timesteps > 1,哪个标签将被用于匹配每个子序列(在第一行还是第二行)?
您能帮我澄清这个困惑吗?(2个问题:重叠还是分离?以及如何获取标签)
非常感谢
也许这篇文章会帮助您准备数据。
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
谢谢 Jason。
我知道那篇文章。这意味着为预测模型和分类模型准备数据是一样的吗?
该方法将有助于一般地准备序列数据,而不仅仅是时间序列。
嗨 Jason
在仔细考虑了 Keras 中 LSTM 的数据准备后,我意识到“特征”一词并不意味着其原始含义(也称为数据集中的属性、字段),实际上它是将多变量时间序列转换为监督学习数据后列的数量。它是基于真实特征和 look_back 计算的,计算方式是真实特征乘以 look_back。我说的对吗?
我遵循了 https://machinelearning.org.cn/multivariate-time-series-forecasting-lstms-keras/
.
谢谢 Jason 和 machinelearningmastery.com
在时间序列中,并行序列将是“特征”,一个序列的滞后观测值将是 LSTM 的时间步长。
嗨 Jason,不错的文章。我有一个问题。进行多类别分类而不是二元分类,我需要做哪些更改?
好问题。
更改输出层,使其每个类别有一个神经元,将输出层的激活函数更改为 softmax,并将损失函数更改为 categorical_crossentropy。
感谢您的精彩回复。最后一个问题,我可以使用负值进行 LSTM 和 CNN 吗?我有一些数据,其中一列既有正值也有负值。如何处理这种情况?提前感谢。
是的。
通常,我建议您在将数据传递给 LSTM 层之前将其重新缩放到 0-1 的范围。
嗨,Jason,
我似乎在使用“model.add(LSTM(100))”这一行时遇到了问题(操作系统:MAC)
TypeError 是:预期 int32,却得到了类型为 'Variable' 的变量。
非常感谢!!!!!!!
这是一个奇怪的错误,你确定是在那一行吗?它没有道理。
也许请确保你已经复制了所有行并且间距/缩进正确?
嗨,Jason,感谢您的帖子。它真的很有帮助。
我有一些问题,希望您能帮忙。
1. 我正在尝试对一个包含用户评论的数据集进行意图分类。评论对应着几种意图。但是我的语言不是英语。所以我明白我必须将数据集构建成类似于 IMDb 的。但我该怎么做?您是否有任何关于如何构建此类数据集的说明/指南?
2. 除了数据集,我想我还必须为我自己的语言构建嵌入向量。我该怎么做?
提前感谢。希望很快能收到您的回复。
我应该很快会发布一些关于这个主题的文章。
通常,你需要清理数据(标点符号、大小写、词汇表),然后将其整数编码以用于词嵌入。Keras 的 Tokenizer 类是一个很好的起点。
Embedding 层将学习您的数据的权重。您可以尝试训练一个 word2vec 模型并使用预训练的权重以获得更好的性能,但我建议首先使用学习到的嵌入层作为第一步。
您好,Jason,
感谢您的出色帖子。
谷歌有其 NLP API:https://cloud.google.com/natural-language/docs/basics
您可以承认他们给我们情感极性范围是 (-1, 1)。他们称之为“分数”。
您可能对如何在情感分析中使用 Keras 实现相同的输出有快速的想法吗?
据我所知,这不再是一个分类器问题。有什么想法吗?
当然,我安排了一些关于这个主题的帖子,将在本月晚些时候/下个月发布。
哎呀,我把回复发错帖子了。抱歉。我已经更正了。
嗨,Jason,
感谢您在这个网站上的出色工作。
我的问题是:在什么情况下 RNN 比 LSTM 效果更好?我知道 LSTM 源于 RNN,并试图消除 RNN 中梯度消失的问题。但是,在我的案例中,我使用的是恶意软件行为序列,我得到了这个 TPR 和 FPR 图表:https://imgur.com/fnYxGwK,图表显示了隐藏层中不同单元数量的 TPR 和 FPR。
你知道为什么 RNN 在我的项目中效果更好吗?
LSTM 是一种 RNN。
嗨,Jason,
首先,很棒的教程。喜欢您提供的所有内容。
我正在处理一个分类任务,涉及评估一个可能长达 27500 个单词的特征。我的问题是,我还需要将其他特征输入到我的 RNN-LSTM 中。我曾想过将长文本特征和其他特征合并到一个文件中——当然特征之间用列分隔,但我不认为这会奏效?相反,我正在考虑将长文本特征分离到一个单独的文件中,并独立地通过 RNN 运行它,然后再获取其他特征。您能给我一些关于如何设计应对我面临的这个挑战的层的指导吗?
您需要将序列分成最多 200-400 个时间步的子序列。
我在这里提供了一些想法
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
您好,Jason Brownlee 博士。感谢您精彩的网站。我是一名深度学习初学者。我复制了您的代码并运行它,在加载 imdb 数据集时遇到了问题。消息如下:
回溯(最近一次调用)
文件“F:\Study\0-MyProject\Test\SimpleLSTM.py”,第 13 行,位于
(X_train, y_train),(X_test, y_test) = imdb.load_data(num_words = top_words)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\site-packages\keras\datasets\imdb.py”,第 51 行,位于 load_data
path = get_file(path, origin=’https://s3.amazonaws.com/text-datasets/imdb.npz’)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\site-packages\keras\utils\data_utils.py”,第 220 行,位于 get_file
urlretrieve(origin, fpath, dl_progress)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\urllib\request.py”,第 217 行,位于 urlretrieve
block = fp.read(bs)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\http\client.py”,第 448 行,位于 read
n = self.readinto(b)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\http\client.py”,第 488 行,位于 readinto
n = self.fp.readinto(b)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\socket.py”,第 575 行,位于 readinto
return self._sock.recv_into(b)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\ssl.py”,第 929 行,位于 recv_into
return self.read(nbytes, buffer)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\ssl.py”,第 791 行,位于 read
return self._sslobj.read(len, buffer)
文件“C:\Users\llfor\AppData\Local\Programs\Python\Python35\lib\ssl.py”,第 575 行,位于 read
v = self._sslobj.read(len, buffer)
TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应,连接尝试失败。
此外,有时它只是说“在 https://s3.amazonaws.com/text-datasets/imdb.npz 上获取失败”。
是因为 imdb 数据源不可用还是网络不稳定?
实际上,我已经从 https://s3.amazonaws.com/text-datasets/imdb.npz 手动下载了数据。
那么如果我无法在线加载数据,我如何处理我手动下载的数据以使用它呢?
我尝试了另一段代码来加载数据:(X_train, y_train),(X_test, y_test) = imdb.load_data(path = “imdb_full.pkl”),但也没有奏效。
期待您的回复。再次感谢!
看起来您可能遇到了互联网连接问题。
请尝试删除 ~/.keras/datasets/ 中未完全下载的文件(如果存在)并重试。
谢谢您的回复。现在我可以加载数据集了。我还有两个问题需要您的帮助
(1)您提到我们可以通过使用代码“numpy.random.seed(7)”来“重现结果”,但我每次仍然得到不同的准确度。我对代码“numpy.random.seed(7)”的理解是否正确?
(2)我得到的结果总是大约50.6%,低于您的。为什么差距这么大?
谢谢您,期待您的回复~
也许这篇博文会有助于重现性
https://machinelearning.org.cn/reproducible-results-neural-networks-keras/
很遗憾听到这个消息,通常神经网络是随机的,评估它们的最佳方法是这个过程
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
嗨,Jason,
这是一篇很棒的帖子。我是神经网络的新手,现在我有一个问题。
我不明白你为什么要为这种语义分析选择LSTM和RNN。明确地说,我不明白哪里有允许我们使用RNN和LSTM的序列部分。
我想知道你是否能解释一下。
我还想知道我们是否可以将LSTM用于实体提取(NLP),以及哪里有好的数据集来训练我们的模型。
当然,请查看这篇关于序列预测的帖子
https://machinelearning.org.cn/sequence-prediction/
还可以看看这篇关于RNN前景的帖子
https://machinelearning.org.cn/promise-recurrent-neural-networks-time-series-forecasting/
我确信LSTMs可以用于实体提取,我没有示例。我的建议是搜索谷歌学术。
嗨,Jason,
在这种情况下特征缩放也会有帮助吗?由于评论被分词,值可能会根据使用的最大词数从低到高变化。
当然可以。
感谢分享模型和代码,以及您热情地回答所有问题。我根据您的cnn+lstm模型构建了我的句子分类模型,它运行良好。我是神经网络的新手,因此我正在努力学习如何解释不同层如何交互,特别是数据形状是什么样的。因此,根据上面的例子,假设我们的数据集有1000条电影评论,使用批大小为64,对于每个批次,请纠正我
嵌入层:输出 – 64(样本大小)x 500(词)x 32(每个词的特征)
conv1d:输入 – 同上;输出 – 对于*每个词*,32个特征图 x (32/3)个特征,其中3是核大小。
maxpooling1d:输入 – 同上;输出 – 对于*每个词*,以及对于*每个特征图*,一个32/3/2特征向量
lstm:输入 – 这是我难以理解的地方… 64是样本大小,500是步长,所以应该是64 x 500 x FEATURES,但是FEATURES=32/3/2,还是32 x (32/3/2),其中第一个32是来自conv1d的特征图?
输出 – 对于*每个样本*,一个100维特征向量
听起来不错。
我鼓励您在您的问题上尝试一系列模型,看看哪个效果最好。
您好,阅读您的博客后觉得非常有帮助,不过您能否指导我一个代码示例,说明如何精确地对文本进行one-hot编码以进行训练,我有20,000条评论需要训练。
或者我可以直接使用哈希技术,其中每个词都表示一个整数吗?
所以就像;
我觉得这家店不错。
我觉得不错。
表示为;
1 2 3 4 5
1 2 5
因为用整数表示每个字符会非常耗时!
然后我就可以继续进行填充等步骤了?
在这种情况下,我将如何预测包含一些新词的新句子?
(这让我重新思考是否应该将每个字符分配给一个整数)如果是这样,您能给我一个示例吗?
我建议对文本使用整数编码。
此外,您可以计算每个单词的出现次数,并将词汇量大小减少到只包含最常用的单词。
我很快会在博客上发布关于如何做到这一点的文章。
我尝试使用 Keras 在 seq2seq 中创建文本摘要模型。效果不佳。预测结果显示的是按频率排列的顶部词汇。我尝试将英文中的常用词('a', 'an', 'the' 等)列入黑名单。结果仍然不理想。有人说 2016 年 Keras 不适合文本摘要。想知道缺少了什么。
这是一个难题,至少需要100万个示例和一个大型模型。
我有一个关于文本摘要的教程,计划在圣诞节前后发布。
您好,我是Asad。我想知道如何加载一个.text文件中的电影评论文本数据集,然后如何在循环神经网络中使用它?
请告诉我完整的步骤。请记住,数据在我本地电脑上。
这篇帖子将向您展示如何编码文本以用于LSTM
https://machinelearning.org.cn/prepare-text-data-deep-learning-keras/
嗨,Jason,
谢谢这篇帖子。我刚将此方法应用于我们的用例,这与电影评论情感分类非常相似。模型的准确率非常高,约为94%。
但是
我将所有频率替换为随机数,令我惊讶的是,准确率仍然非常高。(~94)。标签也相同。
您对此有什么想法吗?
谢谢,
您到底是什么意思?我没明白您改变了什么。
嗨,Jason,
惊人的工作,而且非常及时。
我想问您,您认为这个序列分类模型可以用来预测一个非常长的数字序列的类别吗,而不是单词??
是的。不过,对于非常长的序列(>400个时间步),您可能需要将它们分成子序列以适应您的模型。
请看这篇文章
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
多谢,我会试一试的!
嗨,Jason,
我真的很困惑。我似乎是唯一一个无法运行您提供的代码的人。
我使用的是python 2.7,Keras-2.0.8,Tensorflow-0.12。我在以下行遇到了错误
model.add(LSTM(100))。
TypeError: 预期int32,但得到包含类型为’_Message’的张量的列表。
您能告诉我您使用的python、keras、tensorflow版本吗?
谢谢!
看来您需要将您的 TensorFlow 版本升级到至少 1.3 或更高版本。
你好 jason,
我想告诉您,我按照您的逐步机器学习项目编写了我的第一个机器学习代码。我正在使用一个非线性数据集(nsl-kdd)。我的数据集是CSV格式。我想使用LSTM对我的数据集进行建模和训练。
对于MNIST数据集,我有一个代码,
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.ops import rnn, rnn_cell
mnist = input_data.read_data_sets(“/tmp/data/”, one_hot = True)
hm_epochs = 3
n_classes = 10
batch_size = 128
chunk_size = 28
n_chunks = 28
rnn_size = 128
我的问题是,根据我的数据集,如何为我的数据集定义块大小、块数和rnn大小作为新变量。
因为我是新手,所以真的不知道如何使用lstm对我的数据集进行建模和训练以找到准确性。我想使用LSTM作为分类器。我不知道我对您的问题是否正确。
我非常感谢您的帮助。
抱歉,我没有直接使用 TensorFlow 的示例。我无法给您好的建议。
是否可以将相同的代码用于简单的神经网络进行文本处理?
使用 Keras 进行文本处理是最佳方式吗?或者还有其他库可以实现用于文本处理的神经网络?
是的,也许可以从这篇帖子开始准备您的文本数据
https://machinelearning.org.cn/prepare-text-data-deep-learning-keras/
嗨,Jason,
这篇帖子和评论对我帮助巨大。谢谢!我有一个关于这句话的问题 –
“IMDB评论数据在评论词序中确实具有一维空间结构,CNN可能能够识别出良好和不良情感的不变特征。然后,这些学习到的空间特征可以通过LSTM层作为序列学习。”
我无法想象CNN将如何处理单词。另外,您能解释一下单词的空间结构吗?
单词在句子或段落中是有序的,这就是空间结构。
对于序列到序列挖掘,哪种神经网络性能更好?
LSTMs。
我读过关于神经网络中的序列到序列学习,我们需要LSTMS层,第一个用于输入序列,第二个用于输出序列,在这里我们必须将输入序列向量以相反的顺序发送到LSTM层。
我的疑问是,LSTM层会以相反的顺序接收输入,还是我们必须以相反的顺序提供输入?
是的,您可以通过 LSTM 层的 `go_backwards` 参数反转顺序。
https://keras.org.cn/layers/recurrent/#lstm
对于序列到序列回归模型,输出节点我应该给一个还是应该给出最大可变长度的输出向量?
最终我们将得到输出向量,我们如何将这些输出向量转换为文本,Keras中是否有任何方法,就像在嵌入层中我们进行字符串到向量的转换,类似向量到整数的转换。
要输出文本,您可以使用 softmax 输出每个字符或单词的概率,然后取 argmax 得到一个整数,并将该整数映射回您词汇表中的值。
我很快会在博客上发布关于如何做到这一点的示例。
问题陈述:我的模型应该根据使用Keras的序列到序列建模,根据给定指令生成脚本文件。
示例:输入:从控制台获取两个整数,将两个整数相加,在控制台上打印两个整数的和。
输出:类似于上述输入指令的Python脚本文件。
请给我解决这个问题的任何联系点,我如何进一步解决这个问题。
这里有一个例子
https://machinelearning.org.cn/learn-add-numbers-seq2seq-recurrent-neural-networks/
是否可以使用机器学习将自然语言翻译成编程语言,例如C、PHP或Python?请推荐我任何可用于完成此任务的库。
也许可以。
你可以考虑使用LSTM作为文本生成器进行序列到序列学习。从这里开始
https://machinelearning.org.cn/start-here/#lstm
Brownlee博士,我无法表达我对您网站内容的珍视!如此易懂,切中要害,且富有启发。您正在改变世界。谢谢您。
谢谢 Tamir!
很棒的教程!
但是如何使用这个网络来分类几个不同的类别呢?例如14个类别。
我理解是否正确——我只需要将 model.add(Dense(1, activation='sigmoid'))
改为 model.add(Dense(13, activation='sigmoid'))
还是需要使用 Conv2D?
以及如何将我的文本数据转换为词嵌入(如IMDB所用)?
要将示例更改为适用于多类别分类问题,请将输出层更改为每个类别一个神经元,并使用 categorical_crossentropy 损失函数。
感谢您精彩的示例!
我在模型过拟合方面遇到了一些麻烦 –
在训练中,我使用的是俄语文本数据(语言本身并不重要,因为文本包含大量特殊专业术语,很遗憾无法使用现有的word2vec)。
我的训练数据参数如下:文章最大长度 – 969个词;词汇量大小 – 53886;标签数量 – 12(不幸的是,它们分布很不均匀,例如,第一个标签有大约5000个示例,而第二个标签只有1500个示例)。
训练数据集数量 – 仅9876条。这是最大的问题,因为遗憾的是我无法以任何方式增加训练集的大小(唯一的办法是再等一年☻,但即使这样也只能使训练数据量翻倍,而即使翻倍也不够)。
这是我的代码 –
x, x_test, y, y_test = train_test_split(x_, y_, test_size=0.1)
x_train, x_dev, y_train, y_dev = train_test_split(x, y, test_size=0.1)
embedding_vecor_length = 100
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=4, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=5, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=7, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=9, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=12, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(Conv1D(filters=32, kernel_size=15, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(LSTM(200,dropout=0.3, recurrent_dropout=0.3))
model.add(Dense(labels_count, activation='softmax'))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
打印(model.summary())
model.fit(x_train, y_train, epochs=25, batch_size=30)
scores = model.evaluate(x_, y_)
我尝试了不同的参数,训练准确率非常高(高达98%),但在测试集上表现很差。我最多只能达到约74%,通常结果约为64%。最好的结果是在小的 embedding_vecor_length 和小的 batch_size 下实现的。
我知道我的测试集只占训练集的10%,而且总数据集是最大的问题,但我想找到解决这个问题的方法。
所以我的问题是 – 1) 这个模型是否正确地用于文本分类?(它有效)我需要同时进行卷积并合并结果吗?我只是不明白在具有不同滤波器大小的卷积过程中(如我的示例中)文本信息是如何不丢失的。您能解释一下卷积如何处理文本数据吗?主要有关于图像识别的文章……
2) 我显然遇到了模型过拟合的问题。如何提高性能?我已经添加了Dropout层。接下来我能做什么?
3) 也许我需要一些不同的东西?我的意思是纯粹的RNN而不是卷积?
也许可以尝试使用交叉验证来获得更可靠的模型技能估计。
或许可以探索更简单的基于CNN的方法,这是一个好的开始
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
或许可以探索通用的深度学习调优方法
https://machinelearning.org.cn/improve-deep-learning-performance/
希望这些能作为一个开始有所帮助。
如果没有涉及词汇,您将如何进行序列分类?例如,我想将一个看起来像 [0, 0, 0.4, 0.5, 0.9, 0, 0.4] 的序列分类为0或1,但我不知道我的数据应该采用什么格式才能馈入LSTM。
也许可以从这里开始,Alex
https://machinelearning.org.cn/start-here/#lstm
你好,
如果我们想对数字序列进行分类,这个例子是否适用?我需要嵌入层吗?您能推荐一个您在博客或其他地方的例子,以便我能更深入地理解吗?谢谢。
不需要嵌入层。
您好。
不错的教程,伙计。你能展示一下如何将这个LSTM网络用于二元分类问题吗(就像你关于神经网络的教程——印度原住民糖尿病)。
请您帮帮我……
它不适合该数据集,因为没有序列信息。
您可以从这里开始学习 LSTMs
https://machinelearning.org.cn/start-here/#lstm
谢谢 Jason
你好,
我尝试了序列分类,但无法在嵌入层之上添加LSTM层。
您是否遇到过类似的问题?
这是我遇到的问题:https://stackoverflow.com/questions/47464256/unable-to-add-lstm-layer-on-top-of-embedded-layer-on-gpu-keras-with-tensorflow
这是使用函数式API的示例
取自这里
https://machinelearning.org.cn/develop-a-caption-generation-model-in-keras/
嗨,Jason,
感谢您的教程。但是,当您说
“我们可以看到,我们取得了与第一个示例相似的结果,尽管权重更少,训练时间更快。”
当您说权重更少时,您具体指的是什么?因为当您运行model.summary时,带有卷积层的模型有21.6万个参数,而原始模型有21.3万个参数,从技术上讲,有更多的参数需要训练。
您是不是说,使用卷积+池化层,LTSM层的输入来自250个隐藏层节点,而原始模型是500个?我猜LTSM层更难训练,从而导致拟合时间减少?
谢谢
嗨
我尝试了文本分类。我有一组推文数据集,我必须训练一个模型来判断作者是开心还是难过。我使用了您的“简单LSTM序列分类”代码。但我想要知道在使用您的代码之前,我应该用什么来替换单词。
以前我使用“sequences = tokenizer.texts_to_sequences(tweets_dict["train"])”将文本转换为向量,之后我使用了您的代码。这样做正确吗?
请看这个例子
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
真正信息丰富且内容结构精巧,
现在它非常用户友好(:。
谢谢!
如果您允许我引用您的几篇文章,只要我提供
出处和来源链接到您的网站,您介意吗?我的博客网站与您的网站属于同一兴趣领域,我的用户将真正受益于
您在此处提供的大量信息。
请告诉我这是否可以。非常感谢!
当然,只要您不逐字复制帖子(例如,只复制少量引用)并清楚注明来源即可。
非常好的文章。您能告诉我如何进行单个预测吗?例如,对于给定的文本,我们必须进行预测。
例如,“Very nice movie”作为单个输入,输出“positive”。
是的,请看这篇文章
https://machinelearning.org.cn/make-predictions-long-short-term-memory-models-keras/
嗨,Jason,
在我的问题中,我对每个样本(10000个样本)进行了大小为256的独热编码。嵌入层是必要的吗?我做的第一层是
model.add(LSTM(256, input_shape=(10000, 256), activation = ‘relu’))
您也使用了model.add(LSTM(100))。它与embedding_vecor_length有任何关系吗?它必须大于embedding_vecor_length = 32吗?我正在使用256,但没有任何想法。谢谢。
或许可以尝试有嵌入和无嵌入的模型,看看它如何影响模型性能。
先生,感谢您提供如此精彩的教程。我正在进行序列分类。我的数据集包含41个特征,每个特征都是浮点数,Y是5个类别。
问题1:我需要嵌入吗?
问题2:我已经对数据进行了归一化,那么我需要top_words吗?
问题3:嵌入向量长度可能是多少?
问题4:最大评论长度可能是多少?
问题5:所有示例都包含41个特征,我需要填充吗?
我对嵌入层不是很清楚。您的建议对我来说将非常有用。
一个评论里问题太多了!
一般来说,我无法告诉您哪种方法最适合您的问题,您必须通过实验来发现最有效的方法。请参阅此帖子
https://machinelearning.org.cn/applied-machine-learning-as-a-search-problem/
你好,suman,我遇到了和你一样的情况
我的数据集有8个特征和100,000个观测值,我必须将这些序列数据分类
到4个不同的类别。
但我对嵌入的“向量长度”、“最大评论长度”等一无所知。
如果你解决了你的问题,你能告诉我你是怎么解决的吗?
任何评论或建议都将不胜感激。
以下是一些处理超长序列的方法
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
我有一个小疑问。您正在使用IMDB数据集。如果我想使用不同的数据集,那么如何预处理数据集以准备单词整数矩阵来执行以下操作
# 加载数据集,但只保留前 n 个单词,其余归零
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# 截断并填充输入序列
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
我的数据(.csv格式的两列:推文和类别/手动标注)看起来像这样
奥巴马总统说,美国需要做更多的事情来帮助阻止埃博拉疫情成为全球危机。行动起来,不要空谈。风险
我很难过也很生气,因为托马斯·埃里克·邓肯谎报他接触过埃博拉,让我们所有人都面临感染这种致命疾病的风险。风险
埃博拉通过血液和唾液传播,所以我最好不要再那么用力地揍我的仇人,也不要再亲吻所有这些美丽的女人。传播
他得到了最好的治疗——比利比里亚更好——但我仍然不相信他不知道自己得了埃博拉,又是种族牌。治疗
奥巴马和疾控中心说他们将在非洲抗击埃博拉,今天的新闻是埃博拉死亡人数急剧上升,他们到底什么时候才能抗击它呢?治疗
妈的这真的很难,不知道我是否有勇气和胆量每天面对死亡和埃博拉。风险
对于埃博拉这种该死的东西,需要采取更严肃的措施。机场和他所在的小镇需要被隔离,我受够了被预防
如果你有埃博拉症状,或者认识有埃博拉症状的人,请拥抱并亲吻奥巴马先生,向他表示尊重,他会很感激。症状
只有当您与埃博拉患者的体液频繁接触并出现症状时,您才会感染。传播
请看这里的示例
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
嗨,Jason,我想知道在构建了一个使用机器学习或深度学习的模型之后,如何使用该模型自动分类未标记的语料库?有没有示例?
此致
是的,在此处了解有关最终模型的更多信息
https://machinelearning.org.cn/train-final-machine-learning-model/
在此处学习如何保存和加载深度学习模型
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
嗨,Jason,
感谢您的巨大努力,
我正在尝试使用Keras LSTM,但我不知道数据格式。
我有一个FAQ列表,问题被认为是样本,答案被认为是类别。那么我如何将lstm分类器用于此数据集?
先谢谢了
请看这篇文章
https://machinelearning.org.cn/reshape-input-data-long-short-term-memory-networks-keras/
嗨,Jason,
我有一个需要两种输入进行分类的问题。
第一个输入是在线活动的序列,我可以使用上述模型来处理。
第二个输入是每个活动与上次活动之间的时间差(分钟)向量。在这种情况下,我希望我的模型也能考虑时间对决策的影响。
我的问题是如何最好地将第二个输入合并到上述模型中?
我所做的是在第二个输入上也使用了一个LSTM层,并将输出与上面的输出合并。但这似乎不对,因为第二个输入是连续值而不是离散索引。
那么我应该使用什么样的层来应用于这些实值向量呢?
或许可以尝试一系列模型,看看哪种最有效。
或许多头模型是一个不错的方法。
嗨,Jason,
如何在此模型中处理两种类型的输入?
一个是线上活动的序列,第二个输入是每个活动与上一个活动之间的时间差。
我应该使用多模态层来合并它们吗?
我是否也应该用LSTM层处理第二个输入?(这似乎不对,因为该向量的元素是连续值)
祝好,
R
请参阅此帖子中的示例
https://machinelearning.org.cn/keras-functional-api-deep-learning/
谢谢您的回复。我明白如何合并两个层,但我的问题是,我应该在哪一层合并在线活动及其近期分数?
例如,我可以对在线活动应用一个LSTM层,然后将LSTM层的输出(最后一个隐藏状态输出)与它们的近期分数序列连接起来。但这没有意义。
或者我可以将嵌入输出与它们的近期分数序列相乘,然后将输出放入LSTM层。但我不知道这是否正确。
您能给我一些建议吗?
谢谢,
雷
我的直觉可能会引导您走上错误的道路。也许可以尝试几种设计,看看哪种最适合您的特定问题。
目前这方面更多的是艺术而非科学。
很公平。不过还是非常感谢。当我必须向我的教授汇报进展时,我会以此作为借口。😀
你好,
我可以使用LSTM从视频生成标签吗?例如使用youtube2text?
谢谢
当然可以。
我可以用它进行唇语识别吗?我正在考虑将一系列帧分类为特定单词。比如整个视频将被分类为hello、how等。
你能告诉我该怎么做吗?
听起来不错。抱歉,我没有任何唇语识别模型的示例。
嗨,Jason:您的教学技能远超许多“大牌”教学专家。
作为一个实验,我在您的“简单”LSTM示例中的模型中添加了一行。
model.layers[0].trainable = True # 通过嵌入层进行训练(反向传播)
虽然可训练参数的数量显著增加(从53,301增加到1,660,501),但准确率没有变化。
想听听您对这个实验的看法。
该层默认是可训练的。赋值应该没有效果。我很惊讶。
Jason,
感谢您精彩的解释。
我修改了您的代码,以便在测试数据上获得更高的准确性,最终,我在测试数据集上获得了88.60%的准确性。
我的问题是,除了我盲目地修改这些超参数之外,我们还能做些什么来提高测试数据上的预测准确性?或者如何克服过拟合以在测试数据上获得更高的预测准确性?我发现很容易在训练数据上获得更高的预测准确性,但令人惊讶的是很难在测试数据集(或验证数据集)上实现相同的结果。我修改的代码如下,供其他人参考:
谢谢!
Clock ZHONG
做得好,这里还有一些想法
https://machinelearning.org.cn/improve-deep-learning-performance/
谢谢,Jason,您写的那篇文章,我半年前就已经仔细阅读过了。它也很完美,但我仍然觉得我们没有一个清晰的指南来如何提高测试数据集上的预测准确性。
我们总是说
1. 更多的训练和测试数据可以获得更好的性能,但并非总是如此。
2. 神经网络中更深的层可以获得更好的性能,但仍然并非总是如此;
3. 微调超参数可以获得更好的性能,是的,它是,但除了时间消耗之外,这种工作只能非常非常少地提高性能(根据我的经验)。
4. 尝试更多其他架构的神经网络算法。是的,有时这可能会奏效,但很快我们又会达到上限,并立即面临同样的问题:然后如何改进它?
克服过拟合在神经网络中确实是一项有趣但困难的工作,我觉得未来我们可以找到一些更好的方法来解决这个问题。
我仍然感谢您的文章和回复。祝您周末愉快。
谢谢
Clock ZHONG
是的,这很难,而且是经验性的。这就是这份工作的本质。
没有明确的答案,没有人能告诉您如何为给定数据集获得最佳结果。您必须自己发现。
非常感谢Jason的精彩帖子。我很难理解LSTM如何记住长期依赖关系。或者也许,我误解了“记住依赖关系”的含义。它记住特定训练数据内的不同部分还是不同训练数据之间的不同部分?
例如,如果我们有100个训练数据,它会通过记住之前的训练数据来从第81个数据中学习吗?
提前非常感谢您的时间和帮助,
我有一个例子可以清楚地说明这一点。
https://machinelearning.org.cn/memory-in-a-long-short-term-memory-network/
我会阅读的,非常感谢。
Jason
很棒的文章!它对我帮助很大。
但是,我不明白为什么Dropout在降低准确率的同时却被认为发挥了积极作用。
这通常会有帮助,在这篇文章中我们正在演示如何实现它。
你好,
谢谢这篇文章。您能提供一个关于如何将LSTM应用于手写图像识别的思路吗?我有一个手写字母数据集,图像大小为50*50。
如果我能知道LSTM如何帮助手写文本识别,也会很有帮助
谢谢你,
当然,请看这篇帖子
使用卷积神经网络和 Python Keras 进行手写数字识别
谢谢你的帮助
1.该代码使用卷积神经网络。我应该做哪些更改才能使用循环神经网络(LSTM)?
2.如何加载自定义图像数据集进行训练和测试,而不是MNIST数据集。
LSTM可以用于图像序列,但前端仍将使用CNN。
请参阅此帖子了解CNN LSTM
https://machinelearning.org.cn/cnn-long-short-term-memory-networks/
感谢您这项伟大的工作!我们能将其应用于法语吗?
当然可以。
你好,
好文章。我有一个比较基本的问题。据我所知,这里每个样本都是长度为“max_review_length”的序列。然而,如果我有一个一维序列,每个样本都是序列的一部分。我的问题是,如何告诉算法序列发生在哪个维度。
在这里,我们输入的是本身不是序列一部分但包含序列的样本。但在其他用例中,我们似乎是按序列输入样本,而样本本身构成序列。我们甚至可以输入多维序列,例如多个并行时间序列,它们只在第一维是序列。
我对此有点困惑,在我看来,算法应该只识别沿一个维度的序列,如果您能澄清一下就太好了。
谢谢
我不确定我是否理解。
也许这篇帖子能让LSTM的输入更清晰
https://machinelearning.org.cn/reshape-input-data-long-short-term-memory-networks-keras/
好的,我来澄清一下。假设我们有一个包含5个值的序列。我们可以逐个输入序列,形状为(5,1,1),或者一次性输入所有5个点(1,5,1)作为长度为5的向量。然而,这两种情况都被认为是序列吗?
在我看来,第一个是长度为5的序列,而第二个是5个长度为1的并行序列。这很重要,因为在情感分析的例子中,我们有N个长度为“max_lenght”的样本,即形状为(N, max_lenght, 1)。或者如果使用嵌入,可能是(N, max_lenght, embedding_dim)。
如果序列在第一个维度,即N的维度,那么LSTM就没有意义,因为不同评论之间不应该存在序列关系。
谢谢
不,第一个是5个序列,第二个是1个序列。无论如何,LSTM一次只处理一个时间步的数据作为输入。
一个批次由1个或多个序列(样本,第一维度)组成。
权重更新在每个批次结束时发生,此时内部状态被清除。这意味着,序列之间存在知识。如果需要的话,也可以有。
好的,我明白了。谢谢你的澄清。继续努力。
不客气。
嗨,Jason,
我刚开始学习机器学习,并在keras上尝试了一些示例项目。这篇文章是一个非常好的学习示例。
我有一个关于分类问题的问题。现在,我正在尝试一个二分类序列分类问题。我按照这个教程建立了模型,损失函数为二元交叉熵。然后我将输出层改为2个单元,将损失函数改为分类交叉熵,并将y_training改为独热编码。我期望这两种方法能给出相同的准确率,但实际上,分类交叉熵似乎更准确。你有什么想法为什么会这样吗?据我理解,二元交叉熵与2分类别的分类交叉熵是相同的,所以这两种方法应该给出相同的结果。
另一个问题。我读了你网站上的另一篇文章,并将输入层改为LSTM。然后我截断了训练数据。我使用完整的训练数据进行验证。截断的训练数据在验证时给出了比使用完整训练数据构建的模型更高的准确率。我在这里使用了二元交叉熵方法。这与我的预期不符。我还想知道如何决定输入层的类型?
如果你能花时间回答我的问题,我将不胜感激。
它可能允许模型更具表达力(例如,在输出计算中有更多的权重)。
我不确定我是否理解第二个问题,也许你能给出一个非常简短的例子?
这个模型适合预测用户是否执行了这项活动吗?因为我想开发一个模型来预测用户是否执行了这项活动。我想在用户活动(比如跳跃)上训练模型,然后测试用户是否在跳跃。这个模型能帮到我吗,或者你有什么代码可以帮助我吗?谢谢你的帮助,此致,Sardar Khan。
也许可以尝试一下。
你能给我一个例子吗。
抱歉,我没有你问题的示例。
我无法清楚地理解这里二分类是如何发生的?我正在试图弄清楚以下问题:
对于分类,LSTM的最终单词的最终输出是否被提供给单神经元密集层?如果是这样,在你另一篇关于“使用LSTM生成文本”的文章中,你似乎创建了一个输出密集层,其神经元数量等于词汇量中的单词数量。但在文本生成的情况下,你需要输出,使得给定的记忆单元预测下一个合适的单词。那么密集层到底是如何连接到LSTM层的,它是如何工作的(因为LSTM层似乎只给出最终单词的最终输出)??请帮助我回答这两个问题。
是的,Jason,这也是我困扰的问题。你能解释一下在这两种不同情况(“序列分类”和“文本生成”)中,密集层是如何与LSTM层“连接”的吗?
提前感谢你
安基塔
这个例子是将词序列分类为好/坏情绪。
它与生成文本(输出一个词序列)不同。
这有帮助吗?
谢谢你的回复,Jason。
但是你能解释一下在这两种情况下,LSTM层和密集层之间的连接到底有何不同吗?
你具体是什么意思?
嗨 ..
干得好..但我们如何输入单个评论并获得其预测结果呢?
您必须像处理任何训练数据一样准备单个输入。
这里有一些伪代码可以帮助你
嗨,Jason,
感谢这篇精彩的文章。我正在尝试实现一个类似您的分类器,但在不同的数据(日志文件)上进行训练,并使用另一种输入形状。我得到了多行数据,每行有9个特征,每个特征都填充到MAX_FEATURE_LEN。这对于LSTM层来说工作正常,但只要我添加Embedding或Dense层,就会出现类似以下的错误:
Error when checking target: expected dense_1 to have 2 dimensions, but got array with shape (2000, 9, 256)
我目前的模型
features = 9
MAX_FEATURE_LEN = 256
model = Sequential()
model.add(Embedding(file_len(TRAIN_PATH), features, input_length=MAX_FEATURE_LEN))
model.add(Dropout(0.2))
model.add(LSTM(100, return_sequences=True))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
我尝试了几种方法,它对LSTMs有效,所以我不知道Dense层和LSTMs在input_shape方面有什么区别。
提前感谢你
阿德里安
也许可以退一步,学习一下NLP中的LSTM。
https://machinelearning.org.cn/start-here/#nlp
这篇博文非常棒,对使用Keras实现LSTM-CNN的指南也很易读。
最近我正在处理一个二分类任务,该任务从多个传感器获取实数数据。我受到了你的文章启发,想知道是否可以把这些数据排列成图像一样的矩阵,其中每一行是一个传感器的向量,多行代表不同传感器的数据,然后使用你文章中的LSTM、CNN或LSTM+CNN模型对数据进行分类。
你觉得这种模型可行吗?或者?再次感谢你的文章!
也许多个1D CNN会更有意义?
我建议尝试一下,而不是过多地考虑它是否可行,例如,Keras非常容易,你可以在几分钟内将其原型化。
不错的教程,Jason。它让我开始在Keras中使用LSTMs!
对于分类问题,使用多少个LSTM单元有什么经验法则吗?输入序列的长度对这个数字有影响吗?
好问题。
没有关于配置单元数量或层数的良好启发式方法。输入长度与隐藏层中的单元数量没有关系。
我建议仔细和系统地进行实验,以了解哪种方法最适合您的特定数据集。
nb_words 已被 num_words 取代
谢谢,已修正。
nb_epoch 也被 epochs 取代了
谢谢,已修正。
菜鸟问题:这个模型能预测序列的特定模式吗?比如x, x^2, x^3, sin(x)等等这些序列的所有组合?
一个模型或许可以被训练来学习这些序列。
亲爱的 Jason,
请问您能帮我如何在Keras中“上传我自己的数据集”吗?因为我想使用自己的数据集。谢谢您的时间。
这篇文章将向你展示如何将自己的CSV数据加载到Python中。
https://machinelearning.org.cn/load-machine-learning-data-python/
亲爱的 Jason,
Keras包含预定义的数据集,如“imdb”、“cifar”等。我想知道我能否将自己的数据集包含到Keras数据集中。
您可以将数据加载到 numpy 数组中,然后开始使用 Keras。
我在博客上有很多关于 CSV 数据和文本数据的例子。
我对LSTM如何训练有点困惑。
每个时间戳输入到LSTM的是什么?是整个评论(一个500 x 32矩阵?)还是一个单词(32维向量)?
LSTM在每个epoch中做什么?
以及LSTM中的100个神经元是如何使用的?由于它是循环的,我们能只使用1个神经元来完成这项工作吗?
非常感谢!
LSTM 接受由时间步和特征组成的样本训练数据集,即 [样本, 时间步, 特征]
这有帮助吗?
我也有同样的疑问……你能详细说明一下吗?
你可以在这里了解更多关于如何为LSTM准备数据的信息。
https://machinelearning.org.cn/faq/single-faq/how-do-i-prepare-my-data-for-an-lstm
我有一个长度为25000的数据集,我选择了前2500个长度并将其视为x_train,但我对嵌入层很困惑:参数——词汇量大小应该是什么?如果我选择2500,那么剩余的词汇量就不包括在内,并且会给出错误
”
InvalidArgumentError: indices[23,2433] = 80188 is not in [0, 80000)
[[节点: embedding_59/embedding_lookup = GatherV2[Taxis=DT_INT32, Tindices=DT_INT32, Tparams=DT_FLOAT, _class=["loc:@training_42/Adam/Assign_2"], _device="/job:localhost/replica:0/task:0/device:CPU:0"](embedding_59/embeddings/read, embedding_59/Cast, training_42/Adam/gradients/embedding_59/embedding_lookup_grad/concat/axis)]]"
和
无法通过此代码行下载数据
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
错误显示名称或服务未知。
请尽快帮助
也许尝试将您的代码和错误发布到stackoverflow?
嗨,Jason,
我有32个句子块,每个块包含500个词,在使用预训练的word2vec模型获取每个词400个词嵌入后,将其传递给LSTM。我如何实现同时学习这32个特征?
谢谢!
纳姆拉塔
第一个隐藏层中的单元数量与数据的大小无关。
你可以在这里了解更多关于如何为LSTM准备数据的信息。
https://machinelearning.org.cn/faq/single-faq/how-do-i-prepare-my-data-for-an-lstm
你好,
在pad_sequences中,输出的dtype默认为int32。如果我们要输入词向量,不应该将其更改为float32吗?
谢谢
不,将单词的整数映射馈送到映射是我们想要的,除非我误解了你的问题。
模型测试完成后,准确率达到84%
然而,当我尝试使用以下代码预测句子时
text = ‘It is a bad movie to watch’
text = preprocessing.text.one_hot(text, 5000, lower=True, split=’ ‘)
text = [text]
text = preprocessing.sequence.pad_sequences(text, 500)
predictions = model.predict(text)
print(predictions)
结果是0.90528411
当我把句子改成“It is really a good movie to watch”时
预测结果是0.88954359
那么是预测代码有问题还是我错过了训练
新文本的准备方式必须与用于拟合模型的文本相同,这一点很重要。
我们没有关于imdb数据集是如何准备的信息。
我推荐这个教程。
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
感谢您的回复,也感谢这些精彩的教程,它们真的非常有用和信息丰富,对我帮助很大。
嗨,Jason,
干得好,努力付出!非常感谢。
我对使用rnn-lstm和Tensorflow分析恶意软件的序列分类很感兴趣。虽然有一些资源,但我总是觉得你的博客非常易读和易懂。因此,请求你写一篇关于“使用Tensorflow中的RNN-LSTM进行序列分类”的博客。
谢谢马特。
亲爱的 Jason,
我想知道在深度学习(RNNLSTM)模型中,为了开发一个良好拟合的模型,训练和测试准确率之间应该有什么区别。
并请告诉我我的模型是否良好拟合。
在[10]中:model.fit(X_train, Y_train, epochs = 7, batch_size=batch_size, verbose = 2)
在[11]中:score,acc = model.evaluate(X_test, Y_test, verbose = 2, batch_size = batch_size)
print(“score: %.2f” % (score))
print(“acc: %.2f” % (acc))
Epoch 1/7
1109秒 – 损失:0.6918 – 准确率:0.5056
Epoch 2/7
971秒 – 损失:0.6269 – 准确率:0.7041
Epoch 3/7
693秒 – 损失:0.3696 – 准确率:0.8639
Epoch 4/7
594秒 – 损失:0.1743 – 准确率:0.9388
Epoch 5/7
534秒 – 损失:0.0699 – 准确率:0.9800
Epoch 6/7
473秒 – 损失:0.0276 – 准确率:0.9950
Epoch 7/7
472秒 – 损失:0.0148 – 准确率:0.9963
输出[10]
分数:0.62
准确率:0.82
谢谢您的帮助。
我在这里解释如何判断模型是否良好拟合。
https://machinelearning.org.cn/faq/single-faq/how-to-know-if-a-model-has-good-performance
亲爱的 Jason,
我有一个疑问,这个准确率
# 模型的最终评估
scores = model.evaluate(X_test, y_test, verbose=0)
print(“准确率: %.2f%%” % (scores[1]*100))
是模型的预测准确率吗?
是的。
嗨 Jason,
感谢您的教程,它非常有帮助。
我有一个问题,例如我总共处理500条消息。这些消息被分为某些模式。有时6条消息构成模式A。有时接下来的3条消息构成模式B。我需要对这500条消息中的模式进行分类。
我用LSTM训练了模型,输入形状为包含最多消息的模式,并填充了其他模式。我使用了滑动窗口概念和多标签分类。
在测试时,当我给出一个包含150条消息的文件时,在滑动窗口期间,有时窗口中可能不会出现任何模式,但LSTM模型会将其分类为某种已知模式。那么如何克服这个问题呢?
提前感谢。
也许你可以为这些情况设置一个“无模式”输出,并对模型进行训练?
感谢您的回复,Jason。与已知模式相比,未知模式实在太多了,如果我也要用未知类别进行训练。所以它面临着类别不平衡问题,并且总是给出未知类别作为输出。
我们只在已知输出的数据上训练模型。
亲爱的Jason
感谢您的教程,您还有其他关于在时间序列数据集上使用卷积LSTM的教程示例吗?
谢谢
我有一些帖子已经安排好了。在此之前,这或许能帮到你。
https://machinelearning.org.cn/cnn-long-short-term-memory-networks/
很好的解释!
我如何像imdb数据集格式一样构建词汇表。
你能给出一些伪代码吗?
谢谢
也许这会有帮助。
https://machinelearning.org.cn/prepare-text-data-deep-learning-keras/
尊敬的先生,
我想知道CNN模型的哪些参数或因素使得CNN+LSTM架构能产生86.36%的准确率。换句话说,使用CNN模型时,影响模型准确率的因素有哪些。谢谢…
很多很多事情,这可能会有帮助。
https://machinelearning.org.cn/improve-deep-learning-performance/
亲爱的Jason
首先,非常感谢您的努力。我刚开始学习不同的算法,您的文章对我帮助很大。
我按照您的LSTM文章,尝试了y_pred = model.predict(X_test)。
但它给我的是连续值而不是0或1。我需要在哪里更改才能得到二进制输出?谢谢。
祝您愉快。
祝好
拉希德
也许您的模型配置为预测连续值?
谢谢你的回复。是的,我想是这样。我只是复制并粘贴了你的代码以及你使用的数据。我只是在学习。我没有更改你的任何代码。你能告诉我需要在哪里更改才能得到二进制结果吗?
当然,这会有帮助。
https://machinelearning.org.cn/faq/single-faq/how-can-i-change-a-neural-network-from-regression-to-classification
抱歉,我是NN新手,但我可以用它来识别一个句子是淫秽的还是非淫秽的吗(直觉说是),只是需要确认。
首先收集一个包含已知标签的句子的数据集。
内容很棒,谢谢分享!
鉴于此类数据的顺序性,这是否应该用于分类历史天气模式(非预测;例如,根据已标记的训练集分类为“下雨”等),还是您认为更简单的支持向量分类方法仍能在一定程度上模拟序列数据?
我建议测试一系列方法,以发现哪种方法最适合您的特定问题。
嗨,Jason,感谢您的精彩文章!我不太确定我是否理解为什么我们需要嵌入层?如果我们简单地将原始矩阵(填充后)输入网络会怎样?
[0 0 0 … 12 33 421]
[0 0 0 … 1 654 211]
为什么嵌入有帮助?
你可以在这里了解更多关于嵌入层的好处。
https://machinelearning.org.cn/what-are-word-embeddings/
谢谢!实际上,直接输入原始矩阵是没有意义的,因为据我所知,词的顺序很重要。如果我们使用另一种方法,比如CountVectorizer(来自sci-kit learn),我们能避免嵌入层并直接从LSTM层开始吗?
当然,你可以直接将整数序列(标记化的单词)输入到LSTM。
嗨,Jason,
我从这篇文章中学到了很多。
关于LSTM层,我很难理解输入和输出的维度。我读了很多关于单元层及其工作原理的资料,也理解了数学,但在更高层面我感到困惑。
嵌入后LSTM的输入是500x32。如果我们接收到大小为n个单元(100)的向量输出,那么每个LSTM单元的输出到底是什么?
我之前错误地认为每个单元在这种情况下会产生一个32大小的向量,然后您会得到一个32x100的矩阵。
您能轻松解释一下产生此输出的LSTM动态吗?
LSTM接受一个序列作为输入,并产生一个单一值作为输出。
如果你有一个100个节点的层,每个节点将接收整个序列作为输入并输出一个值,因此是一个长度为100的向量。
这有帮助吗?
你好,
感谢您的快速回复 🙂
在许多地方,我看到节点输出一个向量(通常称为h(t))。这是我不理解的地方。
是的,LSTM 在序列末尾为每个节点输出一个包含一个值的向量。他们将其称为 h 或隐藏状态。
你好,
再次感谢您的博客。我猜您为什么使用二元交叉熵。这个数据集难道不是用1到10的星级评论标记的吗?
有没有使用分类交叉熵的文本分类器帖子?
非常感谢。
诚挚的问候
是的,我确定我有几个。它只适用于多类分类,例如
https://machinelearning.org.cn/multi-class-classification-tutorial-keras-deep-learning-library/
嗨 Jason!你能解释一下为什么你在这里没有使用你的“Series to Supervised”函数吗?我以为所有序列问题都需要转换成那种格式,还是说只适用于时间序列,比如天气预测?
这是一个文本分类问题,数据已经准备好了。
我正在处理类似的数据集,我用词袋模型将文本数据转换为向量。我可以使用相同的模型吗?
或许可以试试看?
不错的教程!嵌入会保留单词的顺序吗?
所以“don’t I like bikes”这句话和“I don’t like bikes”是不一样的。
如果您的训练数据同时包含“bike”和“bikes”的用法,嵌入的性质可以捕捉它们之间的相似性。
好帖子!我仍然对使用metrics=["accuracy"]有点困惑,想知道您是否能帮上忙。假设我们有一个LSTM,预测问题是单标签多类,有多个时间步,并且每个LSTM层都有return_sequences=True。那么“预测”是每个时间步的一个类别,即每个预测都是一个列表,其中len(list) = len(time_steps)。在这种情况下,“准确率”意味着什么?它是获得*每个*时间步预测*完全*正确的二元准确率吗?例如,如果真实标签是[1, 3, 2, 1],预测标签是[1, 3, 2, 2],那么误差是否等于1,因为预测与真实标签不完全相等?
这应该是每个输出时间步的准确率,可能不太合适。您可能需要手动评估预测的性能。
你好 Jason,
感谢您的本教程。
我正在尝试使用训练好的网络来预测一个IMDV评论的情感。
所以我尝试了
prediction = model.predict(x_test[0])
我预期会得到 len(prediction) = 1
但我得到 len(prediction) = 80
80是用于填充输入序列的最大长度。
所以我很困惑。
我将非常感谢对此的一些见解。
非常感谢 Jason
我认为单个样本的形状与模型期望的不符。也许可以重塑它?
嗨
我正在尝试获得纯粹的CNN模型,但似乎缺乏专业知识打败了我。根据您的博客,我构建了这样的模型
top_words = 5000
max_review_length = 500
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
#model.add(Dense(32, activation=’relu’))
model.add(Dense(1, activation=’softmax’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(X_train, y_train, epochs=3, batch_size=64)
但我得到了50%的准确率
25000/25000 [==============================] – 5s 190us/step – loss: 7.9712 – acc: 0.5000
准确率:50.00%
请指导我,并指出我的错误。
此致,
Igor
也许模型需要针对问题进行调整?
谢谢。这很有帮助。
只有一个问题
据我所知,验证集应该与测试集不同。
但在:model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=64) 中,
您似乎将测试集作为验证集!
您能解释一下吗?
是的,我重复使用了测试集以保持示例的简单性。
嗨,Jason,
我有一个数据集,其中包含时间(Unix时间戳)和一些设备级别的特征来预测设备的特定状态,我可以直接使用这些特征通过LSTM进行预测,或者有没有其他方法来加权时间?
我建议您先熟悉时间序列预测。
https://machinelearning.org.cn/start-here/#timeseries
嗨 Jason,您能发布一张网络图片吗?
我在这里解释了如何创建网络图。
https://machinelearning.org.cn/visualize-deep-learning-neural-network-model-keras/
嗨,Jason,
我正在使用LSTM模型进行三分类。其中一个类别在每个样本的序列末尾出现,而另外两个类别在序列的开头和中间出现。我的LSTM未能检测到第三个类别,即使它在序列末尾始终可用。
另一方面,如果我的数据使得三个类别在时间步中均匀分布(所有三个类别在数据集的开头、中间和结尾都可用),那么三分类运行良好。这表明我的模型是好的。
您有什么想法,为什么当一个类别只在数据集末尾出现时,分类会将其关闭?
此致,
Rick
只想补充一下,我正在使用时间分布LSTM模型。
目前没有,也许可以设计一些仔细的实验,使用人造数据来帮助揭示到底发生了什么。
嗨,jason
请分享一个使用CNN-LSTM进行预测的链接。
我在这篇文章中展示了如何操作。
https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
我还有其他帖子,可以尝试搜索框。
你好 Jason,
如果我想将LSTM与Conv2d层一起使用,它会是相同的还是我应该尝试不同的方法,例如添加TimeDistributed层?
请告诉我。
提前感谢!!
这取决于您的具体问题和模型,例如输入和输出是什么。
Jason,非常感谢您——这个教程非常清晰、有帮助,解释得很好!
我在运行代码时遇到错误(在MacBook Pro上使用最新的Pycharm CE),
– 代码最初是粘贴自您的第一个完整代码清单,共29行。
我收到的错误如下——任何能让它运行起来的建议都将不胜感激!
使用 TensorFlow 后端。
回溯(最近一次调用)
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/LSTM brownlee_cr expts.py”, line 28, in
model.add(LSTM(100))
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/engine/sequential.py”, line 181, in add
output_tensor = layer(self.outputs[0])
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/layers/recurrent.py”, line 532, in __call__
return super(RNN, self).__call__(inputs, **kwargs)
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/engine/base_layer.py”, line 457, in __call__
output = self.call(inputs, **kwargs)
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/layers/recurrent.py”, line 2194, in call
initial_state=initial_state)
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/layers/recurrent.py”, line 649, in call
input_length=timesteps)
File “/Users/charlie.roberts/PycharmProjects/test_new_mac_dec_18/venv/lib/python2.7/site-packages/keras/backend/tensorflow_backend.py”, line 3011, in rnn
maximum_iterations=input_length)
TypeError: while_loop() 收到意外的关键字参数 ‘maximum_iterations’
很抱歉听到这个消息,我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
Jason——非常抱歉,我刚刚重新搜索并发现TensorFlow需要再次更新,这似乎解决了问题。吸取教训了,以后会先仔细检查这个(并尝试发布比bug修复更有趣的问题!)。Charlie
好样的,查理!
这确实是一流的。透彻、清晰,一次美妙的长途跋涉,登上顶峰,视野开阔。
谢谢。
嗨,Jason,
感谢您的分享。我有几个问题如下:
1. 当我们在Keras中使用带有后填充序列的LSTM,并且设置return_sequences = False时,LSTM是否能够返回填充开始前最后一个时间步的激活值?或者LSTM总是返回包括填充在内的最后一个时间步的激活值?
2. 如果它返回的是包括填充在内的最后一个时间步的激活值,我们该如何处理?我们需要跟踪序列长度,并为LSTM设置return_sequences = True,然后根据输入序列长度选择正确的激活值吗?有没有更简单的方法?
3. 通常对于情感分析,您认为这会产生很大的不同吗?
非常感谢您的时间!
好问题。
LSTM总是返回最终时间步累积的激活(称为隐藏状态或h),但如果使用掩码层,填充的输入将被忽略。
最终的激活包含整个序列的所有信息——它是一个摘要。如果您需要每个输入时间步的激活来做出决策,那么设置return_sequences=True,并用另一个LSTM或某种其他模型来解释它。
这取决于具体问题。通常情况下,CNN在情感分析方面表现更好。
https://machinelearning.org.cn/best-practices-document-classification-deep-learning/
在进行LSTM分析时,您是否会调整遗忘门和记忆门?例如,在上述用于IMDB数据的LSTM模型中,您是如何将它们整合到您的分析中的?我假设使用了Keras的默认值,但如果需要,我们如何更改?谢谢。
没怎么用过。你可以试试看是否有区别。
嗨 Jason,非常感谢您的教程。
我看不出用numpy.random.seed(7)初始化的种子之后在哪里使用了?是用于Dropout层吗?
对于第一个LSTM模型,为什么我在使用相同种子(7)时会得到不同的训练准确率?
在Keras中获得可复现的结果是具有挑战性的,详情请参见此处。
https://machinelearning.org.cn/reproducible-results-neural-networks-keras/
不错的教程,你做得非常出色。你能制作一个关于使用频谱图或MFCC和神经网络进行语音识别的教程吗?
感谢您的建议。
嗨,杰森,
谢谢你的帖子,非常有帮助。我有一个数据集,它由段落组成,每个段落都包含多个句子。我想让每个句子都经过LSTM层,然后将段落中所有句子的输出结合起来,再经过最终的LSTM层。
就像这个链接中的图片一样
https://drive.google.com/open?id=1E9naIUKybZjlpraidKe_3J5AXJ42ZET_
你能告诉我如何在Keras中构建这种架构吗。
谢谢你。
我不理解图片中的架构,抱歉。
我关于LSTM入门的最佳建议在这里。
https://machinelearning.org.cn/start-here/#lstm
你好,
首先,非常感谢您的这篇文章。
我想使用一个包含词序列的数据集,如何更改这部分代码?
#top_words = 5000
#(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
???
非常感谢。
我建议在处理文本时从这里开始。
https://machinelearning.org.cn/start-here/#nlp
你好,
感谢这篇文章。
我尝试对数值分类问题进行LSTM序列分析。
我的数据集包含36个浮点特征(X)和分类属性(Y)(标签:0,1,2,3)。
我的数据集包含7537条CSV文件记录。
您能告诉我如何为LSTM模型重塑数据集数组吗,因为LSTM需要3D格式的input_shape。
好问题,这将帮助您重塑数据。
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
你好
,
我想问,如果我想使用本教程中的相同方法对品牌数据进行情感分析。品牌数据是客户在社交媒体(如Twitter或新闻)上表达对该品牌的看法的数据。是否存在与品牌数据相关的真实情况,以便我能够明确地基于该真实情况或训练数据来训练模型?!
谢谢您
不,或者我对此表示怀疑。您必须建立一个指标,以帮助您定义一个好的结果是什么样的。
这并非独一无二,大多数问题都存在这个问题,您可以通过将您的指标与朴素方法的结果进行比较来解决它——例如,性能/技能是相对的。
我可以使用LSTM和keras进行未来预测吗?
是的,你可以从这里开始
https://machinelearning.org.cn/start-here/#deep_learning_time_series
嗨,Jason,
感谢您的教程。除了使用前n个单词,我们可以根据,比如说词频x IDF来选择我们模型中的单词吗?
当然可以。
Bryant 2017年10月24日晚上8:12 #
代码给出以下错误
当 allow_pickle=False 时,无法加载对象数组
请您帮助纠正它。
谢谢
很抱歉听到这个消息,我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我遇到了完全相同的错误,但这里的解决方案似乎解决了它。
https://stackoverflow.com/questions/55890813/how-to-fix-object-arrays-cannot-be-loaded-when-allow-pickle-false-for-imdb-loa
本质上,将numpy降级到1.16.2
那真可惜。
我还有另一个修复方法,在代码示例的开头添加这些行
基于
https://stackoverflow.com/questions/55890813/how-to-fix-object-arrays-cannot-be-loaded-when-allow-pickle-false-for-imdb-loa
嗨,我正在使用cnn和lstm对土耳其语文本进行分类研究。有没有土耳其语词典来向量化土耳其语文本?或者,为什么python进行这种向量操作?
你必须对文本进行向量化,我给出了示例。
也许从这里开始
https://machinelearning.org.cn/start-here/#nlp
这个教程会特别有帮助。
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
嗨,Jason,
在实现LSTM时我遇到了以下错误
ValueError: Input 0 is incompatible with layer lstm_1: expected ndim=3, found ndim=2
这是我使用的代码
model.add(LSTM(100, input_shape=(32652,21767,16),return_sequences=False) )
model.add(Dense(22, activation=’relu”))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(X[train], Y[train], epochs=100, batch_size=10)
我尝试过更改input_shape的参数并省略return_sequences。但程序仍然无法运行。
请帮助我解决这个问题
嗨,Jason,
我总是要告诉你我有多么欣赏你的网站。我已经学到了大量关于神经网络编码的知识,而且你似乎已经涵盖了各种主题。我的请求可能也涵盖在内,尽管我没能找到它。
以下问题:我有一些时间序列数据,其中包含混合的分类和数值条目,需要通过LSTM进行分析。想象一下是这样的,但是规模巨大(对于独热编码来说太大了)
2000|20|West|0.2|Yes
2001|21|East|0.4|Yes
2002|22|East|0.9|Maybe
2003|23|North|1.0|No
2000|11|South|0.9|No
2001|12|West|1.1|Maybe
2002|13|West|3.1|Maybe
2003|14|South|0.8|Yes
第一行是时间戳(即年份)。对于纯粹的LSTM,一个3D重塑(在这种情况下是2,4,5)就足以输入了。
分类数据需要一些预处理,这可以通过LabelEncoder和Embedding层实现。
然而,我不确定如何正确地融合Embedding层和LSTM,因为我有很多内部范围不同的类别。
您能否根据您使用嵌入的经验,给出一个简单而简短的例子?
提前万分感谢,
Tobias
谢谢Tobias!
您可以尝试对每个分类变量进行整数编码、独热编码和嵌入,看看哪种效果最好。
嵌入层与每个时间步的其他输入进行连接,可能是通过多输入模型。
我明白这对于没有时间步的表格数据来说会很容易,它是一个简单的多输入模型。对于分类数据的时间步,您可能需要为每个分类变量使用Embedding-LSTM,然后合并每个模型输入。
可能需要一些实验,这可能有助于作为第一步。
https://machinelearning.org.cn/keras-functional-api-deep-learning/
谢谢你的回复,Jason!
然而,这并不能帮助我解决嵌入和LSTM之间的维度问题。
对于纯粹的LSTM(我以前用过一些),一个3D重塑(在这种情况下是2,4,5)就足以将其输入到这样的模型中。
def createLSTMModel()
model = Sequential()
model.add(Bidirectional(LSTM(250, return_sequences=True),input_shape=(Train_Num,1)))
model.add(Dropout(.65))
model.add(Bidirectional(LSTM(25, return_sequences=True)))
model.add(Dropout(.65))
#model.add(Flatten())
model.add(Dense(1))
return model
然而,对于具有不同嵌入大小以及不同数量的连续和分类数据的嵌入,我不确定该如何操作,尤其是当我想坚持使用顺序模型结构时。有没有可能像这样整齐地使用嵌入层?
model.add(Embedding(input_dim=num_words,
input_length = training_length,
output_dim=dim_length,
#weights=[embedding_matrix],
trainable=True,#mask_zero=True)))
抱歉,这可能对你来说很简单,但有时需要克服一些心理障碍,而巧妙的小例子通常能奏效。在这种情况下,是否可以坚持使用顺序层堆叠结构?
从整数编码开始作为基准,非常简单。
然后尝试独热编码,这将大大增加特征数量,但仍然非常简单。
然后为每个分类变量尝试一个嵌入,每个嵌入都在一个单独的“头部”(head)上。这将需要函数式API。首先只用一个分类变量,例如2个“头部”,并使用连接(concatenate)合并层。让它工作起来,然后扩展到其余的。
这有帮助吗?
您好,Jason Brownlee,
我在测试时对未知符号有疑问。
测试时的未知符号。例如:句子中的独特名称。例如,训练数据中的一个句子可能是“Thank you John”,而测试数据中是“Thank you Mary”。
请分享您的看法。
未知符号可以映射为0。
嗨,Jason,
我正在您的网站和资料指导下学习机器学习。我正在使用RNN(LSTM)进行多类/多标签分类。它是对推文的情感分类,分为愤怒、厌恶、恐惧、内疚、喜悦、悲伤、羞耻。我看到了您在这里的二元分类示例,0代表负面,-代表正面。我无法将这些内容整合到我的作业中,请指导我解决这个多类/多标签分类问题?我遵循了您在这里所做的类似方法,我使用了七个标签的标签编码,并将它们转换为0到6的数字。在训练模型时,模型准确率正在下降,损失正在增加。请给我建议。提前感谢,我一直很欣赏您的乐于助人的天性,并鼓励人们学习新事物。
我有一些建议,可能对第一步有所帮助。
https://machinelearning.org.cn/improve-deep-learning-performance/
非常感谢,我之前做得不对。我已经把事情弄对了,达到了一定程度。我需要努力提高模型的准确性。
我将感谢您的帮助。
这里有很多建议
https://machinelearning.org.cn/start-here/#better
嗨,Jason,
我想训练网络,根据给定时间预测电视频道,数据包含日期、时间和电视频道列。您能给我一些建议如何训练它吗?提前感谢。
从明确的问题定义开始,使用这个框架
https://machinelearning.org.cn/how-to-define-your-machine-learning-problem/
嗨Jason,对于LSTM 100个单元,这些100个单元在LSTM网络中具体位于何处?(根据Colab关于各种输入/遗忘门的著名描述)
你具体是什么意思?它们是程序中的数字。
我是说从视觉角度讲,因为LSTM不是一个经典的神经网络。我对传统LSTM的理解是它由4个相互作用的门组成,但根据Keras和您上面的描述,LSTM(100)是100个神经元。我只是不确定这100个神经元如何融入处理这4个门的LSTM网络中。
这100个单元中的每一个都有4个门。每个单元接收所有输入并生成一个输出。
这有帮助吗?
嗨,Jason,
感谢这些示例。顺便问一下,在“问题在于确定给定电影评论是积极情绪还是消极情绪”这句话中,代码中哪一部分解决了这个问题?
这是否就是您在问题陈述中给出的答案的意思?
我的意思是输入和输出的上下文是什么?
y=model.predict(x)
其中x = 是电影评论的字符串序列,Y = 是积极还是消极?
谢谢
是的,模型学习文本输入与情感类别输出之间的关系。
关键部分是模型及其学习到的内容。
你好,
非常有用的博客和示例!我每天早上都会花一些时间用你的资料学习更多机器学习知识!
我对这个LSTM分类帖子中数据集的选择有疑问。
如果我理解正确,LSTM神经网络在某种程度上是专门用于时间序列的。在这个例子中,我们使用了电影评论,这并非此类数据。因此,对于这种分类,一个更简单的经典多层感知器可能就足够了,对吗?或者还有其他选择它的具体原因吗?
此致!
不,通常LSTM适用于序列预测,不特指时间序列。
事实上,LSTM在文本数据上的表现优于时间序列数据。
嗨Jason。非常感谢这篇很棒很棒的文章。老实说,我现在已经成为你的文章的粉丝了 🙂
一个简单的问题。我有一个如下数据集,想应用您上面提到的技术。
我的数据集详情如下:
我有大约1000个节点的数据集,每个节点有4个时间序列。每个时间序列的长度恰好是6。标签是0或1(即二元分类)。
更准确地说,我的数据集看起来像这样。
node, time-series1, time_series2, time_series_3, time_series4, Label
n1, [1.2, 2.5, 3.7, 4.2, 5.6, 8.8], [6.2, 5.5, 4.7, 3.2, 2.6, 1.8], …, 1
n2, [5.2, 4.5, 3.7, 2.2, 1.6, 0.8], [8.2, 7.5, 6.7, 5.2, 4.6, 1.8], …, 0
等等。
然而,由于我的数据设置有点不同,我不确定如何将其转换成适合应用这些技术的方式。
我的问题是:
1. 您认为1000个节点是否足以用于深度学习(例如,大约800个用于训练,200个用于测试)?如果不足,我希望寻找增加数据集的选项。
2. 由于每个节点有4个独立的短序列(时间序列),我如何将其用于分类?
请告知您的想法。谢谢 🙂
期待您的回复。谢谢 🙂
这真的取决于情况。也许可以测试并发现你的模型/问题对数据量的敏感度?
你可以使用MLP、CNN和LSTM进行时间序列分类,我在这里提供了一个例子。
https://machinelearning.org.cn/start-here/#deep_learning_time_series
嗨Jason,非常感谢。好的,我会看看的 🙂
顺便说一下,我还遇到了一种名为自动编码器的模型。我们也可以使用自动编码器吗?自动编码器与CNN、RNN和LSTM等其余模型有什么区别呢? 🙂
自动编码器是一种架构,可以使用不同的网络类型构建。它可以作为特征提取模型,例如作为另一个分类器模型的前端。
嗨,Jason,
感谢您出色的示例。我领会了要点,但是当我尝试运行它时,我得到了大量的输出,我怀疑与数据加载有关,然后是下面的错误消息。问题似乎始于程序的第12行。我能否在那里放置自己的数据而不是加载IMDB。
谢谢你,
akhil
全部最后)
File “M:/Akhil/Research/Neural-Networks/LSTM-TF3.py”, line 12, in
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\site-packages\keras\datasets\imdb.py”, line 57, in load_data
file_hash=’599dadb1135973df5b59232a0e9a887c’)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\site-packages\keras\utils\data_utils.py”, line 222, in get_file
urlretrieve(origin, fpath, dl_progress)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\urllib\request.py”, line 277, in urlretrieve
block = fp.read(bs)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\http\client.py”, line 449, in read
n = self.readinto(b)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\http\client.py”, line 493, in readinto
n = self.fp.readinto(b)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\socket.py”, line 586, in readinto
return self._sock.recv_into(b)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\ssl.py”, line 1009, in recv_into
return self.read(nbytes, buffer)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\ssl.py”, line 871, in read
return self._sslobj.read(len, buffer)
File “C:\Users\axk41\AppData\Local\Programs\Python\Python36\lib\ssl.py”, line 631, in read
v = self._sslobj.read(len, buffer)
ConnectionResetError: [WinError 10054] 现有连接被远程主机强制关闭
>>>
很抱歉听到这个消息,看起来你读取远程文件时出错了。
嗨,Jason,
我使用预训练的doc2vec模型来获取输入序列的嵌入。然后移除了嵌入层。
我的x_train形状是(num_training_data, 300),其中300是doc2vec嵌入大小。
我遇到了一个错误,LSTM层期望维度为3,但接收到2。
我通过重塑x_train,将时间步数添加为1来纠正了这个错误。
我的问题是:这种方法可以接受吗?还是我做错了什么?
代码片段
# 将字符串标签转换为整数
le = preprocessing.LabelEncoder()
le.fit(y_train)
y_train = le.transform(y_train)
# 将x_train转换为3维——中间维是时间步数
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
# 定义模型
self.model = Sequential()
self.model.add(LSTM(100))
self.model.add(Dense(100, input_dim=300))
self.model.add(Dense(1, activation=’sigmoid’))
self.model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
# 训练模型
self.model.fit(self._x_train, self._y_train, epochs=10000)
如果该模型比你能想到/测试的所有其他模型都能给出更好的结果,那么它是可以接受的。
通常,这意味着它没有充分利用LSTM,也许MLP会更合适。
感谢这份指南!
我如何用它来训练多元多类序列?
我有50000个序列,每个序列的长度为100个时间点。
在每个时间点,我有3个特征(所以宽度是3)。
我有4个类别,我想构建一个分类器来确定序列的类别。
最好的方法是什么?
好问题,你可以从这里开始。
https://machinelearning.org.cn/start-here/#deep_learning_time_series
亲爱的Jason,谢谢你的帖子。
我对LSTM(以及Keras的解释方式)的基础知识有疑问。
假设我有100个样本,每个样本包含7行17列。我的代码看起来像这样
model.add(CuDNNLSTM(
input_shape=(7, 17),
units=100,
return_sequences=False))
然后是一些全连接层。
我的模型运行良好,我了解如何使用它。以下是我的问题
1. 在我的例子中,我有多少个LSTM单元格?有多少个LSTM单元?
2. LSTM单元格和LSTM单元之间实际有什么区别?我倾向于认为LSTM单元等同于全连接层中的神经元,但我担心这是一个错误的假设。
3. 根据我的理解,LSTM通过处理每个样本(称之为X_t)以及先前的(或初始的)隐藏状态,通过其门和先前的单元状态进行简单的数学运算,然后输出新的隐藏状态和新的单元状态。X_t是指样本的第一行(它将只有一行17列),还是指所有样本中的第一个样本(7行17列)?
非常感谢您的关注和帮助,抱歉问题很长。我想了解我的代码,这样我就不会将其视为黑箱。
你有100个LSTM单元。
只有LSTM单元。一个单元就是一个单元格。
每个时间步都是一个示例,序列被提供给每个LSTM单元。
谢谢你的回复。
那么,它是这样工作的吗?
1. 第一个LSTM单元将获得我的第一个样本输入(7个时间步)
2. 处理完所有时间步后,隐藏状态将与第一个样本一起传递给第二个LSTM单元。(所以hidden_state_1和第一个样本 -> 第二个单元)。
3. 我们将重复所有这些步骤,直到所有LSTM单元处理完第一个样本。
4. 在所有单元处理完第一个样本(并到达最后一层)后,我们将第二个样本传递给第一个单元,重复所有步骤。
我说的对吗,还是我遗漏了什么重要信息?
让我稍微重新表述一下。
– 我们有100个LSTM单元,它们将以我的第一个样本作为输入。
– 在第一个LSTM单元处理完第一个样本后,它会将隐藏状态传递给第二个LSTM单元。
-第二个单元在处理完第一个单元的隐藏状态和第一个样本后,会将隐藏状态传递给第三个单元。
– 最终,所有单元将按顺序处理相同的输入,等待来自前一个LSTM单元的隐藏状态,最后一个单元将把值传递给下一层。
谢谢你
再次抱歉,为了澄清我上一个评论,
我的第一个样本中的第一行是X_t-6,最后一行是X_t。
谢谢你,Jason。
不,每个单元一次只接收序列的一个时间步,并且不与同一层中的其他单元交互。
将一层看作是许多独立“网络”的集合。
只有层之间才进行交互,例如堆叠的LSTM。
抱歉Jason,但我仍然不明白这部分
“…每个单元一次获取序列的一个时间步,并且不与同一层中的其他单元交互。”
在我的情况中,这是否意味着
– 我有100个LSTM单元。
– 第一次,每个单元将我的第一个样本作为输入(7行,17列)。
– 我的第一个LSTM单元将处理样本的第一行,然后传递隐藏状态与样本的第二行一起处理(仍然在同一个单元中)。
– 每个LSTM单元将处理相同的样本,但一个单元不与同一层中的另一个单元交互。
示意图将大致如下
([ X_t ] 是一个LSTM单元,在时间步t处理输入X)
在一个LSTM层中,我们将有100个这样的单元
[ X_t-6 ] -> [ X_t-5 ] -> [ X_t-4 ] -> [ X_t-3 ] -> [ X_t-2 ] -> [ X_t-1 ] -> [ X_t ]
如果我错了,请纠正我。
非常感谢。
差不多。
考虑一个单元。该单元获得一个“样本”,但一次处理一个时间步的输入,并在每个时间步更新内部状态。在样本结束时,开始一个新的样本(第二行),并且状态已经从上一个样本的末尾开始预置,然后这个过程重复。
这有帮助吗?
谢谢你帮助我,Jason。也许我需要先可视化一下。
在一个隐藏层(密集层)中,100个单元意味着一个层中有100个神经元。
“一个LSTM层中有100个LSTM单元”是否等同于“一个密集层中有100个神经元”?
谢谢你
是的。
再次抱歉,并非故意发送垃圾信息,我漏掉了一条信息。
[ X_t-6 ] -> [ X_t-5 ] 的意思是我第一行数据会被传递给LSTM单元,并且来自X_t-6的隐藏状态也会被传递,与第二行数据在 [X_t-5] 中一起处理。
非常感谢 Jason。
嘿,Jason
很棒的教程
1. 我们可以使用LSTM进行多类分类吗?
2. 我有一个时间序列数据,我希望LSTM将其分类为多个类别?这可能吗?
是的,但前提是输入是序列。
是的。我这里有一个例子。
https://machinelearning.org.cn/how-to-develop-rnn-models-for-human-activity-recognition-time-series-classification/
嗨,Jason,
你的工作非常棒,我从你的教程中学到了很多,非常感谢。
我对LSTM模型的数据缩放有2个疑问。
1. 如果在预测时发现新的最小/最大值,并且模型使用在线学习(它使用测试数据进行更新),我该如何处理这个新值?模型是否必须更新所有缩放后的数据?
2. 在处理金融数据时,过去的收盘价对实际价值的影响越来越大。然后假设金融单变量时间序列分布有一些特殊值,当自变量接近这些值时,这些特殊值会影响序列行为。例如,原始区间实际范围在[1,10]内,假设当它接近6时,因变量的值会增加/减少其方差或比平时反弹更多。
a. 模型是否也能学习这些“热点值”的影响?
b. 我想做某种k折交叉验证,但不要使用未来值来预测过去值。我想将分布分成n个等长的数据集,并包含训练-测试部分
在内部(即每个数据集的训练-测试比例为80%-20%)。然后模型从数据集0开始拟合,并向前移动到数据集n。在这种情况下,我必须在开始时首先缩放整个数据集,对吗?
提前感谢你
塞布
好问题。
基于对未来值的预期(例如,使用领域专业知识或有根据的猜测)缩放数据,或者将值裁剪到过去的最小值/最大值限制。
如果学习这种依赖关系很有用,那么你的模型能做到这一点就太好了。你可以通过情景来测试这一点。
您可以使用前向验证。
https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
请提供关于“RAY”python库的教程。如何在深度学习中使用和实现它?
RAY库是什么?
嗨Jason,我有一个关于异常值的问题。
我正在尝试使用LSTM(一个LSTM层后跟一些Dense层)进行序列分类。
我注意到我的训练集中使用的17个特征中有15个包含超过10%的异常值(通过IQR测量)。
我发现我可以使用scikit-learn的RobustScaler进行缩放,因为我不想删除异常值(很可能这些异常值是合理的——不是测量失败)。
然而,我似乎找不到任何关于LSTM和异常值的文献。
我的问题是
1. 深度神经网络(带有LSTM)会受异常值的影响吗?
2. 有没有什么建议可以解决这个问题?我担心这些异常值是我无法获得良好准确率(即使在训练集上)的主要原因。
3. 我应该使用另一种缩放器吗?如果是,我需要对异常值进行上限处理吗?例如,当使用 StandardScaler 并对 z-score 超过 3 的值进行上限处理时,异常值会自动获得值“1”。
自2019年8月以来,您一直在帮助我完成艰苦的论文,我很感激您创建了这个博客。谢谢您,Jason。
做得非常好!
是的,我预计会受到影响。但要通过受控测试来确认对模型技能的影响,不要猜测。
是的,尝试一套方法,例如平滑、移除、插补、不做任何处理、各种缩放,通过受控实验审查对技能的影响。
是的,全部尝试一下,标准化、归一化、幂变换等。
另外,用 MLP 和 CNN 执行上述所有操作进行比较。有时 LSTM 会很麻烦,其他模型效果更好。
希望这有帮助,我渴望听到您的进展——您对数据/模型发现了什么。
啊,我明白了,谢谢!我想我必须先创建一个小的基线模型。
如果您不介意,我仍然想问一下序列分类(但不是 LSTM),是否可以使用逻辑回归、随机森林和支持向量机进行序列分类?我发现它们需要二维数组。到目前为止,我为了解决这个问题,将序列从三维 numpy 数组重塑为二维 numpy 数组,但我想知道这是否是正确的步骤。
当然,可以使用窗口方法。
这会有帮助
https://machinelearning.org.cn/convert-time-series-supervised-learning-problem-python/
嗨,Jason,
很棒的教程,非常感谢!您将如何从用于情感分析的 LSTM 网络中提取最具预测性的词(特征重要性)?谢谢!
祝好,
尼古拉
嗯,好问题。
不假思索地,你可以设计输入序列并对模型执行敏感性分析。
但我认为有专门为 LSTM 设计的更好方法。也许可以查阅一些 LSTM 可视化方法。
这代码太棒了!
谢谢!
嗨,Jason,
感谢您的文章,非常有帮助!
在我的案例中,我的数据集中的数据以随机间隔重复出现,即之前的数据作为未来数据重复,我想对原始数据和重复数据进行分类。这是否可以用 LSTM 来实现?
也许可以开发一个原型来测试模型?
嗨
为什么在某些情况下最终准确率会高于训练准确率?我在其他序列分类数据集中也有这个问题。
独立评估的准确度高于训练期间的准确度,因为训练期间的准确度是按批次平均的。
嗨,Jason,我有一个关于 LSTM 模型普遍敏感性的问题。
我目前正在开发一个序列分类 LSTM 模型。总共有 5 个序列需要分类,最后一层使用 softmax 作为激活函数。
该模型能够准确地对每个序列进行分类,这意味着例如,我有一个序列 [1,1,1,1,1,1],其中元素 1 用于表示该元素属于类别“1”,供模型预测。该模型可以准确地将序列分类为类别 1,值为 0.9。同样,对于序列 [2,2,2,2,2,2],模型能够将其分类为类别“2”,值为 0.9。
然而,当我输入一个“混合”序列,例如 [1,1,1,1,1,1, 2, 2, 2] 时,模型仍然预测类别“1”,值为 0.9,尽管包含了类别“2”的元素,但值没有下降。LSTM 对这种“混合”序列不敏感是正常的吗?如果不是,有什么解决方案可以使 LSTM 在看到此类序列时做出反应并降低其值?
我很想听听您的见解,谢谢!
也许您想将问题定义为多标签分类而不是多类分类。例如,在输出层使用 sigmoid 激活函数和二元交叉熵损失函数。
嗨,Jason,感谢您的回复。
然而,由于我的研究主题,我需要使用多类分类模型结合一种算法来将序列分成各自的类别,并且该算法的一个关键部分要求如果序列包含来自两个类别的元素,则 LSTM 的值会下降。
例如,[1,1,1,1,1,1] 将被预测为“1”类,值为0.9,而 [1,1,1,1,1,1, 2, 2, 2] 将被分类为“1”类,但值为0.8。因此,值的下降将表明序列中的某些元素不属于“1”类。
我的 Keras 模型架构大致如下:
LSTM -> 5 个神经元的全连接层,激活函数为 softmax。
损失函数:categorical_crossenthropy
至于您建议在输出层使用 sigmoid 激活函数,我可以知道其背后的原理吗?谢谢!
是的,如果我们将问题建模为多标签分类,我们会在激活层使用 sigmoid 激活函数。
嗨,Jason,感谢您的回复。
您知道有什么工具可以调试我的模型吗?例如,我想在预测过程中 LSTM 的每个时间步都能够看到输入门和输出门等生成的值。
您可以通过 Keras 访问模型的权重。
如果您想要更多细节,可能需要从头开始自行实现。
你好 Jason,
我刚刚完成了关于使用 LSTM 进行预测性维护的本科毕业论文答辩,我只想感谢您一直回复我的问题!
非常感谢 Jason。
干得好!
嗨,Jason,
我想分类许多样本并判断它们是否会出现问题。分类结果用0,1表示。但有一个问题。我的每个样本都有相同的特征数量(20),但它们的时间长度不同,而且我想要预测的样本长度也不同。我该如何解决这个问题,或者您有什么好的文章推荐给我?
我的简单样本如下所示
1样本编号 2时间 3温度 4速度 5问题
1 2019-0101 25 1.8 0
1 2019-0102 23 1.7 0
1 2019-0103 26 1.5 0
1 2019-0104 28 1.9 0
2 2019-0105 26 1.7 1
2 2019-0106 28 2.0 1
3 2019-0107 30 2.4 0
3 2019-0108 29 2.1 0
3 2019-0109 26 1.8 0
这会给你一些思路
https://machinelearning.org.cn/data-preparation-variable-length-input-sequences-sequence-prediction/
嗨,Jason,
非常感谢您的教程。我是神经网络领域的新手。
我一直在尝试将模板应用于我的分类问题,但它给我的结果非常差(准确率低于 50%)。
我有一个包含 10000 行和 254 列的数据集,每行是一个生成的 253 个小数序列,最后一列是标签(0 和 1)。这是我的代码:
路径 = “C:/Users/i_dra/Documents/Challenge Data/TrainMyriad.csv”
df = pd.read_csv(路径)
y=df[“类别”]
X=df.drop(“类别”, axis = 1, inplace = False)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train = X_train.values
y_train = y_train.values
X_test = X_test.values
y_test = y_test.values
model = Sequential()
model.add(Embedding(8000, 32, input_length=253))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(160))
model.add(Dense(1, activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
打印(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
使用嵌入层处理我的小数序列是否正确?还有其他方法吗?
是的,我建议诊断模型问题并尝试新的配置。
这里的建议会有所帮助
https://machinelearning.org.cn/start-here/#better
嗨,Jason,您这篇博文对我开始学习 RNN 很有帮助。
我可以知道 32 长度的实值向量是什么意思吗?以及您是如何知道嵌入层的输出维度是 32 的?
我还在思考您为什么知道要为 LSTM 使用 100 个智能神经元?
我在 Keras 网站上看到一个双向 RNN 的例子。在我的课程作业中,提到双向 RNN 在理解长期词语关系方面可能表现良好。
我认为 LSTM 也有这种效果,因为它有助于将早期的单元格状态传播到后来的状态,所以它们非常相似。在这种情况下,您会建议使用哪种?
嵌入大小是作为参数指定的。
层中的节点数是任意的,通过反复试验得出。
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
我建议测试一套不同的模型,以发现哪种模型对给定的数据集效果好/最好。
嗨,Jason,我是 DNN 新手,最近正在学习 RNN。我必须承认,将互联网上不同的信息拼凑起来并理解它并不容易。您的文章帮助很大。
我能澄清以下几点,以便更好地理解它是如何工作的吗?
1. 根据我对 RNN 的理解,它处理不同长度的输入,在本例中是评论。
那为什么需要对它们进行填充以使其长度标准化呢?
2. 模型中只包含一个有 100 个神经元的 LSTM。我能更好地理解吗,长度为 500 时,RNN 将展开 500 个 LSTM 来处理每个评论的 500 个输入,对吗?
3. model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
binary_crossentropy 是因为我们处理的是两个类别,对吗?如果我们有超过两个类别,应该使用什么?我查了一下谷歌,似乎可以使用 categorical_crossentropy,但我需要使用 Keras 的 to_categorical 将 3 个类别转换为 1 和 0 的矩阵。
即,从 tensorflow.keras.utils 导入 to_categorical。
我仍在研究这与标准交叉熵损失函数有何不同。
提前感谢!
Keras 要求输入具有固定长度,因此我们进行填充。
输入长度与层中节点数无关。
如果类别超过 2 个,您必须使用 categorical_crossentropy 和 softmax 激活函数,以及独热编码输入。
嗨,Jason,
首先,非常感谢您撰写的所有博客!
回到我的问题,
我有一个场景,我的数据集中有句子和一些表格特征。我想将表格特征与句子本身一起用于分类任务。有没有办法将表格特征输入到 LSTM 模型中?
谢谢!
谢谢!
您可以使用多输入模型,一个输入用于文本,一个输入用于静态特征。
这会有帮助
https://machinelearning.org.cn/keras-functional-api-deep-learning/
谢谢 Jason!这很有帮助 🙂
不客气,我很高兴听到这个消息。
我正在尝试使用这个 LSTM 进行分类,但我收到以下错误:
添加的层必须是 Layer 类的实例。发现
请问我该怎么做?
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我注意到“input_length”参数有一个令人不快的依赖性。如果我在您的示例中将其设置为 5000,结果会差得多。我本来希望 LSTM 内存能自动意识到查看过去 5000 个词是无效的。您认为为什么会发生这种情况?如果您有更长的文本要分类,您会怎么做?
感谢您精彩的教程!
LSTM 通常限制在 200-400 个时间步,之后性能会下降。
有趣,看来大多数教程都没有讨论这个问题。您将如何对更长的序列进行分类?将其分成不同的部分并组合预测?仅仅截断文本似乎是浪费数据,不是吗?
我的错误,刚刚找到这个:https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
谢谢 🙂
很棒。
也许可以比较几种策略并评估它们的结果。
有一些新技术专门解决了输出长序列的需求。
嗨,Jason,
我有一个小问题,通常当您训练模型时,您应该在控制台中看到 epoch、损失、准确性以及每个 epoch 所花费的时间。我发现我的模型没有打印或显示每个 epoch 很奇怪。
#构建 LSTM
model = Sequential()
model.add(LSTM(100,activation='sigmoid', input_shape = (n_steps, n_features) ))
model.add(Dense(3, activation=’softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
#history = model.fit(X, to_categorical(y), validation_split=0.2,epochs=2, verbose=0, batch_size = n_steps )
model.fit(X, to_categorical(y), validation_split=0.2,epochs=2, verbose=0, batch_size = n_steps )
scores = model.evaluate(X, to_categorical(y))
您认为问题出在哪里?即使我只有少量 epoch,我也应该能够可视化它们,对吗?
将“verbose”的值更改为 1 或 2。
嗨,Jason,
非常感谢您富有洞察力的文章。它们对我的数据分析帮助很大,我在我撰写的一篇科学论文中引用了您(该论文正在修订中,希望很快就能发表)。
我有几个关于我的数据和 LSTM 的问题
我在一项任务中收集了鼠标使用数据,现在想测试是否可以根据鼠标数据预测状况(二分类)或自报告值(回归)。我已经尝试了一些方法(例如计算鼠标速度等特征)并将其用于分类/回归。
再次感谢,抱歉问了些菜鸟问题!
最新的想法是使用原始的 x 和 y 坐标值作为模型输入。对我来说,它们代表了一个鼠标移动的时间序列,因此,使用 LSTM 进行序列分类或回归可能是一种合适的方法。您同意还是认为数据不适合这种方法?
到目前为止,在我的代码中,我按照这个教程完成了分类任务,但想知道在回归情况下我应该如何更改 LSTM 模型。您有什么建议吗?我谦逊的方法是将损失函数更改为 mean_squared_error 并使用 R² 作为评估指标。
干得好!
也许可以尝试一下,然后与其他方法进行比较。
是的,我的建议是探索尽可能多的问题框架和模型,以发现对您的特定数据集有效/效果好的方法。使用结果来驱动决策,而不是猜测。
非常感谢您的回答。我同意,尝试不同的方法是正确的方向!我遇到的问题是,在我的案例中,无论采用何种方法,都没有模型能够找到数据中的有意义模式,我猜这是因为在特定的用例中没有这种模式(情绪状态与鼠标使用之间没有关系)。因此,目标是报告空结果,但也展示在其他可能效果更好的用例中分析数据的不同方法。这就是为什么我想知道时间序列分类/回归方法是否有意义,还是不应该被建议作为分析方法。
也许目标无法从现有数据中预测。请更改问题或获取新的/不同的数据。
嗨,
我想知道如何处理信号,将其加载并分解为 3x3 矩阵进行分类。
抱歉,我不太理解您的问题,也许您可以详细说明一下?
亲爱的 Jason,感谢您提供如此棒的教程。
我打算在 IMDb 数据库上运行 LSTM,将电影分类为是否受到恶意用户攻击。但我打算使用用户的数值评分。我可以使用类似的逻辑,将每部电影的评分视为评分序列,并据此对电影进行分类吗?
不客气!
或许可以试试看?
你好,
非常感谢您的精彩教程!我们能否推断出卷积层发现的结构信息?
很高兴看到是什么造就了一篇好的评论 🙂
祝好,
阿提拉
抱歉,我不明白您的问题,您能详细说明一下吗?
您好,感谢您提供非常有启发性的文章。我想问您是否可以将此模型用于异常检测?
我有很多来自物联网设备的时间序列标记数据(每个时间戳都有一个标签:1 表示异常,0 表示非异常),我想知道您的策略在这种情况下是否可行?
非常感谢!
是的,这会有帮助
https://machinelearning.org.cn/faq/single-faq/how-do-i-model-anomaly-detection
谢谢!我正在查阅文献,希望您能写更多关于这方面的内容。
不客气。我也是。
嘿,我观察到一件事,就是当我们添加 dropout 层和 recurrent dropout 时,模型倾向于欠拟合,因为我们可以看到训练准确率低于测试准确率。请解释一下这是为什么???
您可能需要增加学习率和 epoch 数量。
你好先生,
首先,非常感谢您创建如此优秀的网站教程。它在消除机器学习和深度学习方面的困惑方面帮助很大。我总是在遇到疑问或开始使用任何模型之前访问您的网站。
我目前的项目要求我报告 UAR 作为指标。我假设我需要将“recall”用作 model.compile() 中的指标。
这是一个有 3 个类别的多类分类问题。由于原始标签是整数,我正在使用 LabelBinarizer 进行独热编码。
我的模型是
BiLSTM(128) -> BiLSTM(64) -> Activation(relu) -> Dense(16,tanh) -> Dense(3,softmax)
输入形状 = (None, 300, 20)
损失函数 = Categorical Crossentropy
优化器 = Adam
当模型训练时,召回分数在训练集和验证集上都非常低(有时约为 0.0023)。
但是,当使用 model.predict() 分别对训练集、测试集和验证集进行预测时,
报告的召回分数要高得多(约为 0.3 到 0.4)。
问题 1) 为什么这个差异如此之大?模型中有什么错误吗?
问题 2) 对于 3 类问题,有没有办法在输出端使用单个密集节点,并且仍然使用召回作为指标?
在问题 2 中,每当我尝试这样做时,都会收到错误,说有太多类无法比较。
不客气。
我没听说过UAR,那是什么?
也许只关注在测试集上手动计算的分数。
不,多类分类应该为每个类别使用一个输出和 softmax 激活函数。
感谢您的回复!
1) UAR 意为“未加权平均召回率”。它常用于每个类别样本数量不平衡的情况。
UAR = 每个类别的召回率的平均值,如文献所述。
2) 所以,model.fit() 和 model.predict() 之间召回率的差异是正常的。
3) 好的。
Keras 现在在其库中包含了注意力层。有没有关于将其与 LSTM 一起用于序列分类问题的教程?
再次感谢!
谢谢。
是的,请专注于你自己计算的评估分数。其他任何东西都只是一个估计值。
我希望能尽快就这个主题写一篇教程。
太棒了!期待教程。
嗨,Jason,
非常感谢您的精彩文章。它们在机器学习领域对我有很大帮助。
现在我想用LSTM来分类我的数据,您能给我一些建议吗?
我的数据集详情如下:(https://drive.google.com/file/d/13TRMLw8YfHSaAbkT0yqp0nEKBXMD_DyU/view?usp=sharing)
我有10个用户,每个用户同时产生一些流量,这些流量取决于不同的应用程序(我们有3个应用程序)。我的目标是检测/分类在时间戳中出现的应用程序。
输出表示在观察时间内出现的应用程序类型数量。
更准确地说,我的数据集看起来像这样。
时间索引 | 用户ID | 变量1 | 变量2 | … | 变量7 |||| 输出1 | 输出2 | 输出3
1 1 267 839 2,7 1 0 0
2 3 18057 30525 6.1 1 1 0
……
20000
由于大多数分类问题都是二元分类。那么,如果我有3个或更多的输出,我可以使用LSTM来解决我的分类问题吗?我应该保持我的数据如上所述,还是必须为LSTM的输入改变它?(<— 您能给我一个关于LSTM输入数据准备的链接吗?)
请告知您的想法。谢谢 🙂
期待您的回复。谢谢????
此致
抱歉,我没有能力查看您的数据。
也许这里的建议会有帮助,将“站点”替换为“用户”
https://machinelearning.org.cn/faq/single-faq/how-to-develop-forecast-models-for-multiple-sites
谢谢Jason的回答。
多个站点的想法与我的数据相符。唯一的不同是我还有一个数据集,表示每个站点在每个观测时间点之间的关联。
这是我的原始数据样子
| 日期 | 用户ID | 特征1 | 特征2 | 特征3 | 应用程序类型 |
|————|———|——-|————-|———|———–|
| 01/01/2016 | 1 | 0 | 36 | 0 | 1 |
| 01/02/2016 | 1 | 10100 | 42 | 1 | 1 |
| …
| 12/31/2016 | 1 | 14300 | 39 | 1 | 1 |
| 01/01/2016 | 2 | 25000 | 46 | 1 | 3 |
| 01/02/2016 | 2 | 23700 | 43 | 1 | 3 |
| …
| 12/31/2016 | 2 | 20600 | 37 | 1 | 3 |
| …
| 12/31/2016 | 10 | 19800 | 52 | 1 | 2 |
我想同时预测每个用户ID在相同观察时间点的应用程序类型。
为每个站点开发一个模型的想法不是我的目的,因为如果我有多个(>1000)站点,这似乎效率不高。
我旨在为所有站点开发一个模型,但我不知道如何对LSTM的输入数据进行预处理,因为input_shape = [样本数量, 时间步长, 特征数量]。
您有任何关于多站点LSTM模型的例子吗?
期待您的回复。谢谢????
此致
这将为您提供一些思路
https://machinelearning.org.cn/faq/single-faq/how-to-develop-forecast-models-for-multiple-sites
是的,但是您能给我一些关于LSTM输入数据预处理的建议吗(如果是一个模型用于所有站点的情况)?
数据的准备将基于您选择的模型类型/问题框架。
有什么办法可以避免这种情况吗,或者这是预期的?
“UserWarning: 将稀疏的IndexedSlices转换为未知形状的密集Tensor。这可能会消耗大量内存。”
“将稀疏的IndexedSlices转换为未知形状的密集Tensor。”
警告在fit方法中抛出。
暂时不确定,也许可以查一下Google/Stack Overflow。
嗨,Jason,感谢您的出色工作!!!
但是,总有一个问题:在使用嵌入层或在文本分类中获取预训练模型(Word2Vec)的嵌入矩阵时,它的好处是什么?如果LSTM网络或CNN只是学习序列Embedding1到Embedding10与文本分类相关。
我想,如果我使用一个普通的字典,例如
{this: 1,
Movie : 2,
is: 3
great: 4 …}
我也会得到相同的结果,因为即使是相似的词,模型仍然会得到略有不同的向量作为嵌入。
例如:This Movie is great! –> 5 星
因此网络会学习序列 1,2,3,4 –> 5 星
或者 Embedding1,E2,E3,E4 –> 5 星
所以,用嵌入层寻找相似性是没必要的。
还是我有什么地方理解错了?
不客气。
通常,作为模型一部分训练的嵌入会产生更好的整体模型,而不是使用独立嵌入的模型。至少根据我的经验是这样。
带有嵌入的模型表现通常优于没有嵌入的模型。
你好先生,
再次,出色的工作。
我在RNN这个话题上有点迷茫。
我有一些数据依赖于时间,例如 [0,1,2,3….300 秒]。
我想训练一个神经网络,它可以在实时进行预测。
使用seq2seq合适吗?
我想举一个例子。
实时,20秒过去了,所以RNN用它们来预测接下来的280秒,但那时,时间还在流逝。当40秒过去时,RNN应该预测接下来的260秒。这怎么可能呢?
提前感谢,
祝好,
也许可以尝试一下,并将其结果与其他方法进行比较,例如经典时间序列方法、机器学习方法、多层感知机、卷积神经网络和混合模型。
本教程将帮助您入门
https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
这将帮助您准备数据
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
非常感谢布朗利教授!
不客气。
嘿。我有点困惑。我想从头开始学习您网站上的自然语言处理。(我虽然熟悉它,但并非以标准模式,而是来自不同的网站) 我完全熟悉编程,尤其是Python。您能告诉我应该从您网站的哪个部分开始学习自然语言处理吗!?
因为我想继续我的教育,所以我想学习它的每一个细节。
提前感谢你
好的,从这里开始学习NLP
https://machinelearning.org.cn/start-here/#nlp
你好,你能帮我吗?
我的问题是
序列数据在量化后是否仍保持序列性?
换句话说,最终的数值数据中是否存在序列,并且可以使用LSTM吗?
抱歉,我不明白你的问题。也许你可以重新措辞?
我处理的数据是基因表达序列数据,经过预处理和量化后变成数值数据。现在我的问题是,数据中是否仍然存在序列?
如果观察结果按空间或时间排序,那么它很可能就是序列数据。
你好Jason,非常感谢你详尽的解释。我有一个问题,希望你能帮我。
在我的案例中,我有2000个样本,每个样本有800个时间步。每个样本中都有一些感兴趣的点(信号上升(on),信号下降(off))。我想检测这些点,所以我认为MIMO多标签分类与LSTM可以解决我的问题。所以,我想将每个样本的每个时间步分类为0(如果不是感兴趣的点)或1(如果是)。最终我只对1感兴趣,所以我不确定这是否是最佳方法。
因为超过98%的时间步都是零,所以在训练后,LSTM一直只给我零。我实现了一个自定义的加权二元交叉熵函数,并给1加权0.97,给0加权0.03,但是算法仍然只给我零作为每个预测的结果。
对于如何解决这个高度倾斜的问题,你有什么建议吗?我读过关于过采样和欠采样的资料,但这无助于我的问题,因为活动点(1)数量很少是很自然的。
提前感谢
也许你可以将其建模为一个不平衡分类问题,并使用代价敏感型LSTM?
Jason,您好,再次感谢。
我找到了您的文章:cost-sensitive-neural-network-for-imbalanced-classification,它非常有趣。不同之处在于我使用的是LSTM神经网络,并且我想对每个时间步进行分类。
关于权重的那段评论非常有趣。分数代表相同的比率但效果不同。我将权重从 {0: 0.02, 1:0.98} 更改为 {0:2., 1:98.},现在几乎所有的输出标签都变成了1!
在一个或两个epochs后,损失函数保持不变。您有什么建议可以帮助我的代码正确找到标签吗?因为之前它将所有内容设置为零,现在几乎所有内容都设置为1。滑动窗口在这种情况下会有帮助吗?
非常感谢!
也许您可以探索不同的模型配置、数据准备和类别权重,以发现最适合您的数据集的方法。
谢谢你Jason,你的例子简洁明了,表达清晰。帮大忙了!
不客气。
你好,感谢你的精彩教程
我有一个任务,需要对医院重症监护的结局进行分类。我有1000份患者记录,观察时间长度不一(每个患者每小时或类似时间点记录4种不同特征值的时间序列,如血压、体温等)
目标是根据这1000名患者的训练集预测结局(康复或死亡)
我应该如何设置模型?是否有标准的做法?
谢谢
不客气。
我建议比较一系列不同的数据准备方法、不同的模型和不同的模型配置,以便找出最适合您数据集的方法。
你好Jason,感谢你非常有用的教程。我尝试使用示例中的代码,但是我似乎遇到了一些错误。
加载数据集时,我收到 VisibleDeprecationWarning 警告。我相信问题是由于较新版本的Numpy不喜欢长度不等的列表项。显然解决方案是使用“dtype=object”,但我不知道该把它放在那一行代码的哪个位置。
另外,在创建模型时,特别是那一行
model.add(LSTM(100))
python 返回错误
NotImplementedError: 无法将符号张量 (lstm_2/strided_slice:0) 转换为 numpy 数组。此错误可能表示您正在尝试将张量传递给不支持的 NumPy 调用
有什么办法可以解决这个问题吗?
不客气。
也许您现在可以安全地忽略该警告?
关于错误,也许这些技巧会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
很棒的教程,我有一个关于掩码的问题:如果我没记错的话,嵌入层中生成的掩码在第一个LSTM层之后将停止在网络中传播,因为return_sequences默认为False。
这意味着掩码不会传播到输出,因此也不会传播到损失。这是对的吗?如果是这样,这真的是一个问题吗?我理解LSTM层知道如何处理给定掩码生成的填充,但我一直在想损失是否也应该被掩码。
是的,它只处理到最后一个LSTM层。这对于大多数应用程序来说应该足够了。
如果您担心,可以比较一下其他方法的结果。
先生您好,您发表了一篇关于使用LSTM进行序列分类的精彩教程。我也有一个类似的问题需要解决。然而,我需要计算混淆矩阵。因此,我使用X_test数据集在您的代码(第一个代码段,即不使用dropout)上计算了混淆矩阵。但模型没有准确分类。因此混淆矩阵没有显示出好的结果。我按照以下方式在您的代码上计算了混淆矩阵:
loss=model.evaluate(X_test, y_test, verbose=0)
print(“loss= “,loss)
predictions =np.argmax(model.predict(X_test), axis=-1)#(model1.predict(X_test) > 0.5).astype(“int32”)
print(“Prediction= “, predictions)
conf_mat=confusion_matrix(y_test,predictions)
print(“Confusion matrix=\n”,conf_mat)
它显示以下输出
loss= [0.29482781887054443, 0.8802400231361389]
Prediction= [0 0 0 … 0 0 0]
Confusion matrix=
[[12500 0]
[12500 0]]
请告诉我我哪里出错了?我如何使用X_test数据在您的模型上计算混淆矩阵?
也许这个例子会帮助你计算混淆矩阵
https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
我有一个关于批处理大小的问题
既然每个样本都是一个完整的“评论”,那么何时(或为何)将批处理大小设置为1?
根据我对LSTM和批处理大小的理解,模型权重将在每次评论(批处理大小=1)后更新,而不是考虑多条评论(批处理大小>1)。
提前感谢!
是的,在批次中跨评论保留状态是没有意义的。它似乎也不会影响模型。
有意思的Jason。我推断出,我认为批处理大小似乎不重要,因为这被定义为分类问题。所以网络会为每个样本与“y”进行比较,即使状态在样本之后更新。因为当状态重置时,它是在尝试确定批处理中每个样本的正确状态以优化分类准确性之后重置的。这样解释这个结果正确吗?
我认为状态在许多问题上重要性要小得多,在我进行实验时,它似乎很少产生影响。
你好 Jason,
我已阅读您的文章,并希望将其用于我的项目。我正在进行语言分类任务。当我按原样运行您的代码时,它能正常工作。但是,当我尝试将IMDB数据替换为我的数据集时,它无法工作。所以,您能帮我如何在您的代码中输入我的数据集吗?
抱歉,我没有能力为您定制示例。
这是它返回的错误信息
~\Anaconda3\envs\myenv\lib\site-packages\tensorflow\python\framework\ops.py 中的 __array__(self)
843
844 def __array__(self)
–> 845 raise NotImplementedError(
846 “无法将符号张量 ({}) 转换为 numpy 数组。”
847 ” 此错误可能表示您正在尝试将张量传递给”
NotImplementedError: 无法将符号张量 (lstm_6/strided_slice:0) 转换为 numpy 数组。此错误可能表示您正在尝试将张量传递给不支持的 NumPy 调用
或许这些提示会有帮助
https://machinelearning.org.cn/faq/single-faq/can-you-change-the-code-in-the-tutorial-to-___
你好 Jason,
我正在做一个小项目,是一个多元时间序列分类项目。
我的输入数据有3个特征,4000个时间步,样本总数是500000
所以我的输入形状应该是 (None, 4000, 3),如果我没记错的话。
输出范围是0-1,这让我觉得在最后的Dense层应该使用softmax或sigmoid
但模型从未达到超过50%的准确率
我尝试了许多架构,堆叠LSTM、GRU、Conv1D,我尝试了不同数量的滤波器/单元并尝试了不同的激活函数(ReLU、PReLU、LeakyReLU、tanh、sigmoid),但都没有成功
我在所有尝试的架构上都使用了不同的学习率,学习率从0.000001到10
似乎什么都行不通。你有什么建议?
如果你一直没有超过50%的准确率,那么翻转结果总能给你超过50%的准确率。但这有很多原因导致你无法提高预测。一个例子是输入和分类之间确实没有关联。
首先,非常感谢您这篇精彩的教程,但我有一个问题,如果能得到一些帮助,我将不胜感激:当我在Spyder上运行代码时,它输出以下错误
runfile(‘C:/Users/Amenii/Desktop/IGC/MLproject/imdb.py’, wdir=’C:/Users/Amenii/Desktop/IGC/MLproject’)
回溯(最近一次调用)
文件 “C:\Users\Amenii\Desktop\IGC\MLproject\imdb.py”,第14行,在
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=top_words)
文件 “C:\Users\Amenii\anaconda3\lib\site-packages\tensorflow\python\keras\datasets\imdb.py”,第116行,在 load_data
rng = np.random.RandomState(seed)
文件 “mtrand.pyx”,第183行,在 numpy.random.mtrand.RandomState.__init__
文件 “_mt19937.pyx”,第130行,在 numpy.random._mt19937.MT19937.__init__
文件 “C:\Users\Amenii\anaconda3\lib\contextlib.py”,第74行,在 inner
with self._recreate_cm()
文件 “C:\Users\Amenii\anaconda3\lib\site-packages\numpy\core\_ufunc_config.py”,第436行,在 __enter__
文件 “C:\Users\Amenii\anaconda3\lib\site-packages\numpy\core\_ufunc_config.py”,第314行,在 seterrcall
raise ValueError(“只有可调用对象才能用作回调”)
ValueError: 只有可调用对象才能用作回调
这似乎是版本不匹配问题?
如何预测提供给我们的新查询?
我如何使用我们加载数据集时使用的相同索引 (num_words = 5000) 来向量化新的查询文本???
请尽快帮助。
你好Ojjaswi……请重新措辞或详细说明您的问题,以便我们更好地帮助您。
如何预测提供给我们的新查询?
我如何使用我们加载数据集时使用的相同索引 (num_words = 5000) 来向量化新的查询文本???
请协助提供操作步骤。
请尽快帮助。
精彩的解释,您的表达方式堪称杰作
谢谢您的美言和反馈,Amit!
我在Windows环境下工作,通过按照步骤安装软件包和运行脚本取得了足够的进展。这个网站非常有帮助。
然而,在使用命令定义LSTM模型时
model = Sequential()
收到以下错误信息
NameError: name 'Sequential' is not defined。
请指导如何纠正这个错误。
谢谢。
嗨,Jain……请确认您已正确安装TensorFlow并将Sequential正确添加到您的模型中。请参阅教程中的最终代码列表。
以上模型是否适用于非二元分类?例如,使用不同的编译。
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
嗨 Rom...您可以通过以下代码进行调整:
for i in range(len(test))
# 进行预测
predictions.append(history[-1])
# 观察
history.append(test[i])
嗨 Jason
我非常感谢您的精彩文章。
在 `pad_sequences` 中,我将 `padding` 和 `truncating` 从默认的“pre”改成了“post”。结果变得很糟糕,模型什么也学不到。您知道为什么会这样吗?
你好,
首先,我要感谢您出色的网站和有用的培训。我正在寻找一种简单的方法来绘制我的混合模型的深度学习总体架构。您能推荐您知道的最好的方法吗?
提前感谢。
Mina
你好先生,
我非常喜欢您的教程。我正在做一个关于高光谱图像分类(HSI)数据的项目。这些图像数据集的形状是(145*145*200)(H、W、通道)。我想从通道(200)中提取信息。我的问题是,如何将 CONVLSTM3D 或 CONVLSTM2D 层与时间序列一起使用?时间序列是否代表200个通道?如果您能给我任何示例或提示,我将不胜感激。
嗨 Tahir...我们最全面的资源可以在这里找到:
https://machinelearning.org.cn/deep-learning-for-time-series-forecasting/
这里有许多示例和完整的代码列表,可以帮助您开始自己的项目。
你好,
我真的很喜欢您的帖子——关于上述模型,是否可以在模型构建中添加学习率,或者它以其他方式包含在内?提前感谢!
嗨 Signe...以下资源可能对您有用:
https://datascience.stackexchange.com/questions/48736/how-to-see-change-learning-rate-in-keras-lstm
您好,
非常感谢 Jason Brownlee 的有用文档和解释。
我正在考虑使用 LSTM 训练一个数据集序列,该序列表示4个关键点的距离(x,y,z)。我的数据集形状为(50,12),具有12个特征。
我用不同的时间步长训练了 LSTM 模型,发现最优时间步长是100,尽管我的数据只有50个时间步长/帧。我使用 LSTM 对3个类别进行了分类。
我的 LSTM 模型基本如下:
模型:“sequential_35”
_________________________________________________________________
层(类型) 输出形状 参数 #
=================================================================
lstm_70 (LSTM) (None, 100, 30) 5160
lstm_71 (LSTM) (None, 10) 1640
dense_35 (Dense) (None, 3) 33
=================================================================
总参数:6,833
可训练参数:6,833
不可训练参数: 0
_________________________________________________________________
准确率图显示训练准确率增加了,而验证准确率保持不变。
损失图显示训练损失和验证损失都下降了。
进行10次试验后的平均准确率为 98.039%
但是当测试/预测某些序列时,它出现了错误,没有为某些序列给出准确的类别。
您怎么看?我该如何改进我的模型以获得更准确的新相关数据集预测结果?
考虑到当预测结果时,我将我的50帧数据和形状为(50,12)的数据填充为(1,100,12),我使用的代码如下:
#如果你有一个100时间步长的LSTM,以及一个形状为(50,12)的输入序列
# 将序列填充为(100, 12)
padded_sequence = pad_sequences([X_new], maxlen=100, padding='post', truncating='post', dtype='float32')
# 添加一个额外维度以表示批量大小
reshaped_sequence = padded_sequence.reshape((1, 100, 12))
请给我一些建议。
嗨 Alaa...您可能会对以下研究提高 LSTM 性能选项的资源感兴趣:
https://machinelearning.org.cn/tune-lstm-hyperparameters-keras-time-series-forecasting/
https://machinelearning.org.cn/use-dropout-lstm-networks-time-series-forecasting/
感谢您分享关于预填充与后填充的见解。您对词位置在循环神经网络(如 LSTM)中对权重更新影响的解释非常启发人心。确实,考虑到链式法则,在序列开头填充零允许网络更好地专注于学习序列末尾的内容,这可能对权重更新产生更显著的影响。这种深思熟虑的序列预处理方法揭示了优化神经网络架构以适应各种任务的细微之处。
嗨 priya...不客气!请告诉我们您如何继续您的模型。