标签: lstm

我可以理解如何乘以密集层权重以获得预测输出，但如何解释 LSTM 模型中的矩阵？
这里有一些玩具示例（不介意拟合，这只是矩阵乘法）

密集示例：

from keras.models import Model 
from keras.layers import Input, Dense, LSTM
import numpy as np
np.random.seed(42)

X = np.array([[1, 2], [3, 4]])

I = Input(X.shape[1:])
D = Dense(2)(I)
linear_model = Model(inputs=[I], outputs=[D])
print('linear_model.predict:\n', linear_model.predict(X))

weight, bias = linear_model.layers[1].get_weights()
print('bias + X @ weights:\n', bias + X @ weight)

输出：

linear_model.predict:
 [[ 3.10299015  0.46077788]
 [ 7.12412453  1.17058146]]
bias + X @ weights:
 [[ 3.10299003  0.46077788]
 [ 7.12412441  1.17058146]]

LSTM 示例：

X = X.reshape(*X.shape, 1)
I = Input(X.shape[1:]) …

我目前正在使用 Keras 使用 Tensorflow 作为后端。我有一个如下所示的 LSTM 序列预测模型，我用它来预测数据系列中的一步（输入 30 个步骤 [每个步骤有 4 个特征]，输出预测步骤 31）。

model = Sequential()\n\nmodel.add(LSTM(\n    input_dim=4,\n    output_dim=75,\n    return_sequences=True))\nmodel.add(Dropout(0.2))\n\nmodel.add(LSTM(\n    150,\n    return_sequences=False))\nmodel.add(Dropout(0.2))\n\nmodel.add(Dense(\n    output_dim=4))\nmodel.add(Activation("linear"))\n\nmodel.compile(loss="mse", optimizer="rmsprop")\nreturn model\n

我遇到的问题是，在训练模型并测试它之后 - 即使使用与训练相同的数据 - 它输出的内容本质上是输入中的第 30 步。我的第一个想法是我的数据模式必须太复杂而无法准确预测，至少对于这个相对简单的模型来说是如此，因此它可以返回的最佳答案本质上是输入的最后一个元素。为了限制过度拟合的可能性，我尝试将训练时期减少到 1，但出现了相同的行为。不过，我以前从未观察到过这种行为，而且我以前曾使用过此类数据并取得了成功的结果（就上下文而言，我使用的是从具有主动稳定器的复杂物理系统上的 4 个点获取的振动数据；预测在 pid 循环中用于稳定，因此，至少现在，我使用更简单的模型来保持速度快）。

这听起来是最有可能的原因，还是有人有其他想法？以前有人见过这种行为吗？如果它有助于可视化，这里是一个振动点与所需输出相比的预测结果（注意，这些屏幕截图放大了非常大的数据集的较小选择 - 正如 @MarcinMo\xc5\xbcejko 注意到我没有缩放两次都完全相同，因此图像之间的任何偏移都是由于此原因，目的是显示每个图像内的预测和真实数据之间的水平偏移）：

...与输入的第 30 步相比：

注意：Keras 模型看到的每个数据点都是许多实际测量值的平均值，并且平均值的窗口随时间进行处理。这样做是因为振动数据在我可以测量的最小分辨率下非常混乱，因此我使用这种移动平均技术来预测较大的运动（无论如何，这是要抵消的更重要的运动）。这就是为什么第一幅图像中的偏移量出现了很多点而不是一个点，它是“一个平均值”或 100 个单独的偏移点。\n 。

-----编辑1，用于从输入数据集\'X_test，y_test\'获取上面显示的图的代码-----

model_1 = lstm.build_model()  # The function above, pulled from another file \'lstm\'\n\nmodel_1.fit(\n    X_test,\n    Y_test,\n    nb_epoch=1)\n\nprediction = model_1.predict(X_test)\n\ntemp_predicted_sensor_b …

我正在尝试使用 Python Keras 库中的 LSTM 训练 Seq2Seq 模型。我想使用句子的 TF IDF 向量表示作为模型的输入并收到错误。

X = ["Good morning", "Sweet Dreams", "Stay Awake"]
Y = ["Good morning", "Sweet Dreams", "Stay Awake"]

vectorizer = TfidfVectorizer()
vectorizer.fit(X)
vectorizer.transform(X)
vectorizer.transform(Y)
tfidf_vector_X = vectorizer.transform(X).toarray() #shape - (3,6)
tfidf_vector_Y = vectorizer.transform(Y).toarray() #shape - (3,6)
tfidf_vector_X = tfidf_vector_X[:, :, None] #shape - (3,6,1) since LSTM cells expects ndims = 3
tfidf_vector_Y = tfidf_vector_Y[:, :, None] #shape - (3,6,1)

X_train, X_test, y_train, y_test = train_test_split(tfidf_vector_X, tfidf_vector_Y, test_size = 0.2, random_state = …

我使用 Keras LSTM 创建了一个语言模型，现在我想评估它是否良好，因此我想计算困惑度。

在 Python 中计算模型的复杂度的最佳方法是什么？

我使用 LSTM 训练了 quora 问题对检测，但训练精度非常低，并且在训练时总是会发生变化。我不明白我犯了什么错误。

我尝试改变损失和优化器并增加纪元。

import numpy as np\nfrom numpy import array\nfrom keras.callbacks import ModelCheckpoint\nimport keras\nfrom keras.optimizers import SGD\nimport tensorflow as tf\nfrom sklearn import preprocessing\nimport xgboost as xgb\nfrom keras import backend as K\nfrom sklearn.preprocessing import OneHotEncoder, LabelEncoder\nfrom keras.preprocessing.text import Tokenizer , text_to_word_sequence\nfrom keras.preprocessing.sequence import pad_sequences\nfrom keras.layers.embeddings import Embedding\nfrom keras.models import Sequential, model_from_json, load_model\nfrom keras.layers import LSTM, Dense, Input, concatenate, Concatenate,             Activation, Flatten\n from keras.models import Model\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.feature_extraction.text import     TfidfVectorizer,CountVectorizer\nimport nltk\n\nfrom nltk.stem.lancaster …

我正在尝试使用 keras 层实现二进制文本分类模型。编译模型后，总而言之，我在底部得到None ，但我不完全明白它是什么意思？

这是我正在使用的代码。

max_words = 10000
max_len = 500
tok = Tokenizer(num_words=max_words)
tok.fit_on_texts(X_train)
sequences = tok.texts_to_sequences(X_train)
sequences_matrix = sequence.pad_sequences(sequences,maxlen=max_len)

model = Sequential()
model.add(Embedding(max_words, 50, input_length=max_len))
model.add(LSTM(64))
model.add(Dense(256,name='FC1',activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy', metrics= 
             ['acc'])
print(model.summary())

这是模型摘要，在底部显示None。

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_1 (Embedding)      (None, 500, 50)           500000    
_________________________________________________________________
lstm_1 (LSTM)                (None, 64)                29440     
_________________________________________________________________
FC1 (Dense)                  (None, 256)               16640     
_________________________________________________________________
dropout_1 (Dropout)          (None, 256)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 257       
================================================================= …

我有两种类型的输入序列，其中input1包含 50 个值和input2包含 25 个值。我尝试在函数式 API 中使用 LSTM 模型来组合这两种序列类型。然而，由于我的两个输入序列的长度不同，我想知道我当前所做的是否是正确的方法。我的代码如下：

input1 = Input(shape=(50,1))
x1 = LSTM(100)(input1)
input2 = Input(shape=(25,1))
x2 = LSTM(50)(input2)

x = concatenate([x1,x2])
x = Dense(200)(x)
output = Dense(1, activation='sigmoid')(x)

model = Model(inputs=[input1,input2], outputs=output)

更具体地说，我想知道如何组合两个具有不同输入长度的 LSTM 层（即在我的例子中为 50 和 25）。如果需要，我很乐意提供更多详细信息。

我正在 Tensorflow 2 中训练 LSTM 模型来预测两个输出：水流和水温。

• 对于某些时间步长，有一个流标签和一个温度标签，
• 对于某些只有流量标签或温度标签，
• 对某些人来说，两者都没有。

因此，当温度和流量损失没有标签时，损失函数需要忽略它们。我已经阅读了大量 TF 文档，但我正在努力弄清楚如何最好地做到这一点。

到目前为止我已经尝试过

• sample_weight_mode='temporal'在编译模型时指定，然后sample_weight在调用时包含一个 numpy 数组fit

当我这样做时，我收到一个错误，要求我传递一个二维数组。但这让我感到困惑，因为有 3 个维度：n_samples、sequence_length和n_outputs。

这是我基本上想做的一些代码：

import tensorflow as tf
import numpy as np

# set up the model
simple_lstm_model = tf.keras.models.Sequential([
    tf.keras.layers.LSTM(8, return_sequences=True),
    tf.keras.layers.Dense(2)
])

simple_lstm_model.compile(optimizer='adam', loss='mae',
                          sample_weight_mode='temporal')

n_sample = 2
seq_len = 10
n_feat = 5
n_out = 2

# random in/out
x = np.random.randn(n_sample, seq_len, n_feat)
y_true …

我尝试使用 R2in nn.LSTM 创建损失函数，但我找不到任何有关它的文档。我已经使用了 pytorch 的 RMSE 和 MAE 损失。

我的数据是一个时间序列，我正在做时间序列预测

这是我在数据训练中使用 RMSE 损失函数的代码

model = LSTM_model(input_size=1, output_size=1, hidden_size=512, num_layers=2, dropout=0).to(device)
criterion = nn.MSELoss(reduction="sum")
optimizer = optim.Adam(model.parameters(), lr=0.001)
callback = Callback(model, early_stop_patience=10 ,outdir="model/lstm", plot_every=20,)


from tqdm.auto import tqdm

def loop_fn(mode, dataset, dataloader, model, criterion, optimizer,device):
    if mode =="train":
        model.train()
    elif mode =="test":
        model.eval()
    cost = 0
    for feature, target in tqdm(dataloader, desc=mode.title()):
        feature, target = feature.to(device), target.to(device)
        output , hidden = model(feature,None)
        loss = torch.sqrt(criterion(output,target))
        
        if mode =="train":
            loss.backward()
            optimizer.step() …

我有以下代码：

import torch
import torch.nn as nn

model = nn.Sequential(
          nn.LSTM(300, 300),
          nn.Linear(300, 100),
          nn.ReLU(),
          nn.Linear(300, 7),
          )

s = torch.ones(1, 50, 300)
a = model(s)

我得到：

My-MBP:Desktop myname$ python3 testmodel.py 
Traceback (most recent call last):
  File "testmodel.py", line 12, in <module>
    a = model(s)
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/torch/nn/modules/container.py", line 117, in forward
    input = module(input)
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/torch/nn/modules/linear.py", line 93, in forward …