Merge branch 'develop' into ctc_decoder_dev

generate_sequence_by_rnn_lm/.gitignore

+*.pyc
+*.tar.gz
+models

generate_sequence_by_rnn_lm/README.md

+# 使用循环神经网语言模型生成文本
+
+语言模型(Language Model)是一个概率分布模型，简单来说，就是用来计算一个句子的概率的模型。利用它可以确定哪个词序列的可能性更大，或者给定若干个词，可以预测下一个最可能出现的词。语言模型是自然语言处理领域里一个重要的基础模型。
+
+## 应用场景
+**语言模型被应用在很多领域**，如：
+
+* **自动写作**：语言模型可以根据上文生成下一个词，递归下去可以生成整个句子、段落、篇章。
+* **QA**：语言模型可以根据Question生成Answer。
+* **机器翻译**：当前主流的机器翻译模型大多基于Encoder-Decoder模式，其中Decoder就是一个待条件的语言模型，用来生成目标语言。
+* **拼写检查**：语言模型可以计算出词序列的概率，一般在拼写错误处序列的概率会骤减，可以用来识别拼写错误并提供改正候选集。
+* **词性标注、句法分析、语音识别......**
+
+## 关于本例
+本例实现基于RNN的语言模型，以及利用语言模型生成文本，本例的目录结构如下：
+
+```text
+.
+├── data
+│   └── train_data_examples.txt        # 示例数据，可参考示例数据的格式，提供自己的数据
+├── config.py    # 配置文件，包括data、train、infer相关配置
+├── generate.py  # 预测任务脚本，即生成文本
+├── beam_search.py    # beam search 算法实现
+├── network_conf.py   # 本例中涉及的各种网络结构均定义在此文件中，希望进一步修改模型结构，请修改此文件
+├── reader.py    # 读取数据接口
+├── README.md
+├── train.py    # 训练任务脚本
+└── utils.py    # 定义通用的函数，例如：构建字典、加载字典等
+```
+
+## RNN 语言模型
+### 简介
+
+RNN是一个序列模型，基本思路是：在时刻$t$，将前一时刻$t-1$的隐藏层输出和$t$时刻的词向量一起输入到隐藏层从而得到时刻$t$的特征表示，然后用这个特征表示得到$t$时刻的预测输出，如此在时间维上递归下去。可以看出RNN善于使用上文信息、历史知识，具有“记忆”功能。理论上RNN能实现“长依赖”（即利用很久之前的知识），但在实际应用中发现效果并不理想，研究提出了LSTM和GRU等变种，通过引入门机制对传统RNN的记忆单元进行了改进，弥补了传统RNN在学习长序列时遇到的难题。本例模型使用了LSTM或GRU，可通过配置进行修改。下图是RNN（广义上包含了LSTM、GRU等）语言模型“循环”思想的示意图：
+
+<p align=center><img src='images/rnn.png' width='500px'/></p>
+
+### 模型实现
+
+本例中RNN语言模型的实现简介如下：
+
+- **定义模型参数**：`config.py`中定义了模型的参数变量。
+- **定义模型结构**：`network_conf.py`中的`rnn_lm`**函数**中定义了模型的**结构**，如下：
+    - 输入层：将输入的词（或字）序列映射成向量，即词向量层： `embedding`。
+    - 中间层：根据配置实现RNN层，将上一步得到的`embedding`向量序列作为输入。
+    - 输出层：使用`softmax`归一化计算单词的概率。
+    - loss：定义多类交叉熵作为模型的损失函数。
+- **训练模型**：`train.py`中的`main`方法实现了模型的训练，实现流程如下：
+    - 准备输入数据：建立并保存词典、构建train和test数据的reader。
+    - 初始化模型：包括模型的结构、参数。
+    - 构建训练器：demo中使用的是Adam优化算法。
+    - 定义回调函数：构建`event_handler`来跟踪训练过程中loss的变化，并在每轮训练结束时保存模型的参数。
+    - 训练：使用trainer训练模型。
+
+- **生成文本**：`generate.py` 实现了文本的生成，实现流程如下：
+    - 加载训练好的模型和词典文件。
+    - 读取`gen_file`文件，每行是一个句子的前缀，用[柱搜索算法(Beam Search)](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md#柱搜索算法)根据前缀生成文本。
+    - 将生成的文本及其前缀保存到文件`gen_result`。
+
+## 使用说明
+
+运行本例的方法如下：
+
+* 1，运行`python train.py`命令，开始train模型（默认使用RNN），待训练结束。
+* 2，运行`python generate.py`运行文本生成。（输入的文本默认为`data/train_data_examples.txt`，生成的文本默认保存到`data/gen_result.txt`中。）
+
+
+**如果需要使用自己的语料、定制模型，需要修改`config.py`中的配置，细节和适配工作详情如下：**
+
+
+### 语料适配
+
+* 清洗语料：去除原文中空格、tab、乱码，按需去除数字、标点符号、特殊符号等。
+* 内容格式：每个句子占一行；每行中的各词之间使用一个空格符分开。
+* 按需要配置`config.py`中的如下参数：
+
+    ```python  
+     train_file = "data/train_data_examples.txt"
+     test_file = ""
+
+     vocab_file = "data/word_vocab.txt"
+     model_save_dir = "models"
+    ```
+    1. `train_file`：指定训练数据的路径，**需要预先分词**。
+    2. `test_file`：指定测试数据的路径，如果训练数据不为空，将在每个 `pass` 训练结束对指定的测试数据进行测试。
+    3. `vocab_file`：指定字典的路径，如果字典文件不存在，将会对训练语料进行词频统计，构建字典。
+    4. `model_save_dir`：指定模型保存的路径，如果指定的文件夹不存在，将会自动创建。
+
+### 构建字典的策略
+- 当指定的字典文件不存在时，将对训练数据进行词频统计，自动构建字典`config.py` 中有如下两个参数与构建字典有关：
+
+    ```python
+    max_word_num = 51200 - 2
+    cutoff_word_fre = 0
+    ```
+    1. `max_word_num`：指定字典中含有多少个词。
+    2. `cutoff_word_fre`：字典中词语在训练语料中出现的最低频率。
+- 加入指定了 `max_word_num = 5000`，并且 `cutoff_word_fre = 10`，词频统计发现训练语料中出现频率高于10次的词语仅有3000个，那么最终会取3000个词构成词典。
+- 构建词典时，会自动加入两个特殊符号：
+    1. `<unk>`：不出现在字典中的词
+    2. `<e>`：句子的结束符
+
+    *注：需要注意的是，词典越大生成的内容越丰富，但训练耗时越久。一般中文分词之后，语料中不同的词能有几万乃至几十万，如果`max_word_num`取值过小则导致`<unk>`占比过高，如果`max_word_num`取值较大，则严重影响训练速度（对精度也有影响）。所以，也有“按字”训练模型的方式，即：把每个汉字当做一个词，常用汉字也就几千个，使得字典的大小不会太大、不会丢失太多信息，但汉语中同一个字在不同词中语义相差很大，有时导致模型效果不理想。建议多试试、根据实际情况选择是“按词训练”还是“按字训练”。*
+
+### 模型适配、训练
+
+* 按需调整`config.py`中如下配置，来修改 rnn 语言模型的网络结果：
+
+    ```python
+    rnn_type = "lstm"  # "gru" or "lstm"
+    emb_dim = 256
+    hidden_size = 256
+    stacked_rnn_num = 2
+    ```
+    1. `rnn_type`：支持 ”gru“ 或者 ”lstm“ 两种参数，选择使用何种 RNN 单元。
+    2. `emb_dim`：设置词向量的维度。
+    3. `hidden_size`：设置 RNN 单元隐层大小。
+    4. `stacked_rnn_num`：设置堆叠 RNN 单元的个数，构成一个更深的模型。
+
+* 运行`python train.py`命令训练模型，模型将被保存到`model_save_dir`指定的目录。
+
+### 按需生成文本
+
+* 按需调整`config.py`中以下变量，详解如下：
+
+    ```python
+    gen_file = "data/train_data_examples.txt"
+    gen_result = "data/gen_result.txt"
+    max_gen_len = 25  # the max number of words to generate
+    beam_size = 5
+    model_path = "models/rnn_lm_pass_00000.tar.gz"
+    ```
+    1. `gen_file`：指定输入数据文件，每行是一个句子的前缀，**需要预先分词**。
+    2. `gen_result`：指定输出文件路径，生成结果将写入此文件。
+    3. `max_gen_len`：指定每一句生成的话最长长度，如果模型无法生成出`<e>`，当生成 `max_gen_len` 个词语后，生成过程会自动终止。
+    4. `beam_size`：Beam Search 算法每一步的展开宽度。
+    5. `model_path`：指定训练好的模型的路径。
+
+    其中，`gen_file` 中保存的是待生成的文本前缀，每个前缀占一行，形如：
+
+    ```text
+    若隐若现 地像 幽灵 , 像 死神
+    ```
+    将需要生成的文本前缀按此格式存入文件即可；
+
+* 运行`python generate.py`命令运行beam search 算法为输入前缀生成文本，下面是模型生成的结果：
+
+    ```text
+    81    若隐若现 地像 幽灵 , 像 死神
+    -12.2542    一样 。 他 是 个 怪物 <e>
+    -12.6889    一样 。 他 是 个 英雄 <e>
+    -13.9877    一样 。 他 是 我 的 敌人 <e>
+    -14.2741    一样 。 他 是 我 的 <e>
+    -14.6250    一样 。 他 是 我 的 朋友 <e>
+    ```
+    其中：
+    1. 第一行 `81    若隐若现 地像 幽灵 , 像 死神`以`\t`为分隔，共有两列：
+        - 第一列是输入前缀在训练样本集中的序号。
+        - 第二列是输入的前缀。
+    2. 第二 ~ `beam_size + 1` 行是生成结果，同样以 `\t` 分隔为两列：
+        - 第一列是该生成序列的对数概率（log probability）。
+        - 第二列是生成的文本序列，正常的生成结果会以符号`<e>`结尾，如果没有以`<e>`结尾，意味着超过了最大序列长度，生成强制终止。

generate_sequence_by_rnn_lm/beam_search.py

+#!/usr/bin/env python
+# coding=utf-8
+import os
+import math
+import numpy as np
+
+import paddle.v2 as paddle
+
+from utils import logger, load_reverse_dict
+
+__all__ = ["BeamSearch"]
+
+
+class BeamSearch(object):
+    """
+    Generating sequence by beam search
+    NOTE: this class only implements generating one sentence at a time.
+    """
+
+    def __init__(self, inferer, word_dict_file, beam_size=1, max_gen_len=100):
+        """
+        constructor method.
+
+        :param inferer: object of paddle.Inference that represents the entire
+            network to forward compute the test batch
+        :type inferer: paddle.Inference
+        :param word_dict_file: path of word dictionary file
+        :type word_dict_file: str
+        :param beam_size: expansion width in each iteration
+        :type param beam_size: int
+        :param max_gen_len: the maximum number of iterations
+        :type max_gen_len: int
+        """
+        self.inferer = inferer
+        self.beam_size = beam_size
+        self.max_gen_len = max_gen_len
+        self.ids_2_word = load_reverse_dict(word_dict_file)
+        logger.info("dictionay len = %d" % (len(self.ids_2_word)))
+
+        try:
+            self.eos_id = next(x[0] for x in self.ids_2_word.iteritems()
+                               if x[1] == "<e>")
+            self.unk_id = next(x[0] for x in self.ids_2_word.iteritems()
+                               if x[1] == "<unk>")
+        except StopIteration:
+            logger.fatal(("the word dictionay must contain an ending mark "
+                          "in the text generation task."))
+
+        self.candidate_paths = []
+        self.final_paths = []
+
+    def _top_k(self, softmax_out, k):
+        """
+        get indices of the words with k highest probablities.
+        NOTE: <unk> will be excluded if it is among the top k words, then word
+        with (k + 1)th highest probability will be returned.
+
+        :param softmax_out: probablity over the dictionary
+        :type softmax_out: narray
+        :param k: number of word indices to return
+        :type k: int
+        :return: indices of k words with highest probablities.
+        :rtype: list
+        """
+        ids = softmax_out.argsort()[::-1]
+        return ids[ids != self.unk_id][:k]
+
+    def _forward_batch(self, batch):
+        """
+        forward a test batch.
+
+        :params batch: the input data batch
+        :type batch: list
+        :return: probablities of the predicted word
+        :rtype: ndarray
+        """
+        return self.inferer.infer(input=batch, field=["value"])
+
+    def _beam_expand(self, next_word_prob):
+        """
+        In every iteration step, the model predicts the possible next words.
+        For each input sentence, the top k words is added to end of the original
+        sentence to form a new generated sentence.
+
+        :param next_word_prob: probablities of the next words
+        :type next_word_prob: ndarray
+        :return: the expanded new sentences.
+        :rtype: list
+        """
+        assert len(next_word_prob) == len(self.candidate_paths), (
+            "Wrong forward computing results!")
+        top_beam_words = np.apply_along_axis(self._top_k, 1, next_word_prob,
+                                             self.beam_size)
+        new_paths = []
+        for i, words in enumerate(top_beam_words):
+            old_path = self.candidate_paths[i]
+            for w in words:
+                log_prob = old_path["log_prob"] + math.log(next_word_prob[i][w])
+                gen_ids = old_path["ids"] + [w]
+                if w == self.eos_id:
+                    self.final_paths.append({
+                        "log_prob": log_prob,
+                        "ids": gen_ids
+                    })
+                else:
+                    new_paths.append({"log_prob": log_prob, "ids": gen_ids})
+        return new_paths
+
+    def _beam_shrink(self, new_paths):
+        """
+        to return the top beam_size generated sequences with the highest
+        probabilities at the end of evey generation iteration.
+
+        :param new_paths: all possible generated sentences
+        :type new_paths: list
+        :return: a state flag to indicate whether to stop beam search
+        :rtype: bool
+        """
+
+        if len(self.final_paths) >= self.beam_size:
+            max_candidate_log_prob = max(
+                new_paths, key=lambda x: x["log_prob"])["log_prob"]
+            min_complete_path_log_prob = min(
+                self.final_paths, key=lambda x: x["log_prob"])["log_prob"]
+            if min_complete_path_log_prob >= max_candidate_log_prob:
+                return True
+
+        new_paths.sort(key=lambda x: x["log_prob"], reverse=True)
+        self.candidate_paths = new_paths[:self.beam_size]
+        return False
+
+    def gen_a_sentence(self, input_sentence):
+        """
+        generating sequence for an given input
+
+        :param input_sentence: one input_sentence
+        :type input_sentence: list
+        :return: the generated word sequences
+        :rtype: list
+        """
+        self.candidate_paths = [{"log_prob": 0., "ids": input_sentence}]
+        input_len = len(input_sentence)
+
+        for i in range(self.max_gen_len):
+            next_word_prob = self._forward_batch(
+                [[x["ids"]] for x in self.candidate_paths])
+            new_paths = self._beam_expand(next_word_prob)
+
+            min_candidate_log_prob = min(
+                new_paths, key=lambda x: x["log_prob"])["log_prob"]
+
+            path_to_remove = [
+                path for path in self.final_paths
+                if path["log_prob"] < min_candidate_log_prob
+            ]
+            for p in path_to_remove:
+                self.final_paths.remove(p)
+
+            if self._beam_shrink(new_paths):
+                self.candidate_paths = []
+                break
+
+        gen_ids = sorted(
+            self.final_paths + self.candidate_paths,
+            key=lambda x: x["log_prob"],
+            reverse=True)[:self.beam_size]
+        self.final_paths = []
+
+        def _to_str(x):
+            text = " ".join(self.ids_2_word[idx]
+                            for idx in x["ids"][input_len:])
+            return "%.4f\t%s" % (x["log_prob"], text)
+
+        return map(_to_str, gen_ids)

generate_sequence_by_rnn_lm/config.py

+#!/usr/bin/env python
+# coding=utf-8
+import os
+
+################## for building word dictionary  ##################
+
+max_word_num = 51200 - 2
+cutoff_word_fre = 0
+
+################## for training task  #########################
+# path of training data
+train_file = "data/train_data_examples.txt"
+# path of testing data, if testing file does not exist,
+# testing will not be performed at the end of each training pass
+test_file = ""
+# path of word dictionary, if this file does not exist,
+# word dictionary will be built from training data.
+vocab_file = "data/word_vocab.txt"
+# directory to save the trained model
+# create a new directory if the directoy does not exist
+model_save_dir = "models"
+
+batch_size = 32  # the number of training examples in one forward/backward pass
+num_passes = 20  # how many passes to train the model
+
+log_period = 50
+save_period_by_batches = 50
+
+use_gpu = True  # to use gpu or not
+trainer_count = 1  # number of trainer
+
+##################  for model configuration  ##################
+rnn_type = "lstm"  # "gru" or "lstm"
+emb_dim = 256
+hidden_size = 256
+stacked_rnn_num = 2
+
+##################  for text generation  ##################
+gen_file = "data/train_data_examples.txt"
+gen_result = "data/gen_result.txt"
+max_gen_len = 25  # the max number of words to generate
+beam_size = 5
+model_path = "models/rnn_lm_pass_00000.tar.gz"
+
+if not os.path.exists(model_save_dir):
+    os.mkdir(model_save_dir)

generate_sequence_by_rnn_lm/data/train_data_examples.txt

+我们 不会 伤害 你 的 。 他们 也 这么 说 。
+你 拥有 你 父亲 皇室 的 血统 。 是 合法 的 继承人 。
+叫 什么 你 可以 告诉 我 。
+你 并 没有 留言 说 要 去 哪里 。 是 的 , 因为 我 必须 要 去 完成 这件 事 。
+你 查出 是 谁 住 在 隔壁 房间 吗 ?

generate_sequence_by_rnn_lm/generate.py

+# coding=utf-8
+import os
+import gzip
+import numpy as np
+
+import paddle.v2 as paddle
+
+from utils import logger, load_dict
+from beam_search import BeamSearch
+import config as conf
+from network_conf import rnn_lm
+
+
+def rnn_generate(gen_input_file, model_path, max_gen_len, beam_size,
+                 word_dict_file):
+    """
+    use RNN model to generate sequences.
+
+    :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
+    """
+
+    assert os.path.exists(gen_input_file), "test file does not exist!"
+    assert os.path.exists(model_path), "trained model does not exist!"
+    assert os.path.exists(
+        word_dict_file), "word dictionary file does not exist!"
+
+    # load word dictionary
+    word_2_ids = load_dict(word_dict_file)
+    try:
+        UNK_ID = word_2_ids["<unk>"]
+    except KeyError:
+        logger.fatal("the word dictionary must contain a <unk> token!")
+        sys.exit(-1)
+
+    # initialize paddle
+    paddle.init(use_gpu=conf.use_gpu, trainer_count=conf.trainer_count)
+
+    # load the trained model
+    pred_words = rnn_lm(
+        len(word_2_ids),
+        conf.emb_dim,
+        conf.hidden_size,
+        conf.stacked_rnn_num,
+        conf.rnn_type,
+        is_infer=True)
+
+    parameters = paddle.parameters.Parameters.from_tar(
+        gzip.open(model_path, "r"))
+
+    inferer = paddle.inference.Inference(
+        output_layer=pred_words, parameters=parameters)
+
+    generator = BeamSearch(inferer, word_dict_file, beam_size, max_gen_len)
+    # generate text
+    with open(conf.gen_file, "r") as fin, open(conf.gen_result, "w") as fout:
+        for idx, line in enumerate(fin):
+            fout.write("%d\t%s" % (idx, line))
+            for gen_res in generator.gen_a_sentence([
+                    word_2_ids.get(w, UNK_ID)
+                    for w in line.lower().strip().split()
+            ]):
+                fout.write("%s\n" % gen_res)
+            fout.write("\n")
+
+
+if __name__ == "__main__":
+    rnn_generate(conf.gen_file, conf.model_path, conf.max_gen_len,
+                 conf.beam_size, conf.vocab_file)

generate_sequence_by_rnn_lm/index.html

+
+<html>
+<head>
+  <script type="text/x-mathjax-config">
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js", "TeX/AMSsymbols.js", "TeX/AMSmath.js"],
+    jax: ["input/TeX", "output/HTML-CSS"],
+    tex2jax: {
+      inlineMath: [ ['$','$'] ],
+      displayMath: [ ['$$','$$'] ],
+      processEscapes: true
+    },
+    "HTML-CSS": { availableFonts: ["TeX"] }
+  });
+  </script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js" async></script>
+  <script type="text/javascript" src="../.tools/theme/marked.js">
+  </script>
+  <link href="http://cdn.bootcss.com/highlight.js/9.9.0/styles/darcula.min.css" rel="stylesheet">
+  <script src="http://cdn.bootcss.com/highlight.js/9.9.0/highlight.min.js"></script>
+  <link href="http://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.min.css" rel="stylesheet">
+  <link href="https://cdn.jsdelivr.net/perfect-scrollbar/0.6.14/css/perfect-scrollbar.min.css" rel="stylesheet">
+  <link href="../.tools/theme/github-markdown.css" rel='stylesheet'>
+</head>
+<style type="text/css" >
+.markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+}
+</style>
+
+
+<body>
+
+<div id="context" class="container-fluid markdown-body">
+</div>
+
+<!-- This block will be replaced by each markdown file content. Please do not change lines below.-->
+<div id="markdown" style='display:none'>
+# 使用循环神经网语言模型生成文本
+
+语言模型(Language Model)是一个概率分布模型，简单来说，就是用来计算一个句子的概率的模型。利用它可以确定哪个词序列的可能性更大，或者给定若干个词，可以预测下一个最可能出现的词。语言模型是自然语言处理领域里一个重要的基础模型。
+
+## 应用场景
+**语言模型被应用在很多领域**，如：
+
+* **自动写作**：语言模型可以根据上文生成下一个词，递归下去可以生成整个句子、段落、篇章。
+* **QA**：语言模型可以根据Question生成Answer。
+* **机器翻译**：当前主流的机器翻译模型大多基于Encoder-Decoder模式，其中Decoder就是一个待条件的语言模型，用来生成目标语言。
+* **拼写检查**：语言模型可以计算出词序列的概率，一般在拼写错误处序列的概率会骤减，可以用来识别拼写错误并提供改正候选集。
+* **词性标注、句法分析、语音识别......**
+
+## 关于本例
+本例实现基于RNN的语言模型，以及利用语言模型生成文本，本例的目录结构如下：
+
+```text
+.
+├── data
+│   └── train_data_examples.txt        # 示例数据，可参考示例数据的格式，提供自己的数据
+├── config.py    # 配置文件，包括data、train、infer相关配置
+├── generate.py  # 预测任务脚本，即生成文本
+├── beam_search.py    # beam search 算法实现
+├── network_conf.py   # 本例中涉及的各种网络结构均定义在此文件中，希望进一步修改模型结构，请修改此文件
+├── reader.py    # 读取数据接口
+├── README.md
+├── train.py    # 训练任务脚本
+└── utils.py    # 定义通用的函数，例如：构建字典、加载字典等
+```
+
+## RNN 语言模型
+### 简介
+
+RNN是一个序列模型，基本思路是：在时刻$t$，将前一时刻$t-1$的隐藏层输出和$t$时刻的词向量一起输入到隐藏层从而得到时刻$t$的特征表示，然后用这个特征表示得到$t$时刻的预测输出，如此在时间维上递归下去。可以看出RNN善于使用上文信息、历史知识，具有“记忆”功能。理论上RNN能实现“长依赖”（即利用很久之前的知识），但在实际应用中发现效果并不理想，研究提出了LSTM和GRU等变种，通过引入门机制对传统RNN的记忆单元进行了改进，弥补了传统RNN在学习长序列时遇到的难题。本例模型使用了LSTM或GRU，可通过配置进行修改。下图是RNN（广义上包含了LSTM、GRU等）语言模型“循环”思想的示意图：
+
+<p align=center><img src='images/rnn.png' width='500px'/></p>
+
+### 模型实现
+
+本例中RNN语言模型的实现简介如下：
+
+- **定义模型参数**：`config.py`中定义了模型的参数变量。
+- **定义模型结构**：`network_conf.py`中的`rnn_lm`**函数**中定义了模型的**结构**，如下：
+    - 输入层：将输入的词（或字）序列映射成向量，即词向量层： `embedding`。
+    - 中间层：根据配置实现RNN层，将上一步得到的`embedding`向量序列作为输入。
+    - 输出层：使用`softmax`归一化计算单词的概率。
+    - loss：定义多类交叉熵作为模型的损失函数。
+- **训练模型**：`train.py`中的`main`方法实现了模型的训练，实现流程如下：
+    - 准备输入数据：建立并保存词典、构建train和test数据的reader。
+    - 初始化模型：包括模型的结构、参数。
+    - 构建训练器：demo中使用的是Adam优化算法。
+    - 定义回调函数：构建`event_handler`来跟踪训练过程中loss的变化，并在每轮训练结束时保存模型的参数。
+    - 训练：使用trainer训练模型。
+
+- **生成文本**：`generate.py` 实现了文本的生成，实现流程如下：
+    - 加载训练好的模型和词典文件。
+    - 读取`gen_file`文件，每行是一个句子的前缀，用[柱搜索算法(Beam Search)](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md#柱搜索算法)根据前缀生成文本。
+    - 将生成的文本及其前缀保存到文件`gen_result`。
+
+## 使用说明
+
+运行本例的方法如下：
+
+* 1，运行`python train.py`命令，开始train模型（默认使用RNN），待训练结束。
+* 2，运行`python generate.py`运行文本生成。（输入的文本默认为`data/train_data_examples.txt`，生成的文本默认保存到`data/gen_result.txt`中。）
+
+
+**如果需要使用自己的语料、定制模型，需要修改`config.py`中的配置，细节和适配工作详情如下：**
+
+
+### 语料适配
+
+* 清洗语料：去除原文中空格、tab、乱码，按需去除数字、标点符号、特殊符号等。
+* 内容格式：每个句子占一行；每行中的各词之间使用一个空格符分开。
+* 按需要配置`config.py`中的如下参数：
+
+    ```python  
+     train_file = "data/train_data_examples.txt"
+     test_file = ""
+
+     vocab_file = "data/word_vocab.txt"
+     model_save_dir = "models"
+    ```
+    1. `train_file`：指定训练数据的路径，**需要预先分词**。
+    2. `test_file`：指定测试数据的路径，如果训练数据不为空，将在每个 `pass` 训练结束对指定的测试数据进行测试。
+    3. `vocab_file`：指定字典的路径，如果字典文件不存在，将会对训练语料进行词频统计，构建字典。
+    4. `model_save_dir`：指定模型保存的路径，如果指定的文件夹不存在，将会自动创建。
+
+### 构建字典的策略
+- 当指定的字典文件不存在时，将对训练数据进行词频统计，自动构建字典`config.py` 中有如下两个参数与构建字典有关：
+
+    ```python
+    max_word_num = 51200 - 2
+    cutoff_word_fre = 0
+    ```
+    1. `max_word_num`：指定字典中含有多少个词。
+    2. `cutoff_word_fre`：字典中词语在训练语料中出现的最低频率。
+- 加入指定了 `max_word_num = 5000`，并且 `cutoff_word_fre = 10`，词频统计发现训练语料中出现频率高于10次的词语仅有3000个，那么最终会取3000个词构成词典。
+- 构建词典时，会自动加入两个特殊符号：
+    1. `<unk>`：不出现在字典中的词
+    2. `<e>`：句子的结束符
+
+    *注：需要注意的是，词典越大生成的内容越丰富，但训练耗时越久。一般中文分词之后，语料中不同的词能有几万乃至几十万，如果`max_word_num`取值过小则导致`<unk>`占比过高，如果`max_word_num`取值较大，则严重影响训练速度（对精度也有影响）。所以，也有“按字”训练模型的方式，即：把每个汉字当做一个词，常用汉字也就几千个，使得字典的大小不会太大、不会丢失太多信息，但汉语中同一个字在不同词中语义相差很大，有时导致模型效果不理想。建议多试试、根据实际情况选择是“按词训练”还是“按字训练”。*
+
+### 模型适配、训练
+
+* 按需调整`config.py`中如下配置，来修改 rnn 语言模型的网络结果：
+
+    ```python
+    rnn_type = "lstm"  # "gru" or "lstm"
+    emb_dim = 256
+    hidden_size = 256
+    stacked_rnn_num = 2
+    ```
+    1. `rnn_type`：支持 ”gru“ 或者 ”lstm“ 两种参数，选择使用何种 RNN 单元。
+    2. `emb_dim`：设置词向量的维度。
+    3. `hidden_size`：设置 RNN 单元隐层大小。
+    4. `stacked_rnn_num`：设置堆叠 RNN 单元的个数，构成一个更深的模型。
+
+* 运行`python train.py`命令训练模型，模型将被保存到`model_save_dir`指定的目录。
+
+### 按需生成文本
+
+* 按需调整`config.py`中以下变量，详解如下：
+
+    ```python
+    gen_file = "data/train_data_examples.txt"
+    gen_result = "data/gen_result.txt"
+    max_gen_len = 25  # the max number of words to generate
+    beam_size = 5
+    model_path = "models/rnn_lm_pass_00000.tar.gz"
+    ```
+    1. `gen_file`：指定输入数据文件，每行是一个句子的前缀，**需要预先分词**。
+    2. `gen_result`：指定输出文件路径，生成结果将写入此文件。
+    3. `max_gen_len`：指定每一句生成的话最长长度，如果模型无法生成出`<e>`，当生成 `max_gen_len` 个词语后，生成过程会自动终止。
+    4. `beam_size`：Beam Search 算法每一步的展开宽度。
+    5. `model_path`：指定训练好的模型的路径。
+
+    其中，`gen_file` 中保存的是待生成的文本前缀，每个前缀占一行，形如：
+
+    ```text
+    若隐若现 地像 幽灵 , 像 死神
+    ```
+    将需要生成的文本前缀按此格式存入文件即可；
+
+* 运行`python generate.py`命令运行beam search 算法为输入前缀生成文本，下面是模型生成的结果：
+
+    ```text
+    81    若隐若现 地像 幽灵 , 像 死神
+    -12.2542    一样 。 他 是 个 怪物 <e>
+    -12.6889    一样 。 他 是 个 英雄 <e>
+    -13.9877    一样 。 他 是 我 的 敌人 <e>
+    -14.2741    一样 。 他 是 我 的 <e>
+    -14.6250    一样 。 他 是 我 的 朋友 <e>
+    ```
+    其中：
+    1. 第一行 `81    若隐若现 地像 幽灵 , 像 死神`以`\t`为分隔，共有两列：
+        - 第一列是输入前缀在训练样本集中的序号。
+        - 第二列是输入的前缀。
+    2. 第二 ~ `beam_size + 1` 行是生成结果，同样以 `\t` 分隔为两列：
+        - 第一列是该生成序列的对数概率（log probability）。
+        - 第二列是生成的文本序列，正常的生成结果会以符号`<e>`结尾，如果没有以`<e>`结尾，意味着超过了最大序列长度，生成强制终止。
+
+</div>
+<!-- You can change the lines below now. -->
+
+<script type="text/javascript">
+marked.setOptions({
+  renderer: new marked.Renderer(),
+  gfm: true,
+  breaks: false,
+  smartypants: true,
+  highlight: function(code, lang) {
+    code = code.replace(/&amp;/g, "&")
+    code = code.replace(/&gt;/g, ">")
+    code = code.replace(/&lt;/g, "<")
+    code = code.replace(/&nbsp;/g, " ")
+    return hljs.highlightAuto(code, [lang]).value;
+  }
+});
+document.getElementById("context").innerHTML = marked(
+        document.getElementById("markdown").innerHTML)
+</script>
+</body>

generate_sequence_by_rnn_lm/network_conf.py

+# coding=utf-8
+
+import paddle.v2 as paddle
+
+
+def rnn_lm(vocab_dim,
+           emb_dim,
+           hidden_size,
+           stacked_rnn_num,
+           rnn_type="lstm",
+           is_infer=False):
+    """
+    RNN language model definition.
+
+    :param vocab_dim: size of vocabulary.
+    :type vocab_dim: int
+    :param emb_dim: dimension of the embedding vector
+    :type emb_dim: int
+    :param rnn_type: the type of RNN cell.
+    :type rnn_type: int
+    :param hidden_size: number of hidden unit.
+    :type hidden_size: int
+    :param stacked_rnn_num: number of stacked rnn cell.
+    :type stacked_rnn_num: int
+    :return: cost and output layer of model.
+    :rtype: LayerOutput
+    """
+
+    # input layers
+    input = paddle.layer.data(
+        name="input", type=paddle.data_type.integer_value_sequence(vocab_dim))
+    if not is_infer:
+        target = paddle.layer.data(
+            name="target",
+            type=paddle.data_type.integer_value_sequence(vocab_dim))
+
+    # embedding layer
+    input_emb = paddle.layer.embedding(input=input, size=emb_dim)
+
+    # rnn layer
+    if rnn_type == "lstm":
+        for i in range(stacked_rnn_num):
+            rnn_cell = paddle.networks.simple_lstm(
+                input=rnn_cell if i else input_emb, size=hidden_size)
+    elif rnn_type == "gru":
+        for i in range(stacked_rnn_num):
+            rnn_cell = paddle.networks.simple_gru(
+                input=rnn_cell if i else input_emb, size=hidden_size)
+    else:
+        raise Exception("rnn_type error!")
+
+    # fc(full connected) and output layer
+    output = paddle.layer.fc(
+        input=[rnn_cell], size=vocab_dim, act=paddle.activation.Softmax())
+
+    if is_infer:
+        last_word = paddle.layer.last_seq(input=output)
+        return last_word
+    else:
+        cost = paddle.layer.classification_cost(input=output, label=target)
+
+        return cost, output

generate_sequence_by_rnn_lm/reader.py

+# coding=utf-8
+import collections
+import os
+
+MIN_LEN = 3
+MAX_LEN = 100
+
+
+def rnn_reader(file_name, word_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_dict: vocab with content of '{word, id}',
+                      'word' is string type , 'id' is int type.
+    :return: data reader.
+    """
+
+    def reader():
+        UNK_ID = word_dict['<unk>']
+        with open(file_name) as file:
+            for line in file:
+                words = line.strip().lower().split()
+                if len(words) < MIN_LEN or len(words) > MAX_LEN:
+                    continue
+                ids = [word_dict.get(w, UNK_ID)
+                       for w in words] + [word_dict['<e>']]
+                yield ids[:-1], ids[1:]
+
+    return reader

generate_sequence_by_rnn_lm/train.py

+#!/usr/bin/env python
+# coding=utf-8
+import os
+import sys
+import gzip
+import pdb
+
+import paddle.v2 as paddle
+import config as conf
+import reader
+from network_conf import rnn_lm
+from utils import logger, build_dict, load_dict
+
+
+def train(topology,
+          train_reader,
+          test_reader,
+          model_save_dir="models",
+          num_passes=10):
+    """
+    train model.
+
+    :param topology: cost layer of the model to train.
+    :type topology: LayerOuput
+    :param train_reader: train data reader.
+    :type trainer_reader: collections.Iterable
+    :param test_reader: test data reader.
+    :type test_reader: collections.Iterable
+    :param model_save_dir: path to save the trained model
+    :type model_save_dir: str
+    :param num_passes: number of epoch
+    :type num_passes: int
+    """
+    if not os.path.exists(model_save_dir):
+        os.mkdir(model_save_dir)
+
+    # initialize PaddlePaddle
+    paddle.init(
+        use_gpu=conf.use_gpu, gpu_id=3, trainer_count=conf.trainer_count)
+
+    # 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 parameters
+    parameters = paddle.parameters.create(topology)
+    # create trainer
+    trainer = paddle.trainer.SGD(
+        cost=topology, parameters=parameters, update_equation=adam_optimizer)
+
+    # define the event_handler callback
+    def event_handler(event):
+        if isinstance(event, paddle.event.EndIteration):
+            if not event.batch_id % conf.log_period:
+                logger.info("Pass %d, Batch %d, Cost %f, %s" % (
+                    event.pass_id, event.batch_id, event.cost, event.metrics))
+
+            if (not event.batch_id %
+                    conf.save_period_by_batches) and event.batch_id:
+                save_name = os.path.join(model_save_dir,
+                                         "rnn_lm_pass_%05d_batch_%03d.tar.gz" %
+                                         (event.pass_id, event.batch_id))
+                with gzip.open(save_name, "w") as f:
+                    parameters.to_tar(f)
+
+        if isinstance(event, paddle.event.EndPass):
+            if test_reader is not None:
+                result = trainer.test(reader=test_reader)
+                logger.info("Test with Pass %d, %s" %
+                            (event.pass_id, result.metrics))
+            save_name = os.path.join(model_save_dir, "rnn_lm_pass_%05d.tar.gz" %
+                                     (event.pass_id))
+            with gzip.open(save_name, "w") as f:
+                parameters.to_tar(f)
+
+    logger.info("start training...")
+    trainer.train(
+        reader=train_reader, event_handler=event_handler, num_passes=num_passes)
+
+    logger.info("Training is finished.")
+
+
+def main():
+    # prepare vocab
+    if not (os.path.exists(conf.vocab_file) and
+            os.path.getsize(conf.vocab_file)):
+        logger.info(("word dictionary does not exist, "
+                     "build it from the training data"))
+        build_dict(conf.train_file, conf.vocab_file, conf.max_word_num,
+                   conf.cutoff_word_fre)
+    logger.info("load word dictionary.")
+    word_dict = load_dict(conf.vocab_file)
+    logger.info("dictionay size = %d" % (len(word_dict)))
+
+    cost = rnn_lm(
+        len(word_dict), conf.emb_dim, conf.hidden_size, conf.stacked_rnn_num,
+        conf.rnn_type)
+
+    # define reader
+    reader_args = {
+        "file_name": conf.train_file,
+        "word_dict": word_dict,
+    }
+    train_reader = paddle.batch(
+        paddle.reader.shuffle(
+            reader.rnn_reader(**reader_args), buf_size=102400),
+        batch_size=conf.batch_size)
+    test_reader = None
+    if os.path.exists(conf.test_file) and os.path.getsize(conf.test_file):
+        test_reader = paddle.batch(
+            paddle.reader.shuffle(
+                reader.rnn_reader(**reader_args), buf_size=65536),
+            batch_size=config.batch_size)
+
+    train(
+        topology=cost,
+        train_reader=train_reader,
+        test_reader=test_reader,
+        model_save_dir=conf.model_save_dir,
+        num_passes=conf.num_passes)
+
+
+if __name__ == "__main__":
+    main()

generate_sequence_by_rnn_lm/utils.py

+#!/usr/bin/env python
+# coding=utf-8
+import os
+import logging
+from collections import defaultdict
+
+__all__ = ["build_dict", "load_dict"]
+
+logger = logging.getLogger("paddle")
+logger.setLevel(logging.DEBUG)
+
+
+def build_dict(data_file,
+               save_path,
+               max_word_num,
+               cutoff_word_fre=5,
+               insert_extra_words=["<unk>", "<e>"]):
+    """
+    :param data_file: path of data file
+    :type data_file: str
+    :param save_path: path to save the word dictionary
+    :type save_path: str
+    :param vocab_max_size: if vocab_max_size is set, top vocab_max_size words
+        will be added into word vocabulary
+    :type vocab_max_size: int
+    :param cutoff_thd: if cutoff_thd is set, words whose frequencies are less
+        than cutoff_thd will not be added into word vocabulary.
+        NOTE that: vocab_max_size and cutoff_thd cannot be set at the same time
+    :type cutoff_word_fre: int
+    :param extra_keys: extra keys defined by users that added into the word
+        dictionary, ususally these keys include <unk>, start and ending marks
+    :type extra_keys: list
+    """
+    word_count = defaultdict(int)
+    with open(data_file, "r") as f:
+        for idx, line in enumerate(f):
+            if not (idx + 1) % 100000:
+                logger.debug("processing %d lines ... " % (idx + 1))
+            words = line.strip().lower().split()
+            for w in words:
+                word_count[w] += 1
+
+    sorted_words = sorted(
+        word_count.iteritems(), key=lambda x: x[1], reverse=True)
+
+    stop_pos = len(sorted_words) if sorted_words[-1][
+        1] > cutoff_word_fre else next(idx for idx, v in enumerate(sorted_words)
+                                       if v[1] < cutoff_word_fre)
+
+    stop_pos = min(max_word_num, stop_pos)
+    with open(save_path, "w") as fdict:
+        for w in insert_extra_words:
+            fdict.write("%s\t-1\n" % (w))
+        for idx, info in enumerate(sorted_words):
+            if idx == stop_pos: break
+            fdict.write("%s\t%d\n" % (info[0], info[-1]))
+
+
+def load_dict(dict_path):
+    """
+    load word dictionary from the given file. Each line of the give file is
+    a word in the word dictionary. The first column of the line, seperated by
+    TAB, is the key, while the line index is the value.
+
+    :param dict_path: path of word dictionary
+    :type dict_path: str
+    :return: the dictionary
+    :rtype: dict
+    """
+    return dict((line.strip().split("\t")[0], idx)
+                for idx, line in enumerate(open(dict_path, "r").readlines()))
+
+
+def load_reverse_dict(dict_path):
+    """
+    load word dictionary from the given file. Each line of the give file is
+    a word in the word dictionary. The line index is the key, while the first
+    column of the line, seperated by TAB, is the value.
+
+    :param dict_path: path of word dictionary
+    :type dict_path: str
+    :return: the dictionary
+    :rtype: dict
+    """
+    return dict((idx, line.strip().split("\t")[0])
+                for idx, line in enumerate(open(dict_path, "r").readlines()))

hsigmoid/infer.py

@@ -11,7 +11,7 @@ logger = logging.getLogger("paddle")
 logger.setLevel(logging.WARNING)
 
 
-def decode_res(infer_res, dict_size):
+def decode_result(infer_res, dict_size):
     """
     Inferring probabilities are orginized as a complete binary tree.
     The actual labels are leaves (indices are counted from class number).
@@ -41,10 +41,10 @@ def decode_res(infer_res, dict_size):
     return predict_lbls
 
 
-def predict(batch_ins, idx_word_dict, dict_size, inferer):
+def infer_a_batch(batch_ins, idx_word_dict, dict_size, inferer):
     infer_res = inferer.infer(input=batch_ins)
 
-    predict_lbls = decode_res(infer_res, dict_size)
+    predict_lbls = decode_result(infer_res, dict_size)
     predict_words = [idx_word_dict[lbl] for lbl in predict_lbls]  # map to word
 
     # Ouput format: word1 word2 word3 word4 -> predict label
@@ -53,7 +53,7 @@ def predict(batch_ins, idx_word_dict, dict_size, inferer):
                         for w in ins]) + " -> " + predict_words[i])
 
 
-def main(model_path):
+def infer(model_path, batch_size):
     assert os.path.exists(model_path), "trained model does not exist."
 
     paddle.init(use_gpu=False, trainer_count=1)
@@ -68,19 +68,17 @@ def main(model_path):
     inferer = paddle.inference.Inference(
         output_layer=prediction_layer, parameters=parameters)
     idx_word_dict = dict((v, k) for k, v in word_dict.items())
-    batch_size = 64
-    batch_ins = []
-    ins_iter = paddle.dataset.imikolov.test(word_dict, 5)
 
-    for ins in ins_iter():
+    batch_ins = []
+    for ins in paddle.dataset.imikolov.test(word_dict, 5)():
         batch_ins.append(ins[:-1])
         if len(batch_ins) == batch_size:
-            predict(batch_ins, idx_word_dict, dict_size, inferer)
+            infer_a_batch(batch_ins, idx_word_dict, dict_size, inferer)
             batch_ins = []
 
     if len(batch_ins) > 0:
-        predict(batch_ins, idx_word_dict, dict_size, inferer)
+        infer_a_batch(batch_ins, idx_word_dict, dict_size, inferer)
 
 
 if __name__ == "__main__":
-    main("models/hsigmoid_batch_00010.tar.gz")
+    infer("models/hsigmoid_batch_00010.tar.gz", 20)

language_model/README.md

-# 语言模型
-
-## 简介
-语言模型即 Language Model，简称LM。它是一个概率分布模型，简单来说，就是用来计算一个句子的概率的模型。利用它可以确定哪个词序列的可能性更大，或者给定若干个词，可以预测下一个最可能出现的词。语言模型是自然语言处理领域里一个重要的基础模型。
-
-## 应用场景
-**语言模型被应用在很多领域**，如：
-
-* **自动写作**：语言模型可以根据上文生成下一个词，递归下去可以生成整个句子、段落、篇章。
-* **QA**：语言模型可以根据Question生成Answer。
-* **机器翻译**：当前主流的机器翻译模型大多基于Encoder-Decoder模式，其中Decoder就是一个语言模型，用来生成目标语言。
-* **拼写检查**：语言模型可以计算出词序列的概率，一般在拼写错误处序列的概率会骤减，可以用来识别拼写错误并提供改正候选集。
-* **词性标注、句法分析、语音识别......**
-
-## 关于本例
-Language Model 常见的实现方式有 N-Gram、RNN、seq2seq。本例中实现了基于N-Gram、RNN的语言模型。**本例的文件结构如下**（`images` 文件夹与使用无关可不关心）：
-
-
-```text
-.
-├── data                    # toy、demo数据，用户可据此格式化自己的数据
-│   ├── chinese.test.txt    # test用的数据demo
-|   ├── chinese.train.txt   # train用的数据demo
-│   └── input.txt           # infer用的输入数据demo
-├── config.py               # 配置文件，包括data、train、infer相关配置
-├── infer.py                # 预测任务脚本，即生成文本
-├── network_conf.py         # 本例中涉及的各种网络结构均定义在此文件中，希望进一步修改模型结构，请修改此文件
-├── reader.py               # 读取数据接口
-├── README.md               # 文档
-├── train.py                # 训练任务脚本
-└── utils.py                # 定义通用的函数，例如：构建字典、加载字典等
-```
-
-**注：一般情况下基于N-Gram的语言模型不如基于RNN的语言模型效果好，所以实际使用时建议使用基于RNN的语言模型，本例中也将着重介绍基于RNN的模型，简略介绍基于N-Gram的模型。**
-
-## RNN 语言模型
-### 简介
-
-RNN是一个序列模型，基本思路是：在时刻t，将前一时刻t-1的隐藏层输出和t时刻的词向量一起输入到隐藏层从而得到时刻t的特征表示，然后用这个特征表示得到t时刻的预测输出，如此在时间维上递归下去。可以看出RNN善于使用上文信息、历史知识，具有“记忆”功能。理论上RNN能实现“长依赖”（即利用很久之前的知识），但在实际应用中发现效果并不理想，于是出现了很多RNN的变种，如常用的LSTM和GRU，它们对传统RNN的cell进行了改进，弥补了传统RNN的不足，本例中即使用了LSTM、GRU。下图是RNN（广义上包含了LSTM、GRU等）语言模型“循环”思想的示意图：
-
-<p align=center><img src='images/rnn.png' width='500px'/></p>
-
-### 模型实现
-
-本例中RNN语言模型的实现简介如下：
-
-* **定义模型参数**：`config.py`中的`Config_rnn`**类**中定义了模型的参数变量。
-* **定义模型结构**：`network_conf.py`中的`rnn_lm`**函数**中定义了模型的**结构**，如下：
-    * 输入层：将输入的词（或字）序列映射成向量，即embedding。
-    * 中间层：根据配置实现RNN层，将上一步得到的embedding向量序列作为输入。
-    * 输出层：使用softmax归一化计算单词的概率，将output结果返回
-    * loss：定义模型的cost为多类交叉熵损失函数。
-* **训练模型**：`train.py`中的`main`方法实现了模型的训练，实现流程如下：
-    * 准备输入数据：建立并保存词典、构建train和test数据的reader。
-    * 初始化模型：包括模型的结构、参数。
-    * 构建训练器：demo中使用的是Adam优化算法。
-    * 定义回调函数：构建`event_handler`来跟踪训练过程中loss的变化，并在每轮训练结束时保存模型的参数。
-    * 训练：使用trainer训练模型。
-
-* **生成文本**：`infer.py`中的`main`方法实现了文本的生成，实现流程如下：
-    * 根据配置选择生成方法：RNN模型 or N-Gram模型。
-    * 加载train好的模型和词典文件。
-    * 读取`input_file`文件（每行为一个sentence的前缀），用启发式图搜索算法`beam_search`根据各sentence的前缀生成文本。
-    * 将生成的文本及其前缀保存到文件`output_file`。
-
-
-## N-Gram 语言模型
-
-### 简介
-N-Gram模型也称为N-1阶马尔科夫模型，它有一个有限历史假设：当前词的出现概率仅仅与前面N-1个词相关。一般采用最大似然估计（Maximum Likelihood Estimation，MLE）方法对模型的参数进行估计。当N取1、2、3时，N-Gram模型分别称为unigram、bigram和trigram语言模型。一般情况下，N越大、训练语料的规模越大，参数估计的结果越可靠，但由于模型较简单、表达能力不强以及数据稀疏等问题。一般情况下用N-Gram实现的语言模型不如RNN、seq2seq效果好。下图是基于神经网络的N-Gram语言模型结构示意图：
-
-<p align=center><img src='images/ngram.png' width='500px'/></p>
-
-### 模型实现
-
-本例中N-Gram语言模型的实现简介如下：
-
-* **定义模型参数**：`config.py`中的`Config_ngram`**类**中定义了模型的参数变量。
-* **定义模型结构**：`network_conf.py`中的`ngram_lm`**函数**中定义了模型的**结构**，如下：
-    * 输入层：本例中N取5，将前四个词分别做embedding，然后连接起来作为输入。
-    * 中间层：根据配置实现DNN层，将上一步得到的embedding向量序列作为输入。
-    * 输出层：使用softmax归一化计算单词的概率，将output结果返回
-    * loss：定义模型的cost为多类交叉熵损失函数。
-* **训练模型**：`train.py`中的`main`方法实现了模型的训练，实现流程与上文中RNN语言模型基本一致。
-* **生成文本**：`infer.py`中的`main`方法实现了文本的生成，实现流程与上文中RNN语言模型基本一致，区别在于构建input时本例会取每个前缀的最后4（N-1）个词作为输入。
-
-## 使用说明
-
-运行本例的方法如下：
-
-* 1，运行`python train.py`命令，开始train模型（默认使用RNN），待训练结束。
-* 2，运行`python infer.py`命令做prediction。（输入的文本默认为`data/input.txt`，生成的文本默认保存到`data/output.txt`中。）
-
-
-**如果用户需要使用自己的语料、定制模型，需要修改的地方主要是`语料`和`config.py`中的配置，需要注意的细节和适配工作详情如下：**
-
-
-### 语料适配
-
-* 清洗语料：去除原文中空格、tab、乱码，按需去除数字、标点符号、特殊符号等。
-* 编码格式：utf-8，本例中已经对中文做了适配。
-* 内容格式：每个句子占一行；每行中的各词之间使用一个空格符分开。
-* 按需要配置`config.py`中对于data的配置：
-
-    ```python
-    # -- 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
-    ```
-
-    其中，`build_vocab_method `指定了构建词典的方法：**1，按词频**，即将出现次数小于`unk_threshold `的词视为`<UNK>`；**2，按词典长度**，`vocab_max_size`定义了词典的最大长度，如果语料中出现的不同词的个数大于这个值，则根据各词的词频倒序排，取`top(vocab_max_size)`个词纳入词典。
-
-    其中`min_sentence_length`和`max_sentence_length `分别指定了句子的最小和最大长度，小于最小长度的和大于最大长度的句子将被过滤掉、不参与训练。
-
-    *注：需要注意的是词典越大生成的内容越丰富但训练耗时越久，一般中文分词之后，语料中不同的词能有几万乃至几十万，如果vocab\_max\_size取值过小则导致\<UNK\>占比过高，如果vocab\_max\_size取值较大则严重影响训练速度（对精度也有影响），所以也有“按字”训练模型的方式，即：把每个汉字当做一个词，常用汉字也就几千个，使得字典的大小不会太大、不会丢失太多信息，但汉语中同一个字在不同词中语义相差很大，有时导致模型效果不理想。建议用户多试试、根据实际情况选择是“按词训练”还是“按字训练”。*
-
-### 模型适配、训练
-
-* 按需调整`config.py`中对于模型的配置，详解如下：
-
-    ```python
-    # -- config : train --
-
-    use_which_model = 'rnn'  # 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_'
-    ```
-
-    其中，`use_which_model`指定了要train的模型，如果使用RNN语言模型则设置为'rnn'，如果使用N-Gram语言模型则设置为'ngram'；`use_gpu`指定了train的时候是否使用gpu；`trainer_count`指定了并行度、用几个trainer去train模型；`rnn_type` 用于配置rnn cell类型，可以取‘lstm’或‘gru’；`hidden_size`配置unit个数；`num_layer`配置RNN的层数；`num_passs`配置训练的轮数；`emb_dim`配置embedding的dimension；`batch_size `配置了train model时每个batch的大小；`model_file_name_prefix `配置了要保存的模型的名字前缀。
-
-* 运行`python train.py`命令训练模型，模型将被保存到当前目录。
-
-### 按需生成文本
-
-* 按需调整`config.py`中对于infer的配置，详解如下：
-
-    ```python
-    # -- 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
-    ```
-
-    其中，`input_file`中保存的是待生成的文本前缀，utf-8编码，每个前缀占一行，形如：
-
-    ```text
-    我
-    我 是
-    ```
-    用户将需要生成的文本前缀按此格式存入文件即可；
-    `num_words`指定了要生成多少个单词（实际生成过程中遇到结束符会停止生成，所以实际生成的词个数可能会比此值小）；`beam_size`指定了beam search方法的width，即每个前缀生成多少个候选词序列；`output_file`指定了生成结果的存放位置。
-
-* 运行`python infer.py`命令生成文本，生成的结果格式如下：
-
-    ```text
-    我
-        我 <EOS>    0.107702672482
-        我 爱 。我 中国 中国 <EOS>    0.000177299271939
-        我 爱 中国 。我 是 中国 <EOS>    4.51695544709e-05
-        我 爱 中国 中国 <EOS>    0.000910127729821
-        我 爱 中国 。我 是 <EOS>    0.00015957862922
-    ```
-    其中，‘我’是前缀，其下方的五个句子时补全的结果，每个句子末尾的浮点数表示此句子的生成概率。

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, gram_num=4):
-    """
-    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: number of hidden layers.
-    :param gram_size: gram number in n-gram method
-    :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
-    emb_layers = []
-    for i in range(gram_num):
-        word = paddle.layer.data(
-            name="__word%02d__" % (i + 1),
-            type=paddle.data_type.integer_value(vocab_size))
-        emb = paddle.layer.embedding(
-            input=word,
-            size=emb_dim,
-            param_attr=paddle.attr.Param(name="_proj", initial_std=1e-3))
-        emb_layers.append(emb)
-    next_word = paddle.layer.data(
-        name="__next_word__", type=paddle.data_type.integer_value(vocab_size))
-
-    # hidden layer
-    for i in range(num_layer):
-        hidden = paddle.layer.fc(
-            input=hidden if i else paddle.layer.concat(input=emb_layers),
-            size=hidden_size,
-            act=paddle.activation.Relu())
-
-    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

nce_cost/.gitignore

+*.pyc
+*.tar.gz
+models

nce_cost/README.md

 # 噪声对比估计加速词向量训练
-## 背景介绍
-在自然语言处理领域中，通常使用特征向量来表示一个单词，但是如何使用准确的词向量来表示语义却是一个难点，详细内容可以在[词向量章节](https://github.com/PaddlePaddle/book/blob/develop/04.word2vec/README.cn.md)中查阅到，原作者使用神经概率语言模型（Neural Probabilistic Language Model, NPLM）来训练词向量，尽管 NPLM 有优异的精度表现，但是相对于传统的 N-gram 统计模型，训练时间还是太漫长了\[[3](#参考文献)\]。常用的优化这个问题算法主要有两个：一个是 hierarchical-sigmoid \[[2](#参考文献)\] 另一个 噪声对比估计（Noise-contrastive estimation, NCE）\[[1](#参考文献)\]。为了克服这个问题本文引入了 NCE 方法。本文将以训练 NPLM 作为例子来讲述如何使用 NCE。
 
-## NCE 概览
-NCE 是一种快速对离散分布进行估计的方法，应用到本文中的问题：训练 NPLM 计算开销很大，原因是 softmax 函数计算时需要考虑每个类别的指数项，必须计算字典中的所有单词，而在一般语料集上面字典往往非常大\[[3](#参考文献)\]，从而导致整个训练过程十分耗时。与常用的 hierarchical-sigmoid \[[2](#参考文献)\] 方法相比，NCE 不再使用复杂的二叉树来构造目标函数，而是采用相对简单的随机负采样，以大幅提升计算效率。
+词向量是许多自然语言处理任务的基础，详细介绍可见 PaddleBook 中的[词向量](https://github.com/PaddlePaddle/book/blob/develop/04.word2vec/README.cn.md)一节，其中通过训练神经概率语言模型（Neural Probabilistic Language Model, NPLM）得到词向量，是一种流行的方式。然而，神经概率语言模型的最后一层往往需要计算一个词典之上的概率分布，词典越大这一层的计算量也就越大，往往非常耗时。在models的另一篇我们已经介绍了[Hsigmoid加速词向量训练](https://github.com/PaddlePaddle/models/tree/develop/hsigmoid)，这里我们介绍另一种加速词向量训练的方法：使用噪声对比估计（Noise-contrastive estimation, NCE）损失函数\[[1](#参考文献)\]。
 
+## NCE
+NPLM 的最后一层 `softmax` 函数计算时需要考虑每个类别的指数项，必须计算字典中的所有单词，而在一般语料集上面字典往往非常大\[[3](#参考文献)\]，从而导致整个训练过程十分耗时。NCE 是一种快速对离散分布进行估计的方法。与常用的 hierarchical-sigmoid \[[2](#参考文献)\] 方法相比，NCE 不再使用复杂的二叉树来构造目标函数，而是采用相对简单的随机负采样，以大幅提升计算效率。
 
-假设已知具体的上下文 $h$，并且知道这个分布为 $P^h(w)$ ，并将从中抽样出来的数据作为正样例，而从一个噪音分布 $P_n(w)$ 抽样的数据作为负样例。我们可以任意选择合适的噪音分布，默认为无偏的均匀分布。这里我们同时假设噪音样例 k 倍于数据样例，则训练数据被抽中的概率为\[[1](#参考文献)\]：
+
+假设已知具体的上下文 $h$，并且知道这个分布为 $P^h(w)$ ，并将从中抽样出来的数据作为正样例，而从一个噪音分布 $P_n(w)$ 抽样的数据作为负样例。我们可以任意选择合适的噪音分布，默认为无偏的均匀分布。这里我们同时假设噪音样例 $k$ 倍于数据样例，则训练数据被抽中的概率为\[[1](#参考文献)\]：
 
 $$P^h(D=1|w,\theta)=\frac { P_\theta^h(w) }{ P^h_\theta(w)+kP_n(w) } =\sigma (\Delta s_\theta(w,h))$$
 
@@ -17,7 +17,7 @@ J^h(\theta )=E_{ P_d^h }\left[ \log { P^h(D=1|w,\theta ) }  \right] +kE_{ P_n }\
 $$
  \\\\\qquad =E_{ P_d^h }\left[ \log { \sigma (\Delta s_\theta(w,h)) }  \right] +kE_{ P_n }\left[ \log (1-\sigma (\Delta s_\theta(w,h)))  \right]$$
 
-总体上来说，NCE 是通过构造逻辑回归（logistic regression），对正样例和负样例做二分类，对于每一个样本，将自身的预测词 label 作为正样例，同时采样出 $k$ 个其他词 label 作为负样例，从而只需要计算样本在这 $k+1$ 个 label 上的概率。相比原始的 softmax 分类需要计算每个类别的分数，然后归一化得到概率，节约了大量的时间消耗。
+总体上来说，NCE 是通过构造逻辑回归（logistic regression），对正样例和负样例做二分类，对于每一个样本，将自身的预测词 label 作为正样例，同时采样出 $k$ 个其他词 label 作为负样例，从而只需要计算样本在这 $k+1$ 个 label 上的概率。相比原始的 `softmax ` 分类需要计算每个类别的分数，然后归一化得到概率，节约了大量的计算时间。
 
 ## 实验数据
 本文采用 Penn Treebank (PTB) 数据集（[Tomas Mikolov预处理版本](http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz)）来训练语言模型。PaddlePaddle 提供 [paddle.dataset.imikolov](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/dataset/imikolov.py) 接口来方便调用这些数据，如果当前目录没有找到数据它会自动下载并验证文件的完整性。并提供大小为5的滑动窗口对数据做预处理工作，方便后期处理。语料语种为英文，共有42068句训练数据，3761句测试数据。
@@ -42,70 +42,60 @@ N-gram 神经概率语言模型详细网络结构见图1：
 5. **NCE层**：训练时可以直接实用 PaddlePaddle 提供的 NCE Layer。
 
 
-## 训练阶段
-训练直接运行``` python train.py ```。程序第一次运行会检测用户缓存文件夹中是否包含 ptb 数据集，如果未包含，则自动下载。运行过程中，每1000个 iteration 会打印模型训练信息，主要包含训练损失，每个 pass 会计算测试数据集上的损失，并同时会保存最新的模型快照。在 PaddlePaddle 中有已经实现好的 NCE Layer，一些参数需要自行根据实际场景进行设计，可参考的调参方案如下：
-
-
-| 参数名  | 参数作用  | 介绍 |
-|:------ |:-------| :--------|
-| param\_attr / bias\_attr | 用来设置参数名字 |         可以方便后面预测阶段好来实现网络的参数共享，具体内容在下一个章节里会陈述。|
-| num\_neg\_samples | 参数负责控制对负样例的采样个数。        |           可以控制正负样本比例，这个值取值区间为 [1, 字典大小-1]，负样本个数越多则整个模型的训练速度越慢，模型精度也会越高 |
-| neg\_distribution | 控制生成负样例标签的分布，默认是一个均匀分布。 | 可以自行控制负样本采样时各个类别的采样权重，比如希望正样例为“晴天”时，负样例“洪水”在训练时更被着重区分，则可以将“洪水”这个类别的采样权重增加。 |
-| act | 表示使用何种激活函数。 | 根据 NCE 的原理，这里应该使用 sigmoid 函数。 |
+## 训练
+在命令行窗口运行命令``` python train.py ```可以直接开启训练任务。
 
+- 程序第一次运行会检测用户缓存文件夹中是否包含 ptb 数据集，如果未包含，则自动下载。
+- 运行过程中，每10个 batch 会打印模型训练在训练集上的代价值
+- 每个 pass 结束后，会计算测试数据集上的损失，并同时会保存最新的模型快照。
 
-具体代码实现如下：
+在模型文件`network_conf.py`中 NCE 调用代码如下：
 
 ```python
 cost = paddle.layer.nce(
-    input=hidden_layer,
-    label=next_word,
-    num_classes=dict_size,
-    param_attr=paddle.attr.Param(name='nce_w'),
-    bias_attr=paddle.attr.Param(name='nce_b'),
-    act=paddle.activation.Sigmoid(),
-    num_neg_samples=25,
-    neg_distribution=None)
+            input=hidden_layer,
+            label=next_word,
+            num_classes=dict_size,
+            param_attr=paddle.attr.Param(name="nce_w"),
+            bias_attr=paddle.attr.Param(name="nce_b"),
+            act=paddle.activation.Sigmoid(),
+            num_neg_samples=25,
+            neg_distribution=None)
 ```
 
+NCE 层的一些重要参数解释如下：
 
-## 预测阶段
-预测直接运行` python infer.py `，程序首先会加载最新模型，然后按照 batch 大小依次进行预测，并打印预测结果。因为训练和预测计算逻辑不一样，预测阶段需要共享 NCE Layer 中的逻辑回归训练时得到的参数，所以要写一个推断层，推断层的参数为预先训练好的参数。
-
-具体实现推断层的方法：先是通过 `paddle.attr.Param` 方法获取参数值，然后使用 `paddle.layer.trans_full_matrix_projection` 对隐层输出向量 `hidden_layer` 做一个矩阵右乘，PaddlePaddle 会自行在模型中寻找相同参数名的参数并获取。右乘求和后得到类别向量，将类别向量输入 softmax 做一个归一操作，和为1，从而得到最后的类别概率分布。
-
-代码实现如下：
-
-```python
-with paddle.layer.mixed(
-        size=dict_size,
-        act=paddle.activation.Softmax(),
-        bias_attr=paddle.attr.Param(name='nce_b')) as prediction:
-    prediction += paddle.layer.trans_full_matrix_projection(
-        input=hidden_layer, param_attr=paddle.attr.Param(name='nce_w'))
-```
-
-预测的输出形式为：
-
-```
---------------------------
-No.68 Input: ' <unk> for possible
-Ground Truth Output: <unk>
-Predict Output: <unk>
-
---------------------------
-No.69 Input: <unk> for possible <unk>
-Ground Truth Output: on
-Predict Output: <e>
-
---------------------------
-No.70 Input: for possible <unk> on
-Ground Truth Output: the
-Predict Output: the
-
-```
+| 参数名  | 参数作用  | 介绍 |
+|:------ |:-------| :--------|
+| param\_attr / bias\_attr | 用来设置参数名字 |方便预测阶段加载参数，具体在预测一节中介绍。|
+| num\_neg\_samples | 负样本采样个数|可以控制正负样本比例，这个值取值区间为 [1, 字典大小-1]，负样本个数越多则整个模型的训练速度越慢，模型精度也会越高 |
+| neg\_distribution | 生成负样例标签的分布，默认是一个均匀分布| 可以自行控制负样本采样时各个类别的采样权重。例如：希望正样例为“晴天”时，负样例“洪水”在训练时更被着重区分，则可以将“洪水”这个类别的采样权重增加|
+| act | 使用何种激活函数| 根据 NCE 的原理，这里应该使用 sigmoid 函数 |
+
+## 预测
+1. 首先修改 `infer.py` 脚本的 `main` 函数指定需要测试的模型。
+2. 需要注意的是，**预测和训练的计算逻辑不同**，需要以一个全连接层:`paddle.layer.fc`替换训练使用的`paddle.train.nce`层， 并直接加载NCE学习到的参数，代码如下：
+
+	```python
+	prediction = paddle.layer.fc(
+	    size=dict_size,
+	    act=paddle.activation.Softmax(),
+	    bias_attr=paddle.attr.Param(name="nce_b"),
+	    input=hidden_layer,
+	    param_attr=paddle.attr.Param(name="nce_w"))
+	```
+3. 运行 `python infer.py`。程序首先会加载指定的模型，然后按照 batch 大小依次进行预测，并打印预测结果。预测的输出格式如下：
+
+	```text
+	0.6734  their   may want to move
+
+	```
+
+	每一行是一条预测结果，内部以“\t”分隔，共计3列：
+	- 第一列：下一个词的概率。
+	- 第二列：模型预测的下一个词。
+	- 第三列：输入的 $n$ 个词语，内部以空格分隔。
 
-每一个短线表示一次的预测，第二行显示第几条测试样例，并给出输入的4个单词，第三行为真实的标签，第四行为预测的标签。
 
 ## 参考文献
 1. Mnih A, Kavukcuoglu K. [Learning word embeddings efficiently with noise-contrastive estimation](https://papers.nips.cc/paper/5165-learning-word-embeddings-efficiently-with-noise-contrastive-estimation.pdf)[C]//Advances in neural information processing systems. 2013: 2265-2273.

nce_cost/index.html

+
+<html>
+<head>
+  <script type="text/x-mathjax-config">
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js", "TeX/AMSsymbols.js", "TeX/AMSmath.js"],
+    jax: ["input/TeX", "output/HTML-CSS"],
+    tex2jax: {
+      inlineMath: [ ['$','$'] ],
+      displayMath: [ ['$$','$$'] ],
+      processEscapes: true
+    },
+    "HTML-CSS": { availableFonts: ["TeX"] }
+  });
+  </script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js" async></script>
+  <script type="text/javascript" src="../.tools/theme/marked.js">
+  </script>
+  <link href="http://cdn.bootcss.com/highlight.js/9.9.0/styles/darcula.min.css" rel="stylesheet">
+  <script src="http://cdn.bootcss.com/highlight.js/9.9.0/highlight.min.js"></script>
+  <link href="http://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.min.css" rel="stylesheet">
+  <link href="https://cdn.jsdelivr.net/perfect-scrollbar/0.6.14/css/perfect-scrollbar.min.css" rel="stylesheet">
+  <link href="../.tools/theme/github-markdown.css" rel='stylesheet'>
+</head>
+<style type="text/css" >
+.markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+}
+</style>
+
+
+<body>
+
+<div id="context" class="container-fluid markdown-body">
+</div>
+
+<!-- This block will be replaced by each markdown file content. Please do not change lines below.-->
+<div id="markdown" style='display:none'>
+# 噪声对比估计加速词向量训练
+
+词向量是许多自然语言处理任务的基础，详细介绍可见 PaddleBook 中的[词向量](https://github.com/PaddlePaddle/book/blob/develop/04.word2vec/README.cn.md)一节，其中通过训练神经概率语言模型（Neural Probabilistic Language Model, NPLM）得到词向量，是一种流行的方式。然而，神经概率语言模型的最后一层往往需要计算一个词典之上的概率分布，词典越大这一层的计算量也就越大，往往非常耗时。在models的另一篇我们已经介绍了[Hsigmoid加速词向量训练](https://github.com/PaddlePaddle/models/tree/develop/hsigmoid)，这里我们介绍另一种加速词向量训练的方法：使用噪声对比估计（Noise-contrastive estimation, NCE）损失函数\[[1](#参考文献)\]。
+
+## NCE
+NPLM 的最后一层 `softmax` 函数计算时需要考虑每个类别的指数项，必须计算字典中的所有单词，而在一般语料集上面字典往往非常大\[[3](#参考文献)\]，从而导致整个训练过程十分耗时。NCE 是一种快速对离散分布进行估计的方法。与常用的 hierarchical-sigmoid \[[2](#参考文献)\] 方法相比，NCE 不再使用复杂的二叉树来构造目标函数，而是采用相对简单的随机负采样，以大幅提升计算效率。
+
+
+假设已知具体的上下文 $h$，并且知道这个分布为 $P^h(w)$ ，并将从中抽样出来的数据作为正样例，而从一个噪音分布 $P_n(w)$ 抽样的数据作为负样例。我们可以任意选择合适的噪音分布，默认为无偏的均匀分布。这里我们同时假设噪音样例 $k$ 倍于数据样例，则训练数据被抽中的概率为\[[1](#参考文献)\]：
+
+$$P^h(D=1|w,\theta)=\frac { P_\theta^h(w) }{ P^h_\theta(w)+kP_n(w) } =\sigma (\Delta s_\theta(w,h))$$
+
+其中 $\Delta s_\theta(w,h)=s_\theta(w,h)-\log (kP_n(w))$ ，$s_\theta(w,h)$ 表示选择在生成 $w$ 字并处于上下文 $h$ 时的特征向量，整体目标函数的目的就是增大正样本的概率同时降低负样本的概率。目标函数如下[[1](#参考文献)]：
+
+$$
+J^h(\theta )=E_{ P_d^h }\left[ \log { P^h(D=1|w,\theta ) }  \right] +kE_{ P_n }\left[ \log P^h (D=0|w,\theta ) \right]$$
+$$
+ \\\\\qquad =E_{ P_d^h }\left[ \log { \sigma (\Delta s_\theta(w,h)) }  \right] +kE_{ P_n }\left[ \log (1-\sigma (\Delta s_\theta(w,h)))  \right]$$
+
+总体上来说，NCE 是通过构造逻辑回归（logistic regression），对正样例和负样例做二分类，对于每一个样本，将自身的预测词 label 作为正样例，同时采样出 $k$ 个其他词 label 作为负样例，从而只需要计算样本在这 $k+1$ 个 label 上的概率。相比原始的 `softmax ` 分类需要计算每个类别的分数，然后归一化得到概率，节约了大量的计算时间。
+
+## 实验数据
+本文采用 Penn Treebank (PTB) 数据集（[Tomas Mikolov预处理版本](http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz)）来训练语言模型。PaddlePaddle 提供 [paddle.dataset.imikolov](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/dataset/imikolov.py) 接口来方便调用这些数据，如果当前目录没有找到数据它会自动下载并验证文件的完整性。并提供大小为5的滑动窗口对数据做预处理工作，方便后期处理。语料语种为英文，共有42068句训练数据，3761句测试数据。
+
+## 网络结构
+N-gram 神经概率语言模型详细网络结构见图1：
+
+<p align="center">
+<img src="images/network_conf.png" width = "70%" align="center"/><br/>
+图1. 网络配置结构
+</p>
+可以看到，模型主要分为如下几个部分构成：
+
+1. **输入层**：输入的 ptb 样本由原始的英文单词组成，将每个英文单词转换为字典中的 id 表示，使用唯一的 id 表示可以区分每个单词。
+
+2. **词向量层**：比起原先的 id 表示，词向量表示更能体现词与词之间的语义关系。这里使用可更新的 embedding 矩阵，将原先的 id 表示转换为固定维度的词向量表示。训练完成之后，词语之间的语义相似度可以使用词向量之间的距离来表示，语义越相似，距离越近。
+
+3. **词向量拼接层**：将词向量进行串联，并将词向量首尾相接形成一个长向量。这样可以方便后面全连接层的处理。
+
+4. **全连接隐层**：将上一层获得的长向量输入到一层隐层的神经网络，输出特征向量。全连接的隐层可以增强网络的学习能力。
+
+5. **NCE层**：训练时可以直接实用 PaddlePaddle 提供的 NCE Layer。
+
+
+## 训练
+在命令行窗口运行命令``` python train.py ```可以直接开启训练任务。
+
+- 程序第一次运行会检测用户缓存文件夹中是否包含 ptb 数据集，如果未包含，则自动下载。
+- 运行过程中，每10个 batch 会打印模型训练在训练集上的代价值
+- 每个 pass 结束后，会计算测试数据集上的损失，并同时会保存最新的模型快照。
+
+在模型文件`network_conf.py`中 NCE 调用代码如下：
+
+```python
+cost = paddle.layer.nce(
+            input=hidden_layer,
+            label=next_word,
+            num_classes=dict_size,
+            param_attr=paddle.attr.Param(name="nce_w"),
+            bias_attr=paddle.attr.Param(name="nce_b"),
+            act=paddle.activation.Sigmoid(),
+            num_neg_samples=25,
+            neg_distribution=None)
+```
+
+NCE 层的一些重要参数解释如下：
+
+| 参数名  | 参数作用  | 介绍 |
+|:------ |:-------| :--------|
+| param\_attr / bias\_attr | 用来设置参数名字 |方便预测阶段加载参数，具体在预测一节中介绍。|
+| num\_neg\_samples | 负样本采样个数|可以控制正负样本比例，这个值取值区间为 [1, 字典大小-1]，负样本个数越多则整个模型的训练速度越慢，模型精度也会越高 |
+| neg\_distribution | 生成负样例标签的分布，默认是一个均匀分布| 可以自行控制负样本采样时各个类别的采样权重。例如：希望正样例为“晴天”时，负样例“洪水”在训练时更被着重区分，则可以将“洪水”这个类别的采样权重增加|
+| act | 使用何种激活函数| 根据 NCE 的原理，这里应该使用 sigmoid 函数 |
+
+## 预测
+1. 首先修改 `infer.py` 脚本的 `main` 函数指定需要测试的模型。
+2. 需要注意的是，**预测和训练的计算逻辑不同**，需要以一个全连接层:`paddle.layer.fc`替换训练使用的`paddle.train.nce`层， 并直接加载NCE学习到的参数，代码如下：
+
+	```python
+	prediction = paddle.layer.fc(
+	    size=dict_size,
+	    act=paddle.activation.Softmax(),
+	    bias_attr=paddle.attr.Param(name="nce_b"),
+	    input=hidden_layer,
+	    param_attr=paddle.attr.Param(name="nce_w"))
+	```
+3. 运行 `python infer.py`。程序首先会加载指定的模型，然后按照 batch 大小依次进行预测，并打印预测结果。预测的输出格式如下：
+
+	```text
+	0.6734  their   may want to move
+
+	```
+
+	每一行是一条预测结果，内部以“\t”分隔，共计3列：
+	- 第一列：下一个词的概率。
+	- 第二列：模型预测的下一个词。
+	- 第三列：输入的 $n$ 个词语，内部以空格分隔。
+
+
+## 参考文献
+1. Mnih A, Kavukcuoglu K. [Learning word embeddings efficiently with noise-contrastive estimation](https://papers.nips.cc/paper/5165-learning-word-embeddings-efficiently-with-noise-contrastive-estimation.pdf)[C]//Advances in neural information processing systems. 2013: 2265-2273.
+
+2. Morin, F., & Bengio, Y. (2005, January). [Hierarchical Probabilistic Neural Network Language Model](http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf). In Aistats (Vol. 5, pp. 246-252).
+
+3. Mnih A, Teh Y W. [A Fast and Simple Algorithm for Training Neural Probabilistic Language Models](http://xueshu.baidu.com/s?wd=paperuri%3A%280735b97df93976efb333ac8c266a1eb2%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Farxiv.org%2Fabs%2F1206.6426&ie=utf-8&sc_us=5770715420073315630)[J]. Computer Science, 2012:1751-1758.
+
+</div>
+<!-- You can change the lines below now. -->
+
+<script type="text/javascript">
+marked.setOptions({
+  renderer: new marked.Renderer(),
+  gfm: true,
+  breaks: false,
+  smartypants: true,
+  highlight: function(code, lang) {
+    code = code.replace(/&amp;/g, "&")
+    code = code.replace(/&gt;/g, ">")
+    code = code.replace(/&lt;/g, "<")
+    code = code.replace(/&nbsp;/g, " ")
+    return hljs.highlightAuto(code, [lang]).value;
+  }
+});
+document.getElementById("context").innerHTML = marked(
+        document.getElementById("markdown").innerHTML)
+</script>
+</body>

nce_cost/infer.py

+#!/usr/bin/env python
 # -*- encoding:utf-8 -*-
-import numpy as np
-import glob
+import os
 import gzip
-import paddle.v2 as paddle
-from nce_conf import network_conf
-
-
-def main():
-    paddle.init(use_gpu=False, trainer_count=1)
-    word_dict = paddle.dataset.imikolov.build_dict()
-    dict_size = len(word_dict)
-
-    prediction_layer = network_conf(
-        is_train=False,
-        hidden_size=128,
-        embedding_size=512,
-        dict_size=dict_size)
-
-    models_list = glob.glob('./models/*')
-    models_list = sorted(models_list)
-
-    with gzip.open(models_list[-1], 'r') as f:
-        parameters = paddle.parameters.Parameters.from_tar(f)
+import numpy as np
 
-    idx_word_dict = dict((v, k) for k, v in word_dict.items())
-    batch_size = 64
-    batch_ins = []
-    ins_iter = paddle.dataset.imikolov.test(word_dict, 5)
+import paddle.v2 as paddle
+from network_conf import ngram_lm
 
-    infer_data = []
-    infer_data_label = []
-    for item in paddle.dataset.imikolov.test(word_dict, 5)():
-        infer_data.append((item[:4]))
-        infer_data_label.append(item[4])
-        # Choose 100 samples from the test set to show how to infer.
-        if len(infer_data_label) == 100:
-            break
 
-    feeding = {
-        'firstw': 0,
-        'secondw': 1,
-        'thirdw': 2,
-        'fourthw': 3,
-        'fifthw': 4
-    }
+def infer_a_batch(inferer, test_batch, id_to_word):
+    probs = inferer.infer(input=test_batch)
+    for i, res in enumerate(zip(test_batch, probs)):
+        maxid = res[1].argsort()[-1]
+        print("%.4f\t%s\t%s" % (res[1][maxid], id_to_word[maxid],
+                                " ".join([id_to_word[w] for w in res[0]])))
 
-    predictions = paddle.infer(
-        output_layer=prediction_layer,
-        parameters=parameters,
-        input=infer_data,
-        feeding=feeding,
-        field=['value'])
 
-    for i, (prob, data,
-            label) in enumerate(zip(predictions, infer_data, infer_data_label)):
-        print '--------------------------'
-        print "No.%d Input: " % (i+1) + \
-                idx_word_dict[data[0]] + ' ' + \
-                idx_word_dict[data[1]] + ' ' + \
-                idx_word_dict[data[2]] + ' ' + \
-                idx_word_dict[data[3]]
-        print 'Ground Truth Output: ' + idx_word_dict[label]
-        print 'Predict Output: ' + idx_word_dict[prob.argsort(
-            kind='heapsort', axis=0)[-1]]
-        print
+def infer(model_path, batch_size):
+    assert os.path.exists(model_path), "the trained model does not exist."
+    word_to_id = paddle.dataset.imikolov.build_dict()
+    id_to_word = dict((v, k) for k, v in word_to_id.items())
+    dict_size = len(word_to_id)
 
+    paddle.init(use_gpu=False, trainer_count=1)
 
-if __name__ == '__main__':
-    main()
+    # load the trained model.
+    with gzip.open(model_path) as f:
+        parameters = paddle.parameters.Parameters.from_tar(f)
+    prediction_layer = ngram_lm(
+        is_train=False, hidden_size=128, emb_size=512, dict_size=dict_size)
+    inferer = paddle.inference.Inference(
+        output_layer=prediction_layer, parameters=parameters)
+
+    test_batch = []
+    for idx, item in enumerate(paddle.dataset.imikolov.test(word_to_id, 5)()):
+        test_batch.append((item[:4]))
+        if len(test_batch) == batch_size:
+            infer_a_batch(inferer, test_batch, id_to_word)
+            infer_data = []
+
+    if len(test_batch):
+        infer_a_batch(inferer, test_batch, id_to_word)
+        infer_data = []
+        infer_data_label = []
+
+
+if __name__ == "__main__":
+    infer("models/model_pass_00000_00020.tar.gz", 10)

nce_cost/nce_conf.py

-# -*- encoding:utf-8 -*-
-import math
-import paddle.v2 as paddle
-
-
-def network_conf(hidden_size, embedding_size, dict_size, is_train):
-
-    first_word = paddle.layer.data(
-        name="firstw", type=paddle.data_type.integer_value(dict_size))
-    second_word = paddle.layer.data(
-        name="secondw", type=paddle.data_type.integer_value(dict_size))
-    third_word = paddle.layer.data(
-        name="thirdw", type=paddle.data_type.integer_value(dict_size))
-    fourth_word = paddle.layer.data(
-        name="fourthw", type=paddle.data_type.integer_value(dict_size))
-    next_word = paddle.layer.data(
-        name="fifthw", type=paddle.data_type.integer_value(dict_size))
-
-    embed_param_attr = paddle.attr.Param(
-        name="_proj", initial_std=0.001, learning_rate=1, l2_rate=0)
-    first_embedding = paddle.layer.embedding(
-        input=first_word, size=embedding_size, param_attr=embed_param_attr)
-    second_embedding = paddle.layer.embedding(
-        input=second_word, size=embedding_size, param_attr=embed_param_attr)
-    third_embedding = paddle.layer.embedding(
-        input=third_word, size=embedding_size, param_attr=embed_param_attr)
-    fourth_embedding = paddle.layer.embedding(
-        input=fourth_word, size=embedding_size, param_attr=embed_param_attr)
-
-    context_embedding = paddle.layer.concat(input=[
-        first_embedding, second_embedding, third_embedding, fourth_embedding
-    ])
-
-    hidden_layer = paddle.layer.fc(
-        input=context_embedding,
-        size=hidden_size,
-        act=paddle.activation.Tanh(),
-        bias_attr=paddle.attr.Param(learning_rate=1),
-        param_attr=paddle.attr.Param(
-            initial_std=1. / math.sqrt(embedding_size * 8), learning_rate=1))
-
-    if is_train == True:
-        cost = paddle.layer.nce(
-            input=hidden_layer,
-            label=next_word,
-            num_classes=dict_size,
-            param_attr=paddle.attr.Param(name='nce_w'),
-            bias_attr=paddle.attr.Param(name='nce_b'),
-            act=paddle.activation.Sigmoid(),
-            num_neg_samples=25,
-            neg_distribution=None)
-        return cost
-    else:
-        with paddle.layer.mixed(
-                size=dict_size,
-                act=paddle.activation.Softmax(),
-                bias_attr=paddle.attr.Param(name='nce_b')) as prediction:
-            prediction += paddle.layer.trans_full_matrix_projection(
-                input=hidden_layer, param_attr=paddle.attr.Param(name='nce_w'))
-
-        return prediction

nce_cost/network_conf.py

+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+import math
+import paddle.v2 as paddle
+
+
+def ngram_lm(hidden_size, emb_size, dict_size, gram_num=4, is_train=True):
+    emb_layers = []
+    embed_param_attr = paddle.attr.Param(
+        name="_proj", initial_std=0.001, learning_rate=1, l2_rate=0)
+    for i in range(gram_num):
+        word = paddle.layer.data(
+            name="__word%02d__" % (i),
+            type=paddle.data_type.integer_value(dict_size))
+        emb_layers.append(
+            paddle.layer.embedding(
+                input=word, size=emb_size, param_attr=embed_param_attr))
+
+    next_word = paddle.layer.data(
+        name="__target_word__", type=paddle.data_type.integer_value(dict_size))
+
+    context_embedding = paddle.layer.concat(input=emb_layers)
+
+    hidden_layer = paddle.layer.fc(
+        input=context_embedding,
+        size=hidden_size,
+        act=paddle.activation.Tanh(),
+        param_attr=paddle.attr.Param(initial_std=1. / math.sqrt(emb_size * 8)))
+
+    if is_train:
+        cost = paddle.layer.nce(
+            input=hidden_layer,
+            label=next_word,
+            num_classes=dict_size,
+            param_attr=paddle.attr.Param(name="nce_w"),
+            bias_attr=paddle.attr.Param(name="nce_b"),
+            act=paddle.activation.Sigmoid(),
+            num_neg_samples=25,
+            neg_distribution=None)
+        return cost
+    else:
+        prediction = paddle.layer.fc(
+            size=dict_size,
+            act=paddle.activation.Softmax(),
+            bias_attr=paddle.attr.Param(name="nce_b"),
+            input=hidden_layer,
+            param_attr=paddle.attr.Param(name="nce_w"))
+
+        return prediction

nce_cost/train.py

+#!/usr/bin/env python
 # -*- encoding:utf-8 -*-
-import paddle.v2 as paddle
+import os
+import logging
 import gzip
 
-from nce_conf import network_conf
+import paddle.v2 as paddle
+from network_conf import ngram_lm
+
+logger = logging.getLogger("paddle")
+logger.setLevel(logging.INFO)
 
 
-def main():
+def train(model_save_dir):
+    if not os.path.exists(model_save_dir):
+        os.mkdir(model_save_dir)
+
     paddle.init(use_gpu=False, trainer_count=1)
     word_dict = paddle.dataset.imikolov.build_dict()
     dict_size = len(word_dict)
 
-    cost = network_conf(
-        is_train=True, hidden_size=128, embedding_size=512, dict_size=dict_size)
+    optimizer = paddle.optimizer.Adam(learning_rate=1e-4)
 
+    cost = ngram_lm(hidden_size=128, emb_size=512, dict_size=dict_size)
     parameters = paddle.parameters.create(cost)
-    adagrad = paddle.optimizer.Adam(learning_rate=1e-4)
-    trainer = paddle.trainer.SGD(cost, parameters, adagrad)
+    trainer = paddle.trainer.SGD(cost, parameters, optimizer)
 
     def event_handler(event):
         if isinstance(event, paddle.event.EndIteration):
-            if event.batch_id % 1000 == 0:
-                print "Pass %d, Batch %d, Cost %f" % (
-                    event.pass_id, event.batch_id, event.cost)
+            if event.batch_id and not event.batch_id % 10:
+                logger.info("Pass %d, Batch %d, Cost %f" %
+                            (event.pass_id, event.batch_id, event.cost))
 
         if isinstance(event, paddle.event.EndPass):
             result = trainer.test(
                 paddle.batch(paddle.dataset.imikolov.test(word_dict, 5), 64))
-            print "Test here.. Pass %d, Cost %f" % (event.pass_id, result.cost)
+            logger.info("Test Pass %d, Cost %f" % (event.pass_id, result.cost))
 
-            model_name = "./models/model_pass_%05d.tar.gz" % event.pass_id
-            print "Save model into %s ..." % model_name
-            with gzip.open(model_name, 'w') as f:
+            save_path = os.path.join(model_save_dir,
+                                     "model_pass_%05d.tar.gz" % event.pass_id)
+            logger.info("Save model into %s ..." % save_path)
+            with gzip.open(save_path, "w") as f:
                 parameters.to_tar(f)
 
-    feeding = {
-        'firstw': 0,
-        'secondw': 1,
-        'thirdw': 2,
-        'fourthw': 3,
-        'fifthw': 4
-    }
-
     trainer.train(
         paddle.batch(paddle.dataset.imikolov.train(word_dict, 5), 64),
         num_passes=1000,
-        event_handler=event_handler,
-        feeding=feeding)
+        event_handler=event_handler)
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    train(model_save_dir="models")

nested_sequence/README.md

-TBD

nmt_without_attention/README.md

@@ -51,14 +51,15 @@ RNN 的原始结构用一个向量来存储隐状态，然而这种结构的 RNN
 在 PaddlePaddle 中，双向编码器可以很方便地调用相关 APIs 实现：
 
 ```python
-#### Encoder
 src_word_id = paddle.layer.data(
     name='source_language_word',
     type=paddle.data_type.integer_value_sequence(source_dict_dim))
+
 # source embedding
 src_embedding = paddle.layer.embedding(
     input=src_word_id, size=word_vector_dim)
-# use bidirectional_gru
+
+# bidirectional GRU as encoder
 encoded_vector = paddle.networks.bidirectional_gru(
     input=src_embedding,
     size=encoder_size,
@@ -84,19 +85,17 @@ encoded_vector = paddle.networks.bidirectional_gru(
 
 
 ### 无注意力机制的解码器
-PaddleBook中[机器翻译](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md)的相关章节中，已介绍了带注意力机制（Attention Mechanism）的 Encoder-Decoder 结构，本例则介绍的是不带注意力机制的 Encoder-Decoder 结构。关于注意力机制，读者可进一步参考 PaddleBook 和参考文献\[[3](#参考文献)]。
+- PaddleBook中[机器翻译](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md)的相关章节中，已介绍了带注意力机制（Attention Mechanism）的 Encoder-Decoder 结构，本例介绍的则是不带注意力机制的 Encoder-Decoder 结构。关于注意力机制，读者可进一步参考 PaddleBook 和参考文献\[[3](#参考文献)]。
 
 对于流行的RNN单元，PaddlePaddle 已有很好的实现均可直接调用。如果希望在 RNN 每一个时间步实现某些自定义操作，可使用 PaddlePaddle 中的`recurrent_layer_group`。首先，自定义单步逻辑函数，再利用函数 `recurrent_group()` 循环调用单步逻辑函数处理整个序列。本例中的无注意力机制的解码器便是使用`recurrent_layer_group`来实现，其中，单步逻辑函数`gru_decoder_without_attention()`相关代码如下：
 
 ```python
-#### Decoder
+# the initialization state for decoder GRU
 encoder_last = paddle.layer.last_seq(input=encoded_vector)
-encoder_last_projected = paddle.layer.mixed(
-        size=decoder_size,
-        act=paddle.activation.Tanh(),
-        input=paddle.layer.full_matrix_projection(input=encoder_last))
+encoder_last_projected = paddle.layer.fc(
+    size=decoder_size, act=paddle.activation.Tanh(), input=encoder_last)
 
-# gru step
+# the step function for decoder GRU
 def gru_decoder_without_attention(enc_vec, current_word):
     '''
     Step function for gru decoder
@@ -106,33 +105,29 @@ def gru_decoder_without_attention(enc_vec, current_word):
     :type current_word: layer object
     '''
     decoder_mem = paddle.layer.memory(
-        name='gru_decoder',
-        size=decoder_size,
-        boot_layer=encoder_last_projected)
+            name="gru_decoder",
+            size=decoder_size,
+            boot_layer=encoder_last_projected)
 
     context = paddle.layer.last_seq(input=enc_vec)
 
-    decoder_inputs = paddle.layer.mixed(
-        size=decoder_size * 3,
-        input=[
-            paddle.layer.full_matrix_projection(input=context),
-            paddle.layer.full_matrix_projection(input=current_word)
-        ])
+    decoder_inputs = paddle.layer.fc(
+        size=decoder_size * 3, input=[context, current_word])
 
     gru_step = paddle.layer.gru_step(
-        name='gru_decoder',
+        name="gru_decoder",
         act=paddle.activation.Tanh(),
         gate_act=paddle.activation.Sigmoid(),
         input=decoder_inputs,
         output_mem=decoder_mem,
         size=decoder_size)
 
-    out = paddle.layer.mixed(
+     out = paddle.layer.fc(
         size=target_dict_dim,
         bias_attr=True,
         act=paddle.activation.Softmax(),
-        input=paddle.layer.full_matrix_projection(input=gru_step))
-    return out
+        input=gru_step)
+    return out  
 ```
 
 在模型训练和测试阶段，解码器的行为有很大的不同：
@@ -143,34 +138,14 @@ def gru_decoder_without_attention(enc_vec, current_word):
 训练和生成的逻辑分别实现在如下的`if-else`条件分支中：
 
 ```python
-decoder_group_name = "decoder_group"
-group_input1 = paddle.layer.StaticInput(input=encoded_vector, is_seq=True)
+group_input1 = paddle.layer.StaticInput(input=encoded_vector)
 group_inputs = [group_input1]
-if not generating:
-    trg_embedding = paddle.layer.embedding(
-        input=paddle.layer.data(
-            name='target_language_word',
-            type=paddle.data_type.integer_value_sequence(target_dict_dim)),
-            size=word_vector_dim,
-            param_attr=paddle.attr.ParamAttr(name='_target_language_embedding'))
-    group_inputs.append(trg_embedding)
-
-    decoder = paddle.layer.recurrent_group(
-        name=decoder_group_name,
-        step=gru_decoder_without_attention,
-        input=group_inputs)
-
-    lbl = paddle.layer.data(
-        name='target_language_next_word',
-            type=paddle.data_type.integer_value_sequence(target_dict_dim))
-    cost = paddle.layer.classification_cost(input=decoder, label=lbl)
-
-    return cost
-else:
 
+decoder_group_name = "decoder_group"
+if is_generating:
     trg_embedding = paddle.layer.GeneratedInput(
         size=target_dict_dim,
-        embedding_name='_target_language_embedding',
+        embedding_name="_target_language_embedding",
         embedding_size=word_vector_dim)
     group_inputs.append(trg_embedding)
 
@@ -184,6 +159,26 @@ else:
         max_length=max_length)
 
     return beam_gen
+else:
+    trg_embedding = paddle.layer.embedding(
+        input=paddle.layer.data(
+            name="target_language_word",
+            type=paddle.data_type.integer_value_sequence(target_dict_dim)),
+        size=word_vector_dim,
+        param_attr=paddle.attr.ParamAttr(name="_target_language_embedding"))
+    group_inputs.append(trg_embedding)
+
+    decoder = paddle.layer.recurrent_group(
+        name=decoder_group_name,
+        step=gru_decoder_without_attention,
+        input=group_inputs)
+
+    lbl = paddle.layer.data(
+        name="target_language_next_word",
+        type=paddle.data_type.integer_value_sequence(target_dict_dim))
+    cost = paddle.layer.classification_cost(input=decoder, label=lbl)
+
+    return cost
 ```
 
 ## 数据准备
@@ -191,29 +186,31 @@ else:
 
 ## 模型的训练与测试
 
-在定义好网络结构后，就可以进行模型训练与测试了。根据用户运行时传递的参数是`--train` 还是 `--generate`，Python 脚本的 `main()` 函数分别调用函数`train()`和`generate()`来完成模型的训练与测试。
-
 ### 模型训练
-模型训练阶段，函数 `train()` 依次完成了如下的逻辑：
+
+启动模型训练的十分简单，只需在命令行窗口中执行`python train.py`。模型训练阶段 `train.py` 脚本中的 `train()` 函数依次完成了如下的逻辑：
 
 **a) 由网络定义，解析网络结构，初始化模型参数**
 
-```
-# initialize model
+```python
+# define the network topolgy.
 cost = seq2seq_net(source_dict_dim, target_dict_dim)
 parameters = paddle.parameters.create(cost)
 ```
 
 **b) 设定训练过程中的优化策略、定义训练数据读取 `reader`**
 
-```
-# define optimize method and trainer
+```python
+# define optimization method
 optimizer = paddle.optimizer.RMSProp(
     learning_rate=1e-3,
     gradient_clipping_threshold=10.0,
     regularization=paddle.optimizer.L2Regularization(rate=8e-4))
+
+# define the trainer instance
 trainer = paddle.trainer.SGD(
     cost=cost, parameters=parameters, update_equation=optimizer)
+
 # define data reader
 wmt14_reader = paddle.batch(
     paddle.reader.shuffle(
@@ -223,40 +220,33 @@ wmt14_reader = paddle.batch(
 
 **c) 定义事件句柄，打印训练中间结果、保存模型快照**
 
-```
-# define event_handler callback
+```python
+# define the event_handler callback
 def event_handler(event):
     if isinstance(event, paddle.event.EndIteration):
-        if event.batch_id % 100 == 0 and event.batch_id > 0:
-            with gzip.open('models/nmt_without_att_params_batch_%d.tar.gz' %
-                           event.batch_id, 'w') as f:
+        if not event.batch_id % 100 and event.batch_id:
+            with gzip.open(
+                    os.path.join(save_path,
+                                 "nmt_without_att_%05d_batch_%05d.tar.gz" %
+                                 event.pass_id, event.batch_id), "w") as f:
                 parameters.to_tar(f)
 
-        if event.batch_id % 10 == 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()
+        if event.batch_id and not event.batch_id % 10:
+            logger.info("Pass %d, Batch %d, Cost %f, %s" % (
+                event.pass_id, event.batch_id, event.cost, event.metrics))
 ```
 
 **d) 开始训练**
 
-```
-# start to train
+```python
+# start training
 trainer.train(
     reader=wmt14_reader, event_handler=event_handler, num_passes=2)
 ```
 
-启动模型训练的十分简单，只需在命令行窗口中执行
-
-```
-python nmt_without_attention_v2.py --train
-```
-
 输出样例为
 
-```
+```text
 Pass 0, Batch 0, Cost 267.674663, {'classification_error_evaluator': 1.0}
 .........
 Pass 0, Batch 10, Cost 172.892294, {'classification_error_evaluator': 0.953895092010498}
@@ -268,81 +258,80 @@ Pass 0, Batch 30, Cost 153.633665, {'classification_error_evaluator': 0.86438035
 Pass 0, Batch 40, Cost 168.170543, {'classification_error_evaluator': 0.8348183631896973}
 ```
 
+### 生成翻译结果
+利用训练好的模型生成翻译文本也十分简单。
+
+1. 首先请修改`generate.py`脚本中`main`中传递给`generate`函数的参数，以选择使用哪一个保存的模型来生成。默认参数如下所示：
+
+    ```python
+    generate(
+        source_dict_dim=30000,
+        target_dict_dim=30000,
+        batch_size=20,
+        beam_size=3,
+        model_path="models/nmt_without_att_params_batch_00100.tar.gz")
+    ```
+
+2. 在终端执行命令 `python generate.py`，脚本中的`generate()`执行了依次如下逻辑：
+
+    **a) 加载测试样本**
+
+    ```python
+    # load data  samples for generation
+    gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
+    gen_data = []
+    for item in gen_creator():
+        gen_data.append((item[0], ))
+    ```
+
+    **b) 初始化模型，执行`infer()`为每个输入样本生成`beam search`的翻译结果**
+
+    ```python
+    beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
+    with gzip.open(init_models_path) as f:
+        parameters = paddle.parameters.Parameters.from_tar(f)
+    # prob is the prediction probabilities, and id is the prediction word.
+    beam_result = paddle.infer(
+        output_layer=beam_gen,
+        parameters=parameters,
+        input=gen_data,
+        field=['prob', 'id'])
+    ```
+
+    **c) 加载源语言和目标语言词典，将`id`序列表示的句子转化成原语言并输出结果**
+
+    ```python
+    beam_result = inferer.infer(input=test_batch, field=["prob", "id"])
+
+    gen_sen_idx = np.where(beam_result[1] == -1)[0]
+    assert len(gen_sen_idx) == len(test_batch) * beam_size
+
+    start_pos, end_pos = 1, 0
+    for i, sample in enumerate(test_batch):
+        print(" ".join([
+            src_dict[w] for w in sample[0][1:-1]
+        ]))  # skip the start and ending mark when print the source sentence
+        for j in xrange(beam_size):
+            end_pos = gen_sen_idx[i * beam_size + j]
+            print("%.4f\t%s" % (beam_result[0][i][j], " ".join(
+                trg_dict[w] for w in beam_result[1][start_pos:end_pos])))
+            start_pos = end_pos + 2
+        print("\n")
+    ```
+
+设置beam search的宽度为3，输入为一个法文句子，则自动为测试数据生成对应的翻译结果，输出格式如下：
+
+```text
+Elles connaissent leur entreprise mieux que personne .
+-3.754819        They know their business better than anyone . <e>
+-4.445528        They know their businesses better than anyone . <e>
+-5.026885        They know their business better than anybody . <e>
 
-### 模型测试
-模型测试阶段，函数`generate()`执行了依次如下逻辑：
-
-**a) 加载测试样本**
-
-```
-# load data  samples for generation
-gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
-gen_data = []
-for item in gen_creator():
-    gen_data.append((item[0], ))
 ```
-
-**b) 初始化模型，执行`infer()`为每个输入样本生成`beam search`的翻译结果**
-
-```
-beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
-with gzip.open(init_models_path) as f:
-    parameters = paddle.parameters.Parameters.from_tar(f)
-# prob is the prediction probabilities, and id is the prediction word.
-beam_result = paddle.infer(
-    output_layer=beam_gen,
-    parameters=parameters,
-    input=gen_data,
-    field=['prob', 'id'])
-```
-
-**c) 加载源语言和目标语言词典，将`id`序列表示的句子转化成原语言并输出结果**
-
-```
-# get the dictionary
-src_dict, trg_dict = paddle.dataset.wmt14.get_dict(source_dict_dim)
-
-# the delimited element of generated sequences is -1,
-# the first element of each generated sequence is the sequence length
-seq_list = []
-seq = []
-for w in beam_result[1]:
-    if w != -1:
-        seq.append(w)
-    else:
-        seq_list.append(' '.join([trg_dict.get(w) for w in seq[1:]]))
-        seq = []
-
-prob = beam_result[0]
-for i in xrange(len(gen_data)):
-    print "\n*******************************************************\n"
-    print "src:", ' '.join([src_dict.get(w) for w in gen_data[i][0]]), "\n"
-    for j in xrange(beam_size):
-        print "prob = %f:" % (prob[i][j]), seq_list[i * beam_size + j]
-```
-
-模型测试的执行与模型训练类似，只需执行
-
-```
-python nmt_without_attention_v2.py --generate
-```
-则自动为测试数据生成了对应的翻译结果。
-设置beam search的宽度为3，输入某个法文句子
-
-```
-src: <s> Elles connaissent leur entreprise mieux que personne . <e>
-```
-
-其对应的英文翻译结果为
-
-```
-prob = -3.754819: They know their business better than anyone . <e>
-prob = -4.445528: They know their businesses better than anyone . <e>
-prob = -5.026885: They know their business better than anybody . <e>
-```
-
-* `prob`表示生成句子的得分，随之其后则是翻译生成的句子；
-* `<s>` 表示句子的开始，`<e>`表示一个句子的结束，如果出现了在词典中未包含的词，则用`<unk>`替代。
+- 第一行为输入的源语言句子。
+- 第二 ~ beam_size + 1 行是柱搜索生成的 `beam_size` 条翻译结果
+    - 相同行的输出以“\t”分隔为两列，第一列是句子的log 概率，第二列是翻译结果的文本。
+    - 符号`<s>` 表示句子的开始，符号`<e>`表示一个句子的结束，如果出现了在词典中未包含的词，则用符号`<unk>`替代。
 
 至此，我们在 PaddlePaddle 上实现了一个初步的机器翻译模型。我们可以看到，PaddlePaddle 提供了灵活丰富的API供大家选择和使用，使得我们能够很方便完成各种复杂网络的配置。机器翻译本身也是个快速发展的领域，各种新方法新思想在不断涌现。在学习完本例后，读者若有兴趣和余力，可基于 PaddlePaddle 平台实现更为复杂、性能更优的机器翻译模型。
 

nmt_without_attention/generate.py

+#!/usr/bin/env python
+import os
+import logging
+import numpy as np
+
+from network_conf import seq2seq_net
+
+logger = logging.getLogger("paddle")
+logger.setLevel(logging.WARNING)
+
+
+def infer_a_batch(inferer, test_batch, beam_size, src_dict, trg_dict):
+    beam_result = inferer.infer(input=test_batch, field=["prob", "id"])
+
+    gen_sen_idx = np.where(beam_result[1] == -1)[0]
+    assert len(gen_sen_idx) == len(test_batch) * beam_size
+
+    start_pos, end_pos = 1, 0
+    for i, sample in enumerate(test_batch):
+        print(" ".join([
+            src_dict[w] for w in sample[0][1:-1]
+        ]))  # skip the start and ending mark when print the source sentence
+        for j in xrange(beam_size):
+            end_pos = gen_sen_idx[i * beam_size + j]
+            print("%.4f\t%s" % (beam_result[0][i][j], " ".join(
+                trg_dict[w] for w in beam_result[1][start_pos:end_pos])))
+            start_pos = end_pos + 2
+        print("\n")
+
+
+def generate(source_dict_dim, target_dict_dim, model_path, beam_size,
+             batch_size):
+    """
+    Sequence generation for NMT.
+
+    :param source_dict_dim: size of source dictionary
+    :type source_dict_dim: int
+    :param target_dict_dim: size of target dictionary
+    :type target_dict_dim: int
+    :param model_path: path for inital model
+    :type model_path: string
+    :param beam_size: the expanson width in each generation setp
+    :param beam_size: int
+    :param batch_size: the number of training examples in one forward pass
+    :param batch_size: int
+    """
+
+    assert os.path.exists(model_path), "trained model does not exist."
+
+    # step 1: prepare dictionary
+    src_dict, trg_dict = paddle.dataset.wmt14.get_dict(source_dict_dim)
+
+    # step 2: load the trained model
+    paddle.init(use_gpu=False, trainer_count=1)
+    with gzip.open(model_path) as f:
+        parameters = paddle.parameters.Parameters.from_tar(f)
+    beam_gen = seq2seq_net(
+        source_dict_dim,
+        target_dict_dim,
+        beam_size=beam_size,
+        max_length=100,
+        is_generating=True)
+    inferer = paddle.inference.Inference(
+        output_layer=beam_gen, parameters=parameters)
+
+    # step 3: iterating over the testing dataset
+    test_batch = []
+    for idx, item in enumerate(paddle.dataset.wmt14.gen(source_dict_dim)()):
+        test_batch.append([item[0]])
+        if len(test_batch) == batch_size:
+            infer_a_batch(inferer, test_batch, beam_size, src_dict, trg_dict)
+            test_batch = []
+
+    if len(test_batch):
+        infer_a_batch(inferer, test_batch, beam_size, src_dict, trg_dict)
+        test_batch = []
+
+
+if __name__ == "__main__":
+    generate(
+        source_dict_dim=30000,
+        target_dict_dim=30000,
+        batch_size=20,
+        beam_size=3,
+        model_path="models/nmt_without_att_params_batch_00100.tar.gz")

nmt_without_attention/index.html

@@ -93,14 +93,15 @@ RNN 的原始结构用一个向量来存储隐状态，然而这种结构的 RNN
 在 PaddlePaddle 中，双向编码器可以很方便地调用相关 APIs 实现：
 
 ```python
-#### Encoder
 src_word_id = paddle.layer.data(
     name='source_language_word',
     type=paddle.data_type.integer_value_sequence(source_dict_dim))
+
 # source embedding
 src_embedding = paddle.layer.embedding(
     input=src_word_id, size=word_vector_dim)
-# use bidirectional_gru
+
+# bidirectional GRU as encoder
 encoded_vector = paddle.networks.bidirectional_gru(
     input=src_embedding,
     size=encoder_size,
@@ -126,19 +127,17 @@ encoded_vector = paddle.networks.bidirectional_gru(
 
 
 ### 无注意力机制的解码器
-PaddleBook中[机器翻译](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md)的相关章节中，已介绍了带注意力机制（Attention Mechanism）的 Encoder-Decoder 结构，本例则介绍的是不带注意力机制的 Encoder-Decoder 结构。关于注意力机制，读者可进一步参考 PaddleBook 和参考文献\[[3](#参考文献)]。
+- PaddleBook中[机器翻译](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md)的相关章节中，已介绍了带注意力机制（Attention Mechanism）的 Encoder-Decoder 结构，本例介绍的则是不带注意力机制的 Encoder-Decoder 结构。关于注意力机制，读者可进一步参考 PaddleBook 和参考文献\[[3](#参考文献)]。
 
 对于流行的RNN单元，PaddlePaddle 已有很好的实现均可直接调用。如果希望在 RNN 每一个时间步实现某些自定义操作，可使用 PaddlePaddle 中的`recurrent_layer_group`。首先，自定义单步逻辑函数，再利用函数 `recurrent_group()` 循环调用单步逻辑函数处理整个序列。本例中的无注意力机制的解码器便是使用`recurrent_layer_group`来实现，其中，单步逻辑函数`gru_decoder_without_attention()`相关代码如下：
 
 ```python
-#### Decoder
+# the initialization state for decoder GRU
 encoder_last = paddle.layer.last_seq(input=encoded_vector)
-encoder_last_projected = paddle.layer.mixed(
-        size=decoder_size,
-        act=paddle.activation.Tanh(),
-        input=paddle.layer.full_matrix_projection(input=encoder_last))
+encoder_last_projected = paddle.layer.fc(
+    size=decoder_size, act=paddle.activation.Tanh(), input=encoder_last)
 
-# gru step
+# the step function for decoder GRU
 def gru_decoder_without_attention(enc_vec, current_word):
     '''
     Step function for gru decoder
@@ -148,33 +147,29 @@ def gru_decoder_without_attention(enc_vec, current_word):
     :type current_word: layer object
     '''
     decoder_mem = paddle.layer.memory(
-        name='gru_decoder',
-        size=decoder_size,
-        boot_layer=encoder_last_projected)
+            name="gru_decoder",
+            size=decoder_size,
+            boot_layer=encoder_last_projected)
 
     context = paddle.layer.last_seq(input=enc_vec)
 
-    decoder_inputs = paddle.layer.mixed(
-        size=decoder_size * 3,
-        input=[
-            paddle.layer.full_matrix_projection(input=context),
-            paddle.layer.full_matrix_projection(input=current_word)
-        ])
+    decoder_inputs = paddle.layer.fc(
+        size=decoder_size * 3, input=[context, current_word])
 
     gru_step = paddle.layer.gru_step(
-        name='gru_decoder',
+        name="gru_decoder",
         act=paddle.activation.Tanh(),
         gate_act=paddle.activation.Sigmoid(),
         input=decoder_inputs,
         output_mem=decoder_mem,
         size=decoder_size)
 
-    out = paddle.layer.mixed(
+     out = paddle.layer.fc(
         size=target_dict_dim,
         bias_attr=True,
         act=paddle.activation.Softmax(),
-        input=paddle.layer.full_matrix_projection(input=gru_step))
-    return out
+        input=gru_step)
+    return out  
 ```
 
 在模型训练和测试阶段，解码器的行为有很大的不同：
@@ -185,34 +180,14 @@ def gru_decoder_without_attention(enc_vec, current_word):
 训练和生成的逻辑分别实现在如下的`if-else`条件分支中：
 
 ```python
-decoder_group_name = "decoder_group"
-group_input1 = paddle.layer.StaticInput(input=encoded_vector, is_seq=True)
+group_input1 = paddle.layer.StaticInput(input=encoded_vector)
 group_inputs = [group_input1]
-if not generating:
-    trg_embedding = paddle.layer.embedding(
-        input=paddle.layer.data(
-            name='target_language_word',
-            type=paddle.data_type.integer_value_sequence(target_dict_dim)),
-            size=word_vector_dim,
-            param_attr=paddle.attr.ParamAttr(name='_target_language_embedding'))
-    group_inputs.append(trg_embedding)
-
-    decoder = paddle.layer.recurrent_group(
-        name=decoder_group_name,
-        step=gru_decoder_without_attention,
-        input=group_inputs)
-
-    lbl = paddle.layer.data(
-        name='target_language_next_word',
-            type=paddle.data_type.integer_value_sequence(target_dict_dim))
-    cost = paddle.layer.classification_cost(input=decoder, label=lbl)
-
-    return cost
-else:
 
+decoder_group_name = "decoder_group"
+if is_generating:
     trg_embedding = paddle.layer.GeneratedInput(
         size=target_dict_dim,
-        embedding_name='_target_language_embedding',
+        embedding_name="_target_language_embedding",
         embedding_size=word_vector_dim)
     group_inputs.append(trg_embedding)
 
@@ -226,6 +201,26 @@ else:
         max_length=max_length)
 
     return beam_gen
+else:
+    trg_embedding = paddle.layer.embedding(
+        input=paddle.layer.data(
+            name="target_language_word",
+            type=paddle.data_type.integer_value_sequence(target_dict_dim)),
+        size=word_vector_dim,
+        param_attr=paddle.attr.ParamAttr(name="_target_language_embedding"))
+    group_inputs.append(trg_embedding)
+
+    decoder = paddle.layer.recurrent_group(
+        name=decoder_group_name,
+        step=gru_decoder_without_attention,
+        input=group_inputs)
+
+    lbl = paddle.layer.data(
+        name="target_language_next_word",
+        type=paddle.data_type.integer_value_sequence(target_dict_dim))
+    cost = paddle.layer.classification_cost(input=decoder, label=lbl)
+
+    return cost
 ```
 
 ## 数据准备
@@ -233,29 +228,31 @@ else:
 
 ## 模型的训练与测试
 
-在定义好网络结构后，就可以进行模型训练与测试了。根据用户运行时传递的参数是`--train` 还是 `--generate`，Python 脚本的 `main()` 函数分别调用函数`train()`和`generate()`来完成模型的训练与测试。
-
 ### 模型训练
-模型训练阶段，函数 `train()` 依次完成了如下的逻辑：
+
+启动模型训练的十分简单，只需在命令行窗口中执行`python train.py`。模型训练阶段 `train.py` 脚本中的 `train()` 函数依次完成了如下的逻辑：
 
 **a) 由网络定义，解析网络结构，初始化模型参数**
 
-```
-# initialize model
+```python
+# define the network topolgy.
 cost = seq2seq_net(source_dict_dim, target_dict_dim)
 parameters = paddle.parameters.create(cost)
 ```
 
 **b) 设定训练过程中的优化策略、定义训练数据读取 `reader`**
 
-```
-# define optimize method and trainer
+```python
+# define optimization method
 optimizer = paddle.optimizer.RMSProp(
     learning_rate=1e-3,
     gradient_clipping_threshold=10.0,
     regularization=paddle.optimizer.L2Regularization(rate=8e-4))
+
+# define the trainer instance
 trainer = paddle.trainer.SGD(
     cost=cost, parameters=parameters, update_equation=optimizer)
+
 # define data reader
 wmt14_reader = paddle.batch(
     paddle.reader.shuffle(
@@ -265,40 +262,33 @@ wmt14_reader = paddle.batch(
 
 **c) 定义事件句柄，打印训练中间结果、保存模型快照**
 
-```
-# define event_handler callback
+```python
+# define the event_handler callback
 def event_handler(event):
     if isinstance(event, paddle.event.EndIteration):
-        if event.batch_id % 100 == 0 and event.batch_id > 0:
-            with gzip.open('models/nmt_without_att_params_batch_%d.tar.gz' %
-                           event.batch_id, 'w') as f:
+        if not event.batch_id % 100 and event.batch_id:
+            with gzip.open(
+                    os.path.join(save_path,
+                                 "nmt_without_att_%05d_batch_%05d.tar.gz" %
+                                 event.pass_id, event.batch_id), "w") as f:
                 parameters.to_tar(f)
 
-        if event.batch_id % 10 == 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()
+        if event.batch_id and not event.batch_id % 10:
+            logger.info("Pass %d, Batch %d, Cost %f, %s" % (
+                event.pass_id, event.batch_id, event.cost, event.metrics))
 ```
 
 **d) 开始训练**
 
-```
-# start to train
+```python
+# start training
 trainer.train(
     reader=wmt14_reader, event_handler=event_handler, num_passes=2)
 ```
 
-启动模型训练的十分简单，只需在命令行窗口中执行
-
-```
-python nmt_without_attention_v2.py --train
-```
-
 输出样例为
 
-```
+```text
 Pass 0, Batch 0, Cost 267.674663, {'classification_error_evaluator': 1.0}
 .........
 Pass 0, Batch 10, Cost 172.892294, {'classification_error_evaluator': 0.953895092010498}
@@ -310,81 +300,80 @@ Pass 0, Batch 30, Cost 153.633665, {'classification_error_evaluator': 0.86438035
 Pass 0, Batch 40, Cost 168.170543, {'classification_error_evaluator': 0.8348183631896973}
 ```
 
+### 生成翻译结果
+利用训练好的模型生成翻译文本也十分简单。
+
+1. 首先请修改`generate.py`脚本中`main`中传递给`generate`函数的参数，以选择使用哪一个保存的模型来生成。默认参数如下所示：
+
+    ```python
+    generate(
+        source_dict_dim=30000,
+        target_dict_dim=30000,
+        batch_size=20,
+        beam_size=3,
+        model_path="models/nmt_without_att_params_batch_00100.tar.gz")
+    ```
+
+2. 在终端执行命令 `python generate.py`，脚本中的`generate()`执行了依次如下逻辑：
+
+    **a) 加载测试样本**
+
+    ```python
+    # load data  samples for generation
+    gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
+    gen_data = []
+    for item in gen_creator():
+        gen_data.append((item[0], ))
+    ```
+
+    **b) 初始化模型，执行`infer()`为每个输入样本生成`beam search`的翻译结果**
+
+    ```python
+    beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
+    with gzip.open(init_models_path) as f:
+        parameters = paddle.parameters.Parameters.from_tar(f)
+    # prob is the prediction probabilities, and id is the prediction word.
+    beam_result = paddle.infer(
+        output_layer=beam_gen,
+        parameters=parameters,
+        input=gen_data,
+        field=['prob', 'id'])
+    ```
+
+    **c) 加载源语言和目标语言词典，将`id`序列表示的句子转化成原语言并输出结果**
+
+    ```python
+    beam_result = inferer.infer(input=test_batch, field=["prob", "id"])
+
+    gen_sen_idx = np.where(beam_result[1] == -1)[0]
+    assert len(gen_sen_idx) == len(test_batch) * beam_size
+
+    start_pos, end_pos = 1, 0
+    for i, sample in enumerate(test_batch):
+        print(" ".join([
+            src_dict[w] for w in sample[0][1:-1]
+        ]))  # skip the start and ending mark when print the source sentence
+        for j in xrange(beam_size):
+            end_pos = gen_sen_idx[i * beam_size + j]
+            print("%.4f\t%s" % (beam_result[0][i][j], " ".join(
+                trg_dict[w] for w in beam_result[1][start_pos:end_pos])))
+            start_pos = end_pos + 2
+        print("\n")
+    ```
+
+设置beam search的宽度为3，输入为一个法文句子，则自动为测试数据生成对应的翻译结果，输出格式如下：
+
+```text
+Elles connaissent leur entreprise mieux que personne .
+-3.754819        They know their business better than anyone . <e>
+-4.445528        They know their businesses better than anyone . <e>
+-5.026885        They know their business better than anybody . <e>
 
-### 模型测试
-模型测试阶段，函数`generate()`执行了依次如下逻辑：
-
-**a) 加载测试样本**
-
-```
-# load data  samples for generation
-gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
-gen_data = []
-for item in gen_creator():
-    gen_data.append((item[0], ))
 ```
-
-**b) 初始化模型，执行`infer()`为每个输入样本生成`beam search`的翻译结果**
-
-```
-beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
-with gzip.open(init_models_path) as f:
-    parameters = paddle.parameters.Parameters.from_tar(f)
-# prob is the prediction probabilities, and id is the prediction word.
-beam_result = paddle.infer(
-    output_layer=beam_gen,
-    parameters=parameters,
-    input=gen_data,
-    field=['prob', 'id'])
-```
-
-**c) 加载源语言和目标语言词典，将`id`序列表示的句子转化成原语言并输出结果**
-
-```
-# get the dictionary
-src_dict, trg_dict = paddle.dataset.wmt14.get_dict(source_dict_dim)
-
-# the delimited element of generated sequences is -1,
-# the first element of each generated sequence is the sequence length
-seq_list = []
-seq = []
-for w in beam_result[1]:
-    if w != -1:
-        seq.append(w)
-    else:
-        seq_list.append(' '.join([trg_dict.get(w) for w in seq[1:]]))
-        seq = []
-
-prob = beam_result[0]
-for i in xrange(len(gen_data)):
-    print "\n*******************************************************\n"
-    print "src:", ' '.join([src_dict.get(w) for w in gen_data[i][0]]), "\n"
-    for j in xrange(beam_size):
-        print "prob = %f:" % (prob[i][j]), seq_list[i * beam_size + j]
-```
-
-模型测试的执行与模型训练类似，只需执行
-
-```
-python nmt_without_attention_v2.py --generate
-```
-则自动为测试数据生成了对应的翻译结果。
-设置beam search的宽度为3，输入某个法文句子
-
-```
-src: <s> Elles connaissent leur entreprise mieux que personne . <e>
-```
-
-其对应的英文翻译结果为
-
-```
-prob = -3.754819: They know their business better than anyone . <e>
-prob = -4.445528: They know their businesses better than anyone . <e>
-prob = -5.026885: They know their business better than anybody . <e>
-```
-
-* `prob`表示生成句子的得分，随之其后则是翻译生成的句子；
-* `<s>` 表示句子的开始，`<e>`表示一个句子的结束，如果出现了在词典中未包含的词，则用`<unk>`替代。
+- 第一行为输入的源语言句子。
+- 第二 ~ beam_size + 1 行是柱搜索生成的 `beam_size` 条翻译结果
+    - 相同行的输出以“\t”分隔为两列，第一列是句子的log 概率，第二列是翻译结果的文本。
+    - 符号`<s>` 表示句子的开始，符号`<e>`表示一个句子的结束，如果出现了在词典中未包含的词，则用符号`<unk>`替代。
 
 至此，我们在 PaddlePaddle 上实现了一个初步的机器翻译模型。我们可以看到，PaddlePaddle 提供了灵活丰富的API供大家选择和使用，使得我们能够很方便完成各种复杂网络的配置。机器翻译本身也是个快速发展的领域，各种新方法新思想在不断涌现。在学习完本例后，读者若有兴趣和余力，可基于 PaddlePaddle 平台实现更为复杂、性能更优的机器翻译模型。
 

nmt_without_attention/nmt_without_attention.py → nmt_without_attention/network_conf.py

 #!/usr/bin/env python
-
+import paddle.v2 as paddle
 import sys
 import gzip
-import paddle.v2 as paddle
-
-### Parameters
-word_vector_dim = 620
-latent_chain_dim = 1000
-
-beam_size = 5
-max_length = 50
 
 
-def seq2seq_net(source_dict_dim, target_dict_dim, generating=False):
-    '''
+def seq2seq_net(source_dict_dim,
+                target_dict_dim,
+                word_vector_dim=620,
+                rnn_hidden_size=1000,
+                beam_size=1,
+                max_length=50,
+                is_generating=False):
+    """
     Define the network structure of NMT, including encoder and decoder.
 
     :param source_dict_dim: size of source dictionary
     :type source_dict_dim : int
     :param target_dict_dim: size of target dictionary
     :type target_dict_dim: int
-    '''
+    :param word_vector_dim: size of source language word embedding
+    :type word_vector_dim: int
+    :param rnn_hidden_size: size of hidden state of encoder and decoder RNN
+    :type rnn_hidden_size: int
+    :param beam_size: expansion width in each step when generating
+    :type beam_size: int
+    :param max_length: max iteration number in generation
+    :type max_length: int
+    :param generating: whether to generate sequence or to train
+    :type generating: bool
+    """
+
+    decoder_size = encoder_size = rnn_hidden_size
 
-    decoder_size = encoder_size = latent_chain_dim
-
-    #### Encoder
     src_word_id = paddle.layer.data(
-        name='source_language_word',
+        name="source_language_word",
         type=paddle.data_type.integer_value_sequence(source_dict_dim))
     src_embedding = paddle.layer.embedding(
         input=src_word_id, size=word_vector_dim)
-    # use bidirectional_gru
+
+    # use bidirectional_gru as the encoder
     encoded_vector = paddle.networks.bidirectional_gru(
         input=src_embedding,
         size=encoder_size,
@@ -41,79 +49,52 @@ def seq2seq_net(source_dict_dim, target_dict_dim, generating=False):
         return_seq=True)
     #### Decoder
     encoder_last = paddle.layer.last_seq(input=encoded_vector)
-    encoder_last_projected = paddle.layer.mixed(
-        size=decoder_size,
-        act=paddle.activation.Tanh(),
-        input=paddle.layer.full_matrix_projection(input=encoder_last))
+    encoder_last_projected = paddle.layer.fc(
+        size=decoder_size, act=paddle.activation.Tanh(), input=encoder_last)
 
     # gru step
     def gru_decoder_without_attention(enc_vec, current_word):
-        '''
+        """
         Step function for gru decoder
 
         :param enc_vec: encoded vector of source language
         :type enc_vec: layer object
         :param current_word: current input of decoder
         :type current_word: layer object
-        '''
+        """
         decoder_mem = paddle.layer.memory(
-            name='gru_decoder',
+            name="gru_decoder",
             size=decoder_size,
             boot_layer=encoder_last_projected)
 
         context = paddle.layer.last_seq(input=enc_vec)
 
-        decoder_inputs = paddle.layer.mixed(
-            size=decoder_size * 3,
-            input=[
-                paddle.layer.full_matrix_projection(input=context),
-                paddle.layer.full_matrix_projection(input=current_word)
-            ])
+        decoder_inputs = paddle.layer.fc(
+            size=decoder_size * 3, input=[context, current_word])
 
         gru_step = paddle.layer.gru_step(
-            name='gru_decoder',
+            name="gru_decoder",
             act=paddle.activation.Tanh(),
             gate_act=paddle.activation.Sigmoid(),
             input=decoder_inputs,
             output_mem=decoder_mem,
             size=decoder_size)
 
-        out = paddle.layer.mixed(
+        out = paddle.layer.fc(
             size=target_dict_dim,
             bias_attr=True,
             act=paddle.activation.Softmax(),
-            input=paddle.layer.full_matrix_projection(input=gru_step))
+            input=gru_step)
         return out
 
-    decoder_group_name = "decoder_group"
-    group_input1 = paddle.layer.StaticInput(input=encoded_vector, is_seq=True)
+    group_input1 = paddle.layer.StaticInput(input=encoded_vector)
     group_inputs = [group_input1]
 
-    if not generating:
-        trg_embedding = paddle.layer.embedding(
-            input=paddle.layer.data(
-                name='target_language_word',
-                type=paddle.data_type.integer_value_sequence(target_dict_dim)),
-            size=word_vector_dim,
-            param_attr=paddle.attr.ParamAttr(name='_target_language_embedding'))
-        group_inputs.append(trg_embedding)
-
-        decoder = paddle.layer.recurrent_group(
-            name=decoder_group_name,
-            step=gru_decoder_without_attention,
-            input=group_inputs)
-
-        lbl = paddle.layer.data(
-            name='target_language_next_word',
-            type=paddle.data_type.integer_value_sequence(target_dict_dim))
-        cost = paddle.layer.classification_cost(input=decoder, label=lbl)
-
-        return cost
-    else:
-
+    decoder_group_name = "decoder_group"
+    if is_generating:
         trg_embedding = paddle.layer.GeneratedInput(
             size=target_dict_dim,
-            embedding_name='_target_language_embedding',
+            embedding_name="_target_language_embedding",
             embedding_size=word_vector_dim)
         group_inputs.append(trg_embedding)
 
@@ -127,137 +108,23 @@ def seq2seq_net(source_dict_dim, target_dict_dim, generating=False):
             max_length=max_length)
 
         return beam_gen
-
-
-def train(source_dict_dim, target_dict_dim):
-    '''
-    Training function for NMT
-
-    :param source_dict_dim: size of source dictionary
-    :type source_dict_dim: int
-    :param target_dict_dim: size of target dictionary
-    :type target_dict_dim: int
-    '''
-    # initialize model
-    cost = seq2seq_net(source_dict_dim, target_dict_dim)
-    parameters = paddle.parameters.create(cost)
-
-    # define optimize method and trainer
-    optimizer = paddle.optimizer.RMSProp(
-        learning_rate=1e-3,
-        gradient_clipping_threshold=10.0,
-        regularization=paddle.optimizer.L2Regularization(rate=8e-4))
-    trainer = paddle.trainer.SGD(
-        cost=cost, parameters=parameters, update_equation=optimizer)
-    # define data reader
-    wmt14_reader = paddle.batch(
-        paddle.reader.shuffle(
-            paddle.dataset.wmt14.train(source_dict_dim), buf_size=8192),
-        batch_size=55)
-
-    # define event_handler callback
-    def event_handler(event):
-        if isinstance(event, paddle.event.EndIteration):
-            if event.batch_id % 100 == 0 and event.batch_id > 0:
-                with gzip.open('models/nmt_without_att_params_batch_%d.tar.gz' %
-                               event.batch_id, 'w') as f:
-                    parameters.to_tar(f)
-
-            if event.batch_id % 10 == 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()
-
-    # start to train
-    trainer.train(
-        reader=wmt14_reader, event_handler=event_handler, num_passes=2)
-
-
-def generate(source_dict_dim, target_dict_dim, init_models_path):
-    '''
-    Generating function for NMT
-
-    :param source_dict_dim: size of source dictionary
-    :type source_dict_dim: int
-    :param target_dict_dim: size of target dictionary
-    :type target_dict_dim: int
-    :param init_models_path: path for inital model
-    :type init_models_path: string
-    '''
-
-    # load data  samples for generation
-    gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
-    gen_data = []
-    for item in gen_creator():
-        gen_data.append((item[0], ))
-
-    beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
-    with gzip.open(init_models_path) as f:
-        parameters = paddle.parameters.Parameters.from_tar(f)
-    # prob is the prediction probabilities, and id is the prediction word.
-    beam_result = paddle.infer(
-        output_layer=beam_gen,
-        parameters=parameters,
-        input=gen_data,
-        field=['prob', 'id'])
-
-    # get the dictionary
-    src_dict, trg_dict = paddle.dataset.wmt14.get_dict(source_dict_dim)
-
-    # the delimited element of generated sequences is -1,
-    # the first element of each generated sequence is the sequence length
-    seq_list, seq = [], []
-    for w in beam_result[1]:
-        if w != -1:
-            seq.append(w)
-        else:
-            seq_list.append(' '.join([trg_dict.get(w) for w in seq[1:]]))
-            seq = []
-
-    prob = beam_result[0]
-    for i in xrange(len(gen_data)):
-        print "\n*******************************************************\n"
-        print "src:", ' '.join([src_dict.get(w) for w in gen_data[i][0]]), "\n"
-        for j in xrange(beam_size):
-            print "prob = %f:" % (prob[i][j]), seq_list[i * beam_size + j]
-
-
-def usage_helper():
-    print "Please specify training/generating phase!"
-    print "Usage: python nmt_without_attention_v2.py --train/generate"
-    exit(1)
-
-
-def main():
-    if not (len(sys.argv) == 2):
-        usage_helper()
-    if sys.argv[1] == '--train':
-        generating = False
-    elif sys.argv[1] == '--generate':
-        generating = True
     else:
-        usage_helper()
-
-    # initialize paddle
-    paddle.init(use_gpu=False, trainer_count=1)
-    source_language_dict_dim = 30000
-    target_language_dict_dim = 30000
+        trg_embedding = paddle.layer.embedding(
+            input=paddle.layer.data(
+                name="target_language_word",
+                type=paddle.data_type.integer_value_sequence(target_dict_dim)),
+            size=word_vector_dim,
+            param_attr=paddle.attr.ParamAttr(name="_target_language_embedding"))
+        group_inputs.append(trg_embedding)
 
-    if generating:
-        # modify this path to speicify a trained model.
-        init_models_path = 'models/nmt_without_att_params_batch_1800.tar.gz'
-        if not os.path.exists(init_models_path):
-            print "trained model cannot be found."
-            exit(1)
-        generate(source_language_dict_dim, target_language_dict_dim,
-                 init_models_path)
-    else:
-        if not os.path.exists('./models'):
-            os.system('mkdir ./models')
-        train(source_language_dict_dim, target_language_dict_dim)
+        decoder = paddle.layer.recurrent_group(
+            name=decoder_group_name,
+            step=gru_decoder_without_attention,
+            input=group_inputs)
 
+        lbl = paddle.layer.data(
+            name="target_language_next_word",
+            type=paddle.data_type.integer_value_sequence(target_dict_dim))
+        cost = paddle.layer.classification_cost(input=decoder, label=lbl)
 
-if __name__ == '__main__':
-    main()
+        return cost

nmt_without_attention/train.py

+#!/usr/bin/env python
+import os
+import logging
+import paddle.v2 as paddle
+
+from network_conf import seq2seq_net
+
+logger = logging.getLogger("paddle")
+logger.setLevel(logging.INFO)
+
+
+def train(save_dir_path, source_dict_dim, target_dict_dim):
+    '''
+    Training function for NMT
+
+    :param save_dir_path: path of the directory to save the trained models.
+    :param save_dir_path: str
+    :param source_dict_dim: size of source dictionary
+    :type source_dict_dim: int
+    :param target_dict_dim: size of target dictionary
+    :type target_dict_dim: int
+    '''
+    if not os.path.exists(save_dir_path):
+        os.mkdir(save_dir_path)
+
+    # initialize PaddlePaddle
+    paddle.init(use_gpu=False, trainer_count=1)
+
+    cost = seq2seq_net(source_dict_dim, target_dict_dim)
+    parameters = paddle.parameters.create(cost)
+
+    # define optimization method and the trainer instance
+    optimizer = paddle.optimizer.RMSProp(
+        learning_rate=1e-3,
+        gradient_clipping_threshold=10.0,
+        regularization=paddle.optimizer.L2Regularization(rate=8e-4))
+    trainer = paddle.trainer.SGD(
+        cost=cost, parameters=parameters, update_equation=optimizer)
+
+    # define data reader
+    wmt14_reader = paddle.batch(
+        paddle.reader.shuffle(
+            paddle.dataset.wmt14.train(source_dict_dim), buf_size=8192),
+        batch_size=8)
+
+    # define the event_handler callback
+    def event_handler(event):
+        if isinstance(event, paddle.event.EndIteration):
+            if not event.batch_id % 100 and event.batch_id:
+                with gzip.open(
+                        os.path.join(save_path,
+                                     "nmt_without_att_%05d_batch_%05d.tar.gz" %
+                                     event.pass_id, event.batch_id), "w") as f:
+                    parameters.to_tar(f)
+
+            if event.batch_id and not event.batch_id % 10:
+                logger.info("Pass %d, Batch %d, Cost %f, %s" % (
+                    event.pass_id, event.batch_id, event.cost, event.metrics))
+
+    # start training
+    trainer.train(
+        reader=wmt14_reader, event_handler=event_handler, num_passes=2)
+
+
+if __name__ == '__main__':
+    train(save_dir_path="models", source_dict_dim=3000, target_dict_dim=3000)

ntm_addressing_mechanism/README.md

-TBD

regression/README.md

-TBD

scheduled_sampling/README.md

@@ -4,7 +4,7 @@
 
 序列生成任务的生成目标是在给定源输入的条件下，最大化目标序列的概率。训练时该模型将目标序列中的真实元素作为解码器每一步的输入，然后最大化下一个元素的概率。生成时上一步解码得到的元素被用作当前的输入，然后生成下一个元素。可见这种情况下训练阶段和生成阶段的解码器输入数据的概率分布并不一致。
 
-Scheduled Sampling\[[1](#参考文献)\]是一种解决训练和生成时输入数据分布不一致的方法。在训练早期该方法主要使用目标序列中的真实元素作为解码器输入，可以将模型从随机初始化的状态快速引导至一个合理的状态。随着训练的进行，该方法会逐渐更多地使用生成的元素作为解码器输入，以解决数据分布不一致的问题。
+Scheduled Sampling \[[1](#参考文献)\]是一种解决训练和生成时输入数据分布不一致的方法。在训练早期该方法主要使用目标序列中的真实元素作为解码器输入，可以将模型从随机初始化的状态快速引导至一个合理的状态。随着训练的进行，该方法会逐渐更多地使用生成的元素作为解码器输入，以解决数据分布不一致的问题。
 
 标准的序列到序列模型中，如果序列前面生成了错误的元素，后面的输入状态将会收到影响，而该误差会随着生成过程不断向后累积。Scheduled Sampling以一定概率将生成的元素作为解码器输入，这样即使前面生成错误，其训练目标仍然是最大化真实目标序列的概率，模型会朝着正确的方向进行训练。因此这种方式增加了模型的容错能力。
 
@@ -24,14 +24,14 @@ Scheduled Sampling主要应用在序列到序列模型的训练阶段，而生
 图1给出了这三种方式的衰减曲线，
 
 <p align="center">
-<img src="img/decay.jpg" width="50%" align="center"><br>
+<img src="images/decay.jpg" width="50%" align="center"><br>
 图1. 线性衰减、指数衰减和反向Sigmoid衰减的衰减曲线
 </p>
 
 如图2所示，在解码器的$t$时刻Scheduled Sampling以概率$\epsilon_i$使用上一时刻的真实元素$y_{t-1}$作为解码器输入，以概率$1-\epsilon_i$使用上一时刻生成的元素$g_{t-1}$作为解码器输入。从图1可知随着$i$的增大$\epsilon_i$会不断减小，解码器将不断倾向于使用生成的元素作为输入，训练阶段和生成阶段的数据分布将变得越来越一致。
 
 <p align="center">
-<img src="img/Scheduled_Sampling.jpg" width="50%" align="center"><br>
+<img src="images/Scheduled_Sampling.jpg" width="50%" align="center"><br>
 图2. Scheduled Sampling选择不同元素作为解码器输入示意图
 </p>
 

scheduled_sampling/index.html

+
+<html>
+<head>
+  <script type="text/x-mathjax-config">
+  MathJax.Hub.Config({
+    extensions: ["tex2jax.js", "TeX/AMSsymbols.js", "TeX/AMSmath.js"],
+    jax: ["input/TeX", "output/HTML-CSS"],
+    tex2jax: {
+      inlineMath: [ ['$','$'] ],
+      displayMath: [ ['$$','$$'] ],
+      processEscapes: true
+    },
+    "HTML-CSS": { availableFonts: ["TeX"] }
+  });
+  </script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js" async></script>
+  <script type="text/javascript" src="../.tools/theme/marked.js">
+  </script>
+  <link href="http://cdn.bootcss.com/highlight.js/9.9.0/styles/darcula.min.css" rel="stylesheet">
+  <script src="http://cdn.bootcss.com/highlight.js/9.9.0/highlight.min.js"></script>
+  <link href="http://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.min.css" rel="stylesheet">
+  <link href="https://cdn.jsdelivr.net/perfect-scrollbar/0.6.14/css/perfect-scrollbar.min.css" rel="stylesheet">
+  <link href="../.tools/theme/github-markdown.css" rel='stylesheet'>
+</head>
+<style type="text/css" >
+.markdown-body {
+    box-sizing: border-box;
+    min-width: 200px;
+    max-width: 980px;
+    margin: 0 auto;
+    padding: 45px;
+}
+</style>
+
+
+<body>
+
+<div id="context" class="container-fluid markdown-body">
+</div>
+
+<!-- This block will be replaced by each markdown file content. Please do not change lines below.-->
+<div id="markdown" style='display:none'>
+# Scheduled Sampling
+
+## 概述
+
+序列生成任务的生成目标是在给定源输入的条件下，最大化目标序列的概率。训练时该模型将目标序列中的真实元素作为解码器每一步的输入，然后最大化下一个元素的概率。生成时上一步解码得到的元素被用作当前的输入，然后生成下一个元素。可见这种情况下训练阶段和生成阶段的解码器输入数据的概率分布并不一致。
+
+Scheduled Sampling \[[1](#参考文献)\]是一种解决训练和生成时输入数据分布不一致的方法。在训练早期该方法主要使用目标序列中的真实元素作为解码器输入，可以将模型从随机初始化的状态快速引导至一个合理的状态。随着训练的进行，该方法会逐渐更多地使用生成的元素作为解码器输入，以解决数据分布不一致的问题。
+
+标准的序列到序列模型中，如果序列前面生成了错误的元素，后面的输入状态将会收到影响，而该误差会随着生成过程不断向后累积。Scheduled Sampling以一定概率将生成的元素作为解码器输入，这样即使前面生成错误，其训练目标仍然是最大化真实目标序列的概率，模型会朝着正确的方向进行训练。因此这种方式增加了模型的容错能力。
+
+## 算法简介
+Scheduled Sampling主要应用在序列到序列模型的训练阶段，而生成阶段则不需要使用。
+
+训练阶段解码器在最大化第$t$个元素概率时，标准序列到序列模型使用上一时刻的真实元素$y_{t-1}$作为输入。设上一时刻生成的元素为$g_{t-1}$，Scheduled Sampling算法会以一定概率使用$g_{t-1}$作为解码器输入。
+
+设当前已经训练到了第$i$个mini-batch，Scheduled Sampling定义了一个概率$\epsilon_i$控制解码器的输入。$\epsilon_i$是一个随着$i$增大而衰减的变量，常见的定义方式有：
+
+ - 线性衰减：$\epsilon_i=max(\epsilon,k-c*i)$，其中$\epsilon$限制$\epsilon_i$的最小值，$k$和$c$控制线性衰减的幅度。
+
+ - 指数衰减：$\epsilon_i=k^i$，其中$0<k<1$，$k$控制着指数衰减的幅度。
+
+ - 反向Sigmoid衰减：$\epsilon_i=k/(k+exp(i/k))$，其中$k>1$，$k$同样控制衰减的幅度。
+
+图1给出了这三种方式的衰减曲线，
+
+<p align="center">
+<img src="images/decay.jpg" width="50%" align="center"><br>
+图1. 线性衰减、指数衰减和反向Sigmoid衰减的衰减曲线
+</p>
+
+如图2所示，在解码器的$t$时刻Scheduled Sampling以概率$\epsilon_i$使用上一时刻的真实元素$y_{t-1}$作为解码器输入，以概率$1-\epsilon_i$使用上一时刻生成的元素$g_{t-1}$作为解码器输入。从图1可知随着$i$的增大$\epsilon_i$会不断减小，解码器将不断倾向于使用生成的元素作为输入，训练阶段和生成阶段的数据分布将变得越来越一致。
+
+<p align="center">
+<img src="images/Scheduled_Sampling.jpg" width="50%" align="center"><br>
+图2. Scheduled Sampling选择不同元素作为解码器输入示意图
+</p>
+
+## 模型实现
+
+由于Scheduled Sampling是对序列到序列模型的改进，其整体实现框架与序列到序列模型较为相似。为突出本文重点，这里仅介绍与Scheduled Sampling相关的部分，完整的代码见`scheduled_sampling.py`。
+
+首先导入需要的包，并定义控制衰减概率的类`RandomScheduleGenerator`，如下：
+
+```python
+import numpy as np
+import math
+
+
+class RandomScheduleGenerator:
+    """
+    The random sampling rate for scheduled sampling algoithm, which uses devcayed
+    sampling rate.
+
+    """
+    ...
+```
+
+下面将分别定义类`RandomScheduleGenerator`的`__init__`、`getScheduleRate`和`processBatch`三个方法。
+
+`__init__`方法对类进行初始化，其`schedule_type`参数指定了使用哪种衰减方式，可选的方式有`constant`、`linear`、`exponential`和`inverse_sigmoid`。`constant`指对所有的mini-batch使用固定的$\epsilon_i$，`linear`指线性衰减方式，`exponential`表示指数衰减方式，`inverse_sigmoid`表示反向Sigmoid衰减。`__init__`方法的参数`a`和`b`表示衰减方法的参数，需要在验证集上调优。`self.schedule_computers`将衰减方式映射为计算$\epsilon_i$的函数。最后一行根据`schedule_type`将选择的衰减函数赋给`self.schedule_computer`变量。
+
+```python
+    def __init__(self, schedule_type, a, b):
+        """
+        schduled_type: is the type of the decay. It supports constant, linear,
+        exponential, and inverse_sigmoid right now.
+        a: parameter of the decay (MUST BE DOUBLE)
+        b: parameter of the decay (MUST BE DOUBLE)
+        """
+        self.schedule_type = schedule_type
+        self.a = a
+        self.b = b
+        self.data_processed_ = 0
+        self.schedule_computers = {
+            "constant": lambda a, b, d: a,
+            "linear": lambda a, b, d: max(a, 1 - d / b),
+            "exponential": lambda a, b, d: pow(a, d / b),
+            "inverse_sigmoid": lambda a, b, d: b / (b + math.exp(d * a / b)),
+        }
+        assert (self.schedule_type in self.schedule_computers)
+        self.schedule_computer = self.schedule_computers[self.schedule_type]
+```
+
+`getScheduleRate`根据衰减函数和已经处理的数据量计算$\epsilon_i$。
+
+```python
+    def getScheduleRate(self):
+        """
+        Get the schedule sampling rate. Usually not needed to be called by the users
+        """
+        return self.schedule_computer(self.a, self.b, self.data_processed_)
+
+```
+
+`processBatch`方法根据概率值$\epsilon_i$进行采样，得到`indexes`，`indexes`中每个元素取值为`0`的概率为$\epsilon_i$，取值为`1`的概率为$1-\epsilon_i$。`indexes`决定了解码器的输入是真实元素还是生成的元素，取值为`0`表示使用真实元素，取值为`1`表示使用生成的元素。
+
+```python
+    def processBatch(self, batch_size):
+        """
+        Get a batch_size of sampled indexes. These indexes can be passed to a
+        MultiplexLayer to select from the grouth truth and generated samples
+        from the last time step.
+        """
+        rate = self.getScheduleRate()
+        numbers = np.random.rand(batch_size)
+        indexes = (numbers >= rate).astype('int32').tolist()
+        self.data_processed_ += batch_size
+        return indexes
+```
+
+Scheduled Sampling需要在序列到序列模型的基础上增加一个输入`true_token_flag`，以控制解码器输入。
+
+```python
+true_token_flags = paddle.layer.data(
+    name='true_token_flag',
+    type=paddle.data_type.integer_value_sequence(2))
+```
+
+这里还需要对原始reader进行封装，增加`true_token_flag`的数据生成器。下面以线性衰减为例说明如何调用上面定义的`RandomScheduleGenerator`产生`true_token_flag`的输入数据。
+
+```python
+schedule_generator = RandomScheduleGenerator("linear", 0.75, 1000000)
+
+def gen_schedule_data(reader):
+    """
+    Creates a data reader for scheduled sampling.
+
+    Output from the iterator that created by original reader will be
+    appended with "true_token_flag" to indicate whether to use true token.
+
+    :param reader: the original reader.
+    :type reader: callable
+
+    :return: the new reader with the field "true_token_flag".
+    :rtype: callable
+    """
+
+    def data_reader():
+        for src_ids, trg_ids, trg_ids_next in reader():
+            yield src_ids, trg_ids, trg_ids_next, \
+                  [0] + schedule_generator.processBatch(len(trg_ids) - 1)
+
+    return data_reader
+```
+
+这段代码在原始输入数据（即源序列元素`src_ids`、目标序列元素`trg_ids`和目标序列下一个元素`trg_ids_next`）后追加了控制解码器输入的数据。由于解码器第一个元素是序列开始符，因此将追加的数据第一个元素设置为`0`，表示解码器第一步始终使用真实目标序列的第一个元素（即序列开始符）。
+
+训练时`recurrent_group`每一步调用的解码器函数如下：
+
+```python
+    def gru_decoder_with_attention_train(enc_vec, enc_proj, true_word,
+                                         true_token_flag):
+        """
+        The decoder step for training.
+        :param enc_vec: the encoder vector for attention
+        :type enc_vec: LayerOutput
+        :param enc_proj: the encoder projection for attention
+        :type enc_proj: LayerOutput
+        :param true_word: the ground-truth target word
+        :type true_word: LayerOutput
+        :param true_token_flag: the flag of using the ground-truth target word
+        :type true_token_flag: LayerOutput
+        :return: the softmax output layer
+        :rtype: LayerOutput
+        """
+
+        decoder_mem = paddle.layer.memory(
+            name='gru_decoder', size=decoder_size, boot_layer=decoder_boot)
+
+        context = paddle.networks.simple_attention(
+            encoded_sequence=enc_vec,
+            encoded_proj=enc_proj,
+            decoder_state=decoder_mem)
+
+        gru_out_memory = paddle.layer.memory(
+            name='gru_out', size=target_dict_dim)
+
+        generated_word = paddle.layer.max_id(input=gru_out_memory)
+
+        generated_word_emb = paddle.layer.embedding(
+            input=generated_word,
+            size=word_vector_dim,
+            param_attr=paddle.attr.ParamAttr(name='_target_language_embedding'))
+
+        current_word = paddle.layer.multiplex(
+            input=[true_token_flag, true_word, generated_word_emb])
+
+        with paddle.layer.mixed(size=decoder_size * 3) as decoder_inputs:
+            decoder_inputs += paddle.layer.full_matrix_projection(input=context)
+            decoder_inputs += paddle.layer.full_matrix_projection(
+                input=current_word)
+
+        gru_step = paddle.layer.gru_step(
+            name='gru_decoder',
+            input=decoder_inputs,
+            output_mem=decoder_mem,
+            size=decoder_size)
+
+        with paddle.layer.mixed(
+                name='gru_out',
+                size=target_dict_dim,
+                bias_attr=True,
+                act=paddle.activation.Softmax()) as out:
+            out += paddle.layer.full_matrix_projection(input=gru_step)
+
+        return out
+```
+
+该函数使用`memory`层`gru_out_memory`记忆上一时刻生成的元素，根据`gru_out_memory`选择概率最大的词语`generated_word`作为生成的词语。`multiplex`层会在真实元素`true_word`和生成的元素`generated_word`之间做出选择，并将选择的结果作为解码器输入。`multiplex`层使用了三个输入，分别为`true_token_flag`、`true_word`和`generated_word_emb`。对于这三个输入中每个元素，若`true_token_flag`中的值为`0`，则`multiplex`层输出`true_word`中的相应元素；若`true_token_flag`中的值为`1`，则`multiplex`层输出`generated_word_emb`中的相应元素。
+
+## 参考文献
+
+[1] Bengio S, Vinyals O, Jaitly N, et al. [Scheduled sampling for sequence prediction with recurrent neural networks](http://papers.nips.cc/paper/5956-scheduled-sampling-for-sequence-prediction-with-recurrent-neural-networks)//Advances in Neural Information Processing Systems. 2015: 1171-1179.
+
+</div>
+<!-- You can change the lines below now. -->
+
+<script type="text/javascript">
+marked.setOptions({
+  renderer: new marked.Renderer(),
+  gfm: true,
+  breaks: false,
+  smartypants: true,
+  highlight: function(code, lang) {
+    code = code.replace(/&amp;/g, "&")
+    code = code.replace(/&gt;/g, ">")
+    code = code.replace(/&lt;/g, "<")
+    code = code.replace(/&nbsp;/g, " ")
+    return hljs.highlightAuto(code, [lang]).value;
+  }
+});
+document.getElementById("context").innerHTML = marked(
+        document.getElementById("markdown").innerHTML)
+</script>
+</body>

sequence_tagging_for_ner/infer.py

 import gzip
 
 import reader
-from network_conf import *
-from utils import *
+import paddle.v2 as paddle
+from network_conf import ner_net
+from utils import load_dict, load_reverse_dict
 
 
 def infer(model_path, batch_size, test_data_file, vocab_file, target_file):

sequence_tagging_for_ner/train.py

@@ -2,8 +2,11 @@ import gzip
 import numpy as np
 
 import reader
-from utils import *
-from network_conf import *
+from utils import logger, load_dict, get_embedding
+from network_conf import ner_net
+
+import paddle.v2 as paddle
+import paddle.v2.evaluator as evaluator
 
 
 def main(train_data_file,
@@ -11,8 +14,12 @@ def main(train_data_file,
          vocab_file,
          target_file,
          emb_file,
+         model_save_dir,
          num_passes=10,
          batch_size=32):
+    if not os.path.exists(model_save_dir):
+        os.mkdir(model_save_dir)
+
     word_dict = load_dict(vocab_file)
     label_dict = load_dict(target_file)
 
@@ -77,8 +84,9 @@ def main(train_data_file,
 
         if isinstance(event, paddle.event.EndPass):
             # save parameters
-            with gzip.open("models/params_pass_%d.tar.gz" % event.pass_id,
-                           "w") as f:
+            with gzip.open(
+                    os.path.join(model_save_dir, "params_pass_%d.tar.gz" %
+                                 event.pass_id), "w") as f:
                 parameters.to_tar(f)
 
             result = trainer.test(reader=test_reader, feeding=feeding)
@@ -94,8 +102,8 @@ def main(train_data_file,
 
 if __name__ == "__main__":
     main(
-        train_data_file='data/train',
-        test_data_file='data/test',
-        vocab_file='data/vocab.txt',
-        target_file='data/target.txt',
-        emb_file='data/wordVectors.txt')
+        train_data_file="data/train",
+        test_data_file="data/test",
+        vocab_file="data/vocab.txt",
+        target_file="data/target.txt",
+        emb_file="data/wordVectors.txt")

text_classification/infer.py

@@ -6,15 +6,15 @@ import gzip
 
 import paddle.v2 as paddle
 
-import network_conf
 import reader
-from utils import *
+from network_conf import fc_net, convolution_net
+from utils import logger, load_dict
 
 
 def infer(topology, data_dir, model_path, word_dict_path, label_dict_path,
           batch_size):
     def _infer_a_batch(inferer, test_batch, ids_2_word, ids_2_label):
-        probs = inferer.infer(input=test_batch, field=['value'])
+        probs = inferer.infer(input=test_batch, field=["value"])
         assert len(probs) == len(test_batch)
         for word_ids, prob in zip(test_batch, probs):
             word_text = " ".join([ids_2_word[id] for id in word_ids[0]])
@@ -22,7 +22,7 @@ def infer(topology, data_dir, model_path, word_dict_path, label_dict_path,
                                   " ".join(["{:0.4f}".format(p)
                                             for p in prob]), word_text))
 
-    logger.info('begin to predict...')
+    logger.info("begin to predict...")
     use_default_data = (data_dir is None)
 
     if use_default_data:
@@ -33,9 +33,9 @@ def infer(topology, data_dir, model_path, word_dict_path, label_dict_path,
         test_reader = paddle.dataset.imdb.test(word_dict)
     else:
         assert os.path.exists(
-            word_dict_path), 'the word dictionary file does not exist'
+            word_dict_path), "the word dictionary file does not exist"
         assert os.path.exists(
-            label_dict_path), 'the label dictionary file does not exist'
+            label_dict_path), "the label dictionary file does not exist"
 
         word_dict = load_dict(word_dict_path)
         word_reverse_dict = load_reverse_dict(word_dict_path)
@@ -52,7 +52,7 @@ def infer(topology, data_dir, model_path, word_dict_path, label_dict_path,
 
     # load the trained models
     parameters = paddle.parameters.Parameters.from_tar(
-        gzip.open(model_path, 'r'))
+        gzip.open(model_path, "r"))
     inferer = paddle.inference.Inference(
         output_layer=prob_layer, parameters=parameters)
 
@@ -70,19 +70,19 @@ def infer(topology, data_dir, model_path, word_dict_path, label_dict_path,
         test_batch = []
 
 
-if __name__ == '__main__':
-    model_path = 'dnn_params_pass_00000.tar.gz'
+if __name__ == "__main__":
+    model_path = "models/dnn_params_pass_00000.tar.gz"
     assert os.path.exists(model_path), "the trained model does not exist."
 
-    nn_type = 'dnn'
+    nn_type = "dnn"
     test_dir = None
     word_dict = None
     label_dict = None
 
-    if nn_type == 'dnn':
-        topology = network_conf.fc_net
-    elif nn_type == 'cnn':
-        topology = network_conf.convolution_net
+    if nn_type == "dnn":
+        topology = fc_net
+    elif nn_type == "cnn":
+        topology = convolution_net
 
     infer(
         topology=topology,

text_classification/train.py

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+import os
 import sys
 import gzip
 
 import paddle.v2 as paddle
 
-import network_conf
 import reader
-from utils import *
+from utils import logger, parse_train_cmd, build_dict, load_dict
+from network_conf import fc_net, convolution_net
 
 
 def train(topology,
@@ -15,6 +16,7 @@ def train(topology,
           test_data_dir=None,
           word_dict_path=None,
           label_dict_path=None,
+          model_save_dir="models",
           batch_size=32,
           num_passes=10):
     """
@@ -33,6 +35,8 @@ def train(topology,
     :params num_pass: train pass number
     :type num_pass: int
     """
+    if not os.path.exists(model_save_dir):
+        os.mkdir(model_save_dir)
 
     use_default_data = (train_data_dir is None)
 
@@ -136,8 +140,9 @@ def train(topology,
                 result = trainer.test(reader=test_reader, feeding=feeding)
                 logger.info("Test at Pass %d, %s \n" % (event.pass_id,
                                                         result.metrics))
-            with gzip.open("dnn_params_pass_%05d.tar.gz" % event.pass_id,
-                           "w") as f:
+            with gzip.open(
+                    os.path.join(model_save_dir, "dnn_params_pass_%05d.tar.gz" %
+                                 event.pass_id), "w") as f:
                 parameters.to_tar(f)
 
     trainer.train(
@@ -151,9 +156,9 @@ def train(topology,
 
 def main(args):
     if args.nn_type == "dnn":
-        topology = network_conf.fc_net
+        topology = fc_net
     elif args.nn_type == "cnn":
-        topology = network_conf.convolution_net
+        topology = convolution_net
 
     train(
         topology=topology,
@@ -162,7 +167,8 @@ def main(args):
         word_dict_path=args.word_dict,
         label_dict_path=args.label_dict,
         batch_size=args.batch_size,
-        num_passes=args.num_passes)
+        num_passes=args.num_passes,
+        model_save_dir=args.model_save_dir)
 
 
 if __name__ == "__main__":

text_classification/utils.py

@@ -5,7 +5,7 @@ import os
 import argparse
 from collections import defaultdict
 
-logger = logging.getLogger("logger")
+logger = logging.getLogger("paddle")
 logger.setLevel(logging.INFO)
 
 
@@ -60,6 +60,12 @@ def parse_train_cmd():
         help="the number of training examples in one forward/backward pass")
     parser.add_argument(
         "--num_passes", type=int, default=10, help="number of passes to train")
+    parser.add_argument(
+        "--model_save_dir",
+        type=str,
+        required=False,
+        help=("path to save the trained models."),
+        default="models")
 
     return parser.parse_args()