动手学深度学习（三十八）——从零开始实现循环神经网络RNN_手动实现循环神经网络rnn

【说明】：这里加载了两本书的数据，都是李沐沐神书中提到的数据。由于沐神封装的代码都是加载的《Time machine》，所以我是将前面两篇Blog的代码又在这里复写了一遍，用来加载《星球大战》数据集。后面的内容是对沐神课程和代码的一个复现。其中的知识点我会用黄色标出。

%matplotlib inline
import math
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l 
import re
import collections
import random
1
2
3
4
5
6
7
8
9

1. 数据加载与转换

1.1 加载Time machine这本书

# 加载数据
batch_size,num_steps = 32,35
train_iter,vocab = d2l.load_data_time_machine(batch_size,num_steps)
1
2
3

# 将每个标记的数字进行独热编码
# 索引为0和2的独热编码如下
F.one_hot(torch.tensor([0,2]),len(vocab))
1
2
3

tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0],
        [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0]])
1
2
3
4

  我们每次采样的小批量形状是(批量大小，时间步数)。one_hot编码将这样的小批量转换成三维张量，最后一个维度等于词表大小（len(vocab)）。我们经常置换输入的维度，以便于获得形状（时间步数，批量大小，词汇表大小）的输出。这将使得我们更方便地通过最外层的维度，一步一步地更新小批量的隐藏状态。（想象后面我们训练的时候时输入的每个时间步子上的数据，转置之后的数据方便我们python的读取，有一定的计算加速效果）

X = torch.arange(10).reshape((2, 5))
F.one_hot(X.T, 28).shape
1
2

torch.Size([5, 2, 28])
1

1.2 读取《星球大战》书籍数据集

手动将前面的代码修改了一点点。为了方便查看也没有封装了

def read_book(dir):
    """这里的预处理操作比较暴力，将标点符号和特殊字符全部剔除了，只剩下了26个字母和空格"""
    with open(dir,'r') as f:
        lines = f.readlines()
    return [re.sub('[^A-Za-z]+',' ',line).strip().lower() for line in lines]

def tokenize(lines,token='word'):
    if token=="word":
        return [line.split() for line in lines]
    elif token =="char":
        return [list(line) for line in lines]
    else:
        print("Error:未知令牌类型："+token)

        lines = read_book('./data/RNN/36-0.txt') 
        
def count_corpus(tokens):
    """统计标记的频率：这里的tokens是1D列表或者2D列表"""
    if len(tokens) ==0 or isinstance(tokens[0],list):
        # 将tokens展平成使用标记填充的一个列表
        tokens = [token for line in tokens for token in line]
    return collections.Counter(tokens)

class Vocab:
    """构建文本词表"""
    def __init__(self,tokens=None,min_freq=0,reserved_tokens=None):
        if tokens is None:
            tokens=[]
        if reserved_tokens is None:
            reserved_tokens = []
        # 根据出现频率排序
        counter = count_corpus(tokens)
        self.token_freqs = sorted(counter.items(),key=lambda x:x[1],reverse=True)
        
        # 未知标记的索引为0
        self.unk , uniq_tokens = 0, ['<unk>']+reserved_tokens
        uniq_tokens += [token for token,freq in self.token_freqs
                       if freq >= min_freq and token not in uniq_tokens]
        self.idx_to_token,self.token_to_idx = [],dict() # 根据索引找标记和根据标记找索引
        for token in uniq_tokens:
            self.idx_to_token.append(token)
            self.token_to_idx[token] = len(self.idx_to_token)-1
            
    def __len__(self):
        return len(self.idx_to_token)
    
    def __getitem__(self,tokens):
        """转换到一个一个的item进行输出"""
        if not isinstance(tokens,(list,tuple)):
            return self.token_to_idx.get(tokens,self.unk)
        return [self.__getitem__(token) for token in tokens]
    
    def to_tokens(self,indices):
        """如果是单个index直接输出，如果是list或者tuple迭代输出"""
        if not isinstance(indices,(list,tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]
    
def load_corpus_book(max_tokens=-1):
    """返回book数据集中的标记索引列表和词汇表"""
    lines = read_book('./data/RNN/36-0.txt')
    tokens = tokenize(lines,'char')
    vocab = Vocab(tokens)
    # 因为数据集中每一个文本行，不一定是一个句子或者段落
    # 所以将所有文本行展平到一个列表之中
    corpus = [vocab[token] for line in tokens for token in line]
    if max_tokens >0:
        corpus = corpus[:max_tokens]
    return corpus,vocab

def seq_data_iter_random(corpus,batch_size,num_steps):
    """使用随机抽样生成一个小批量子序列"""
    # 从随机偏移量开始对序列进行分区，随机范围包括`num_steps - 1`
    corpus = corpus[random.randint(0, num_steps - 1):]
    # 减去1，是因为我们需要考虑标签
    num_subseqs = (len(corpus) - 1) // num_steps
    # 长度为`num_steps`的子序列的起始索引
    initial_indices = list(range(0, num_subseqs * num_steps, num_steps))
    # 在随机抽样的迭代过程中，
    # 来自两个相邻的、随机的、小批量中的子序列不一定在原始序列上相邻
    random.shuffle(initial_indices)

    def data(pos):
        # 返回从`pos`位置开始的长度为`num_steps`的序列
        return corpus[pos:pos + num_steps]

    num_batches = num_subseqs // batch_size
    for i in range(0, batch_size * num_batches, batch_size):
        # 在这里，`initial_indices`包含子序列的随机起始索引
        initial_indices_per_batch = initial_indices[i:i + batch_size]
        X = [data(j) for j in initial_indices_per_batch]
        Y = [data(j + 1) for j in initial_indices_per_batch]
        yield torch.tensor(X), torch.tensor(Y)
        
def seq_data_iter_sequential(corpus,batch_size,num_steps):
    """使用顺序分区生成一个小批量子序列"""
    # 从随机偏移量开始划分序列
    offset = random.randint(0,num_steps)
    num_tokens = ((len(corpus)- offset -1)//batch_size)*batch_size
    Xs = torch.tensor(corpus[offset:offset+num_tokens])
    Ys = torch.tensor(corpus[offset+1:offset+num_tokens+1])
    Xs,Ys = Xs.reshape(batch_size,-1),Ys.reshape(batch_size,-1)
    num_batches = Xs.shape[1]//num_steps
    for i in range(0,num_steps*num_batches,num_steps):
        X = Xs[:,i:i+num_steps]
        Y = Ys[:,i:i+num_steps]
        yield X,Y

class SeqDataLoader:  #@save
    """加载序列数据的迭代器。"""
    def __init__(self, batch_size, num_steps, use_random_iter, max_tokens):
        if use_random_iter:
            self.data_iter_fn = seq_data_iter_random
        else:
            self.data_iter_fn = seq_data_iter_sequential
        self.corpus, self.vocab = load_corpus_book(max_tokens)
        self.batch_size, self.num_steps = batch_size, num_steps

    def __iter__(self):
        return self.data_iter_fn(self.corpus, self.batch_size, self.num_steps)
        
# 定义函数load_data_book同时返回数据迭代器和词汇表
def load_data_book(batch_size, num_steps,  #@save
                           use_random_iter=False, max_tokens=10000):
    """返回时光机器数据集的迭代器和词汇表。"""
    data_iter = SeqDataLoader(batch_size, num_steps, use_random_iter,max_tokens)
    return data_iter, data_iter.vocab
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

# 加载数据
batch_size,num_steps = 32,35
train_iter,vocab = load_data_book(batch_size,num_steps)
1
2
3

2. 初始化模型参数

num_hiddens是一个可调整的超参数，当训练网络模型时，输入和输出来自相同的词表，因此其具有相同的维度，等于词表的大小

def get_params(vocab_size,num_hiddens,device):
    num_inputs = num_outputs = vocab_size
    
    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) # 每一个隐藏变量的bias
    
    # 输出层
    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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 循环神经网络模型

  为了定义循环神经网络模型，我们首先需要一个函数在初始化时返回隐藏状态。其返回一个张量，全用0填充，其形状为（批量大小，隐藏单元数）。使用元组可以更容易地处理隐藏状态包含多个变量的情况。

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

  使用rnn函数定义如何在一个时间步计算隐藏状态和输出。请注意，循环神经网络模型通过最外层维度inputs循环，以便于逐时间步更新小批量的隐藏状态H。激活函数使用tanh函数。如多层感知机章节中所述，当元素在实数上均匀分布的时候，tanh的平均值为0

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:
        """按照时间顺序来遍历数据"""
        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
2
3
4
5
6
7
8
9
10
11
12

# 用一个类整合上面的全部函数，并存储RNN的模型参数
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#检查输出的形状是否正确，保证隐藏状态的维度不变
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
1
2
3
4
5
6

(torch.Size([10, 28]), 1, torch.Size([2, 512]))
1

输出的形状是（时间步数*批量大小，词汇表大小），而隐藏状态的形状保持不变，即（批量大小，隐藏单元数）

4. 预测

  定义预测函数用来生成用户提供的prefix之后的新字符，prefix是一个包含多个字符的字符串。在prefix中循环遍历这些开始的字符时，不断地将隐藏状态传递到下一个时间步，而不生成任何输出。

  这被称为"预热期"（warm-up），在这个期间模型会自我更新（例如，更新隐藏状态），但不进行预测。
预测期之后，隐藏状态比开始的初始值好。

def predict(prefix,num_preds,net,vocab,device):
    """在prefix 后面生成新的字符"""
    state = net.begin_state(batch_size=1,device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.tensor([outputs[-1]], device=device).reshape((1, 1))
    
    for y in prefix[1:]: #预热期
        _,state = net(get_input(),state)
        outputs.append(vocab[y])
    
    for _ in range(num_preds): # 进行`num_preds`步预测
        y,state = net(get_input(),state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return "".join([vocab.idx_to_token[i] for i in outputs])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

predict('time traveller ', 10, net, vocab, d2l.try_gpu())
1

'time traveller awmjvgtmjv'
1

5. 梯度裁剪

  对于长度为$T$的序列，我们在迭代中计算这些$T$个时间步上的梯度，从而在反向传播过程中产生长度为$\mathcal{O}(T)$的矩阵乘法链。当$T$较大时，它可能导致数值不稳定，例如可能梯度爆炸或梯度消失。 因此，循环神经网络模型往往需要额外的帮助来稳定训练。

  一般来说，在解决优化问题时，我们对模型参数采取更新步骤，例如在向量形式的$\mathbf{x}$中，在小批量的负梯度$\mathbf{g}$方向上。例如，使用$\eta >0$作为学习率，在一次迭代中，我们将$\mathbf{x}$更新为$\mathbf{x}-\eta \mathbf{g}$。让我们进一步假设目标函数$f$表现良好，例如，李卜希兹连续（Lipschitz continuous）常数$L$。也就是说，对于任意$\mathbf{x}$和$\mathbf{y}$我们有：

$$|f(\mathbf{x})-f(\mathbf{y})|\le L\Vert \mathbf{x}-\mathbf{y}\Vert .$$

  在这种情况下，我们可以合理地假设，如果我们将参数向量通过$\eta \mathbf{g}$更新，那么：

$$|f(\mathbf{x})-f(\mathbf{x}-\eta \mathbf{g})|\le L\eta \Vert \mathbf{g}\Vert ,$$

  这意味着我们不会观察到超过$L\eta \Vert \mathbf{g}\Vert$的变化。这既是诅咒也是祝福。在诅咒的一面，它限制了进步的速度；而在祝福的一面，它限制了如果我们朝着错误的方向前进，事情会出错的程度。

  有时梯度可能很大，优化算法可能无法收敛。我们可以通过降低$\eta$的学习率来解决这个问题。但是如果我们很少得到大的梯度呢？在这种情况下，这种做法似乎完全没有根据。一个流行的替代方法是通过将梯度$\mathbf{g}$投影回给定半径的球（例如$\theta$）来裁剪梯度$\mathbf{g}$。如下式：

$$\mathbf{g}\leftarrow \min \left(1,\frac{\theta }{\Vert \mathbf{g}\Vert }\right)\mathbf{g}.$$

  通过这样做，我们知道梯度范数永远不会超过$\theta$，并且更新后的梯度完全与$\mathbf{g}$的原始方向对齐。它还有一个理想的副作用，即限制任何给定的小批量（以及其中任何给定的样本）对参数向量的影响。这赋予了模型一定程度的健壮性。梯度裁剪提供了一个快速修复梯度爆炸的方法。虽然它并不能完全解决问题，但它是众多缓解问题的技术之一。

  下面我们定义一个函数来裁剪从零开始实现的模型或由高级API构建的模型的梯度。还要注意，我们计算了所有模型参数的梯度范数。

def grad_clipping(net, theta):  #@save
    """裁剪梯度。"""
    if isinstance(net, nn.Module):
        params = [p for p in net.parameters() if p.requires_grad]
    else:
        params = net.params
    norm = torch.sqrt(sum(torch.sum((p.grad**2)) for p in params))
    if norm > theta:
        for param in params:
            param.grad[:] *= theta / norm
1
2
3
4
5
6
7
8
9
10

6. 训练

  在训练模型之前，让我们定义一个函数来训练只有一个迭代周期的模型。它与我们训练softmax回归模型的方式有三个不同之处：

1. 顺序数据的不同采样方法（随机采样和顺序分区）将导致隐藏状态初始化的差异。
2. 我们在更新模型参数之前裁剪梯度。这确保了即使在训练过程中的某个点上梯度爆炸，模型也不会发散。
3. 我们用困惑度来评价模型。确保了不同长度的序列具有可比性。

  具体地说，当使用顺序分区时，我们只在每个迭代周期的开始处初始化隐藏状态。由于下一个小批量中的$i^{\mathrm{th}}$子序列样本与当前$i^{\mathrm{th}}$子序列样本相邻，因此当前小批量末尾的隐藏状态将用于初始化下一个小批量开头的隐藏状态。这样，存储在隐藏状态中的序列历史信息可以在一个迭代周期内流过相邻的子序列。然而，任何一点隐藏状态计算都依赖于同一迭代周期中所有的前一个小批量，这使得梯度计算变得复杂。为了降低计算量，我们在处理任何一个小批量之前先分离梯度，使得隐藏状态的梯度计算总是限制在一个小批量的时间步内。

  当使用随机抽样时，我们需要为每个迭代周期重新初始化隐藏状态，因为每个样本都是在一个随机位置抽样的。

def train_epoch(net, train_iter, loss, updater, device, use_random_iter):
    """训练模型一个迭代周期。"""
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和, 标记数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化`state`
            state = net.begin_state(batch_size=X.shape[0], device=device)
        else:
            if isinstance(net, nn.Module) and not isinstance(state, tuple):
                # `state`对于`nn.GRU`是个张量
                state.detach_()
            else:
                # `state`对于`nn.LSTM`或对于我们从零开始实现的模型是个张量
                for s in state:
                    s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了`mean`函数
            updater(batch_size=1)
        metric.add(l * y.numel(), y.numel())
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#@save
def train(net, train_iter, vocab, lr, num_epochs, device,use_random_iter=False):
    """训练模型"""
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',
                            legend=['train'], xlim=[10, num_epochs])
    # 初始化
    if isinstance(net, nn.Module):
        updater = torch.optim.SGD(net.parameters(), lr)
    else:
        updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)
    predict_train = lambda prefix: predict(prefix, 50, net, vocab, device)
    # 训练和预测
    for epoch in range(num_epochs):
        ppl, speed = train_epoch(net, train_iter, loss, updater, device,
                                     use_random_iter)
        if (epoch + 1) % 10 == 0:
            print(predict_train('time traveller'))
            animator.add(epoch + 1, [ppl])
    print(f'困惑度 {ppl:.1f}, {speed:.1f} 标记/秒 {str(device)}')
    print(predict_train('the planet mars i scarcely'))
    print(predict_train('scarcely'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

现在我们可以训练循环神经网络模型。因为我们在数据集中只使用10000个标记，所以模型需要更多的迭代周期来更好地收敛。

num_epochs, lr = 500, 1
train(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu())
1
2

困惑度 1.0, 172140.2 标记/秒 cuda:0
the planet mars i scarcely need remind the reader revolves about thesun at a
scarcely ore seventh ofthe volume of the earth must have a
1
2
3

最后，让我们检查一下使用随机抽样方法的结果。

train(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu(),use_random_iter=True)
1

困惑度 1.4, 172089.0 标记/秒 cuda:0
<unk>he planet <unk>ars<unk> <unk> scarcely one seventh ofthe volume of the earth must have a
scarcely one seventh ofthe volume of the earth must have a
1
2
3

小结

• 我们可以训练一个基于循环神经网络的字符级语言模型，根据用户提供的文本前缀生成文本。
• 一个简单的循环神经网络语言模型包括输入编码、循环神经网络模型和输出生成。
• 循环神经网络模型需要状态初始化来训练，尽管随机抽样和顺序划分使用不同的方法。
• 当使用顺序划分时，我们需要分离梯度以减少计算量。
• 预热期允许模型在进行任何预测之前进行自我更新（例如，获得比初始值更好的隐藏状态）。
• 梯度裁剪可以防止渐变爆炸，但不能应对梯度消失。

练习

1. 说明独热编码等同于为每个对象选择不同的嵌入。
2. 通过调整超参数（如迭代周期数、隐藏单元数、小批量的时间步数、学习率等）来改善困惑度。
   • 你能降到多低？
   • 用可学习的嵌入替换独热编码。这会带来更好的表现吗？
   • 它在其他书上的效果如何，例如星球大战？
3. 修改预测函数，例如使用采样，而不是选择最有可能的下一个字符。
   • 会发生什么？
   • 使模型偏向更可能的输出，例如，从$q(x_t\mid x_{t-1},\dots ,x_1)\propto P(x_t\mid x_{t-1},\dots ,x_1{)}^{\alpha }$中抽取$\alpha >1$。
4. 在不裁剪梯度的情况下运行本节中的代码。会发生什么事？
5. 更改顺序划分，使其不会从计算图中分离隐藏状态。运行时间有变化吗？困惑度呢？
6. 用ReLU替换本节中使用的激活函数，并重复本节中的实验。我们还需要梯度裁剪吗？为什么？