语言模型
什么是语言模型?给定一个长度为
T
T
T的词的序列
x
1
,
x
2
,
⋯
,
x
T
x_1,x_2,\cdots,x_T
x1,x2,⋯,xT,语言模型的目标就是就是评估改序列是否合理,即计算序列的概率:
P
(
x
1
,
x
2
,
⋯
,
x
T
)
.
P(x_1,x_2,\cdots,x_T).
P(x1,x2,⋯,xT).
概率越大,合理性越高。本节课介绍基于统计的语言模型,主要是 n n n元语法(n-gram)。
假设序列
x
1
,
x
2
,
⋯
,
x
T
x_1,x_2,\cdots,x_T
x1,x2,⋯,xT中每个词是依次生成的,那么序列生成的概率为
P
(
x
1
,
x
2
,
⋯
,
x
T
)
=
∏
t
=
1
T
P
(
x
t
∣
x
1
,
⋯
,
x
t
−
1
)
P(x_1,x_2,\cdots,x_T)=\prod_{t=1}^TP(x_t|x_1,\cdots,x_{t-1})
P(x1,x2,⋯,xT)=t=1∏TP(xt∣x1,⋯,xt−1)
第一项表示
x
1
x_1
x1这个词出现的概率,后面的项表示在前面出现
x
1
,
⋯
,
x
i
x_1,\cdots,x_i
x1,⋯,xi这些词的情况下,下一项出现
x
i
+
1
x_{i+1}
xi+1的可能性,因此为条件概率。
词的概率可以通过该词在训练数据集中的相对词频来计算,例如,
x
1
x_1
x1的概率可以计算为:
P
^
(
x
1
)
=
n
(
x
1
)
n
\hat{P}(x_1)=\frac{n(x_1)}{n}
P^(x1)=nn(x1)
其中 n ( x 1 ) n(x_1) n(x1)为语料库中以 x 1 x_1 x1作为第一个词的文本数量, n n n为语料库中文本总数。
条件概率的计算公式为(以
x
1
x_1
x1为例):
P
^
(
x
2
∣
x
1
)
=
n
(
x
1
,
x
2
)
n
(
x
1
)
.
\hat{P}(x_2|x_1)=\frac{n(x_1,x_2)}{n(x_1)}.
P^(x2∣x1)=n(x1)n(x1,x2).
n元语法
序列长度增加,计算和存储多个词共同出现的概率的复杂度会呈指数级增加。因此这里提出了马尔可夫链的概念,假设后一个词的出现只与前 n n n个词相关,称为 n n n阶马尔科夫链。基于 n − 1 n-1 n−1阶马尔科夫链的概率语言模型也叫 n n n元语法。当n较小时,n元语法往往并不准确。例如,在一元语法中,由三个词组成的句子“你走先”和“你先走”的概率是一样的。然而,当n较大时,n元语法需要计算并存储大量的词频和多词相邻频率。
n元语法的缺陷:
- 参数空间过大。例如字典大小为 V V V,序列长度为 T T T,那么需要计算的参数为 V + V 2 + V 3 V+V^2+V^3 V+V2+V3。
- 数据稀疏。齐夫定律说明大部分词的词频很小,甚至不会在语料库里出现,因此对这些词概率的估计都不准确,而且频率较高的词通常是一些连接词,这些词会有大量的组合,但这些组合根本不会出现,因此都是0,从而使得数据稀疏。齐夫定律:在自然语言的语料库里,一个单词出现的频率与它在频率表里的排名成反比。
语言模型数据集
读取数据集
# 读取数据,输出长度和前40个字符
with open('/home/kesci/input/jaychou_lyrics4703/jaychou_lyrics.txt') as f:
corpus_chars = f.read()
print(len(corpus_chars))
print(corpus_chars[: 40])
# 将换行符和回车符全部用空格代替
corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ')
# 只取前10000个字符
corpus_chars = corpus_chars[: 10000]
output:
63282
想要有直升机
想要和你飞到宇宙去
想要和你融化在一起
融化在宇宙里
我每天每天每
建立字符索引
# set去重,得到索引到字符的映射
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)
print(vocab_size)
corpus_indices = [char_to_idx[char] for char in corpus_chars] # 将每个字符转化为索引,得到一个索引的序列
sample = corpus_indices[: 20]
# join()函数,这里以空格作为分隔符
print('chars:', ''.join([idx_to_char[idx] for idx in sample]))
print('indices:', sample)
- set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
x = set('runoob')
y = set('google')
print(x)
print(y)
print(x & y) # 交集
print(x | y) # 并集
print(x - y) # 差集
output:
{'b', 'r', 'u', 'o', 'n'}
{'e', 'o', 'g', 'l'}
{'o'}
{'l', 'b', 'r', 'u', 'g', 'e', 'o', 'n'}
{'b', 'u', 'n', 'r'}
- join()函数:连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串。
a = 'You are my friend'
b = ''.join(a)
c = '-'.join(a)
print(b)
print(c)
output:
You are my friend
Y-o-u- -a-r-e- -m-y- -f-r-i-e-n-d
时序数据的采样
在训练中我们需要每次随机读取小批量样本和标签。与之前章节的实验数据不同的是,时序数据的一个样本通常包含连续的字符。假设时间步数为5,样本序列为5个字符,即“想”“要”“有”“直”“升”。该样本的标签序列为这些字符分别在训练集中的下一个字符,即“要”“有”“直”“升”“机”,即 X X X =“想要有直升”, Y Y Y =“要有直升机”。
如果序列的长度为 T T T ,时间步数为 n n n ,那么一共有 T − n T−n T−n 个合法的样本,但是这些样本有大量的重合,我们通常采用更加高效的采样方式。我们有两种方式对时序数据进行采样,分别是随机采样和相邻采样。
随机采样
下面的代码每次从数据里随机采样一个小批量。其中批量大小batch_size是每个小批量的样本数,num_steps是每个样本所包含的时间步数。 在随机采样中,每个样本是原始序列上任意截取的一段序列,相邻的两个随机小批量在原始序列上的位置不一定相毗邻。
随机采样示意图:
代码展示:
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)
my_seq = list(range(30))
for X, Y in data_iter_random(my_seq, batch_size=2, num_steps=6):
print('X: ', X, '\nY:', Y, '\n')
output:
X: tensor([[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17]])
Y: tensor([[ 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18]])
X: tensor([[ 0, 1, 2, 3, 4, 5],
[18, 19, 20, 21, 22, 23]])
Y: tensor([[ 1, 2, 3, 4, 5, 6],
[19, 20, 21, 22, 23, 24]])
神经网络输入都是文本字符在语料库中的索引。
相邻采样
在相邻采样中,相邻的两个随机小批量在原始序列上的位置相毗邻。
相邻采样示例:
代码展示:
ef 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
for X, Y in data_iter_consecutive(my_seq, batch_size=2, num_steps=6):
print('X: ', X, '\nY:', Y, '\n')
output:
X: tensor([[ 0, 1, 2, 3, 4, 5],
[15, 16, 17, 18, 19, 20]])
Y: tensor([[ 1, 2, 3, 4, 5, 6],
[16, 17, 18, 19, 20, 21]])
X: tensor([[ 6, 7, 8, 9, 10, 11],
[21, 22, 23, 24, 25, 26]])
Y: tensor([[ 7, 8, 9, 10, 11, 12],
[22, 23, 24, 25, 26, 27]])