《动手学深度学习》-学习笔记task20. 学习任务1. 文本预处理2. 语言模型3. 循环神经网络4. 疑问与解决方案5. 参考链接：

0. 学习任务

文本预处理、语言模型与数据集、循环神经网络

1. 文本预处理

文本预处理通常包括四个步骤：

1. 读入文本
2. 分词
3. 建立字典，将每个词映射到一个唯一的索引（index）
4. 将文本从词的序列转换为索引的序列，方便输入模型

1.1 读入文本

def read_time_machine():
    with open('/Users/janti/Boyu/0-DeepLearning/input/timemachine7163/timemachine.txt', 'r') as f:
        lines = [re.sub('[^a-z]+', ' ', line.strip().lower()) for line in f]      # re.sub 正则化   
    return lines

核心代码解析：

 lines = [re.sub('[^a-z]+', ' ', line.strip().lower()) for line in f] 

这句话的是：先将句子中的首尾空格去掉 (line.strip())，并将所有字符转为小写(lower())，然后用空格去替换非a到z([^a-z]))的字符。
比如：

" % I shouldn’t go to school ! % "

1. 执行line.strip() 后，变为 “% I shouldn’t go to school ! %”
2. 执行line.strip().lower() 后，变为 “% i shouldn’t go to school ! %”
3. re.sub(’[^a-z] +’, ’ ‘, sents) : 指将sents中的非 a-z 替换成空格（’ '）；变为 " i shouldn t go to school "

1.2 建立字典

为了方便模型处理，我们需要将字符串转换为数字，将每个词映射到一个唯一的索引编号。
建立字典的步骤：

1. 统计词频并去重
2. 处理特殊tokens ：padding, begin of sentence, end of sentence, unknown
3. 构建一个list列表，建立index to token，用列表的下标表示index
4. 将lists转为dict，从而 实现token to index，实现 每个词映射到一个唯一的索引编号。

class Vocab(object):
    def __init__(self, tokens, min_freq=0, use_special_tokens=False):
        counter = count_corpus(tokens)  # : 
        self.token_freqs = list(counter.items())
        self.idx_to_token = []   #设置一个list 
        if use_special_tokens:
            # padding, begin of sentence, end of sentence, unknown
            self.pad, self.bos, self.eos, self.unk = (0, 1, 2, 3)  # 特殊字符的索引编号
            self.idx_to_token += ['<pad>', '<bos>', '<eos>', '<unk>']  # 这里面表示上面所示的四种特殊字符放在字典的前四个位置 index为0，1，2，3
        else:
            self.unk = 0
            self.idx_to_token += ['unk']
        self.idx_to_token += [token for token, freq in self.token_freqs 
                        if freq >= min_freq and token not in self.idx_to_token]  # 设置min_freq 是为了过滤掉极少出现的字符
        self.token_to_idx = dict()
        for idx, token in enumerate(self.idx_to_token):
            self.token_to_idx[token] = idx
    
    
    def __len__(self):
        return len(self.idx_to_token)

    def __getitem__(self, tokens):
        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):
        if not isinstance(indices, (list, tuple)):
            return self.idx_to_token[indices]
        return [self.idx_to_token[index] for index in indices]

def count_corpus(sentences):
    tokens = [tk for st in sentences for tk in st]   # 这里面的st怎么理解？  次序为啥要这样？ 比如 [tk for tk in st for st in sentences]
    return collections.Counter(tokens)  # 返回一个字典，记录每个词的出现次数

2. 语言模型

假设序列$w_1,w_2,\dots ,w_T$中的每个词是依次生成的，我们有

例如，一段含有4个词的文本序列的概率

$$P(w_1,w_2,w_3,w_4)=P(w_1)P(w_2\mid w_1)P(w_3\mid w_1,w_2)P(w_4\mid w_1,w_2,w_3).$$

语言模型的参数就是词的概率以及给定前几个词情况下的条件概率。设训练数据集为一个大型文本语料库，如维基百科的所有条目，词的概率可以通过该词在训练数据集中的相对词频来计算，例如，$w_1$的概率可以计算为：

$$\hat{P}(w_1)=\frac{n(w_1)}{n}$$

其中$n(w_1)$为语料库中以$w_1$作为第一个词的文本的数量，$n$为语料库中文本的总数量。

类似的，给定$w_1$情况下，$w_2$的条件概率可以计算为：

$$\hat{P}(w_2\mid w_1)=\frac{n(w_1,w_2)}{n(w_1)}$$

其中$n(w_1,w_2)$为语料库中以$w_1$作为第一个词，$w_2$作为第二个词的文本的数量。

2.1 n 元语法

序列长度增加，计算和存储多个词共同出现的概率的复杂度会呈指数级增加。$n$元语法通过马尔可夫假设简化模型，马尔科夫假设是指一个词的出现只与前面$n$个词相关，即$n$阶马尔可夫链（Markov chain of order $n$），如果$n=1$，那么有$P(w_3\mid w_1,w_2)=P(w_3\mid w_2)$。基于$n-1$阶马尔可夫链，我们可以将语言模型改写为

$$P(w_1,w_2,\dots ,w_T)=\prod _{t=1}^{T}P(w_t\mid w_{t-(n-1)},\dots ,w_{t-1}).$$

以上也叫$n$元语法（$n$-grams），它是基于$n-1$阶马尔可夫链的概率语言模型。例如，当$n=2$时，含有4个词的文本序列的概率就可以改写为：

当$n$分别为1、2和3时，我们将其分别称作一元语法（unigram）、二元语法（bigram）和三元语法（trigram）。例如，长度为4的序列$w_1,w_2,w_3,w_4$在一元语法、二元语法和三元语法中的概率分别为

$$\begin{array}{rl}P(w_1,w_2,w_3,w_4)& =P(w_1)P(w_2)P(w_3)P(w_4),\\ P(w_1,w_2,w_3,w_4)& =P(w_1)P(w_2\mid w_1)P(w_3\mid w_2)P(w_4\mid w_3),\\ P(w_1,w_2,w_3,w_4)& =P(w_1)P(w_2\mid w_1)P(w_3\mid w_1,w_2)P(w_4\mid w_2,w_3).\end{array}$$

当$n$较小时，$n$元语法往往并不准确。例如，在一元语法中，由三个词组成的句子“你走先”和“你先走”的概率是一样的。然而，当$n$较大时，$n$元语法需要计算并存储大量的词频和多词相邻频率。

2.2 时序数据的采样

在训练中我们需要每次随机读取小批量样本和标签。与之前章节的实验数据不同的是，时序数据的一个样本通常包含连续的字符。假设时间步数为5，样本序列为5个字符，即“想”“要”“有”“直”“升”。该样本的标签序列为这些字符分别在训练集中的下一个字符，即“要”“有”“直”“升”“机”，即$X$=“想要有直升”，$Y$=“要有直升机”。

现在我们考虑序列“想要有直升机，想要和你飞到宇宙去”，如果时间步数为5，有以下可能的样本和标签：

• $X$：“想要有直升”，$Y$：“要有直升机”
• $X$：“要有直升机”，$Y$：“有直升机，”
• $X$：“有直升机，”，$Y$：“直升机，想”
• …
• $X$：“要和你飞到”，$Y$：“和你飞到宇”
• $X$：“和你飞到宇”，$Y$：“你飞到宇宙”
• $X$：“你飞到宇宙”，$Y$：“飞到宇宙去”

可以看到，如果序列的长度为$T$，时间步数为$n$，那么一共有$T-n$个合法的样本，但是这些样本有大量的重合，我们通常采用更加高效的采样方式。我们有两种方式对时序数据进行采样，分别是随机采样和相邻采样。

2.2.1 随机采样

下面的代码每次从数据里随机采样一个小批量。其中批量大小batch_size是每个小批量的样本数，num_steps是每个样本所包含的时间步数。
在随机采样中，每个样本是原始序列上任意截取的一段序列，相邻的两个随机小批量在原始序列上的位置不一定相毗邻。

2.2.2 相邻采样

在相邻采样中，相邻的两个随机小批量在原始序列上的位置相毗邻。

3. 循环神经网络

本节介绍循环神经网络，下图展示了如何基于循环神经网络实现语言模型。我们的目的是基于当前的输入与过去的输入序列，预测序列的下一个字符。循环神经网络引入一个隐藏变量$H$，用$H_t$表示$H$在时间步$t$的值。$H_t$的计算基于$X_t$和$H_{t-1}$，可以认为$H_t$记录了到当前字符为止的序列信息，利用$H_t$对序列的下一个字符进行预测。

3.1 循环神经网络的构造

我们先看循环神经网络的具体构造。假设${\mathbf{X}}_t\in {\mathbb{R}}^{n\times d}$是时间步$t$的小批量输入，${\mathbf{H}}_t\in {\mathbb{R}}^{n\times h}$是该时间步的隐藏变量，则：

$${\mathbf{H}}_t=\varphi ({\mathbf{X}}_t{\mathbf{W}}_{xh}+{\mathbf{H}}_{t-1}{\mathbf{W}}_{hh}+{\mathbf{b}}_h).$$
备注： ${\mathbb{R}}^{n\times d}$中的n为批量大小， d 为向量长度。

其中，${\mathbf{W}}_{xh}\in {\mathbb{R}}^{d\times h}$，${\mathbf{W}}_{hh}\in {\mathbb{R}}^{h\times h}$，${\mathbf{b}}_h\in {\mathbb{R}}^{1\times h}$，$\varphi$函数是非线性激活函数。由于引入了${\mathbf{H}}_{t-1}{\mathbf{W}}_{hh}$，$H_t$能够捕捉截至当前时间步的序列的历史信息，就像是神经网络当前时间步的状态或记忆一样。由于$H_t$的计算基于$H_{t-1}$，上式的计算是循环的，使用循环计算的网络即循环神经网络（recurrent neural network）。

在时间步$t$，输出层的输出为：

$${\mathbf{O}}_t={\mathbf{H}}_t{\mathbf{W}}_{hq}+{\mathbf{b}}_q.$$

其中${\mathbf{W}}_{hq}\in {\mathbb{R}}^{h\times q}$，${\mathbf{b}}_q\in {\mathbb{R}}^{1\times q}$。

3.2 循环神经网络代码实现

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

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

3.2.1 裁剪梯度

循环神经网络中较容易出现梯度衰减或梯度爆炸，这会导致网络几乎无法训练。裁剪梯度（clip gradient）是一种应对梯度爆炸的方法。假设我们把所有模型参数的梯度拼接成一个向量 $\mathbf{g}$，并设裁剪的阈值是$\theta$。裁剪后的梯度

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

的$L_2$范数不超过$\theta$。

例题：关于梯度裁剪描述错误的是： （D）

• A. 梯度裁剪之后的梯度小于或者等于原梯度
• B. 梯度裁剪是应对梯度爆炸的一种方法
• C. 裁剪之后的梯度L2范数小于阈值$\theta \theta$
• D. 梯度裁剪也是应对梯度消失的一种方法

梯度裁剪只能应对梯度爆炸。

代码实现：

def grad_clipping(params, theta, device):
    norm = torch.tensor([0.0], device=device)  #L2 范数，初始值为0
    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)

3.2.2 困惑度

我们通常使用困惑度（perplexity）来评价语言模型的好坏。回忆一下“softmax回归”一节中交叉熵损失函数的定义。困惑度是对交叉熵损失函数做指数运算后得到的值。特别地，

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

显然，任何一个有效模型的困惑度必须小于类别个数。在本例中，困惑度必须小于词典大小vocab_size。

一个随机分类模型（基线模型）的困惑度等于分类问题的类别个数，有效模型的困惑度应小于类别个数。

3.2.3 具体代码实现

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 = d2l.data_iter_random
    else:
        data_iter_fn = d2l.data_iter_consecutive
    params = get_params()
    loss = nn.CrossEntropyLoss()

    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函数从计算图分离隐藏状态
                for s in state:
                    s.detach_()
            # inputs是num_steps个形状为(batch_size, vocab_size)的矩阵
            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)，转置后再变成形状为
            # (num_steps * batch_size,)的向量，这样跟输出的行一一对应
            y = torch.flatten(Y.T)
            # 使用交叉熵损失计算平均分类误差
            l = loss(outputs, y.long())
            
            #反向传播
            # 梯度清0
            if params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
            l.backward()
            grad_clipping(params, clipping_theta, device)  # 裁剪梯度
            d2l.sgd(params, lr, 1)  # 因为误差已经取过均值，梯度不用再做平均
            l_sum += l.item() * y.shape[0]
            n += y.shape[0]

        # 训练过程中输出一些loss信息    
        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))

• 采用相邻采样仅在每个训练周期开始的时候初始化隐藏状态是因为相邻的两个批量在原始数据上是连续的
• 采用随机采样需要在每个小批量更新前初始化隐藏状态是因为随机采样中每个样本只包含局部的时间序列信息，由于样本不完整所以每个批量需要重新初始化隐藏状态

4. 疑问与解决方案

4.1 无法正确读取中文文本

遇到的问题：

'gbk' codec can't decode byte 0xa6 in position 4： illegal multibyte sequence

解决方法：
读取文件时添加encoding方式：
也就是将

with open('/Users/janti/Boyu/0-DeepLearning/input/jaychou_lyrics4703/jaychou_lyrics.txt') as f:
    corpus_chars = f.read()

改为：

with open('/Users/janti/Boyu/0-DeepLearning/input/jaychou_lyrics4703/jaychou_lyrics.txt',encoding='utf-8') as f:
    corpus_chars = f.read()

参考链接： 如何一劳永逸的解决UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xaf in position 60: illegal multibyte sequence问题

4.2 n元语法可能有哪些缺陷？

1. 参数空间过大
   若是三元语法，那么需要维护 $p(w1)p(w2|w1)p(w3|w1w2)$
   若字典大小为V，则需要的参数有 $V+V^2+V^3$, 指数增长，所以参数空间很大

2. 数据稀疏
   由于有很多词的组合方式，出现次数极少，词频较低，该词组组合概率概率会接近0，所以矩阵会非常稀少

4.3 如何理解梯度裁剪后不超过 $\theta$

也就是求证：
$$\Vert \min \left(\frac{\mathbf{\theta }}{\Vert \mathbf{g}\Vert },1\right)\mathbf{g}\Vert <=\theta$$
分类讨论：
（1）当 $\frac{\theta }{\Vert \mathbf{g}\Vert }>1$ 时，
$$\Vert \min \left(\frac{\mathbf{\theta }}{\Vert \mathbf{g}\Vert },1\right)\mathbf{g}\Vert =\Vert \mathbf{g}\Vert <\theta$$
(2) 当 $\frac{\theta }{\Vert \mathbf{g}\Vert }<=1$ 时,
$$\Vert \min \left(\frac{\mathbf{\theta }}{\Vert \mathbf{g}\Vert },1\right)\mathbf{g}\Vert =\Vert \frac{\mathbf{\theta }}{\Vert \mathbf{g}\Vert }\mathbf{g}\Vert =\frac{\theta }{\Vert \mathbf{g}\Vert }\Vert \mathbf{g}\Vert =\theta$$
**所以梯度裁剪后不超过 $\theta$ **

5. 参考链接：

[1] https://www.jianshu.com/p/e68193d3d998
[2] https://blog.csdn.net/rocling/article/details/90290576
[3] https://github.com/ShusenTang/Dive-into-DL-PyTorch

最后

以上就是会撒娇咖啡豆为你收集整理的《动手学深度学习》-学习笔记task20. 学习任务1. 文本预处理2. 语言模型3. 循环神经网络4. 疑问与解决方案5. 参考链接：的全部内容，希望文章能够帮你解决《动手学深度学习》-学习笔记task20. 学习任务1. 文本预处理2. 语言模型3. 循环神经网络4. 疑问与解决方案5. 参考链接：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。