python-3.x - 了解 Pytorch vanilla RNN 架构

Question

标准解释：在原始 RNN 中，隐藏状态和输出计算为

换句话说，我们从隐藏状态获得输出。

根据Wiki，RNN 架构可以这样展开：

我一直在使用的代码是这样的：

class Model(nn.Module):
    def __init__(self, input_size, output_size, hidden_dim, n_layers):
        super(Model, self).__init__()
        self.hidden_dim = hidden_dim
        self.rnn = nn.RNN(input_size, hidden_dim, 1)   
        self.fc = nn.Linear(hidden_dim, output_size)

    def forward(self, x):
        batch_size = x.size(0)

        out, hidden = self.rnn(x)

        # getting output from the hidden state
        out = out..view(-1, self.hidden_dim)
        out = self.fc(out)

        return out, hidden

RNN 作为“纯”前馈层：但是今天，我从Pytorch 教程中看到了另一个实现

他们的代码就像

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()

        self.hidden_size = hidden_size

        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(input_size + hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden):
        combined = torch.cat((input, hidden), 1)
        hidden = self.i2h(combined)
        output = self.i2o(combined)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        return torch.zeros(1, self.hidden_size)

隐藏层计算与标准解释相同，但输出是独立于当前隐藏状态计算的h。

对我来说，这个实现背后的数学是：

那么，这个实现与原来的 RNN 实现有什么不同呢？

我使用 RNN 快 1 年了，我以为我明白了，直到今天我看到 Pytorch 的这篇文章。我现在真的很困惑。

标签： python-3.xpytorchrecurrent-neural-network