为文本序列预测正确塑造 LSTM 输入/输出？

Question

我正在尝试学习如何使用 LSTM 根据前一个字符预测下一个字符。我已经成功创建了一个函数，可以将一长串文本（在一次热编码之后）批处理成(batch_size, seq_len, one_hot_features) 的形状。 one_hot_features 只是文本中唯一字符的数量。

由于我的批处理功能为我提供了训练序列和“基本事实”序列，我需要 LSTM 网络的输出与“基本事实”批次的形状相同，以便我可以将输出和标签插入损失函数。

所以我的问题是：

1. 如何正确定义我的网络架构以满足上述要求。
2. 当我的数据通过forward 函数中的各个层时，我如何对其进行整形？

这是我的尝试，代码将运行，但网络输出的形状不正确，无法与“ground truth”序列批次进行比较：

class charNN(nn.Module):
    def __init__(self, vocab, hidden_size, n_layers, dropout=0.5):
        super().__init__()

        self.vocab_length = len(vocab)
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(self.vocab_length, hidden_size, n_layers, batch_first=True)
        self.fc   = nn.Linear(hidden_size, self.vocab_length)
        
    def forward(self, x, hidden=None):
        x, hidden = self.lstm(x, hidden)     # -> (n_batches, seq_len, hidden_size)
        x = x.reshape(-1, self.hidden_size)  # -> (n_batches * seq_len, hidden_size)
        x = self.fc(x)                       # -> (n_batches * seq_len, vocab_length)
        
        return x, hidden    

提前谢谢你。我已经为此苦苦挣扎了几天。如果需要，我也很乐意提供用于训练网络的代码。它不会抛出任何错误，只是告诉我输出大小和真实标签大小不匹配。

Answer 1

您的input_size: len(vocab) 并且您还为__init__ 方法提供了足够的数量信息。

我也是 lstm 的初学者。

答案 1：

据我说，您已经正确定义了您的架构。也许您可以添加以下内容：

• token_size 变量：你的输出大小

• encoder 和 decoder 结构。

• 权重初始化方法

例如：

class charNN(nn.Module):
    def __init__(self, vocab, hidden_size, n_layers, dropout=0.5, token_size):
        super(charNN, self).__init__()
        self.token_size = token_size
        self.drop = nn.Dropout(dropout)
        self.vocab_length = len(vocab)
        self.hidden_size = hidden_size
        self.encoder = nn.Embedding(token_size, vocab_length)
        self.lstm = nn.LSTM(self.vocab_length,   
                            hidden_size, 
                            n_layers, 
                            batch_first=True, 
                            dropout=dropout)
        self.fc   = nn.Linear(hidden_size,  
                              self.vocab_length)
        self.decoder = nn.Linear(hidden_size, token_size)
        self.init_weights()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

    def init_weights(self):
        init_range = 0.1
        uniform_(self.encoder.weight, -init_range, init_range)
        zeros_(self.decoder.weight)
        uniform_(self.decoder.weight, -init_range, init_range)
        

    def init_hidden(self, batch_size):
        weight = next(self.parameters())
        return (weight.new_zeros(self.num_layers, batch_size,
                                 self.hidden_size),
                weight.new_zeros(self.num_layers, batch_size,
                                 self.hidden_size))

答案 2：

您可以将以下结构用于转发功能：

    def forward(self, input_, hidden_):
        embedded = self.drop(self.encoder(input_))
        output, hidden_ = self.rnn(input_, hidden_)
        output = self.drop(output)
        decoded = self.decoder(output)
        decoded = decoded.view(-1, self.token_size)
        output = log_softmax(decoded, dim=1)
        return output, hidden_

希望对你有帮助，祝你好运！