大白话式粗浅地聊聊NLP语言模型

前言

在聊NLP领域的语言模型的时候，我们究竟在聊什么？这就涉及nlp语言模型的定义。语言模型发展至今，其实可以简单的分为传统意义上的语言模型和现代的语言模型，传统语言模型主要是指利用统计学计算语料序列的概率分布，对于一个给定长度为m的序列，它可以为整个序列产生一个概率 P(w_1,w_2,…,w_m) 。其实就是想办法找到一个概率分布，它可以表示任意一个句子或序列出现的概率。现代的语言模型，则是指使用复杂神经网络的结构，采用监督学习，或者无监督/自监督学习的方式来训练得到的语言模型，比如rnn，transformers， bert等。当然，这个语言模型的分类，是基于笔者的理解简单粗暴的进行分类，学术上并没有这样严格意义上的将语言模型进行传统与现代的划分。当然，不管是传统的还是现代的语言模型，本质上就是用来计算任何的文本字符串或语料库的概率。好的语言模型对于未观察过的流畅的文本应该能输出一个高概率或者低混淆度(perplexity),反之则输出低概率。

传统的语言模型

在大白话讲懂word2vec原理和如何使用已经简单的介绍了一些传统的语言模型的内容，比如统计语言模型的公式，向量空间模型和单层的神经网络语言模型。关于统计语言模型，word2vec中的CBOW和Skip-Gram模型已经讲的比较清楚了，这里主要就是补充说一下n-gram模型。

n-gram模型本质上就是统计语言模型的实际能够工业落地的版本。为什么这样说呢，我们来看统计语言模型公式：$$p(W)=p(w_1)p(w_2\mid w_1)p(w_3\mid w_1,w_2)...p(w_T\mid w_1,w_2,...w_{T-1})$$
这里计算每个单词，都会用到前面单词的来计算条件概率，如果遇到长的语料或者句子，这个计算量是会让人崩溃的。

而n-gram的公式则是$$p(w_1,w_2,...w_m)=\prod _i^{m}p(w_i\mid w_{i-(n-1)}...w_{i-1})$$
这里的n就是代码只使用计算当前单词的条件概率的时只依赖于其前n个单词，而不在依赖于前面的所有单词，计算量就大大减少了。

n-gram模型中，计算单词的条件概率可以用词频来计算$$p(w_i\mid w_{i-(n-1)}...w_{i-1})=\frac{count(w_{i-(n-1)}...w_{i-1},w_i)}{count(w_{i-(n-1)}...w_{i-1})}$$

其实即使是使用n-gram来简化了统计语言模型的计算量，n-gram模型在处理上亿级别的语料时，仍然比较吃力，所以现在在大规模数据集上训练语言模型，一般都是用到较为复杂的神经网络语言模型。

现代的语言模型

现代的语言模型，一般来说小规模的语料，可以直接使用rnn或者transformer来做训练，而大规模的语料才用得上bert这种模型。实际工业场景，一般就用场景数据在bert这种预训练好的模型上做一些finetune，然后就可以部署使用了。

rnn和transformer模型都是序列化模型，就是会将上一个时刻输出的结果作为输入来进行计算，辅助进行下一个时刻的预测输出，所以很适合训练语言模型。

rnn和transformer模型虽然都是序列化模型，但是再输入方面也有所区别。rnn只需要将输入单词做 embedding即可，transformer除了做embedding之外，还需要加入positional encoding, 表征单词位置关系，这是transformer模型改进之处。

而bert模型结构其实就是 transformer encoder 模块的堆叠，其模型输入由三种不同的embedding求和而得，主要包含单词的word embedding、position embedding和segment embedding。bert的前两个输入和transformer几乎是一样的，segment embedding则用于区分两个句子的向量表示，就是在一个句子结束之后，加一个"sep"标识符，这样就可以区分两个句子。

rnn和transformer虽然模型输入略微有所差别，但是在训练语言模型时候的label几乎是一样的，就是将句子中单词进行往后移动一位，其中一个单词是输入，那个这个单词的下一个单词便是这个输入的label。具体在代码中操作也很简单：

it = iter(train_iter)
batch = next(it)
print(" ".join([TEXT.vocab.itos[i] for i in batch.text[:,1].data]))
print(" ".join([TEXT.vocab.itos[i] for i in batch.target[:,1].data]))

打印输出为：
rather than in an <eos> uncertain something. but that is nihilism, and the sign of a despairing, <eos> mortally wearied soul, notwithstanding the courageous bearing such a <eos> virtue may display. it
than in an <eos> uncertain something. but that is nihilism, and the sign of a despairing, <eos> mortally wearied soul, notwithstanding the courageous bearing such a <eos> virtue may display. it seems,

而bert的模型训练采用的是无监督的方式，bert 借鉴完形填空任务和 cbow 的思想，使用语言掩码方法训练模型。

语言掩码方法也就是随机去掉句子中的部分 token（单词），然后模型来预测被去掉的 token 是什么。这样的操作使得其和传统的神经网络语言模型就有较大的差别，而是单纯作为分类问题，根据这个时刻的 hidden state 来预测这个时刻的 token 应该是什么，而不是预测下一个时刻的词的概率分布了。

随机去掉的 token 被称作掩码词，在训练中，掩码词将以 15% 的概率被替换成 [MASK]，也就是说随机 mask 语料中 15% 的 token，这个操作则称为掩码操作。

因为bert是使用掩码的方式进行语言模型的模型，所以bert也叫掩码语言模型（Masked Language Modeling，MLM）。现在随着nlp领域的发展，在bert基础上又衍射出了更新更好的模型，增强掩码模型（Enhanced Masked Language Modeling），比如 RoBERTa 采用了一种动态的遮罩处理。UniLM 将遮罩任务拓展到 3 种不同的类型：单向的，双向的和 Seq2Seq 类型的。这里就不展开讲了，

rnn语言模型训练代码

首先是模型定义

import torch
import torch.nn as nn


class RNNModel(nn.Module):
    """ 一个简单的循环神经网络"""

    def __init__(self, rnn_type, ntoken, ninp, nhid, nlayers, dropout=0.5):
        ''' 该模型包含以下几层:
            - 词嵌入层
            - 一个循环神经网络层(RNN, LSTM, GRU)
            - 一个线性层，从hidden state到输出单词表
            - 一个dropout层，用来做regularization
        '''
        super(RNNModel, self).__init__()
        self.drop = nn.Dropout(dropout)
        self.encoder = nn.Embedding(ntoken, ninp)
        if rnn_type in ['LSTM', 'GRU']:
            self.rnn = getattr(nn, rnn_type)(ninp, nhid, nlayers, dropout=dropout)
        else:
            try:
                nonlinearity = {
    
    'RNN_TANH': 'tanh', 'RNN_RELU': 'relu'}[rnn_type]
            except KeyError:
                raise ValueError( """An invalid option for `--model` was supplied,
                                 options are ['LSTM', 'GRU', 'RNN_TANH' or 'RNN_RELU']""")
            self.rnn = nn.RNN(ninp, nhid, nlayers, nonlinearity=nonlinearity, dropout=dropout)
        self.decoder = nn.Linear(nhid, ntoken)

        self.init_weights()

        self.rnn_type = rnn_type
        self.nhid = nhid
        self.nlayers = nlayers

    def init_weights(self):
        initrange = 0.1
        self.encoder.weight.data.uniform_(-initrange, initrange)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, input, hidden):
        ''' Forward pass:
            - word embedding
            - 输入循环神经网络
            - 一个线性层从hidden state转化为输出单词表
        '''
        emb = self.drop(self.encoder(input))
        output, hidden = self.rnn(emb, hidden)
        output = self.drop(output)
        decoded = self.decoder(output.view(output.size(0)*output.size(1), output.size(2)))
        return decoded.view(output.size(0), output.size(1), decoded.size(1)), hidden

    def init_hidden(self, bsz, requires_grad=True):
        weight = next(self.parameters())
        if self.rnn_type == 'LSTM':
            return (weight.new_zeros((self.nlayers, bsz, self.nhid), requires_grad=requires_grad),
                    weight.new_zeros((self.nlayers, bsz, self.nhid), requires_grad=requires_grad))
        else:
            return weight.new_zeros((self.nlayers, bsz, self.nhid), requires_grad=requires_grad)

然后导入本地数据集，这里用的是英文数据集

TEXT = torchtext.legacy.data.Field(lower=True)
train, val, test = torchtext.legacy.datasets.LanguageModelingDataset.splits(path='.',
                                                                     train="./data/nietzsche.txt",
                                                                     validation="./data/nietzsche.txt",
                                                                     test="./data/nietzsche.txt",
                                                                     text_field=TEXT)
TEXT.build_vocab(train, max_size=MAX_VOCAB_SIZE)
print("vocabulary size: {}".format(len(TEXT.vocab)))

VOCAB_SIZE = len(TEXT.vocab)
train_iter, val_iter, test_iter = torchtext.legacy.data.BPTTIterator.splits(
    (train, val, test), batch_size=BATCH_SIZE, device=-1, bptt_len=32, repeat=False, shuffle=True)

初始化模型

model = RNNModel("LSTM", VOCAB_SIZE, EMBEDDING_SIZE, EMBEDDING_SIZE, 2, dropout=0.5)
if USE_CUDA:
    model = model.cuda()

定义损失函数和优化器选择

loss_fn = nn.CrossEntropyLoss()
learning_rate = 0.001
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, 0.5)

模型训练

import copy
GRAD_CLIP = 1.
NUM_EPOCHS = 2

val_losses = []
for epoch in range(NUM_EPOCHS):
    model.train()
    it = iter(train_iter)
    hidden = model.init_hidden(BATCH_SIZE)
    for i, batch in enumerate(it):
        data, target = batch.text, batch.target
        if USE_CUDA:
            data, target = data.cuda(), target.cuda()
        hidden = repackage_hidden(hidden)
        model.zero_grad()
        output, hidden = model(data, hidden)
        loss = loss_fn(output.view(-1, VOCAB_SIZE), target.view(-1))
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
        optimizer.step()
        if i % 1000 == 0:
            print("epoch", epoch, "iter", i, "loss", loss.item())
    
        if i % 10000 == 0:
            val_loss = evaluate(model, val_iter)
            
            if len(val_losses) == 0 or val_loss < min(val_losses):
                print("best model, val loss: ", val_loss)
                torch.save(model.state_dict(), "lm-best.pth")
            else:
                scheduler.step()
                optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
            val_losses.append(val_loss)

最后就是模型预测

hidden = best_model.init_hidden(1)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
input = torch.randint(VOCAB_SIZE, (1, 1), dtype=torch.long).to(device)
words = []
for i in range(100):
    output, hidden = best_model(input, hidden)
    word_weights = output.squeeze().exp().cpu()
    word_idx = torch.multinomial(word_weights, 1)[0]
    input.fill_(word_idx)
    word = TEXT.vocab.itos[word_idx]
    words.append(word)
print(" ".join(words))