(一)语言模型
给定一个文本序列，语言模型的目标就是估计联合概率密度
他的应用包括：
- 做预训练的模型（BERT, GPT-3）
- 生成文本，给定几个词，不断的使用
~
来生成后续文本
- 判断多个序列中哪个序列更常见。例如输入法的联想词。
(1)使用计数来建模
假设有一个长度为2的序列，我们来求他的联合概率密度。
（这里n是总词数，n(x)、n(x,x')，是单个单词和连续单词对出现的次数。）
同理也可以拓展到序列为3的情况：
缺点：当序列非常长的时候，可能这个长序列出现的次数不足为1.
可以使用马尔可夫假设来缓解这个问题。
(2)马尔科夫假设（N元语法）
假设和预测值前面的n个元素相关，可以处理较长序列。
-
一元语法
-
二元语法
-
三元语法
（二）代码实现
N元语法的实现和常用数据集。
import random
import torch
import re
from d2l import torch as d2l
def read_time_machine():
"""将时间机器科幻小说加载到文本行列表中"""
with open("../data/timemachine.txt",'r') as f:
lines = f.readlines()
return [re.sub('[^A-Za-z]+',' ', line).strip().lower() for line in lines] # strip去掉左右两边的特殊字符串
tokens = d2l.tokenize(read_time_machine()) # 二维数组，一行一行读取内容
corpus = [token for line in tokens for token in line] # 一维数组，小说中的每一个单词
vocab = d2l.Vocab(corpus) # 统计每个词出现的次数，及映射关系
print(vocab.token_freqs[:10])
# 可视化词频
freqs = [freq for token, freq in vocab.token_freqs]
d2l.plot(freqs, xlabel='token: x', ylabel='frequency: n(x)',
xscale='log', yscale='log')
# 其他的词元组合，比如二元组合，三元语法等
# 二元
bigram_tokens = [pair for pair in zip(corpus[:-1],corpus[1:])] # 优雅
bigram_vocab = d2l.Vocab(bigram_tokens)
print(bigram_vocab.token_freqs[:10])
# 三元
trigram_tokens = [triple for triple in zip(corpus[:-2], corpus[1:-1], corpus[2:])]
trigram_vocab = d2l.Vocab(trigram_tokens)
print(trigram_vocab.token_freqs[:10])
bigram_freqs = [freq for token, freq in bigram_vocab.token_freqs]
trigram_freqs = [freq for token, freq in trigram_vocab.token_freqs]
d2l.plot([freqs, bigram_freqs, trigram_freqs], xlabel='token: x',
ylabel='frequency: n(x)', xscale='log', yscale='log',
legend=['unigram', 'bigram', 'trigram'])
# 随机的生成一个小批量数据的特征和标签以供读取。在随机采样中，每个样本都是在原始的长序列上任意捕获的子序列
def seq_data_iter_random(corpus, batch_size, num_steps):
"""随机生成一个小批量的子序列"""
corpus = corpus[random.randint(0, num_steps-1):] # 随机选取起始点
# 计算可以切分为多少个子序列。
num_subseqs = (len(corpus)-1) // num_steps # 要给最后一个标签预留一个预测的位置，所以需要-1
# 获取每个子序列开始的下标
initial_indices = list(range(0, num_subseqs*num_steps, num_steps))
random.shuffle(initial_indices)
def data(pos):
return corpus[pos:pos + num_steps]
# 可以划分多少个batch
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] # [-1, num_steps]
Y = [data(j + 1) for j in initial_indices_per_batch] # [-1, num_steps]
yield torch.tensor(X), torch.tensor(Y)
my_seq = list(range(35))
for X, Y in seq_data_iter_random(my_seq, batch_size=2, num_steps=5):
print('X: ', X, '\nY:', Y)
# 另一种方法是保证小批量里面的子序列在原始数据上也是相邻的
def seq_data_iter_sequential(corpus, batch_size, num_steps): #@save
"""使用顺序分区生成一个小批量子序列"""
# 从随机偏移量开始划分序列
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 + 1 + num_tokens])
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
for X, Y in seq_data_iter_sequential(my_seq, batch_size=2, num_steps=5):
print('X: ', X, '\nY:', Y)
# 将上面两种采样方式封装成一个类
class SeqDataLoader: #@save
"""加载序列数据的迭代器"""
def __init__(self, batch_size, num_steps, use_random_iter, max_tokens):
if use_random_iter:
self.data_iter_fn = d2l.seq_data_iter_random
else:
self.data_iter_fn = d2l.seq_data_iter_sequential
self.corpus, self.vocab = d2l.load_corpus_time_machine(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)
def load_data_time_machine(batch_size, num_steps,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
网友评论