深度学习实战（基于pytroch）系列（三十五）循环神经网络的从零开始实现

循环神经网络的从零开始实现

上一节语言模型数据集我们利用周杰伦的专辑制作了我们所需要的数据集，在本节中，我们将从零开始实现一个基于字符级循环神经网络的语言模型，并在周杰伦专辑歌词数据集上训练一个模型来进行歌词创作。首先，我们读取周杰伦专辑歌词数据集：

python 复制代码

import torch
import torch.nn as nn
import torch.optim as optim
import math
import random
import time
import zipfile

def load_data_jay_lyrics():
    with zipfile.ZipFile('../data/jaychou_lyrics.txt.zip') as zin:
        with zin.open('jaychou_lyrics.txt') as f:
            corpus_chars = f.read().decode('utf-8')
    corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ')
    corpus_chars = corpus_chars[0:10000]
    idx_to_char = list(set(corpus_chars))
    char_to_idx = {char: i for i, char in enumerate(idx_to_char)}
    vocab_size = len(char_to_idx)
    corpus_indices = [char_to_idx[char] for char in corpus_chars]
    return corpus_indices, char_to_idx, idx_to_char, vocab_size


(corpus_indices, char_to_idx, idx_to_char, vocab_size) = load_data_jay_lyrics()

one-hot向量

为了将词表示成向量输入到神经网络，一个简单的办法是使用one-hot向量。假设词典中不同字符的数量为 N N N（即词典大小vocab_size），每个字符已经同一个从0到 N − 1 N-1 N−1 的连续整数值索引一一对应。如果一个字符的索引是整数 i i i，那么我们创建一个全0的长为 N N N 的向量，并将其位置为 i i i 的元素设成1。该向量就是对原字符的one-hot向量。

python 复制代码

def one_hot(x, n_class, dtype=torch.float32):
    # x shape: (batch_size,), 输出形状: (batch_size, n_class)
    x = x.long()
    res = torch.zeros(x.shape[0], n_class, dtype=dtype, device=x.device)
    res.scatter_(1, x.view(-1, 1), 1)
    return res

x = torch.tensor([0, 2])
print(one_hot(x, vocab_size))

res.scatter_(1, x.view(-1, 1), 1)参数解释：

1: 操作的维度（dim=1，即列方向）

x.view(-1, 1): 将输入张量重塑为 (batch_size, 1) 的形状

1: 要填充的值

scatter_ 的工作原理：对于每个样本 i：在 res[i] 这个行向量中,在位置 x[i] 处设置值为 1,其他位置保持为 0.

我们每次采样的小批量的形状是(批量大小, 时间步数)。下面的函数将这样的小批量变换成数个可以输入进网络的形状为(批量大小, 词典大小)的矩阵，矩阵个数等于时间步数。也就是说，时间步 t t t 的输入为 X t ∈ R n × d \boldsymbol{X}_t \in \mathbb{R}^{n \times d} Xt∈Rn×d，其中 n n n 为批量大小， d d d 为输入个数，即one-hot向量长度（词典大小）。

python 复制代码

def to_onehot(X, n_class):
    # X shape: (batch_size, seq_len), 输出: seq_len个(batch_size, n_class)的Tensor
    return [one_hot(X[:, i], n_class) for i in range(X.shape[1])]

X = torch.arange(10).reshape(2, 5)
inputs = to_onehot(X, vocab_size)
print(len(inputs), inputs[0].shape)

输出

5 torch.Size([2, 1027])

to_onehot函数详细执行过程

循环展开 ：for i in range(X.shape[1]) → for i in range(5)

时间步 0 (i=0)

X[:, 0] = tensor([0, 5]) # 取第0列的所有行

one_hot(tensor([0, 5]), 13)`
输出：

tensor([[1., 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.\]\]) 时间步 1 (i=1) X\[:, 1\] = tensor(\[1, 6\]) one_hot(tensor(\[1, 6\]), 13) **输出** ： tensor(\[\[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.\], \[0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.\]\]) 时间步 2 (i=2) X\[:, 2\] = tensor(\[2, 7\]) one_hot(tensor(\[2, 7\]), 13) **输出** ： tensor(\[\[0., 0., 1., 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, 1, 2, 3, 4]

样本1: [5, 6, 7, 8, 9]

输出结构

inputs = [

时间步0: 两个样本的第0个元素
$\[1,0,0,0,0,0,0,0,0,0,0,0,0\], # 样本0的0 → 第0位为1 \[0,0,0,0,0,1,0,0,0,0,0,0,0\]\], # 样本1的5 → 第5位为1 # 时间步1: 两个样本的第1个元素 \[\[0,1,0,0,0,0,0,0,0,0,0,0,0\], # 样本0的1 → 第1位为1 \[0,0,0,0,0,0,1,0,0,0,0,0,0\]\], # 样本1的6 → 第6位为1 # ... 以此类推$

初始化模型参数

接下来，我们初始化模型参数。隐藏单元个数 num_hiddens是一个超参数。

python 复制代码

def try_gpu():
    """If GPU is available, return torch.device('cuda'); else return torch.device('cpu')."""
    if torch.cuda.is_available():
        return torch.device('cuda')
    else:
        return torch.device('cpu')
    
num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
device = try_gpu()
print('will use', device)



def get_params():
    def _one(shape):
        ts = torch.tensor(torch.randn(*shape) * 0.01, device=device)
        return torch.nn.Parameter(ts, requires_grad=True)
    
    # 隐藏层参数
    W_xh = _one((num_inputs, num_hiddens))
    W_hh = _one((num_hiddens, num_hiddens))
    b_h = torch.nn.Parameter(torch.zeros(num_hiddens, device=device), requires_grad=True)
    # 输出层参数
    W_hq = _one((num_hiddens, num_outputs))
    b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device), requires_grad=True)
    
    return [W_xh, W_hh, b_h, W_hq, b_q]

定义模型

我们根据循环神经网络的计算表达式实现该模型。首先定义init_rnn_state函数来返回初始化的隐藏状态。它返回由一个形状为(批量大小, 隐藏单元个数)的值为0的Tensor组成的元组。

python 复制代码

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

下面的rnn函数定义了在一个时间步里如何计算隐藏状态和输出。这里的激活函数使用了tanh函数。

python 复制代码

def rnn(inputs, state, params):
    # inputs和outputs皆为num_steps个形状为(batch_size, vocab_size)的Tensor
    W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    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 outputs, (H,)

做个简单的测试来观察输出结果的个数（时间步数），以及第一个时间步的输出层输出的形状和隐藏状态的形状。

python 复制代码

state = init_rnn_state(X.shape[0], num_hiddens, device)
inputs = to_onehot(X.to(device), vocab_size)
params = get_params()
outputs, state_new = rnn(inputs, state, params)
print(len(outputs), outputs[0].shape, state_new[0].shape)

输出

5 torch.Size([2, 1027]) torch.Size([2, 256])

定义预测函数

以下函数基于前缀prefix（含有数个字符的字符串）来预测接下来的num_chars个字符。

python 复制代码

def predict_rnn(prefix, num_chars, rnn, params, init_rnn_state,
                num_hiddens, vocab_size, device, idx_to_char, char_to_idx):
    state = init_rnn_state(1, num_hiddens, device)
    output = [char_to_idx[prefix[0]]]
    for t in range(num_chars + len(prefix) - 1):
        # 将上一时间步的输出作为当前时间步的输入
        X = to_onehot(torch.tensor([[output[-1]]], device=device), vocab_size)
        # 计算输出和更新隐藏状态
        (Y, state) = rnn(X, state, params)
        # 下一个时间步的输入是prefix里的字符或者当前的最佳预测字符
        if t < len(prefix) - 1:
            output.append(char_to_idx[prefix[t + 1]])
        else:
            output.append(int(Y[0].argmax(dim=1).item()))
    return ''.join([idx_to_char[i] for i in output])

我们先测试一下predict_rnn函数。我们将根据前缀"分开"创作长度为10个字符（不考虑前缀长度）的一段歌词。

python 复制代码

predict_rnn('分开', 10, rnn, params, init_rnn_state, num_hiddens, vocab_size,
            device, idx_to_char, char_to_idx)

输出

'分开难兵单养句烁狂舍晰闭'

裁剪梯度

循环神经网络中较容易出现梯度衰减或梯度爆炸。为了应对梯度爆炸，我们可以裁剪梯度（clip gradient）。假设我们把所有模型参数梯度的元素拼接成一个向量 g \boldsymbol{g} g，并设裁剪的阈值是 θ \theta θ。裁剪后的梯度

min ⁡ ( θ ∥ g ∥ , 1 ) g \min\left(\frac{\theta}{\|\boldsymbol{g}\|}, 1\right) \boldsymbol{g} min(∥g∥θ,1)g

的 L 2 L_2 L2 范数不超过 θ \theta θ。

python 复制代码

def grad_clipping(params, theta, device):
    norm = torch.tensor([0.0], device=device)
    for param in params:
        norm += (param.grad.data ** 2).sum()
    norm = norm.sqrt().item()
    if norm > theta:
        for param in params:
            param.grad.data *= (theta / norm)

困惑度

我们通常使用困惑度（perplexity）来评价语言模型的好坏。困惑度是对交叉熵损失函数做指数运算后得到的值。特别地，

最佳情况下，模型总是把标签类别的概率预测为1，此时困惑度为1；
最坏情况下，模型总是把标签类别的概率预测为0，此时困惑度为正无穷；
基线情况下，模型总是预测所有类别的概率都相同，此时困惑度为类别个数。

困惑度有两个等价的定义公式,两个公式是等价的,并且与前面我们所说的交叉熵损失函数为逆运算，困惑度的计算本质是以自然常数 e 为底数的指数运算：

公式一：基于交叉熵损失

困惑度 = exp(交叉熵损失)

Perplexity = exp ⁡ ( L ) \text{Perplexity} = \exp(L) Perplexity=exp(L)

其中 L L L 是平均交叉熵损失。

公式二：基于概率乘积

困惑度 = ∏ i = 1 N 1 P ( w i ∣ w 1 , ⋯ , w i − 1 ) N \sqrt[N]{\prod_{i=1}^N \frac{1}{P(w_i|w_1, \cdots, w_{i-1})}} N∏i=1NP(wi∣w1,⋯,wi−1)1

Perplexity = ( ∏ i = 1 N 1 P ( w i ∣ w 1 , ⋯ , w i − 1 ) ) 1 N \text{Perplexity} = \left( \prod_{i=1}^N \frac{1}{P(w_i|w_1, \cdots, w_{i-1})} \right)^{\frac{1}{N}} Perplexity=(i=1∏NP(wi∣w1,⋯,wi−1)1)N1

定义模型训练函数

跟之前章节的模型训练函数相比，这里的模型训练函数有以下几点不同：

使用困惑度评价模型。
在迭代模型参数前裁剪梯度。
对时序数据采用不同采样方法将导致隐藏状态初始化的不同。

python 复制代码

def data_iter_random(corpus_indices, batch_size, num_steps, device=None):
    # 减1是因为输出的索引是相应输入的索引加1
    num_examples = (len(corpus_indices) - 1) // num_steps
    epoch_size = num_examples // batch_size
    example_indices = list(range(num_examples))
    random.shuffle(example_indices)
    
    # 返回从pos开始的长为num_steps的序列
    def _data(pos):
        return corpus_indices[pos: pos + num_steps]
    
    for i in range(epoch_size):
        # 每次读取batch_size个随机样本
        i = i * batch_size
        batch_indices = example_indices[i: i + batch_size]
        X = [_data(j * num_steps) for j in batch_indices]
        Y = [_data(j * num_steps + 1) for j in batch_indices]
        yield torch.tensor(X, device=device), torch.tensor(Y, device=device)

def data_iter_consecutive(corpus_indices, batch_size, num_steps, device=None):
    corpus_indices = torch.tensor(corpus_indices, device=device)
    data_len = len(corpus_indices)
    batch_len = data_len // batch_size
    indices = corpus_indices[0: batch_size * batch_len].reshape(
        batch_size, batch_len)
    epoch_size = (batch_len - 1) // num_steps
    for i in range(epoch_size):
        i = i * num_steps
        X = indices[:, i: i + num_steps]
        Y = indices[:, i + 1: i + num_steps + 1]
        yield X, Y

def train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                          vocab_size, device, corpus_indices, idx_to_char,
                          char_to_idx, is_random_iter, num_epochs, num_steps,
                          lr, clipping_theta, batch_size, pred_period,
                          pred_len, prefixes):
    if is_random_iter:
        data_iter_fn = data_iter_random
    else:
        data_iter_fn = data_iter_consecutive
    params = get_params()
    loss = nn.CrossEntropyLoss()
    optimizer = optim.SGD(params, lr=lr)
    
    for epoch in range(num_epochs):
        if not is_random_iter:  # 如使用相邻采样，在epoch开始时初始化隐藏状态
            state = init_rnn_state(batch_size, num_hiddens, device)
        l_sum, n, start = 0.0, 0, time.time()
        data_iter = data_iter_fn(corpus_indices, batch_size, num_steps, device)
        for X, Y in data_iter:
            if is_random_iter:  # 如使用随机采样，在每个小批量更新前初始化隐藏状态
                state = init_rnn_state(batch_size, num_hiddens, device)
            else:  # 否则需要使用detach函数从计算图分离隐藏状态
                if isinstance(state, (tuple, list)):
                    for s in state:
                        s.detach_()
                else:
                    state.detach_()
            
            inputs = to_onehot(X, vocab_size)
            # outputs有num_steps个形状为(batch_size, vocab_size)的矩阵
            (outputs, state) = rnn(inputs, state, params)
            # 拼接之后形状为(num_steps * batch_size, vocab_size)
            outputs = torch.cat(outputs, dim=0)
            # Y的形状是(batch_size, num_steps)，转置后再变成长度为
            # batch * num_steps 的向量，这样跟输出的行一一对应
            y = Y.T.reshape(-1)
            
            # 使用交叉熵损失计算平均分类误差
            l = loss(outputs, y.long())
            
            optimizer.zero_grad()
            l.backward()
            grad_clipping(params, clipping_theta, device)  # 裁剪梯度
            optimizer.step()  # 因为误差已经取过均值，梯度不用再做平均
            
            l_sum += l.item() * y.numel()
            n += y.numel()
        
        if (epoch + 1) % pred_period == 0:
            print('epoch %d, perplexity %f, time %.2f sec' % (
                epoch + 1, math.exp(l_sum / n), time.time() - start))
            for prefix in prefixes:
                print(' -', predict_rnn(
                    prefix, pred_len, rnn, params, init_rnn_state,
                    num_hiddens, vocab_size, device, idx_to_char, char_to_idx))

代码注解：numel()：PyTorch 方法，返回张量中所有元素的总数

len()：Python 内置函数，对于张量只返回第一维的长度

在训练代码中：y.numel() 用于准确计算处理的样本总数，用于计算平均损失和困惑度

代码中在初始化时候的state，以及作为rnn训练后得到的state，注意两者的区别。

训练模型并创作歌词

现在我们可以训练模型了。首先，设置模型超参数。我们将根据前缀"分开"和"不分开"分别创作长度为50个字符（不考虑前缀长度）的一段歌词。我们每过50个迭代周期便根据当前训练的模型创作一段歌词。

python 复制代码

num_epochs, num_steps, batch_size, lr, clipping_theta = 250, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 50, 50, ['分开', '不分开']

下面采用随机采样训练模型并创作歌词。

python 复制代码

train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                      vocab_size, device, corpus_indices, idx_to_char,
                      char_to_idx, True, num_epochs, num_steps, lr,
                      clipping_theta, batch_size, pred_period, pred_len,
                      prefixes)

输出

epoch 50, perplexity 69.004720, time 0.05 sec

分开我不要再想你的爱你的让我疯狂的可爱女人坏坏的让我疯狂的可爱女人坏坏的让我疯狂的可爱女人坏坏

不分开我想要你爱我别子我有多的可爱女人坏坏的让我疯狂的可爱女人坏坏的让我疯狂的可爱女人坏坏的让

epoch 100, perplexity 10.726740, time 0.04 sec

分开一只在停落有话在旧载让我别你的事丽我说揍爱情我我想就这样牵你说这你再依倒我说散

不分开吗我只好的生写后知是你笑回我跟了这节奏后知是你在是我怎好球节奏后知是你在是玩我说

epoch 150, perplexity 2.922448, time 0.04 sec

分开一颗两停三一只盘满温一个人只大色蜡烛温暖了空屋白色蜡烛温暖了空屋白色蜡烛温暖了空屋

不分开期单后人空现你的躺美温暖村空屋白色蜡烛温暖了空屋白色蜡烛温暖了空屋白色蜡烛温暖了空

epoch 200, perplexity 1.623452, time 0.04 sec

分开一只令步心你的躺烛问后分好伤的梦娘子动的为入当一九四步三步四步望著天看星星一颗两颗

不分开扫把的胖女巫用拉丁文念咒语啦啦呜她养的黑猫笑起来像哭啦啦啦呜在场村外的溪边传绪激待一颗心

epoch 250, perplexity 1.410600, time 0.04 sec

分开一只令一步两步三步四步望著天看星星一颗两颗三颗四颗连成线一著背默荡在蓝安排的雨随时准备

不分开扫我叫你爸你打我妈这样对吗干嘛这样何必让酒牵鼻子走瞎说不睡痛对我甩散线口让我选你这种

接下来采用相邻采样训练模型并创作歌词。

python 复制代码

train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                      vocab_size, device, corpus_indices, idx_to_char,
                      char_to_idx, False, num_epochs, num_steps, lr,
                      clipping_theta, batch_size, pred_period, pred_len,
                      prefixes)

输出

epoch 50, perplexity 56.893596, time 0.04 sec

分开我想要这你来了空不要了我不要的可爱女人坏坏的让我疯狂的可爱女人坏坏的让我疯狂的可爱女人

不分开我想要你你我的外如果的可在人的可在果的可在人的可在人的可在人的可在人的可在人的可

epoch 100, perplexity 6.416500, time 0.04 sec

分开我已要这样你不我不我不要再想你爱情我的见快就像龙卷风不的世旧已狂的暴力我不能再想我

不分开柳你样经离的溪边河默默默等著我娘子依旧每日折一枝杨柳你在那里在小村外的溪边默默有话是很听

epoch 150, perplexity 1.992987, time 0.04 sec

分开我已要这样活我爱你你的直是我妈想想想多我知道这里很美但家乡的你更美走过了很多地方我来到伊斯

不分开觉你已经离开我不知不觉我跟了这节奏后知后觉又过了一个秋后知后觉我该好好生活我该好好生

epoch 200, perplexity 1.295328, time 0.04 sec

分开我对多这样活你说你你不都连隔悄邻球默猜开我现在的感受河边的风在吹着头发飘动牵着你的手一

不分开觉你已经离开我不知不觉我跟了这节奏后知后觉又过了一个秋后知后觉我该好好生活我该好好生

epoch 250, perplexity 1.146049, time 0.04 sec

分开问候的风猫下去来的画面落义的猪许消过的外我已无的可爱女人坏坏的让我疯狂的可爱女人坏坏的让我疯

不分开觉你已经离开我后知不觉我跟了这节奏后知后觉后知后觉迷迷蒙蒙你给的梦出现裂缝隐隐作痛

小结

可以用基于字符级循环神经网络的语言模型来生成文本序列，例如创作歌词。
当训练循环神经网络时，为了应对梯度爆炸，可以裁剪梯度。
困惑度是对交叉熵损失函数做指数运算后得到的值。