Skip to content

M
models

PaddlePaddle / models
接近 2 年 前同步成功

通知 230
Star 6828
Fork 2962
M
models
“b9fdd3bc0f4f22af17a81bb8a50a337b563c876b”上不存在“paddle/phi/kernels/selected_rows/isfinite_kernel.h”
提交 bcc236e7 编写于 作者: Y Yibing Liu
浏览文件
操作

Merge branch 'develop' of upstream into ctc_decoder_deploy

上级 8c5576d9 f8be148f
展开全部 隐藏空白更改
内联 并排
Showing with 1942 addition and 599 deletion
.clang_format.hook
浏览文件 @ bcc236e7
#!/bin/bash #!/usr/bin/env bash
set -e
# clang-format hook without version check readonly VERSION="3.8"
version=$(clang-format -version)
if ! [[ $version == *"$VERSION"* ]]; then
echo "clang-format version check failed."
echo "a version contains '$VERSION' is needed, but get '$version'"
echo "you can install the right version, and make an soft-link to '\$PATH' env"
exit -1
fi
clang-format $@ clang-format $@
ctr/README.md
浏览文件 @ bcc236e7
# 点击率预估 # Click-Through Rate Prediction
以下是本例目录包含的文件以及对应说明: ## Introduction
``` CTR(Click-Through Rate)\[[1](https://en.wikipedia.org/wiki/Click-through_rate)\]
├── README.md # 本教程markdown 文档 is a prediction of the probability that a user clicks on an advertisement. This model is widely used in the advertisement industry. Accurate click rate estimates are important for maximizing online advertising revenue.
├── dataset.md # 数据集处理教程
├── images # 本教程图片目录
│   ├── lr_vs_dnn.jpg
│   └── wide_deep.png
├── infer.py # 预测脚本
├── network_conf.py # 模型网络配置
├── reader.py # data reader
├── train.py # 训练脚本
└── utils.py # helper functions
└── avazu_data_processer.py # 示例数据预处理脚本
```
## 背景介绍
CTR(Click-Through Rate，点击率预估)\[[1](https://en.wikipedia.org/wiki/Click-through_rate)\]
是对用户点击一个特定链接的概率做出预测，是广告投放过程中的一个重要环节。精准的点击率预估对在线广告系统收益最大化具有重要意义。
当有多个广告位时，CTR 预估一般会作为排序的基准，比如在搜索引擎的广告系统里，当用户输入一个带商业价值的搜索词（query）时，系统大体上会执行下列步骤来展示广告： When there are multiple ad slots, CTR estimates are generally used as a baseline for ranking. For example, in a search engine's ad system, when the user enters a query, the system typically performs the following steps to show relevant ads.
1. 获取与用户搜索词相关的广告集合 1. Get the ad collection associated with the user's search term.
2. 业务规则和相关性过滤 2. Business rules and relevance filtering.
3. 根据拍卖机制和 CTR 排序 3. Rank by auction mechanism and CTR.
4. 展出广告 4. Show ads.
可以看到，CTR 在最终排序中起到了很重要的作用。 Here，CTR plays a crucial role.
### 发展阶段 ### Brief history
在业内，CTR 模型经历了如下的发展阶段： Historically, the CTR prediction model has been evolving as follows.
- Logistic Regression(LR) / GBDT + 特征工程 - Logistic Regression(LR) / Gradient Boosting Decision Trees (GBDT) + feature engineering
- LR + DNN 特征 - LR + Deep Neural Network (DNN)
- DNN + 特征工程 - DNN + feature engineering
在发展早期时 LR 一统天下，但最近 DNN 模型由于其强大的学习能力和逐渐成熟的性能优化， In the early stages of development LR dominated, but the recent years DNN based models are mainly used.
逐渐地接过 CTR 预估任务的大旗。
### LR vs DNN ### LR vs DNN
下图展示了 LR 和一个 \(3x2\) 的 DNN 模型的结构： The following figure shows the structure of LR and DNN model:
<p align="center"> <p align="center">
<img src="images/lr_vs_dnn.jpg" width="620" hspace='10'/> <br/> <img src="images/lr_vs_dnn.jpg" width="620" hspace='10'/> <br/>
Figure 1. LR 和 DNN 模型结构对比 Figure 1. LR and DNN model structure comparison
</p> </p>
LR 的蓝色箭头部分可以直接类比到 DNN 中对应的结构，可以看到 LR 和 DNN 有一些共通之处（比如权重累加）， We can see, LR and CNN have some common structures. However, DNN can have non-linear relation between input and output values by adding activation unit and further layers. This enables DNN to achieve better learning results in CTR estimates.
但前者的模型复杂度在相同输入维度下比后者可能低很多（从某方面讲，模型越复杂，越有潜力学习到更复杂的信息）；
如果 LR 要达到匹敌 DNN 的学习能力，必须增加输入的维度，也就是增加特征的数量，
这也就是为何 LR 和大规模的特征工程必须绑定在一起的原因。
LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括内存和计算量等方面，工业界都有非常成熟的优化方法； In the following, we demonstrate how to use PaddlePaddle to learn to predict CTR.
而 DNN 模型具有自己学习新特征的能力，一定程度上能够提升特征使用的效率，
这使得 DNN 模型在同样规模特征的情况下，更有可能达到更好的学习效果。
本文后面的章节会演示如何使用 PaddlePaddle 编写一个结合两者优点的模型。 ## Data and Model formation
Here `click` is the learning objective. There are several ways to learn the objectives.
## 数据和任务抽象 1. Direct learning click, 0,1 for binary classification
2. Learning to rank, pairwise rank or listwise rank
3. Measure the ad click rate of each ad, then rank by the click rate.
我们可以将 `click` 作为学习目标，任务可以有以下几种方案： In this example, we use the first method.
1. 直接学习 click，0,1 作二元分类 We use the Kaggle `Click-through rate prediction` task \[[2](https://www.kaggle.com/c/avazu-ctr-prediction/data)\].
2. Learning to rank, 具体用 pairwise rank（标签 1>0）或者 listwise rank
3. 统计每个广告的点击率，将同一个 query 下的广告两两组合，点击率高的>点击率低的，做 rank 或者分类
我们直接使用第一种方法做分类任务。 Please see the [data process](./dataset.md) for pre-processing data.
我们使用 Kaggle 上 `Click-through rate prediction` 任务的数据集\[[2](https://www.kaggle.com/c/avazu-ctr-prediction/data)\] 来演示本例中的模型。 The input data format for the demo model in this tutorial is as follows:
具体的特征处理方法参看 [data process](./dataset.md)。
本教程中演示模型的输入格式如下：
``` ```
# <dnn input ids> \t <lr input sparse values> \t click # <dnn input ids> \t <lr input sparse values> \t click
...@@ -84,10 +59,10 @@ LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括 ...@@ -84,10 +59,10 @@ LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括
23 231 \t 1230:0.12 13421:0.9 \t 1 23 231 \t 1230:0.12 13421:0.9 \t 1
``` ```
详细的格式描述如下： Description：
- `dnn input ids` 采用 one-hot 表示，只需要填写值为1的ID（注意这里不是变长输入） - `dnn input ids` one-hot coding.
- `lr input sparse values` 使用了 `ID:VALUE` 的表示，值部分最好规约到值域 `[-1, 1]`。 - `lr input sparse values` Use `ID:VALUE` , values are preferaly scaled to the range `[-1, 1]`。
此外，模型训练时需要传入一个文件描述 dnn 和 lr两个子模型的输入维度，文件的格式如下： 此外，模型训练时需要传入一个文件描述 dnn 和 lr两个子模型的输入维度，文件的格式如下：
...@@ -96,9 +71,9 @@ dnn_input_dim: <int> ...@@ -96,9 +71,9 @@ dnn_input_dim: <int>
lr_input_dim: <int> lr_input_dim: <int>
``` ```
其中， `<int>` 表示一个整型数值。 <int> represents an integer value.
本目录下的 `avazu_data_processor.py` 可以对下载的演示数据集\[[2](#参考文档)\] 进行处理，具体使用方法参考如下说明： `avazu_data_processor.py` can be used to download the data set \[[2](#参考文档)\]and pre-process the data.
``` ```
usage: avazu_data_processer.py [-h] --data_path DATA_PATH --output_dir usage: avazu_data_processer.py [-h] --data_path DATA_PATH --output_dir
...@@ -123,40 +98,38 @@ optional arguments: ...@@ -123,40 +98,38 @@ optional arguments:
size of the trainset (default: 100000) size of the trainset (default: 100000)
``` ```
- `data_path` 是待处理的数据路径 - `data_path` The data path to be processed
- `output_dir` 生成数据的输出路径 - `output_dir` The output path of the data
- `num_lines_to_detect` 预先扫描数据生成ID的个数，这里是扫描的文件行数 - `num_lines_to_detect` The number of generated IDs
- `test_set_size` 生成测试集的行数 - `test_set_size` The number of rows for the test set
- `train_size` 生成训练姐的行数 - `train_size` The number of rows of training set
## Wide & Deep Learning Model ## Wide & Deep Learning Model
谷歌在 16 年提出了 Wide & Deep Learning 的模型框架，用于融合适合学习抽象特征的 DNN 和 适用于大规模稀疏特征的 LR 两种模型的优点。 Google proposed a model framework for Wide & Deep Learning to integrate the advantages of both DNNs suitable for learning abstract features and LR models for large sparse features.
### 模型简介 ### Introduction to the model
Wide & Deep Learning Model\[[3](#参考文献)\] 可以作为一种相对成熟的模型框架使用， Wide & Deep Learning Model\[[3](#References)\] is a relatively mature model, but this model is still being used in the CTR predicting task. Here we demonstrate the use of this model to complete the CTR predicting task.
在 CTR 预估的任务中工业界也有一定的应用，因此本文将演示使用此模型来完成 CTR 预估的任务。
模型结构如下： The model structure is as follows:
<p align="center"> <p align="center">
<img src="images/wide_deep.png" width="820" hspace='10'/> <br/> <img src="images/wide_deep.png" width="820" hspace='10'/> <br/>
Figure 2. Wide & Deep Model Figure 2. Wide & Deep Model
</p> </p>
模型左边的 Wide 部分，可以容纳大规模系数特征，并且对一些特定的信息（比如 ID）有一定的记忆能力； The wide part of the left side of the model can accommodate large-scale coefficient features and has some memory for some specific information (such as ID); and the Deep part of the right side of the model can learn the implicit relationship between features.
而模型右边的 Deep 部分，能够学习特征间的隐含关系，在相同数量的特征下有更好的学习和推导能力。
### 编写模型输入 ### Model Input
模型只接受 3 个输入，分别是 The model has three inputs as follows.
- `dnn_input` ，也就是 Deep 部分的输入 - `dnn_input` ，the Deep part of the input
- `lr_input` ，也就是 Wide 部分的输入 - `lr_input` ，the wide part of the input
- `click` ， 点击与否，作为二分类模型学习的标签 - `click` ， click on or not
```python ```python
dnn_merged_input = layer.data( dnn_merged_input = layer.data(
...@@ -170,9 +143,9 @@ lr_merged_input = layer.data( ...@@ -170,9 +143,9 @@ lr_merged_input = layer.data(
click = paddle.layer.data(name='click', type=dtype.dense_vector(1)) click = paddle.layer.data(name='click', type=dtype.dense_vector(1))
``` ```
### 编写 Wide 部分 ### Wide part
Wide 部分直接使用了 LR 模型，但激活函数改成了 `RELU` 来加速 Wide part uses of the LR model, but the activation function changed to `RELU` for speed.
```python ```python
def build_lr_submodel(): def build_lr_submodel():
...@@ -181,9 +154,9 @@ def build_lr_submodel(): ...@@ -181,9 +154,9 @@ def build_lr_submodel():
return fc return fc
``` ```
### 编写 Deep 部分 ### Deep part
Deep 部分使用了标准的多层前向传导的 DNN 模型 The Deep part uses a standard multi-layer DNN.
```python ```python
def build_dnn_submodel(dnn_layer_dims): def build_dnn_submodel(dnn_layer_dims):
...@@ -199,10 +172,9 @@ def build_dnn_submodel(dnn_layer_dims): ...@@ -199,10 +172,9 @@ def build_dnn_submodel(dnn_layer_dims):
return _input_layer return _input_layer
``` ```
### 两者融合 ### Combine
两个 submodel 的最上层输出加权求和得到整个模型的输出，输出部分使用 `sigmoid` 作为激活函数，得到区间 (0,1) 的预测值， The output section uses `sigmoid` function to output (0,1) as the prediction value.
来逼近训练数据中二元类别的分布，并最终作为 CTR 预估的值使用。
```python ```python
# conbine DNN and LR submodels # conbine DNN and LR submodels
...@@ -217,7 +189,7 @@ def combine_submodels(dnn, lr): ...@@ -217,7 +189,7 @@ def combine_submodels(dnn, lr):
return fc return fc
``` ```
### 训练任务的定义 ### Training
```python ```python
dnn = build_dnn_submodel(dnn_layer_dims) dnn = build_dnn_submodel(dnn_layer_dims)
lr = build_lr_submodel() lr = build_lr_submodel()
...@@ -263,16 +235,17 @@ trainer.train( ...@@ -263,16 +235,17 @@ trainer.train(
event_handler=event_handler, event_handler=event_handler,
num_passes=100) num_passes=100)
``` ```
## 运行训练和测试
训练模型需要如下步骤：
1. 准备训练数据 ## Run training and testing
1. 从 [Kaggle CTR](https://www.kaggle.com/c/avazu-ctr-prediction/data) 下载 train.gz The model go through the following steps:
2. 解压 train.gz 得到 train.txt
1. Prepare training data
1. Download train.gz from [Kaggle CTR](https://www.kaggle.com/c/avazu-ctr-prediction/data) .
2. Unzip train.gz to get train.txt
3. `mkdir -p output; python avazu_data_processer.py --data_path train.txt --output_dir output --num_lines_to_detect 1000 --test_set_size 100` 生成演示数据 3. `mkdir -p output; python avazu_data_processer.py --data_path train.txt --output_dir output --num_lines_to_detect 1000 --test_set_size 100` 生成演示数据
2. 执行 `python train.py --train_data_path ./output/train.txt --test_data_path ./output/test.txt --data_meta_file ./output/data.meta.txt --model_type=0` 开始训练 2. Execute `python train.py --train_data_path ./output/train.txt --test_data_path ./output/test.txt --data_meta_file ./output/data.meta.txt --model_type=0`. Start training.
上面第2个步骤可以为 `train.py` 填充命令行参数来定制模型的训练过程，具体的命令行参数及用法如下 The argument options for `train.py` are as follows.
``` ```
usage: train.py [-h] --train_data_path TRAIN_DATA_PATH usage: train.py [-h] --train_data_path TRAIN_DATA_PATH
...@@ -303,15 +276,16 @@ optional arguments: ...@@ -303,15 +276,16 @@ optional arguments:
classification) classification)
``` ```
- `train_data_path` ： 训练集的路径 - `train_data_path` ： The path of the training set
- `test_data_path` : 测试集的路径 - `test_data_path` : The path of the testing set
- `num_passes`: 模型训练多少轮 - `num_passes`: number of rounds of model training
- `data_meta_file`: 参考[数据和任务抽象](### 数据和任务抽象)的描述。 - `data_meta_file`: Please refer to [数据和任务抽象](### 数据和任务抽象)的描述。
- `model_type`: 模型分类或回归 - `model_type`: Model classification or regressio
## Use the training model for prediction
The training model can be used to predict new data, and the format of the forecast data is as follows.
## 用训好的模型做预测
训好的模型可以用来预测新的数据， 预测数据的格式为
``` ```
# <dnn input ids> \t <lr input sparse values> # <dnn input ids> \t <lr input sparse values>
...@@ -319,9 +293,9 @@ optional arguments: ...@@ -319,9 +293,9 @@ optional arguments:
23 231 \t 1230:0.12 13421:0.9 23 231 \t 1230:0.12 13421:0.9
``` ```
这里与训练数据的格式唯一不同的地方，就是没有标签，也就是训练数据中第3列 `click` 对应的数值。 Here the only difference to the training data is that there is no label (i.e. `click` values).
`infer.py` 的使用方法如下 We now can use `infer.py` to perform inference.
``` ```
usage: infer.py [-h] --model_gz_path MODEL_GZ_PATH --data_path DATA_PATH usage: infer.py [-h] --model_gz_path MODEL_GZ_PATH --data_path DATA_PATH
...@@ -345,21 +319,21 @@ optional arguments: ...@@ -345,21 +319,21 @@ optional arguments:
classification) classification)
``` ```
- `model_gz_path_model`：用 `gz` 压缩过的模型路径 - `model_gz_path_model`：path for `gz` compressed data.
- `data_path` ： 需要预测的数据路径 - `data_path` ：
- `prediction_output_paht`：预测输出的路径 - `prediction_output_patj`：path for the predicted values s
- `data_meta_file` ：参考[数据和任务抽象](### 数据和任务抽象)的描述。 - `data_meta_file` ：Please refer to [数据和任务抽象](### 数据和任务抽象)。
- `model_type` ：分类或回归 - `model_type` ：Classification or regression
示例数据可以用如下命令预测 The sample data can be predicted with the following command
``` ```
python infer.py --model_gz_path <model_path> --data_path output/infer.txt --prediction_output_path predictions.txt --data_meta_path data.meta.txt python infer.py --model_gz_path <model_path> --data_path output/infer.txt --prediction_output_path predictions.txt --data_meta_path data.meta.txt
``` ```
最终的预测结果位于 `predictions.txt`。 The final prediction is written in `predictions.txt`。
## 参考文献 ## References
1. <https://en.wikipedia.org/wiki/Click-through_rate> 1. <https://en.wikipedia.org/wiki/Click-through_rate>
2. <https://www.kaggle.com/c/avazu-ctr-prediction/data> 2. <https://www.kaggle.com/c/avazu-ctr-prediction/data>
3. Cheng H T, Koc L, Harmsen J, et al. [Wide & deep learning for recommender systems](https://arxiv.org/pdf/1606.07792.pdf)[C]//Proceedings of the 1st Workshop on Deep Learning for Recommender Systems. ACM, 2016: 7-10. 3. Cheng H T, Koc L, Harmsen J, et al. [Wide & deep learning for recommender systems](https://arxiv.org/pdf/1606.07792.pdf)[C]//Proceedings of the 1st Workshop on Deep Learning for Recommender Systems. ACM, 2016: 7-10.
ctr/index.html
浏览文件 @ bcc236e7
...@@ -40,85 +40,60 @@ ...@@ -40,85 +40,60 @@
<!-- This block will be replaced by each markdown file content. Please do not change lines below.--> <!-- This block will be replaced by each markdown file content. Please do not change lines below.-->
<div id="markdown" style='display:none'> <div id="markdown" style='display:none'>
# 点击率预估 # Click-Through Rate Prediction
以下是本例目录包含的文件以及对应说明: ## Introduction
``` CTR(Click-Through Rate)\[[1](https://en.wikipedia.org/wiki/Click-through_rate)\]
├── README.md # 本教程markdown 文档 is a prediction of the probability that a user clicks on an advertisement. This model is widely used in the advertisement industry. Accurate click rate estimates are important for maximizing online advertising revenue.
├── dataset.md # 数据集处理教程
├── images # 本教程图片目录
│   ├── lr_vs_dnn.jpg
│   └── wide_deep.png
├── infer.py # 预测脚本
├── network_conf.py # 模型网络配置
├── reader.py # data reader
├── train.py # 训练脚本
└── utils.py # helper functions
└── avazu_data_processer.py # 示例数据预处理脚本
```
## 背景介绍
CTR(Click-Through Rate，点击率预估)\[[1](https://en.wikipedia.org/wiki/Click-through_rate)\]
是对用户点击一个特定链接的概率做出预测，是广告投放过程中的一个重要环节。精准的点击率预估对在线广告系统收益最大化具有重要意义。
当有多个广告位时，CTR 预估一般会作为排序的基准，比如在搜索引擎的广告系统里，当用户输入一个带商业价值的搜索词（query）时，系统大体上会执行下列步骤来展示广告： When there are multiple ad slots, CTR estimates are generally used as a baseline for ranking. For example, in a search engine's ad system, when the user enters a query, the system typically performs the following steps to show relevant ads.
1. 获取与用户搜索词相关的广告集合 1. Get the ad collection associated with the user's search term.
2. 业务规则和相关性过滤 2. Business rules and relevance filtering.
3. 根据拍卖机制和 CTR 排序 3. Rank by auction mechanism and CTR.
4. 展出广告 4. Show ads.
可以看到，CTR 在最终排序中起到了很重要的作用。 Here，CTR plays a crucial role.
### 发展阶段 ### Brief history
在业内，CTR 模型经历了如下的发展阶段： Historically, the CTR prediction model has been evolving as follows.
- Logistic Regression(LR) / GBDT + 特征工程 - Logistic Regression(LR) / Gradient Boosting Decision Trees (GBDT) + feature engineering
- LR + DNN 特征 - LR + Deep Neural Network (DNN)
- DNN + 特征工程 - DNN + feature engineering
在发展早期时 LR 一统天下，但最近 DNN 模型由于其强大的学习能力和逐渐成熟的性能优化， In the early stages of development LR dominated, but the recent years DNN based models are mainly used.
逐渐地接过 CTR 预估任务的大旗。
### LR vs DNN ### LR vs DNN
下图展示了 LR 和一个 \(3x2\) 的 DNN 模型的结构： The following figure shows the structure of LR and DNN model:
<p align="center"> <p align="center">
<img src="images/lr_vs_dnn.jpg" width="620" hspace='10'/> <br/> <img src="images/lr_vs_dnn.jpg" width="620" hspace='10'/> <br/>
Figure 1. LR 和 DNN 模型结构对比 Figure 1. LR and DNN model structure comparison
</p> </p>
LR 的蓝色箭头部分可以直接类比到 DNN 中对应的结构，可以看到 LR 和 DNN 有一些共通之处（比如权重累加）， We can see, LR and CNN have some common structures. However, DNN can have non-linear relation between input and output values by adding activation unit and further layers. This enables DNN to achieve better learning results in CTR estimates.
但前者的模型复杂度在相同输入维度下比后者可能低很多（从某方面讲，模型越复杂，越有潜力学习到更复杂的信息）；
如果 LR 要达到匹敌 DNN 的学习能力，必须增加输入的维度，也就是增加特征的数量，
这也就是为何 LR 和大规模的特征工程必须绑定在一起的原因。
LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括内存和计算量等方面，工业界都有非常成熟的优化方法； In the following, we demonstrate how to use PaddlePaddle to learn to predict CTR.
而 DNN 模型具有自己学习新特征的能力，一定程度上能够提升特征使用的效率，
这使得 DNN 模型在同样规模特征的情况下，更有可能达到更好的学习效果。
本文后面的章节会演示如何使用 PaddlePaddle 编写一个结合两者优点的模型。 ## Data and Model formation
Here `click` is the learning objective. There are several ways to learn the objectives.
## 数据和任务抽象 1. Direct learning click, 0,1 for binary classification
2. Learning to rank, pairwise rank or listwise rank
3. Measure the ad click rate of each ad, then rank by the click rate.
我们可以将 `click` 作为学习目标，任务可以有以下几种方案： In this example, we use the first method.
1. 直接学习 click，0,1 作二元分类 We use the Kaggle `Click-through rate prediction` task \[[2](https://www.kaggle.com/c/avazu-ctr-prediction/data)\].
2. Learning to rank, 具体用 pairwise rank（标签 1>0）或者 listwise rank
3. 统计每个广告的点击率，将同一个 query 下的广告两两组合，点击率高的>点击率低的，做 rank 或者分类
我们直接使用第一种方法做分类任务。 Please see the [data process](./dataset.md) for pre-processing data.
我们使用 Kaggle 上 `Click-through rate prediction` 任务的数据集\[[2](https://www.kaggle.com/c/avazu-ctr-prediction/data)\] 来演示本例中的模型。 The input data format for the demo model in this tutorial is as follows:
具体的特征处理方法参看 [data process](./dataset.md)。
本教程中演示模型的输入格式如下：
``` ```
# <dnn input ids> \t <lr input sparse values> \t click # <dnn input ids> \t <lr input sparse values> \t click
...@@ -126,10 +101,10 @@ LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括 ...@@ -126,10 +101,10 @@ LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括
23 231 \t 1230:0.12 13421:0.9 \t 1 23 231 \t 1230:0.12 13421:0.9 \t 1
``` ```
详细的格式描述如下： Description：
- `dnn input ids` 采用 one-hot 表示，只需要填写值为1的ID（注意这里不是变长输入） - `dnn input ids` one-hot coding.
- `lr input sparse values` 使用了 `ID:VALUE` 的表示，值部分最好规约到值域 `[-1, 1]`。 - `lr input sparse values` Use `ID:VALUE` , values are preferaly scaled to the range `[-1, 1]`。
此外，模型训练时需要传入一个文件描述 dnn 和 lr两个子模型的输入维度，文件的格式如下： 此外，模型训练时需要传入一个文件描述 dnn 和 lr两个子模型的输入维度，文件的格式如下：
...@@ -138,9 +113,9 @@ dnn_input_dim: <int> ...@@ -138,9 +113,9 @@ dnn_input_dim: <int>
lr_input_dim: <int> lr_input_dim: <int>
``` ```
其中， `<int>` 表示一个整型数值。 <int> represents an integer value.
本目录下的 `avazu_data_processor.py` 可以对下载的演示数据集\[[2](#参考文档)\] 进行处理，具体使用方法参考如下说明： `avazu_data_processor.py` can be used to download the data set \[[2](#参考文档)\]and pre-process the data.
``` ```
usage: avazu_data_processer.py [-h] --data_path DATA_PATH --output_dir usage: avazu_data_processer.py [-h] --data_path DATA_PATH --output_dir
...@@ -165,40 +140,38 @@ optional arguments: ...@@ -165,40 +140,38 @@ optional arguments:
size of the trainset (default: 100000) size of the trainset (default: 100000)
``` ```
- `data_path` 是待处理的数据路径 - `data_path` The data path to be processed
- `output_dir` 生成数据的输出路径 - `output_dir` The output path of the data
- `num_lines_to_detect` 预先扫描数据生成ID的个数，这里是扫描的文件行数 - `num_lines_to_detect` The number of generated IDs
- `test_set_size` 生成测试集的行数 - `test_set_size` The number of rows for the test set
- `train_size` 生成训练姐的行数 - `train_size` The number of rows of training set
## Wide & Deep Learning Model ## Wide & Deep Learning Model
谷歌在 16 年提出了 Wide & Deep Learning 的模型框架，用于融合适合学习抽象特征的 DNN 和 适用于大规模稀疏特征的 LR 两种模型的优点。 Google proposed a model framework for Wide & Deep Learning to integrate the advantages of both DNNs suitable for learning abstract features and LR models for large sparse features.
### 模型简介 ### Introduction to the model
Wide & Deep Learning Model\[[3](#参考文献)\] 可以作为一种相对成熟的模型框架使用， Wide & Deep Learning Model\[[3](#References)\] is a relatively mature model, but this model is still being used in the CTR predicting task. Here we demonstrate the use of this model to complete the CTR predicting task.
在 CTR 预估的任务中工业界也有一定的应用，因此本文将演示使用此模型来完成 CTR 预估的任务。
模型结构如下： The model structure is as follows:
<p align="center"> <p align="center">
<img src="images/wide_deep.png" width="820" hspace='10'/> <br/> <img src="images/wide_deep.png" width="820" hspace='10'/> <br/>
Figure 2. Wide & Deep Model Figure 2. Wide & Deep Model
</p> </p>
模型左边的 Wide 部分，可以容纳大规模系数特征，并且对一些特定的信息（比如 ID）有一定的记忆能力； The wide part of the left side of the model can accommodate large-scale coefficient features and has some memory for some specific information (such as ID); and the Deep part of the right side of the model can learn the implicit relationship between features.
而模型右边的 Deep 部分，能够学习特征间的隐含关系，在相同数量的特征下有更好的学习和推导能力。
### 编写模型输入 ### Model Input
模型只接受 3 个输入，分别是 The model has three inputs as follows.
- `dnn_input` ，也就是 Deep 部分的输入 - `dnn_input` ，the Deep part of the input
- `lr_input` ，也就是 Wide 部分的输入 - `lr_input` ，the wide part of the input
- `click` ， 点击与否，作为二分类模型学习的标签 - `click` ， click on or not
```python ```python
dnn_merged_input = layer.data( dnn_merged_input = layer.data(
...@@ -212,9 +185,9 @@ lr_merged_input = layer.data( ...@@ -212,9 +185,9 @@ lr_merged_input = layer.data(
click = paddle.layer.data(name='click', type=dtype.dense_vector(1)) click = paddle.layer.data(name='click', type=dtype.dense_vector(1))
``` ```
### 编写 Wide 部分 ### Wide part
Wide 部分直接使用了 LR 模型，但激活函数改成了 `RELU` 来加速 Wide part uses of the LR model, but the activation function changed to `RELU` for speed.
```python ```python
def build_lr_submodel(): def build_lr_submodel():
...@@ -223,9 +196,9 @@ def build_lr_submodel(): ...@@ -223,9 +196,9 @@ def build_lr_submodel():
return fc return fc
``` ```
### 编写 Deep 部分 ### Deep part
Deep 部分使用了标准的多层前向传导的 DNN 模型 The Deep part uses a standard multi-layer DNN.
```python ```python
def build_dnn_submodel(dnn_layer_dims): def build_dnn_submodel(dnn_layer_dims):
...@@ -241,10 +214,9 @@ def build_dnn_submodel(dnn_layer_dims): ...@@ -241,10 +214,9 @@ def build_dnn_submodel(dnn_layer_dims):
return _input_layer return _input_layer
``` ```
### 两者融合 ### Combine
两个 submodel 的最上层输出加权求和得到整个模型的输出，输出部分使用 `sigmoid` 作为激活函数，得到区间 (0,1) 的预测值， The output section uses `sigmoid` function to output (0,1) as the prediction value.
来逼近训练数据中二元类别的分布，并最终作为 CTR 预估的值使用。
```python ```python
# conbine DNN and LR submodels # conbine DNN and LR submodels
...@@ -259,7 +231,7 @@ def combine_submodels(dnn, lr): ...@@ -259,7 +231,7 @@ def combine_submodels(dnn, lr):
return fc return fc
``` ```
### 训练任务的定义 ### Training
```python ```python
dnn = build_dnn_submodel(dnn_layer_dims) dnn = build_dnn_submodel(dnn_layer_dims)
lr = build_lr_submodel() lr = build_lr_submodel()
...@@ -305,16 +277,17 @@ trainer.train( ...@@ -305,16 +277,17 @@ trainer.train(
event_handler=event_handler, event_handler=event_handler,
num_passes=100) num_passes=100)
``` ```
## 运行训练和测试
训练模型需要如下步骤：
1. 准备训练数据 ## Run training and testing
1. 从 [Kaggle CTR](https://www.kaggle.com/c/avazu-ctr-prediction/data) 下载 train.gz The model go through the following steps:
2. 解压 train.gz 得到 train.txt
1. Prepare training data
1. Download train.gz from [Kaggle CTR](https://www.kaggle.com/c/avazu-ctr-prediction/data) .
2. Unzip train.gz to get train.txt
3. `mkdir -p output; python avazu_data_processer.py --data_path train.txt --output_dir output --num_lines_to_detect 1000 --test_set_size 100` 生成演示数据 3. `mkdir -p output; python avazu_data_processer.py --data_path train.txt --output_dir output --num_lines_to_detect 1000 --test_set_size 100` 生成演示数据
2. 执行 `python train.py --train_data_path ./output/train.txt --test_data_path ./output/test.txt --data_meta_file ./output/data.meta.txt --model_type=0` 开始训练 2. Execute `python train.py --train_data_path ./output/train.txt --test_data_path ./output/test.txt --data_meta_file ./output/data.meta.txt --model_type=0`. Start training.
上面第2个步骤可以为 `train.py` 填充命令行参数来定制模型的训练过程，具体的命令行参数及用法如下 The argument options for `train.py` are as follows.
``` ```
usage: train.py [-h] --train_data_path TRAIN_DATA_PATH usage: train.py [-h] --train_data_path TRAIN_DATA_PATH
...@@ -345,15 +318,16 @@ optional arguments: ...@@ -345,15 +318,16 @@ optional arguments:
classification) classification)
``` ```
- `train_data_path` ： 训练集的路径 - `train_data_path` ： The path of the training set
- `test_data_path` : 测试集的路径 - `test_data_path` : The path of the testing set
- `num_passes`: 模型训练多少轮 - `num_passes`: number of rounds of model training
- `data_meta_file`: 参考[数据和任务抽象](### 数据和任务抽象)的描述。 - `data_meta_file`: Please refer to [数据和任务抽象](### 数据和任务抽象)的描述。
- `model_type`: 模型分类或回归 - `model_type`: Model classification or regressio
## Use the training model for prediction
The training model can be used to predict new data, and the format of the forecast data is as follows.
## 用训好的模型做预测
训好的模型可以用来预测新的数据， 预测数据的格式为
``` ```
# <dnn input ids> \t <lr input sparse values> # <dnn input ids> \t <lr input sparse values>
...@@ -361,9 +335,9 @@ optional arguments: ...@@ -361,9 +335,9 @@ optional arguments:
23 231 \t 1230:0.12 13421:0.9 23 231 \t 1230:0.12 13421:0.9
``` ```
这里与训练数据的格式唯一不同的地方，就是没有标签，也就是训练数据中第3列 `click` 对应的数值。 Here the only difference to the training data is that there is no label (i.e. `click` values).
`infer.py` 的使用方法如下 We now can use `infer.py` to perform inference.
``` ```
usage: infer.py [-h] --model_gz_path MODEL_GZ_PATH --data_path DATA_PATH usage: infer.py [-h] --model_gz_path MODEL_GZ_PATH --data_path DATA_PATH
...@@ -387,21 +361,21 @@ optional arguments: ...@@ -387,21 +361,21 @@ optional arguments:
classification) classification)
``` ```
- `model_gz_path_model`：用 `gz` 压缩过的模型路径 - `model_gz_path_model`：path for `gz` compressed data.
- `data_path` ： 需要预测的数据路径 - `data_path` ：
- `prediction_output_paht`：预测输出的路径 - `prediction_output_patj`：path for the predicted values s
- `data_meta_file` ：参考[数据和任务抽象](### 数据和任务抽象)的描述。 - `data_meta_file` ：Please refer to [数据和任务抽象](### 数据和任务抽象)。
- `model_type` ：分类或回归 - `model_type` ：Classification or regression
示例数据可以用如下命令预测 The sample data can be predicted with the following command
``` ```
python infer.py --model_gz_path <model_path> --data_path output/infer.txt --prediction_output_path predictions.txt --data_meta_path data.meta.txt python infer.py --model_gz_path <model_path> --data_path output/infer.txt --prediction_output_path predictions.txt --data_meta_path data.meta.txt
``` ```
最终的预测结果位于 `predictions.txt`。 The final prediction is written in `predictions.txt`。
## 参考文献 ## References
1. <https://en.wikipedia.org/wiki/Click-through_rate> 1. <https://en.wikipedia.org/wiki/Click-through_rate>
2. <https://www.kaggle.com/c/avazu-ctr-prediction/data> 2. <https://www.kaggle.com/c/avazu-ctr-prediction/data>
3. Cheng H T, Koc L, Harmsen J, et al. [Wide & deep learning for recommender systems](https://arxiv.org/pdf/1606.07792.pdf)[C]//Proceedings of the 1st Workshop on Deep Learning for Recommender Systems. ACM, 2016: 7-10. 3. Cheng H T, Koc L, Harmsen J, et al. [Wide & deep learning for recommender systems](https://arxiv.org/pdf/1606.07792.pdf)[C]//Proceedings of the 1st Workshop on Deep Learning for Recommender Systems. ACM, 2016: 7-10.
......
deep_speech_2/README.md
浏览文件 @ bcc236e7
...@@ -419,13 +419,56 @@ python deploy/demo_server.py --help ...@@ -419,13 +419,56 @@ python deploy/demo_server.py --help
python deploy/demo_client.py --help python deploy/demo_client.py --help
``` ```
## Released Models
#### Speech Model Released
Language | Model Name | Training Data | Training Hours
:-----------: | :------------: | :----------: | -------:
English | [LibriSpeech Model](http://cloud.dlnel.org/filepub/?uuid=17404caf-cf19-492f-9707-1fad07c19aae) | [LibriSpeech Dataset](http://www.openslr.org/12/) | 960 h
English | [Internal English Model](to-be-added) | Baidu English Dataset | 8000 h
Mandarin | [Aishell Model](http://cloud.dlnel.org/filepub/?uuid=6c83b9d8-3255-4adf-9726-0fe0be3d0274) | [Aishell Dataset](http://www.openslr.org/33/) | 151 h
Mandarin | [Internal Mandarin Model](to-be-added) | Baidu Mandarin Dataset | 2917 h
#### Language Model Released
Language Model | Training Data | Token-based | Size | Filter Configuraiton
:-------------:| :------------:| :-----: | -----: | -----------------:
[English LM (Median)](http://paddlepaddle.bj.bcebos.com/model_zoo/speech/common_crawl_00.prune01111.trie.klm) | To Be Added | Word-based | 8.3 GB | To Be Added
[English LM (Big)](to-be-added) | To Be Added | Word-based | X.X GB | To Be Added
[Mandarin LM (Median)](http://cloud.dlnel.org/filepub/?uuid=d21861e4-4ed6-45bb-ad8e-ae417a43195e) | To Be Added | Character-based | 2.8 GB | To Be Added
[Mandarin LM (Big)](to-be-added) | To Be Added | Character-based | X.X GB | To Be Added
## Experiments and Benchmarks ## Experiments and Benchmarks
TODO: to be added #### English Model Evaluation (Word Error Rate)
## Released Models Test Set | LibriSpeech Model | Internal English Model
:---------------------: | :---------------: | :-------------------:
LibriSpeech-Test-Clean | 7.9 | X.X
LibriSpeech-Test-Other | X.X | X.X
VoxForge-Test | X.X | X.X
Baidu-English-Test | X.X | X.X
TODO: to be added #### English Model Evaluation (Character Error Rate)
Test Set | LibriSpeech Model | Internal English Model
:---------------------: | :---------------: | :-------------------:
LibriSpeech-Test-Clean | X.X | X.X
LibriSpeech-Test-Other | X.X | X.X
VoxForge-Test | X.X | X.X
Baidu-English-Test | X.X | X.X
#### Mandarin Model Evaluation (Character Error Rate)
Test Set | Aishell Model | Internal Mandarin Model
:---------------------: | :---------------: | :-------------------:
Aishell-Test | X.X | X.X
Baidu-Mandarin-Test | X.X | X.X
#### Multiple GPU Efficiency
TODO: To Be Added
## Questions and Help ## Questions and Help
......
deep_speech_2/cloud/pcloud_submit.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
TRAIN_MANIFEST="cloud/cloud_manifests/cloud.manifest.train" TRAIN_MANIFEST="cloud/cloud_manifests/cloud.manifest.train"
DEV_MANIFEST="cloud/cloud_manifests/cloud.manifest.dev" DEV_MANIFEST="cloud/cloud_manifests/cloud.manifest.dev"
......
deep_speech_2/cloud/pcloud_train.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
TRAIN_MANIFEST=$1 TRAIN_MANIFEST=$1
DEV_MANIFEST=$2 DEV_MANIFEST=$2
......
deep_speech_2/cloud/pcloud_upload_data.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
mkdir cloud_manifests mkdir cloud_manifests
......
deep_speech_2/deploy/demo_server.py
浏览文件 @ bcc236e7
...@@ -100,7 +100,7 @@ class AsrRequestHandler(SocketServer.BaseRequestHandler): ...@@ -100,7 +100,7 @@ class AsrRequestHandler(SocketServer.BaseRequestHandler):
finish_time = time.time() finish_time = time.time()
print("Response Time: %f, Transcript: %s" % print("Response Time: %f, Transcript: %s" %
(finish_time - start_time, transcript)) (finish_time - start_time, transcript))
self.request.sendall(transcript) self.request.sendall(transcript.encode('utf-8'))
def _write_to_file(self, data): def _write_to_file(self, data):
# prepare save dir and filename # prepare save dir and filename
......
deep_speech_2/examples/librispeech/run_data.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_infer.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_infer_golden.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_test.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_test_golden.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_train.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/librispeech/run_tune.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/mandarin/run_demo_client.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/mandarin/run_demo_server.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
# TODO: replace the model with a mandarin model # TODO: replace the model with a mandarin model
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_data.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_infer.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_infer_golden.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_test.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_test_golden.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_train.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/examples/tiny/run_tune.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
pushd ../.. > /dev/null pushd ../.. > /dev/null
......
deep_speech_2/model_utils/model.py
浏览文件 @ bcc236e7
...@@ -8,6 +8,7 @@ import os ...@@ -8,6 +8,7 @@ import os
import time import time
import logging import logging
import gzip import gzip
from distutils.dir_util import mkpath
import paddle.v2 as paddle import paddle.v2 as paddle
from decoders.swig_wrapper import Scorer from decoders.swig_wrapper import Scorer
from decoders.swig_wrapper import ctc_greedy_decoder from decoders.swig_wrapper import ctc_greedy_decoder
...@@ -85,7 +86,7 @@ class DeepSpeech2Model(object): ...@@ -85,7 +86,7 @@ class DeepSpeech2Model(object):
""" """
# prepare model output directory # prepare model output directory
if not os.path.exists(output_model_dir): if not os.path.exists(output_model_dir):
os.mkdir(output_model_dir) mkpath(output_model_dir)
# prepare optimizer and trainer # prepare optimizer and trainer
optimizer = paddle.optimizer.Adam( optimizer = paddle.optimizer.Adam(
......
deep_speech_2/models/aishell/download_model.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
source ../../utils/utility.sh source ../../utils/utility.sh
......
deep_speech_2/models/librispeech/download_model.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
source ../../utils/utility.sh source ../../utils/utility.sh
......
deep_speech_2/models/lm/download_lm_ch.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
source ../../utils/utility.sh source ../../utils/utility.sh
......
deep_speech_2/models/lm/download_lm_en.sh
浏览文件 @ bcc236e7
#! /usr/bin/bash #! /usr/bin/env bash
source ../../utils/utility.sh source ../../utils/utility.sh
......
deep_speech_2/setup.sh
浏览文件 @ bcc236e7
#!/bin/bash #! /usr/bin/env bash
# install python dependencies # install python dependencies
if [ -f "requirements.txt" ]; then if [ -f "requirements.txt" ]; then
......
dssm/README.cn.md 0 → 100644
浏览文件 @ bcc236e7
此差异已折叠。
dssm/README.md
浏览文件 @ bcc236e7
# 深度结构化语义模型 (Deep Structured Semantic Models, DSSM) # Deep Structured Semantic Models (DSSM)
DSSM使用DNN模型在一个连续的语义空间中学习文本低纬的表示向量，并且建模两个句子间的语义相似度。 Deep Structured Semantic Models (DSSM) is simple but powerful DNN based model for matching web search queries and the URL based documents. This example demonstrates how to use PaddlePaddle to implement a generic DSSM model for modeling the semantic similarity between two strings.
本例演示如何使用 PaddlePaddle实现一个通用的DSSM 模型，用于建模两个字符串间的语义相似度，
模型实现支持通用的数据格式，用户替换数据便可以在真实场景中使用该模型。
## 背景介绍 ## Background Introduction
DSSM \[[1](##参考文献)\]是微软研究院13年提出来的经典的语义模型，用于学习两个文本之间的语义距离， DSSM \[[1](##References)]is a classic semantic model proposed by the Institute of Physics. It is used to study the semantic distance between two texts. The general implementation of DSSM is as follows.
广义上模型也可以推广和适用如下场景：
1. CTR预估模型，衡量用户搜索词（Query）与候选网页集合（Documents）之间的相关联程度。 1. The CTR predictor measures the degree of association between a user search query and a candidate web page.
2. 文本相关性，衡量两个字符串间的语义相关程度。 2. Text relevance, which measures the degree of semantic correlation between two strings.
3. 自动推荐，衡量User与被推荐的Item之间的关联程度。 3. Automatically recommend, measure the degree of association between User and the recommended Item.
DSSM 已经发展成了一个框架，可以很自然地建模两个记录之间的距离关系，
例如对于文本相关性问题，可以用余弦相似度 (cosin similarity) 来刻画语义距离；
而对于搜索引擎的结果排序，可以在DSSM上接上Rank损失训练处一个排序模型。
## 模型简介 ## Model Architecture
在原论文\[[1](#参考文献)\]中，DSSM模型用来衡量用户搜索词 Query 和文档集合 Documents 之间隐含的语义关系，模型结构如下
In the original paper \[[1](#References)] the DSSM model uses the implicit semantic relation between the user search query and the document as metric. The model structure is as follows
<p align="center"> <p align="center">
<img src="./images/dssm.png"/><br/><br/> <img src="./images/dssm.png"/><br/><br/>
图 1. DSSM 原始结构 Figure 1. DSSM In the original paper
</p> </p>
其贯彻的思想是， **用DNN将高维特征向量转化为低纬空间的连续向量（图中红色框部分）** ，
**在上层用cosin similarity来衡量用户搜索词与候选文档间的语义相关性** 。
在最顶层损失函数的设计上，原始模型使用类似Word2Vec中负例采样的方法，
一个Query会抽取正例 $D+$ 和4个负例 $D-$ 整体上算条件概率用对数似然函数作为损失，
这也就是图 1中类似 $P(D_1|Q)$ 的结构，具体细节请参考原论文。
随着后续优化DSSM模型的结构得以简化\[[3](#参考文献)\]，演变为： With the subsequent optimization of the DSSM model to simplify the structure \[[3](#References)]，the model becomes：
<p align="center"> <p align="center">
<img src="./images/dssm2.png" width="600"/><br/><br/> <img src="./images/dssm2.png" width="600"/><br/><br/>
图 2. DSSM通用结构 Figure 2. DSSM generic structure
</p> </p>
图中的空白方框可以用任何模型替代，比如全连接FC，卷积CNN，RNN等都可以， The blank box in the figure can be replaced by any model, such as fully connected FC, convoluted CNN, RNN, etc. The structure is designed to measure the semantic distance between two elements (such as strings).
该模型结构专门用于衡量两个元素（比如字符串）间的语义距离。
在现实使用中，DSSM模型会作为基础的积木，搭配上不同的损失函数来实现具体的功能，比如
- 在排序学习中，将 图 2 中结构添加 pairwise rank损失，变成一个排序模型
- 在CTR预估中，对点击与否做0，1二元分类，添加交叉熵损失变成一个分类模型
- 在需要对一个子串打分时，可以使用余弦相似度来计算相似度，变成一个回归模型
本例将尝试面向应用提供一个比较通用的解决方案，在模型任务类型上支持
- 分类 In practice，DSSM model serves as a basic building block, with different loss functions to achieve specific functions, such as
- [-1, 1] 值域内的回归
- Pairwise-Rank
在生成低纬语义向量的模型结构上，本模型支持以下三种： - In ranking system, the pairwise rank loss function.
- In the CTR estimate, instead of the binary classification on the click, use cross-entropy loss for a classification model
- In regression model, the cosine similarity is used to calculate the similarity
- FC, 多层全连接层 ## Model Implementation
- CNN，卷积神经网络 At a high level, DSSM model is composed of three components: the left and right DNN, and loss function on top of them. In complex tasks, the structure of the left DNN and the light DNN can be different. In this example, we keep these two DNN structures the same. And we choose any of FC, CNN, and RNN for the DNN architecture.
- RNN，递归神经网络
## 模型实现 In PaddlePaddle, the loss functions are supported for any of classification, regression, and ranking. Among them, the distance between the left and right DNN is calculated by the cosine similarity. In the classification task, the predicted distribution is calculated by softmax.
DSSM模型可以拆成三小块实现，分别是左边和右边的DNN，以及顶层的损失函数。
在复杂任务中，左右两边DNN的结构可以是不同的，比如在原始论文中左右分别学习Query和Document的semantic vector，
两者数据的数据不同，建议对应定制DNN的结构。
本例中为了简便和通用，将左右两个DNN的结构都设为相同的，因此只有三个选项FC,CNN,RNN等。 Here we demonstrate:
在损失函数的设计方面，也支持三种，分类, 回归, 排序； - How CNN, FC do text information extraction can refer to [text classification](https://github.com/PaddlePaddle/models/blob/develop/text_classification/README.md#模型详解)
其中，在回归和排序两种损失中，左右两边的匹配程度通过余弦相似度（cossim）来计算； - The contents of the RNN / GRU can be found in [Machine Translation](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.md#gated-recurrent-unit-gru)
在分类任务中，类别预测的分布通过softmax计算。 - For Pairwise Rank learning, please refer to [learn to rank](https://github.com/PaddlePaddle/models/blob/develop/ltr/README.md)
在其它教程中，对上述很多内容都有过详细的介绍，例如： Figure 3 shows the general architecture for both regression and classification models.
- 如何CNN, FC 做文本信息提取可以参考 [text classification](https://github.com/PaddlePaddle/models/blob/develop/text_classification/README.md#模型详解)
- RNN/GRU 的内容可以参考 [Machine Translation](https://github.com/PaddlePaddle/book/blob/develop/08.machine_translation/README.md#gated-recurrent-unit-gru)
- Pairwise Rank即排序学习可参考 [learn to rank](https://github.com/PaddlePaddle/models/blob/develop/ltr/README.md)
相关原理在此不再赘述，本文接下来的篇幅主要集中介绍使用PaddlePaddle实现这些结构上。
如图3，回归和分类模型的结构很相似
<p align="center"> <p align="center">
<img src="./images/dssm3.jpg"/><br/><br/> <img src="./images/dssm3.jpg"/><br/><br/>
图 3. DSSM for REGRESSION or CLASSIFICATION Figure 3. DSSM for REGRESSION or CLASSIFICATION
</p> </p>
最重要的组成部分包括词向量，图中`(1)`,`(2)`两个低纬向量的学习器（可以用RNN/CNN/FC中的任意一种实现）， The structure of the Pairwise Rank is more complex, as shown in Figure 4.
最上层对应的损失函数。
而Pairwise Rank的结构会复杂一些，类似两个 图 4. 中的结构，增加了对应的损失函数：
- 模型总体思想是，用同一个source(源)为左右两个target(目标)分别打分——`(a),(b)`，学习目标是(a),(b)间的大小关系
- `(a)`和`(b)`类似图3中结构，用于给source和target的pair打分
- `(1)`和`(2)`的结构其实是共用的，都表示同一个source，图中为了表达效果展开成两个
<p align="center"> <p align="center">
<img src="./images/dssm2.jpg"/><br/><br/> <img src="./images/dssm2.jpg"/><br/><br/>
图 4. DSSM for Pairwise Rank 图 4. DSSM for Pairwise Rank
</p> </p>
下面是各个部分具体的实现方法，所有的代码均包含在 `./network_conf.py` 中。 In below, we describe how to train DSSM model in PaddlePaddle. All the codes are included in `./network_conf.py`.
### 创建文本的词向量表
### Create a word vector table for the text
```python ```python
def create_embedding(self, input, prefix=''): def create_embedding(self, input, prefix=''):
''' '''
...@@ -117,10 +77,9 @@ def create_embedding(self, input, prefix=''): ...@@ -117,10 +77,9 @@ def create_embedding(self, input, prefix=''):
return emb return emb
``` ```
由于输入给词向量表(embedding table)的是一个句子对应的词的ID的列表 ，因此词向量表输出的是词向量的序列。 Since the input (embedding table) is a list of the IDs of the words corresponding to a sentence, the word vector table outputs the sequence of word vectors.
### CNN 结构实现
### CNN implementation
```python ```python
def create_cnn(self, emb, prefix=''): def create_cnn(self, emb, prefix=''):
''' '''
...@@ -151,14 +110,11 @@ def create_cnn(self, emb, prefix=''): ...@@ -151,14 +110,11 @@ def create_cnn(self, emb, prefix=''):
return conv_3, conv_4 return conv_3, conv_4
``` ```
CNN 接受 embedding table输出的词向量序列，通过卷积和池化操作捕捉到原始句子的关键信息， CNN accepts the word sequence of the embedding table, then process the data by convolution and pooling, and finally outputs a semantic vector.
最终输出一个语义向量（可以认为是句子向量）。
本例的实现中，分别使用了窗口长度为3和4的CNN学到的句子向量按元素求和得到最终的句子向量。
### RNN 结构实现 ### RNN implementation
RNN很适合学习变长序列的信息，使用RNN来学习句子的信息几乎是自然语言处理任务的标配。 RNN is suitable for learning variable length of the information
```python ```python
def create_rnn(self, emb, prefix=''): def create_rnn(self, emb, prefix=''):
...@@ -170,7 +126,7 @@ def create_rnn(self, emb, prefix=''): ...@@ -170,7 +126,7 @@ def create_rnn(self, emb, prefix=''):
return sent_vec return sent_vec
``` ```
### FC 结构实现 ### FC implementation
```python ```python
def create_fc(self, emb, prefix=''): def create_fc(self, emb, prefix=''):
...@@ -188,11 +144,9 @@ def create_fc(self, emb, prefix=''): ...@@ -188,11 +144,9 @@ def create_fc(self, emb, prefix=''):
return fc return fc
``` ```
在构建FC时需要首先使用`paddle.layer.pooling` 对词向量序列进行最大池化操作，将边长序列转化为一个固定维度向量， In the construction of FC, we use `paddle.layer.pooling` for the maximum pooling operation on the word vector sequence. Then we transform the sequence into a fixed dimensional vector.
作为整个句子的语义表达，使用最大池化能够降低句子长度对句向量表达的影响。
### 多层DNN实现 ### Multi-layer DNN implementation
在 CNN/DNN/FC提取出 semantic vector后，在上层可继续接多层FC来实现深层DNN结构。
```python ```python
def create_dnn(self, sent_vec, prefix): def create_dnn(self, sent_vec, prefix):
...@@ -215,8 +169,8 @@ def create_dnn(self, sent_vec, prefix): ...@@ -215,8 +169,8 @@ def create_dnn(self, sent_vec, prefix):
return _input_layer return _input_layer
``` ```
### 分类或回归实现 ### Classification / Regression
分类和回归的结构比较相似，因此可以用一个函数创建出来 The structure of classification and regression is similar. Below function can be used for both tasks.
```python ```python
def _build_classification_or_regression_model(self, is_classification): def _build_classification_or_regression_model(self, is_classification):
...@@ -269,9 +223,9 @@ def _build_classification_or_regression_model(self, is_classification): ...@@ -269,9 +223,9 @@ def _build_classification_or_regression_model(self, is_classification):
prediction, label) prediction, label)
return cost, prediction, label return cost, prediction, label
``` ```
### Pairwise Rank实现
Pairwise Rank复用上面的DNN结构，同一个source对两个target求相似度打分， ### Pairwise Rank
如果左边的target打分高，预测为1，否则预测为 0。
```python ```python
def _build_rank_model(self): def _build_rank_model(self):
...@@ -323,10 +277,10 @@ def _build_rank_model(self): ...@@ -323,10 +277,10 @@ def _build_rank_model(self):
# so AUC will not used. # so AUC will not used.
return cost, None, None return cost, None, None
``` ```
## 数据格式 ## Data Format
在 `./data` 中有简单的示例数据 Below is a simple example for the data in `./data`
### 回归的数据格式 ### Regression data format
``` ```
# 3 fields each line: # 3 fields each line:
# - source's word ids # - source's word ids
...@@ -335,13 +289,14 @@ def _build_rank_model(self): ...@@ -335,13 +289,14 @@ def _build_rank_model(self):
<ids> \t <ids> \t <float> <ids> \t <ids> \t <float>
``` ```
比如： The example of this format is as follows.
``` ```
3 6 10 \t 6 8 33 \t 0.7 3 6 10 \t 6 8 33 \t 0.7
6 0 \t 6 9 330 \t 0.03 6 0 \t 6 9 330 \t 0.03
``` ```
### 分类的数据格式
### Classification data format
``` ```
# 3 fields each line: # 3 fields each line:
# - source's word ids # - source's word ids
...@@ -350,7 +305,8 @@ def _build_rank_model(self): ...@@ -350,7 +305,8 @@ def _build_rank_model(self):
<ids> \t <ids> \t <label> <ids> \t <ids> \t <label>
``` ```
比如： The example of this format is as follows.
``` ```
3 6 10 \t 6 8 33 \t 0 3 6 10 \t 6 8 33 \t 0
...@@ -358,7 +314,7 @@ def _build_rank_model(self): ...@@ -358,7 +314,7 @@ def _build_rank_model(self):
``` ```
### 排序的数据格式 ### Ranking data format
``` ```
# 4 fields each line: # 4 fields each line:
# - source's word ids # - source's word ids
...@@ -368,18 +324,17 @@ def _build_rank_model(self): ...@@ -368,18 +324,17 @@ def _build_rank_model(self):
<ids> \t <ids> \t <ids> \t <label> <ids> \t <ids> \t <ids> \t <label>
``` ```
比如： The example of this format is as follows.
``` ```
7 2 4 \t 2 10 12 \t 9 2 7 10 23 \t 0 7 2 4 \t 2 10 12 \t 9 2 7 10 23 \t 0
7 2 4 \t 10 12 \t 9 2 21 23 \t 1 7 2 4 \t 10 12 \t 9 2 21 23 \t 1
``` ```
## 执行训练 ## Training
可以直接执行 `python train.py -y 0 --model_arch 0` 使用 `./data/classification` 目录里简单的数据来训练一个分类的FC模型。 We use `python train.py -y 0 --model_arch 0` with the data in `./data/classification` to train a DSSM model for classification.
其他模型结构也可以通过命令行实现定制，详细命令行参数如下
``` ```
usage: train.py [-h] [-i TRAIN_DATA_PATH] [-t TEST_DATA_PATH] usage: train.py [-h] [-i TRAIN_DATA_PATH] [-t TEST_DATA_PATH]
...@@ -438,17 +393,17 @@ optional arguments: ...@@ -438,17 +393,17 @@ optional arguments:
number of batches to output model, (default: 400) number of batches to output model, (default: 400)
``` ```
重要的参数描述如下 Parameter description:
- `train_data_path` 训练数据路径 - `train_data_path` Training data path
- `test_data_path` 测试数据路局，可以不设置 - `test_data_path` Test data path, optional
- `source_dic_path` 源字典字典路径 - `source_dic_path` Source dictionary path
- `target_dic_path` 目标字典路径 - `target_dic_path` 目Target dictionary path
- `model_type` 模型的损失函数的类型，分类0，排序1，回归2 - `model_type` The type of loss function of the model: classification 0, sort 1, regression 2
- `model_arch` 模型结构，FC 0， CNN 1, RNN 2 - `model_arch` Model structure: FC 0，CNN 1, RNN 2
- `dnn_dims` 模型各层的维度设置，默认为 `256,128,64,32`，即模型有4层，各层维度如上设置 - `dnn_dims` The dimension of each layer of the model is set, the default is `256,128,64,32`，with 4 layers.
## 用训练好的模型预测 ## To predict using the trained model
``` ```
usage: infer.py [-h] --model_path MODEL_PATH -i DATA_PATH -o usage: infer.py [-h] --model_path MODEL_PATH -i DATA_PATH -o
PREDICTION_OUTPUT_PATH -y MODEL_TYPE [-s SOURCE_DIC_PATH] PREDICTION_OUTPUT_PATH -y MODEL_TYPE [-s SOURCE_DIC_PATH]
...@@ -490,12 +445,12 @@ optional arguments: ...@@ -490,12 +445,12 @@ optional arguments:
number of categories for classification task. number of categories for classification task.
``` ```
部分参数可以参考 `train.py`，重要参数解释如下 Important parameters are
- `data_path` 需要预测的数据路径 - `data_path` Path for the data to predict
- `prediction_output_path` 预测的输出路径 - `prediction_output_path` Prediction output path
## 参考文献 ## References
1. Huang P S, He X, Gao J, et al. Learning deep structured semantic models for web search using clickthrough data[C]//Proceedings of the 22nd ACM international conference on Conference on information & knowledge management. ACM, 2013: 2333-2338. 1. Huang P S, He X, Gao J, et al. Learning deep structured semantic models for web search using clickthrough data[C]//Proceedings of the 22nd ACM international conference on Conference on information & knowledge management. ACM, 2013: 2333-2338.
2. [Microsoft Learning to Rank Datasets](https://www.microsoft.com/en-us/research/project/mslr/) 2. [Microsoft Learning to Rank Datasets](https://www.microsoft.com/en-us/research/project/mslr/)
......
dssm/index.html 0 → 100644
浏览文件 @ bcc236e7
此差异已折叠。
mt_with_external_memory/README.md
浏览文件 @ bcc236e7
...@@ -142,6 +142,7 @@ class ExternalMemory(object): ...@@ -142,6 +142,7 @@ class ExternalMemory(object):
name, name,
mem_slot_size, mem_slot_size,
boot_layer, boot_layer,
initial_weight,
readonly=False, readonly=False,
enable_interpolation=True): enable_interpolation=True):
""" Initialization. """ Initialization.
...@@ -154,6 +155,8 @@ class ExternalMemory(object): ...@@ -154,6 +155,8 @@ class ExternalMemory(object):
sequence layer has sequence length indicating the number sequence layer has sequence length indicating the number
of memory slots, and size as memory slot size. of memory slots, and size as memory slot size.
:type boot_layer: LayerOutput :type boot_layer: LayerOutput
:param initial_weight: Initializer for addressing weights.
:type initial_weight: LayerOutput
:param readonly: If true, the memory is read-only, and write function cannot :param readonly: If true, the memory is read-only, and write function cannot
be called. Default is false. be called. Default is false.
:type readonly: bool :type readonly: bool
...@@ -205,7 +208,7 @@ class ExternalMemory(object): ...@@ -205,7 +208,7 @@ class ExternalMemory(object):
- `_content_addressing`: 通过基于内容的寻址，计算得到读写操作的寻址强度。 - `_content_addressing`: 通过基于内容的寻址，计算得到读写操作的寻址强度。
- `_interpolation`: 通过插值寻址（当前寻址强度和上一时间步寻址强度的线性加权），更新当前寻址强度。 - `_interpolation`: 通过插值寻址（当前寻址强度和上一时间步寻址强度的线性加权），更新当前寻址强度。
- `_get_addressing_weight`: 调用上述两个寻址操作，获得对存储导员的读写操作的最终寻址强度。 - `_get_addressing_weight`: 调用上述两个寻址操作，获得对存储单元的读写操作的最终寻址强度。
对外接口包含： 对外接口包含：
...@@ -214,6 +217,7 @@ class ExternalMemory(object): ...@@ -214,6 +217,7 @@ class ExternalMemory(object):
- 输入参数 `name`: 外部记忆单元名，不同实例的相同命名将共享同一外部记忆单元。 - 输入参数 `name`: 外部记忆单元名，不同实例的相同命名将共享同一外部记忆单元。
- 输入参数 `mem_slot_size`: 单个记忆槽（向量）的维度。 - 输入参数 `mem_slot_size`: 单个记忆槽（向量）的维度。
- 输入参数 `boot_layer`: 用于内存槽初始化的层。需为序列类型，序列长度表明记忆槽的数量。 - 输入参数 `boot_layer`: 用于内存槽初始化的层。需为序列类型，序列长度表明记忆槽的数量。
- 输入参数 `initial_weight`: 用于初始化寻址强度。
- 输入参数 `readonly`: 是否打开只读模式（例如打开只读模式，该实例可用于注意力机制）。打开只读模式，`write` 方法不可被调用。 - 输入参数 `readonly`: 是否打开只读模式（例如打开只读模式，该实例可用于注意力机制）。打开只读模式，`write` 方法不可被调用。
- 输入参数 `enable_interpolation`: 是否允许插值寻址（例如当用于注意力机制时，需要关闭插值寻址）。 - 输入参数 `enable_interpolation`: 是否允许插值寻址（例如当用于注意力机制时，需要关闭插值寻址）。
- `write`: 写操作。 - `write`: 写操作。
...@@ -230,7 +234,6 @@ class ExternalMemory(object): ...@@ -230,7 +234,6 @@ class ExternalMemory(object):
self.external_memory = paddle.layer.memory( self.external_memory = paddle.layer.memory(
name=self.name, name=self.name,
size=self.mem_slot_size, size=self.mem_slot_size,
is_seq=True,
boot_layer=boot_layer) boot_layer=boot_layer)
``` ```
- `ExternalMemory`类的寻址逻辑通过 `_content_addressing` 和 `_interpolation` 两个私有方法实现。读和写操作通过 `read` 和 `write` 两个函数实现，包括上述的寻址操作。并且读和写的寻址独立进行，不同于 \[[2](#参考文献)\] 中的二者共享同一个寻址强度，目的是为了使得该类更通用。 - `ExternalMemory`类的寻址逻辑通过 `_content_addressing` 和 `_interpolation` 两个私有方法实现。读和写操作通过 `read` 和 `write` 两个函数实现，包括上述的寻址操作。并且读和写的寻址独立进行，不同于 \[[2](#参考文献)\] 中的二者共享同一个寻址强度，目的是为了使得该类更通用。
...@@ -349,6 +352,7 @@ def memory_enhanced_seq2seq(encoder_input, decoder_input, decoder_target, ...@@ -349,6 +352,7 @@ def memory_enhanced_seq2seq(encoder_input, decoder_input, decoder_target,
name="unbounded_memory", name="unbounded_memory",
mem_slot_size=size * 2, mem_slot_size=size * 2,
boot_layer=unbounded_memory_init, boot_layer=unbounded_memory_init,
initial_weight=unbounded_memory_weight_init,
readonly=True, readonly=True,
enable_interpolation=False) enable_interpolation=False)
``` ```
...@@ -359,6 +363,7 @@ def memory_enhanced_seq2seq(encoder_input, decoder_input, decoder_target, ...@@ -359,6 +363,7 @@ def memory_enhanced_seq2seq(encoder_input, decoder_input, decoder_target,
name="bounded_memory", name="bounded_memory",
mem_slot_size=size, mem_slot_size=size,
boot_layer=bounded_memory_init, boot_layer=bounded_memory_init,
initial_weight=bounded_memory_weight_init,
readonly=False, readonly=False,
enable_interpolation=True) enable_interpolation=True)
``` ```
......
mt_with_external_memory/train.py
浏览文件 @ bcc236e7
...@@ -135,7 +135,7 @@ def train(): ...@@ -135,7 +135,7 @@ def train():
sys.stdout.flush() sys.stdout.flush()
if isinstance(event, paddle.event.EndPass): if isinstance(event, paddle.event.EndPass):
result = trainer.test(reader=test_batch_reader, feeding=feeding) result = trainer.test(reader=test_batch_reader, feeding=feeding)
print "Pass: %d, TestCost: %f, %s" % (event.pass_id, event.cost, print "Pass: %d, TestCost: %f, %s" % (event.pass_id, result.cost,
result.metrics) result.metrics)
with gzip.open("checkpoints/params.pass-%d.tar.gz" % event.pass_id, with gzip.open("checkpoints/params.pass-%d.tar.gz" % event.pass_id,
'w') as f: 'w') as f:
......
nmt_without_attention/README.cn.md 0 → 100644
浏览文件 @ bcc236e7
# 神经网络机器翻译模型
## 背景介绍
机器翻译利用计算机将源语言转换成目标语言的同义表达，是自然语言处理中重要的研究方向，有着广泛的应用需求，其实现方式也经历了不断地演化。传统机器翻译方法主要基于规则或统计模型，需要人为地指定翻译规则或设计语言特征，效果依赖于人对源语言与目标语言的理解程度。近些年来，深度学习的提出与迅速发展使得特征的自动学习成为可能。深度学习首先在图像识别和语音识别中取得成功，进而在机器翻译等自然语言处理领域中掀起了研究热潮。机器翻译中的深度学习模型直接学习源语言到目标语言的映射，大为减少了学习过程中人的介入，同时显著地提高了翻译质量。本例介绍在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
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)
# bidirectional GRU as encoder
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
# the initialization state for decoder GRU
encoder_last = paddle.layer.last_seq(input=encoded_vector)
encoder_last_projected = paddle.layer.fc(
size=decoder_size, act=paddle.activation.Tanh(), input=encoder_last)
# the step function for decoder GRU
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)
decoder_inputs = paddle.layer.fc(
size=decoder_size * 3, input=[context, 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)
out = paddle.layer.fc(
size=target_dict_dim,
bias_attr=True,
act=paddle.activation.Softmax(),
input=gru_step)
return out
```
在模型训练和测试阶段，解码器的行为有很大的不同：
- **训练阶段**：目标翻译结果的词向量`trg_embedding`作为参数传递给单步逻辑`gru_decoder_without_attention()`，函数`recurrent_group()`循环调用单步逻辑执行，最后计算目标翻译与实际解码的差异cost并返回；
- **测试阶段**：解码器根据最后一个生成的词预测下一个词，`GeneratedInput()`自动取出模型预测出的概率最高的$k$个词的词向量传递给单步逻辑，`beam_search()`函数调用单步逻辑函数`gru_decoder_without_attention()`完成柱搜索并作为结果返回。
训练和生成的逻辑分别实现在如下的`if-else`条件分支中：
```python
group_input1 = paddle.layer.StaticInput(input=encoded_vector)
group_inputs = [group_input1]
decoder_group_name = "decoder_group"
if is_generating:
trg_embedding = paddle.layer.GeneratedInput(
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
else:
trg_embedding = paddle.layer.embedding(
input=paddle.layer.data(
name="target_language_word",
type=paddle.data_type.integer_value_sequence(target_dict_dim)),
size=word_vector_dim,
param_attr=paddle.attr.ParamAttr(name="_target_language_embedding"))
group_inputs.append(trg_embedding)
decoder = paddle.layer.recurrent_group(
name=decoder_group_name,
step=gru_decoder_without_attention,
input=group_inputs)
lbl = paddle.layer.data(
name="target_language_next_word",
type=paddle.data_type.integer_value_sequence(target_dict_dim))
cost = paddle.layer.classification_cost(input=decoder, label=lbl)
return cost
```
## 数据准备
本例所用到的数据来自[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中已经封装好了该数据集的读取接口，在首次运行的时候，程序会自动完成下载，用户无需手动完成相关的数据准备。
## 模型的训练与测试
### 模型训练
启动模型训练的十分简单，只需在命令行窗口中执行`python train.py`。模型训练阶段 `train.py` 脚本中的 `train()` 函数依次完成了如下的逻辑：
**a) 由网络定义，解析网络结构，初始化模型参数**
```python
# define the network topolgy.
cost = seq2seq_net(source_dict_dim, target_dict_dim)
parameters = paddle.parameters.create(cost)
```
**b) 设定训练过程中的优化策略、定义训练数据读取 `reader`**
```python
# define optimization method
optimizer = paddle.optimizer.RMSProp(
learning_rate=1e-3,
gradient_clipping_threshold=10.0,
regularization=paddle.optimizer.L2Regularization(rate=8e-4))
# define the trainer instance
trainer = paddle.trainer.SGD(
cost=cost, parameters=parameters, update_equation=optimizer)
# define data reader
wmt14_reader = paddle.batch(
paddle.reader.shuffle(
paddle.dataset.wmt14.train(source_dict_dim), buf_size=8192),
batch_size=55)
```
**c) 定义事件句柄，打印训练中间结果、保存模型快照**
```python
# define the event_handler callback
def event_handler(event):
if isinstance(event, paddle.event.EndIteration):
if not event.batch_id % 100 and event.batch_id:
with gzip.open(
os.path.join(save_path,
"nmt_without_att_%05d_batch_%05d.tar.gz" %
event.pass_id, event.batch_id), "w") as f:
parameters.to_tar(f)
if event.batch_id and not event.batch_id % 10:
logger.info("Pass %d, Batch %d, Cost %f, %s" % (
event.pass_id, event.batch_id, event.cost, event.metrics))
```
**d) 开始训练**
```python
# start training
trainer.train(
reader=wmt14_reader, event_handler=event_handler, num_passes=2)
```
输出样例为
```text
Pass 0, Batch 0, Cost 267.674663, {'classification_error_evaluator': 1.0}
.........
Pass 0, Batch 10, Cost 172.892294, {'classification_error_evaluator': 0.953895092010498}
.........
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}
```
### 生成翻译结果
利用训练好的模型生成翻译文本也十分简单。
1. 首先请修改`generate.py`脚本中`main`中传递给`generate`函数的参数，以选择使用哪一个保存的模型来生成。默认参数如下所示：
```python
generate(
source_dict_dim=30000,
target_dict_dim=30000,
batch_size=20,
beam_size=3,
model_path="models/nmt_without_att_params_batch_00100.tar.gz")
```
2. 在终端执行命令 `python generate.py`，脚本中的`generate()`执行了依次如下逻辑：
**a) 加载测试样本**
```python
# load data samples for generation
gen_creator = paddle.dataset.wmt14.gen(source_dict_dim)
gen_data = []
for item in gen_creator():
gen_data.append((item[0], ))
```
**b) 初始化模型，执行`infer()`为每个输入样本生成`beam search`的翻译结果**
```python
beam_gen = seq2seq_net(source_dict_dim, target_dict_dim, True)
with gzip.open(init_models_path) as f:
parameters = paddle.parameters.Parameters.from_tar(f)
# prob is the prediction probabilities, and id is the prediction word.
beam_result = paddle.infer(
output_layer=beam_gen,
parameters=parameters,
input=gen_data,
field=['prob', 'id'])
```
**c) 加载源语言和目标语言词典，将`id`序列表示的句子转化成原语言并输出结果**
```python
beam_result = inferer.infer(input=test_batch, field=["prob", "id"])
gen_sen_idx = np.where(beam_result[1] == -1)[0]
assert len(gen_sen_idx) == len(test_batch) * beam_size
start_pos, end_pos = 1, 0
for i, sample in enumerate(test_batch):
print(" ".join([
src_dict[w] for w in sample[0][1:-1]
])) # skip the start and ending mark when print the source sentence
for j in xrange(beam_size):
end_pos = gen_sen_idx[i * beam_size + j]
print("%.4f\t%s" % (beam_result[0][i][j], " ".join(
trg_dict[w] for w in beam_result[1][start_pos:end_pos])))
start_pos = end_pos + 2
print("\n")
```
设置beam search的宽度为3，输入为一个法文句子，则自动为测试数据生成对应的翻译结果，输出格式如下：
```text
Elles connaissent leur entreprise mieux que personne .
-3.754819 They know their business better than anyone . <e>
-4.445528 They know their businesses better than anyone . <e>
-5.026885 They know their business better than anybody . <e>
```
- 第一行为输入的源语言句子。
- 第二 ~ beam_size + 1 行是柱搜索生成的 `beam_size` 条翻译结果
- 相同行的输出以“\t”分隔为两列，第一列是句子的log 概率，第二列是翻译结果的文本。
- 符号`<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/README.md
浏览文件 @ bcc236e7
此差异已折叠。
nmt_without_attention/index.html
浏览文件 @ bcc236e7
此差异已折叠。
ssd/README.md
浏览文件 @ bcc236e7
# SSD目标检测 # Single Shot MultiBox Detector (SSD) Object Detection
## 概述
SSD全称为Single Shot MultiBox Detector，是目标检测领域较新且效果较好的检测算法之一，具体参见论文\[[1](#引用)\]。SSD算法主要特点是检测速度快且检测精度高。PaddlePaddle已集成SSD算法，本示例旨在介绍如何使用PaddlePaddle中的SSD模型进行目标检测。下文展开顺序为：首先简要介绍SSD原理，然后介绍示例包含文件及作用，接着介绍如何在PASCAL VOC数据集上训练、评估及检测，最后简要介绍如何在自有数据集上使用SSD。
## SSD原理
SSD使用一个卷积神经网络实现“端到端”的检测，所谓“端到端”指输入为原始图像，输出为检测结果，无需借助外部工具或流程进行特征提取、候选框生成等。论文中SSD的基础模型为VGG16\[[2](#引用)\]，不同于原始VGG16网络模型，SSD做了一些改变：
1. 将最后的fc6、fc7全连接层变为卷积层，卷积层参数通过对原始fc6、fc7参数采样得到。 ## Introduction
2. 将pool5层的参数由2x2-s2（kernel大小为2x2，stride size为2）更改为3x3-s1-p1（kernel大小为3x3，stride size为1，padding size为1）。 Single Shot MultiBox Detector (SSD) is one of the new and enhanced detection algorithms detecting objects in images [ 1 ]. SSD algorithm is characterized by rapid detection and high detection accuracy. PaddlePaddle has an integrated SSD algorithm! This example demonstrates how to use the SSD model in PaddlePaddle for object detection. We first provide a brief introduction to the SSD principle. Then we describe how to train, evaluate and test on the PASCAL VOC data set, and finally on how to use SSD on custom data set.
3. 在conv4\_3、conv7、conv8\_2、conv9\_2、conv10\_2及pool11层后面接了priorbox层，priorbox层的主要目的是根据输入的特征图（feature map）生成一系列的矩形候选框。关于SSD的更详细的介绍可以参考论文\[[1](#引用)\]。
下图为模型（300x300）的总体结构： ## SSD Architecture
SSD uses a convolutional neural network to achieve end-to-end detection. The term "End-to-end" is used because it uses the input as the original image and the output for the test results, without the use of external tools or processes for feature extraction. One popular model of SSD is VGG16 [ 2 ]. SSD differs from VGG16 network model as in following.
1. The final fc6, fc7 full connection layer into a convolution layer, convolution layer parameters through the original fc6, fc7 parameters obtained.
2. Change the parameters of the pool5 layer from 2x2-s2 (kernel size 2x2, stride size to 2) to 3x3-s1-p1 (kernel size is 3x3, stride size is 1, padding size is 1).
3. The initial layers are composed of conv4\_3、conv7、conv8\_2、conv9\_2、conv10\_2, and pool11 layers. The main purpose of the priorbox layer is to generate a series of rectangular candidates based on the input feature map. A more detailed introduction to SSD can be found in the paper\[[1](#References)\]。
Below is the overall structure of the model (300x300)
<p align="center"> <p align="center">
<img src="images/ssd_network.png" width="900" height="250" hspace='10'/> <br/> <img src="images/ssd_network.png" width="900" height="250" hspace='10'/> <br/>
图1. SSD网络结构 图1. SSD网络结构
</p> </p>
图中每个矩形盒子代表一个卷积层，最后的两个矩形框分别表示汇总各卷积层输出结果和后处理阶段。具体地，在预测阶段网络会输出一组候选矩形框，每个矩形包含两类信息：位置和类别得分，图中倒数第二个矩形框即表示网络的检测结果的汇总处理，由于候选矩形框数量较多且很多矩形框重叠严重，这时需要经过后处理来筛选出质量较高的少数矩形框，这里的后处理主要指非极大值抑制（Non-maximum Suppression）。 Each box in the figure represents a convolution layer, and the last two rectangles represent the summary of each convolution layer output and the post-processing phase. Specifically, the network will output a set of candidate rectangles in the prediction phase. Each rectangle contains two types of information: the position and the category score. The network produces thousands of predictions at various scales and aspect ratios before performing non-maximum suppression, resulting in a handful of final tags.
从SSD的网络结构可以看出，候选矩形框在多个特征图（feature map上）生成，不同的feature map具有的感受野不同，这样可以在不同尺度扫描图像，相对于其他检测方法可以生成更丰富的候选框，从而提高检测精度；另一方面SSD对VGG16的扩展部分以较小的代价实现对候选框的位置和类别得分的计算，整个过程只需要一个卷积神经网络完成，所以速度较快。
## 示例总览 ## Example Overview
本示例共包含如下文件： This example contains the following files:
<table> <table>
<caption>表1. 示例文件</caption> <caption>Table 1. Directory structure</caption>
<tr><th>文件</th><th>用途</th></tr> <tr><th>File</th><th>Description</th></tr>
<tr><td>train.py</td><td>训练脚本</td></tr> <tr><td>train.py</td><td>Training script</td></tr>
<tr><td>eval.py</td><td>评估脚本，用于评估训好模型</td></tr> <tr><td>eval.py</td><td>Evaluation</td></tr>
<tr><td>infer.py</td><td>检测脚本，给定图片及模型，实施检测</td></tr> <tr><td>infer.py</td><td>Prediction using the trained model</tr>
<tr><td>visual.py</td><td>检测结果可视化</td></tr> <tr><td>visual.py</td><td>Visualization of the test results</td></tr>
<tr><td>image_util.py</td><td>图像预处理所需公共函数</td></tr> <tr><td>image_util.py</td><td>Image preprocessing required common function</td></tr>
<tr><td>data_provider.py</td><td>数据处理脚本，生成训练、评估或检测所需数据</td></tr> <tr><td>data_provider.py</td><td>Data processing scripts, generate training, evaluate or detect the required data</td></tr>
<tr><td>config/pascal_voc_conf.py</td><td>神经网络超参数配置文件</td></tr> <tr><td>config/pascal_voc_conf.py</td><td> Neural network hyperparameter configuration file</td></tr>
<tr><td>data/label_list</td><td>类别列表</td></tr> <tr><td>data/label_list</td><td>Label list</td></tr>
<tr><td>data/prepare_voc_data.py</td><td>准备训练PASCAL VOC数据列表</td></tr> <tr><td>data/prepare_voc_data.py</td><td>Prepare training PASCAL VOC data list</td></tr>
</table> </table>
训练阶段需要对数据做预处理，包括裁剪、采样等，这部分操作在```image_util.py```和```data_provider.py```中完成。值得注意的是，```config/vgg_config.py```为参数配置文件，包括训练参数、神经网络参数等，本配置文件包含参数是针对PASCAL VOC数据配置的，当训练自有数据时，需要仿照该文件配置新的参数。```data/prepare_voc_data.py```脚本用来生成文件列表，包括切分训练集和测试集，使用时需要用户事先下载并解压数据，默认采用VOC2007和VOC2012。 The training phase requires pre-processing of the data, including clipping, sampling, etc. This is done in ```image_util.py``` and ```data_provider.py```.```config/vgg_config.py```. ```data/prepare_voc_data.py``` is used to generate a list of files, including the training set and test set, the need to use the user to download and extract data, the default use of VOC2007 and VOC2012.
## PASCAL VOC数据集 ## PASCAL VOC Data set
### 数据准备
首先需要下载数据集，VOC2007\[[3](#引用)\]和VOC2012\[[4](#引用)\]，VOC2007包含训练集和测试集，VOC2012只包含训练集，将下载好的数据解压，目录结构为```data/VOCdevkit/VOC2007```和```data/VOCdevkit/VOC2012```。进入```data```目录，运行```python prepare_voc_data.py```即可生成```trainval.txt```和```test.txt```。核心函数为： ### Data Preparation
First download the data set. VOC2007\[[3](#References)\] contains both training and test data set, and VOC2012\[[4](#References)\] contains only training set. Downloaded data are stored in ```data/VOCdevkit/VOC2007``` and ```data/VOCdevkit/VOC2012```. Next, run ```data/prepare_voc_data.py``` to generate ```trainval.txt``` and ```test.txt```. The relevant function is as following:
```python ```python
def prepare_filelist(devkit_dir, years, output_dir): def prepare_filelist(devkit_dir, years, output_dir):
...@@ -60,7 +61,7 @@ def prepare_filelist(devkit_dir, years, output_dir): ...@@ -60,7 +61,7 @@ def prepare_filelist(devkit_dir, years, output_dir):
ftest.write(item[0] + ' ' + item[1] + '\n') ftest.write(item[0] + ' ' + item[1] + '\n')
``` ```
该函数首先对每一年（year）的数据进行处理，然后将训练图像的文件路径列表进行随机打乱，最后保存训练文件列表和测试文件列表。默认```prepare_voc_data.py```和```VOCdevkit```在相同目录下，且生成的文件列表也在该目录。需注意```trainval.txt```既包含VOC2007的训练数据，也包含VOC2012的训练数据，```test.txt```只包含VOC2007的测试数据。我们这里提供```trainval.txt```前几行输入作为样例： The data in ```trainval.txt``` will look like:
``` ```
VOCdevkit/VOC2007/JPEGImages/000005.jpg VOCdevkit/VOC2007/Annotations/000005.xml VOCdevkit/VOC2007/JPEGImages/000005.jpg VOCdevkit/VOC2007/Annotations/000005.xml
...@@ -68,12 +69,14 @@ VOCdevkit/VOC2007/JPEGImages/000007.jpg VOCdevkit/VOC2007/Annotations/000007.xml ...@@ -68,12 +69,14 @@ VOCdevkit/VOC2007/JPEGImages/000007.jpg VOCdevkit/VOC2007/Annotations/000007.xml
VOCdevkit/VOC2007/JPEGImages/000009.jpg VOCdevkit/VOC2007/Annotations/000009.xml VOCdevkit/VOC2007/JPEGImages/000009.jpg VOCdevkit/VOC2007/Annotations/000009.xml
``` ```
文件共两个字段，第一个字段为图像文件的相对路径，第二个字段为对应标注文件的相对路径。 The first field is the relative path of the image file, and the second field is the relative path of the corresponding label file.
### 预训练模型准备 ### To Use Pre-trained Model
下载预训练的VGG-16模型，我们提供了一个转换好的模型，具体下载地址为：http://paddlepaddle.bj.bcebos.com/model_zoo/detection/ssd_model/vgg_model.tar.gz ，下载好模型后，放置路径为```vgg/vgg_model.tar.gz```。 We also provide a pre-trained model using VGG-16 with good performance. To use the model, download the file http://paddlepaddle.bj.bcebos.com/model_zoo/detection/ssd_model/vgg_model.tar.gz, and place it as ```vgg/vgg_model.tar.gz```。
### 模型训练
直接执行```python train.py```即可进行训练。需要注意本示例仅支持CUDA GPU环境，无法在CPU上训练，主要因为使用CPU训练速度很慢，实践中一般使用GPU来处理图像任务，这里实现采用硬编码方式使用cuDNN，不提供CPU版本。```train.py```的一些关键执行逻辑： ### Training
Next, run ```python train.py``` to train the model. Note that this example only supports the CUDA GPU environment, and can not be trained using only CPU. This is mainly because the training is very slow using CPU only.
```python ```python
paddle.init(use_gpu=True, trainer_count=4) paddle.init(use_gpu=True, trainer_count=4)
...@@ -89,14 +92,14 @@ train(train_file_list='./data/trainval.txt', ...@@ -89,14 +92,14 @@ train(train_file_list='./data/trainval.txt',
init_model_path='./vgg/vgg_model.tar.gz') init_model_path='./vgg/vgg_model.tar.gz')
``` ```
主要包括： Below is a description about this script:
1. 调用```paddle.init```指定使用4卡GPU训练。 1. Call ```paddle.init``` with 4 GPUs.
2. 调用```data_provider.Settings```配置数据预处理所需参数，其中```cfg.IMG_HEIGHT```和```cfg.IMG_WIDTH```在配置文件```config/vgg_config.py```中设置，这里均为300，300x300是一个典型配置，兼顾效率和检测精度，也可以通过修改配置文件扩展到512x512。 2. ```data_provider.Settings()``` is to pass configuration parameters. For ```config/vgg_config.py``` setting，300x300 is a typical configuration for both the accuracy and efficiency. It can be extended to 512x512 by modifying the configuration file.
3. 调用```train```执行训练，其中```train_file_list```指定训练数据列表，```dev_file_list```指定评估数据列表，```init_model_path```指定预训练模型位置。 3. In ```train()```执 function, ```train_file_list``` specifies the training data list, and ```dev_file_list``` specifies the evaluation data list, and ```init_model_path``` specifies the pre-training model location.
4. 训练过程中会打印一些日志信息，每训练1个batch会输出当前的轮数、当前batch的cost及mAP（mean Average Precision，平均精度均值），每训练一个pass，会保存一次模型，默认保存在```checkpoints```目录下（注：需事先创建）。 4. During the training process will print some log information, each training a batch will output the current number of rounds, the current batch cost and mAP (mean Average Precision. Each training pass will be saved a model to the default saved directory ```checkpoints``` (Need to be created in advance).
下面给出SDD300x300在VOC数据集（train包括07+12，test为07）上的mAP曲线，迭代140轮mAP可达到71.52%。 The following shows the SDD300x300 in the VOC data set.
<p align="center"> <p align="center">
<img src="images/SSD300x300_map.png" hspace='10'/> <br/> <img src="images/SSD300x300_map.png" hspace='10'/> <br/>
...@@ -104,8 +107,8 @@ train(train_file_list='./data/trainval.txt', ...@@ -104,8 +107,8 @@ train(train_file_list='./data/trainval.txt',
</p> </p>
### 模型评估 ### Model Assessment
执行```python eval.py```即可对模型进行评估，```eval.py```的关键执行逻辑如下： Next, run ```python eval.py``` to evaluate the model.
```python ```python
paddle.init(use_gpu=True, trainer_count=4) # use 4 gpus paddle.init(use_gpu=True, trainer_count=4) # use 4 gpus
...@@ -124,10 +127,8 @@ eval( ...@@ -124,10 +127,8 @@ eval(
model_path='models/pass-00000.tar.gz') model_path='models/pass-00000.tar.gz')
``` ```
调用```paddle.init```指定使用4卡GPU评估；```data_provider.Settings```参见训练阶段的配置；调用```eval```执行评估，其中```eval_file_list```指定评估数据列表，```batch_size```指定评估时batch size的大小，```model_path ```指定模型位置。评估结束会输出```loss```信息和```mAP```信息。 ### Obejct Detection
Run ```python infer.py``` to perform the object detection using the trained model.
### 图像检测
执行```python infer.py```即可使用训练好的模型对图片实施检测，```infer.py```关键逻辑如下：
```python ```python
infer( infer(
...@@ -139,7 +140,9 @@ infer( ...@@ -139,7 +140,9 @@ infer(
threshold=0.3) threshold=0.3)
``` ```
其中```eval_file_list```指定图像路径列表；```save_path```指定预测结果保存路径；```data_args```如上；```batch_size```为每多少样本预测一次；```model_path```指模型的位置；```threshold```为置信度阈值，只有得分大于或等于该值的才会输出。下面给出```infer.res```的一些输出样例：
Here ```eval_file_list``` specified image path list, ```save_path``` specifies directory to save the prediction result.
``` ```
VOCdevkit/VOC2007/JPEGImages/006936.jpg 12 0.997844 131.255611777 162.271582842 396.475315094 334.0 VOCdevkit/VOC2007/JPEGImages/006936.jpg 12 0.997844 131.255611777 162.271582842 396.475315094 334.0
...@@ -150,19 +153,19 @@ VOCdevkit/VOC2007/JPEGImages/006936.jpg 14 0.372522 187.543615699 133.727034628 ...@@ -150,19 +153,19 @@ VOCdevkit/VOC2007/JPEGImages/006936.jpg 14 0.372522 187.543615699 133.727034628
一共包含4个字段，以tab分割，第一个字段是检测图像路径，第二字段为检测矩形框内类别，第三个字段是置信度，第四个字段是4个坐标值（以空格分割）。 一共包含4个字段，以tab分割，第一个字段是检测图像路径，第二字段为检测矩形框内类别，第三个字段是置信度，第四个字段是4个坐标值（以空格分割）。
示例还提供了一个可视化脚本，直接运行```python visual.py```即可，须指定输出检测结果路径及输出目录，默认可视化后图像保存在```./visual_res```，下面是用训练好的模型infer部分图像并可视化的效果： Below is the example after running ```python visual.py``` to visualize the model result. The default visualization of the image saved in the ```./visual_res```.
<p align="center"> <p align="center">
<img src="images/vis_1.jpg" height=150 width=200 hspace='10'/> <img src="images/vis_1.jpg" height=150 width=200 hspace='10'/>
<img src="images/vis_2.jpg" height=150 width=200 hspace='10'/> <img src="images/vis_2.jpg" height=150 width=200 hspace='10'/>
<img src="images/vis_3.jpg" height=150 width=100 hspace='10'/> <img src="images/vis_3.jpg" height=150 width=100 hspace='10'/>
<img src="images/vis_4.jpg" height=150 width=200 hspace='10'/> <br /> <img src="images/vis_4.jpg" height=150 width=200 hspace='10'/> <br />
图3. SSD300x300 检测可视化示例 Figure 3. SSD300x300 Visualization Example
</p> </p>
## 自有数据集 ## To Use Custo Data set
在自有数据上训练PaddlePaddle SSD需要完成两个关键准备，首先需要适配网络可以接受的输入格式，这里提供一个推荐的结构，以```train.txt```为例 In PaddlePaddle, using the custom data set to train SSD model is also easy! Just input the format that ```train.txt``` can understand. Below is a recommended structure to input for ```train.txt```.
``` ```
image00000_file_path image00000_annotation_file_path image00000_file_path image00000_annotation_file_path
...@@ -171,7 +174,7 @@ image00002_file_path image00002_annotation_file_path ...@@ -171,7 +174,7 @@ image00002_file_path image00002_annotation_file_path
... ...
``` ```
文件共两列，以空白符分割，第一列为图像文件的路径，第二列为对应标注数据的文件路径。对图像文件的读取比较直接，略微复杂的是对标注数据的解析，本示例中标注数据使用xml文件存储，所以需要在```data_provider.py```中对xml解析，核心逻辑如下： The first column is for the image file path, and the second column for the corresponding marked data file path. In the case of using xml file format, ```data_provider.py``` can be used to process the data as follows.
```python ```python
bbox_labels = [] bbox_labels = []
...@@ -191,7 +194,7 @@ for object in root.findall('object'): ...@@ -191,7 +194,7 @@ for object in root.findall('object'):
bbox_labels.append(bbox_sample) bbox_labels.append(bbox_sample)
``` ```
这里一条标注数据包括：label、xmin、ymin、xmax、ymax和is\_difficult，is\_difficult表示该object是否为难例，实际中如果不需要，只需把该字段置零即可。自有数据也需要提供对应的解析逻辑，假设标注数据（比如image00000\_annotation\_file\_path）存储格式如下： Now the marked data（e.g. image00000\_annotation\_file\_path）is as follows:
``` ```
label1 xmin1 ymin1 xmax1 ymax1 label1 xmin1 ymin1 xmax1 ymax1
...@@ -199,7 +202,7 @@ label2 xmin2 ymin2 xmax2 ymax2 ...@@ -199,7 +202,7 @@ label2 xmin2 ymin2 xmax2 ymax2
... ...
``` ```
每行对应一个物体，共5个字段，第一个为label（注背景为0，需从1编号），剩余4个为坐标，对应的解析逻辑可更改为如下： Here each row corresponds to an object for 5 fields. The first is for the label (note the background 0, need to be numbered from 1), and the remaining four are for the coordinates.
``` ```
bbox_labels = [] bbox_labels = []
...@@ -217,9 +220,9 @@ with open(label_path) as flabel: ...@@ -217,9 +220,9 @@ with open(label_path) as flabel:
bbox_labels.append(bbox_sample) bbox_labels.append(bbox_sample)
``` ```
另一个重要的事情就是根据图像大小及检测物体的大小等更改网络结构的配置，主要是仿照```config/vgg_config.py```创建自己的配置文件，参数设置经验请参照论文\[[1](#引用)\]。 Another important thing is to change the size of the image and the size of the object to change the configuration of the network structure. Use ```config/vgg_config.py``` to create the custom configuration file. For more details, please refer to \[[1](#References)\]。
## 引用 ## References
1. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg. [SSD: Single shot multibox detector](https://arxiv.org/abs/1512.02325). European conference on computer vision. Springer, Cham, 2016. 1. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg. [SSD: Single shot multibox detector](https://arxiv.org/abs/1512.02325). European conference on computer vision. Springer, Cham, 2016.
2. Simonyan, Karen, and Andrew Zisserman. [Very deep convolutional networks for large-scale image recognition](https://arxiv.org/abs/1409.1556). arXiv preprint arXiv:1409.1556 (2014). 2. Simonyan, Karen, and Andrew Zisserman. [Very deep convolutional networks for large-scale image recognition](https://arxiv.org/abs/1409.1556). arXiv preprint arXiv:1409.1556 (2014).
3. [The PASCAL Visual Object Classes Challenge 2007](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html) 3. [The PASCAL Visual Object Classes Challenge 2007](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html)
......
ssd/index.html
浏览文件 @ bcc236e7
...@@ -40,49 +40,50 @@ ...@@ -40,49 +40,50 @@
<!-- This block will be replaced by each markdown file content. Please do not change lines below.--> <!-- This block will be replaced by each markdown file content. Please do not change lines below.-->
<div id="markdown" style='display:none'> <div id="markdown" style='display:none'>
# SSD目标检测 # Single Shot MultiBox Detector (SSD) Object Detection
## 概述
SSD全称为Single Shot MultiBox Detector，是目标检测领域较新且效果较好的检测算法之一，具体参见论文\[[1](#引用)\]。SSD算法主要特点是检测速度快且检测精度高。PaddlePaddle已集成SSD算法，本示例旨在介绍如何使用PaddlePaddle中的SSD模型进行目标检测。下文展开顺序为：首先简要介绍SSD原理，然后介绍示例包含文件及作用，接着介绍如何在PASCAL VOC数据集上训练、评估及检测，最后简要介绍如何在自有数据集上使用SSD。
## SSD原理
SSD使用一个卷积神经网络实现“端到端”的检测，所谓“端到端”指输入为原始图像，输出为检测结果，无需借助外部工具或流程进行特征提取、候选框生成等。论文中SSD的基础模型为VGG16\[[2](#引用)\]，不同于原始VGG16网络模型，SSD做了一些改变：
1. 将最后的fc6、fc7全连接层变为卷积层，卷积层参数通过对原始fc6、fc7参数采样得到。 ## Introduction
2. 将pool5层的参数由2x2-s2（kernel大小为2x2，stride size为2）更改为3x3-s1-p1（kernel大小为3x3，stride size为1，padding size为1）。 Single Shot MultiBox Detector (SSD) is one of the new and enhanced detection algorithms detecting objects in images [ 1 ]. SSD algorithm is characterized by rapid detection and high detection accuracy. PaddlePaddle has an integrated SSD algorithm! This example demonstrates how to use the SSD model in PaddlePaddle for object detection. We first provide a brief introduction to the SSD principle. Then we describe how to train, evaluate and test on the PASCAL VOC data set, and finally on how to use SSD on custom data set.
3. 在conv4\_3、conv7、conv8\_2、conv9\_2、conv10\_2及pool11层后面接了priorbox层，priorbox层的主要目的是根据输入的特征图（feature map）生成一系列的矩形候选框。关于SSD的更详细的介绍可以参考论文\[[1](#引用)\]。
下图为模型（300x300）的总体结构： ## SSD Architecture
SSD uses a convolutional neural network to achieve end-to-end detection. The term "End-to-end" is used because it uses the input as the original image and the output for the test results, without the use of external tools or processes for feature extraction. One popular model of SSD is VGG16 [ 2 ]. SSD differs from VGG16 network model as in following.
1. The final fc6, fc7 full connection layer into a convolution layer, convolution layer parameters through the original fc6, fc7 parameters obtained.
2. Change the parameters of the pool5 layer from 2x2-s2 (kernel size 2x2, stride size to 2) to 3x3-s1-p1 (kernel size is 3x3, stride size is 1, padding size is 1).
3. The initial layers are composed of conv4\_3、conv7、conv8\_2、conv9\_2、conv10\_2, and pool11 layers. The main purpose of the priorbox layer is to generate a series of rectangular candidates based on the input feature map. A more detailed introduction to SSD can be found in the paper\[[1](#References)\]。
Below is the overall structure of the model (300x300)
<p align="center"> <p align="center">
<img src="images/ssd_network.png" width="900" height="250" hspace='10'/> <br/> <img src="images/ssd_network.png" width="900" height="250" hspace='10'/> <br/>
图1. SSD网络结构 图1. SSD网络结构
</p> </p>
图中每个矩形盒子代表一个卷积层，最后的两个矩形框分别表示汇总各卷积层输出结果和后处理阶段。具体地，在预测阶段网络会输出一组候选矩形框，每个矩形包含两类信息：位置和类别得分，图中倒数第二个矩形框即表示网络的检测结果的汇总处理，由于候选矩形框数量较多且很多矩形框重叠严重，这时需要经过后处理来筛选出质量较高的少数矩形框，这里的后处理主要指非极大值抑制（Non-maximum Suppression）。 Each box in the figure represents a convolution layer, and the last two rectangles represent the summary of each convolution layer output and the post-processing phase. Specifically, the network will output a set of candidate rectangles in the prediction phase. Each rectangle contains two types of information: the position and the category score. The network produces thousands of predictions at various scales and aspect ratios before performing non-maximum suppression, resulting in a handful of final tags.
从SSD的网络结构可以看出，候选矩形框在多个特征图（feature map上）生成，不同的feature map具有的感受野不同，这样可以在不同尺度扫描图像，相对于其他检测方法可以生成更丰富的候选框，从而提高检测精度；另一方面SSD对VGG16的扩展部分以较小的代价实现对候选框的位置和类别得分的计算，整个过程只需要一个卷积神经网络完成，所以速度较快。
## 示例总览 ## Example Overview
本示例共包含如下文件： This example contains the following files:
<table> <table>
<caption>表1. 示例文件</caption> <caption>Table 1. Directory structure</caption>
<tr><th>文件</th><th>用途</th></tr> <tr><th>File</th><th>Description</th></tr>
<tr><td>train.py</td><td>训练脚本</td></tr> <tr><td>train.py</td><td>Training script</td></tr>
<tr><td>eval.py</td><td>评估脚本，用于评估训好模型</td></tr> <tr><td>eval.py</td><td>Evaluation</td></tr>
<tr><td>infer.py</td><td>检测脚本，给定图片及模型，实施检测</td></tr> <tr><td>infer.py</td><td>Prediction using the trained model</tr>
<tr><td>visual.py</td><td>检测结果可视化</td></tr> <tr><td>visual.py</td><td>Visualization of the test results</td></tr>
<tr><td>image_util.py</td><td>图像预处理所需公共函数</td></tr> <tr><td>image_util.py</td><td>Image preprocessing required common function</td></tr>
<tr><td>data_provider.py</td><td>数据处理脚本，生成训练、评估或检测所需数据</td></tr> <tr><td>data_provider.py</td><td>Data processing scripts, generate training, evaluate or detect the required data</td></tr>
<tr><td>config/pascal_voc_conf.py</td><td>神经网络超参数配置文件</td></tr> <tr><td>config/pascal_voc_conf.py</td><td> Neural network hyperparameter configuration file</td></tr>
<tr><td>data/label_list</td><td>类别列表</td></tr> <tr><td>data/label_list</td><td>Label list</td></tr>
<tr><td>data/prepare_voc_data.py</td><td>准备训练PASCAL VOC数据列表</td></tr> <tr><td>data/prepare_voc_data.py</td><td>Prepare training PASCAL VOC data list</td></tr>
</table> </table>
训练阶段需要对数据做预处理，包括裁剪、采样等，这部分操作在```image_util.py```和```data_provider.py```中完成。值得注意的是，```config/vgg_config.py```为参数配置文件，包括训练参数、神经网络参数等，本配置文件包含参数是针对PASCAL VOC数据配置的，当训练自有数据时，需要仿照该文件配置新的参数。```data/prepare_voc_data.py```脚本用来生成文件列表，包括切分训练集和测试集，使用时需要用户事先下载并解压数据，默认采用VOC2007和VOC2012。 The training phase requires pre-processing of the data, including clipping, sampling, etc. This is done in ```image_util.py``` and ```data_provider.py```.```config/vgg_config.py```. ```data/prepare_voc_data.py``` is used to generate a list of files, including the training set and test set, the need to use the user to download and extract data, the default use of VOC2007 and VOC2012.
## PASCAL VOC数据集 ## PASCAL VOC Data set
### 数据准备
首先需要下载数据集，VOC2007\[[3](#引用)\]和VOC2012\[[4](#引用)\]，VOC2007包含训练集和测试集，VOC2012只包含训练集，将下载好的数据解压，目录结构为```data/VOCdevkit/VOC2007```和```data/VOCdevkit/VOC2012```。进入```data```目录，运行```python prepare_voc_data.py```即可生成```trainval.txt```和```test.txt```。核心函数为： ### Data Preparation
First download the data set. VOC2007\[[3](#References)\] contains both training and test data set, and VOC2012\[[4](#References)\] contains only training set. Downloaded data are stored in ```data/VOCdevkit/VOC2007``` and ```data/VOCdevkit/VOC2012```. Next, run ```data/prepare_voc_data.py``` to generate ```trainval.txt``` and ```test.txt```. The relevant function is as following:
```python ```python
def prepare_filelist(devkit_dir, years, output_dir): def prepare_filelist(devkit_dir, years, output_dir):
...@@ -102,7 +103,7 @@ def prepare_filelist(devkit_dir, years, output_dir): ...@@ -102,7 +103,7 @@ def prepare_filelist(devkit_dir, years, output_dir):
ftest.write(item[0] + ' ' + item[1] + '\n') ftest.write(item[0] + ' ' + item[1] + '\n')
``` ```
该函数首先对每一年（year）的数据进行处理，然后将训练图像的文件路径列表进行随机打乱，最后保存训练文件列表和测试文件列表。默认```prepare_voc_data.py```和```VOCdevkit```在相同目录下，且生成的文件列表也在该目录。需注意```trainval.txt```既包含VOC2007的训练数据，也包含VOC2012的训练数据，```test.txt```只包含VOC2007的测试数据。我们这里提供```trainval.txt```前几行输入作为样例： The data in ```trainval.txt``` will look like:
``` ```
VOCdevkit/VOC2007/JPEGImages/000005.jpg VOCdevkit/VOC2007/Annotations/000005.xml VOCdevkit/VOC2007/JPEGImages/000005.jpg VOCdevkit/VOC2007/Annotations/000005.xml
...@@ -110,12 +111,14 @@ VOCdevkit/VOC2007/JPEGImages/000007.jpg VOCdevkit/VOC2007/Annotations/000007.xml ...@@ -110,12 +111,14 @@ VOCdevkit/VOC2007/JPEGImages/000007.jpg VOCdevkit/VOC2007/Annotations/000007.xml
VOCdevkit/VOC2007/JPEGImages/000009.jpg VOCdevkit/VOC2007/Annotations/000009.xml VOCdevkit/VOC2007/JPEGImages/000009.jpg VOCdevkit/VOC2007/Annotations/000009.xml
``` ```
文件共两个字段，第一个字段为图像文件的相对路径，第二个字段为对应标注文件的相对路径。 The first field is the relative path of the image file, and the second field is the relative path of the corresponding label file.
### 预训练模型准备 ### To Use Pre-trained Model
下载预训练的VGG-16模型，我们提供了一个转换好的模型，具体下载地址为：http://paddlepaddle.bj.bcebos.com/model_zoo/detection/ssd_model/vgg_model.tar.gz ，下载好模型后，放置路径为```vgg/vgg_model.tar.gz```。 We also provide a pre-trained model using VGG-16 with good performance. To use the model, download the file http://paddlepaddle.bj.bcebos.com/model_zoo/detection/ssd_model/vgg_model.tar.gz, and place it as ```vgg/vgg_model.tar.gz```。
### 模型训练
直接执行```python train.py```即可进行训练。需要注意本示例仅支持CUDA GPU环境，无法在CPU上训练，主要因为使用CPU训练速度很慢，实践中一般使用GPU来处理图像任务，这里实现采用硬编码方式使用cuDNN，不提供CPU版本。```train.py```的一些关键执行逻辑： ### Training
Next, run ```python train.py``` to train the model. Note that this example only supports the CUDA GPU environment, and can not be trained using only CPU. This is mainly because the training is very slow using CPU only.
```python ```python
paddle.init(use_gpu=True, trainer_count=4) paddle.init(use_gpu=True, trainer_count=4)
...@@ -131,14 +134,14 @@ train(train_file_list='./data/trainval.txt', ...@@ -131,14 +134,14 @@ train(train_file_list='./data/trainval.txt',
init_model_path='./vgg/vgg_model.tar.gz') init_model_path='./vgg/vgg_model.tar.gz')
``` ```
主要包括： Below is a description about this script:
1. 调用```paddle.init```指定使用4卡GPU训练。 1. Call ```paddle.init``` with 4 GPUs.
2. 调用```data_provider.Settings```配置数据预处理所需参数，其中```cfg.IMG_HEIGHT```和```cfg.IMG_WIDTH```在配置文件```config/vgg_config.py```中设置，这里均为300，300x300是一个典型配置，兼顾效率和检测精度，也可以通过修改配置文件扩展到512x512。 2. ```data_provider.Settings()``` is to pass configuration parameters. For ```config/vgg_config.py``` setting，300x300 is a typical configuration for both the accuracy and efficiency. It can be extended to 512x512 by modifying the configuration file.
3. 调用```train```执行训练，其中```train_file_list```指定训练数据列表，```dev_file_list```指定评估数据列表，```init_model_path```指定预训练模型位置。 3. In ```train()```执 function, ```train_file_list``` specifies the training data list, and ```dev_file_list``` specifies the evaluation data list, and ```init_model_path``` specifies the pre-training model location.
4. 训练过程中会打印一些日志信息，每训练1个batch会输出当前的轮数、当前batch的cost及mAP（mean Average Precision，平均精度均值），每训练一个pass，会保存一次模型，默认保存在```checkpoints```目录下（注：需事先创建）。 4. During the training process will print some log information, each training a batch will output the current number of rounds, the current batch cost and mAP (mean Average Precision. Each training pass will be saved a model to the default saved directory ```checkpoints``` (Need to be created in advance).
下面给出SDD300x300在VOC数据集（train包括07+12，test为07）上的mAP曲线，迭代140轮mAP可达到71.52%。 The following shows the SDD300x300 in the VOC data set.
<p align="center"> <p align="center">
<img src="images/SSD300x300_map.png" hspace='10'/> <br/> <img src="images/SSD300x300_map.png" hspace='10'/> <br/>
...@@ -146,8 +149,8 @@ train(train_file_list='./data/trainval.txt', ...@@ -146,8 +149,8 @@ train(train_file_list='./data/trainval.txt',
</p> </p>
### 模型评估 ### Model Assessment
执行```python eval.py```即可对模型进行评估，```eval.py```的关键执行逻辑如下： Next, run ```python eval.py``` to evaluate the model.
```python ```python
paddle.init(use_gpu=True, trainer_count=4) # use 4 gpus paddle.init(use_gpu=True, trainer_count=4) # use 4 gpus
...@@ -166,10 +169,8 @@ eval( ...@@ -166,10 +169,8 @@ eval(
model_path='models/pass-00000.tar.gz') model_path='models/pass-00000.tar.gz')
``` ```
调用```paddle.init```指定使用4卡GPU评估；```data_provider.Settings```参见训练阶段的配置；调用```eval```执行评估，其中```eval_file_list```指定评估数据列表，```batch_size```指定评估时batch size的大小，```model_path ```指定模型位置。评估结束会输出```loss```信息和```mAP```信息。 ### Obejct Detection
Run ```python infer.py``` to perform the object detection using the trained model.
### 图像检测
执行```python infer.py```即可使用训练好的模型对图片实施检测，```infer.py```关键逻辑如下：
```python ```python
infer( infer(
...@@ -181,7 +182,9 @@ infer( ...@@ -181,7 +182,9 @@ infer(
threshold=0.3) threshold=0.3)
``` ```
其中```eval_file_list```指定图像路径列表；```save_path```指定预测结果保存路径；```data_args```如上；```batch_size```为每多少样本预测一次；```model_path```指模型的位置；```threshold```为置信度阈值，只有得分大于或等于该值的才会输出。下面给出```infer.res```的一些输出样例：
Here ```eval_file_list``` specified image path list, ```save_path``` specifies directory to save the prediction result.
``` ```
VOCdevkit/VOC2007/JPEGImages/006936.jpg 12 0.997844 131.255611777 162.271582842 396.475315094 334.0 VOCdevkit/VOC2007/JPEGImages/006936.jpg 12 0.997844 131.255611777 162.271582842 396.475315094 334.0
...@@ -192,19 +195,19 @@ VOCdevkit/VOC2007/JPEGImages/006936.jpg 14 0.372522 187.543615699 133.727034628 ...@@ -192,19 +195,19 @@ VOCdevkit/VOC2007/JPEGImages/006936.jpg 14 0.372522 187.543615699 133.727034628
一共包含4个字段，以tab分割，第一个字段是检测图像路径，第二字段为检测矩形框内类别，第三个字段是置信度，第四个字段是4个坐标值（以空格分割）。 一共包含4个字段，以tab分割，第一个字段是检测图像路径，第二字段为检测矩形框内类别，第三个字段是置信度，第四个字段是4个坐标值（以空格分割）。
示例还提供了一个可视化脚本，直接运行```python visual.py```即可，须指定输出检测结果路径及输出目录，默认可视化后图像保存在```./visual_res```，下面是用训练好的模型infer部分图像并可视化的效果： Below is the example after running ```python visual.py``` to visualize the model result. The default visualization of the image saved in the ```./visual_res```.
<p align="center"> <p align="center">
<img src="images/vis_1.jpg" height=150 width=200 hspace='10'/> <img src="images/vis_1.jpg" height=150 width=200 hspace='10'/>
<img src="images/vis_2.jpg" height=150 width=200 hspace='10'/> <img src="images/vis_2.jpg" height=150 width=200 hspace='10'/>
<img src="images/vis_3.jpg" height=150 width=100 hspace='10'/> <img src="images/vis_3.jpg" height=150 width=100 hspace='10'/>
<img src="images/vis_4.jpg" height=150 width=200 hspace='10'/> <br /> <img src="images/vis_4.jpg" height=150 width=200 hspace='10'/> <br />
图3. SSD300x300 检测可视化示例 Figure 3. SSD300x300 Visualization Example
</p> </p>
## 自有数据集 ## To Use Custo Data set
在自有数据上训练PaddlePaddle SSD需要完成两个关键准备，首先需要适配网络可以接受的输入格式，这里提供一个推荐的结构，以```train.txt```为例 In PaddlePaddle, using the custom data set to train SSD model is also easy! Just input the format that ```train.txt``` can understand. Below is a recommended structure to input for ```train.txt```.
``` ```
image00000_file_path image00000_annotation_file_path image00000_file_path image00000_annotation_file_path
...@@ -213,7 +216,7 @@ image00002_file_path image00002_annotation_file_path ...@@ -213,7 +216,7 @@ image00002_file_path image00002_annotation_file_path
... ...
``` ```
文件共两列，以空白符分割，第一列为图像文件的路径，第二列为对应标注数据的文件路径。对图像文件的读取比较直接，略微复杂的是对标注数据的解析，本示例中标注数据使用xml文件存储，所以需要在```data_provider.py```中对xml解析，核心逻辑如下： The first column is for the image file path, and the second column for the corresponding marked data file path. In the case of using xml file format, ```data_provider.py``` can be used to process the data as follows.
```python ```python
bbox_labels = [] bbox_labels = []
...@@ -233,7 +236,7 @@ for object in root.findall('object'): ...@@ -233,7 +236,7 @@ for object in root.findall('object'):
bbox_labels.append(bbox_sample) bbox_labels.append(bbox_sample)
``` ```
这里一条标注数据包括：label、xmin、ymin、xmax、ymax和is\_difficult，is\_difficult表示该object是否为难例，实际中如果不需要，只需把该字段置零即可。自有数据也需要提供对应的解析逻辑，假设标注数据（比如image00000\_annotation\_file\_path）存储格式如下： Now the marked data（e.g. image00000\_annotation\_file\_path）is as follows:
``` ```
label1 xmin1 ymin1 xmax1 ymax1 label1 xmin1 ymin1 xmax1 ymax1
...@@ -241,7 +244,7 @@ label2 xmin2 ymin2 xmax2 ymax2 ...@@ -241,7 +244,7 @@ label2 xmin2 ymin2 xmax2 ymax2
... ...
``` ```
每行对应一个物体，共5个字段，第一个为label（注背景为0，需从1编号），剩余4个为坐标，对应的解析逻辑可更改为如下： Here each row corresponds to an object for 5 fields. The first is for the label (note the background 0, need to be numbered from 1), and the remaining four are for the coordinates.
``` ```
bbox_labels = [] bbox_labels = []
...@@ -259,9 +262,9 @@ with open(label_path) as flabel: ...@@ -259,9 +262,9 @@ with open(label_path) as flabel:
bbox_labels.append(bbox_sample) bbox_labels.append(bbox_sample)
``` ```
另一个重要的事情就是根据图像大小及检测物体的大小等更改网络结构的配置，主要是仿照```config/vgg_config.py```创建自己的配置文件，参数设置经验请参照论文\[[1](#引用)\]。 Another important thing is to change the size of the image and the size of the object to change the configuration of the network structure. Use ```config/vgg_config.py``` to create the custom configuration file. For more details, please refer to \[[1](#References)\]。
## 引用 ## References
1. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg. [SSD: Single shot multibox detector](https://arxiv.org/abs/1512.02325). European conference on computer vision. Springer, Cham, 2016. 1. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg. [SSD: Single shot multibox detector](https://arxiv.org/abs/1512.02325). European conference on computer vision. Springer, Cham, 2016.
2. Simonyan, Karen, and Andrew Zisserman. [Very deep convolutional networks for large-scale image recognition](https://arxiv.org/abs/1409.1556). arXiv preprint arXiv:1409.1556 (2014). 2. Simonyan, Karen, and Andrew Zisserman. [Very deep convolutional networks for large-scale image recognition](https://arxiv.org/abs/1409.1556). arXiv preprint arXiv:1409.1556 (2014).
3. [The PASCAL Visual Object Classes Challenge 2007](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html) 3. [The PASCAL Visual Object Classes Challenge 2007](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html)
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或