Merge branch 'master' into classification

core/trainers/framework/dataset.py

@@ -68,6 +68,8 @@ class DataLoader(DatasetBase):
             reader_ins = SlotReader(context["config_yaml"])
         if hasattr(reader_ins, 'generate_batch_from_trainfiles'):
             dataloader.set_sample_list_generator(reader)
+        elif hasattr(reader_ins, 'batch_tensor_creator'):
+            dataloader.set_batch_generator(reader)
         else:
             dataloader.set_sample_generator(reader, batch_size)
         return dataloader

core/utils/dataloader_instance.py

@@ -83,6 +83,10 @@ def dataloader_by_name(readerclass,
 
     if hasattr(reader, 'generate_batch_from_trainfiles'):
         return gen_batch_reader()
+
+    if hasattr(reader, "batch_tensor_creator"):
+        return reader.batch_tensor_creator(gen_reader)
+
     return gen_reader
 
 

models/contentunderstanding/readme.md

@@ -22,12 +22,12 @@
 
 |       模型        |       简介        |       论文        |
 | :------------------: | :--------------------: | :---------: |
-| TagSpace | 标签推荐 | [EMNLP 2014][TagSpace: Semantic Embeddings from Hashtags](https://research.fb.com/publications/tagspace-semantic-embeddings-from-hashtags/) |
+| TagSpace | 标签推荐 | [EMNLP 2014][TagSpace: Semantic Embeddings from Hashtags](https://www.aclweb.org/anthology/D14-1194.pdf) |
 | Classification | 文本分类 | [EMNLP 2014][Convolutional neural networks for sentence classication](https://www.aclweb.org/anthology/D14-1181.pdf) |
 
 下面是每个模型的简介（注：图片引用自链接中的论文）
 
-[TagSpace模型](https://research.fb.com/publications/tagspace-semantic-embeddings-from-hashtags)
+[TagSpace模型](https://www.aclweb.org/anthology/D14-1194.pdf)
 <p align="center">
 <img align="center" src="../../doc/imgs/tagspace.png">
 <p>
@@ -37,25 +37,24 @@
 <img align="center" src="../../doc/imgs/cnn-ckim2014.png">
 <p>
 
-##使用教程(快速开始)
+## 使用教程(快速开始)
 ```
 git clone https://github.com/PaddlePaddle/PaddleRec.git paddle-rec
-cd paddle-rec
-
+cd PaddleRec
 python -m paddlerec.run -m models/contentunderstanding/tagspace/config.yaml
 python -m paddlerec.run -m models/contentunderstanding/classification/config.yaml
 ```
 
 ## 使用教程（复现论文）
 
-###注意
+### 注意
 
 为了方便使用者能够快速的跑通每一个模型，我们在每个模型下都提供了样例数据。如果需要复现readme中的效果请使用以下提供的脚本下载对应数据集以及数据预处理。
 
-### 数据处理
 
 **（1）TagSpace**
 
+### 数据处理
 [数据地址](https://github.com/mhjabreel/CharCNN/tree/master/data/) , [备份数据地址](https://paddle-tagspace.bj.bcebos.com/data.tar)
 
 数据格式如下
@@ -63,63 +62,148 @@ python -m paddlerec.run -m models/contentunderstanding/classification/config.yam
 "3","Wall St. Bears Claw Back Into the Black (Reuters)","Reuters - Short-sellers, Wall Street's dwindling\band of ultra-cynics, are seeing green again."
 ```
 
-数据解压后，将文本数据转为paddle数据，先将数据放到训练数据目录和测试数据目录
-
+本文提供了快速将数据集中的汉字数据处理为可训练格式数据的脚本，您在解压数据集后，将原始数据存放在raw_big_train_data和raw_big_test_data两个目录下，并在python3环境下运行我们提供的text2paddle.py文件。即可生成可以直接用于训练的数据目录test_big_data和train_big_data。命令如下：
 ```
 mkdir raw_big_train_data
 mkdir raw_big_test_data
 mv train.csv raw_big_train_data
 mv test.csv raw_big_test_data
+python3 text2paddle.py raw_big_train_data/ raw_big_test_data/ train_big_data test_big_data big_vocab_text.txt big_vocab_tag.txt
 ```
 
-运行脚本text2paddle.py 生成paddle输入格式
+运行后的data目录：  
 
 ```
-python text2paddle.py raw_big_train_data/ raw_big_test_data/ train_big_data test_big_data big_vocab_text.txt big_vocab_tag.txt
+big_vocab_tag.txt  #标签词汇数
+big_vocab_text.txt #文本词汇数
+data.tar  #数据集
+raw_big_train_data  #数据集中原始的训练集
+raw_big_test_data  #数据集中原始的测试集
+train_data  #样例训练集
+test_data  #样例测试集
+train_big_data  #数据集经处理后的训练集
+test_big_data  #数据集经处理后的测试集
+text2paddle.py  #预处理文件
 ```
 
+处理完成的数据格式如下：
+```
+2,27 7062 8390 456 407 8 11589 3166 4 7278 31046 33 3898 2897 426 1
+2,27 9493 836 355 20871 300 81 19 3 4125 9 449 462 13832 6 16570 1380 2874 5 0 797 236 19 3688 2106 14 8615 7 209 304 4 0 123 1
+2,27 12754 637 106 3839 1532 66 0 379 6 0 1246 9 307 33 161 2 8100 36 0 350 123 101 74 181 0 6657 4 0 1222 17195 1
+```
+
+
 ### 训练
+退回tagspace目录中，打开文件config.yaml,更改其中的参数  
+将workspace改为您当前的绝对路径。（可用pwd命令获取绝对路径）  
+将dataset下sample_1的batch_size值从10改为128   
+将dataset下sample_1的data_path改为：{workspace}/data/train_big_data  
+将dataset下inferdata的batch_size值从10改为500 
+将dataset下inferdata的data_path改为：{workspace}/data/test_big_data 
+执行命令，开始训练：
 ```
-cd modles/contentunderstanding/tagspace
-python -m paddlerec.run -m ./config.yaml # 自定义修改超参后，指定配置文件，使用自定义配置
+python -m paddlerec.run -m ./config.yaml
 ```
 
 ### 预测
+在跑完训练后，模型会开始在验证集上预测。
+运行结果：
+```
+PaddleRec: Runner infer_runner Begin
+Executor Mode: infer
+processor_register begin
+Running SingleInstance.
+Running SingleNetwork.
+Running SingleInferStartup.
+Running SingleInferRunner.
+load persistables from increment/9
+batch: 1, acc: [0.91], loss: [0.02495437]
+batch: 2, acc: [0.936], loss: [0.01941476]
+batch: 3, acc: [0.918], loss: [0.02116447]
+batch: 4, acc: [0.916], loss: [0.0219945]
+batch: 5, acc: [0.902], loss: [0.02242816]
+batch: 6, acc: [0.9], loss: [0.02421589]
+batch: 7, acc: [0.9], loss: [0.026441]
+batch: 8, acc: [0.934], loss: [0.01797657]
+batch: 9, acc: [0.932], loss: [0.01687362]
+batch: 10, acc: [0.926], loss: [0.02047823]
+batch: 11, acc: [0.918], loss: [0.01998716]
+batch: 12, acc: [0.898], loss: [0.0229556]
+batch: 13, acc: [0.928], loss: [0.01736144]
+batch: 14, acc: [0.93], loss: [0.01911209]
 ```
-# 修改对应模型的config.yaml, workspace配置为当前目录的绝对路径
-# 修改对应模型的config.yaml，mode配置infer_runner
-# 示例: mode: train_runner -> mode: infer_runner
-# infer_runner中 class配置为 class: infer
-# 修改phase阶段为infer的配置，参照config注释
 
-# 修改完config.yaml后 执行:
-python -m paddlerec.run -m ./config.yaml
+**（2）Classification**
+
+### 数据处理
+情感倾向分析（Sentiment Classification，简称Senta）针对带有主观描述的中文文本，可自动判断该文本的情感极性类别并给出相应的置信度。情感类型分为积极、消极。情感倾向分析能够帮助企业理解用户消费习惯、分析热点话题和危机舆情监控，为企业提供有利的决策支持。  
+情感是人类的一种高级智能行为，为了识别文本的情感倾向，需要深入的语义建模。另外，不同领域（如餐饮、体育）在情感的表达各不相同，因而需要有大规模覆盖各个领域的数据进行模型训练。为此，我们通过基于深度学习的语义模型和大规模数据挖掘解决上述两个问题。效果上，我们基于开源情感倾向分类数据集ChnSentiCorp进行评测。  
+您可以直接执行以下命令下载我们分词完毕后的数据集,文件解压之后，senta_data目录下会存在训练数据（train.tsv）、开发集数据（dev.tsv）、测试集数据（test.tsv）以及对应的词典（word_dict.txt）：
+
+``` 
+wget https://baidu-nlp.bj.bcebos.com/sentiment_classification-dataset-1.0.0.tar.gz
+tar -zxvf sentiment_classification-dataset-1.0.0.tar.gz
 ```
 
-**（2）Classification**
+数据格式为一句中文的评价语句，和一个代表情感信息的标签。两者之间用/t分隔，中文的评价语句已经分词，词之间用空格分隔。  
 
-### 训练
 ```
-cd modles/contentunderstanding/classification
-python -m paddlerec.run -m ./config.yaml # 自定义修改超参后，指定配置文件，使用自定义配置
+15.4寸 笔记本 的 键盘 确实 爽 ， 基本 跟 台式机 差不多 了 ， 蛮 喜欢 数字 小 键盘 ， 输 数字 特 方便 ， 样子 也 很 美观 ， 做工 也 相当 不错    1
+跟 心灵 鸡汤 没 什么 本质 区别 嘛 ， 至少 我 不 喜欢 这样 读 经典 ， 把 经典 都 解读 成 这样 有点 去 中国 化 的 味道 了 0
+```
+本文提供了快速将数据集中的汉字数据处理为可训练格式数据的脚本，您在解压数据集后，将preprocess.py复制到senta_data文件中并执行，即可将数据集中提供的dev.tsv，test.tsv，train.tsv转化为可直接训练的dev.txt，test.txt，train.txt.
+```
+cp ./data/preprocess.py ./senta_data/
+cd senta_data/
+python preprocess.py
 ```
 
-### 预测
+### 训练
+创建存放训练集和测试集的目录，将数据放入目录中。
 ```
-# 修改对应模型的config.yaml, workspace配置为当前目录的绝对路径
-# 修改对应模型的config.yaml，mode配置infer_runner
-# 示例: mode: train_runner -> mode: infer_runner
-# infer_runner中 class配置为 class: infer
-# 修改phase阶段为infer的配置，参照config注释
+mkdir train
+mv train.txt train
+mkdir test
+mv dev.txt  test
+cd ..
+```  
+
+打开文件config.yaml,更改其中的参数  
+将workspace改为您当前的绝对路径。（可用pwd命令获取绝对路径）  
+将data1下的batch_size值从10改为128    
+将data1下的data_path改为：{workspace}/senta_data/train  
+将dataset_infer下的batch_size值从2改为256  
+将dataset_infer下的data_path改为：{workspace}/senta_data/test  
 
-# 修改完config.yaml后 执行:
+执行命令，开始训练：
+```
 python -m paddlerec.run -m ./config.yaml
 ```
 
+### 预测
+在跑完训练后，模型会开始在验证集上预测。
+运行结果：  
+
+```
+PaddleRec: Runner infer_runner Begin
+Executor Mode: infer
+processor_register begin
+Running SingleInstance.
+Running SingleNetwork.
+Running SingleInferStartup.
+Running SingleInferRunner.
+load persistables from increment/14
+batch: 1, acc: [0.91796875], loss: [0.2287855]
+batch: 2, acc: [0.91796875], loss: [0.22827303]
+batch: 3, acc: [0.90234375], loss: [0.27907994]
+```
+
+
 ## 效果对比
 ### 模型效果 (测试)
 
-|       数据集        |       模型       |       loss        |       auc          |       acc         |       mae          |
-| :------------------: | :--------------------: | :---------: |:---------: | :---------: |:---------: |
-|       ag news dataset        |       TagSpace       |       --        |       --          |       --          |       --          |
-|       --        |       Classification       |       --        |       --          |       --          |       --          |
+|       数据集        |       模型       |       loss         |       acc         |
+| :------------------: | :--------------------: | :---------: |:---------: | 
+|       ag news dataset        |       TagSpace       |       0.0198        |       0.9177          | 
+|       ChnSentiCorp        |       Classification       |       0.2282        |        0.9127         | 

models/contentunderstanding/tagspace/config.yaml

@@ -16,16 +16,21 @@ workspace: "models/contentunderstanding/tagspace"
 
 dataset:
 - name: sample_1
-  type: QueueDataset
-  batch_size: 5
+  type: DataLoader
+  batch_size: 10
   data_path: "{workspace}/data/train_data"
   data_converter: "{workspace}/reader.py"
+- name: inferdata
+  type: DataLoader
+  batch_size: 10
+  data_path: "{workspace}/data/test_data"
+  data_converter: "{workspace}/reader.py" 
 
 hyper_parameters:
   optimizer:
     class: Adagrad
     learning_rate: 0.001
-  vocab_text_size: 11447
+  vocab_text_size: 75378
   vocab_tag_size: 4
   emb_dim: 10
   hid_dim: 1000
@@ -34,22 +39,34 @@ hyper_parameters:
   neg_size: 3
   num_devices: 1
 
-mode: runner1
+mode: [runner1,infer_runner]
 
 runner:
 - name: runner1
   class: train
   epochs: 10
   device: cpu
-  save_checkpoint_interval: 2
-  save_inference_interval: 4
+  save_checkpoint_interval: 1
+  save_inference_interval: 1
   save_checkpoint_path: "increment"
   save_inference_path: "inference"
   save_inference_feed_varnames: []
   save_inference_fetch_varnames: []
+  phases: phase1
+- name: infer_runner
+  class: infer
+  # device to run training or infer
+  device: cpu
+  print_interval: 1
+  init_model_path: "increment/9" # load model path
+  phases: phase_infer
 
 phase:
 - name: phase1
   model: "{workspace}/model.py"
   dataset_name: sample_1
   thread_num: 1
+- name: phase_infer
+  model: "{workspace}/model.py"
+  dataset_name: inferdata
+  thread_num: 1

models/contentunderstanding/tagspace/data/text2paddle.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import six
+import collections
+import os
+import csv
+import re
+import sys
+if six.PY2:
+    reload(sys)
+    sys.setdefaultencoding('utf-8')
+
+
+def word_count(column_num, input_file, word_freq=None):
+    """
+    compute word count from corpus
+    """
+    if word_freq is None:
+        word_freq = collections.defaultdict(int)
+    data_file = csv.reader(input_file)
+    for row in data_file:
+        for w in re.split(r'\W+', row[column_num].strip()):
+            word_freq[w] += 1
+    return word_freq
+
+
+def build_dict(column_num=2, min_word_freq=0, train_dir="", test_dir=""):
+    """
+    Build a word dictionary from the corpus,  Keys of the dictionary are words,
+    and values are zero-based IDs of these words.
+    """
+    word_freq = collections.defaultdict(int)
+    files = os.listdir(train_dir)
+    for fi in files:
+        with open(os.path.join(train_dir, fi), "r", encoding='utf-8') as f:
+            word_freq = word_count(column_num, f, word_freq)
+    files = os.listdir(test_dir)
+    for fi in files:
+        with open(os.path.join(test_dir, fi), "r", encoding='utf-8') as f:
+            word_freq = word_count(column_num, f, word_freq)
+
+    word_freq = [x for x in six.iteritems(word_freq) if x[1] > min_word_freq]
+    word_freq_sorted = sorted(word_freq, key=lambda x: (-x[1], x[0]))
+    words, _ = list(zip(*word_freq_sorted))
+    word_idx = dict(list(zip(words, six.moves.range(len(words)))))
+    return word_idx
+
+
+def write_paddle(text_idx, tag_idx, train_dir, test_dir, output_train_dir,
+                 output_test_dir):
+    files = os.listdir(train_dir)
+    if not os.path.exists(output_train_dir):
+        os.mkdir(output_train_dir)
+    for fi in files:
+        with open(os.path.join(train_dir, fi), "r", encoding='utf-8') as f:
+            with open(
+                    os.path.join(output_train_dir, fi), "w",
+                    encoding='utf-8') as wf:
+                data_file = csv.reader(f)
+                for row in data_file:
+                    tag_raw = re.split(r'\W+', row[0].strip())
+                    pos_index = tag_idx.get(tag_raw[0])
+                    wf.write(str(pos_index) + ",")
+                    text_raw = re.split(r'\W+', row[2].strip())
+                    l = [text_idx.get(w) for w in text_raw]
+                    for w in l:
+                        wf.write(str(w) + " ")
+                    wf.write("\n")
+
+    files = os.listdir(test_dir)
+    if not os.path.exists(output_test_dir):
+        os.mkdir(output_test_dir)
+    for fi in files:
+        with open(os.path.join(test_dir, fi), "r", encoding='utf-8') as f:
+            with open(
+                    os.path.join(output_test_dir, fi), "w",
+                    encoding='utf-8') as wf:
+                data_file = csv.reader(f)
+                for row in data_file:
+                    tag_raw = re.split(r'\W+', row[0].strip())
+                    pos_index = tag_idx.get(tag_raw[0])
+                    wf.write(str(pos_index) + ",")
+                    text_raw = re.split(r'\W+', row[2].strip())
+                    l = [text_idx.get(w) for w in text_raw]
+                    for w in l:
+                        wf.write(str(w) + " ")
+                    wf.write("\n")
+
+
+def text2paddle(train_dir, test_dir, output_train_dir, output_test_dir,
+                output_vocab_text, output_vocab_tag):
+    print("start constuct word dict")
+    vocab_text = build_dict(2, 0, train_dir, test_dir)
+    with open(output_vocab_text, "w", encoding='utf-8') as wf:
+        wf.write(str(len(vocab_text)) + "\n")
+
+    vocab_tag = build_dict(0, 0, train_dir, test_dir)
+    with open(output_vocab_tag, "w", encoding='utf-8') as wf:
+        wf.write(str(len(vocab_tag)) + "\n")
+
+    print("construct word dict done\n")
+    write_paddle(vocab_text, vocab_tag, train_dir, test_dir, output_train_dir,
+                 output_test_dir)
+
+
+train_dir = sys.argv[1]
+test_dir = sys.argv[2]
+output_train_dir = sys.argv[3]
+output_test_dir = sys.argv[4]
+output_vocab_text = sys.argv[5]
+output_vocab_tag = sys.argv[6]
+text2paddle(train_dir, test_dir, output_train_dir, output_test_dir,
+            output_vocab_text, output_vocab_tag)

models/contentunderstanding/tagspace/model.py

@@ -16,7 +16,6 @@ import paddle.fluid as fluid
 import paddle.fluid.layers.nn as nn
 import paddle.fluid.layers.tensor as tensor
 import paddle.fluid.layers.control_flow as cf
-
 from paddlerec.core.model import ModelBase
 from paddlerec.core.utils import envs
 
@@ -98,14 +97,19 @@ class Model(ModelBase):
             tensor.fill_constant_batch_size_like(
                 input=loss_part2, shape=[-1, 1], value=0.0, dtype='float32'),
             loss_part2)
-        avg_cost = nn.mean(loss_part3)
+        avg_cost = fluid.layers.mean(loss_part3)
+
         less = tensor.cast(cf.less_than(cos_neg, cos_pos), dtype='float32')
+        label_ones = fluid.layers.fill_constant_batch_size_like(
+            input=cos_neg, dtype='float32', shape=[-1, 1], value=1.0)
         correct = nn.reduce_sum(less)
+        total = fluid.layers.reduce_sum(label_ones)
+        acc = fluid.layers.elementwise_div(correct, total)
         self._cost = avg_cost
 
         if is_infer:
-            self._infer_results["correct"] = correct
-            self._infer_results["cos_pos"] = cos_pos
+            self._infer_results["acc"] = acc
+            self._infer_results["loss"] = self._cost
         else:
-            self._metrics["correct"] = correct
-            self._metrics["cos_pos"] = cos_pos
+            self._metrics["acc"] = acc
+            self._metrics["loss"] = self._cost

models/contentunderstanding/tagspace/readme.md

+# tagspace文本分类模型
+
+以下是本例的简要目录结构及说明： 
+
+```
+├── data #样例数据
+    ├── train_data
+        ├── small_train.csv #训练数据样例
+    ├── test_data
+        ├── small_test.csv #测试数据样例
+    ├── text2paddle.py #数据处理程序
+├── __init__.py
+├── README.md #文档
+├── model.py #模型文件
+├── config.yaml #配置文件
+├── reader.py #读取程序
+```
+
+注：在阅读该示例前，建议您先了解以下内容：
+
+[paddlerec入门教程](https://github.com/PaddlePaddle/PaddleRec/blob/master/README.md)
+
+## 内容
+
+- [模型简介](#模型简介)
+- [数据准备](#数据准备)
+- [运行环境](#运行环境)
+- [快速开始](#快速开始)
+- [效果复现](#效果复现)
+- [进阶使用](#进阶使用)
+- [FAQ](#FAQ)
+
+
+## 模型简介
+tagspace模型是一种对文本打标签的方法，它主要学习从短文到相关主题标签的映射。论文中主要利用CNN做doc向量， 然后优化 f(w,t+),f(w,t-)的距离作为目标函数，得到了 t（标签）和doc在一个特征空间的向量表达，这样就可以找 doc的hashtags了。  
+
+论文[TAGSPACE: Semantic Embeddings from Hashtags](https://www.aclweb.org/anthology/D14-1194.pdf)中的网络结构如图所示，一层输入层，一个卷积层，一个pooling层以及最后一个全连接层进行降维。
+<p align="center">
+<img align="center" src="../../../doc/imgs/tagspace.png">
+<p>
+
+## 数据准备
+[数据地址](https://github.com/mhjabreel/CharCNN/tree/master/data/) , [备份数据地址](https://paddle-tagspace.bj.bcebos.com/data.tar)
+
+数据格式如下：  
+```
+"3","Wall St. Bears Claw Back Into the Black (Reuters)","Reuters - Short-sellers, Wall Street's dwindling\band of ultra-cynics, are seeing green again."
+```
+
+## 运行环境
+PaddlePaddle>=1.7.2  
+
+python 2.7/3.5/3.6/3.7  
+
+PaddleRec >=0.1  
+
+os : windows/linux/macos    
+
+
+## 快速开始
+本文提供了样例数据可以供您快速体验，在paddlerec目录下直接执行下面的命令即可启动训练： 
+
+```
+python -m paddlerec.run -m models/contentunderstanding/tagspace/config.yaml
+```   
+
+
+## 效果复现
+为了方便使用者能够快速的跑通每一个模型，我们在每个模型下都提供了样例数据。如果需要复现readme中的效果,请按如下步骤依次操作即可。  
+1. 确认您当前所在目录为PaddleRec/models/contentunderstanding/tagspace  
+2. 在data目录下载并解压数据集，命令如下：  
+``` 
+cd data
+wget https://paddle-tagspace.bj.bcebos.com/data.tar
+tar -xvf data.tar
+```
+3. 本文提供了快速将数据集中的汉字数据处理为可训练格式数据的脚本，您在解压数据集后，将原始数据存放在raw_big_train_data和raw_big_test_data两个目录下，并在python3环境下运行我们提供的text2paddle.py文件。即可生成可以直接用于训练的数据目录test_big_data和train_big_data。命令如下：
+```
+mkdir raw_big_train_data
+mkdir raw_big_test_data
+mv train.csv raw_big_train_data
+mv test.csv raw_big_test_data
+python3 text2paddle.py raw_big_train_data/ raw_big_test_data/ train_big_data test_big_data big_vocab_text.txt big_vocab_tag.txt
+```
+
+运行后的data目录：  
+
+```
+big_vocab_tag.txt  #标签词汇数
+big_vocab_text.txt #文本词汇数
+data.tar  #数据集
+raw_big_train_data  #数据集中原始的训练集
+raw_big_test_data  #数据集中原始的测试集
+train_data  #样例训练集
+test_data  #样例测试集
+train_big_data  #数据集经处理后的训练集
+test_big_data  #数据集经处理后的测试集
+text2paddle.py  #预处理文件
+```
+
+处理完成的数据格式如下：
+```
+2,27 7062 8390 456 407 8 11589 3166 4 7278 31046 33 3898 2897 426 1
+2,27 9493 836 355 20871 300 81 19 3 4125 9 449 462 13832 6 16570 1380 2874 5 0 797 236 19 3688 2106 14 8615 7 209 304 4 0 123 1
+2,27 12754 637 106 3839 1532 66 0 379 6 0 1246 9 307 33 161 2 8100 36 0 350 123 101 74 181 0 6657 4 0 1222 17195 1
+```
+
+4. 退回tagspace目录中，打开文件config.yaml,更改其中的参数  
+将workspace改为您当前的绝对路径。（可用pwd命令获取绝对路径）  
+将dataset下sample_1的batch_size值从10改为128   
+将dataset下sample_1的data_path改为：{workspace}/data/train_big_data  
+将dataset下inferdata的batch_size值从10改为500 
+将dataset下inferdata的data_path改为：{workspace}/data/test_big_data 
+
+5.  执行命令，开始训练：
+```
+python -m paddlerec.run -m ./config.yaml
+```
+6. 运行结果：
+```
+PaddleRec: Runner infer_runner Begin
+Executor Mode: infer
+processor_register begin
+Running SingleInstance.
+Running SingleNetwork.
+Running SingleInferStartup.
+Running SingleInferRunner.
+load persistables from increment/9
+batch: 1, acc: [0.91], loss: [0.02495437]
+batch: 2, acc: [0.936], loss: [0.01941476]
+batch: 3, acc: [0.918], loss: [0.02116447]
+batch: 4, acc: [0.916], loss: [0.0219945]
+batch: 5, acc: [0.902], loss: [0.02242816]
+batch: 6, acc: [0.9], loss: [0.02421589]
+batch: 7, acc: [0.9], loss: [0.026441]
+batch: 8, acc: [0.934], loss: [0.01797657]
+batch: 9, acc: [0.932], loss: [0.01687362]
+batch: 10, acc: [0.926], loss: [0.02047823]
+batch: 11, acc: [0.918], loss: [0.01998716]
+batch: 12, acc: [0.898], loss: [0.0229556]
+batch: 13, acc: [0.928], loss: [0.01736144]
+batch: 14, acc: [0.93], loss: [0.01911209]
+```
+
+## 进阶使用
+  
+## FAQ

models/match/dssm/config.yaml

@@ -17,50 +17,52 @@ workspace: "models/match/dssm"
 
 dataset:
 - name: dataset_train
-  batch_size: 4
-  type: QueueDataset
+  batch_size: 8
+  type: DataLoader # or QueueDataset
   data_path: "{workspace}/data/train" 
   data_converter: "{workspace}/synthetic_reader.py"
 - name: dataset_infer
   batch_size: 1
-  type: QueueDataset
-  data_path: "{workspace}/data/train"
+  type: DataLoader # or QueueDataset
+  data_path: "{workspace}/data/test"
   data_converter: "{workspace}/synthetic_evaluate_reader.py"
 
 hyper_parameters:
   optimizer:
     class: sgd
-    learning_rate: 0.01
+    learning_rate: 0.001
     strategy: async
-  trigram_d: 1000
-  neg_num: 4
+  trigram_d: 1439
+  neg_num: 1
   fc_sizes: [300, 300, 128]
   fc_acts: ['tanh', 'tanh', 'tanh']
 
-mode: train_runner
+mode: [train_runner,infer_runner]
 # config of each runner.
 # runner is a kind of paddle training class, which wraps the train/infer process.
 runner:
 - name: train_runner
   class: train
   # num of epochs
-  epochs: 4
+  epochs: 3
   # device to run training or infer
   device: cpu
-  save_checkpoint_interval: 2 # save model interval of epochs
-  save_inference_interval: 4 # save inference
+  save_checkpoint_interval: 1 # save model interval of epochs
+  save_inference_interval: 1 # save inference
   save_checkpoint_path: "increment" # save checkpoint path
   save_inference_path: "inference" # save inference path
   save_inference_feed_varnames: ["query", "doc_pos"] # feed vars of save inference
   save_inference_fetch_varnames: ["cos_sim_0.tmp_0"] # fetch vars of save inference
   init_model_path: "" # load model path
   print_interval: 2
+  phases: phase1
 - name: infer_runner
   class: infer
   # device to run training or infer
   device: cpu
   print_interval: 1
   init_model_path: "increment/2" # load model path
+  phases: phase2
 
 # runner will run all the phase in each epoch
 phase:
@@ -68,7 +70,7 @@ phase:
   model: "{workspace}/model.py" # user-defined model
   dataset_name: dataset_train # select dataset by name
   thread_num: 1
-#- name: phase2
-#  model: "{workspace}/model.py" # user-defined model
-#  dataset_name: dataset_infer # select dataset by name
-#  thread_num: 1
+- name: phase2
+  model: "{workspace}/model.py" # user-defined model
+  dataset_name: dataset_infer # select dataset by name
+  thread_num: 1

models/match/dssm/data/preprocess.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#encoding=utf-8
+
+import os
+import sys
+import numpy as np
+import random
+
+f = open("./zhidao", "r")
+lines = f.readlines()
+f.close()
+
+#建立字典
+word_dict = {}
+for line in lines:
+    line = line.strip().split("\t")
+    text = line[0].split(" ") + line[1].split(" ")
+    for word in text:
+        if word in word_dict:
+            continue
+        else:
+            word_dict[word] = len(word_dict) + 1
+
+f = open("./zhidao", "r")
+lines = f.readlines()
+f.close()
+
+lines = [line.strip().split("\t") for line in lines]
+
+#建立以query为key，以负例为value的字典
+neg_dict = {}
+for line in lines:
+    if line[2] == "0":
+        if line[0] in neg_dict:
+            neg_dict[line[0]].append(line[1])
+        else:
+            neg_dict[line[0]] = [line[1]]
+
+#建立以query为key，以正例为value的字典
+pos_dict = {}
+for line in lines:
+    if line[2] == "1":
+        if line[0] in pos_dict:
+            pos_dict[line[0]].append(line[1])
+        else:
+            pos_dict[line[0]] = [line[1]]
+
+#划分训练集和测试集
+query_list = list(pos_dict.keys())
+#print(len(query))
+random.shuffle(query_list)
+train_query = query_list[:90]
+test_query = query_list[90:]
+
+#获得训练集
+train_set = []
+for query in train_query:
+    for pos in pos_dict[query]:
+        if query not in neg_dict:
+            continue
+        for neg in neg_dict[query]:
+            train_set.append([query, pos, neg])
+random.shuffle(train_set)
+
+#获得测试集
+test_set = []
+for query in test_query:
+    for pos in pos_dict[query]:
+        test_set.append([query, pos, 1])
+    if query not in neg_dict:
+        continue
+    for neg in neg_dict[query]:
+        test_set.append([query, neg, 0])
+random.shuffle(test_set)
+
+#训练集中的query,pos,neg转化为词袋
+f = open("train.txt", "w")
+for line in train_set:
+    query = line[0].strip().split(" ")
+    pos = line[1].strip().split(" ")
+    neg = line[2].strip().split(" ")
+    query_token = [0] * (len(word_dict) + 1)
+    for word in query:
+        query_token[word_dict[word]] = 1
+    pos_token = [0] * (len(word_dict) + 1)
+    for word in pos:
+        pos_token[word_dict[word]] = 1
+    neg_token = [0] * (len(word_dict) + 1)
+    for word in neg:
+        neg_token[word_dict[word]] = 1
+    f.write(','.join([str(x) for x in query_token]) + "\t" + ','.join([
+        str(x) for x in pos_token
+    ]) + "\t" + ','.join([str(x) for x in neg_token]) + "\n")
+f.close()
+
+#测试集中的query和pos转化为词袋
+f = open("test.txt", "w")
+fa = open("label.txt", "w")
+for line in test_set:
+    query = line[0].strip().split(" ")
+    pos = line[1].strip().split(" ")
+    label = line[2]
+    query_token = [0] * (len(word_dict) + 1)
+    for word in query:
+        query_token[word_dict[word]] = 1
+    pos_token = [0] * (len(word_dict) + 1)
+    for word in pos:
+        pos_token[word_dict[word]] = 1
+    f.write(','.join([str(x) for x in query_token]) + "\t" + ','.join(
+        [str(x) for x in pos_token]) + "\n")
+    fa.write(str(label) + "\n")
+f.close()
+fa.close()

models/match/dssm/model.py

@@ -73,6 +73,7 @@ class Model(ModelBase):
 
         query_fc = fc(inputs[0], self.hidden_layers, self.hidden_acts,
                       ['query_l1', 'query_l2', 'query_l3'])
+
         doc_pos_fc = fc(inputs[1], self.hidden_layers, self.hidden_acts,
                         ['doc_pos_l1', 'doc_pos_l2', 'doc_pos_l3'])
         R_Q_D_p = fluid.layers.cos_sim(query_fc, doc_pos_fc)
@@ -93,7 +94,7 @@ class Model(ModelBase):
         prob = fluid.layers.softmax(concat_Rs, axis=1)
 
         hit_prob = fluid.layers.slice(
-            prob, axes=[0, 1], starts=[0, 0], ends=[4, 1])
+            prob, axes=[0, 1], starts=[0, 0], ends=[8, 1])
         loss = -fluid.layers.reduce_sum(fluid.layers.log(hit_prob))
         avg_cost = fluid.layers.mean(x=loss)
         self._cost = avg_cost

models/match/dssm/readme.md

+# DSSM文本匹配模型
+
+以下是本例的简要目录结构及说明： 
+
+```
+├── data #样例数据
+	├── train
+		├── train.txt #训练数据样例
+	├── test
+    	├── test.txt #测试数据样例
+	├── preprocess.py #数据处理程序
+├── __init__.py
+├── README.md #文档
+├── model.py #模型文件
+├── config.yaml #配置文件
+├── synthetic_reader.py #读取训练集的程序
+├── synthetic_evaluate_reader.py #读取测试集的程序
+├── transform.py #将数据整理成合适的格式方便计算指标
+├── run.sh #全量数据集中的训练脚本，从训练到预测并计算指标
+
+```
+
+注：在阅读该示例前，建议您先了解以下内容：
+
+[paddlerec入门教程](https://github.com/PaddlePaddle/PaddleRec/blob/master/README.md)
+
+## 内容
+
+- [模型简介](#模型简介)
+- [数据准备](#数据准备)
+- [运行环境](#运行环境)
+- [快速开始](#快速开始)
+- [效果复现](#效果复现)
+- [进阶使用](#进阶使用)
+- [FAQ](#FAQ)
+
+
+## 模型简介
+DSSM是Deep Structured Semantic Model的缩写，即我们通常说的基于深度网络的语义模型，其核心思想是将query和doc映射到到共同维度的语义空间中，通过最大化query和doc语义向量之间的余弦相似度，从而训练得到隐含语义模型，达到检索的目的。DSSM有很广泛的应用，比如：搜索引擎检索，广告相关性，问答系统，机器翻译等。    
+DSSM 的输入采用 BOW（Bag of words）的方式，相当于把字向量的位置信息抛弃了，整个句子里的词都放在一个袋子里了。将一个句子用这种方式转化为一个向量输入DNN中。  
+Query 和 Doc 的语义相似性可以用这两个向量的 cosine 距离表示，然后通过softmax 函数选出与Query语义最相似的样本 Doc 。  
+
+模型的具体细节可以阅读论文[DSSM](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/cikm2013_DSSM_fullversion.pdf):
+<p align="center">
+<img align="center" src="../../../doc/imgs/dssm.png">
+<p>
+
+## 数据准备
+我们公开了自建的测试集，包括百度知道、ECOM、QQSIM、UNICOM 四个数据集。这里我们选取百度知道数据集来进行训练。执行以下命令可以获取上述数据集。
+```
+wget --no-check-certificate https://baidu-nlp.bj.bcebos.com/simnet_dataset-1.0.0.tar.gz
+tar xzf simnet_dataset-1.0.0.tar.gz
+rm simnet_dataset-1.0.0.tar.gz
+```
+
+## 运行环境
+PaddlePaddle>=1.7.2
+
+python 2.7/3.5/3.6/3.7
+
+PaddleRec >=0.1
+
+os : windows/linux/macos
+
+## 快速开始
+本文提供了样例数据可以供您快速体验，在paddlerec目录下执行下面的命令即可快速启动训练： 
+
+```
+python -m paddlerec.run -m models/match/dssm/config.yaml
+```   
+
+输出结果示例：
+```
+PaddleRec: Runner train_runner Begin
+Executor Mode: train
+processor_register begin
+Running SingleInstance.
+Running SingleNetwork.
+file_list : ['models/match/dssm/data/train/train.txt']
+Running SingleStartup.
+Running SingleRunner.
+!!! The CPU_NUM is not specified, you should set CPU_NUM in the environment variable list.
+CPU_NUM indicates that how many CPUPlace are used in the current task.
+And if this parameter are set as N (equal to the number of physical CPU core) the program may be faster.
+export CPU_NUM=32 # for example, set CPU_NUM as number of physical CPU core which is 32.
+!!! The default number of CPU_NUM=1.
+I0821 06:56:26.224299 31061 parallel_executor.cc:440] The Program will be executed on CPU using ParallelExecutor, 1 cards are used, so 1 programs are executed in parallel.
+I0821 06:56:26.231163 31061 build_strategy.cc:365] SeqOnlyAllReduceOps:0, num_trainers:1
+I0821 06:56:26.237023 31061 parallel_executor.cc:307] Inplace strategy is enabled, when build_strategy.enable_inplace = True
+I0821 06:56:26.240788 31061 parallel_executor.cc:375] Garbage collection strategy is enabled, when FLAGS_eager_delete_tensor_gb = 0
+batch: 2, LOSS: [4.538238]
+batch: 4, LOSS: [4.16424]
+batch: 6, LOSS: [3.8121371]
+batch: 8, LOSS: [3.4250507]
+batch: 10, LOSS: [3.2285979]
+batch: 12, LOSS: [3.2116117]
+batch: 14, LOSS: [3.1406002]
+epoch 0 done, use time: 0.357971906662, global metrics: LOSS=[3.0968776]
+batch: 2, LOSS: [2.6843479]
+batch: 4, LOSS: [2.546976]
+batch: 6, LOSS: [2.4103594]
+batch: 8, LOSS: [2.301374]
+batch: 10, LOSS: [2.264183]
+batch: 12, LOSS: [2.315862]
+batch: 14, LOSS: [2.3409634]
+epoch 1 done, use time: 0.22123003006, global metrics: LOSS=[2.344321]
+batch: 2, LOSS: [2.0882485]
+batch: 4, LOSS: [2.006743]
+batch: 6, LOSS: [1.9231766]
+batch: 8, LOSS: [1.8850241]
+batch: 10, LOSS: [1.8829436]
+batch: 12, LOSS: [1.9336565]
+batch: 14, LOSS: [1.9784685]
+epoch 2 done, use time: 0.212922096252, global metrics: LOSS=[1.9934461]
+PaddleRec Finish
+```
+## 效果复现
+为了方便使用者能够快速的跑通每一个模型，我们在每个模型下都提供了样例数据。如果需要复现readme中的效果,请按如下步骤依次操作即可。  
+1. 确认您当前所在目录为PaddleRec/models/match/dssm
+2. 在data目录下载并解压数据集，命令如下：  
+``` 
+cd data
+wget --no-check-certificate https://baidu-nlp.bj.bcebos.com/simnet_dataset-1.0.0.tar.gz
+tar xzf simnet_dataset-1.0.0.tar.gz
+rm simnet_dataset-1.0.0.tar.gz
+```
+3. 本文提供了快速将数据集中的汉字数据处理为可训练格式数据的脚本，您在解压数据集后，可以看见目录中存在一个名为zhidao的文件。然后能可以在python3环境下运行我们提供的preprocess.py文件。即可生成可以直接用于训练的数据目录test.txt,train.txt和label.txt。将其放入train和test目录下以备训练时调用。命令如下：
+```
+mv data/zhidao ./
+rm -rf data
+python3 preprocess.py
+rm -f ./train/train.txt
+mv train.txt ./train
+rm -f ./test/test.txt
+mv test.txt test
+cd ..
+```
+经过预处理的格式：  
+训练集为三个稀疏的BOW方式的向量：query,pos,neg  
+测试集为两个稀疏的BOW方式的向量：query,pos  
+label.txt中对应的测试集中的标签
+
+4. 退回dssm目录中，打开文件config.yaml,更改其中的参数  
+
+将workspace改为您当前的绝对路径。（可用pwd命令获取绝对路径）  
+将dataset_train中的batch_size从8改为128
+将文件model.py中的 hit_prob = fluid.layers.slice(prob, axes=[0, 1], starts=[0, 0], ends=[8, 1])  
+    改为hit_prob = fluid.layers.slice(prob, axes=[0, 1], starts=[0, 0], ends=[128, 1]).当您需要改变batchsize的时候，end中第一个参数也需要随之变化
+
+5.  执行脚本，开始训练.脚本会运行python -m paddlerec.run -m ./config.yaml启动训练，并将结果输出到result文件中。然后启动transform.py整合数据，最后计算出正逆序指标：
+```
+sh run.sh
+```
+
+输出结果示例：
+```
+................run.................
+!!! The CPU_NUM is not specified, you should set CPU_NUM in the environment variable list.
+CPU_NUM indicates that how many CPUPlace are used in the current task.
+And if this parameter are set as N (equal to the number of physical CPU core) the program may be faster.
+
+export CPU_NUM=32 # for example, set CPU_NUM as number of physical CPU core which is 32.
+
+!!! The default number of CPU_NUM=1.
+I0821 07:16:04.512531 32200 parallel_executor.cc:440] The Program will be executed on CPU using ParallelExecutor, 1 cards are used, so 1 programs are executed in parallel.
+I0821 07:16:04.515708 32200 build_strategy.cc:365] SeqOnlyAllReduceOps:0, num_trainers:1
+I0821 07:16:04.518872 32200 parallel_executor.cc:307] Inplace strategy is enabled, when build_strategy.enable_inplace = True
+I0821 07:16:04.520995 32200 parallel_executor.cc:375] Garbage collection strategy is enabled, when FLAGS_eager_delete_tensor_gb = 0
+75
+pnr: 2.25581395349
+query_num: 11
+pair_num: 184 184
+equal_num: 44
+正序率： 0.692857142857
+97 43
+```
+6. 提醒：因为采取较小的数据集进行训练和测试，得到指标的浮动程度会比较大。如果得到的指标不合预期，可以多次执行步骤5，即可获得合理的指标。
+
+## 进阶使用
+  
+## FAQ

models/match/dssm/run.sh

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#!/bin/bash
+echo "................run................."
+python -m paddlerec.run -m ./config.yaml >result1.txt
+grep -i "query_doc_sim" ./result1.txt >./result2.txt
+sed '$d' result2.txt >result.txt
+rm -f result1.txt
+rm -f result2.txt
+python transform.py
+sort -t $'\t' -k1,1 -k 2nr,2 pair.txt >result.txt
+rm -f pair.txt
+python ../../../tools/cal_pos_neg.py result.txt

models/match/dssm/transform.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+import numpy as np
+import sklearn.metrics
+
+label = []
+filename = './data/label.txt'
+f = open(filename, "r")
+f.readline()
+num = 0
+for line in f.readlines():
+    num = num + 1
+    line = line.strip()
+    label.append(line)
+f.close()
+print(num)
+
+filename = './result.txt'
+sim = []
+for line in open(filename):
+    line = line.strip().split(",")
+    line[1] = line[1].split(":")
+    line = line[1][1].strip(" ")
+    line = line.strip("[")
+    line = line.strip("]")
+    sim.append(float(line))
+
+filename = './data/test/test.txt'
+f = open(filename, "r")
+f.readline()
+query = []
+for line in f.readlines():
+    line = line.strip().split("\t")
+    query.append(line[0])
+f.close()
+
+filename = 'pair.txt'
+f = open(filename, "w")
+for i in range(len(sim)):
+    f.write(str(query[i]) + "\t" + str(sim[i]) + "\t" + str(label[i]) + "\n")
+f.close()

models/match/match-pyramid/readme.md

 # match-pyramid文本匹配模型
 
-## 介绍
+以下是本例的简要目录结构及说明： 
+
+```
+├── data #样例数据
+    ├── process.py #数据处理脚本
+    ├── relation.test.fold1.txt #评估计算指标时用到的关系文件
+    ├── train
+    	├── train.txt #训练数据样例
+    ├── test
+    	├── test.txt #测试数据样例
+├── __init__.py
+├── README.md #文档
+├── model.py #模型文件
+├── config.yaml #配置文件
+├── data_process.sh #数据下载和处理脚本
+├── eval.py #计算指标的评估程序
+├── run.sh #一键运行程序
+├── test_reader.py #测试集读取程序
+├── train_reader.py #训练集读取程序
+```
+
+注：在阅读该示例前，建议您先了解以下内容：
+
+[paddlerec入门教程](https://github.com/PaddlePaddle/PaddleRec/blob/master/README.md)
+
+## 内容
+
+- [模型简介](#模型简介)
+- [数据准备](#数据准备)
+- [运行环境](#运行环境)
+- [快速开始](#快速开始)
+- [论文复现](#论文复现)
+- [进阶使用](#进阶使用)
+- [FAQ](#FAQ)
+
+
+## 模型简介
 在许多自然语言处理任务中，匹配两个文本是一个基本问题。一种有效的方法是从单词，短语和句子中提取有意义的匹配模式以产生匹配分数。受卷积神经网络在图像识别中的成功启发，神经元可以根据提取的基本视觉模式（例如定向的边角和边角）捕获许多复杂的模式，所以我们尝试将文本匹配建模为图像识别问题。本模型对齐原作者庞亮开源的tensorflow代码：https://github.com/pl8787/MatchPyramid-TensorFlow/blob/master/model/model_mp.py， 实现了下述论文中提出的Match-Pyramid模型：
 
 ```text
@@ -19,8 +55,23 @@
 3.关系文件：关系文件被用来存储两个句子之间的关系，如query 和document之间的关系。例如：relation.train.fold1.txt, relation.test.fold1.txt  
 4.嵌入层文件：我们将预训练的词向量存储在嵌入文件中。例如：embed_wiki-pdc_d50_norm  
 
-## 数据下载和预处理
-本文提供了数据集的下载以及一键生成训练和测试数据的预处理脚本，您可以直接一键运行:bash data_process.sh  
+## 运行环境
+PaddlePaddle>=1.7.2
+python 2.7/3.5/3.6/3.7
+PaddleRec >=0.1
+os : windows/linux/macos
+
+## 快速开始
+
+本文提供了样例数据可以供您快速体验，在paddlerec目录下直接执行下面的命令即可启动训练： 
+
+```
+python -m paddlerec.run -m models/match/match-pyramid/config.yaml
+```   
+
+## 论文复现
+1. 确认您当前所在目录为PaddleRec/models/match/match-pyramid
+2. 本文提供了原数据集的下载以及一键生成训练和测试数据的预处理脚本，您可以直接一键运行:bash data_process.sh  
 执行该脚本，会从国内源的服务器上下载Letor07数据集，删除掉data文件夹中原有的relation.test.fold1.txt和relation.train.fold1.txt，并将完整的数据集解压到data文件夹。随后运行 process.py 将全量训练数据放置于`./data/train`，全量测试数据放置于`./data/test`。并生成用于初始化embedding层的embedding.npy文件  
 执行该脚本的理想输出为：  
 ```
@@ -69,9 +120,11 @@ data/embed_wiki-pdc_d50_norm
 [./data/relation.test.fold1.txt]
         Instance size: 13652
 ```
+3. 打开文件config.yaml,更改其中的参数  
+
+将workspace改为您当前的绝对路径。（可用pwd命令获取绝对路径）
 
-## 一键训练并测试评估
-本文提供了一键执行训练，测试和评估的脚本，您可以直接一键运行：bash run.sh  
+4. 随后，您直接一键运行：bash run.sh  即可得到复现的论文效果
 执行该脚本后，会执行python -m paddlerec.run -m ./config.yaml 命令开始训练并测试模型，将测试的结果保存到result.txt文件，最后通过执行eval.py进行评估得到数据的map指标  
 执行该脚本的理想输出为：  
 ```
@@ -80,15 +133,6 @@ data/embed_wiki-pdc_d50_norm
 336
 ('map=', 0.420878322843591)
 ```  
+## 进阶使用
   
-## 每个文件的作用
-paddlerec可以：  
-通过config.yaml规定模型的参数  
-通过model.py规定模型的组网  
-使用train_reader.py读取训练集中的数据  
-使用test_reader.py读取测试集中的数据。  
-本文额外提供：  
-data_process.sh用来一键处理数据  
-run.sh用来一键启动训练，直接得出测试结果  
-eval.py通过保存的测试结果，计算map指标  
-如需详细了解paddlerec的使用方法请参考https://github.com/PaddlePaddle/PaddleRec/blob/master/README_CN.md 页面下方的教程。    
+## FAQ

models/match/match-pyramid/run.sh

 #!/bin/bash
 echo "................run................."
 python -m paddlerec.run -m ./config.yaml >result1.txt
-grep -A1 "prediction" ./result1.txt >./result.txt
+grep -i "prediction" ./result1.txt >./result.txt
 rm -f result1.txt
 python eval.py

models/match/readme.md

 # 匹配模型库
 
 ## 简介
-我们提供了常见的匹配任务中使用的模型算法的PaddleRec实现, 单机训练&预测效果指标以及分布式训练&预测性能指标等。实现的模型包括 [DSSM](http://gitlab.baidu.com/tangwei12/paddlerec/tree/develop/models/match/dssm)、[MultiView-Simnet](http://gitlab.baidu.com/tangwei12/paddlerec/tree/develop/models/match/multiview-simnet)。
+我们提供了常见的匹配任务中使用的模型算法的PaddleRec实现, 单机训练&预测效果指标以及分布式训练&预测性能指标等。实现的模型包括 [DSSM](http://gitlab.baidu.com/tangwei12/paddlerec/tree/develop/models/match/dssm)、[MultiView-Simnet](http://gitlab.baidu.com/tangwei12/paddlerec/tree/develop/models/match/multiview-simnet)、[match-pyramid](https://github.com/PaddlePaddle/PaddleRec/tree/master/models/match/match-pyramid)。
 
 模型算法库在持续添加中，欢迎关注。
 
@@ -18,6 +18,8 @@
 | :------------------: | :--------------------: | :---------: |
 | DSSM | Deep Structured Semantic Models | [CIKM 2013][Learning Deep Structured Semantic Models for Web Search using Clickthrough Data](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/cikm2013_DSSM_fullversion.pdf) |
 | MultiView-Simnet | Multi-view Simnet for Personalized recommendation | [WWW 2015][A Multi-View Deep Learning Approach for Cross Domain User Modeling in Recommendation Systems](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/frp1159-songA.pdf) |
+| match-pyramid | Text Matching as Image Recognition | [arXiv W2016][Text Matching as Image Recognition](https://arxiv.org/pdf/1602.06359.pdf) |
+
 
 下面是每个模型的简介（注：图片引用自链接中的论文）
 
@@ -31,24 +33,26 @@
 <img align="center" src="../../doc/imgs/multiview-simnet.png">
 <p>
 
-## 使用教程(快速开始)
-### 训练
-```shell
-git clone https://github.com/PaddlePaddle/PaddleRec.git paddle-rec
-cd paddle-rec
+[match-pyramid](https://arxiv.org/pdf/1602.06359.pdf):
+<p align="center">
+<img align="center" src="../../doc/imgs/match-pyramid.png">
+<p>
 
+## 使用教程(快速开始)
+### 训练&预测
+每个模型都提供了样例数据可以供您快速体验，在paddlerec目录下直接执行下面的命令即可启动训练：
+```
 python -m paddlerec.run -m models/match/dssm/config.yaml # dssm
 python -m paddlerec.run -m models/match/multiview-simnet/config.yaml # multiview-simnet
+python -m paddlerec.run -m models/contentunderstanding/match-pyramid/config.yaml #match-pyramid
 ```
+### 效果复现
+每个模型下的readme中都有详细的效果复现的教程，您可以进入模型的目录中详细查看  
 
-### 预测
-```shell
-# 修改对应模型的config.yaml, workspace配置为当前目录的绝对路径
-# 修改对应模型的config.yaml，mode配置infer_runner
-# 示例: mode: train_runner -> mode: infer_runner
-# infer_runner中 class配置为 class: infer
-# 修改phase阶段为infer的配置，参照config注释
+### 模型效果 (测试)
 
-# 修改完config.yaml后 执行:
-python -m paddlerec.run -m ./config.yaml # 以dssm为例
-```
+|       数据集        |       模型       |      正逆序比          |       map       |  
+| :------------------: | :--------------------: | :---------: |:---------: |
+|       zhidao       |       DSSM       |       2.25        |       --          | 
+|       Letor07        |       match-pyramid       |       --        |      0.42          | 
+|       zhidao        |       multiview-simnet       |       1.72        |       --          |

models/multitask/mmoe/README.md

@@ -34,19 +34,7 @@
 
 多任务模型通过学习不同任务的联系和差异，可提高每个任务的学习效率和质量。多任务学习的的框架广泛采用shared-bottom的结构，不同任务间共用底部的隐层。这种结构本质上可以减少过拟合的风险，但是效果上可能受到任务差异和数据分布带来的影响。  论文[《Modeling Task Relationships in Multi-task Learning with Multi-gate Mixture-of-Experts》]( https://www.kdd.org/kdd2018/accepted-papers/view/modeling-task-relationships-in-multi-task-learning-with-multi-gate-mixture- )中提出了一个Multi-gate Mixture-of-Experts(MMOE)的多任务学习结构。MMOE模型刻画了任务相关性，基于共享表示来学习特定任务的函数，避免了明显增加参数的缺点。 
 
-我们在Paddlepaddle定义MMOE的网络结构，在开源数据集Census-income Data上验证模型效果，两个任务的auc分别为：
-
-1.income
-
-> max_mmoe_test_auc_income：0.94937
->
-> mean_mmoe_test_auc_income：0.94465
-
-2.marital
-
-> max_mmoe_test_auc_marital：0.99419
->
-> mean_mmoe_test_auc_marital：0.99324
+我们在Paddlepaddle定义MMOE的网络结构，在开源数据集Census-income Data上验证模型效果。
 
 若进行精度验证，请参考[论文复现](https://github.com/PaddlePaddle/PaddleRec/tree/master/models/multitask/mmoe#论文复现)部分。
 
@@ -59,26 +47,6 @@
 
 数据地址： [Census-income Data](https://archive.ics.uci.edu/ml/machine-learning-databases/census-income-mld/census.tar.gz )
 
-数据解压后， 在run.sh脚本文件中添加文件的路径，并运行脚本。
-
-```sh
-mkdir train_data
-mkdir test_data
-mkdir data
-train_path="data/census-income.data"
-test_path="data/census-income.test"
-train_data_path="train_data/"
-test_data_path="test_data/"
-pip install -r requirements.txt
-wget -P data/ https://archive.ics.uci.edu/ml/machine-learning-databases/census-income-mld/census.tar.gz
-tar -zxvf data/census.tar.gz -C data/
-
-python data_preparation.py --train_path ${train_path} \
-                           --test_path ${test_path} \
-                           --train_data_path ${train_data_path}\
-                           --test_data_path ${test_data_path}
-
-```
 
 生成的格式以逗号为分割点
 
@@ -86,6 +54,7 @@ python data_preparation.py --train_path ${train_path} \
 0,0,73,0,0,0,0,1700.09,0,0
 ```
 
+完整的大数据参考论文复现部分。
 
 ## 运行环境
 
@@ -124,7 +93,6 @@ dataset:
 CPU环境
 
 在config.yaml文件中设置好epochs、device等参数。
-
 ```
 - name: infer_runner
   class: infer
@@ -134,14 +102,20 @@ CPU环境
 
 ## 论文复现
 
-用原论文的完整数据复现论文效果需要在config.yaml中修改batch_size=1000, thread_num=8, epoch_num=4
+数据下载，我们提供了在百度云上预处理好的数据，可以直接训练
 
-使用gpu p100 单卡训练 6.5h 测试auc: best:0.9940, mean:0.9932
+```
+wget https://paddlerec.bj.bcebos.com/mmoe/train_data.csv
+wget https://paddlerec.bj.bcebos.com/mmoe/test_data.csv
+wget https://paddlerec.bj.bcebos.com/mmoe/config_all.yaml
+```
+
+用原论文的完整数据复现论文效果需要在config.yaml中修改batch_size=32 gpu配置等，可参考config_all.yaml
 
-修改后运行方案：修改config.yaml中的'workspace'为config.yaml的目录位置，执行
+使用gpu p100 单卡训练 6.5h 测试auc: best:0.9940, mean:0.9932
 
 ```
-python -m paddlerec.run -m /home/your/dir/config.yaml #调试模式 直接指定本地config的绝对路径
+python -m paddlerec.run -m /home/your/dir/config_all.yaml #调试模式 直接指定本地config的绝对路径
 ```
 
 ## 进阶使用

models/multitask/mmoe/config.yaml

@@ -16,12 +16,12 @@ workspace: "models/multitask/mmoe"
 
 dataset:
 - name: dataset_train
-  batch_size: 1
+  batch_size: 5
   type: QueueDataset
   data_path: "{workspace}/data/train"
   data_converter: "{workspace}/census_reader.py"
 - name: dataset_infer
-  batch_size: 1
+  batch_size: 5
   type: QueueDataset
   data_path: "{workspace}/data/train"
   data_converter: "{workspace}/census_reader.py"
@@ -38,15 +38,14 @@ hyper_parameters:
     strategy: async
 
 #use infer_runner mode and modify 'phase' below if infer
-mode: train_runner
-#mode: infer_runner
+mode: [train_runner, infer_runner]
 
 runner:
 - name: train_runner
   class: train
   device: cpu
   epochs: 3
-  save_checkpoint_interval: 2
+  save_checkpoint_interval: 1
   save_inference_interval: 4
   save_checkpoint_path: "increment"
   save_inference_path: "inference"
@@ -61,7 +60,7 @@ phase:
   model: "{workspace}/model.py"
   dataset_name: dataset_train
   thread_num: 1
-    #- name: infer
-    #  model: "{workspace}/model.py"
-    #  dataset_name: dataset_infer
-    #  thread_num: 1
+- name: infer
+  model: "{workspace}/model.py"
+  dataset_name: dataset_infer
+  thread_num: 1

models/recall/word2vec/README.md

+# Skip-Gram W2V
+
+以下是本例的简要目录结构及说明： 
+
+```
+├── data #样例数据
+  ├── train
+    ├── convert_sample.txt
+  ├── test
+    ├── sample.txt
+  ├── dict
+    ├── word_count_dict.txt
+    ├── word_id_dict.txt
+├── preprocess.py # 数据预处理文件
+├── __init__.py
+├── README.md # 文档
+├── model.py #模型文件
+├── config.yaml #配置文件
+├── data_prepare.sh #一键数据处理脚本
+├── w2v_reader.py #训练数据reader
+├── w2v_evaluate_reader.py # 预测数据reader
+├── infer.py # 自定义预测脚本
+├── utils.py # 自定义预测中用到的reader等工具
+```
+
+注：在阅读该示例前，建议您先了解以下内容：
+
+[paddlerec入门教程](https://github.com/PaddlePaddle/PaddleRec/blob/master/README.md)
+
+
+---
+## 内容
+
+- [模型简介](#模型简介)
+- [数据准备](#数据准备)
+- [运行环境](#运行环境)
+- [快速开始](#快速开始)
+- [论文复现](#论文复现)
+- [进阶使用](#进阶使用)
+- [FAQ](#FAQ)
+
+## 模型简介
+本例实现了skip-gram模式的word2vector模型，如下图所示：
+<p align="center">
+<img align="center" src="../../../doc/imgs/word2vec.png">
+<p>
+以每一个词为中心词X，然后在窗口内和临近的词Y组成样本对（X,Y）用于网络训练。在实际训练过程中还会根据自定义的负采样率生成负样本来加强训练的效果  
+具体的训练思路如下：  
+<p align="center">
+<img align="center" src="../../../doc/imgs/w2v_train.png">
+<p>
+
+推荐用户参考[ IPython Notebook demo](https://aistudio.baidu.com/aistudio/projectDetail/124377)教程获取更详细的信息。
+
+本模型配置默认使用demo数据集，若进行精度验证，请参考[论文复现](#论文复现)部分。
+
+本项目支持功能
+
+训练：单机CPU、本地模拟参数服务器训练、增量训练，配置请参考 [启动训练](https://github.com/PaddlePaddle/PaddleRec/blob/master/doc/train.md)   
+
+预测：单机CPU；配置请参考[PaddleRec 离线预测](https://github.com/PaddlePaddle/PaddleRec/blob/master/doc/predict.md) 
+
+## 数据处理
+为和样例数据路径区分，全量训练数据、测试数据、词表文件会依次保存在data/all_train, data/all_test, data/all_dict文件夹中。
+```
+mkdir -p data/all_dict
+mkdir -p data/all_train
+mkdir -p data/all_test
+```
+本示例中全量数据处理共包含三步：
+- Step1: 数据下载。
+    ```
+    # 全量训练集
+    mkdir raw_data
+    wget --no-check-certificate https://paddlerec.bj.bcebos.com/word2vec/1-billion-word-language-modeling-benchmark-r13output.tar
+    tar xvf 1-billion-word-language-modeling-benchmark-r13output.tar
+    mv 1-billion-word-language-modeling-benchmark-r13output/training-monolingual.tokenized.shuffled/ raw_data/
+
+    # 测试集
+    wget --no-check-certificate https://paddlerec.bj.bcebos.com/word2vec/test_dir.tar
+    tar xzvf test_dir.tar -C raw_data
+    mv raw_data/data/test_dir/* data/all_test/
+    ```
+
+- Step2: 训练据预处理。包含三步，第一步，根据英文语料生成词典，中文语料可以通过修改text_strip方法自定义处理方法。
+    ```
+    python preprocess.py --build_dict --build_dict_corpus_dir raw_data/training-monolingual.tokenized.shuffled --dict_path raw_data/word_count_dict.txt
+    ```
+    得到的词典格式为词<空格>词频，低频词用'UNK'表示，如下所示：
+    ```
+    the 1061396
+    of 593677
+    and 416629
+    one 411764
+    in 372201
+    a 325873
+    <UNK> 324608
+    to 316376
+    zero 264975
+    nine 250430
+    ```
+    第二步，根据词典将文本转成id, 同时进行downsample，按照概率过滤常见词, 同时生成word和id映射的文件，文件名为词典+"word_to_id"。
+    ```
+    python preprocess.py --filter_corpus --dict_path raw_data/word_count_dict.txt --input_corpus_dir raw_data/training-monolingual.tokenized.shuffled --output_corpus_dir raw_data/convert_text8 --min_count 5 --downsample 0.001
+    ```
+    第三步，为更好地利用多线程进行训练加速，我们需要将训练文件分成多个子文件，默认拆分成1024个文件。
+    ```
+    python preprocess.py --data_resplit --input_corpus_dir=raw_data/convert_text8 --output_corpus_dir=data/all_train
+    ```
+- Step3: 路径整理。
+    ```
+    mv raw_data/word_count_dict.txt data/all_dict/
+    mv raw_data/word_count_dict.txt_word_to_id_ data/all_dict/word_id_dict.txt
+    rm -rf raw_data
+    ```
+方便起见， 我们提供了一键式数据处理脚本：
+```
+sh data_prepare.sh
+```
+
+## 运行环境
+
+PaddlePaddle>=1.7.2 
+
+python 2.7/3.5/3.6/3.7
+
+PaddleRec >=0.1
+
+os : windows/linux/macos
+
+## 快速开始
+
+### 单机训练
+
+CPU环境
+
+在config.yaml文件中设置好设备，epochs等。
+
+```
+# select runner by name
+mode: [single_cpu_train, single_cpu_infer]
+# config of each runner.
+# runner is a kind of paddle training class, which wraps the train/infer process.
+runner:
+- name: single_cpu_train
+  class: train
+  # num of epochs
+  epochs: 5
+  # device to run training or infer
+  device: cpu
+  save_checkpoint_interval: 1 # save model interval of epochs
+  save_inference_interval: 1 # save inference
+  save_checkpoint_path: "increment_w2v" # save checkpoint path
+  save_inference_path: "inference_w2v" # save inference path
+  save_inference_feed_varnames: [] # feed vars of save inference
+  save_inference_fetch_varnames: [] # fetch vars of save inference
+  init_model_path: "" # load model path
+  print_interval: 1
+  phases: [phase1]
+```
+### 单机预测
+我们通过词类比（Word Analogy）任务来检验word2vec模型的训练效果。输入四个词A，B，C，D，假设存在一种关系relation, 使得relation(A, B) = relation(C， D)，然后通过A，B，C去预测D，emb(D) = emb(B) - emb(A) + emb(C)。
+
+CPU环境
+
+PaddleRec预测配置：
+
+在config.yaml文件中设置好epochs、device等参数。
+
+```
+- name: single_cpu_infer
+  class: infer
+  # device to run training or infer
+  device: cpu
+  init_model_path: "increment_w2v" # load model path
+  print_interval: 1
+  phases: [phase2]
+```
+
+为复现论文效果，我们提供了一个自定义预测脚本，在自定义预测中，我们会跳过预测结果是输入A，B，C的情况，然后计算预测准确率。执行命令如下：
+```
+python infer.py --test_dir ./data/test --dict_path ./data/dict/word_id_dict.txt --batch_size 20000 --model_dir ./increment_w2v/  --start_index 0 --last_index 5 --emb_size 300
+```
+
+### 运行
+```
+python -m paddlerec.run -m paddlerec.models.recall.word2vec
+```
+
+### 结果展示
+
+样例数据训练结果展示：
+
+```
+Running SingleStartup.
+Running SingleRunner.
+W0813 11:36:16.129736 43843 build_strategy.cc:170] fusion_group is not enabled for Windows/MacOS now, and only effective when running with CUDA GPU.
+batch: 1, LOSS: [3.618 3.684 3.698 3.653 3.736]
+batch: 2, LOSS: [3.394 3.453 3.605 3.487 3.553]
+batch: 3, LOSS: [3.411 3.402 3.444 3.387 3.357]
+batch: 4, LOSS: [3.557 3.196 3.304 3.209 3.299]
+batch: 5, LOSS: [3.217 3.141 3.168 3.114 3.315]
+batch: 6, LOSS: [3.342 3.219 3.124 3.207 3.282]
+batch: 7, LOSS: [3.19  3.207 3.136 3.322 3.164]
+epoch 0 done, use time: 0.119026899338, global metrics: LOSS=[3.19  3.207 3.136 3.322 3.164]
+...
+epoch 4 done, use time: 0.097608089447, global metrics: LOSS=[2.734 2.66  2.763 2.804 2.809]
+```
+样例数据预测结果展示:
+```
+Running SingleInferStartup.
+Running SingleInferRunner.
+load persistables from increment_w2v/4
+batch: 1, acc: [1.]
+batch: 2, acc: [1.]
+batch: 3, acc: [1.]
+Infer phase2 of epoch 4 done, use time: 4.89376211166, global metrics: acc=[1.]
+...
+Infer phase2 of epoch 3 done, use time: 4.43099021912, global metrics: acc=[1.]
+```
+
+## 论文复现
+
+1. 用原论文的完整数据复现论文效果需要在config.yaml修改超参：
+- name: dataset_train 
+  batch_size: 100 # 1. 修改batch_size为100
+  type: DataLoader 
+  data_path: "{workspace}/data/all_train" # 2. 修改数据为全量训练数据
+  word_count_dict_path: "{workspace}/data/all_dict/ word_count_dict.txt"   # 3. 修改词表为全量词表
+  data_converter: "{workspace}/w2v_reader.py"
+
+- name: single_cpu_train
+  - epochs: # 4. 修改config.yaml中runner的epochs为5。
+
+修改后运行方案：修改config.yaml中的'workspace'为config.yaml的目录位置，执行
+```
+python -m paddlerec.run -m /home/your/dir/config.yaml #调试模式 直接指定本地config的绝对路径
+```
+
+2. 使用自定义预测程序预测全量测试集：
+```
+python infer.py --test_dir ./data/all_test --dict_path ./data/all_dict/word_id_dict.txt --batch_size 20000 --model_dir ./increment_w2v/  --start_index 0 --last_index 5 --emb_size 300
+```
+
+结论：使用cpu训练5轮，自定义预测准确率为0.540，每轮训练时间7小时左右。
+## 进阶使用
+
+## FAQ

models/recall/word2vec/config.yaml

@@ -22,7 +22,7 @@ dataset:
   word_count_dict_path: "{workspace}/data/dict/word_count_dict.txt"
   data_converter: "{workspace}/w2v_reader.py"
 - name: dataset_infer # name
-  batch_size: 50
+  batch_size: 2000
   type: DataLoader # or QueueDataset
   data_path: "{workspace}/data/test"
   word_id_dict_path: "{workspace}/data/dict/word_id_dict.txt"
@@ -42,38 +42,40 @@ hyper_parameters:
   window_size: 5
 
 # select runner by name
-mode: train_runner
+mode: [single_cpu_train, single_cpu_infer]
 # config of each runner.
 # runner is a kind of paddle training class, which wraps the train/infer process.
 runner:
-- name: train_runner
+- name: single_cpu_train
   class: train
   # num of epochs
-  epochs: 2
+  epochs: 5
   # device to run training or infer
   device: cpu
   save_checkpoint_interval: 1 # save model interval of epochs
   save_inference_interval: 1 # save inference
-  save_checkpoint_path: "increment" # save checkpoint path
-  save_inference_path: "inference" # save inference path
+  save_checkpoint_path: "increment_w2v" # save checkpoint path
+  save_inference_path: "inference_w2v" # save inference path
   save_inference_feed_varnames: [] # feed vars of save inference
   save_inference_fetch_varnames: [] # fetch vars of save inference
   init_model_path: "" # load model path
-  print_interval: 1
-- name: infer_runner
+  print_interval: 1000
+  phases: [phase1]
+- name: single_cpu_infer
   class: infer
   # device to run training or infer
   device: cpu
-  init_model_path: "increment/0" # load model path
+  init_model_path: "increment_w2v" # load model path
   print_interval: 1
+  phases: [phase2]
 
 # runner will run all the phase in each epoch
 phase:
 - name: phase1
   model: "{workspace}/model.py" # user-defined model
   dataset_name: dataset_train # select dataset by name
+  thread_num: 5
+- name: phase2
+  model: "{workspace}/model.py" # user-defined model
+  dataset_name: dataset_infer # select dataset by name
   thread_num: 1
-# - name: phase2
-#   model: "{workspace}/model.py" # user-defined model
-#   dataset_name: dataset_infer # select dataset by name
-#   thread_num: 1

models/recall/word2vec/data_prepare.sh

@@ -14,6 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+mkdir -p data/all_dict
+mkdir -p data/all_train
+mkdir -p data/all_test
 
 # download train_data
 mkdir raw_data
@@ -21,18 +24,16 @@ wget --no-check-certificate https://paddlerec.bj.bcebos.com/word2vec/1-billion-w
 tar xvf 1-billion-word-language-modeling-benchmark-r13output.tar
 mv 1-billion-word-language-modeling-benchmark-r13output/training-monolingual.tokenized.shuffled/ raw_data/
 
+# download test data
+wget --no-check-certificate https://paddlerec.bj.bcebos.com/word2vec/test_dir.tar
+tar xzvf test_dir.tar -C raw_data
+mv raw_data/data/test_dir/* data/all_test/
+
 # preprocess data
 python preprocess.py --build_dict --build_dict_corpus_dir raw_data/training-monolingual.tokenized.shuffled --dict_path raw_data/word_count_dict.txt
 python preprocess.py --filter_corpus --dict_path raw_data/word_count_dict.txt --input_corpus_dir raw_data/training-monolingual.tokenized.shuffled --output_corpus_dir raw_data/convert_text8 --min_count 5 --downsample 0.001
-mv raw_data/word_count_dict.txt data/dict/
-mv raw_data/word_id_dict.txt data/dict/
+python preprocess.py --data_resplit --input_corpus_dir=raw_data/convert_text8 --output_corpus_dir=data/all_train
 
-rm -rf data/train/*
-rm -rf data/test/*
-python preprocess.py --data_resplit --input_corpus_dir=raw_data/convert_text8 --output_corpus_dir=data/train
-
-# download test data
-wget --no-check-certificate https://paddlerec.bj.bcebos.com/word2vec/test_dir.tar
-tar xzvf test_dir.tar -C raw_data
-mv raw_data/data/test_dir/* data/test/
+mv raw_data/word_count_dict.txt data/all_dict/
+mv raw_data/word_count_dict.txt_word_to_id_ data/all_dict/word_id_dict.txt
 rm -rf raw_data

models/recall/word2vec/infer.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import sys
+import time
+import math
+import numpy as np
+import six
+import paddle.fluid as fluid
+import paddle
+import utils
+if six.PY2:
+    reload(sys)
+    sys.setdefaultencoding('utf-8')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("PaddlePaddle Word2vec infer example")
+    parser.add_argument(
+        '--dict_path',
+        type=str,
+        default='./data/data_c/1-billion_dict_word_to_id_',
+        help="The path of dic")
+    parser.add_argument(
+        '--test_dir', type=str, default='test_data', help='test file address')
+    parser.add_argument(
+        '--print_step', type=int, default='500000', help='print step')
+    parser.add_argument(
+        '--start_index', type=int, default='0', help='start index')
+    parser.add_argument(
+        '--last_index', type=int, default='100', help='last index')
+    parser.add_argument(
+        '--model_dir', type=str, default='model', help='model dir')
+    parser.add_argument(
+        '--use_cuda', type=int, default='0', help='whether use cuda')
+    parser.add_argument(
+        '--batch_size', type=int, default='5', help='batch_size')
+    parser.add_argument(
+        '--emb_size', type=int, default='64', help='batch_size')
+    args = parser.parse_args()
+    return args
+
+
+def infer_network(vocab_size, emb_size):
+    analogy_a = fluid.data(name="analogy_a", shape=[None], dtype='int64')
+    analogy_b = fluid.data(name="analogy_b", shape=[None], dtype='int64')
+    analogy_c = fluid.data(name="analogy_c", shape=[None], dtype='int64')
+    all_label = fluid.data(name="all_label", shape=[vocab_size], dtype='int64')
+    emb_all_label = fluid.embedding(
+        input=all_label, size=[vocab_size, emb_size], param_attr="emb")
+
+    emb_a = fluid.embedding(
+        input=analogy_a, size=[vocab_size, emb_size], param_attr="emb")
+    emb_b = fluid.embedding(
+        input=analogy_b, size=[vocab_size, emb_size], param_attr="emb")
+    emb_c = fluid.embedding(
+        input=analogy_c, size=[vocab_size, emb_size], param_attr="emb")
+    target = fluid.layers.elementwise_add(
+        fluid.layers.elementwise_sub(emb_b, emb_a), emb_c)
+    emb_all_label_l2 = fluid.layers.l2_normalize(x=emb_all_label, axis=1)
+    dist = fluid.layers.matmul(x=target, y=emb_all_label_l2, transpose_y=True)
+    values, pred_idx = fluid.layers.topk(input=dist, k=4)
+    return values, pred_idx
+
+
+def infer_epoch(args, vocab_size, test_reader, use_cuda, i2w):
+    """ inference function """
+    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    emb_size = args.emb_size
+    batch_size = args.batch_size
+    with fluid.scope_guard(fluid.Scope()):
+        main_program = fluid.Program()
+        with fluid.program_guard(main_program):
+            values, pred = infer_network(vocab_size, emb_size)
+            for epoch in range(start_index, last_index + 1):
+                copy_program = main_program.clone()
+                model_path = model_dir + "/" + str(epoch)
+                fluid.io.load_persistables(
+                    exe, model_path, main_program=copy_program)
+                accum_num = 0
+                accum_num_sum = 0.0
+                t0 = time.time()
+                step_id = 0
+                for data in test_reader():
+                    step_id += 1
+                    b_size = len([dat[0] for dat in data])
+                    wa = np.array([dat[0] for dat in data]).astype(
+                        "int64").reshape(b_size)
+                    wb = np.array([dat[1] for dat in data]).astype(
+                        "int64").reshape(b_size)
+                    wc = np.array([dat[2] for dat in data]).astype(
+                        "int64").reshape(b_size)
+
+                    label = [dat[3] for dat in data]
+                    input_word = [dat[4] for dat in data]
+                    para = exe.run(copy_program,
+                                   feed={
+                                       "analogy_a": wa,
+                                       "analogy_b": wb,
+                                       "analogy_c": wc,
+                                       "all_label": np.arange(vocab_size)
+                                       .reshape(vocab_size).astype("int64"),
+                                   },
+                                   fetch_list=[pred.name, values],
+                                   return_numpy=False)
+                    pre = np.array(para[0])
+                    val = np.array(para[1])
+                    for ii in range(len(label)):
+                        top4 = pre[ii]
+                        accum_num_sum += 1
+                        for idx in top4:
+                            if int(idx) in input_word[ii]:
+                                continue
+                            if int(idx) == int(label[ii][0]):
+                                accum_num += 1
+                            break
+                    if step_id % 1 == 0:
+                        print("step:%d %d " % (step_id, accum_num))
+
+                print("epoch:%d \t acc:%.3f " %
+                      (epoch, 1.0 * accum_num / accum_num_sum))
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    start_index = args.start_index
+    last_index = args.last_index
+    test_dir = args.test_dir
+    model_dir = args.model_dir
+    batch_size = args.batch_size
+    dict_path = args.dict_path
+    use_cuda = True if args.use_cuda else False
+    print("start index: ", start_index, " last_index:", last_index)
+    vocab_size, test_reader, id2word = utils.prepare_data(
+        test_dir, dict_path, batch_size=batch_size)
+    print("vocab_size:", vocab_size)
+    infer_epoch(
+        args,
+        vocab_size,
+        test_reader=test_reader,
+        use_cuda=use_cuda,
+        i2w=id2word)

models/recall/word2vec/model.py

@@ -209,10 +209,10 @@ class Model(ModelBase):
         emb_all_label_l2 = fluid.layers.l2_normalize(x=emb_all_label, axis=1)
         dist = fluid.layers.matmul(
             x=target, y=emb_all_label_l2, transpose_y=True)
-        values, pred_idx = fluid.layers.topk(input=dist, k=4)
+        values, pred_idx = fluid.layers.topk(input=dist, k=1)
         label = fluid.layers.expand(
             fluid.layers.unsqueeze(
-                inputs[3], axes=[1]), expand_times=[1, 4])
+                inputs[3], axes=[1]), expand_times=[1, 1])
         label_ones = fluid.layers.fill_constant_batch_size_like(
             label, shape=[-1, 1], value=1.0, dtype='float32')
         right_cnt = fluid.layers.reduce_sum(input=fluid.layers.cast(

models/recall/word2vec/preprocess.py

@@ -228,7 +228,7 @@ def data_split(args):
             contents.extend(f.readlines())
 
     num = int(args.file_nums)
-    lines_per_file = len(contents) / num
+    lines_per_file = int(math.ceil(len(contents) / float(num)))
     print("contents: ", str(len(contents)))
     print("lines_per_file: ", str(lines_per_file))
 

models/recall/word2vec/utils.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import collections
+import six
+import time
+import numpy as np
+import paddle.fluid as fluid
+import paddle
+import os
+import preprocess
+import io
+
+
+def BuildWord_IdMap(dict_path):
+    word_to_id = dict()
+    id_to_word = dict()
+    with io.open(dict_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            word_to_id[line.split(' ')[0]] = int(line.split(' ')[1])
+            id_to_word[int(line.split(' ')[1])] = line.split(' ')[0]
+    return word_to_id, id_to_word
+
+
+def prepare_data(file_dir, dict_path, batch_size):
+    w2i, i2w = BuildWord_IdMap(dict_path)
+    vocab_size = len(i2w)
+    reader = fluid.io.batch(test(file_dir, w2i), batch_size)
+    return vocab_size, reader, i2w
+
+
+def check_version(with_shuffle_batch=False):
+    """
+     Log error and exit when the installed version of paddlepaddle is
+     not satisfied.
+     """
+    err = "PaddlePaddle version 1.6 or higher is required, " \
+          "or a suitable develop version is satisfied as well. \n" \
+          "Please make sure the version is good with your code." \
+
+    try:
+        if with_shuffle_batch:
+            fluid.require_version('1.7.0')
+        else:
+            fluid.require_version('1.6.0')
+    except Exception as e:
+        logger.error(err)
+        sys.exit(1)
+
+
+def native_to_unicode(s):
+    if _is_unicode(s):
+        return s
+    try:
+        return _to_unicode(s)
+    except UnicodeDecodeError:
+        res = _to_unicode(s, ignore_errors=True)
+        return res
+
+
+def _is_unicode(s):
+    if six.PY2:
+        if isinstance(s, unicode):
+            return True
+    else:
+        if isinstance(s, str):
+            return True
+    return False
+
+
+def _to_unicode(s, ignore_errors=False):
+    if _is_unicode(s):
+        return s
+    error_mode = "ignore" if ignore_errors else "strict"
+    return s.decode("utf-8", errors=error_mode)
+
+
+def strip_lines(line, vocab):
+    return _replace_oov(vocab, native_to_unicode(line))
+
+
+def _replace_oov(original_vocab, line):
+    """Replace out-of-vocab words with "<UNK>".
+  This maintains compatibility with published results.
+  Args:
+    original_vocab: a set of strings (The standard vocabulary for the dataset)
+    line: a unicode string - a space-delimited sequence of words.
+  Returns:
+    a unicode string - a space-delimited sequence of words.
+  """
+    return u" ".join([
+        word if word in original_vocab else u"<UNK>" for word in line.split()
+    ])
+
+
+def reader_creator(file_dir, word_to_id):
+    def reader():
+        files = os.listdir(file_dir)
+        for fi in files:
+            with io.open(
+                    os.path.join(file_dir, fi), "r", encoding='utf-8') as f:
+                for line in f:
+                    if ':' in line:
+                        pass
+                    else:
+                        line = strip_lines(line.lower(), word_to_id)
+                        line = line.split()
+                        yield [word_to_id[line[0]]], [word_to_id[line[1]]], [
+                            word_to_id[line[2]]
+                        ], [word_to_id[line[3]]], [
+                            word_to_id[line[0]], word_to_id[line[1]],
+                            word_to_id[line[2]]
+                        ]
+
+    return reader
+
+
+def test(test_dir, w2i):
+    return reader_creator(test_dir, w2i)

models/recall/word2vec/w2v_evaluate_reader.py

@@ -76,7 +76,7 @@ class Reader(ReaderBase):
     def generate_sample(self, line):
         def reader():
             if ':' in line:
-                pass
+                return
             features = self.strip_lines(line.lower(), self.word_to_id)
             features = features.split()
             yield [('analogy_a', [self.word_to_id[features[0]]]),

models/recall/word2vec/w2v_reader.py

@@ -15,6 +15,7 @@
 import io
 
 import numpy as np
+import paddle.fluid as fluid
 
 from paddlerec.core.reader import ReaderBase
 from paddlerec.core.utils import envs
@@ -47,6 +48,10 @@ class Reader(ReaderBase):
         self.with_shuffle_batch = envs.get_global_env(
             "hyper_parameters.with_shuffle_batch")
         self.random_generator = NumpyRandomInt(1, self.window_size + 1)
+        self.batch_size = envs.get_global_env(
+            "dataset.dataset_train.batch_size")
+        self.is_dataloader = envs.get_global_env(
+            "dataset.dataset_train.type") == "DataLoader"
 
         self.cs = None
         if not self.with_shuffle_batch:
@@ -88,7 +93,9 @@ class Reader(ReaderBase):
                 for context_id in context_word_ids:
                     output = [('input_word', [int(target_id)]),
                               ('true_label', [int(context_id)])]
-                    if not self.with_shuffle_batch:
+                    if self.with_shuffle_batch or self.is_dataloader:
+                        yield output
+                    else:
                         neg_array = self.cs.searchsorted(
                             np.random.sample(self.neg_num))
                         output += [('neg_label',
@@ -96,3 +103,36 @@ class Reader(ReaderBase):
                         yield output
 
         return reader
+
+    def batch_tensor_creator(self, sample_reader):
+        def __reader__():
+            result = [[], []]
+            for sample in sample_reader():
+                for i, fea in enumerate(sample):
+                    result[i].append(fea)
+                if len(result[0]) == self.batch_size:
+                    tensor_result = []
+                    for tensor in result:
+                        t = fluid.Tensor()
+                        dat = np.array(tensor, dtype='int64')
+                        if len(dat.shape) > 2:
+                            dat = dat.reshape((dat.shape[0], dat.shape[2]))
+                        elif len(dat.shape) == 1:
+                            dat = dat.reshape((-1, 1))
+                        t.set(dat, fluid.CPUPlace())
+                        tensor_result.append(t)
+                    if self.with_shuffle_batch:
+                        yield tensor_result
+                    else:
+                        tt = fluid.Tensor()
+                        neg_array = self.cs.searchsorted(
+                            np.random.sample(self.neg_num))
+                        neg_array = np.tile(neg_array, self.batch_size)
+                        tt.set(
+                            neg_array.reshape((self.batch_size, self.neg_num)),
+                            fluid.CPUPlace())
+                        tensor_result.append(tt)
+                        yield tensor_result
+                    result = [[], []]
+
+        return __reader__

models/recall/youtube_dnn/README.md

+# Youtebe-DNN
+
+以下是本例的简要目录结构及说明： 
+
+```
+├── data #样例数据
+	├── train
+		├── data.txt
+    ├── test
+		├── data.txt
+├── generate_ramdom_data # 随机训练数据生成文件
+├── __init__.py
+├── README.md # 文档
+├── model.py #模型文件
+├── config.yaml #配置文件
+├── data_prepare.sh #一键数据处理脚本
+├── reader.py #reader
+├── infer.py # 预测程序
+```
+
+注：在阅读该示例前，建议您先了解以下内容：
+
+[paddlerec入门教程](https://github.com/PaddlePaddle/PaddleRec/blob/master/README.md)
+
+
+---
+## 内容
+
+- [模型简介](#模型简介)
+- [数据准备](#数据准备)
+- [运行环境](#运行环境)
+- [快速开始](#快速开始)
+- [论文复现](#论文复现)
+- [进阶使用](#进阶使用)
+- [FAQ](#FAQ)
+
+## 模型简介
+[《Deep Neural Networks for YouTube Recommendations》](https://link.zhihu.com/?target=https%3A//static.googleusercontent.com/media/research.google.com/zh-CN//pubs/archive/45530.pdf) 这篇论文是google的YouTube团队在推荐系统上DNN方面的尝试，是经典的向量化召回模型，主要通过模型来学习用户和物品的兴趣向量，并通过内积来计算用户和物品之间的相似性，从而得到最终的候选集。YouTube采取了两层深度网络完成整个推荐过程：
+
+1.第一层是**Candidate Generation Model**完成候选视频的快速筛选，这一步候选视频集合由百万降低到了百的量级。
+
+2.第二层是用**Ranking Model**完成几百个候选视频的精排。
+
+本项目在paddlepaddle上完成YouTube dnn的召回部分Candidate Generation Model，分别获得用户和物品的向量表示，从而后续可以通过其他方法（如用户和物品的余弦相似度）给用户推荐物品。
+
+由于原论文没有开源数据集，本项目随机构造数据验证网络的正确性。
+
+本项目支持功能
+
+训练：单机CPU、单机单卡GPU、本地模拟参数服务器训练、增量训练，配置请参考 [启动训练](https://github.com/PaddlePaddle/PaddleRec/blob/master/doc/train.md)   
+
+预测：单机CPU、单机单卡GPU；配置请参考[PaddleRec 离线预测](https://github.com/PaddlePaddle/PaddleRec/blob/master/doc/predict.md) 
+
+## 数据处理
+调用python generate_ramdom_data.py生成随机训练数据，每行数据格式如下：
+```
+#watch_vec;search_vec;other_feat;label
+0.01,0.02,...,0.09;0.01,0.02,...,0.09;0.01,0.02,...,0.09;20
+```
+方便起见，我们提供了一键式数据生成脚本：
+```
+sh data_prepare.sh
+```
+
+## 运行环境
+
+PaddlePaddle>=1.7.2 
+
+python 2.7/3.5/3.6/3.7
+
+PaddleRec >=0.1
+
+os : windows/linux/macos
+
+## 快速开始
+
+### 单机训练
+
+```
+mode: [cpu_single_train]
+
+runner:
+- name: cpu_single_train
+  class: train
+  device: cpu   # if use_gpu, set it to gpu
+  epochs: 20
+  save_checkpoint_interval: 1
+  save_inference_interval: 1
+  save_checkpoint_path: "increment_youtubednn"
+  save_inference_path: "inference_youtubednn"
+  save_inference_feed_varnames: ["watch_vec", "search_vec", "other_feat"] # feed vars of save inference
+  save_inference_fetch_varnames: ["l3.tmp_2"]
+  print_interval: 1
+```
+
+### 单机预测
+通过计算每个用户和每个物品的余弦相似度，给每个用户推荐topk视频：
+
+cpu infer:
+```
+python infer.py --test_epoch 19 --inference_model_dir ./inference_youtubednn --increment_model_dir ./increment_youtubednn --watch_vec_size 64 --search_vec_size 64 --other_feat_size 64 --topk 5
+```
+
+gpu infer:
+```
+python infer.py --use_gpu 1 --test_epoch 19 --inference_model_dir ./inference_youtubednn --increment_model_dir ./increment_youtubednn --watch_vec_size 64 --search_vec_size 64 --other_feat_size 64 --topk 5
+```
+### 运行
+```
+python -m paddlerec.run -m paddlerec.models.recall.w2v
+```
+
+### 结果展示
+
+样例数据训练结果展示：
+
+```
+Running SingleStartup.
+Running SingleRunner.
+batch: 1, acc: [0.03125]
+batch: 2, acc: [0.0625]
+batch: 3, acc: [0.]
+...
+epoch 0 done, use time: 0.0605320930481, global metrics: acc=[0.]
+...
+epoch 19 done, use time: 0.33447098732, global metrics: acc=[0.]
+```
+
+样例数据预测结果展示:
+```
+user:0, top K videos:[40, 31, 4, 33, 93]
+user:1, top K videos:[35, 57, 58, 40, 17]
+user:2, top K videos:[35, 17, 88, 40, 9]
+user:3, top K videos:[73, 35, 39, 58, 38]
+user:4, top K videos:[40, 31, 57, 4, 73]
+user:5, top K videos:[38, 9, 7, 88, 22]
+user:6, top K videos:[35, 73, 14, 58, 28]
+user:7, top K videos:[35, 73, 58, 38, 56]
+user:8, top K videos:[38, 40, 9, 35, 99]
+user:9, top K videos:[88, 73, 9, 35, 28]
+user:10, top K videos:[35, 52, 28, 54, 73]
+```
+
+## 进阶使用
+
+## FAQ

models/recall/youtube_dnn/config.yaml

@@ -17,11 +17,10 @@ workspace: "models/recall/youtube_dnn"
 
 dataset:
 - name: dataset_train
-  batch_size: 5
-  type: DataLoader
-  #type: QueueDataset
+  batch_size: 32
+  type: DataLoader # or QueueDataset
   data_path: "{workspace}/data/train"
-  data_converter: "{workspace}/random_reader.py"
+  data_converter: "{workspace}/reader.py"
 
 hyper_parameters:
   watch_vec_size: 64
@@ -30,22 +29,23 @@ hyper_parameters:
   output_size: 100
   layers: [128, 64, 32]
   optimizer: 
-    class: adam
-    learning_rate: 0.001
-    strategy: async
+    class: SGD
+    learning_rate: 0.01
 
-mode: train_runner
+mode: [cpu_single_train]
 
 runner:
-- name: train_runner
+- name: cpu_single_train
   class: train
   device: cpu
-  epochs: 3
-  save_checkpoint_interval: 2
-  save_inference_interval: 4
-  save_checkpoint_path: "increment"
-  save_inference_path: "inference"
-  print_interval: 10
+  epochs: 20
+  save_checkpoint_interval: 1
+  save_inference_interval: 1
+  save_checkpoint_path: "increment_youtubednn"
+  save_inference_path: "inference_youtubednn"
+  save_inference_feed_varnames: ["watch_vec", "search_vec", "other_feat"] # feed vars of save inference
+  save_inference_fetch_varnames: ["l3.tmp_2"]
+  print_interval: 1
 
 phase:
 - name: train

models/recall/youtube_dnn/data/test/small_data.txt

-4764,174,1
-4764,2958,0
-4764,452,0
-4764,1946,0
-4764,3208,0
-2044,2237,1
-2044,1998,0
-2044,328,0
-2044,1542,0
-2044,1932,0
-4276,65,1
-4276,3247,0
-4276,942,0
-4276,3666,0
-4276,2222,0
-3933,682,1
-3933,2451,0
-3933,3695,0
-3933,1643,0
-3933,3568,0
-1151,1265,1
-1151,118,0
-1151,2532,0
-1151,2083,0
-1151,2350,0
-1757,876,1
-1757,201,0
-1757,3633,0
-1757,1068,0
-1757,2549,0
-3370,276,1
-3370,2435,0
-3370,606,0
-3370,910,0
-3370,2146,0
-5137,1018,1
-5137,2163,0
-5137,3167,0
-5137,2315,0
-5137,3595,0
-3933,2831,1
-3933,2881,0
-3933,2949,0
-3933,3660,0
-3933,417,0
-3102,999,1
-3102,1902,0
-3102,2161,0
-3102,3042,0
-3102,1113,0
-2022,336,1
-2022,1672,0
-2022,2656,0
-2022,3649,0
-2022,883,0
-2664,655,1
-2664,3660,0
-2664,1711,0
-2664,3386,0
-2664,1668,0
-25,701,1
-25,32,0
-25,2482,0
-25,3177,0
-25,2767,0
-1738,1643,1
-1738,2187,0
-1738,228,0
-1738,650,0
-1738,3101,0
-5411,1241,1
-5411,2546,0
-5411,3019,0
-5411,3618,0
-5411,1674,0
-638,579,1
-638,3512,0
-638,783,0
-638,2111,0
-638,1880,0
-3554,200,1
-3554,2893,0
-3554,2428,0
-3554,969,0
-3554,2741,0
-4283,1074,1
-4283,3056,0
-4283,2032,0
-4283,405,0
-4283,1505,0
-5111,200,1
-5111,3488,0
-5111,477,0
-5111,2790,0
-5111,40,0
-3964,515,1
-3964,1528,0
-3964,2173,0
-3964,1701,0
-3964,2832,0

models/recall/youtube_dnn/data/train/samll_data.txt

-4764,174,1
-4764,2958,0
-4764,452,0
-4764,1946,0
-4764,3208,0
-2044,2237,1
-2044,1998,0
-2044,328,0
-2044,1542,0
-2044,1932,0
-4276,65,1
-4276,3247,0
-4276,942,0
-4276,3666,0
-4276,2222,0
-3933,682,1
-3933,2451,0
-3933,3695,0
-3933,1643,0
-3933,3568,0
-1151,1265,1
-1151,118,0
-1151,2532,0
-1151,2083,0
-1151,2350,0
-1757,876,1
-1757,201,0
-1757,3633,0
-1757,1068,0
-1757,2549,0
-3370,276,1
-3370,2435,0
-3370,606,0
-3370,910,0
-3370,2146,0
-5137,1018,1
-5137,2163,0
-5137,3167,0
-5137,2315,0
-5137,3595,0
-3933,2831,1
-3933,2881,0
-3933,2949,0
-3933,3660,0
-3933,417,0
-3102,999,1
-3102,1902,0
-3102,2161,0
-3102,3042,0
-3102,1113,0
-2022,336,1
-2022,1672,0
-2022,2656,0
-2022,3649,0
-2022,883,0
-2664,655,1
-2664,3660,0
-2664,1711,0
-2664,3386,0
-2664,1668,0
-25,701,1
-25,32,0
-25,2482,0
-25,3177,0
-25,2767,0
-1738,1643,1
-1738,2187,0
-1738,228,0
-1738,650,0
-1738,3101,0
-5411,1241,1
-5411,2546,0
-5411,3019,0
-5411,3618,0
-5411,1674,0
-638,579,1
-638,3512,0
-638,783,0
-638,2111,0
-638,1880,0
-3554,200,1
-3554,2893,0
-3554,2428,0
-3554,969,0
-3554,2741,0
-4283,1074,1
-4283,3056,0
-4283,2032,0
-4283,405,0
-4283,1505,0
-5111,200,1
-5111,3488,0
-5111,477,0
-5111,2790,0
-5111,40,0
-3964,515,1
-3964,1528,0
-3964,2173,0
-3964,1701,0
-3964,2832,0

models/recall/youtube_dnn/data_prepare.sh

+python generate_ramdom_data.py

models/recall/youtube_dnn/generate_ramdom_data.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import numpy as np
+
+# Build a random data set.
+sample_size = 100
+batch_size = 32
+watch_vec_size = 64
+search_vec_size = 64
+other_feat_size = 64
+output_size = 100
+
+watch_vecs = np.random.rand(batch_size * sample_size, watch_vec_size).tolist()
+search_vecs = np.random.rand(batch_size * sample_size,
+                             search_vec_size).tolist()
+other_vecs = np.random.rand(batch_size * sample_size, other_feat_size).tolist()
+labels = np.random.randint(
+    output_size, size=(batch_size * sample_size)).tolist()
+
+output_path = "./data/train/data.txt"
+with open(output_path, 'w') as fout:
+    for i in range(batch_size * sample_size):
+        _str_ = ','.join(map(str, watch_vecs[i])) + ";" + ','.join(
+            map(str, search_vecs[i])) + ";" + ','.join(
+                map(str, other_vecs[i])) + ";" + str(labels[i])
+        fout.write(_str_)
+        fout.write("\n")

models/recall/youtube_dnn/infer.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import copy
+import numpy as np
+import argparse
+import paddle.fluid as fluid
+import pandas as pd
+from paddle.fluid.incubate.fleet.utils import utils
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("PaddlePaddle Youtube DNN infer example")
+    parser.add_argument(
+        '--use_gpu', type=int, default='0', help='whether use gpu')
+    parser.add_argument(
+        "--batch_size", type=int, default=32, help="batch_size")
+    parser.add_argument(
+        "--test_epoch", type=int, default=19, help="test_epoch")
+    parser.add_argument(
+        '--inference_model_dir',
+        type=str,
+        default='./inference_youtubednn',
+        help='inference_model_dir')
+    parser.add_argument(
+        '--increment_model_dir',
+        type=str,
+        default='./increment_youtubednn',
+        help='persistable_model_dir')
+    parser.add_argument(
+        '--watch_vec_size', type=int, default=64, help='watch_vec_size')
+    parser.add_argument(
+        '--search_vec_size', type=int, default=64, help='search_vec_size')
+    parser.add_argument(
+        '--other_feat_size', type=int, default=64, help='other_feat_size')
+    parser.add_argument('--topk', type=int, default=5, help='topk')
+    args = parser.parse_args()
+    return args
+
+
+def infer(args):
+    video_save_path = os.path.join(args.increment_model_dir,
+                                   str(args.test_epoch), "l4_weight")
+    video_vec, = utils.load_var("l4_weight", [32, 100], 'float32',
+                                video_save_path)
+
+    place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    cur_model_path = os.path.join(args.inference_model_dir,
+                                  str(args.test_epoch))
+
+    user_vec = None
+    with fluid.scope_guard(fluid.Scope()):
+        infer_program, feed_target_names, fetch_vars = fluid.io.load_inference_model(
+            cur_model_path, exe)
+        # Build a random data set.
+        sample_size = 100
+        watch_vecs = []
+        search_vecs = []
+        other_feats = []
+
+        for i in range(sample_size):
+            watch_vec = np.random.rand(1, args.watch_vec_size)
+            search_vec = np.random.rand(1, args.search_vec_size)
+            other_feat = np.random.rand(1, args.other_feat_size)
+            watch_vecs.append(watch_vec)
+            search_vecs.append(search_vec)
+            other_feats.append(other_feat)
+
+        for i in range(sample_size):
+            l3 = exe.run(infer_program,
+                         feed={
+                             "watch_vec": watch_vecs[i].astype('float32'),
+                             "search_vec": search_vecs[i].astype('float32'),
+                             "other_feat": other_feats[i].astype('float32'),
+                         },
+                         return_numpy=True,
+                         fetch_list=fetch_vars)
+            if user_vec is not None:
+                user_vec = np.concatenate([user_vec, l3[0]], axis=0)
+            else:
+                user_vec = l3[0]
+
+    # get topk result
+    user_video_sim_list = []
+    for i in range(user_vec.shape[0]):
+        for j in range(video_vec.shape[1]):
+            user_video_sim = cos_sim(user_vec[i], video_vec[:, j])
+            user_video_sim_list.append(user_video_sim)
+
+        tmp_list = copy.deepcopy(user_video_sim_list)
+        tmp_list.sort()
+        max_sim_index = [
+            user_video_sim_list.index(one)
+            for one in tmp_list[::-1][:args.topk]
+        ]
+
+        print("user:{0}, top K videos:{1}".format(i, max_sim_index))
+        user_video_sim_list = []
+
+
+def cos_sim(vector_a, vector_b):
+    vector_a = np.mat(vector_a)
+    vector_b = np.mat(vector_b)
+    num = float(vector_a * vector_b.T)
+    denom = np.linalg.norm(vector_a) * np.linalg.norm(vector_b)
+    cos = num / (denom + 1e-4)
+    sim = 0.5 + 0.5 * cos
+    return sim
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    infer(args)

models/recall/youtube_dnn/random_reader.py → models/recall/youtube_dnn/reader.py

@@ -39,13 +39,17 @@ class Reader(ReaderBase):
             """
             This function needs to be implemented by the user, based on data format
             """
-
+            features = line.rstrip().split(";")
+            watch_vec = features[0].split(',')
+            search_vec = features[1].split(',')
+            other_feat = features[2].split(',')
+            label = features[3]
+            assert (len(watch_vec) == self.watch_vec_size)
+            assert (len(search_vec) == self.search_vec_size)
+            assert (len(other_feat) == self.other_feat_size)
             feature_name = ["watch_vec", "search_vec", "other_feat", "label"]
             yield list(
-                zip(feature_name, [
-                    np.random.rand(self.watch_vec_size).tolist()
-                ] + [np.random.rand(self.search_vec_size).tolist()] + [
-                    np.random.rand(self.other_feat_size).tolist()
-                ] + [[np.random.randint(self.output_size)]]))
+                zip(feature_name, [watch_vec] + [search_vec] + [other_feat] +
+                    [label]))
 
         return reader

tools/cal_pos_neg.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#!/usr/bin/python  
+#-*- coding:utf-8 -*-  
+############################  
+#File Name: cal_pos_neg.py
+#Author: youqiheng 
+#Mail: youqiheng@baidu.com
+#Created Time: 2018-04-15 21:59:45
+############################ 
+"""
+docstring
+"""
+
+import os
+import sys
+
+if len(sys.argv) < 2:
+    print "usage:python %s input" % (sys.argv[0])
+    sys.exit(-1)
+
+fin = file(sys.argv[1])
+pos_num = 0
+neg_num = 0
+
+score_list = []
+label_list = []
+last_query = "-1"
+
+#0       12.786960       1
+#0       -1.480890       0
+cnt = 0
+query_num = 0
+pair_num = 0
+equal_num = 0
+for line in fin:
+    cols = line.strip().split("\t")
+    cnt += 1
+    if cnt % 500000 == 0:
+        print "cnt:", cnt, 1.0 * pos_num / neg_num
+    if len(cols) != 3:
+        continue
+
+    cur_query = cols[0]
+    if cur_query != last_query:
+        query_num += 1
+        for i in xrange(0, len(score_list)):
+            for j in xrange(i + 1, len(score_list)):
+                if label_list[i] == label_list[j]:
+                    continue
+                pair_num += 1
+                if (score_list[i] - score_list[j]) * (
+                        label_list[i] - label_list[j]) < 0:
+                    neg_num += 1
+                elif (score_list[i] - score_list[j]) * (
+                        label_list[i] - label_list[j]) > 0:
+                    pos_num += 1
+                else:
+                    equal_num += 1
+        score_list = []
+        label_list = []
+
+    last_query = cur_query
+
+    label = int(cols[2])
+
+    score_list.append(round(float(cols[1]), 6))
+    label_list.append(int(cols[2]))
+
+fin.close()
+
+for i in xrange(0, len(score_list)):
+    for j in xrange(i + 1, len(score_list)):
+        if label_list[i] == label_list[j]:
+            continue
+        pair_num += 1
+        if (score_list[i] - score_list[j]) * (label_list[i] - label_list[j]
+                                              ) < 0:
+            neg_num += 1
+        elif (score_list[i] - score_list[j]) * (label_list[i] - label_list[j]
+                                                ) > 0:
+            pos_num += 1
+        else:
+            equal_num += 1
+
+if neg_num > 0:
+    print "pnr:", 1.0 * pos_num / neg_num
+    print "query_num:", query_num
+    print "pair_num:", pos_num + neg_num + equal_num, pair_num
+    print "equal_num:", equal_num
+    print "正序率：", 1.0 * pos_num / (pos_num + neg_num)
+print pos_num, neg_num