词向量(二)

文章结构:

词向量

  1. 背景介绍
  2. 效果展示
  3. 模型概览
  4. 数据准备
  5. 编程实现
  6. 模型应用
  7. 总结
  8. 参考文献

模型概览

 

在这里我们介绍三个训练词向量的模型:N-gram模型,CBOW模型和Skip-gram模型,它们的中心思想都是通过上下文得到一个词出现的概率。对于N-gram模型,我们会先介绍语言模型的概念,并在之后的训练模型中,带大家用PaddlePaddle实现它。而后两个模型,是近年来最有名的神经元词向量模型,由 Tomas Mikolov 在Google 研发[3],虽然它们很浅很简单,但训练效果很好。

 

语言模型

 

在介绍词向量模型之前,我们先来引入一个概念:语言模型。 语言模型旨在为语句的联合概率函数P(w1,...,wT)P(w1,...,wT)建模, 其中wiwi表示句子中的第i个词。语言模型的目标是,希望模型对有意义的句子赋予大概率,对没意义的句子赋予小概率。 这样的模型可以应用于很多领域,如机器翻译、语音识别、信息检索、词性标注、手写识别等,它们都希望能得到一个连续序列的概率。 以信息检索为例,当你在搜索“how long is a football bame”时(bame是一个医学名词),搜索引擎会提示你是否希望搜索"how long is a football game", 这是因为根据语言模型计算出“how long is a football bame”的概率很低,而与bame近似的,可能引起错误的词中,game会使该句生成的概率最大。

 

对语言模型的目标概率P(w1,...,wT)P(w1,...,wT),如果假设文本中每个词都是相互独立的,则整句话的联合概率可以表示为其中所有词语条件概率的乘积,即:

P(w1,...,wT)=∏t=1TP(wt)P(w1,...,wT)=∏t=1TP(wt)

 

然而我们知道语句中的每个词出现的概率都与其前面的词紧密相关, 所以实际上通常用条件概率表示语言模型:

 

P(w1,...,wT)=∏t=1TP(wt|w1,...,wt−1)P(w1,...,wT)=∏t=1TP(wt|w1,...,wt−1)

 

N-gram neural model

 

在计算语言学中,n-gram是一种重要的文本表示方法,表示一个文本中连续的n个项。基于具体的应用场景,每一项可以是一个字母、单词或者音节。 n-gram模型也是统计语言模型中的一种重要方法,用n-gram训练语言模型时,一般用每个n-gram的历史n-1个词语组成的内容来预测第n个词。

 

Yoshua Bengio等科学家就于2003年在著名论文 Neural Probabilistic Language Models [1] 中介绍如何学习一个神经元网络表示的词向量模型。文中的神经概率语言模型(Neural Network Language Model,NNLM)通过一个线性映射和一个非线性隐层连接,同时学习了语言模型和词向量,即通过学习大量语料得到词语的向量表达,通过这些向量得到整个句子的概率。因所有的词语都用一个低维向量来表示,用这种方法学习语言模型可以克服维度灾难(curse of dimensionality)。注意:由于“神经概率语言模型”说法较为泛泛,我们在这里不用其NNLM的本名,考虑到其具体做法,本文中称该模型为N-gram neural model。

 

我们在上文中已经讲到用条件概率建模语言模型,即一句话中第tt个词的概率和该句话的前t−1t−1个词相关。可实际上越远的词语其实对该词的影响越小,那么如果考虑一个n-gram, 每个词都只受其前面n-1个词的影响,则有:

 

P(w1,...,wT)=∏t=nTP(wt|wt−1,wt−2,...,wt−n+1)P(w1,...,wT)=∏t=nTP(wt|wt−1,wt−2,...,wt−n+1)

 

给定一些真实语料,这些语料中都是有意义的句子,N-gram模型的优化目标则是最大化目标函数:

 

1T∑tf(wt,wt−1,...,wt−n+1;θ)+R(θ)1T∑tf(wt,wt−1,...,wt−n+1;θ)+R(θ)

 

其中f(wt,wt−1,...,wt−n+1)f(wt,wt−1,...,wt−n+1)表示根据历史n-1个词得到当前词wtwt的条件概率,R(θ)R(θ)表示参数正则项。

 

图2. N-gram神经网络模型

 

图2展示了N-gram神经网络模型,从下往上看,该模型分为以下几个部分: - 对于每个样本,模型输入wt−n+1,...wt−1wt−n+1,...wt−1, 输出句子第t个词在字典中|V|个词上的概率分布。

 

每个输入词wt−n+1,...wt−1wt−n+1,...wt−1首先通过映射矩阵映射到词向量C(wt−n+1),...C(wt−1)C(wt−n+1),...C(wt−1)

 

  • 然后所有词语的词向量拼接成一个大向量,并经过一个非线性映射得到历史词语的隐层表示:
     
     
    g=Utanh(θTx+b1)+Wx+b2g=Utanh(θTx+b1)+Wx+b2
    其中,xx为所有词语的词向量拼接成的大向量,表示文本历史特征;θθUUb1b1b2b2WW分别为词向量层到隐层连接的参数。gg表示未经归一化的所有输出单词概率,gigi表示未经归一化的字典中第ii个单词的输出概率。
  • 根据softmax的定义,通过归一化gigi, 生成目标词wtwt的概率为:
 
P(wt|w1,...,wt−n+1)=egwt∑|V|iegiP(wt|w1,...,wt−n+1)=egwt∑i|V|egi

 

  • 整个网络的损失值(cost)为多类分类交叉熵,用公式表示为:
 
J(θ)=−∑i=1N∑k=1|V|yiklog(softmax(gik))J(θ)=−∑i=1N∑k=1|V|ykilog(softmax(gki))

 

其中yikyki表示第ii个样本第kk类的真实标签(0或1),softmax(gik)softmax(gki)表示第i个样本第k类softmax输出的概率。

 

Continuous Bag-of-Words model(CBOW)

 

CBOW模型通过一个词的上下文(各N个词)预测当前词。当N=2时,模型如下图所示:

 

图3. CBOW模型

 

具体来说,不考虑上下文的词语输入顺序,CBOW是用上下文词语的词向量的均值来预测当前词。即:

 
context=xt−1+xt−2+xt+1+xt+24context=xt−1+xt−2+xt+1+xt+24

 

其中xtxt为第tt个词的词向量,分类分数(score)向量 z=U∗contextz=U∗context,最终的分类yy采用softmax,损失函数采用多类分类交叉熵。

 

Skip-gram model

 

CBOW的好处是对上下文词语的分布在词向量上进行了平滑,去掉了噪声,因此在小数据集上很有效。而Skip-gram的方法中,用一个词预测其上下文,得到了当前词上下文的很多样本,因此可用于更大的数据集。

 

图4. Skip-gram模型

 

如上图所示,Skip-gram模型的具体做法是,将一个词的词向量映射到2n2n个词的词向量(2n2n表示当前输入词的前后各nn个词),然后分别通过softmax得到这2n2n个词的分类损失值之和。

 

数据准备

 

数据介绍

 

本教程使用Penn Treebank (PTB)(经Tomas Mikolov预处理过的版本)数据集。PTB数据集较小,训练速度快,应用于Mikolov的公开语言模型训练工具[2]中。其统计情况如下:

 

本章训练的是5-gram模型,表示在PaddlePaddle训练时,每条数据的前4个词用来预测第5个词。PaddlePaddle提供了对应PTB数据集的python包paddle.dataset.imikolov,自动做数据的下载与预处理,方便大家使用。

 

数据预处理

 

预处理会把数据集中的每一句话前后加上开始符号<s>以及结束符号<e>。然后依据窗口大小(本教程中为5),从头到尾每次向右滑动窗口并生成一条数据。如"I have a dream that one day" 一句提供了5条数据:

<s> I have a dream
I have a dream that
have a dream that one
a dream that one day
dream that one day <e>

 

最后,每个输入会按其单词次在字典里的位置,转化成整数的索引序列,作为PaddlePaddle的输入。

 

 

编程实现

 

本配置的模型结构如下图所示:


图5. 模型配置中的N-gram神经网络模型

 

首先,加载所需要的包:

import paddle as paddle
import paddle.fluid as fluid
import six
import numpy
import math

from __future__ import print_function

然后,定义参数:

EMBED_SIZE = 32      # embedding维度
HIDDEN_SIZE = 256    # 隐层大小
N = 5                # ngram大小,这里固定取5
BATCH_SIZE = 100     # batch大小
PASS_NUM = 100       # 训练轮数

use_cuda = False  # 如果用GPU训练,则设置为True

word_dict = paddle.dataset.imikolov.build_dict()
dict_size = len(word_dict)

 

更大的BATCH_SIZE将使得训练更快收敛,但也会消耗更多内存。由于词向量计算规模较大,如果环境允许,请开启使用GPU进行训练,能更快得到结果。 不同于之前的PaddlePaddle v2版本,在新的Fluid版本里,我们不必再手动计算词向量。PaddlePaddle提供了一个内置的方法fluid.layers.embedding,我们就可以直接用它来构造 N-gram 神经网络。

 

  • 我们来定义我们的 N-gram 神经网络结构。这个结构在训练和预测中都会使用到。因为词向量比较稀疏,我们传入参数 is_sparse == True, 可以加速稀疏矩阵的更新。
def inference_program(words, is_sparse):

    embed_first = fluid.layers.embedding(
        input=words[0],
        size=[dict_size, EMBED_SIZE],
        dtype='float32',
        is_sparse=is_sparse,
        param_attr='shared_w')
    embed_second = fluid.layers.embedding(
        input=words[1],
        size=[dict_size, EMBED_SIZE],
        dtype='float32',
        is_sparse=is_sparse,
        param_attr='shared_w')
    embed_third = fluid.layers.embedding(
        input=words[2],
        size=[dict_size, EMBED_SIZE],
        dtype='float32',
        is_sparse=is_sparse,
        param_attr='shared_w')
    embed_fourth = fluid.layers.embedding(
        input=words[3],
        size=[dict_size, EMBED_SIZE],
        dtype='float32',
        is_sparse=is_sparse,
        param_attr='shared_w')

    concat_embed = fluid.layers.concat(
        input=[embed_first, embed_second, embed_third, embed_fourth], axis=1)
    hidden1 = fluid.layers.fc(input=concat_embed,
                              size=HIDDEN_SIZE,
                              act='sigmoid')
    predict_word = fluid.layers.fc(input=hidden1, size=dict_size, act='softmax')
    return predict_word

 

 

  • 基于以上的神经网络结构,我们可以如下定义我们的训练方法
def train_program(predict_word):
    # 'next_word'的定义必须要在inference_program的声明之后,
    # 否则train program输入数据的顺序就变成了[next_word, firstw, secondw,
    # thirdw, fourthw], 这是不正确的.
    next_word = fluid.layers.data(name='nextw', shape=[1], dtype='int64')
    cost = fluid.layers.cross_entropy(input=predict_word, label=next_word)
    avg_cost = fluid.layers.mean(cost)
    return avg_cost

def optimizer_func():
    return fluid.optimizer.AdagradOptimizer(
        learning_rate=3e-3,
        regularization=fluid.regularizer.L2DecayRegularizer(8e-4))

 

  • 现在我们可以开始训练啦。如今的版本较之以前就简单了许多。我们有现成的训练和测试集:paddle.dataset.imikolov.train()paddle.dataset.imikolov.test()。两者都会返回一个读取器。在PaddlePaddle中,读取器是一个Python的函数,每次调用,会读取下一条数据。它是一个Python的generator。

paddle.batch 会读入一个读取器,然后输出一个批次化了的读取器。我们还可以在训练过程中输出每个步骤,批次的训练情况。

def train(if_use_cuda, params_dirname, is_sparse=True):
    place = fluid.CUDAPlace(0) if if_use_cuda else fluid.CPUPlace()

    train_reader = paddle.batch(
        paddle.dataset.imikolov.train(word_dict, N), BATCH_SIZE)
    test_reader = paddle.batch(
        paddle.dataset.imikolov.test(word_dict, N), BATCH_SIZE)

    first_word = fluid.layers.data(name='firstw', shape=[1], dtype='int64')
    second_word = fluid.layers.data(name='secondw', shape=[1], dtype='int64')
    third_word = fluid.layers.data(name='thirdw', shape=[1], dtype='int64')
    forth_word = fluid.layers.data(name='fourthw', shape=[1], dtype='int64')
    next_word = fluid.layers.data(name='nextw', shape=[1], dtype='int64')

    word_list = [first_word, second_word, third_word, forth_word, next_word]
    feed_order = ['firstw', 'secondw', 'thirdw', 'fourthw', 'nextw']

    main_program = fluid.default_main_program()
    star_program = fluid.default_startup_program()

    predict_word = inference_program(word_list, is_sparse)
    avg_cost = train_program(predict_word)
    test_program = main_program.clone(for_test=True)

    sgd_optimizer = optimizer_func()
    sgd_optimizer.minimize(avg_cost)

    exe = fluid.Executor(place)

    def train_test(program, reader):
        count = 0
        feed_var_list = [
            program.global_block().var(var_name) for var_name in feed_order
        ]
        feeder_test = fluid.DataFeeder(feed_list=feed_var_list, place=place)
        test_exe = fluid.Executor(place)
        accumulated = len([avg_cost]) * [0]
        for test_data in reader():
            avg_cost_np = test_exe.run(
                program=program,
                feed=feeder_test.feed(test_data),
                fetch_list=[avg_cost])
            accumulated = [
                x[0] + x[1][0] for x in zip(accumulated, avg_cost_np)
            ]
            count += 1
        return [x / count for x in accumulated]

    def train_loop():
        step = 0
        feed_var_list_loop = [
            main_program.global_block().var(var_name) for var_name in feed_order
        ]
        feeder = fluid.DataFeeder(feed_list=feed_var_list_loop, place=place)
        exe.run(star_program)
        for pass_id in range(PASS_NUM):
            for data in train_reader():
                avg_cost_np = exe.run(
                    main_program, feed=feeder.feed(data), fetch_list=[avg_cost])

                if step % 10 == 0:
                    outs = train_test(test_program, test_reader)

                    print("Step %d: Average Cost %f" % (step, outs[0]))

                    # 整个训练过程要花费几个小时,如果平均损失低于5.8,
                    # 我们就认为模型已经达到很好的效果可以停止训练了。
                    # 注意5.8是一个相对较高的值,为了获取更好的模型,可以将
                    # 这里的阈值设为3.5,但训练时间也会更长。
                    if outs[0] < 5.8:
                        if params_dirname is not None:
                            fluid.io.save_inference_model(params_dirname, [
                                'firstw', 'secondw', 'thirdw', 'fourthw'
                            ], [predict_word], exe)
                        return
                step += 1
                if math.isnan(float(avg_cost_np[0])):
                    sys.exit("got NaN loss, training failed.")

        raise AssertionError("Cost is too large {0:2.2}".format(avg_cost_np[0]))

    train_loop()

 

  • train_loop将会开始训练。期间打印训练过程的日志如下:
Step 0: Average Cost 7.337213
Step 10: Average Cost 6.136128
Step 20: Average Cost 5.766995
...

 

参考文献

 

  1. Bengio Y, Ducharme R, Vincent P, et al. A neural probabilistic language model[J]. journal of machine learning research, 2003, 3(Feb): 1137-1155.
  2. Mikolov T, Kombrink S, Deoras A, et al. Rnnlm-recurrent neural network language modeling toolkit[C]//Proc. of the 2011 ASRU Workshop. 2011: 196-201.
  3. Mikolov T, Chen K, Corrado G, et al. Efficient estimation of word representations in vector space[J]. arXiv preprint arXiv:1301.3781, 2013.
  4. Maaten L, Hinton G. Visualizing data using t-SNE[J]. Journal of Machine Learning Research, 2008, 9(Nov): 2579-2605.
  5. https://en.wikipedia.org/wiki/Singular_value_decomposition


知识共享许可协议
本教程 由 PaddlePaddle 创作,采用 知识共享 署名-相同方式共享 4.0 国际 许可协议进行许可。

收藏 评论(0)
分享到: