深度学习02-N-gram语言模型

理论基础

什么是语言模型

一段自然语言文本可以看作是一个给定一个长度为$T$的词的离散时间序列$w_1, w_2, \ldots, w_T$,这就是语言模型.语言模型的目标就是评估该序列是否合理，即计算该序列的概率：

$P(w_1, w_2, \ldots, w_T).$

数学表示 - Chain Rule

假设序列$w_1, w_2, \ldots, w_T$中的每个词是依次生成的，则有：

$\begin{aligned} P(w_1, w_2, \ldots, w_T) &= \prod_{t=1}^T P(w_t \mid w_1, \ldots, w_{t-1})\\ &= P(w_1)·P(w_2 \mid w_1)·P(w_3 \mid w_{1}^{2}) \cdots P(w_T \mid w_{1}^{T-1}) \end{aligned}$

其中，$w_{1}^{k}$表示从第$1$个到第$k$个词构成的词串。

语言模型的参数就是词的概率以及给定前几个词情况下的条件概率。假设训练数据集为一个大型文本语料库，根据大数定理，词的概率可以通过该词在训练数据集中的相对词频来计算，这样，$w_k$的概率可以计算为：

$p(w_{k} \mid w_{1}^{k-1})= \frac{p(w_{1}^{k})}{p(w_{1}^{k-1})}\approx \frac{count(w_{1}^{k})}{count(w_{1}^{k-1})}$

其中$count(w_{1}^{k-1})$表示词串$w_{1}^{k}$在语料中出现的次数。

可见，随着序列长度增加，计算和存储多个词共同出现的概率的复杂度会呈指数级增加。解决这一问题，需要引入马尔可夫假设。

马尔可夫假设与$N$-Gram

马尔科夫假设是指一个词的出现只与前面$n$个词相关，这样一来，上式可以改写为：

$P(w_{k}\mid w_{1}^{k-1}) \approx P(w_{k}\mid w_{k-n+1}^{k-1}) \approx \frac{count(w_{1}^{k})}{count(w_{k-n+1}^{k-1})}$

以上也叫$N$元语法（$N$-Gram），它是基于$n-1$阶马尔可夫链的概率语言模型。

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

$\begin{aligned} 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{aligned}$

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

$N$-Gram模型的实践

对于参数$n$的选取，要考虑计算复杂度和模型效果两方面

1. 计算复杂度：由于参数的个数是$N + N^{2} + \cdots + N^{n}$个，很明显，$n$越大，计算复杂度将呈指数级增大；
2. 模型效果：理论上$n$是越大越好，但是$n$越大的时候，模型效果提升幅度就会越小。例如$n$从3到4的效果提升可能就远比不上从$2$到$3$的效果提升。

因此，实际工作中，最多的情况是取$n=3$。

此外，还需要考虑到数据稀疏的问题：在文本中经常出现的现象是，有些词出现的频率很低，但是很重要，有些词（如“的”、“和”）出现次数很多，但不重要。假如重要的词串在统计时计数为$0$，即$count(w_{k-n+1}^{k-1})=0$，我们并不能认为$P(w_{k}\mid w_{1}^{k-1})=0$，否则会导致连乘的时候，整个词串的概率都为$0$，这时需要考虑使用『平滑化』。

概率模型函数化

通常构造的目标函数是『最大似然函数』

$\prod_{w\in C} p(w|Context(w))$

其中

• $C$是语料库(Corpus)
• $Context(w)$是词$w$的上下文(Context)，对于N-gram来说，$Context(w_i)=w_{i-n+1}^{i-1}$

实际上由于连乘可能导致概率极小，所以经常采用的是『最大对数似然』，即目标函数为：

$\mathcal{L}=\sum_{w\in C}log \, p(w|Context(w)) \\ 将条件概率p(w|Context(w))视为关于w和Context(w)的函数 \\ = \sum_{w\in C}log \, F(w,Context(w),\theta)$

其中是$\theta$待定参数集。因此一旦对上式进行优化得到最优参数集$\theta^*$之后，$F$也就唯一确定。如果选取合适的方法来构造函数$F$，可以使得$\theta$中参数的个数远小于N-gram模型中参数的个数。

动手实践 - 预处理语言模型数据集

数据集（点击查看下载）是周杰伦从第一张专辑《Jay》到第十张专辑《跨时代》中的歌词，这里将其转换成字符级循环神经网络所需要的输入格式，之后将用于循环神经网络来训练一个语言模型。

读取数据与字符索引

python

deeplearning_02.pyview raw

def load_data_jay_lyrics():
    # 读取数据集
    with open('../jaychou_lyrics.txt') as f:
        corpus_chars = f.read()
    corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ')
    corpus_chars = corpus_chars[0:10000]
    # 建立字符索引
    idx_to_char = list(set(corpus_chars))  # 去重，得到索引到字符的映射
    char_to_idx = dict([(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

时序数据的采样

在训练时需要每次随机读取小批量样本和标签。注意，时序数据的一个样本通常包含连续的字符，而样本的标签序列为这些字符分别在训练集中的下一个字符。
以如下序列为例，假设时间步数为5，有以下可能的样本和标签：

想要有直升机，想要和你飞到宇宙去

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

可见，如果序列的长度为$T$，时间步数为$n$，那么一共有$T-n$个合法的样本。但是这些样本有大量的重合，通常采用随机采样或相邻采样来对时序数据进行采样。

随机采样

下面的代码每次从数据里随机采样一个小批量。其中批量大小batch_size指每个小批量的样本数，num_steps为每个样本所包含的时间步数。 在随机采样中，每个样本是原始序列上任意截取的一段序列。相邻的两个随机小批量在原始序列上的位置不一定相毗邻。因此，无法用一个小批量最终时间步的隐藏状态来初始化下一个小批量的隐藏状态。在训练模型时，每次随机采样前都需要重新初始化隐藏状态。

python

deeplearning_02.pyview raw

import torch
import random
def data_iter_random(corpus_indices, batch_size, num_steps, device=None):
    # 减1是因为对于长度为n的序列，X最多只有包含其中的前n - 1个字符
    num_examples = (len(corpus_indices) - 1) // num_steps  # 下取整，得到不重叠情况下的样本个数
    example_indices = [i * num_steps for i in range(num_examples)]  # 每个样本的第一个字符在corpus_indices中的下标
    random.shuffle(example_indices)

    def _data(i):
        # 返回从i开始的长为num_steps的序列
        return corpus_indices[i: i + num_steps]
    if device is None:
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    for i in range(0, num_examples, batch_size):
        # 每次选出batch_size个随机样本
        batch_indices = example_indices[i: i + batch_size]  # 当前batch的各个样本的首字符的下标
        X = [_data(j) for j in batch_indices]
        Y = [_data(j + 1) for j in batch_indices]
        yield torch.tensor(X, device=device), torch.tensor(Y, device=device)

相邻采样

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

python

deeplearning_02.pyview raw

def data_iter_consecutive(corpus_indices, batch_size, num_steps, device=None):
    if device is None:
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    corpus_len = len(corpus_indices) // batch_size * batch_size  # 保留下来的序列的长度
    corpus_indices = corpus_indices[: corpus_len]  # 仅保留前corpus_len个字符
    indices = torch.tensor(corpus_indices, device=device)
    indices = indices.view(batch_size, -1)  # resize成(batch_size, )
    batch_num = (indices.shape[1] - 1) // num_steps
    for i in range(batch_num):
        i = i * num_steps
        X = indices[:, i: i + num_steps]
        Y = indices[:, i + 1: i + num_steps + 1]
        yield X, Y

采样测试

这里构造一个数字序列，设置batch_size=2, num_steps=6来测试上述采样代码

python

deeplearning_02.pyview raw

test_seq = list(range(100))
for X, Y in data_iter_random(test_seq, batch_size=2, num_steps=6):
    print('随机采样测试:', '\nX: ', X, '\nY:', Y, '\n')
for X, Y in data_iter_consecutive(test_seq, batch_size=2, num_steps=6):
    print('相邻采样测试:', '\nX: ', X, '\nY:', Y, '\n')

随机采样测试：
X: tensor([[78, 79, 80, 81, 82, 83], [72, 73, 74, 75, 76, 77]])
Y: tensor([[79, 80, 81, 82, 83, 84], [73, 74, 75, 76, 77, 78]])
X: tensor([[18, 19, 20, 21, 22, 23], [36, 37, 38, 39, 40, 41]])
Y: tensor([[19, 20, 21, 22, 23, 24], [37, 38, 39, 40, 41, 42]])
X: tensor([[ 0, 1, 2, 3, 4, 5], [84, 85, 86, 87, 88, 89]])
Y: tensor([[ 1, 2, 3, 4, 5, 6], [85, 86, 87, 88, 89, 90]])
…
X: tensor([[48, 49, 50, 51, 52, 53], [42, 43, 44, 45, 46, 47]])
Y: tensor([[49, 50, 51, 52, 53, 54], [43, 44, 45, 46, 47, 48]])

相邻采样测试：
X: tensor([[ 0, 1, 2, 3, 4, 5], [50, 51, 52, 53, 54, 55]])
Y: tensor([[ 1, 2, 3, 4, 5, 6], [51, 52, 53, 54, 55, 56]])
X: tensor([[ 6, 7, 8, 9, 10, 11], [56, 57, 58, 59, 60, 61]])
Y: tensor([[ 7, 8, 9, 10, 11, 12], [57, 58, 59, 60, 61, 62]])
…
X: tensor([[42, 43, 44, 45, 46, 47], [92, 93, 94, 95, 96, 97]])
Y: tensor([[43, 44, 45, 46, 47, 48], [93, 94, 95, 96, 97, 98]])

总结

图中每个框的宽度代表num_steps,每一个小框（颜色相同）代表一个样本，batch_size个样本组成一个batch。