rebuid code

language_model/README.md

-# 语言模型
-## 简介
-语言模型即 Language Model，简称LM，它是一个概率分布模型，简单来说，就是用来计算一个句子的概率的模型。给定句子（词语序列）：
-
-<div align=center><img src='images/s.png'/></div>
-
-它的概率可以表示为：
-
-<div align=center><img src='images/ps.png'/> &nbsp;&nbsp;&nbsp;&nbsp;(式1)</div>
-
-语言模型可以计算（式1）中的P(S)及其中间结果。**利用它可以确定哪个词序列的可能性更大，或者给定若干个词，可以预测下一个最可能出现的词语。**
-
-## 应用场景
-**语言模型被应用在多个领域**，如：
-
-* **自动写作**：语言模型可以根据上文生成下一个词，递归下去可以生成整个句子、段落、篇章。
-* **QA**：语言模型可以根据Question生成Answer。
-* **机器翻译**：当前主流的机器翻译模型大多基于Encoder-Decoder模式，其中Decoder就是一个语言模型，用来生成目标语言。
-* **拼写检查**：语言模型可以计算出词语序列的概率，一般在拼写错误处序列的概率会骤减，可以用来识别拼写错误并提供改正候选集。
-* **词性标注、句法分析、语音识别......**
-
-## 关于本例
-Language Model 常见的实现方式有 N-Gram、RNN、seq2seq。本例中实现了基于N-Gram、RNN的语言模型。**本例的文件结构如下**：
-
-* data_util.py：实现了对语料的读取以及词典的建立、保存和加载。
-* lm_rnn.py：实现了基于rnn的语言模型的定义、训练以及做预测。
-* lm_ngram.py：实现了基于n-gram的语言模型的定义、训练以及做预测。
-
-***注：**一般情况下基于N-Gram的语言模型不如基于RNN的语言模型效果好，所以实际使用时建议使用基于RNN的语言模型，本例中也将着重介绍基于RNN的模型，简略介绍基于N-Gram的模型。*
-
-## RNN 语言模型
-### 简介
-
-RNN是一个序列模型，基本思路是：在时刻t，将前一时刻t-1的隐藏层输出h<small>t-1</small>和t时刻的词向量x<small>t</small>一起输入到隐藏层从而得到时刻t的特征表示h<small>t</small>，然后用这个特征表示得到t时刻的预测输出ŷ ，如此在时间维上递归下去，如下图所示：
-
-<div align=center><img src='images/rnn_str.png' width='500px'/></div>
-
-可以看出RNN善于使用上文信息、历史知识，具有“记忆”功能。理论上RNN能实现“长依赖”（即利用很久之前的知识），但在实际应用中发现效果并不理想，于是出现了很多RNN的变种，如常用的LSTM和GRU，它们对传统RNN的cell进行了改进，弥补了RNN的不足，下图是LSTM的示意图：
-
-<div align=center><img src='images/lstm.png' width='500px'/></div>
-
-本例中即使用了LSTM、GRU。
-
-### 模型结构
-
-lm_rnn.py 中的 lm() 函数定义了模型的结构。解析如下：
-
-* 1，首先，在\_\_main\_\_中定义了模型的参数变量。
-
-	```python
-    # -- config : model --
-    rnn_type = 'gru' # or 'lstm'
-    emb_dim = 200
-    hidden_size = 200
-    num_passs = 2
-    num_layer = 2
-	```
-
-	其中 rnn\_type 用于配置rnn cell类型，可以取‘lstm’或‘gru’；hidden\_size配置unit个数；num\_layer配置RNN的层数；num\_passs配置训练的轮数；emb_dim配置embedding的dimension。
-
-* 2，将输入的词（或字）序列映射成向量，即embedding。
-
-	```python
-	data = paddle.layer.data(name="word", type=paddle.data_type.integer_value_sequence(vocab_size))
-	target = paddle.layer.data("label", paddle.data_type.integer_value_sequence(vocab_size))
-	emb = paddle.layer.embedding(input=data, size=emb_dim)
-	```
-
-* 3，根据配置实现RNN层，将上一步得到的embedding向量序列作为输入。
-
-	```python
-    if rnn_type == 'lstm':
-        rnn_cell = paddle.networks.simple_lstm(
-            input=emb, size=hidden_size)
-        for _ in range(num_layer - 1):
-            rnn_cell = paddle.networks.simple_lstm(
-                input=rnn_cell, size=hidden_size)
-    elif rnn_type == 'gru':
-        rnn_cell = paddle.networks.simple_gru(
-            input=emb, size=hidden_size)
-        for _ in range(num_layer - 1):
-            rnn_cell = paddle.networks.simple_gru(
-                input=rnn_cell, size=hidden_size)
-	```
-
-* 4，实现输出层（使用softmax归一化计算单词的概率，将output结果返回）、定义模型的cost（多类交叉熵损失函数）。
-
-	```python
-	# fc and output layer
-	output = paddle.layer.fc(input=[rnn_cell], size=vocab_size, act=paddle.activation.Softmax())
-
-	# loss
-	cost = paddle.layer.classification_cost(input=output, label=target)
-	```
-
-### 训练模型
-
-lm\_rnn.py 中的 train() 方法实现了模型的训练，流程如下：
-
-* 1，准备输入数据：本例中使用的是标准PTB数据，调用data\_util.py中的build\_vocab()方法建立词典，并使用save\_vocab()方法将词典持久化，以备复用（当语料量大时生成词典比较耗时，所以这里把第一次生成的词典保存下来复用）。然后使用data\_util.py中的train\_data()、test\_data()方法建立train\_reader和test\_reader用来实现对train数据和test数据的读取。
-
-* 2，初始化模型：包括模型的结构、参数、优化器（demo中使用的是Adam）以及训练器trainer。如下：
-
-	```python
-	# network config
-	cost, _ = lm(len(word_id_dict), emb_dim, rnn_type, hidden_size, num_layer)
-
-	# create parameters
-	parameters = paddle.parameters.create(cost)
-
-	# create optimizer
-	adam_optimizer = paddle.optimizer.Adam(
-        learning_rate=1e-3,
-        regularization=paddle.optimizer.L2Regularization(rate=1e-3),
-        model_average=paddle.optimizer.ModelAverage(average_window=0.5))
-
-    # create trainer
-    trainer = paddle.trainer.SGD(
-        cost=cost, parameters=parameters, update_equation=adam_optimizer)
-	```
-
-* 3，定义回调函数event_handler来跟踪训练过程中loss的变化，并在每轮时结束保存模型的参数：
-
-	```python
-	# define event_handler callback
-    def event_handler(event):
-        if isinstance(event, paddle.event.EndIteration):
-            if event.batch_id % 100 == 0:
-                print("\nPass %d, Batch %d, Cost %f, %s" % (
-                    event.pass_id, event.batch_id, event.cost,
-                    event.metrics))
-            else:
-                sys.stdout.write('.')
-                sys.stdout.flush()
-
-        # save model each pass
-        if isinstance(event, paddle.event.EndPass):
-            result = trainer.test(reader=ptb_reader)
-            print("\nTest with Pass %d, %s" % (event.pass_id, result.metrics))
-            with gzip.open(model_file_name_prefix + str(event.pass_id) + '.tar.gz', 'w') as f:
-                parameters.to_tar(f)
-	```
-
-* 4，开始train模型：
-
-	```python
-	trainer.train(
-	        reader=ptb_reader, event_handler=event_handler, num_passes=num_passs)
-	```
-
-### 生成文本
-lm\_rnn.py中的predict()方法实现了做prediction、生成文本。流程如下：
-
-* 1，首先加载并缓存词典和模型，其中加载train好的模型参数方法如下：
-
-	```python
-	parameters = paddle.parameters.Parameters.from_tar(gzip.open(model_file_name))
-	```
-
-* 2，生成文本，本例中生成文本的方式是启发式图搜索算法beam search，即lm\_rnn.py中的 \_generate\_with\_beamSearch() 方法。
-
-### <font color='red'>使用此demo</font>
-
-本例中使用的是标准的PTB数据，如果用户要实现自己的model，则只需要做如下适配工作：
-
-#### 语料适配
-* 清洗语料：去除空格、tab、乱码，根据需要去除数字、标点符号、特殊符号等。
-* 编码格式：utf-8，本例中已经对中文做了适配。
-* 内容格式：每个句子占一行；每行中的各词之间使用一个空格分开。
-* 按需要配置lm\_rnn.py中\_\_main\_\_函数中对于data的配置：
-
-	```python
-    # -- config : data --
-    train_file = 'data/ptb.train.txt'
-    test_file = 'data/ptb.test.txt'
-    vocab_file = 'data/vocab_cn.txt'  # the file to save vocab
-    vocab_max_size = 3000
-    min_sentence_length = 3
-    max_sentence_length = 60
-	```
-
-	其中，vocab\_max\_size定义了词典的最大长度，如果语料中出现的不同词的个数大于这个值，则根据各词的词频倒序排，取top(vocab\_max\_size)个词纳入词典。
-
-	*注：需要注意的是词典越大生成的内容越丰富但训练耗时越久，一般中文分词之后，语料中不同的词能有几万乃至几十万，如果vocab\_max\_size取值过小则导致\<UNK\>占比过高，如果vocab\_max\_size取值较大则严重影响训练速度（对精度也有影响），所以也有“按字”训练模型的方式，即：把每个汉字当做一个词，常用汉字也就几千个，使得字典的大小不会太大、不会丢失太多信息，但汉语中同一个字在不同词中语义相差很大，有时导致模型效果不理想。建议用户多试试、根据实际情况选择是“按词训练”还是“按字训练”。*
-
-#### 模型适配
-
-根据语料的大小按需调整模型的\_\_main\_\_中定义的参数。
-
-然后运行 python lm\_rnn.py即可训练模型、做prediction。
-
-## n-gram 语言模型
-
-n-gram模型也称为n-1阶马尔科夫模型，它有一个有限历史假设：当前词的出现概率仅仅与前面n-1个词相关。因此 (式1) 可以近似为：
-<div align=center><img src='images/ps2.png'/></div>
-一般采用最大似然估计（Maximum Likelihood Estimation，MLE）的方法对模型的参数进行估计。当n取1、2、3时，n-gram模型分别称为unigram、bigram和trigram语言模型。一般情况下，n越大、训练语料的规模越大，参数估计的结果越可靠，但由于模型较简单、表达能力不强以及数据稀疏等问题。一般情况下用n-gram实现的语言模型不如RNN、seq2seq效果好。
-
-### 模型结构
-
-lm\_ngram.py中的lm()定义了模型的结构，大致如下：
-
-* 1，demo中n取5，将前四个词分别做embedding，然后连接起来作为特征向量。
-* 2，后接DNN的hidden layer。
-* 3，将DNN的输出通过softmax layer做分类，得到下个词在词典中的概率分布。
-* 4，模型的loss采用交叉熵，用Adam optimizer对loss做优化。
-
-图示如下：
-<div align=center><img src='images/ngram.png' width='400px'/></div>
-
-### 模型训练
-
-lm\_ngram.py中的train()方法实现了模型的训练，过程和RNN LM类似，简介如下：
-
-* 1，准备输入数据：使用的是标准PTB数据，调用data\_util.py中的build\_vocab()方法建立词典，并使用save\_vocab()方法将词典持久化，使用data\_util.py中的train\_data()、test\_data()方法建立train\_reader和test\_reader用来实现对train数据和test数据的读取。
-* 2，初始化模型：包括模型的结构、参数、优化器（demo中使用的是Adam）以及trainer。
-* 3，定义回调函数event_handler来跟踪训练过程中loss的变化，并在每轮时结束保存模型的参数。
-* 4，使用trainer开始train模型。
-
-### 生成文本
-lm\_ngram.py中的\_\_main\_\_方法中对prediction（生成文本）做了简单的实现。流程如下：
-
-* 1，首先加载词典和模型：
-
-	```python
-	# prepare model
-	word_id_dict = reader.load_vocab(vocab_file)  # load word dictionary
-	_, output_layer = lm(len(word_id_dict), emb_dim, hidden_size, num_layer)  # network config
-	model_file_name =  model_file_name_prefix + str(num_passs - 1) + '.tar.gz'
-parameters = paddle.parameters.Parameters.from_tar(gzip.open(model_file_name))  # load parameters
-	```
-
-* 2，根据4（n-1）个词的上文预测下一个单词并打印：
-
-	```python
-	# generate
-	text = 'the end of the'  # use 4 words to predict the 5th word
-	input = [[word_id_dict.get(w, word_id_dict['<UNK>']) for w in text.split()]]
-	predictions = paddle.infer(
-	    output_layer=output_layer,
-	    parameters=parameters,
-	    input=input,
-	    field=['value'])
-	id_word_dict = dict([(v, k) for k, v in word_id_dict.items()])  # dictionary with type {id : word}
-	predictions[-1][word_id_dict['<UNK>']] = -1  # filter <UNK>
-	next_word = id_word_dict[np.argmax(predictions[-1])]
-	print(next_word.encode('utf-8'))
-	```
-
-	*注：这里展示了另一种做预测的方法，即使用paddle.infer方法。RNN的实例中使用的是paddle.inference.Inference接口。*

language_model/config.py

+# coding=utf-8
+
+# -- config : data --
+
+train_file = 'data/chinese.train.txt'
+test_file = 'data/chinese.test.txt'
+vocab_file = 'data/vocab_cn.txt'  # the file to save vocab
+
+build_vocab_method = 'fixed_size'  # 'frequency' or 'fixed_size'
+vocab_max_size = 3000  # when build_vocab_method = 'fixed_size'
+unk_threshold = 1  # # when build_vocab_method = 'frequency'
+
+min_sentence_length = 3
+max_sentence_length = 60
+
+# -- config : train --
+
+use_which_model = 'ngram'  # must be: 'rnn' or 'ngram'
+use_gpu = False  # whether to use gpu
+trainer_count = 1  # number of trainer
+
+
+class Config_rnn(object):
+    """
+    config for RNN language model
+    """
+    rnn_type = 'gru'  # or 'lstm'
+    emb_dim = 200
+    hidden_size = 200
+    num_layer = 2
+    num_passs = 2
+    batch_size = 32
+    model_file_name_prefix = 'lm_' + rnn_type + '_params_pass_'
+
+
+class Config_ngram(object):
+    """
+    config for N-Gram language model
+    """
+    emb_dim = 200
+    hidden_size = 200
+    num_layer = 2
+    N = 5
+    num_passs = 2
+    batch_size = 32
+    model_file_name_prefix = 'lm_ngram_pass_'
+
+
+# -- config : infer --
+
+input_file = 'data/input.txt'  # input file contains sentence prefix each line
+output_file = 'data/output.txt'  # the file to save results
+num_words = 10  # the max number of words need to generate
+beam_size = 5  # beam_width, the number of the prediction sentence for each prefix

language_model/data/chinese.test.txt

+我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。
\ No newline at end of file

language_model/data/chinese.train.txt

+我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。我 是 中国 人 。
+我 爱 中国 。
\ No newline at end of file

language_model/data/input.txt

+我
+我 是
+我 是 中国
+我 爱
+我 是 中国 人。
+我 爱 中国
+我 爱 中国 。我
+我 爱 中国 。我 爱
+我 爱 中国 。我 是
+我 爱 中国 。我 是 中国
\ No newline at end of file

language_model/infer.py

+# coding=utf-8
+import paddle.v2 as paddle
+import gzip
+import numpy as np
+from utils import *
+import network_conf
+from config import *
+
+
+def generate_using_rnn(word_id_dict, num_words, beam_size):
+    """
+    Demo: use RNN model to do prediction.
+
+    :param word_id_dict: vocab.
+    :type word_id_dict: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    :param num_words: the number of the words to generate.
+    :type num_words: int
+    :param beam_size: beam width.
+    :type beam_size: int
+    :return: save prediction results to output_file
+    """
+
+    # prepare and cache model
+    config = Config_rnn()
+    _, output_layer = network_conf.rnn_lm(
+        vocab_size=len(word_id_dict),
+        emb_dim=config.emb_dim,
+        rnn_type=config.rnn_type,
+        hidden_size=config.hidden_size,
+        num_layer=config.num_layer)  # network config
+    model_file_name = config.model_file_name_prefix + str(config.num_passs -
+                                                          1) + '.tar.gz'
+    parameters = paddle.parameters.Parameters.from_tar(
+        gzip.open(model_file_name))  # load parameters
+    inferer = paddle.inference.Inference(
+        output_layer=output_layer, parameters=parameters)
+
+    # tools, different from generate_using_ngram's tools
+    id_word_dict = dict(
+        [(v, k) for k, v in word_id_dict.items()])  # {id : word}
+
+    def str2ids(str):
+        return [[[
+            word_id_dict.get(w, word_id_dict['<UNK>']) for w in str.split()
+        ]]]
+
+    def ids2str(ids):
+        return [[[id_word_dict.get(id, ' ') for id in ids]]]
+
+    # generate text
+    with open(input_file) as file:
+        output_f = open(output_file, 'w')
+        for line in file:
+            line = line.decode('utf-8').strip()
+            # generate
+            texts = {}  # type: {text : probability}
+            texts[line] = 1
+            for _ in range(num_words):
+                texts_new = {}
+                for (text, prob) in texts.items():
+                    if '<EOS>' in text:  # stop prediction when <EOS> appear
+                        texts_new[text] = prob
+                        continue
+                    # next word's probability distribution
+                    predictions = inferer.infer(input=str2ids(text))
+                    predictions[-1][word_id_dict['<UNK>']] = -1  # filter <UNK>
+                    # find next beam_size words
+                    for _ in range(beam_size):
+                        cur_maxProb_index = np.argmax(
+                            predictions[-1])  # next word's id
+                        text_new = text + ' ' + id_word_dict[
+                            cur_maxProb_index]  # text append next word
+                        texts_new[text_new] = texts[text] * predictions[-1][
+                            cur_maxProb_index]
+                        predictions[-1][cur_maxProb_index] = -1
+                texts.clear()
+                if len(texts_new) <= beam_size:
+                    texts = texts_new
+                else:  # cutting
+                    texts = dict(
+                        sorted(
+                            texts_new.items(), key=lambda d: d[1], reverse=True)
+                        [:beam_size])
+
+            # save results to output file
+            output_f.write(line.encode('utf-8') + '\n')
+            for (sentence, prob) in texts.items():
+                output_f.write('\t' + sentence.encode('utf-8', 'replace') + '\t'
+                               + str(prob) + '\n')
+            output_f.write('\n')
+
+        output_f.close()
+    print('already saved results to ' + output_file)
+
+
+def generate_using_ngram(word_id_dict, num_words, beam_size):
+    """
+    Demo: use N-Gram model to do prediction.
+
+    :param word_id_dict: vocab.
+    :type word_id_dict: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    :param num_words: the number of the words to generate.
+    :type num_words: int
+    :param beam_size: beam width.
+    :type beam_size: int
+    :return: save prediction results to output_file
+    """
+
+    # prepare and cache model
+    config = Config_ngram()
+    _, output_layer = network_conf.ngram_lm(
+        vocab_size=len(word_id_dict),
+        emb_dim=config.emb_dim,
+        hidden_size=config.hidden_size,
+        num_layer=config.num_layer)  # network config
+    model_file_name = config.model_file_name_prefix + str(config.num_passs -
+                                                          1) + '.tar.gz'
+    parameters = paddle.parameters.Parameters.from_tar(
+        gzip.open(model_file_name))  # load parameters
+    inferer = paddle.inference.Inference(
+        output_layer=output_layer, parameters=parameters)
+
+    # tools, different from generate_using_rnn's tools
+    id_word_dict = dict(
+        [(v, k) for k, v in word_id_dict.items()])  # {id : word}
+
+    def str2ids(str):
+        return [[
+            word_id_dict.get(w, word_id_dict['<UNK>']) for w in str.split()
+        ]]
+
+    def ids2str(ids):
+        return [[id_word_dict.get(id, ' ') for id in ids]]
+
+    # generate text
+    with open(input_file) as file:
+        output_f = open(output_file, 'w')
+        for line in file:
+            line = line.decode('utf-8').strip()
+            words = line.split()
+            if len(words) < config.N:
+                output_f.write(line.encode('utf-8') + "\n\tnone\n")
+                continue
+            # generate
+            texts = {}  # type: {text : probability}
+            texts[line] = 1
+            for _ in range(num_words):
+                texts_new = {}
+                for (text, prob) in texts.items():
+                    if '<EOS>' in text:  # stop prediction when <EOS> appear
+                        texts_new[text] = prob
+                        continue
+                    # next word's probability distribution
+                    predictions = inferer.infer(
+                        input=str2ids(' '.join(text.split()[-config.N:])))
+                    predictions[-1][word_id_dict['<UNK>']] = -1  # filter <UNK>
+                    # find next beam_size words
+                    for _ in range(beam_size):
+                        cur_maxProb_index = np.argmax(
+                            predictions[-1])  # next word's id
+                        text_new = text + ' ' + id_word_dict[
+                            cur_maxProb_index]  # text append nextWord
+                        texts_new[text_new] = texts[text] * predictions[-1][
+                            cur_maxProb_index]
+                        predictions[-1][cur_maxProb_index] = -1
+                texts.clear()
+                if len(texts_new) <= beam_size:
+                    texts = texts_new
+                else:  # cutting
+                    texts = dict(
+                        sorted(
+                            texts_new.items(), key=lambda d: d[1], reverse=True)
+                        [:beam_size])
+
+            # save results to output file
+            output_f.write(line.encode('utf-8') + '\n')
+            for (sentence, prob) in texts.items():
+                output_f.write('\t' + sentence.encode('utf-8', 'replace') + '\t'
+                               + str(prob) + '\n')
+            output_f.write('\n')
+
+        output_f.close()
+    print('already saved results to ' + output_file)
+
+
+def main():
+    # init paddle
+    paddle.init(use_gpu=use_gpu, trainer_count=trainer_count)
+
+    # prepare and cache vocab
+    if os.path.isfile(vocab_file):
+        word_id_dict = load_vocab(vocab_file)  # load word dictionary
+    else:
+        if build_vocab_method == 'fixed_size':
+            word_id_dict = build_vocab_with_fixed_size(
+                train_file, vocab_max_size)  # build vocab
+        else:
+            word_id_dict = build_vocab_using_threshhold(
+                train_file, unk_threshold)  # build vocab
+        save_vocab(word_id_dict, vocab_file)  # save vocab
+
+    # generate
+    if use_which_model == 'rnn':
+        generate_using_rnn(
+            word_id_dict=word_id_dict, num_words=num_words, beam_size=beam_size)
+    elif use_which_model == 'ngram':
+        generate_using_ngram(
+            word_id_dict=word_id_dict, num_words=num_words, beam_size=beam_size)
+    else:
+        raise Exception('use_which_model must be rnn or ngram!')
+
+
+if __name__ == "__main__":
+    main()

language_model/network_conf.py

+# coding=utf-8
+
+import paddle.v2 as paddle
+
+
+def rnn_lm(vocab_size, emb_dim, rnn_type, hidden_size, num_layer):
+    """
+    RNN language model definition.
+
+    :param vocab_size: size of vocab.
+    :param emb_dim: embedding vector's dimension.
+    :param rnn_type: the type of RNN cell.
+    :param hidden_size: number of unit.
+    :param num_layer: layer number.
+    :return: cost and output layer of model.
+    """
+
+    assert emb_dim > 0 and hidden_size > 0 and vocab_size > 0 and num_layer > 0
+
+    # input layers
+    input = paddle.layer.data(
+        name="input", type=paddle.data_type.integer_value_sequence(vocab_size))
+    target = paddle.layer.data(
+        name="target", type=paddle.data_type.integer_value_sequence(vocab_size))
+
+    # embedding layer
+    input_emb = paddle.layer.embedding(input=input, size=emb_dim)
+
+    # rnn layer
+    if rnn_type == 'lstm':
+        rnn_cell = paddle.networks.simple_lstm(
+            input=input_emb, size=hidden_size)
+        for _ in range(num_layer - 1):
+            rnn_cell = paddle.networks.simple_lstm(
+                input=rnn_cell, size=hidden_size)
+    elif rnn_type == 'gru':
+        rnn_cell = paddle.networks.simple_gru(input=input_emb, size=hidden_size)
+        for _ in range(num_layer - 1):
+            rnn_cell = paddle.networks.simple_gru(
+                input=rnn_cell, size=hidden_size)
+    else:
+        raise Exception('rnn_type error!')
+
+    # fc(full connected) and output layer
+    output = paddle.layer.fc(
+        input=[rnn_cell], size=vocab_size, act=paddle.activation.Softmax())
+
+    # loss
+    cost = paddle.layer.classification_cost(input=output, label=target)
+
+    return cost, output
+
+
+def ngram_lm(vocab_size, emb_dim, hidden_size, num_layer):
+    """
+    N-Gram language model definition.
+
+    :param vocab_size: size of vocab.
+    :param emb_dim: embedding vector's dimension.
+    :param hidden_size: size of unit.
+    :param num_layer: layer number.
+    :return: cost and output layer of model.
+    """
+
+    assert emb_dim > 0 and hidden_size > 0 and vocab_size > 0 and num_layer > 0
+
+    def wordemb(inlayer):
+        wordemb = paddle.layer.table_projection(
+            input=inlayer,
+            size=emb_dim,
+            param_attr=paddle.attr.Param(
+                name="_proj", initial_std=0.001, learning_rate=1, l2_rate=0))
+        return wordemb
+
+    # input layers
+    first_word = paddle.layer.data(
+        name="first_word", type=paddle.data_type.integer_value(vocab_size))
+    second_word = paddle.layer.data(
+        name="second_word", type=paddle.data_type.integer_value(vocab_size))
+    third_word = paddle.layer.data(
+        name="third_word", type=paddle.data_type.integer_value(vocab_size))
+    fourth_word = paddle.layer.data(
+        name="fourth_word", type=paddle.data_type.integer_value(vocab_size))
+    next_word = paddle.layer.data(
+        name="next_word", type=paddle.data_type.integer_value(vocab_size))
+
+    # embedding layer
+    first_emb = wordemb(first_word)
+    second_emb = wordemb(second_word)
+    third_emb = wordemb(third_word)
+    fourth_emb = wordemb(fourth_word)
+
+    context_emb = paddle.layer.concat(
+        input=[first_emb, second_emb, third_emb, fourth_emb])
+
+    # hidden layer
+    hidden = paddle.layer.fc(
+        input=context_emb, size=hidden_size, act=paddle.activation.Relu())
+    for _ in range(num_layer - 1):
+        hidden = paddle.layer.fc(
+            input=hidden, size=hidden_size, act=paddle.activation.Relu())
+
+    # fc(full connected) and output layer
+    predict_word = paddle.layer.fc(
+        input=[hidden], size=vocab_size, act=paddle.activation.Softmax())
+
+    # loss
+    cost = paddle.layer.classification_cost(input=predict_word, label=next_word)
+
+    return cost, predict_word

language_model/reader.py

+# coding=utf-8
+import collections
+import os
+
+
+def rnn_reader(file_name, min_sentence_length, max_sentence_length,
+               word_id_dict):
+    """
+    create reader for RNN, each line is a sample.
+
+    :param file_name: file name.
+    :param min_sentence_length: sentence's min length.
+    :param max_sentence_length: sentence's max length.
+    :param word_id_dict: vocab with content of '{word, id}', 'word' is string type , 'id' is int type.
+    :return: data reader.
+    """
+
+    def reader():
+        UNK = word_id_dict['<UNK>']
+        with open(file_name) as file:
+            for line in file:
+                words = line.decode('utf-8', 'ignore').strip().split()
+                if len(words) < min_sentence_length or len(
+                        words) > max_sentence_length:
+                    continue
+                ids = [word_id_dict.get(w, UNK) for w in words]
+                ids.append(word_id_dict['<EOS>'])
+                target = ids[1:]
+                target.append(word_id_dict['<EOS>'])
+                yield ids[:], target[:]
+
+    return reader
+
+
+def ngram_reader(file_name, N, word_id_dict):
+    """
+    create reader for N-Gram.
+
+    :param file_name: file name.
+    :param N: N-Gram's N.
+    :param word_id_dict: vocab with content of '{word, id}', 'word' is string type , 'id' is int type.
+    :return: data reader.
+    """
+    assert N >= 2
+
+    def reader():
+        ids = []
+        UNK_ID = word_id_dict['<UNK>']
+        cache_size = 10000000
+        with open(file_name) as file:
+            for line in file:
+                words = line.decode('utf-8', 'ignore').strip().split()
+                ids += [word_id_dict.get(w, UNK_ID) for w in words]
+                ids_len = len(ids)
+                if ids_len > cache_size:  # output
+                    for i in range(ids_len - N - 1):
+                        yield tuple(ids[i:i + N])
+                    ids = []
+        ids_len = len(ids)
+        for i in range(ids_len - N - 1):
+            yield tuple(ids[i:i + N])
+
+    return reader

language_model/train.py

+# coding=utf-8
+import sys
+import paddle.v2 as paddle
+import reader
+from utils import *
+import network_conf
+import gzip
+from config import *
+
+
+def train(model_cost, train_reader, test_reader, model_file_name_prefix,
+          num_passes):
+    """
+    train model.
+
+    :param model_cost: cost layer of the model to train.
+    :param train_reader: train data reader.
+    :param test_reader: test data reader.
+    :param model_file_name_prefix: model's prefix name.
+    :param num_passes: epoch.
+    :return:
+    """
+
+    # init paddle
+    paddle.init(use_gpu=use_gpu, trainer_count=trainer_count)
+
+    # create parameters
+    parameters = paddle.parameters.create(model_cost)
+
+    # create optimizer
+    adam_optimizer = paddle.optimizer.Adam(
+        learning_rate=1e-3,
+        regularization=paddle.optimizer.L2Regularization(rate=1e-3),
+        model_average=paddle.optimizer.ModelAverage(
+            average_window=0.5, max_average_window=10000))
+
+    # create trainer
+    trainer = paddle.trainer.SGD(
+        cost=model_cost, parameters=parameters, update_equation=adam_optimizer)
+
+    # define event_handler callback
+    def event_handler(event):
+        if isinstance(event, paddle.event.EndIteration):
+            if event.batch_id % 100 == 0:
+                print("\nPass %d, Batch %d, Cost %f, %s" % (
+                    event.pass_id, event.batch_id, event.cost, event.metrics))
+            else:
+                sys.stdout.write('.')
+                sys.stdout.flush()
+
+        # save model each pass
+        if isinstance(event, paddle.event.EndPass):
+            result = trainer.test(reader=test_reader)
+            print("\nTest with Pass %d, %s" % (event.pass_id, result.metrics))
+            with gzip.open(
+                    model_file_name_prefix + str(event.pass_id) + '.tar.gz',
+                    'w') as f:
+                parameters.to_tar(f)
+
+    # start to train
+    print('start training...')
+    trainer.train(
+        reader=train_reader, event_handler=event_handler, num_passes=num_passes)
+
+    print("Training finished.")
+
+
+def main():
+    # prepare vocab
+    print('prepare vocab...')
+    if build_vocab_method == 'fixed_size':
+        word_id_dict = build_vocab_with_fixed_size(
+            train_file, vocab_max_size)  # build vocab
+    else:
+        word_id_dict = build_vocab_using_threshhold(
+            train_file, unk_threshold)  # build vocab
+    save_vocab(word_id_dict, vocab_file)  # save vocab
+
+    # init model and data reader
+    if use_which_model == 'rnn':
+        # init RNN model
+        print('prepare rnn model...')
+        config = Config_rnn()
+        cost, _ = network_conf.rnn_lm(
+            len(word_id_dict), config.emb_dim, config.rnn_type,
+            config.hidden_size, config.num_layer)
+
+        # init RNN data reader
+        train_reader = paddle.batch(
+            paddle.reader.shuffle(
+                reader.rnn_reader(train_file, min_sentence_length,
+                                  max_sentence_length, word_id_dict),
+                buf_size=65536),
+            batch_size=config.batch_size)
+
+        test_reader = paddle.batch(
+            paddle.reader.shuffle(
+                reader.rnn_reader(test_file, min_sentence_length,
+                                  max_sentence_length, word_id_dict),
+                buf_size=65536),
+            batch_size=config.batch_size)
+
+    elif use_which_model == 'ngram':
+        # init N-Gram model
+        print('prepare ngram model...')
+        config = Config_ngram()
+        assert config.N == 5
+        cost, _ = network_conf.ngram_lm(
+            vocab_size=len(word_id_dict),
+            emb_dim=config.emb_dim,
+            hidden_size=config.hidden_size,
+            num_layer=config.num_layer)
+
+        # init N-Gram data reader
+        train_reader = paddle.batch(
+            paddle.reader.shuffle(
+                reader.ngram_reader(train_file, config.N, word_id_dict),
+                buf_size=65536),
+            batch_size=config.batch_size)
+
+        test_reader = paddle.batch(
+            paddle.reader.shuffle(
+                reader.ngram_reader(test_file, config.N, word_id_dict),
+                buf_size=65536),
+            batch_size=config.batch_size)
+    else:
+        raise Exception('use_which_model must be rnn or ngram!')
+
+    # train model
+    train(
+        model_cost=cost,
+        train_reader=train_reader,
+        test_reader=test_reader,
+        model_file_name_prefix=config.model_file_name_prefix,
+        num_passes=config.num_passs)
+
+
+if __name__ == "__main__":
+    main()

language_model/utils.py

+# coding=utf-8
+import os
+import collections
+
+
+def save_vocab(word_id_dict, vocab_file_name):
+    """
+    save vocab.
+
+    :param word_id_dict: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    :param vocab_file_name: vocab file name.
+    """
+    f = open(vocab_file_name, 'w')
+    for (k, v) in word_id_dict.items():
+        f.write(k.encode('utf-8') + '\t' + str(v) + '\n')
+    print('save vocab to ' + vocab_file_name)
+    f.close()
+
+
+def load_vocab(vocab_file_name):
+    """
+    load vocab from file.
+    :param vocab_file_name: vocab file name.
+    :return: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    """
+    assert os.path.isfile(vocab_file_name)
+    dict = {}
+    with open(vocab_file_name) as file:
+        for line in file:
+            if len(line) < 2:
+                continue
+            kv = line.decode('utf-8').strip().split('\t')
+            dict[kv[0]] = int(kv[1])
+    return dict
+
+
+def build_vocab_using_threshhold(file_name, unk_threshold):
+    """
+    build vacab using_<UNK> threshhold.
+
+    :param file_name:
+    :param unk_threshold: <UNK> threshhold.
+    :type unk_threshold: int.
+    :return: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    """
+    counter = {}
+    with open(file_name) as file:
+        for line in file:
+            words = line.decode('utf-8', 'ignore').strip().split()
+            for word in words:
+                if word in counter:
+                    counter[word] += 1
+                else:
+                    counter[word] = 1
+    counter_new = {}
+    for (word, frequency) in counter.items():
+        if frequency >= unk_threshold:
+            counter_new[word] = frequency
+    counter.clear()
+    counter_new = sorted(counter_new.items(), key=lambda d: -d[1])
+    words = [word_frequency[0] for word_frequency in counter_new]
+    word_id_dict = dict(zip(words, range(2, len(words) + 2)))
+    word_id_dict['<UNK>'] = 0
+    word_id_dict['<EOS>'] = 1
+    return word_id_dict
+
+
+def build_vocab_with_fixed_size(file_name, vocab_max_size):
+    """
+    build vacab with assigned max size.
+
+    :param vocab_max_size: vocab's max size.
+    :return: dictionary with content of '{word, id}', 'word' is string type , 'id' is int type.
+    """
+    words = []
+    for line in open(file_name):
+        words += line.decode('utf-8', 'ignore').strip().split()
+
+    counter = collections.Counter(words)
+    counter = sorted(counter.items(), key=lambda x: -x[1])
+    if len(counter) > vocab_max_size:
+        counter = counter[:vocab_max_size]
+    words, counts = zip(*counter)
+    word_id_dict = dict(zip(words, range(2, len(words) + 2)))
+    word_id_dict['<UNK>'] = 0
+    word_id_dict['<EOS>'] = 1
+    return word_id_dict