为什么非常简单的 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 由神经元组成，这些神经元根据先前训练数据的反馈循环生成内部状态。每个神经元都有四个内部门，它们接受多个输入并产生多个输出。它是使用和理解的更复杂的神经元之一，我的技能还不够深入，无法给出深入的答案。

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

你这样定义 LSTM：

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

hidden_size 与内存和功能如何与门一起工作有关。

PyTorch 文档说明如下：

hidden_​​size – 隐藏状态的特征个数 h

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

那么为什么这如此重要？

你在训练期间丢弃隐藏状态数据，我不知道如果你不定义隐藏状态会发生什么。我假设 LSTM 就像没有任何历史一样工作。

forward 函数应该如下所示：

    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，以更好地了解它们的工作原理。