基于PaddlePaddle的词向量实战 | 深度学习基础任务教程系列（二）

如"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神经网络模型

首先我们先加载所需的包

 **from** **__future__** **import** **print_function**
**import** **paddle** **as** **paddle**
**import** **paddle.fluid** **as** **fluid**
**import** **six**
**import** **numpy**
**import sys**
**import** **math**

然后，定义参数

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进行训练，能更快得到结果。在新的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()。两者都会返回一个读取器。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]))
    tain_loop()

train_loop将会开始训练。期间打印训练过程的日志如下：

Step 0: Average Cost 7.337213
Step 10: Average Cost 6.136128
Step 20: Average Cost 5.766995
...

预测下一个词的配置

我们可以用我们训练过的模型，在得知之前的N-gram 后，预测下一个词。

 **def** **infer** (use_cuda,params_dirname **=** None):
    place **=** fluid **.** CUDAPlace(0) **if** use_cuda **else** fluid **.** CPUPlace()
 
    exe **=** fluid **.** Executor(place)
 
    inference_scope **=** fluid **.** core **.** Scope()
    **with** fluid **.** scope_guard(inference_scope):
        **#** **使用** **fluid.io.load_inference_model** **获取** **inference program** **，**
        **# feed** **变量的名称** **feed_target_names** **和从** **scope** **中** **fetch** **的对象** **fetch_targets**
[inferencer,feed_target_names,
         fetch_targets] **=** fluid **.** io **.** load_inference_model(params_dirname,exe)
 
        **#** **设置输入，用四个** **LoDTensor** **来表示** **4** **个词语。这里每个词都是一个** **id** **，**
        **#** **用来查询** **embedding** **表获取对应的词向量，因此其形状大小是** **[1]** **。**
        **# recursive_sequence_lengths** **设置的是基于长度的** **LoD** **，因此都应该设为** **[[1]]**
        **#** **注意** **recursive_sequence_lengths** **是列表的列表**
        data1 **=** [[211]]  **# 'among'**
        data2 **=** [[6]]  **# 'a'**
        data3 **=** [[96]]  **# 'group'**
        data4 **=** [[4]]  **# 'of'**
        lod **=** [[1]]
 
        first_word **=** fluid **.** create_lod_tensor(data1,lod,place)
        second_word **=** fluid **.** create_lod_tensor(data2,lod,place)
        third_word **=** fluid **.** create_lod_tensor(data3,lod,place)
        fourth_word **=** fluid **.** create_lod_tensor(data4,lod,place)
 
        **assert** feed_target_names[0] **==** 'firstw'
        **assert** feed_target_names[1] **==** 'secondw'
        **assert** feed_target_names[2] **==** 'thirdw'
        **assert** feed_target_names[3] **==** 'fourthw'
 
        **#** **构造** **feed** **词典** **{feed_target_name: feed_target_data}**
        **#** **预测结果包含在** **results** **之中**
        results **=** exe **.** run(
            inferencer,
            feed **=** {
                feed_target_names[0]:first_word,
                feed_target_names[1]:second_word,
                feed_target_names[2]:third_word,
                feed_target_names[3]:fourth_word
},
            fetch_list **=** fetch_targets,
            return_numpy **=** False)
        **print** (numpy **.** array(results[0]))
        most_possible_word_index **=** numpy **.** argmax(results[0])
        **print** (most_possible_word_index)
        **print** ([
            key **for** key,value **in** six **.** iteritems(word_dict)
            **if** value **==** most_possible_word_index
][0])

由于词向量矩阵本身比较稀疏，训练的过程如果要达到一定的精度耗时会比较长。为了能简单看到效果，教程只设置了经过很少的训练就结束并得到如下的预测。我们的模型预测 among a group of 的下一个词是the。这比较符合文法规律。如果我们训练时间更长，比如几个小时，那么我们会得到的下一个预测是 workers。预测输出的格式如下所示:

[[0.03768077 0.03463154 0.00018074 ... 0.00022283 0.00029888 0.02967956]]0the

其中第一行表示预测词在词典上的概率分布，第二行表示概率最大的词对应的id，第三行表示概率最大的词。

整个程序的入口很简单：

 **def** **main** (use_cuda,is_sparse):
    **if** use_cuda **and** **not** fluid **.** core **.** is_compiled_with_cuda():
        **return**


    params_dirname **=** "word2vec.inference.model" 
    train(
        if_use_cuda **=** use_cuda,
        params_dirname **=** params_dirname,
        is_sparse **=** is_sparse)
infer(use_cuda **=** use_cuda,params_dirname **=** params_dirname)
main(use_cuda **=** use_cuda,is_sparse **=** True)

总结

在本教程中，我们最开始先介绍了词向量、语言模型和词向量的关系、以及如何通过训练神经网络模型获得词向量。在信息检索中，我们可以根据向量间的余弦夹角，来判断query和文档关键词这二者间的相关性。在句法分析和语义分析中，训练好的词向量可以用来初始化模型，以得到更好的效果。在文档分类中，有了词向量之后，可以用聚类的方法将文档中同义词进行分组，也可以用N- gram 来预测下一个词。希望大家在阅读完本教程能够自行运用词向量进行相关领域的研究。

参考文献

[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.