为什么非常简单的 PyTorch LSTM 模型不学习？

Question

我正在尝试进行非常简单的学习，以便更好地理解 PyTorch 和 LSTM 的工作原理。为此，我正在尝试学习从输入张量到输出张量（相同形状）的两倍值的映射。所以 [1 2 3] 作为输入应该学习 [2 4 6] 作为输出。为此，我有一个 dataloader:

class AudioDataset(Dataset):
    def __init__(self, corrupted_path, train_set=False, test_set=False):
        torch.manual_seed(0)
        numpy.random.seed(0)

    def __len__(self):
        return len(self.file_paths)

    def __getitem__(self, index):
        random_tensor = torch.rand(1, 5) * 2
        random_tensor = random_tensor - 1

        return random_tensor, random_tensor * 2

我的 LSTM 本身非常简单：

class MyLSTM(nn.Module):
    def __init__(self, input_size=4000):
        super(MyLSTM, self).__init__()

        self.lstm = nn.LSTM(input_size=input_size, hidden_size=input_size,
                            num_layers=2)

    def forward(self, x):
        y = self.lstm(x)
        return y

我的训练是这样的：

    train_loader = torch.utils.data.DataLoader(
        train_set, batch_size=1, shuffle=True, **kwargs)

    model = MyLSTM(input_size=5)
    optimizer = optim.Adam(model.parameters(), lr=0.01, weight_decay=0.0001)
    loss_fn = torch.nn.MSELoss(reduction='sum')

    for epoch in range(300):
        for i, data in enumerate(train_loader):
            inputs = data[0]
            outputs = data[1]

            print('inputs', inputs, inputs.size())
            print('outputs', outputs, outputs.size())
            optimizer.zero_grad()

            pred = model(inputs)
            print('pred', pred[0], pred[0].size())

            loss = loss_fn(pred[0], outputs)

            model.zero_grad()

            loss.backward()
            optimizer.step()

经过 300 个 epoch，我的 loss 看起来像 tensor(1.4892, grad_fn=<MseLossBackward>)。好像不太好。

随机查看一些输入/输出和预测：

inputs tensor([[[0.5050, 0.4669, 0.8310,  ..., 0.0659, 0.5043, 0.8885]]]) torch.Size([1, 1, 4000])
outputs tensor([[[1.0100, 0.9338, 1.6620,  ..., 0.1319, 1.0085, 1.7770]]]) torch.Size([1, 1, 4000])
pred tensor([[[ 0.6930,  0.0231, -0.6874,  ..., -0.5225,  0.1096,  0.5796]]],
       grad_fn=<StackBackward>) torch.Size([1, 1, 4000])

我们看到它根本没有学到太多东西。我不明白我做错了什么；如果有人能指导我，那将不胜感激。

Answer 1

LSTM 由神经元组成，这些神经元根据先前训练数据的反馈循环生成内部状态。每个神经元都有四个内部门，它们接受多个输入并生成多个输出。它是需要处理和理解的更复杂的神经元之一，我的技能还不足以给出深入的答案。

我在您的示例代码中看到的是对它们的工作方式缺乏了解，而且您似乎假设它们像线性层一样工作。我这么说，因为你的前向方法不处理 internal 状态并且你没有重塑输出。

你这样定义 LSTM：

     self.lstm = nn.LSTM(input_size=input_size, hidden_size=input_size, num_layers=2)

hidden_size 与记忆和功能如何与门配合使用有关。

PyTorch 文档说明如下：

hidden_size – The number of features in the hidden state h

它指的是用于训练长期和短期记忆的内部门的隐藏状态的大小。门是一个跨越隐藏特征的函数，store 以前的门输出。每次训练一个神经元时，隐藏状态都会更新并再次用于 next 训练数据。

为什么这如此重要？

你正在丢弃训练过程中的隐藏状态数据，我不知道如果你不定义隐藏状态会发生什么。我假设 LSTM 的工作方式就好像从来没有任何历史记录一样。

前向函数应如下所示：

    def forward(self, x, hidden):
        lstm_output, hidden = self.lstm(x, hidden)
        return lstm_output, hidden

在训练过程中，你必须自己跟踪隐藏状态。

for i in range(epochs):
   hidden = (torch.zeros(num_layers, batch_size, num_hidden),
             torch.zeros(num_layers, batch_size, num_hidden))

   for x, y in generate_batches(...):
        # missing code....
        lstm_output, hidden = model.forward(x, hidden)

记下隐藏状态的形状。这与您通常对线性图层所做的不同。

上面缺少一些与重置隐藏状态相关的步骤，但我不记得那部分是如何工作的。

LSTM 本身只能描述特征，很像卷积层。 LSTM 的输出不太可能是您感兴趣的用途。

大多数使用 LSTM 或卷积的模型底部都有全连接层（例如：nn.Linear()）。这些层将在特征上进行训练，以预测您感兴趣的输出。

这里的问题是 LSTM 的输出形状错误，您必须重塑张量，以便线性层可以使用它们。

这是我使用的 LSTM 前向函数示例：

    def forward(self, x, hidden):
        lstm_output, hidden = self.lstm(x, hidden)
        drop_output = self.dropout(lstm_output)
        drop_output = drop_output.contiguous().view(-1, self.num_hidden)
        final_out = self.fc_linear(drop_output)
        return final_out, hidden

LSTM 绝对是机器学习中的高级主题，而 PyTorch 并不是一个容易学习的库。我建议使用 TensorFlow 文档和在线博客阅读 LSTM，以更好地了解它们的工作原理。

为什么非常简单的 PyTorch LSTM 模型不学习？

Why is very simple PyTorch LSTM model not learning?

python

lstm

pytorch

tensor