重新创建用于生成文本的字符级 RNN

Question

我关注了一本关于深度学习的书，其中有一章是关于以示例样式生成文本的。他们使用了一个带有两个 LSTM 层的 char 级 RNN 来生成 Shaspare 风格的文本。但是书中的代码（也在线：https://github.com/DOsinga/deep_learning_cookbook/blob/master/05.1%20Generating%20Text%20in%20the%20Style%20of%20an%20Example%20Text.ipynb）是用keras写的，我只用pytorch。所以我绑在 pytorch 中重新创建它，具有相同的网络结构和超参数。

因此，在重新创建它并使其正常工作后，它对其进行了训练，它只学会了写最常见的字符，即空格。然后我尝试在一个非常简单的句子上过度拟合，所以我不得不将序列长度减少到 8。这也不起作用，但是当将 LSTM 的隐藏大小减少到只有 32 时，它几乎完美地学会了它。 因此，我继续处理原始文本，并开始使用隐藏大小、学习率、优化器（也尝试过 adam）并对其进行更长时间的训练。我能做到的最好的是一些随机的字母，仍然有很多空格，有时像“她”这样的东西，但远不可读，仍然有相当高的损失。我使用 RMSprop，lr=0.01，隐藏大小为 128，超过 20000 个 epoch。我还尝试将隐藏状态和单元状态初始化为零。

问题是，我的结果远比书中的差，但我在 pytorch 中的结果完全一样。有人可以告诉我，我应该尝试什么或我做错了什么。任何帮助表示赞赏！ PS：对不起我的英语不好。

这是我的原始超参数代码：

#hyperparameters
batch_size = 256
seq_len = 160
hidden_size = 640
layers = 2

#network structure
class RNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.lstm = nn.LSTM(len(chars),hidden_size,layers)
        self.linear = nn.Linear(hidden_size,len(chars))
        self.softmax = nn.Softmax(dim=2)
    def forward(self,x,h,c):
        x,(h,c) = self.lstm(x,(h,c))
        x = self.softmax(self.linear(x))
        return x,h,c

#create network, optimizer and criterion
rnn = RNN().cuda()
optimizer = torch.optim.RMSprop(rnn.parameters(),lr=0.01)
criterion = nn.CrossEntropyLoss()

#training loop
plt.ion()
losses = []
loss_sum = 0
for epoch in range(10000):
    #generate input and target filled with zeros
    input = numpy.zeros((seq_len,batch_size,len(chars)))
    target = numpy.zeros((seq_len,batch_size))
    for batch in range(batch_size):
        #choose random starting index in text
        start = random.randrange(len(text)-seq_len-1)
        #generate sequences for that batch filled with zeros
        input_seq = numpy.zeros((seq_len+1,len(chars)))
        target_seq = numpy.zeros((seq_len+1))
        for i,char in enumerate(text[start:start+seq_len+1]):
            #convert character to index
            idx = char_to_idx[char]
            #set value of index to one (one-hot-encoding)
            input_seq[i,idx] = 1
            #set value to index (only label)
            target_seq[i] = idx
        #insert sequences into input and target
        input[:,batch,:] = input_seq[:-1]
        target[:,batch] = target_seq[1:]
    #convert input and target from numpy array to pytorch tensor on gpu
    input = torch.from_numpy(input).float().cuda()
    target = torch.from_numpy(target).long().cuda()

    #initialize hidden state and cell state to zero
    h0 = torch.zeros(layers,batch_size,hidden_size).cuda()
    c0 = torch.zeros(layers,batch_size,hidden_size).cuda()
    #run the network on the input
    output,h,c = rnn(input,h0,c0)
    #calculate loss and perform gradient descent
    optimizer.zero_grad()
    loss = criterion(output.view(-1,len(chars)),target.view(-1))
    loss.backward()
    optimizer.step()

使用原始超参数绘制损失图：

训练后的目标和输出示例：

Target:  can bring this instrument of honour
    again into his native quarter, be magnanimous in the enterprise,
    and go on; I will grace the attempt for a worthy e
Output:                                                                                                                                                                 

在 20000 个时期内隐藏大小为 128 的损失图（最佳结果）：

Answer 1

我后来终于找到了一种接近真实句子的方法，也许它会对某人有所帮助。这是一个示例结果：

-我没有见过他，而王子是继承财产的迹象

在我的例子中，重要的变化是不将隐藏和单元状态初始化为每批归零，而是仅在每个时期。为此，我必须重写批处理生成器，以便它生成彼此跟随的批处理。