NLP3：从零实现RNN

我们每次采样的小批量数据形状是（批量⼤小, 时间步数）。
one_hot函数将这样⼀个小批量数据转换成三维张量，张量的最后⼀个维度等于词汇表⼤小（len(vocab)）。
我们经常转换输⼊的维度，以便获得形状为（时间步数, 批量⼤小, 词汇表⼤小）的输出。
这将使我们能够更⽅便地通过最外层的维度，⼀步⼀步地更新小批量数据的隐藏状态。

下面我们讨论一下，为什么要转置矩阵。
拿本例来说，我们的输入是一个 2528的矩阵。2是batchsize，即有2句话，5是timestep，即每句话有5个词，28是vocab_size
我们需要的是拿第n个词（及前面的一些词）来预测第n+1个词，而不是用第一句话来预测第二句话。
如果输入 2528，首层遍历之后，每次输入都是528，而这528代表的是一句话，这句话输入进去之后H保存的就是这句话的信息，输出的是预测的下一句话，然而，第二句话与第一句话是独立的,这就与我们的需求相违背。

总之就是，我们需要每次训练同一个批量下的同一时间步，即一次输入几句话，几句话同时推进时间步。

初始化循环神经网络模型参数

隐藏单元数num_hiddens是一个可调的超参数。 当训练语言模型时，输入和输出来自相同的词表。 因此，它们具有相同的维度，即词表的大小。

def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size
    #输入输出都是一个词，onehot之后变成一个长度为vocabsize的向量
    def normal(shape):
        return torch.randn(size=shape, device=device) * 0.01

    # 隐藏层参数
    W_xh = normal((num_inputs, num_hiddens))
    W_hh = normal((num_hiddens, num_hiddens))
    b_h = torch.zeros(num_hiddens, device=device)
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

def init_rnn_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device), )

def rnn(inputs, state, params):
    # inputs的形状：(时间步数量，批量大小，词表大小)
    W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    #H是前一时刻隐藏状态
    outputs = []
    # X的形状：(批量大小，词表大小)
    for X in inputs:
        #使用前一时刻t-1的H更新成为当前t的H
        H = torch.tanh(torch.mm(X, W_xh) + torch.mm(H, W_hh) + b_h)
        Y = torch.mm(H, W_hq) + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H,)

注意：
1、inputs是（batchsize,vocabsize），事实上，如果时间步为t的话，我们可以类似看成是每个batch里面有t个样本而不是batchsize个样本（转置带来的作用）
2、rnn函数中的循环的是时间步，每一个时间步是for的每一次循环
3、我们把结果Y拼接起来，使得列数不变，仍为vocabsize，行数叠加，最终成为bacthsize*numstep

包装类

class RNNModelScratch: #@save
    """从零开始实现的循环神经网络模型"""
    def __init__(self, vocab_size, num_hiddens, device,
                 get_params, init_state, forward_fn):
        self.vocab_size, self.num_hiddens = vocab_size, num_hiddens
        self.params = get_params(vocab_size, num_hiddens, device)
        self.init_state, self.forward_fn = init_state, forward_fn

    def __call__(self, X, state):
        X = F.one_hot(X.T, self.vocab_size).type(torch.float32)
        return self.forward_fn(X, state, self.params)

    def begin_state(self, batch_size, device):
        return self.init_state(batch_size, self.num_hiddens, device)

检查

X是[2,5]

num_hiddens = 512
net = RNNModelScratch(len(vocab), num_hiddens, d2l.try_gpu(), get_params,
                      init_rnn_state, rnn)
state = net.begin_state(X.shape[0], d2l.try_gpu())
Y, new_state = net(X.to(d2l.try_gpu()), state)
Y.shape, len(new_state), new_state[0].shape

我们可以看到输出形状是（时间步数×批量大小，词表大小）， 而隐状态形状保持不变，即（批量大小，隐藏单元数）。