用飞桨做自然语言处理:神经网络语言模型应用实例

允中 发自 凹非寺 量子位 报道 | 公众号 QbitAI

编者按:

语言模型的身影遍布在NLP研究中的各个角落,想要了解NLP领域,就不能不知道语言模型。

想要让模型能落地奔跑,就需借助深度学习框架之力,Tensorflow、PyTorch自然是主流,但在Dropout都成独家专利之后,不储备“B计划”,多少让人有些担惊受怕

这里有一份飞桨(PaddlePaddle)语言模型应用实例,从基础概念到代码实现,娓娓道来,一一说明。现在,量子位分享转载如下,宜学习,宜收藏。

刚入门深度学习与自然语言处理(NLP)时,在学习了 Goldberg 特别棒的入门书 NN4NLP,斯坦福 cs224n 等等后,也无限次起念头,写个系列吧,但都不了了之了。

近来,NLP 领域因为超大预训练模型,很多研究需要耗费大量计算资源(比如百度新发布持续学习语义理解框架 ERNIE 2.0,该模型在共计 16 个中英文任务上超越了 BERT 和 XLNet,取得了 SOTA 效果),这样的项目基本上就是在烧钱,小家小户玩不起,于是就傻傻地等着大佬们发出论文,放出代码,刷新榜单。不过这也意味着一个总结的好机会,加上额外的推动,便重新起了念头。

这个系列会介绍我认为现代 NLP 最重要的几个主题,同时包括它们的实现与讲解。

这里会使用的百度的开源深度学习平台飞桨(PaddlePaddle),关于这点,有如下几个原因。

首先,不久前和一个科技媒体朋友聊天,因为当时封锁华为事件的原因,聊到了美国企业是否可能对我们封锁深度学习框架,比如说主流的 Tensorflow 和 Pytorch,我当时答是说不定可能呢,毕竟谷歌连 Dropout 都能去申请专利。只要之后改一下许可,不让使用这些框架的更新,估计我们也没办法,于是就想着可以了解一下国内百度的框架飞桨。

去飞桨的 PaddleNLP 看了一下,内容很丰富,感觉飞桨对 NLP 这块支持非常好,值得关注。

项目地址: https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP

语言模型

现代 NLP 领域的一个核心便是语言模型 (Language Model),可以说它无处不在,一方面它给 NLP 发展带来巨大推动,是多个领域的关键部分,但另一方面,成也萧何败也萧何,语言模型其实也限制了 NLP 发展,比如说在创新性生成式任务上,还有如何用语言模型获得双向信息。

那到底什么是语言模型?

什么是语言模型

就是语言的模型(认真脸),开个玩笑,语言模型通俗点讲其实就是判断一句话是不是人话,正式点讲就是计算一句话的概率,这个概率值表示这个本文有多大概率是一段正常的文本。

对于一句话,比如说用脸滚出来的一句话:“哦他发看和了犯点就看见发”,很明显就不像人话,所以语言模型判断它是人话的概率就小。而一句很常用的话:“好的,谢谢”,语言模型就会给它比较高的概率评分。

用数学的方式来表示,语言模型需要获得这样的概率:

其中 X 表示句子,x1,x2… 代表句子中的词。怎么计算这样一个概率呢,一个比较粗暴的方法就是有个非常非常大的语料库,里面有各种各样的句子,然后我们一个个数,来计算不同句子的概率,但稍微想想就知道这个方法不太可能,因为句子组合无穷无尽。

为更好计算,利用条件概率公式和链式法则,按照从左到右的句序,可以将公式转换成:

题变成了如何求解:

怎么根据前面所有的词预测下一个词,当然这个问题对于现在还有点复杂,之后可以用 RNN 模型来计算,但现在让我们先假设对于一个词离它近的词重要性更大,于是基于马尔可夫性假设,一个词只依赖它前面 n-1 个词,这种情况下的语言模型就被称为 N-gram 语言模型。

比如说基于前面2个词来预测下一个词就是 3-gram (tri-gram) 语言模型:

细心些的话,会发现,当 n-gram 中的 n 增大,就会越接近原始语言模型概率方程。

当然n并不是越大越好,因为一旦n过大,计算序列就会变长,在计算时 n-gram 时词表就会太大,也就会引发所谓的 The Curse of Dimension (维度灾难) 。因此一般大家都将n的大小取在3,4,5附近。

早期实现:数一数就知道了

最早了解类似语言模型计算概率,是在研究生阶段当时号称全校最难的信息论课上,老师强烈安利香农的经典论文 A Mathematical Theory of Communication,论文中有一小节中,他就给利用类似计算上述语言模型概率的方法,生成了一些文本。

其中一个就是用 2-gram (bi-gram) 的频率表来生成的,这已经相当于一个 bi-gram 语言模型了。

同样,要构建这样一个 n-gram 语言模型,最主要工作就是,基于大量文本来统计 n-gram 频率。

当时有个课程作业,就是先准备一些英文文本,然后一个一个数 n-gram,之后除以总数算出语言模型中需要的概率估计值,这种方法叫 Count-based Language Model。

传统 NLP 中搭建语言模型便是这样,当然还有更多技巧,比如平滑算法,具体可以参考 Jurafsky 教授的书和课。

但这种方法会有一个很大的问题,那就是前面提到的维度灾难,而这里要实现的神经网络语言模型(Neural Network Language Model),便是用神经网络构建语言模型,通过学习分布式词表示(即词向量)的方式解决了这个问题。

语言模型能干什么

不过在谈神经网络语言模型前,我们先来看看语言模型的用途。

那它有什么用呢,如之前提到,语言模型可以说是现代 NLP 核心之一,无处不在。比如说词向量,最早算是语言模型的副产品;同时经典的序列到序列(seq2seq) 模型,其中解码器还可以被称为,Conditional Language Model(条件语言模型);而现在大火的预训练模型,主要任务也都是语言模型。

在实际 NLP 应用中,我认为能总结成以下三条:

第一,给句子打分,排序。先在大量文本上训练,之后就能用获得的语言模型来评估某句话的好坏。这在对一些生成结果进行重排序时非常有用,能很大程度地提高指标,机器翻译中有一个技巧便是结合语言模型 Loss 来重排序生成的候选结果。

第二,用于文本生成。首先其训练方式是根据前面词,生成之后词。于是只要不断重复此过程(自回归)就能生成长文本了。比较有名的例子就包括最近的 GPT2,其标题就叫 “ Better Language Models and Their Implications.” 它生成的句子效果真的非常棒,可以自己体验一番 https://talktotransformer.com/.

第三,作为预训练模型的预训练任务。最近很火的预训练模型,几乎都和语言模型脱不开关系。

比如说 ELMo 就是先训练双向 LSTM 语言模型,之后双向不同层向量拼接获得最后的 ELMo词向量,还有 BERT 里最主要的方法就是 Masked Language Model (遮掩语言模型)。

而最近的 XLNet 中最主要训练任务也叫做 Permutation language Model (排列语言模型),可见语言模型在其中的重要性重要性。

神经网络语言模型架构

接下来简单介绍一下这里要实现的网络结构,借鉴自 Bengio 的经典论文 A Neural Probabilistic Language Model 中的模型。

这里我们训练 Tri-gram 语言模型,即用前面两个词预测当前词。

于是输入就是两个单词,然后查表取出对应词向量,之后将两个词向量拼接起来,过一个线性层,加入 tanh 激活函数,最后再过线性层输出分数,通过 softmax 将分数转换成对各个词预测的概率,一般取最大概率位置为预测词。

用公式表达整个过程就是:

整个结构非常简单,接下来就来看看如何用 飞桨来实现这个结构吧,同时介绍以下 飞桨的基本思想,和一般训练流程。

项目地址: https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP/language_model

PaddlePaddle代码基本实现

这里拿一个小例子来解说,假设我们在一个叫做 PaddlePaddle 的世界,这个世界的人们只会说三句话,每句话三个词,我们需要建立一个 Tri-gram 语言模型,来通过一句话前两个词预测下一个词。

关于整个流程,主要分成准备,数据预处理,模型构建,训练,保存,预测几个阶段,这也是一般一个 NLP 任务的基础流程。

准备

首先,先导入需要的库。

import numpy as np 
import paddle 
import paddle.fluid as fluid

之后准备训练数据与词表,统计所有不同词,建立词表,然后按照顺序建立一个单词到 id 的映射表和配套的 id 到单词映射表。因为模型无法直接读这些词,所以需要单词与 id 之间的转换。

# 假设在这个叫做Paddle的世界里,人们只会说这三句话 
sentences = ["我 喜欢 Paddle", "Paddle 等于 飞桨", "我 会 Paddle"]  

vocab = set(' '.join(sentences).split(' ')) # 统计词表 
word2idx = {w: i for i, w in enumerate(word_list)} # 建立单词到id映射表 
idx2word = word_list # id到单词的映射表 
n_vocab = len(word2idx) # 词表大小

准备好数据后,设置模型参数和训练相关参数,因为任务很简单,所以参数都设很小。

# 参数设置 
# 语言模型参数 
n_step = 2 # 输入前面多少个词,tri-gram 所以取 3-1=2 个 
n_hidden = 2 # 隐层的单元个数 

# 训练参数 
n_epochs = 5000 # 训练 epoch 数 
word_dim = 2 # 词向量大小 
lr = 0.001 # 学习率 
use_cuda = False #用不用GPU

数据预处理

根据 PaddlePaddle 数据输入要求,需要准备数据读取器 (reader),之后通过它来读取数据,对输入数据进行一些前处理,最后作为 batch 输出。

def sent_reader(): 
    def reader(): 
        batch = [] 
        for sent in sentences: 
            words = sent.split(' ') 
            input_ids = [word2idx[word] for word in words[:-1]] # 将输入转为id 
            target_id = word2idx[words[-1]] # 目标转为id 
            input = np.eye(n_vocab)[input_ids] # 将输入id转换成one_hot表示 
            target = np.array([target_id])  
            batch.append((input, target)) 
        yield batch 
    return reader

构建模型

这里从飞桨中较底层 API 来进行构建,理解更透彻。先创建所需参数矩阵,之后按照前面的公式来一步步运算。

def nnlm(one_hots): 
    # 创建所需参数 
    # 词向量表 
    L = fluid.layers.create_parameter(shape=[n_vocab, word_dim], dtype='float32') 
    # 运算所需参数 
    W1 = fluid.layers.create_parameter(shape=[n_step*word_dim, n_hidden], dtype='float32') 
    b1 = fluid.layers.create_parameter(shape=[n_hidden], dtype='float32', is_bias=True) 
    W2 = fluid.layers.create_parameter(shape=[n_hidden, n_vocab], dtype='float32') 
    b2 = fluid.layers.create_parameter(shape=[n_vocab], dtype='float32', is_bias=True) 
    # 取出词向量 
    word_emb = fluid.layers.matmul(one_hots, L) 
    # 两个词向量拼接 
    input = fluid.layers.reshape(x=word_emb, shape=[-1, n_step*word_dim], inplace=True) 
    # 前向运算 
    input2hid = fluid.layers.tanh(fluid.layers.matmul(input, W1) + b1) # 输入到隐层 
    hid2out = fluid.layers.softmax(fluid.layers.matmul(input2hid, W2) + b2) # 隐层到输出 
    return hid2out

先根据输入的独热(one-hot)向量,取出对应的词向量,因为每个例子输入前两个词,因此每个例子可获得两个词向量,之后按照步骤,将它们拼接起来,然后与 W1 和 b1 进行运算,过 tanh 非线性,最后再拿结果与 W2 和 b2 进行运算,softmax 输出结果。

接下来构建损失函数,我们用常用的交叉熵(cross-entropy)损失函数,直接调 API。

def ce_loss(softmax, target): 
    cost = fluid.layers.cross_entropy(input=softmax, label=target) # 计算每个batch的损失 
    avg_cost = fluid.layers.mean(cost) # 平均 
    return avg_cost

开始训练

终于进入了训练环节,不过为了更好理解,先稍稍介绍一点 飞桨的设计思想。

飞桨同时为用户提供动态图和静态图两种计算图。动态图组网更加灵活、调试网络便捷,实现AI 想法更快速;静态图部署方便、运行速度快,应用落地更高效。

如果想了解飞桨动态图更多内容,可以参考GitHub项目地址:https://github.com/PaddlePaddle/models/tree/v1.5.1/dygraph

实际应用中,静态图更为常见,下面我们以静态图为例介绍一个完整的实现:

首先,需要先定义 Program,整个 Program 中包括了各种网络定义,操作等等,定义完之后,再创建一个 Executor 来运行 Program,用过类似框架的同学应该并不陌生。

因此先来看看这两行代码,fluid 中最重要的两个 Program,将它们取出来。

startup_program = fluid.default_startup_program() # 默认启动程序 
main_program = fluid.default_main_program() # 默认主程序

default_startup_program 主要定义了输入输出,创建模型参数,还有可学习参数的初始化;而 default_main_program 则是定义了神经网络模型,前向反向,还有优化算法的更新。

之后将之前定义好的一些模块放入训练代码中。

train_reader = sent_reader() # 获取数据 reader 

# 定义输入和目标数据 
input = fluid.layers.data(name='input', shape=[-1, n_step, n_vocab], dtype='float32') 
target = fluid.layers.data(name='target', shape=[-1, 1], dtype='int64') 

# 输入到模型,获得 loss 
softmax = nnlm(input) 
loss = ce_loss(softmax, target)
之后还需要定义优化器(Optimizer),还有数据 Feeder 用于喂入数据。
# 配置优化器 
optimizer = fluid.optimizer.Adam(learning_rate=0.001) # 万金油的 Adam 
optimizer.minimize(loss) 

# 用于之后预测 
prediction = fluid.layers.argmax(softmax, axis=-1) 

# 定义 Executor 
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() # 指定运行位置 
exe = fluid.Executor(place) 

#定义数据 Feeder 
feeder = fluid.DataFeeder(feed_list=[input, target], place=place) # 每次喂入input和target
至此就完成了第一步的定义环节,然后就可以用定义的 Executor 来执行程序了。
# 参数初始化 
exe.run(startup_program) 

# 训练 
for epoch in range(n_epochs): 
    for data in train_reader(): 
        metrics = exe.run( 
            main_program, # 主程序 
            feed=feeder.feed(data), # 数据喂入 
            fetch_list=[loss]) # 要取出的数据 
        if epoch % 500 == 0: 
            print("Epoch {}, Cost {:.5f}".format(epoch, step, float(metrics[0][0])))

简单解释一下代码,训练时需要exe.run来执行每一步的训练,对于run需要传入主程序,还有输入 Feeder,和需要拿出来(fetch)的输出。

之后运行就能看到训练 log 了。

能明显看到 loss 在不断下降,等训练完成,我们就获得一个训练好的模型。

保存模型

在预测前可以尝试先保存一个模型,可以便于之后使用,比如 load 出来做预测。

fluid.io.save_inference_model('./model', ['input'], [prediction], exe)

很简单,只需要传入保存的路径’./model’,预测需要 feed 的数据’input’,之后需要 fetch 出的预测结果 prediction,最后加上执行器 exe,就 OK 了。

非常快。

预测阶段

预测阶段其实和训练阶段类似,但因为主程序都保存下来了,所以只用先建立执行器 Executor,同时建立一个用于预测的作用域。

infer_exe = fluid.Executor(place) # 预测 Executor 
inference_scope = fluid.core.Scope() # 预测作用域

然后在预测作用域中 load 出模型,进行预测运算,大部分操作都和训练很类似了。唯一不同就是 load 模型这块,其实就是把之前保存下来的参数给 load 出来了,然后用于预测。

with fluid.scope_guard(inference_scope): 
    [inference_program, feed_target_names, 
     fetch_targets] = fluid.io.load_inference_model('./model', infer_exe) # 载入预训练模型 

    infer_reader = sent_reader() # 定义预测数据 reader 

    infer_data = next(infer_reader()) # 读出数据 
    infer_feat = np.array([data[0] for data in infer_data]).astype("float32") 

    assert feed_target_names[0] == 'input' 
    results = infer_exe.run(inference_program, 
                            feed={feed_target_names[0]: infer_feat}, 
                            fetch_list=fetch_targets) # 进行预测

结果如何?

for sent, idx in zip(sentences, results[0]):
    print("{} -> {}".format(' '.join(sent.split()[:2]), idx2word[idx]))
我 喜欢 -> Paddle
Paddle 等于 -> 飞桨
我 会 -> Paddle

模型完美地学习到了 PaddlePaddle 世界中仅有的几个 trigram 规则,当然因为该任务非常简单,所以模型一下就能学会。

更多尝试

在了解完以上这个小例子之后,就能在它基础上做很多修改了,感兴趣的同学不妨拿下面的几个思路作为练习。

比如说用一个大数据集,加上更大模型,来进行训练,可以尝试复现 Bengio 论文中的模型规模,大致结构差不多,只是修改一下参数大小。

还比如说,在这里搭建网络结构时,用的是较底层API,直接创建矩阵权重,相乘相加,而 飞桨中有很多好用的API,能否调用这些API来重新构建这个模型呢,比如说词向量部分,可以用fluid.layers.embedding直接传入词 id 来实现,还有全连接层,可以直接用 fluid.layers.fc 来实现,激活函数可以直接通过里面参数设置,非常方便。

其实还可以在这里尝试些小技巧,比如共享词向量表为 softmax 前全连接层的权重 W2,以及加入 Bengio 论文中提到的类似残差连接直接将 embedding 连到输出的部分。

这次在这里介绍神经网络语言模型,并通过 飞桨来实现了一个简单的小例子,主要想做的是:

第一,语言模型任务在 NLP 领域很重要,想首先介绍一下;

第二,Bengio 这篇神经网络语言模型的论文非常经典,比如说提出了用神经网络实现语言模型,同时还最早提出词表示来解决“维数灾难”问题,通过复现,也好引出之后词向量,还有seq2seq 等话题;

第三,通过用 飞桨来实现这样一个简单例子,可以抛开各种模型与数据复杂度,更直观了解一个飞桨程序是如何构建的,也为之后讲解飞桨更复杂程序打下基础。

想详细了解更多飞桨相关内容,请点击文末阅读原文或参阅以下链接:

https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP

想与更多的深度学习开发者交流,请加入飞桨官方QQ群:432676488

原文发布于微信公众号 - 量子位(QbitAI)

原文发表时间:2019-08-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券