如何在 PyTorch 中处理 2 层 LSTM 的隐藏单元输出？

Question

我在 PyTorch 中创建了一个带有 LSTM 和全连接层的网络。我想测试 LSTM 层数的增加如何影响我的性能。

假设我的输入是 (6, 9, 14)，意味着批量大小为 6，序列大小为 9，特征大小为 14，并且我正在处理一个有 6 个类的任务，所以我期望一个 6 元素 one-hot-编码张量作为单个序列的预测。 FC 层之后该网络的输出应该是 (6, 6)，但是，如果我使用 2 个 LSTM 层，它就会变成 (12, 6)。

我不明白应该如何处理 LSTM 层的输出，以将批次数量从 [2 * batch_size] 减少到 [batch_size]。另外，我知道我正在使用隐藏状态作为 FC 层的输入，我现在想尝试这种方式。

我应该每两批求和或连接还是其他什么？干杯!

    def forward(self, x):
        hidden_0 = torch.zeros((self.lstm_layers, x.size(0), self.hidden_size), dtype=torch.double, device=self.device)
        cell_0 = torch.zeros((self.lstm_layers, x.size(0), self.hidden_size), dtype=torch.double, device=self.device)

        y1, (hidden_1, cell_1) = self.lstm(x, (hidden_0, cell_0))
        hidden_1 = hidden_1.view(-1, self.hidden_size)

        y = self.linear(hidden_1)

        return y

Answer 1

多层 lstm 的隐藏状态形状为 (layers, batch_size, hide_size) 查看输出 LSTM。它包含沿第 0 维的每一层的隐藏状态。

在您的示例中，您在此处将形状转换为二维：

hidden_1 = hidden_1.view(-1, self.hidden_size)

这会将形状转换为 (batch_size *layers, hide_size)。

您想要做的只是使用最后一层的隐藏状态：

hidden = hidden_1[-1,:,:].view(-1, self.hidden_size)  # (1, bs, hidden) -> (bs, hidden)
y = self.linear(hidden)
return y

Answer 2

对于多层LSTM，可以这样写：

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size, batch_size):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.output_size = output_size
        self.batch_size = batch_size
        self.lstm = nn.LSTM(self.input_size, self.hidden_size, self.num_layers, batch_first=True)
        self.linear = nn.Linear(self.hidden_size, self.output_size)

    def forward(self, input_seq):
        h_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        c_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        seq_len = input_seq.shape[1]
        # input(batch_size, seq_len, input_size)
        input_seq = input_seq.view(self.batch_size, seq_len, 1)
        # output(batch_size, seq_len, num_directions * hidden_size)
        output, _ = self.lstm(input_seq, (h_0, c_0))
        # print('output.size=', output.size())
        # print(self.batch_size * seq_len, self.hidden_size)
        output = output.contiguous().view(self.batch_size * seq_len, self.hidden_size)
        pred = self.linear(output)
        # print('pred=', pred.shape)
        pred = pred.view(self.batch_size, seq_len, -1)
        pred = pred[:, -1, :]
        return pred