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个纪元后，我的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由神经元组成，这些神经元根据来自先前训练数据的反馈回路生成内部状态。每个神经元具有四个内部门，这些内部门接收多个输入并生成多个输出。它是可以处理和理解的较复杂的神经元之一，我还不够熟练，无法给出深入的答案。

我在您的示例代码中看到的是缺乏对它们如何工作的理解，似乎您假设它们像线性层一样工作。我这么说是因为您的前进方法无法处理内部状态，并且您不会重塑输出。

您可以这样定义LSTM：

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

hidden_size与内存和功能与门的工作方式有关。

PyTorch文档中的内容如下：

hidden_size –处于隐藏状态h的要素数量

它是指用于训练内部和长期存储器的隐藏状态的大小。门是跨越存储先前门输出的隐藏特征的功能。每次训练神经元时，隐藏状态都会更新，并再次用于 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模型无法学习？

1 个答案: