Merge branch 'develop' of https://github.com/PaddlePaddle/models into add_ner_model

ltr/README.md

-TBD
+## 排序学习(LearningToRank)
+
+排序学习技术\[[1](#参考文献1)\]是构建排序模型的机器学习方法，在信息检索，自然语言处理，数据挖掘等机器学场景中具有重要作用。排序学习的主要目的是对给定一组文档，对任意查询请求给出反映相关性的文档排序。在本例子中，利用标注过的语料库训练两种经典排序模型RankNet[[4](#参考文献4)\]和LamdaRank[[6](#参考文献6)\]，分别可以生成对应的排序模型，能够对任意查询请求，给出相关性文档排序。
+
+RankNet模型在命令行输入：
+
+```python
+python ranknet.py
+```
+
+LambdaRank模型在命令行输入：
+
+```python
+python lambdaRank.py
+```
+
+用户只需要使用以上命令就完成排序模型的训练和预测，程序会自动下载内置数据集，无需手动下载。
+
+
+
+## 背景介绍
+
+排序学习技术随着互联网的快速增长而受到越来越多关注，是机器学习中的常见任务之一。一方面人工排序规则不能处理海量规模的候选数据，另一方面无法为不同渠道的候选数据给于合适的权重，因此排序学习在日常生活中应用非常广泛。排序学习起源于信息检索领域，目前仍然是许多信息检索场景中的核心模块，例如搜索引擎搜索结果排序，推荐系统候选集排序，在线广告排序等等。在本例子中，采用文档检索阐述排序学习模型。
+
+<p align="center">
+<img src="image/search-engine-example.png" width="30%" ><br/>
+图1. 排序模型在文档检索的典型应用搜索引擎中的作用
+</p>
+
+假定有一组文档S，文档检索任务是依据和请求的相关性，给出文档排列顺序。查询引擎根据查询请求，排序模型会给每个文档打出分数，依据打分情况倒序排列文档，得到查询结果。在训练模型时，给定一条查询，并给出对应的文档最佳排序和得分。在预测时候，给出查询请求，排序模型生成文档排序。常见的排序学习方法划分为以下三类：
+
+- Pointwise 方法
+
+  Pointwise方法是通过近似为回归问题解决排序问题，输入的单条样本为**得分-文档**，将每个查询-文档对的相关性得分作为实数分数或者序数分数，使得单个查询-文档对作为样本点(Pointwise的由来)，训练排序模型。预测时候对于指定输入，给出查询-文档对的相关性得分。
+
+- Pairwise方法
+
+  Pairwise方法是通过近似为分类问题解决排序问题，输入的单条样本为**标签-文档对**。对于一次查询的多个结果文档，组合任意两个文档形成文档对作为输入样本。即学习一个二分类器，对输入的一对文档对AB（Pairwise的由来），根据A相关性是否比B好，二分类器给出分类标签1或0。对所有文档对进行分类，就可以得到一组偏序关系，从而构造文档全集的排序关系。该类方法的原理是对给定的文档全集S，降低排序中的逆序文档对的个数来降低排序错误，从而达到优化排序结果的目的。
+
+- Listwise方法
+
+  Listwise方法是直接优化排序列表，输入为单条样本为一个**文档排列**。通过构造合适的度量函数衡量当前文档排序和最优排序差值，优化度量函数得到排序模型。由于度量函数很多具有非连续性的性质，优化困难。
+
+  ​
+
+<p align="center">
+<img src="image/learningToRank.jpg" width="50%" ><br/>
+图2. 排序模型构造的三类方法
+</p>
+
+## 实验数据
+
+本例子中的实验数据采用了排序学习中的基准数据[LETOR]([http://research.microsoft.com/en-us/um/beijing/projects/letor/LETOR4.0/Data/MQ2007.rar](http://research.microsoft.com/en-us/um/beijing/projects/letor/LETOR4.0/Data/MQ2007.rar))中语料库，部分来自于Gov2网站的查询请求结果，包含了约1700条查询请求结果文档列表，并对文档相关性做出了人工标注。其中，一条查询含有唯一的查询id，对应于多个具有相关性的文档，构成了一次查询请求结果文档列表。每个文档由一个一维数组的特征向量表示，并对应一个人工标注与查询的相关性分数。
+
+本样例在第一次运行的时候会自动下载LETOR MQ2007数据集并缓存，用户无需手动下载。
+
+`mq2007`数据集分别提供了三种类型排序模型的生成格式，需要指定生成格式`format`
+
+例如调用接口
+
+```python
+pairwise_train_dataset = functools.partial(paddle.dataset.mq2007.train, format="pairwise")
+for label, left_doc, right_doc in pairwise_train_dataset():
+    ...
+```
+
+## 模型概览
+
+对于排序模型，本样例中提供了Pairwise方法的模型RankNet和ListWise方法的模型LambdaRank，分别代表了两类学习方法。PointWise方法的排序模型退化为回归问题，不予赘述。
+
+## RankNet排序模型
+
+[RankNet](http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf)是一种经典的Pairwise的排序学习方法，是典型的前向神经网络排序模型。在文档集合$S$中的第i个文档记做$U_i$，它的文档特征向量记做$x_i$，对于给定的一个文档对$U_i$, $U_j$，RankNet将输入的单个文档特征向量$x$映射到$f(x)$，得到$s_i=f(x_i)$, $s_j=f(x_j)$。将$U_i$相关性比$U_j$好的概率记做$P_{i,j}$，则
+
+$$P_{i,j}=P(U_{i}>U_{j})=\frac{1}{1+e^{-\sigma (s_{i}-s_{j}))}}$$
+
+由于排序度量函数大多数非连续，非光滑，因此RankNet需要一个可以优化的度量函数$C$。首先使用交叉熵作为度量函数衡量预测代价，将损失函数$C$记做
+
+$$C_{i,j}=-\bar{P_{i,j}}logP_{i,j}-(1-\bar{P_{i,j}})log(1-P_{i,j})$$
+
+其中$\bar{P_{i,j}}$代表真实概率，记做
+
+$$\bar{P_{i,j}}=\frac{1}{2}(1+S_{i,j})$$
+
+而$S_{i,j}$ = {+1,0}，表示$U_i$和$U_j$组成的Pair的标签，即Ui相关性是否好于Uj。
+
+最终得到了可求导的度量损失函数
+
+$$C=\frac{1}{2}(1-S_{i,j})\sigma (s_{i}-s{j})+log(1+e^{-\sigma (s_{i}-s_{j})})$$
+
+可以使用常规的梯度下降方法进行优化。细节见[RankNet](http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf)
+
+同时，得到文档$U_i$在排序优化过程的梯度信息为
+
+$$\lambda _{i,j}=\frac{\partial C}{\partial s_{i}} = \frac{1}{2}(1-S_{i,j})-\frac{1}{1+e^{\sigma (s_{i}-s_{j})}}$$
+
+表示的含义是本轮排序优化过程中文档$U_i$的上升或者下降量。
+
+
+
+根据以上推论构造RankNet网络结构，由若干层隐藏层和全连接层构成，如图所示，将文档特征使用隐藏层，全连接层逐层变换，完成了底层特征空间到高层特征空间的变换。其中docA和docB结构对称，分别输入到最终的RankCost层中。
+
+<p align="center">
+<img src="image/ranknet.jpg" width="50%" ><br/>
+图3. RankNet网络结构示意图
+</p>
+
+- 全连接层(fully connected layer) : 指上一层中的每个节点都连接到下层网络。本例子中同样使用paddle.layer.fc实现，注意输入到RankCost层的全连接层维度为1。
+- RankCost层： RankCost层是排序网络RankNet的核心，度量docA相关性是否比docB好，给出预测值并和label比较。使用了交叉熵(cross enctropy)作为度量损失函数，使用梯度下降方法进行优化。细节可见[RankNet](http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf)[4]。
+
+由于Pairwise中的网络结构是左右对称，可定义一半网络结构，另一半共享网络参数。在PaddlePaddle中允许网络结构中共享连接，具有相同名字的参数将会共享参数状态。使用PaddlePaddle实现RankNet排序模型，定义网络结构的示例代码如下：
+
+```python
+import paddle.v2 as paddle
+
+def half_ranknet(name_prefix, input_dim):
+  """
+  parameter in same name will be shared in paddle framework,
+  these parameters in ranknet can be used in shared state, e.g. left network and right network in detail
+  https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/api.md
+  """
+  # data layer
+  data = paddle.layer.data(name_prefix+"/data", paddle.data_type.dense_vector(input_dim))
+
+  # fully connect layer
+  hd1 = paddle.layer.fc(
+    input=data,
+    size=10,
+    act=paddle.activation.Tanh(),
+    param_attr=paddle.attr.Param(initial_std=0.01, name="hidden_w1"))
+  # fully connect layer/ output layer
+  output = paddle.layer.fc(
+    input=hd1,
+    size=1,
+    act=paddle.activation.Linear(),
+    param_attr=paddle.attr.Param(initial_std=0.01, name="output"))
+  return output
+
+def ranknet(input_dim):
+  # label layer
+  label = paddle.layer.data("label", paddle.data_type.integer_value(1))
+
+  # reuse the parameter in half_ranknet
+  output_left = half_ranknet("left", input_dim)  
+  output_right = half_ranknet("right", input_dim)
+
+  # rankcost layer
+  cost = paddle.layer.rank_cost(name="cost", left=output_left, right=output_right, label=label)
+  return cost
+```
+
+上述结构中使用了和前述图表相同的模型结构，使用了两层隐藏层，分别使用了`hidden_size=10`的全连接层和`hidden_size=1`的全连接层。本例子中的input_dim指输入**单个文档**的特征的维度，label取值为1，0。每条输入样本为`<label>，<docA, docB>`的结构，以docA为例，输入`input_dim`的文档特征，依次变换成10维，1维特征，最终输入到RankCost层中，比较docA和docB在RankCost输出得到预测值。
+
+### rankNet模型训练
+
+用户运行只需要运行命令：
+
+```python
+python ranknet.py
+```
+将会自动下载数据，训练RankNet模型，并将每个轮次的模型参数存储下来。
+
+### rankNet模型预测
+
+本例子提供了rankNet模型的训练和预测两个部分。完成训练后的模型分为拓扑结构(需要注意rank_cost不是模型拓扑结构的一部分)和模型参数文件两部分。在本例子中复用了ranknet训练时的模型拓扑结构half_ranknet，模型参数从外存中加载。模型预测的输入为单个文档的特征向量，模型会给出相关性得分。将预测得分排序即可得到最终的文档相关性排序结果。
+
+
+
+##  用户自定义RankNet数据
+
+上面的代码使用了paddle内置的排序数据，如果希望使用自定义格式数据，可以参考Paddle内置的`mq2007`数据集，编写一个生成器函数。例如输入数据为如下格式，只包含doc0-doc2三个文档。
+
+\<query_id\> \<relevance_score\> \<feature_vector\>的格式(featureid: feature_value)
+
+```
+query_id : 1, relevance_score:1, feature_vector 0:0.1, 1:0.2, 2:0.4  #doc0
+query_id : 1, relevance_score:2, feature_vector 0:0.3, 1:0.1, 2:0.4  #doc1
+query_id : 1, relevance_score:0, feature_vector 0:0.2, 1:0.4, 2:0.1  #doc2
+query_id : 2, relevance_score:0, feature_vector 0:0.1, 1:0.4, 2:0.1  #doc0
+.....
+```
+
+需要将输入样本转换为PairWise的输入格式，例如组合生成格式与mq2007 PairWise格式相同的结构
+
+\<label\> \<docA_feature_vector\>\<docB_feature_vector\>
+
+```
+1 doc1 doc0
+1 doc1 doc2
+1 doc0 doc2
+....
+```
+
+注意，一般在PairWise格式的数据中，label=1表示docA和查询的相关性好于docB，事实上label信息隐含在docA和docB组合pair中。如果存在`0 docA docB`，交换顺序构造`1 docB docA`即可。
+
+另外组合所有的pair会有训练数据冗余，因为可以从部分偏序关系恢复文档集上的全序关系。相关研究见[PairWise approach](http://www.machinelearning.org/proceedings/icml2007/papers/139.pdf)[[5](#参考文献5)\]，本例子不予赘述。
+
+```python
+# self define data generator
+def gen_pairwise_data(text_line_of_data):
+    """
+      return :
+  ------
+  label : np.array, shape=(1)
+  docA_feature_vector : np.array, shape=(1, feature_dimension)
+  docA_feature_vector : np.array, shape=(1, feature_dimension)
+    """
+    return label, docA_feature_vector, docB_feature_vector
+```
+
+对应于paddle的输入中，`integer_value`为单个整数，`dense_vector`为实数一维向量，与生成器对应，需要在训练模型之前指明输入数据对应关系。
+
+```python
+# Define the input data order
+feeding = {"label":0,
+            "left/data" :1,
+            "right/data":2}
+```
+
+
+
+## LambdaRank排序模型
+
+[LambdaRank](https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf)[6]是ListWise的排序方法，是Bugers[6]等人从RankNet发展而来，使用构造lambda函数(LambdaRank名字的由来)的方法优化度量标准NDCG(Normalized Discounted Cumulative Gain)，每个查询后得到的结果文档列表都单独作为一个训练样本。NDCG是信息论中很衡量文档列表排序质量的标准之一，前K个文档的NDCG得分记做
+
+$$NDCG@K=Z_{k}\sum (2^{rel_{i}})1/log(k+1)$$
+
+前文中RankNet中推导出，文档排序需要的是排序错误的梯度信息。NDCG度量函数是非光滑，非连续的，不能直接求得梯度信息，因此将|delta(NDCG)|=|NDCG(new) - NDCG(old)|引入，构造lambda函数为
+
+$$\lambda _{i,j}=\frac{\partial C}{\partial s_{i}}=-\frac{\sigma }{1+e^{\sigma (s_{i}-s{j})}}|\Delta NDCG|$$
+
+替换RankNet中的梯度表示，得到的排序模型称为[LambdaRank](https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf)
+
+由以上推导可知，LambdaRank网络结构和RankNet结构非常相似。如图所示
+
+<p align="center">
+<img src="image/lambdarank.jpg" width="50%" ><br/>
+图4. LambdaRank的网络结构示意图
+</p>
+
+一个查询得到的结果文档列表作为一条样本输入到网络中，替换RankCost为LambdaCost层，其他结构与RankNet相同。
+
+- LambdaCost层 : LambdaCost层使用NDCG差值作为Lambda函数，score是一个一维的序列，对于单调训练样本全连接层输出的是1x1的序列，二者的序列长度都等于该条查询得到的文档数量。Lambda函数的构造详细见[LambdaRank](https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf)
+
+使用Paddle定义LambdaRank网络结构的示例代码如下：
+
+```python
+import paddle.v2 as paddle
+def lambdaRank(input_dim):
+    """
+    lambdaRank is a ListWise Rank Model, input data and label must be sequence
+    https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf
+    parameters :
+      input_dim, one document's dense feature vector dimension
+
+    dense_vector_sequence format
+    [[f, ...], [f, ...], ...], f is represent for an float or int number
+    """
+    label = paddle.layer.data("label",
+                              paddle.data_type.dense_vector_sequence(1))
+    data = paddle.layer.data("data",
+                             paddle.data_type.dense_vector_sequence(input_dim))
+
+    # hidden layer
+    hd1 = paddle.layer.fc(
+        input=data,
+        size=10,
+        act=paddle.activation.Tanh(),
+        param_attr=paddle.attr.Param(initial_std=0.01))
+    output = paddle.layer.fc(
+        input=hd1,
+        size=1,
+        act=paddle.activation.Linear(),
+        param_attr=paddle.attr.Param(initial_std=0.01))
+    # cost layer
+    cost = paddle.layer.lambda_cost(
+        input=output, score=label, NDCG_num=6, max_sort_size=-1)
+    return cost, output
+```
+
+上述结构中使用了和前述图表相同的模型结构，和RankNet相似，分别使用了`hidden_size=10`的全连接层和`hidden_size=1`的全连接层。本例子中的input_dim指输入**单个文档**的特征的维度，label取值为1，0。每条输入样本为label，\<docA, docB\>的结构，以docA为例，输入input_dim的文档特征，依次变换成10维，1维特征，最终输入到LambdaCost层中。需要注意这里的label和data格式为**dense_vector_sequence**，表示一列文档得分或者文档特征组成的**序列**。
+
+### lambdaRank模型训练
+
+用户运行只需要运行命令：
+
+```python
+python lambdaRank.py
+```
+
+将会自动下载数据，训练LambdaRank模型，并将每个轮次的模型存储下来，将最终模型存储在文件中。
+
+### lambdaRank模型预测
+
+lambdaRank模型预测过程和ranknet相同。预测时的模型拓扑结构复用代码中的模型定义，从外存加载对应的参数文件。预测时的输入是文档列表，输出是该文档列表的各个文档相关性打分，根据打分对文档进行重新排序，即可得到最终的文档排序结果。
+
+## 自定义 LambdaRank数据
+
+上面的代码使用了paddle内置的mq2007数据，如果希望使用自定义格式数据，可以参考Paddle内置的`mq2007`数据集，编写一个生成器函数。例如输入数据为如下格式，只包含doc0-doc2三个文档。
+
+\<query_id\> \<relevance_score\> \<feature_vector\>的格式
+
+```
+query_id : 1, relevance_score:1, feature_vector 0:0.1, 1:0.2, 2:0.4  #doc0
+query_id : 1, relevance_score:2, feature_vector 0:0.3, 1:0.1, 2:0.4  #doc1
+query_id : 1, relevance_score:0, feature_vector 0:0.2, 1:0.4, 2:0.1  #doc2
+query_id : 2, relevance_score:0, feature_vector 0:0.1, 1:0.4, 2:0.1  #doc0
+query_id : 2, relevance_score:2, feature_vector 0:0.1, 1:0.4, 2:0.1  #doc1
+.....
+```
+
+需要转换为ListWise格式，例如
+
+<query_id><relevance_score> <feature_vector>
+
+```tex
+1    1    0.1,0.2,0.4
+1    2    0.3,0.1,0.4
+1    0    0.2,0.4,0.1
+
+2    0    0.1,0.4,0.1
+2    2    0.1,0.4,0.1
+......
+```
+
+**数据格式注意**
+
+- 数据中每条样本对应的文档数量都必须大于Lambda_cost层的NDCG_num
+- 单条样本对应的文档都为0，NDCG将会计算无效。文档相关性都为0，那么可以判定该query无效，可以过滤掉。
+
+
+
+```python
+# self define data generator
+def gen_listwise_data(text_all_lines_of_data):
+    """
+  return :
+  ------
+  label : np.array, shape=(samples_num, )
+  querylist : np.array, shape=(samples_num, feature_dimension)
+    """
+    return label_list, query_docs_feature_vector_matrix
+```
+
+对应于paddle的输入中，label的`dense_vector_sequence`为得分序列，data的`dense_vector_sequence`为特征向量的序列输入，input_dim为单个文档的一维特征向量维度，与生成器对应，需要在训练模型之前指明输入数据对应关系。
+
+```python
+# Define the input data order
+feeding = {"label":0,
+           "data" : 1}
+```
+
+
+
+## 总结
+
+LearningToRank是和业务场景结合非常紧密的常用机器学习方法，排序模型构造方法一般可划分为PointWise方法，PairWise方法，ListWise方法，本例子中以LETOR的mq2007数据为例，阐述了PairWise的经典方法RankNet和ListWise方法中的LambdaRank，展示如何使用Paddle框架构造对应的排序模型结构，并提供了自定义数据类型样例。Paddle提供了灵活的编程接口，并可以使用一套代码运行在单机单GPU和多机分布式多GPU情况下，可以实现LearningToRank类型任务。
+
+
+
+## 参考文献
+
+1. https://en.wikipedia.org/wiki/Learning_to_rank
+2. T.Y. Liu, “Learning to rank for information retrieval,” Foundations and Trends in Information Retrieval, vol.3, no.3, pp.225–331, 2009.
+3. H. Li, “Learning to rank for information retrieval and natural language processing,” Synthesis Lectures on Human Language Technologies, 2011, Morgan & Claypool Publishers.
+4. Burges, Chris, et al. "Learning to rank using gradient descent." *Proceedings of the 22nd international conference on Machine learning*. ACM, 2005.
+5. Cao, Zhe, et al. "Learning to rank: from pairwise approach to listwise approach." *Proceedings of the 24th international conference on Machine learning*. ACM, 2007.
+6. Burges, Christopher JC, Robert Ragno, and Quoc Viet Le. "Learning to rank with nonsmooth cost functions." *NIPS*. Vol. 6. 2006.

ltr/lambdaRank.py

+import os, sys
+import gzip
+import paddle.v2 as paddle
+import numpy as np
+import functools
+
+#lambdaRank is listwise learning to rank model
+
+
+def lambdaRank(input_dim):
+    """
+    lambdaRank is a ListWise Rank Model, input data and label must be sequence
+    https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf
+    parameters :
+      input_dim, one document's dense feature vector dimension
+
+    dense_vector_sequence format
+    [[f, ...], [f, ...], ...], f is represent for an float or int number
+    """
+    label = paddle.layer.data("label",
+                              paddle.data_type.dense_vector_sequence(1))
+    data = paddle.layer.data("data",
+                             paddle.data_type.dense_vector_sequence(input_dim))
+
+    # hidden layer
+    hd1 = paddle.layer.fc(
+        input=data,
+        size=128,
+        act=paddle.activation.Tanh(),
+        param_attr=paddle.attr.Param(initial_std=0.01))
+
+    hd2 = paddle.layer.fc(
+        input=hd1,
+        size=10,
+        act=paddle.activation.Tanh(),
+        param_attr=paddle.attr.Param(initial_std=0.01))
+    output = paddle.layer.fc(
+        input=hd2,
+        size=1,
+        act=paddle.activation.Linear(),
+        param_attr=paddle.attr.Param(initial_std=0.01))
+
+    # evaluator
+    evaluator = paddle.evaluator.auc(input=output, label=label)
+    # cost layer
+    cost = paddle.layer.lambda_cost(
+        input=output, score=label, NDCG_num=6, max_sort_size=-1)
+    return cost, output
+
+
+def train_lambdaRank(num_passes):
+    # listwise input sequence
+    fill_default_train = functools.partial(
+        paddle.dataset.mq2007.train, format="listwise")
+    fill_default_test = functools.partial(
+        paddle.dataset.mq2007.test, format="listwise")
+    train_reader = paddle.batch(
+        paddle.reader.shuffle(fill_default_train, buf_size=100), batch_size=32)
+    test_reader = paddle.batch(fill_default_test, batch_size=32)
+
+    # mq2007 input_dim = 46, dense format
+    input_dim = 46
+    cost, output = lambdaRank(input_dim)
+    parameters = paddle.parameters.create(cost)
+
+    trainer = paddle.trainer.SGD(
+        cost=cost,
+        parameters=parameters,
+        update_equation=paddle.optimizer.Adam(learning_rate=1e-4))
+
+    #  Define end batch and end pass event handler
+    def event_handler(event):
+        if isinstance(event, paddle.event.EndIteration):
+            print "Pass %d Batch %d Cost %.9f" % (event.pass_id, event.batch_id,
+                                                  event.cost)
+        if isinstance(event, paddle.event.EndPass):
+            result = trainer.test(reader=test_reader, feeding=feeding)
+            print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)
+            with gzip.open("lambdaRank_params_%d.tar.gz" % (event.pass_id),
+                           "w") as f:
+                parameters.to_tar(f)
+
+    feeding = {"label": 0, "data": 1}
+    trainer.train(
+        reader=train_reader,
+        event_handler=event_handler,
+        feeding=feeding,
+        num_passes=num_passes)
+
+
+def lambdaRank_infer(pass_id):
+    """
+  lambdaRank model inference interface
+  parameters:
+    pass_id : inference model in pass_id
+  """
+    print "Begin to Infer..."
+    input_dim = 46
+    output = lambdaRank(input_dim)
+    parameters = paddle.parameters.Parameters.from_tar(
+        gzip.open("lambdaRank_params_%d.tar.gz" % (pass_id - 1)))
+
+    infer_query_id = None
+    infer_data = []
+    infer_data_num = 1
+    fill_default_test = functools.partial(
+        paddle.dataset.mq2007.test, format="listwise")
+    for label, querylist in fill_default_test():
+        infer_data.append(querylist)
+        if len(infer_data) == infer_data_num:
+            break
+
+    # predict score of infer_data document. Re-sort the document base on predict score
+    # in descending order. then we build the ranking documents
+    predicitons = paddle.infer(
+        output_layer=output, parameters=parameters, input=infer_data)
+    for i, score in enumerate(predicitons):
+        print i, score
+
+
+if __name__ == '__main__':
+    paddle.init(use_gpu=False, trainer_count=4)
+    train_lambdaRank(2)
+    lambdaRank_infer(pass_id=1)

ltr/metrics.py

+import numpy as np
+import unittest
+
+
+def ndcg(score_list):
+    """
+    measure the ndcg score of order list
+    https://en.wikipedia.org/wiki/Discounted_cumulative_gain
+    parameter:
+        score_list: np.array, shape=(sample_num,1)
+
+    e.g. predict rank score list :
+    >>> scores =  [3, 2, 3, 0, 1, 2] 
+    >>> ndcg_score = ndcg(scores)
+    
+    """
+
+    def dcg(score_list):
+        n = len(score_list)
+        cost = .0
+        for i in range(n):
+            cost += float(score_list[i]) / np.log((i + 1) + 1)
+        return cost
+
+    dcg_cost = dcg(score_list)
+    score_ranking = sorted(score_list, reverse=True)
+    ideal_cost = dcg(score_ranking)
+    return dcg_cost / ideal_cost
+
+
+class NdcgTest(unittest.TestCase):
+    def __init__(self):
+        pass
+
+    def runcase(self):
+        a = [3, 2, 3, 0, 1, 2]
+        value = ndcg(a)
+        self.assertAlmostEqual(0.961, value, places=3)
+
+
+if __name__ == '__main__':
+    unittest.main()

ltr/ranknet.py

+import os
+import sys
+import gzip
+import functools
+import paddle.v2 as paddle
+import numpy as np
+from metrics import ndcg
+
+# ranknet is the classic pairwise learning to rank algorithm
+# http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf
+
+
+def half_ranknet(name_prefix, input_dim):
+    """
+  parameter in same name will be shared in paddle framework,
+  these parameters in ranknet can be used in shared state, e.g. left network and right network
+  shared parameters in detail
+  https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/api.md
+  """
+    # data layer
+    data = paddle.layer.data(name_prefix + "/data",
+                             paddle.data_type.dense_vector(input_dim))
+
+    # hidden layer
+    hd1 = paddle.layer.fc(
+        input=data,
+        size=10,
+        act=paddle.activation.Tanh(),
+        param_attr=paddle.attr.Param(initial_std=0.01, name="hidden_w1"))
+    # fully connect layer/ output layer
+    output = paddle.layer.fc(
+        input=hd1,
+        size=1,
+        act=paddle.activation.Linear(),
+        param_attr=paddle.attr.Param(initial_std=0.01, name="output"))
+    return output
+
+
+def ranknet(input_dim):
+    # label layer
+    label = paddle.layer.data("label", paddle.data_type.dense_vector(1))
+
+    # reuse the parameter in half_ranknet
+    output_left = half_ranknet("left", input_dim)
+    output_right = half_ranknet("right", input_dim)
+
+    evaluator = paddle.evaluator.auc(input=output_left, label=label)
+    # rankcost layer
+    cost = paddle.layer.rank_cost(
+        name="cost", left=output_left, right=output_right, label=label)
+    return cost
+
+
+def train_ranknet(num_passes):
+    train_reader = paddle.batch(
+        paddle.reader.shuffle(paddle.dataset.mq2007.train, buf_size=100),
+        batch_size=100)
+    test_reader = paddle.batch(paddle.dataset.mq2007.test, batch_size=100)
+
+    # mq2007 feature_dim = 46, dense format
+    # fc hidden_dim = 128
+    feature_dim = 46
+    cost = ranknet(feature_dim)
+    parameters = paddle.parameters.create(cost)
+
+    trainer = paddle.trainer.SGD(
+        cost=cost,
+        parameters=parameters,
+        update_equation=paddle.optimizer.Adam(learning_rate=2e-4))
+
+    # Define the input data order
+    feeding = {"label": 0, "left/data": 1, "right/data": 2}
+
+    #  Define end batch and end pass event handler
+    def event_handler(event):
+        if isinstance(event, paddle.event.EndIteration):
+            if event.batch_id % 100 == 0:
+                print "Pass %d Batch %d Cost %.9f" % (
+                    event.pass_id, event.batch_id, event.cost)
+            else:
+                sys.stdout.write(".")
+                sys.stdout.flush()
+        if isinstance(event, paddle.event.EndPass):
+            result = trainer.test(reader=test_reader, feeding=feeding)
+            print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)
+            with gzip.open("ranknet_params_%d.tar.gz" % (event.pass_id),
+                           "w") as f:
+                parameters.to_tar(f)
+
+    trainer.train(
+        reader=train_reader,
+        event_handler=event_handler,
+        feeding=feeding,
+        num_passes=num_passes)
+
+
+def ranknet_infer(pass_id):
+    """
+  load the trained model. And predict with plain txt input
+  """
+    print "Begin to Infer..."
+    feature_dim = 46
+
+    # we just need half_ranknet to predict a rank score, which can be used in sort documents
+    output = half_ranknet("left", feature_dim)
+    parameters = paddle.parameters.Parameters.from_tar(
+        gzip.open("ranknet_params_%d.tar.gz" % (pass_id - 1)))
+
+    # load data of same query and relevance documents, need ranknet to rank these candidates
+    infer_query_id = []
+    infer_data = []
+    infer_doc_index = []
+
+    # convert to mq2007 built-in data format
+    # <query_id> <relevance_score> <feature_vector>
+    plain_txt_test = functools.partial(
+        paddle.dataset.mq2007.test, format="plain_txt")
+
+    for query_id, relevance_score, feature_vector in plain_txt_test():
+        infer_query_id.append(query_id)
+        infer_data.append(feature_vector)
+
+    # predict score of infer_data document. Re-sort the document base on predict score
+    # in descending order. then we build the ranking documents
+    scores = paddle.infer(
+        output_layer=output, parameters=parameters, input=infer_data)
+    for query_id, score in zip(infer_query_id, scores):
+        print "query_id : ", query_id, " ranknet rank document order : ", score
+
+
+if __name__ == '__main__':
+    paddle.init(use_gpu=False, trainer_count=4)
+    pass_num = 2
+    train_ranknet(pass_num)
+    ranknet_infer(pass_id=pass_num - 1)

nmt_without_attention/README.md

+# 神经网络机器翻译模型
+
+## 背景介绍
+机器翻译利用计算机将源语言转换成目标语言的同义表达，是自然语言处理中重要的研究方向，有着广泛的应用需求，其实现方式也经历了不断地演化。传统机器翻译方法主要基于规则或统计模型，需要人为地指定翻译规则或设计语言特征，效果依赖于人对源语言与目标语言的理解程度。近些年来，深度学习的提出与迅速发展使得特征的自动学习成为可能。深度学习首先在图像识别和语音识别中取得成功，进而在机器翻译等自然语言处理领域中掀起了研究热潮。机器翻译中的深度学习模型直接学习源语言到目标语言的映射，大为减少了学习过程中人的介入，同时显著地提高了翻译质量。本例介绍在PaddlePaddle中如何利用循环神经网络（Recurrent Neural Network, RNN）构建一个端到端（End-to-End）的神经网络机器翻译（Neural Machine Translation, NMT）模型。
+
+## 模型概览
+基于 RNN 的神经网络机器翻译模型遵循编码器－解码器结构，其中的编码器和解码器均是一个循环神经网络。将构成编码器和解码器的两个 RNN 沿时间步展开，得到如下的模型结构图：
+
+<p align="center"><img src="images/encoder-decoder.png" width = "90%" align="center"/><br/>图 1. 编码器－解码器框架 </p>
+
+神经机器翻译模型的输入输出可以是字符，也可以是词或者短语。不失一般性，本例以基于词的模型为例说明编码器／解码器的工作机制：
+
+- **编码器**：将源语言句子编码成一个向量，作为解码器的输入。解码器的原始输入是表示词的 `id` 序列 $w = {w_1, w_2, ..., w_T}$，用独热（One-hot）码表示。为了对输入进行降维，同时建立词语之间的语义关联，模型为热独码表示的单词学习一个词嵌入（Word Embedding）表示，也就是常说的词向量，关于词向量的详细介绍请参考 PaddleBook 的[词向量](https://github.com/PaddlePaddle/book/blob/develop/04.word2vec/README.cn.md)一章。最后 RNN 单元逐个词地处理输入，得到完整句子的编码向量。
+
+- **解码器**：接受编码器的输入，逐个词地解码出目标语言序列 $u = {u_1, u_2, ..., u_{T'}}$。每个时间步，RNN 单元输出一个隐藏向量，之后经 `Softmax` 归一化计算出下一个目标词的条件概率，即 $P(u_i | w, u_1, u_2, ..., u_{t-1})$。因此，给定输入 $w$，其对应的翻译结果为 $u$ 的概率则为
+
+$$ P(u_1,u_2,...,u_{T'} | w) = \prod_{t=1}^{t={T'}}p(u_t|w, u_1, u_2, u_{t-1})$$
+
+以中文到英文的翻译为例，源语言是中文，目标语言是英文。下面是一句源语言分词后的句子
+
+```
+祝愿 祖国 繁荣 昌盛
+```
+
+对应的目标语言英文翻译结果为：
+
+```
+Wish motherland rich and powerful
+```
+
+在预处理阶段，准备源语言与目标语言互译的平行语料数据，并分别构建源语言和目标语言的词典；在训练阶段，用这样成对的平行语料训练模型；在模型测试阶段，输入中文句子，模型自动生成对应的英语翻译，然后将生成结果与标准翻译对比进行评估。在机器翻译领域，BLEU 是最流行的自动评估指标之一。
+
+### RNN 单元
+RNN 的原始结构用一个向量来存储隐状态，然而这种结构的 RNN 在训练时容易发生梯度弥散（gradient vanishing），对于长时间的依赖关系难以建模。因此人们对 RNN 单元进行了改进，提出了 LSTM\[[1](#参考文献)] 和 GRU\[[2](#参考文献)]，这两种单元以门来控制应该记住的和遗忘的信息，较好地解决了序列数据的长时依赖问题。以本例所用的 GRU 为例，其基本结构如下：
+
+<p align="center">
+<img src="images/gru.png" width = "90%" align="center"/><br/>
+图 2. GRU 单元
+ </p>
+
+可以看到除了隐含状态以外，GRU 内部还包含了两个门：更新门(Update Gate)、重置门(Reset Gate)。在每一个时间步，门限和隐状态的更新由图 2 右侧的公式决定。这两个门限决定了状态以何种方式更新。
+
+### 双向编码器
+在上述的基本模型中，编码器在顺序处理输入句子序列时，当前时刻的状态只包含了历史输入信息，而没有未来时刻的序列信息。而对于序列建模，未来时刻的上下文同样包含了重要的信息。可以使用如图 3 所示的这种双向编码器来同时获取当前时刻输入的上下文：
+<p align="center">
+<img src="images/bidirectional-encoder.png" width = "90%" align="center"/><br/>
+图 3. 双向编码器结构示意图
+ </p>
+
+图 3 所示的双向编码器\[[3](#参考文献)\]由两个独立的 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
+encoded_vector = paddle.networks.bidirectional_gru(
+    input=src_embedding,
+    size=encoder_size,
+    fwd_act=paddle.activation.Tanh(),
+    fwd_gate_act=paddle.activation.Sigmoid(),
+    bwd_act=paddle.activation.Tanh(),
+    bwd_gate_act=paddle.activation.Sigmoid(),
+    return_seq=True)
+```
+
+### 柱搜索（Beam Search） 算法
+训练完成后的生成阶段，模型根据源语言输入，解码生成对应的目标语言翻译结果。解码时，一个直接的方式是取每一步条件概率最大的词，作为当前时刻的输出。但局部最优并不一定能得到全局最优，即这种做法并不能保证最后得到的完整句子出现的概率最大。如果对解的全空间进行搜索，其代价又过大。为了解决这个问题，通常采用柱搜索（Beam Search）算法。柱搜索是一种启发式的图搜索算法，用一个参数 $k$ 控制搜索宽度，其要点如下：
+
+**1**. 在解码的过程中，始终维护 $k$ 个已解码出的子序列；
+
+**2**. 在中间时刻 $t$, 对于 $k$ 个子序列中的每个序列，计算下一个词出现的概率并取概率最大的前 $k$ 个词，组合得到 $k^2$ 个新子序列；
+
+**3**. 取 **2** 中这些组合序列中概率最大的前 $k$ 个以更新原来的子序列;
+
+**4**. 不断迭代下去，直至得到 $k$ 个完整的句子，作为翻译结果的候选。
+
+关于柱搜索的更多介绍，可以参考 PaddleBook 中[机器翻译](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md)一章中[柱搜索](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.cn.md#柱搜索算法)一节。
+
+
+### 无注意力机制的解码器
+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
+encoder_last = paddle.layer.last_seq(input=encoded_vector)
+with paddle.layer.mixed(
+        size=decoder_size,
+        act=paddle.activation.Tanh()) as encoder_last_projected:
+        encoder_last_projected += paddle.layer.full_matrix_projection(
+            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',
+        size=decoder_size,
+        boot_layer=encoder_last_projected)
+
+    context = paddle.layer.last_seq(input=enc_vec)
+
+    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',
+        act=paddle.activation.Tanh(),
+        gate_act=paddle.activation.Sigmoid(),
+        input=decoder_inputs,
+        output_mem=decoder_mem,
+        size=decoder_size)
+
+    with paddle.layer.mixed(
+            size=target_dict_dim,
+            bias_attr=True,
+            act=paddle.activation.Softmax()) as out:
+        out += paddle.layer.full_matrix_projection(input=gru_step)
+    return out
+```
+
+在模型训练和测试阶段，解码器的行为有很大的不同：
+
+- **训练阶段**：目标翻译结果的词向量`trg_embedding`作为参数传递给单步逻辑`gru_decoder_without_attention()`，函数`recurrent_group()`循环调用单步逻辑执行，最后计算目标翻译与实际解码的差异cost并返回；
+- **测试阶段**：解码器根据最后一个生成的词预测下一个词，`GeneratedInputV2()`自动取出模型预测出的概率最高的$k$个词的词向量传递给单步逻辑，`beam_search()`函数调用单步逻辑函数`gru_decoder_without_attention()`完成柱搜索并作为结果返回。
+
+训练和生成的逻辑分别实现在如下的`if-else`条件分支中：
+
+```python
+decoder_group_name = "decoder_group"
+group_input1 = paddle.layer.StaticInputV2(input=encoded_vector, is_seq=True)
+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:
+
+    trg_embedding = paddle.layer.GeneratedInputV2(
+        size=target_dict_dim,
+        embedding_name='_target_language_embedding',
+        embedding_size=word_vector_dim)
+    group_inputs.append(trg_embedding)
+
+    beam_gen = paddle.layer.beam_search(
+        name=decoder_group_name,
+        step=gru_decoder_without_attention,
+        input=group_inputs,
+        bos_id=0,
+        eos_id=1,
+        beam_size=beam_size,
+        max_length=max_length)
+
+    return beam_gen
+```
+
+## 数据准备
+本例所用到的数据来自[WMT14](http://www-lium.univ-lemans.fr/~schwenk/cslm_joint_paper/)，该数据集是法文到英文互译的平行语料。用[bitexts](http://www-lium.univ-lemans.fr/~schwenk/cslm_joint_paper/data/bitexts.tgz)作为训练数据，[dev+test data](http://www-lium.univ-lemans.fr/~schwenk/cslm_joint_paper/data/dev+test.tgz)作为验证与测试数据。在PaddlePaddle中已经封装好了该数据集的读取接口，在首次运行的时候，程序会自动完成下载，用户无需手动完成相关的数据准备。
+
+## 模型的训练与测试
+
+在定义好网络结构后，就可以进行模型训练与测试了。根据用户运行时传递的参数是`--train` 还是 `--generate`，Python 脚本的 `main()` 函数分别调用函数`train()`和`generate()`来完成模型的训练与测试。
+
+### 模型训练
+模型训练阶段，函数 `train()` 依次完成了如下的逻辑：
+
+**a) 由网络定义，解析网络结构，初始化模型参数**
+
+```
+# initialize model
+cost = seq2seq_net(source_dict_dim, target_dict_dim)
+parameters = paddle.parameters.create(cost)
+```
+
+**b) 设定训练过程中的优化策略、定义训练数据读取 `reader`**
+
+```
+# 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)
+```
+
+**c) 定义事件句柄，打印训练中间结果、保存模型快照**
+
+```
+# 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()
+```
+
+**d) 开始训练**
+
+```
+# start to train
+trainer.train(
+    reader=wmt14_reader, event_handler=event_handler, num_passes=2)
+```
+
+启动模型训练的十分简单，只需在命令行窗口中执行
+
+```
+python nmt_without_attention_v2.py --train
+```
+
+输出样例为
+
+```
+Pass 0, Batch 0, Cost 267.674663, {'classification_error_evaluator': 1.0}
+.........
+Pass 0, Batch 10, Cost 172.892294, {'classification_error_evaluator': 0.953895092010498}
+.........
+Pass 0, Batch 20, Cost 177.989329, {'classification_error_evaluator': 0.9052488207817078}
+.........
+Pass 0, Batch 30, Cost 153.633665, {'classification_error_evaluator': 0.8643803596496582}
+.........
+Pass 0, Batch 40, Cost 168.170543, {'classification_error_evaluator': 0.8348183631896973}
+```
+
+
+### 模型测试
+模型测试阶段，函数`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>`替代。
+
+至此，我们在 PaddlePaddle 上实现了一个初步的机器翻译模型。我们可以看到，PaddlePaddle 提供了灵活丰富的API供大家选择和使用，使得我们能够很方便完成各种复杂网络的配置。机器翻译本身也是个快速发展的领域，各种新方法新思想在不断涌现。在学习完本例后，读者若有兴趣和余力，可基于 PaddlePaddle 平台实现更为复杂、性能更优的机器翻译模型。
+
+
+## 参考文献
+[1] Sutskever I, Vinyals O, Le Q V. [Sequence to Sequence Learning with Neural Networks](https://arxiv.org/abs/1409.3215)[J]. 2014, 4:3104-3112.
+
+[2]Cho K, Van Merriënboer B, Gulcehre C, et al. [Learning phrase representations using RNN encoder-decoder for statistical machine translation](http://www.aclweb.org/anthology/D/D14/D14-1179.pdf)[C]. Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2014: 1724-1734.
+
+[3] Bahdanau D, Cho K, Bengio Y. [Neural machine translation by jointly learning to align and translate](https://arxiv.org/abs/1409.0473)[C]. Proceedings of ICLR 2015, 2015

nmt_without_attention/nmt_without_attention.py

+#!/usr/bin/env python
+
+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):
+    '''
+    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
+    '''
+
+    decoder_size = encoder_size = latent_chain_dim
+
+    #### Encoder
+    src_word_id = paddle.layer.data(
+        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
+    encoded_vector = paddle.networks.bidirectional_gru(
+        input=src_embedding,
+        size=encoder_size,
+        fwd_act=paddle.activation.Tanh(),
+        fwd_gate_act=paddle.activation.Sigmoid(),
+        bwd_act=paddle.activation.Tanh(),
+        bwd_gate_act=paddle.activation.Sigmoid(),
+        return_seq=True)
+    #### Decoder
+    encoder_last = paddle.layer.last_seq(input=encoded_vector)
+    with paddle.layer.mixed(
+            size=decoder_size,
+            act=paddle.activation.Tanh()) as encoder_last_projected:
+        encoder_last_projected += paddle.layer.full_matrix_projection(
+            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',
+            size=decoder_size,
+            boot_layer=encoder_last_projected)
+
+        context = paddle.layer.last_seq(input=enc_vec)
+
+        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',
+            act=paddle.activation.Tanh(),
+            gate_act=paddle.activation.Sigmoid(),
+            input=decoder_inputs,
+            output_mem=decoder_mem,
+            size=decoder_size)
+
+        with paddle.layer.mixed(
+                size=target_dict_dim,
+                bias_attr=True,
+                act=paddle.activation.Softmax()) as out:
+            out += paddle.layer.full_matrix_projection(input=gru_step)
+        return out
+
+    decoder_group_name = "decoder_group"
+    group_input1 = paddle.layer.StaticInputV2(input=encoded_vector, is_seq=True)
+    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:
+
+        trg_embedding = paddle.layer.GeneratedInputV2(
+            size=target_dict_dim,
+            embedding_name='_target_language_embedding',
+            embedding_size=word_vector_dim)
+        group_inputs.append(trg_embedding)
+
+        beam_gen = paddle.layer.beam_search(
+            name=decoder_group_name,
+            step=gru_decoder_without_attention,
+            input=group_inputs,
+            bos_id=0,
+            eos_id=1,
+            beam_size=beam_size,
+            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
+
+    if generating:
+        # shoud pass the right generated model's path here
+        init_models_path = 'models/nmt_without_att_params_batch_1800.tar.gz'
+        if not os.path.exists(init_models_path):
+            print "Cannot find models for generation"
+            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)
+
+
+if __name__ == '__main__':
+    main()

seq2seq/README.md

-TBD