Merge pull request #4823 from luotao1/doc

remove duplicated doc/tutorials, and rename tutorials to v1_api_tutorials
7 years ago · 8fe7bf3802
parent 5c5250e3e0 8fd07c9661
commit 8fe7bf3802
67 changed files with 10 additions and 3106 deletions
--- a/doc/howto/deep_model/rnn/rnn_config_cn.rst
+++ b/doc/howto/deep_model/rnn/rnn_config_cn.rst
@ -21,7 +21,7 @@ wmt14数据的提供文件在 `python/paddle/v2/dataset/wmt14.py <https://github
 循环神经网络在每个时间步骤顺序地处理序列。下面列出了 LSTM 的架构的示例。
-.. image:: ../../../tutorials/sentiment_analysis/bi_lstm.jpg
+.. image:: src/bi_lstm.jpg
      :align: center
 一般来说，循环网络从 :math:`t=1` 到 :math:`t=T` 或者反向地从 :math:`t=T` 到 :math:`t=1` 执行以下操作。
@ -96,7 +96,7 @@ Sequence to Sequence Model with Attention
 我们将使用 sequence to sequence model with attention
 作为例子演示如何配置复杂的循环神经网络模型。该模型的说明如下图所示。
-.. image:: ../../../tutorials/text_generation/encoder-decoder-attention-model.png
+.. image:: src/encoder-decoder-attention-model.png
      :align: center
 在这个模型中，源序列 :math:`S = \{s_1, \dots, s_T\}` 
--- a/doc/howto/deep_model/rnn/rnn_config_en.rst
+++ b/doc/howto/deep_model/rnn/rnn_config_en.rst
@ -19,7 +19,7 @@ Simple Gated Recurrent Neural Network
 Recurrent neural network process a sequence at each time step sequentially. An example of the architecture of LSTM is listed below.
-.. image:: ../../../tutorials/sentiment_analysis/src/bi_lstm.jpg
+.. image:: src/bi_lstm.jpg
     :align: center
 Generally speaking, a recurrent network perform the following operations from :math:`t=1` to :math:`t=T`, or reversely from :math:`t=T` to :math:`t=1`.
@ -78,7 +78,7 @@ Sequence to Sequence Model with Attention
 -----------------------------------------
 We will use the sequence to sequence model with attention as an example to demonstrate how you can configure complex recurrent neural network models. An illustration of the sequence to sequence model with attention is shown in the following figure.
-.. image:: ../../../tutorials/text_generation/encoder-decoder-attention-model.png
+.. image:: src/encoder-decoder-attention-model.png
      :align: center
 In this model, the source sequence :math:`S = \{s_1, \dots, s_T\}` is encoded with a bidirectional gated recurrent neural networks. The hidden states of the bidirectional gated recurrent neural network :math:`H_S = \{H_1, \dots, H_T\}` is called *encoder vector* The decoder is a gated recurrent neural network. When decoding each token :math:`y_t`, the gated recurrent neural network generates a set of weights :math:`W_S^t = \{W_1^t, \dots, W_T^t\}`, which are used to compute a weighted sum of the encoder vector. The weighted sum of the encoder vector is utilized to condition the generation of the token :math:`y_t`.
--- a/doc/tutorials/sentiment_analysis/bi_lstm.jpg
+++ b/doc/tutorials/sentiment_analysis/bi_lstm.jpg
--- a/doc/tutorials/text_generation/encoder-decoder-attention-model.png
+++ b/doc/tutorials/text_generation/encoder-decoder-attention-model.png
--- a/doc/tutorials/image_classification/cifar.png
+++ b/doc/tutorials/image_classification/cifar.png
--- a/doc/tutorials/image_classification/image_classification.png
+++ b/doc/tutorials/image_classification/image_classification.png
--- a/doc/tutorials/image_classification/index_cn.md
+++ b/doc/tutorials/image_classification/index_cn.md
@ -1,205 +0,0 @@
 图像分类教程
 ==========
 在本教程中，我们将使用CIFAR-10数据集训练一个卷积神经网络，并使用这个神经网络来对图片进行分类。如下图所示，卷积神经网络可以辨识图片中的主体，并给出分类结果。
 <center>![Image Classification](./image_classification.png)</center>
 ## 数据准备
 首先下载CIFAR-10数据集。下面是CIFAR-10数据集的官方网址：
 <https://www.cs.toronto.edu/~kriz/cifar.html>
 我们准备了一个脚本，可以用于从官方网站上下载CIFAR-10数据集，转为jpeg文件并存入特定的目录。使用这个脚本前请确认已经安装了pillow及相关依赖模块。可以参照下面的命令进行安装：
 1. 安装pillow
 ```bash
 sudo apt-get install libjpeg-dev
 pip install pillow
 ```
 2. 下载数据集
 ```bash
 cd demo/image_classification/data/
 sh download_cifar.sh
 ```
 CIFAR-10数据集包含60000张32x32的彩色图片。图片分为10类，每个类包含6000张。其中50000张图片作为训练集，10000张作为测试集。
 下图展示了所有的图片类别，每个类别中随机抽取了10张图片。
 <center>![Image Classification](./cifar.png)</center>
 脚本运行完成后，我们应当会得到一个名为cifar-out的文件夹，其下子文件夹的结构如下
 ```
 train
 ---airplane
 ---automobile
 ---bird
 ---cat
 ---deer
 ---dog
 ---frog
 ---horse
 ---ship
 ---truck
 test
 ---airplane
 ---automobile
 ---bird
 ---cat
 ---deer
 ---dog
 ---frog
 ---horse
 ---ship
 ---truck
 ```
 cifar-out下包含`train`和`test`两个文件夹，其中分别包含了CIFAR-10中的训练集和测试集。这两个文件夹下各自有10个子文件夹，每个子文件夹下存储相应分类的图片。将图片按照上述结构存储好之后，我们就可以着手对分类模型进行训练了。
 ## 预处理
 数据下载之后，还需要进行预处理，将数据转换为Paddle的格式。我们可以通过如下命令进行预处理工作：
 ```
 cd demo/image_classification/
 sh preprocess.sh
 ```
 其中`preprocess.sh` 调用 `./demo/image_classification/preprocess.py` 对图片进行预处理
 ```sh
 export PYTHONPATH=$PYTHONPATH:../../
 data_dir=./data/cifar-out
 python preprocess.py -i $data_dir -s 32 -c 1
 ```
 `./demo/image_classification/preprocess.py` 使用如下参数：
 - `-i` 或 `--input` 给出输入数据所在路径；
 - `-s` 或 `--size` 给出图片尺寸；
 - `-c` 或 `--color` 标示图片是彩色图或灰度图
 ## 模型训练
 在开始训练之前，我们需要先创建一个模型配置文件。下面我们给出了一个配置示例。**注意**，这里的列出的和`vgg_16_cifar.py`文件稍有差别，因为该文件可适用于预测。
 ```python
 from paddle.trainer_config_helpers import *
 data_dir='data/cifar-out/batches/'
 meta_path=data_dir+'batches.meta'
 args = {'meta':meta_path, 'mean_img_size': 32,
        'img_size': 32, 'num_classes': 10,
        'use_jpeg': 1, 'color': "color"}
 define_py_data_sources2(train_list=data_dir+"train.list",
                        test_list=data_dir+'test.list',
                        module='image_provider',
                        obj='processData',
                        args=args)
 settings(
    batch_size = 128,
    learning_rate = 0.1 / 128.0,
    learning_method = MomentumOptimizer(0.9),
    regularization = L2Regularization(0.0005 * 128))
 img = data_layer(name='image', size=3*32*32)
 lbl = data_layer(name="label", size=10)
 # small_vgg is predined in trainer_config_helpers.network
 predict = small_vgg(input_image=img, num_channels=3)
 outputs(classification_cost(input=predict, label=lbl))
 ```
 在第一行中我们载入用于定义网络的函数。
 ```python
 from paddle.trainer_config_helpers import *
 ```
 之后定义的`define_py_data_sources2`使用Python数据提供器，其中 `args`将在`image_provider.py`进行使用，该文件负责产生图片数据并传递给Paddle系统
 - `meta`: 训练集平均值。
 - `mean_img_size`: 平均特征图的高度及宽度。
 - `img_size`：输入图片的高度及宽度。
 - `num_classes`：类别个数。
 - `use_jpeg`：处理过程中数据存储格式。
 - `color`：标示是否为彩色图片。
 `settings`用于设置训练算法。在下面的例子中，learning rate被设置为0.1除以batch size，而weight decay则为0.0005乘以batch size。
 ```python
 settings(
    batch_size = 128,
    learning_rate = 0.1 / 128.0,
    learning_method = MomentumOptimizer(0.9),
    regularization = L2Regularization(0.0005 * 128)
 )
 ```
 `small_vgg`定义了网络结构。这里我们使用的是一个小的VGG网络。关于VGG卷积神经网络的描述可以参考：[http://www.robots.ox.ac.uk/~vgg/research/very_deep/](http://www.robots.ox.ac.uk/~vgg/research/very_deep/)。
 ```python
 # small_vgg is predined in trainer_config_helpers.network
 predict = small_vgg(input_image=img, num_channels=3)
 ```
 配置创建完毕后，可以运行脚本train.sh来训练模型。
 ```bash
 config=vgg_16_cifar.py
 output=./cifar_vgg_model
 log=train.log
 paddle train \
 --config=$config \
 --dot_period=10 \
 --log_period=100 \
 --test_all_data_in_one_period=1 \
 --use_gpu=1 \
 --save_dir=$output \
 2>&1 | tee $log
 python -m paddle.utils.plotcurve -i $log > plot.png
 ```
 - 这里我们使用的是GPU模式进行训练。如果你没有GPU环境，可以设置`use_gpu=0`。
 - `./demo/image_classification/vgg_16_cifar.py`是网络和数据配置文件。各项参数的详细说明可以在命令行参数相关文档中找到。
 - 脚本`plotcurve.py`依赖于python的`matplotlib`模块。因此如果这个脚本运行失败，也许是因为需要安装`matplotlib`。
 在训练完成后，训练及测试误差曲线图会被`plotcurve.py`脚本保存在 `plot.png`中。下面是一个误差曲线图的示例：
 <center>![Training and testing curves.](./plot.png)</center>
 ## 预测
 在训练完成后，模型及参数会被保存在路径`./cifar_vgg_model/pass-%05d`下。例如第300个pass的模型会被保存在`./cifar_vgg_model/pass-00299`。
 要对一个图片的进行分类预测，我们可以使用`predict.sh`，该脚本将输出预测分类的标签：
 ```
 sh predict.sh
 ```
 predict.sh:
 ```
 model=cifar_vgg_model/pass-00299/
 image=data/cifar-out/test/airplane/seaplane_s_000978.png
 use_gpu=1
 python prediction.py $model $image $use_gpu
 ```
 ## 练习
 在CUB-200数据集上使用VGG模型训练一个鸟类图片分类模型。相关的鸟类数据集可以从如下地址下载，其中包含了200种鸟类的照片（主要来自北美洲）。
 <http://www.vision.caltech.edu/visipedia/CUB-200.html>
 ## 细节探究
 ### 卷积神经网络
 卷积神经网络是一种使用卷积层的前向神经网络，很适合构建用于理解图片内容的模型。一个典型的神经网络如下图所示：
 ![Convolutional Neural Network](./lenet.png)
 一个卷积神经网络包含如下层：
 - 卷积层：通过卷积操作从图片或特征图中提取特征
 - 池化层：使用max-pooling对特征图下采样
 - 全连接层：使输入层到隐藏层的神经元是全部连接的。
 卷积神经网络在图片分类上有着惊人的性能，这是因为它发掘出了图片的两类重要信息：局部关联性质和空间不变性质。通过交替使用卷积和池化处理， 卷积神经网络能够很好的表示这两类信息。
 关于如何定义网络中的层，以及如何在层之间进行连接，请参考Layer文档。
--- a/doc/tutorials/image_classification/index_en.md
+++ b/doc/tutorials/image_classification/index_en.md
@ -1,221 +0,0 @@
 Image Classification Tutorial
 ==============================
 This tutorial will guide you through training a convolutional neural network to classify objects using the CIFAR-10 image classification dataset.
 As shown in the following figure, the convolutional neural network can recognize the main object in images, and output the classification result.
 <center>![Image Classification](./image_classification.png)</center>
 ## Data Preparation
 First, download CIFAR-10 dataset. CIFAR-10 dataset can be downloaded from its official website.
 <https://www.cs.toronto.edu/~kriz/cifar.html>
 We have prepared a script to download and process CIFAR-10 dataset. The script will download CIFAR-10 dataset from the official dataset.
 It will convert it to jpeg images and organize them into a directory with the required structure for the tutorial. Make sure that you have installed pillow and its dependents.
 Consider the following commands:
 1. install pillow dependents
 ```bash
 sudo apt-get install libjpeg-dev
 pip install pillow
 ```
 2. download data and preparation
 ```bash
 cd demo/image_classification/data/
 sh download_cifar.sh
 ```
 The CIFAR-10 dataset consists of 60000 32x32 color images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images.
 Here are the classes in the dataset, as well as 10 random images from each:
 <center>![Image Classification](./cifar.png)</center>
 After downloading and converting, we should find a directory (cifar-out) containing the dataset in the following format:
 ```
 train
 ---airplane
 ---automobile
 ---bird
 ---cat
 ---deer
 ---dog
 ---frog
 ---horse
 ---ship
 ---truck
 test
 ---airplane
 ---automobile
 ---bird
 ---cat
 ---deer
 ---dog
 ---frog
 ---horse
 ---ship
 ---truck
 ```
 It has two directories:`train` and `test`. These two directories contain training data and testing data of CIFAR-10, respectively. Each of these two folders contains 10 sub-folders, ranging from `airplane` to `truck`. Each sub-folder contains images with the corresponding label. After the images are organized into this structure, we are ready to train an image classification model.
 ## Preprocess
 After the data has been downloaded, it needs to be pre-processed into the Paddle format. We can run the following command for preprocessing.
 ```
 cd demo/image_classification/
 sh preprocess.sh
 ```
 `preprocess.sh` calls `./demo/image_classification/preprocess.py` to preprocess image data.
 ```sh
 export PYTHONPATH=$PYTHONPATH:../../
 data_dir=./data/cifar-out
 python preprocess.py -i $data_dir -s 32 -c 1
 ```
 `./demo/image_classification/preprocess.py` has the following arguments
 - `-i` or `--input` specifes  the input data directory.
 - `-s` or `--size` specifies the processed size of images.
 - `-c` or `--color` specifes whether images are color images or gray images.
 ## Model Training
 We need to create a model config file before training the model. An example of the config file (vgg_16_cifar.py) is listed below. **Note**, it is slightly different from the `vgg_16_cifar.py` which also applies to the prediction.
 ```python
 from paddle.trainer_config_helpers import *
 data_dir='data/cifar-out/batches/'
 meta_path=data_dir+'batches.meta'
 args = {'meta':meta_path, 'mean_img_size': 32,
        'img_size': 32, 'num_classes': 10,
        'use_jpeg': 1, 'color': "color"}
 define_py_data_sources2(train_list=data_dir+"train.list",
                        test_list=data_dir+'test.list',
                        module='image_provider',
                        obj='processData',
                        args=args)
 settings(
    batch_size = 128,
    learning_rate = 0.1 / 128.0,
    learning_method = MomentumOptimizer(0.9),
    regularization = L2Regularization(0.0005 * 128))
 img = data_layer(name='image', size=3*32*32)
 lbl = data_layer(name="label", size=10)
 # small_vgg is predined in trainer_config_helpers.network
 predict = small_vgg(input_image=img, num_channels=3)
 outputs(classification_cost(input=predict, label=lbl))
 ```
 The first line imports python functions for defining networks.
 ```python
 from paddle.trainer_config_helpers import *
 ```
 Then define an `define_py_data_sources2` which use python data provider
 interface. The arguments in `args` are used in `image_provider.py` which
 yeilds image data and transform them to Paddle.
 - `meta`: the mean value of training set.
 - `mean_img_size`: the size of mean feature map.
 - `img_size`: the height and width of input image.
 - `num_classes`: the number of classes.
 - `use_jpeg`: the data storage type when preprocessing.
 - `color`: specify color image.
 `settings` specifies the training algorithm. In the following example,
 it specifies learning rate as 0.1, but divided by batch size, and the weight decay
 is 0.0005 and multiplied by batch size.
 ```python
 settings(
    batch_size = 128,
    learning_rate = 0.1 / 128.0,
    learning_method = MomentumOptimizer(0.9),
    regularization = L2Regularization(0.0005 * 128)
 )
 ```
 The `small_vgg` specifies the network. We use a small version of VGG convolutional network as our network
 for classification. A description of VGG network can be found here [http://www.robots.ox.ac.uk/~vgg/research/very_deep/](http://www.robots.ox.ac.uk/~vgg/research/very_deep/).
 ```python
 # small_vgg is predined in trainer_config_helpers.network
 predict = small_vgg(input_image=img, num_channels=3)
 ```
 After writing the config, we can train the model by running the script train.sh.
 ```bash
 config=vgg_16_cifar.py
 output=./cifar_vgg_model
 log=train.log
 paddle train \
 --config=$config \
 --dot_period=10 \
 --log_period=100 \
 --test_all_data_in_one_period=1 \
 --use_gpu=1 \
 --save_dir=$output \
 2>&1 | tee $log
 python -m paddle.utils.plotcurve -i $log > plot.png
 ```
 - Here we use GPU mode to train. If you have no gpu environment, just set `use_gpu=0`.
 - `./demo/image_classification/vgg_16_cifar.py` is the network and data configuration file. The meaning of the other flags can be found in the documentation of the command line flags.
 - The script `plotcurve.py` requires the python module of `matplotlib`, so if it fails, maybe you need to install `matplotlib`.
 After training finishes, the training and testing error curves will be saved to `plot.png` using `plotcurve.py` script. An example of the plot is shown below:
 <center>![Training and testing curves.](./plot.png)</center>
 ## Prediction
 After we train the model, the model file as well as the model parameters are stored in path `./cifar_vgg_model/pass-%05d`. For example, the model of the 300-th pass is stored at `./cifar_vgg_model/pass-00299`.
 To make a prediction for an image, one can run `predict.sh` as follows. The script will output the label of the classfiication.
 ```
 sh predict.sh
 ```
 predict.sh:
 ```
 model=cifar_vgg_model/pass-00299/
 image=data/cifar-out/test/airplane/seaplane_s_000978.png
 use_gpu=1
 python prediction.py $model $image $use_gpu
 ```
 ## Exercise
 Train a image classification of birds using VGG model and CUB-200 dataset. The birds dataset can be downloaded here. It contains an image dataset with photos of 200 bird species (mostly North American).
 <http://www.vision.caltech.edu/visipedia/CUB-200.html>
 ## Delve into Details
 ### Convolutional Neural Network
 A Convolutional Neural Network is a feedforward neural network that uses convolution layers. It is very suitable for building neural networks that process and understand images. A standard convolutional neural network is shown below:
 ![Convolutional Neural Network](./lenet.png)
 Convolutional Neural Network contains the following layers:
 - Convolutional layer: It uses convolution operation to extract features from an image or a feature map.
 - Pooling layer: It uses max-pooling to downsample feature maps.
 - Fully Connected layer: It uses fully connected connections to transform features.
 Convolutional Neural Network achieves amazing performance for image classification because it exploits two important characteristics of images: *local correlation* and *spatial invariance*. By iteratively applying convolution and max-pooing operations, convolutional neural network can well represent these two characteristics of images.
 For more details of how to define layers and their connections, please refer to the documentation of layers.
--- a/doc/tutorials/image_classification/lenet.png
+++ b/doc/tutorials/image_classification/lenet.png
--- a/doc/tutorials/image_classification/plot.png
+++ b/doc/tutorials/image_classification/plot.png
--- a/doc/tutorials/image_classification/src/cifar.png
+++ b/doc/tutorials/image_classification/src/cifar.png
--- a/doc/tutorials/image_classification/src/image_classification.png
+++ b/doc/tutorials/image_classification/src/image_classification.png
--- a/doc/tutorials/image_classification/src/lenet.png
+++ b/doc/tutorials/image_classification/src/lenet.png
--- a/doc/tutorials/image_classification/src/plot.png
+++ b/doc/tutorials/image_classification/src/plot.png
--- a/doc/tutorials/index_cn.md
+++ b/doc/tutorials/index_cn.md
@ -1,13 +0,0 @@
 # 完整教程
 * [快速入门](quick_start/index_cn.rst)
 * [个性化推荐](rec/ml_regression_cn.rst)
 * [图像分类](image_classification/index_cn.md)
 * [情感分析](sentiment_analysis/index_cn.md)
 * [语义角色标注](semantic_role_labeling/index_cn.md)
 * [机器翻译](text_generation/index_cn.md)
 ## 常用模型
 * [ResNet模型](imagenet_model/resnet_model_cn.md)
 * [词向量模型](embedding_model/index_cn.md)
--- a/doc/tutorials/index_en.md
+++ b/doc/tutorials/index_en.md
@ -1,14 +0,0 @@
 # TUTORIALS
 There are several examples and demos here.
 * [Quick Start](quick_start/index_en.md)
 * [MovieLens Regression](rec/ml_regression_en.rst)
 * [Image Classification](image_classification/index_en.md)
 * [Sentiment Analysis](sentiment_analysis/index_en.md)
 * [Semantic Role Labeling](semantic_role_labeling/index_en.md)
 * [Text Generation](text_generation/index_en.md)
 * [Image Auto-Generation](gan/index_en.md)
 ## Model Zoo
 * [ImageNet: ResNet](imagenet_model/resnet_model_en.md)
 * [Embedding: Chinese Word](embedding_model/index_en.md)
--- a/doc/tutorials/rec/ml_dataset_cn.md
+++ b/doc/tutorials/rec/ml_dataset_cn.md
@ -1,105 +0,0 @@
 ```eval_rst
 .. _demo_ml_dataset:
 ```
 # MovieLens数据集
 [MovieLens 数据集](http://grouplens.org/datasets/movielens/)由GroupLens Research实验室搜集整理。
 该数据集包含一些用户信息、电影信息以及电影评分\[1-5\]。根据数据量规模，该数据及有很多不同的版本。
 我们用[MovieLens 百万数据集](http://files.grouplens.org/datasets/movielens/ml-1m.zip)作为示例数据
 集，其中包含6,000位用户对4,000部电影的1,000,000条评价。该数据集于2003年2月发布。
 ## 数据集特征
 在[ml-1m 数据集](http://files.grouplens.org/datasets/movielens/ml-1m.zip)中有许多的特征。在[ml-1m 数据集]
 (http://files.grouplens.org/datasets/movielens/ml-1m.zip)中的这些数据文件(含有".dat"的后缀)实际上是CSV文件，
 分隔符为"::"。以下我们翻译数据集网站中README文件的描述:
 ### 评分文件描述(ratings.dat)
 所有的评分数据都包含在"ratings.dat"文件中，遵循如下的格式:
 用户ID::电影ID::评分::时间戳
 - 用户ID范围从1到6040
 - 电影ID范围从1到3952
 - 评分被调整为5星的规模(只允许整数的星级)
 - 时间戳表示为从1970-01-01(UTC)来的秒数，与time(2)的返回值一致
 - 每位用户至少有20条评分
 ### 用户文件描述(users.dat)
 所有的用户信息都包含在"users.dat"文件中，遵循如下的格式:
 用户ID::性别::年龄::职业::邮编
 所有的人口统计学信息由用户自愿提供，没有进行正确性的检查。只有含有人
 口统计学信息的用户才被包含在数据集中。
 - 性别，用"M"表示男性，"F"表示女性
 - 年龄从下列列表范围中选取:
 	*   1:	"18岁以下"
 	*  18:	"18-24岁"
 	*  25:	"25-34岁"
 	*  35:	"35-44岁"
 	*  45:	"45-49岁"
 	*  50:	"50-55岁"
 	*  56:	"56+"
 - 职业从下面所列中选择:
 	*   0:  "其他"或不确定
 	*   1:  "学术/教育工作者"
 	*   2:  "艺术家"
 	*   3:  "文书工作/管理员"
 	*   4:  "大学生/研究生"
 	*   5:  "客户服务"
 	*   6:  "医生/医疗保健"
 	*   7:  "行政工作/管理人员"
 	*   8:  "农民"
 	*   9:  "操持家务者"
 	*  10:  "高中毕业生"
 	*  11:  "律师"
 	*  12:  "程序员"
 	*  13:  "退休人员"
 	*  14:  "销售/市场"
 	*  15:  "科学家"
 	*  16:  "自由职业者"
 	*  17:  "技术员/工程师"
 	*  18:  "推销员/手工艺者"
 	*  19:  "无业人士"
 	*  20:  "作家"
 ### 电影文件描述(movies.dat)
 所有的电影信息都包含在"movies.dat"文件中，遵循如下的格式:
 电影ID::电影名称::电影类型
 - 电影名称（包括发行时间）与IMDB网站提供的一致
 - 电影类型如符合多种用管道符号|分割，选自下列类型:
 	*	动作片
 	*	冒险片
 	*	动画片
 	*	儿童片
 	*	喜剧片
 	*	犯罪片
 	*	纪录片
 	*	戏剧
 	*	奇幻片
 	*	黑色电影
 	*	恐怖片
 	*	音乐剧
 	*	悬疑片
 	*	浪漫片
 	*	科幻片
 	*	惊险电影
 	*	战争片
 	*	西部片
 - 由于意外的副本记录和测试记录，有些电影ID可能与实际电影不相符合
 - 电影大部分是手工输入数据，因此可能会有一些错误和不一致发生
--- a/doc/tutorials/rec/ml_dataset_en.md
+++ b/doc/tutorials/rec/ml_dataset_en.md
@ -1,111 +0,0 @@
 ```eval_rst
 ..  _demo_ml_dataset:
 ```
 # MovieLens Dataset
 The [MovieLens Dataset](http://grouplens.org/datasets/movielens/) was collected by GroupLens Research.
 The data set contains some user information, movie information, and many movie ratings from \[1-5\].
 The data sets have many version depending on the size of set.
 We use [MovieLens 1M Dataset](http://files.grouplens.org/datasets/movielens/ml-1m.zip) as a demo dataset, which contains
 1 million ratings from 6000 users on 4000 movies. Released 2/2003.
 ## Dataset Features
 In [ml-1m Dataset](http://files.grouplens.org/datasets/movielens/ml-1m.zip), there are many features in these dataset.
 The data files (which have ".dat" extension) in [ml-1m Dataset](http://files.grouplens.org/datasets/movielens/ml-1m.zip)
 is basically CSV file that delimiter is "::". The description in README we quote here.
 ### RATINGS FILE DESCRIPTION(ratings.dat)
 All ratings are contained in the file "ratings.dat" and are in the
 following format:
 UserID::MovieID::Rating::Timestamp
 - UserIDs range between 1 and 6040
 - MovieIDs range between 1 and 3952
 - Ratings are made on a 5-star scale (whole-star ratings only)
 - Timestamp is represented in seconds since the epoch as returned by time(2)
 - Each user has at least 20 ratings
 ### USERS FILE DESCRIPTION(users.dat)
 User information is in the file "users.dat" and is in the following
 format:
 UserID::Gender::Age::Occupation::Zip-code
 All demographic information is provided voluntarily by the users and is
 not checked for accuracy.  Only users who have provided some demographic
 information are included in this data set.
 - Gender is denoted by a "M" for male and "F" for female
 - Age is chosen from the following ranges:
 	*  1:  "Under 18"
 	* 18:  "18-24"
 	* 25:  "25-34"
 	* 35:  "35-44"
 	* 45:  "45-49"
 	* 50:  "50-55"
 	* 56:  "56+"
 - Occupation is chosen from the following choices:
 	*  0:  "other" or not specified
 	*  1:  "academic/educator"
 	*  2:  "artist"
 	*  3:  "clerical/admin"
 	*  4:  "college/grad student"
 	*  5:  "customer service"
 	*  6:  "doctor/health care"
 	*  7:  "executive/managerial"
 	*  8:  "farmer"
 	*  9:  "homemaker"
 	* 10:  "K-12 student"
 	* 11:  "lawyer"
 	* 12:  "programmer"
 	* 13:  "retired"
 	* 14:  "sales/marketing"
 	* 15:  "scientist"
 	* 16:  "self-employed"
 	* 17:  "technician/engineer"
 	* 18:  "tradesman/craftsman"
 	* 19:  "unemployed"
 	* 20:  "writer"
 ### MOVIES FILE DESCRIPTION(movies.dat)
 Movie information is in the file "movies.dat" and is in the following
 format:
 MovieID::Title::Genres
 - Titles are identical to titles provided by the IMDB (including
 year of release)
 - Genres are pipe-separated and are selected from the following genres:
 	* Action
 	* Adventure
 	* Animation
 	* Children's
 	* Comedy
 	* Crime
 	* Documentary
 	* Drama
 	* Fantasy
 	* Film-Noir
 	* Horror
 	* Musical
 	* Mystery
 	* Romance
 	* Sci-Fi
 	* Thriller
 	* War
 	* Western
 - Some MovieIDs do not correspond to a movie due to accidental duplicate
 entries and/or test entries
 - Movies are mostly entered by hand, so errors and inconsistencies may exist
--- a/doc/tutorials/rec/ml_regression_cn.rst
+++ b/doc/tutorials/rec/ml_regression_cn.rst
--- a/doc/tutorials/rec/ml_regression_en.rst
+++ b/doc/tutorials/rec/ml_regression_en.rst
--- a/doc/tutorials/rec/rec_regression_network.png
+++ b/doc/tutorials/rec/rec_regression_network.png
--- a/doc/tutorials/semantic_role_labeling/feature.jpg
+++ b/doc/tutorials/semantic_role_labeling/feature.jpg
--- a/doc/tutorials/semantic_role_labeling/index_cn.md
+++ b/doc/tutorials/semantic_role_labeling/index_cn.md
@ -1,201 +0,0 @@
 # 语义角色标注教程 #
 语义角色标注（Semantic role labeling, SRL）是浅层语义解析的一种形式，其目的是在给定的输入句子中发现每个谓词的谓词论元结构。 SRL作为很多自然语言处理任务中的中间步骤是很有用的，如信息提取、文档自动分类和问答。 实例如下 [1]:
 [ <sub>A0</sub> He ] [ <sub>AM-MOD</sub> would ][ <sub>AM-NEG</sub> n’t ] [ <sub>V</sub> accept] [ <sub>A1</sub> anything of value ] from [<sub>A2</sub> those he was writing about ]. 
 - V: 动词
 - A0: 接受者
 - A1: 接受的东西
 - A2: 从……接受
 - A3: 属性
 - AM-MOD: 情态动词 
 - AM-NEG: 否定
 给定动词“accept”，句子中的组块将会扮演某些语义角色。这里，标签方案来自 Penn Proposition Bank。
 到目前为止，大多数成功的SRL系统是建立在某种形式的句法分析结果之上的，使用了基于句法结构的预定义特征模板。 本教程将介绍使用深度双向长短期记忆（DB-LSTM）模型[2]的端到端系统来解决SRL任务，这在很大程度上优于先前的最先进的系统。 这个系统将SRL任务视为序列标注问题。
 ## 数据描述
 相关论文[2]采用 CoNLL-2005＆2012 共享任务中设置的数据进行训练和测试。由于数据许可的原因，演示采用 CoNLL-2005 的测试数据集，可以在网站上找到。
 用户只需执行以下命令就可以下载并处理原始数据：
 ```bash
 cd data
 ./get_data.sh
 ```
 `data `目录会出现如下几个新的文件：
 ```bash
 conll05st-release：the test data set of CoNll-2005 shared task 
 test.wsj.words：the Wall Street Journal data sentences
 test.wsj.props:  the propositional arguments
 feature: the extracted features from data set
 ```
 ## 训练
 ### DB-LSTM
 请参阅情感分析的演示以了解有关长期短期记忆单元的更多信息。
 与在 Sentiment Analysis 演示中使用的 Bidirectional-LSTM 不同，DB-LSTM 采用另一种方法来堆叠LSTM层。首先，标准LSTM以正向处理该序列。该 LSTM 层的输入和输出作为下一个 LSTM 层的输入，并被反向处理。这两个标准 LSTM 层组成一对 LSTM。然后我们堆叠一对对的 LSTM 层后得到深度 LSTM 模型。
 下图展示了时间扩展的2层 DB-LSTM 网络。
 <center>
 ![pic](./network_arch.png)
 </center>
 ### 特征
 两个输入特征在这个流程中起着至关重要的作用：predicate（pred）和argument（arguments）。 还采用了两个其他特征：谓词上下文（ctx-p）和区域标记（mr）。 因为单个谓词不能精确地描述谓词信息，特别是当相同的词在句子中出现多于一次时。 使用谓词上下文，可以在很大程度上消除歧义。类似地，如果它位于谓词上下文区域中，则使用区域标记 m<sub>r</sub> = 1 来表示参数位置，反之则 m<sub>r</sub> = 0。这四个简单的特征是我们的SRL系统所需要的。上下文大小设置为1的一个样本的特征如下[2]所示：
 <center>
 ![pic](./feature.jpg)
 </center>
 在这个示例中，相应的标记句子是：
 [ <sub>A1</sub> A record date ] has [ <sub>AM-NEG</sub> n't ] been [ <sub>V</sub> set ] . 
 在演示中, 我们采用上面的特征模板, 包括：  `argument`, `predicate`, `ctx-p (p=-1,0,1)`, `mark` 并使用 `B/I/O` 方案来标记每个参数。这些特征和标签存储在 `feature` 文件中, 用`\t`分割。
 ### 数据提供
 `dataprovider.py` 是一个包装数据的 Python 文件。 函数 `hook()` 定义了网络的数据槽。六个特征和标签都是索引槽。
 ```
 def hook(settings, word_dict, label_dict, **kwargs):
    settings.word_dict = word_dict
    settings.label_dict = label_dict
    #all inputs are integral and sequential type
    settings.slots = [
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(predicate_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(2),
        integer_value_sequence(len(label_dict))]
 ```
 相应的数据迭代器如下：
 ```
@provider(init_hook=hook, should_shuffle=True, calc_batch_size=get_batch_size,
          can_over_batch_size=False, cache=CacheType.CACHE_PASS_IN_MEM)
 def process(settings, file_name):
    with open(file_name, 'r') as fdata:
        for line in fdata:
            sentence, predicate, ctx_n2, ctx_n1, ctx_0, ctx_p1, ctx_p2,  mark, label = \
                line.strip().split('\t')
            words = sentence.split()
            sen_len = len(words)
            word_slot = [settings.word_dict.get(w, UNK_IDX) for w in words]
            predicate_slot = [settings.predicate_dict.get(predicate)] * sen_len
            ctx_n2_slot = [settings.word_dict.get(ctx_n2, UNK_IDX)] * sen_len
            ctx_n1_slot = [settings.word_dict.get(ctx_n1, UNK_IDX)] * sen_len
            ctx_0_slot = [settings.word_dict.get(ctx_0, UNK_IDX)] * sen_len
            ctx_p1_slot = [settings.word_dict.get(ctx_p1, UNK_IDX)] * sen_len
            ctx_p2_slot = [settings.word_dict.get(ctx_p2, UNK_IDX)] * sen_len
            marks = mark.split()
            mark_slot = [int(w) for w in marks]
            label_list = label.split()
            label_slot = [settings.label_dict.get(w) for w in label_list]
            yield word_slot, predicate_slot, ctx_n2_slot, ctx_n1_slot, \
                  ctx_0_slot, ctx_p1_slot, ctx_p2_slot, mark_slot, label_slot
 ```
 函数 `process` 返回8个特征list和1个标签list。
 ### 神经网络配置
 `db_lstm.py` 是在训练过程中加载字典并定义数据提供程序模块和网络架构的神经网络配置文件。
 九个 `data_layer` 从数据提供程序加载实例。八个特征分别转换为向量，并由`mixed_layer`混合。 深度双向LSTM层提取softmax层的特征。目标函数是标签的交叉熵。
 ### 训练 
 训练的脚本是 `train.sh`，用户只需执行:
 ```bash
  ./train.sh
 ```
 `train.sh` 中的内容：
 ```
 paddle train \
  --config=./db_lstm.py \
  --use_gpu=0 \
  --log_period=5000 \
  --trainer_count=1 \
  --show_parameter_stats_period=5000 \
  --save_dir=./output \
  --num_passes=10000 \
  --average_test_period=10000000 \
  --init_model_path=./data \
  --load_missing_parameter_strategy=rand \
  --test_all_data_in_one_period=1 \
 2>&1 | tee 'train.log'
 ```
 -  \--config=./db_lstm.py : 网络配置文件
 -  \--use_gpu=false: 使用 CPU 训练（如果已安装 PaddlePaddle GPU版本并想使用 GPU 训练可以设置为true，目前 crf_layer 不支持 GPU）
 -  \--log_period=500: 每20个batch输出日志
 -  \--trainer_count=1: 设置线程数（或 GPU 数）
 -  \--show_parameter_stats_period=5000: 每100个batch显示参数统计
 -  \--save_dir=./output: 模型输出路径
 -  \--num_passes=10000: 设置数据遍历次数，一个pass意味着PaddlePaddle训练数据集中的所有样本被遍历一次
 -  \--average_test_period=10000000:  每个 average_test_period 批次对平均参数进行测试
 -  \--init_model_path=./data: 参数初始化路径
 -  \--load_missing_parameter_strategy=rand: 随机初始不存在的参数
 -  \--test_all_data_in_one_period=1: 在一个周期内测试所有数据
 训练后，模型将保存在目录`output`中。 我们的训练曲线如下：
 <center>
 ![pic](./src/curve.jpg)
 </center>
 ### 测试
 测试脚本是 `test.sh`, 执行:
 ```bash
  ./test.sh
 ```
 `tesh.sh` 的主要部分：
 ```
 paddle train \
  --config=./db_lstm.py \
  --model_list=$model_list \
  --job=test \
  --config_args=is_test=1 \
 ```
  - \--config=./db_lstm.py: 网络配置文件
  - \--model_list=$model_list.list: 模型列表文件
  - \--job=test: 指示测试任务
  - \--config_args=is_test=1: 指示测试任务的标记
  - \--test_all_data_in_one_period=1: 在一个周期内测试所有数据
 ### 预测
 预测脚本是 `predict.sh`，用户只需执行：
 ```bash
  ./predict.sh
 ```
 在`predict.sh`中，用户应该提供网络配置文件，模型路径，标签文件，字典文件，特征文件。
 ```
 python predict.py 
     -c $config_file \
     -w $best_model_path \
     -l $label_file \
     -p $predicate_dict_file  \
     -d $dict_file \
     -i $input_file \
     -o $output_file
 ```
 `predict.py` 是主要的可执行python脚本，其中包括函数：加载模型，加载数据，数据预测。网络模型将输出标签的概率分布。 在演示中，我们使用最大概率的标签作为结果。用户还可以根据概率分布矩阵实现柱搜索或维特比解码。
 预测后，结果保存在 `predict.res` 中。
 ## 引用
 [1] Martha Palmer, Dan Gildea, and Paul Kingsbury. The Proposition Bank: An Annotated Corpus of Semantic Roles , Computational Linguistics, 31(1), 2005. 
 [2] Zhou, Jie, and Wei Xu. "End-to-end learning of semantic role labeling using recurrent neural networks." Proceedings of the Annual Meeting of the Association for Computational Linguistics. 2015.
--- a/doc/tutorials/semantic_role_labeling/index_en.md
+++ b/doc/tutorials/semantic_role_labeling/index_en.md
@ -1,204 +0,0 @@
 ```eval_rst
 ..  _semantic_role_labeling:
 ```
 # Semantic Role labeling Tutorial #
 Semantic role labeling (SRL) is a form of shallow semantic parsing whose goal is to discover the predicate-argument structure of each predicate in a given input sentence. SRL is useful as an intermediate step in a wide range of natural language processing tasks, such as information extraction. automatic document categorization and question answering.  An instance is as following [1]:
 [ <sub>A0</sub> He ] [ <sub>AM-MOD</sub> would ][ <sub>AM-NEG</sub> n’t ] [ <sub>V</sub> accept] [ <sub>A1</sub> anything of value ] from [<sub>A2</sub> those he was writing about ]. 
 - V: verb
 - A0: acceptor
 - A1: thing accepted
 - A2: accepted-from
 - A3: Attribute
 - AM-MOD: modal 
 - AM-NEG: negation
 Given the verb "accept", the chunks in sentence would play certain semantic roles. Here, the label scheme is from Penn Proposition Bank. 
 To this date, most of the successful SRL systems are built on top of some form of parsing results where pre-defined feature templates over the syntactic structure are used. This tutorial will present an end-to-end system using deep bidirectional long short-term memory (DB-LSTM)[2] for solving the SRL task, which largely outperforms the previous state-of-the-art systems. The system regards SRL task as the sequence labelling problem. 
 ## Data Description
 The relevant paper[2] takes the data set in CoNLL-2005&2012 Shared Task for training and testing. Accordingto data license,  the demo adopts the test data set of CoNLL-2005, which can be reached on website.
 To download and process the original data, user just need to execute the following command:
 ```bash
 cd data
 ./get_data.sh
 ```
 Several new files appear in the `data `directory as follows.
 ```bash
 conll05st-release：the test data set of CoNll-2005 shared task 
 test.wsj.words：the Wall Street Journal data sentences
 test.wsj.props:  the propositional arguments
 feature: the extracted features from data set
 ```
 ## Training
 ### DB-LSTM
 Please refer to the Sentiment Analysis demo to learn more about the long short-term memory unit. 
 Unlike Bidirectional-LSTM that used in Sentiment Analysis demo,  the DB-LSTM adopts another way to stack LSTM layer. First a standard LSTM processes the sequence in forward direction. The input and output of this LSTM layer are taken by the next LSTM layer as input, processed in reversed direction. These two standard LSTM layers compose a pair of LSTM. Then we stack LSTM layers pair after pair to obtain the deep LSTM model. 
 The following figure shows a temporal expanded 2-layer DB-LSTM network.
 <center>
 ![pic](./src/network_arch.png)
 </center>
 ### Features
 Two input features play an essential role in this pipeline: predicate (pred) and argument (argu). Two other features: predicate context (ctx-p) and region mark (mr) are also adopted. Because a single predicate word can not exactly describe the predicate information, especially when the same words appear more than one times in a sentence. With the predicate context, the ambiguity can be largely eliminated. Similarly, we use region mark m<sub>r</sub> = 1 to denote the argument position if it locates in the predicate context region, or m<sub>r</sub> = 0 if does not. These four simple features are all we need for our SRL system. Features of one sample with context size set to 1 is showed as following[2]:
 <center>
 ![pic](./src/feature.jpg)
 </center>
 In this sample, the coresponding labelled sentence is:
 [ <sub>A1</sub> A record date ] has [ <sub>AM-NEG</sub> n't ] been [ <sub>V</sub> set ] . 
 In the demo, we adopt the feature template as above, consists of :  `argument`, `predicate`, `ctx-p (p=-1,0,1)`, `mark` and use `B/I/O` scheme to label each argument. These features and labels are stored in `feature` file, and separated by `\t`.
 ### Data Provider
 `dataprovider.py` is the python file to wrap data. `hook()` function is to define the data slots for network. The  Six features and label are all IndexSlots.
 ```
 def hook(settings, word_dict, label_dict, **kwargs):
    settings.word_dict = word_dict
    settings.label_dict = label_dict
    #all inputs are integral and sequential type
    settings.slots = [
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(predicate_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(len(word_dict)),
        integer_value_sequence(2),
        integer_value_sequence(len(label_dict))]
 ```
 The corresponding data iterator is as following:
 ```
@provider(init_hook=hook, should_shuffle=True, calc_batch_size=get_batch_size,
          can_over_batch_size=False, cache=CacheType.CACHE_PASS_IN_MEM)
 def process(settings, file_name):
    with open(file_name, 'r') as fdata:
        for line in fdata:
            sentence, predicate, ctx_n2, ctx_n1, ctx_0, ctx_p1, ctx_p2,  mark, label = \
                line.strip().split('\t')
            words = sentence.split()
            sen_len = len(words)
            word_slot = [settings.word_dict.get(w, UNK_IDX) for w in words]
            predicate_slot = [settings.predicate_dict.get(predicate)] * sen_len
            ctx_n2_slot = [settings.word_dict.get(ctx_n2, UNK_IDX)] * sen_len
            ctx_n1_slot = [settings.word_dict.get(ctx_n1, UNK_IDX)] * sen_len
            ctx_0_slot = [settings.word_dict.get(ctx_0, UNK_IDX)] * sen_len
            ctx_p1_slot = [settings.word_dict.get(ctx_p1, UNK_IDX)] * sen_len
            ctx_p2_slot = [settings.word_dict.get(ctx_p2, UNK_IDX)] * sen_len
            marks = mark.split()
            mark_slot = [int(w) for w in marks]
            label_list = label.split()
            label_slot = [settings.label_dict.get(w) for w in label_list]
            yield word_slot, predicate_slot, ctx_n2_slot, ctx_n1_slot, \
                  ctx_0_slot, ctx_p1_slot, ctx_p2_slot, mark_slot, label_slot
 ```
 The `process`function yield 9 lists which are 8 features and label.
 ### Neural Network Config
 `db_lstm.py` is the neural network config file to load the dictionaries and define the  data provider module and network architecture during the training procedure. 
 Nine `data_layer` load instances from data provider. Eight features are transformed into embedddings respectively, and mixed by `mixed_layer` .  Deep bidirectional LSTM layers extract features for the softmax layer. The objective function is cross entropy of labels.
 ### Run Training 
 The script for training is `train.sh`, user just need to execute:
 ```bash
  ./train.sh
 ```
 The content in `train.sh`:
 ```
 paddle train \
  --config=./db_lstm.py \
  --use_gpu=0 \
  --log_period=5000 \
  --trainer_count=1 \
  --show_parameter_stats_period=5000 \
  --save_dir=./output \
  --num_passes=10000 \
  --average_test_period=10000000 \
  --init_model_path=./data \
  --load_missing_parameter_strategy=rand \
  --test_all_data_in_one_period=1 \
 2>&1 | tee 'train.log'
 ```
 -  \--config=./db_lstm.py : network config file.
 -  \--use_gpu=false: use CPU to train, set true, if you install GPU version of PaddlePaddle and want to use GPU to train, until now crf_layer do not support GPU
 -  \--log_period=500: print log every 20 batches.
 -  \--trainer_count=1: set thread number (or GPU count).
 -  \--show_parameter_stats_period=5000: show parameter statistic every 100 batches.
 -  \--save_dir=./output: output path to save models.
 -  \--num_passes=10000: set pass number, one pass in PaddlePaddle means training all samples in dataset one time.
 -  \--average_test_period=10000000:  do test on average parameter every average_test_period batches
 -  \--init_model_path=./data: parameter initialization path 
 -  \--load_missing_parameter_strategy=rand: random initialization unexisted parameters
 -  \--test_all_data_in_one_period=1: test all data in one period
 After training, the models  will be saved in directory `output`. Our training curve is as following:
 <center>
 ![pic](./src/curve.jpg)
 </center>
 ### Run testing
 The script for testing is `test.sh`, user just need to execute:
 ```bash
  ./test.sh
 ```
 The main part in `tesh.sh`
 ```
 paddle train \
  --config=./db_lstm.py \
  --model_list=$model_list \
  --job=test \
  --config_args=is_test=1 \
 ```
  - \--config=./db_lstm.py: network config file
  - \--model_list=$model_list.list: model list file
  - \--job=test: indicate the test job
  - \--config_args=is_test=1: flag to indicate test
  - \--test_all_data_in_one_period=1: test all data in 1 period
 ### Run prediction
 The script for prediction is `predict.sh`, user just need to execute:
 ```bash
  ./predict.sh
 ```
 In `predict.sh`, user should offer the network config file, model path, label file, word dictionary file, feature file
 ```
 python predict.py 
     -c $config_file \
     -w $best_model_path \
     -l $label_file \
     -p $predicate_dict_file  \
     -d $dict_file \
     -i $input_file \
     -o $output_file
 ```
 `predict.py` is the main executable python script, which includes functions: load model, load data, data prediction. The network model will output the probability distribution of labels. In the demo, we take the label with maximum probability as result. User can also implement the beam search or viterbi decoding upon the probability distribution matrix.
 After prediction,  the result is saved in `predict.res`.
 ## Reference
 [1] Martha Palmer, Dan Gildea, and Paul Kingsbury. The Proposition Bank: An Annotated Corpus of Semantic Roles , Computational Linguistics, 31(1), 2005. 
 [2] Zhou, Jie, and Wei Xu. "End-to-end learning of semantic role labeling using recurrent neural networks." Proceedings of the Annual Meeting of the Association for Computational Linguistics. 2015.
--- a/doc/tutorials/semantic_role_labeling/network_arch.png
+++ b/doc/tutorials/semantic_role_labeling/network_arch.png
--- a/Show More
+++ b/Show More