-
-
-
-
-# Click-Through Rate Prediction
-
-## Introduction
-
-CTR(Click-Through Rate)\[[1](https://en.wikipedia.org/wiki/Click-through_rate)\]
-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.
-
-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. Get the ad collection associated with the user's search term.
-2. Business rules and relevance filtering.
-3. Rank by auction mechanism and CTR.
-4. Show ads.
-
-Here，CTR plays a crucial role.
-
-### Brief history
-Historically, the CTR prediction model has been evolving as follows.
-
-- Logistic Regression(LR) / Gradient Boosting Decision Trees (GBDT) + feature engineering
-- LR + Deep Neural Network (DNN)
-- DNN + feature engineering
-
-In the early stages of development LR dominated, but the recent years DNN based models are mainly used.
-
-
-### LR vs DNN
-
-The following figure shows the structure of LR and DNN model:
-
- \t \t click
-1 23 190 \t 230:0.12 3421:0.9 23451:0.12 \t 0
-23 231 \t 1230:0.12 13421:0.9 \t 1
-```
-
-Description：
-
-- `dnn input ids` one-hot coding.
-- `lr input sparse values` Use `ID:VALUE` , values are preferaly scaled to the range `[-1, 1]`。
-
-此外，模型训练时需要传入一个文件描述 dnn 和 lr两个子模型的输入维度，文件的格式如下：
-
-```
-dnn_input_dim:
-lr_input_dim:
-```
-
- represents an integer value.
-
-`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
- OUTPUT_DIR
- [--num_lines_to_detect NUM_LINES_TO_DETECT]
- [--test_set_size TEST_SET_SIZE]
- [--train_size TRAIN_SIZE]
-
-PaddlePaddle CTR example
-
-optional arguments:
- -h, --help show this help message and exit
- --data_path DATA_PATH
- path of the Avazu dataset
- --output_dir OUTPUT_DIR
- directory to output
- --num_lines_to_detect NUM_LINES_TO_DETECT
- number of records to detect dataset's meta info
- --test_set_size TEST_SET_SIZE
- size of the validation dataset(default: 10000)
- --train_size TRAIN_SIZE
- size of the trainset (default: 100000)
-```
-
-- `data_path` The data path to be processed
-- `output_dir` The output path of the data
-- `num_lines_to_detect` The number of generated IDs
-- `test_set_size` The number of rows for the test set
-- `train_size` The number of rows of training set
-
-## Wide & Deep Learning Model
-
-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](#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.
-
-The model structure is as follows:
-
- \t
-1 23 190 \t 230:0.12 3421:0.9 23451:0.12
-23 231 \t 1230:0.12 13421:0.9
-```
-
-Here the only difference to the training data is that there is no label (i.e. `click` values).
-
-We now can use `infer.py` to perform inference.
-
-```
-usage: infer.py [-h] --model_gz_path MODEL_GZ_PATH --data_path DATA_PATH
- --prediction_output_path PREDICTION_OUTPUT_PATH
- [--data_meta_path DATA_META_PATH] --model_type MODEL_TYPE
-
-PaddlePaddle CTR example
-
-optional arguments:
- -h, --help show this help message and exit
- --model_gz_path MODEL_GZ_PATH
- path of model parameters gz file
- --data_path DATA_PATH
- path of the dataset to infer
- --prediction_output_path PREDICTION_OUTPUT_PATH
- path to output the prediction
- --data_meta_path DATA_META_PATH
- path of trainset's meta info, default is ./data.meta
- --model_type MODEL_TYPE
- model type, classification: 0, regression 1 (default
- classification)
-```
-
-- `model_gz_path_model`：path for `gz` compressed data.
-- `data_path` ：
-- `prediction_output_patj`：path for the predicted values s
-- `data_meta_file` ：Please refer to [数据和任务抽象](### 数据和任务抽象)。
-- `model_type` ：Classification or regression
-
-The sample data can be predicted with the following command
-
-```
-python infer.py --model_gz_path --data_path output/infer.txt --prediction_output_path predictions.txt --data_meta_path data.meta.txt
-```
-
-The final prediction is written in `predictions.txt`。
-
-## References
-1.
-2.
-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.
-
-
-
-
-
-
diff --git a/dssm/index.html b/dssm/index.html
deleted file mode 100644
index 5c4a1a9d316821f25bbf204c3ba7698573722b94..0000000000000000000000000000000000000000
--- a/dssm/index.html
+++ /dev/null
@@ -1,328 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Figure 1. LR and DNN model structure comparison
-
-
-Figure 2. Wide & Deep Model
-
-
-
-
-
-# Deep Structured Semantic Models (DSSM)
-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.
-
-## Background Introduction
-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. The CTR predictor measures the degree of association between a user search query and a candidate web page.
-2. Text relevance, which measures the degree of semantic correlation between two strings.
-3. Automatically recommend, measure the degree of association between User and the recommended Item.
-
-
-## Model Architecture
-
-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
-
- \t \t
-```
-
-The example of this format is as follows.
-
-```
-3 6 10 \t 6 8 33 \t 0.7
-6 0 \t 6 9 330 \t 0.03
-```
-
-### Classification data format
-```
-# 3 fields each line:
-# - source's word ids
-# - target's word ids
-# - target
- \t \t
-
-
-
-
diff --git a/generate_chinese_poetry/README.md b/generate_chinese_poetry/README.md
index f6a09ed22d42d6de3b0d6fd14d826cb87de822f5..1f6bef0da8145098f70fd02030f6cf4f7284dd3e 100644
--- a/generate_chinese_poetry/README.md
+++ b/generate_chinese_poetry/README.md
@@ -1 +1,111 @@
-[TBD]
+# 中国古诗生成
+
+## 简介
+基于编码器-解码器(encoder-decoder)神经网络模型，利用全唐诗进行诗句-诗句(sequence to sequence)训练，实现给定诗句后，生成下一诗句。
+
+模型中的编码器、解码器均使用堆叠双向LSTM (stacked bi-directional LSTM)，默认均为3层，带有注意力单元(attention)。
+
+以下是本例的简要目录结构及说明：
+
+```text
+.
+├── data # 存储训练数据及字典
+│ ├── download.sh # 下载原始数据
+├── README.md # 文档
+├── index.html # 文档(html格式)
+├── preprocess.py # 原始数据预处理
+├── generate.py # 生成诗句脚本
+├── network_conf.py # 模型定义
+├── reader.py # 数据读取接口
+├── train.py # 训练脚本
+└── utils.py # 定义实用工具函数
+```
+
+## 数据处理
+### 原始数据来源
+本例使用[中华古诗词数据库](https://github.com/chinese-poetry/chinese-poetry)中收集的全唐诗作为训练数据，共有约5.4万首唐诗。
+
+### 原始数据下载
+```bash
+cd data && ./download.sh && cd ..
+```
+### 数据预处理
+```bash
+python preprocess.py --datadir data/raw --outfile data/poems.txt --dictfile data/dict.txt
+```
+
+上述脚本执行完后将生成处理好的训练数据poems.txt和字典dict.txt。字典的构建以字为单位，使用出现频数至少为10的字构建字典。
+
+poems.txt中每行为一首唐诗的信息，分为三列，分别为题目、作者、诗内容。在诗内容中，诗句之间用`.`分隔。
+
+训练数据示例：
+```text
+登鸛雀樓 王之渙 白日依山盡.黃河入海流.欲窮千里目.更上一層樓
+觀獵 李白 太守耀清威.乘閑弄晚暉.江沙橫獵騎.山火遶行圍.箭逐雲鴻落.鷹隨月兔飛.不知白日暮.歡賞夜方歸
+晦日重宴 陳嘉言 高門引冠蓋.下客抱支離.綺席珍羞滿.文場翰藻摛.蓂華彫上月.柳色藹春池.日斜歸戚里.連騎勒金羈
+```
+
+模型训练时，使用每一诗句作为模型输入，下一诗句作为预测目标。
+
+
+## 模型训练
+训练脚本[train.py](./train.py)中的命令行参数可以通过`python train.py --help`查看。主要参数说明如下：
+- `num_passes`: 训练pass数
+- `batch_size`: batch大小
+- `use_gpu`: 是否使用GPU
+- `trainer_count`: trainer数目，默认为1
+- `save_dir_path`: 模型存储路径，默认为当前目录下models目录
+- `encoder_depth`: 模型中编码器LSTM深度，默认为3
+- `decoder_depth`: 模型中解码器LSTM深度，默认为3
+- `train_data_path`: 训练数据路径
+- `word_dict_path`: 数据字典路径
+- `init_model_path`: 初始模型路径，从头训练时无需指定
+
+### 训练执行
+```bash
+python train.py \
+ --num_passes 50 \
+ --batch_size 256 \
+ --use_gpu True \
+ --trainer_count 1 \
+ --save_dir_path models \
+ --train_data_path data/poems.txt \
+ --word_dict_path data/dict.txt \
+ 2>&1 | tee train.log
+```
+每个pass训练结束后，模型参数将保存在models目录下。训练日志保存在train.log中。
+
+### 最优模型参数
+寻找cost最小的pass，使用该pass对应的模型参数用于后续预测。
+```bash
+python -c 'import utils; utils.find_optiaml_pass("./train.log")'
+```
+
+## 生成诗句
+使用[generate.py](./generate.py)脚本对输入诗句生成下一诗句，命令行参数可通过`python generate.py --help`查看。
+主要参数说明如下：
+- `model_path`: 训练好的模型参数文件
+- `word_dict_path`: 数据字典路径
+- `test_data_path`: 输入数据路径
+- `batch_size`: batch大小，默认为1
+- `beam_size`: beam search中搜索范围大小，默认为5
+- `save_file`: 输出保存路径
+- `use_gpu`: 是否使用GPU
+
+### 执行生成
+例如将诗句 `孤帆遠影碧空盡` 保存在文件 `input.txt` 中作为预测下句诗的输入，执行命令：
+```bash
+python generate.py \
+ --model_path models/pass_00049.tar.gz \
+ --word_dict_path data/dict.txt \
+ --test_data_path input.txt \
+ --save_file output.txt
+```
+生成结果将保存在文件 `output.txt` 中。对于上述示例输入，生成的诗句如下：
+```text
+-9.6987 萬 壑 清 風 黃 葉 多
+-10.0737 萬 里 遠 山 紅 葉 深
+-10.4233 萬 壑 清 波 紅 一 流
+-10.4802 萬 壑 清 風 黃 葉 深
+-10.9060 萬 壑 清 風 紅 葉 多
+```
diff --git a/generate_chinese_poetry/data/download.sh b/generate_chinese_poetry/data/download.sh
new file mode 100755
index 0000000000000000000000000000000000000000..988c09c0f27c81854d2e090913d2972cb0ffbb51
--- /dev/null
+++ b/generate_chinese_poetry/data/download.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+git clone https://github.com/chinese-poetry/chinese-poetry.git
+
+if [ ! -d raw ]
+then
+ mkdir raw
+fi
+
+mv chinese-poetry/json/poet.tang.* raw/
+rm -rf chinese-poetry
diff --git a/generate_chinese_poetry/generate.py b/generate_chinese_poetry/generate.py
index b2d909171fa713bb2e01d711b63060cb8850c768..952de15fbcfdb1193c30c6828b73d3a6a825b473 100755
--- a/generate_chinese_poetry/generate.py
+++ b/generate_chinese_poetry/generate.py
@@ -28,7 +28,7 @@ def infer_a_batch(inferer, test_batch, beam_size, id_to_text, fout):
for j in xrange(beam_size):
end_pos = gen_sen_idx[i * beam_size + j]
fout.write("%s\n" % ("%.4f\t%s" % (beam_result[0][i][j], " ".join(
- id_to_text[w] for w in beam_result[1][start_pos:end_pos]))))
+ id_to_text[w] for w in beam_result[1][start_pos:end_pos - 1]))))
start_pos = end_pos + 2
fout.write("\n")
fout.flush
@@ -80,9 +80,11 @@ def generate(model_path, word_dict_path, test_data_path, batch_size, beam_size,
encoder_hidden_dim=512,
decoder_depth=3,
decoder_hidden_dim=512,
- is_generating=True,
+ bos_id=0,
+ eos_id=1,
+ max_length=9,
beam_size=beam_size,
- max_length=10)
+ is_generating=True)
inferer = paddle.inference.Inference(
output_layer=beam_gen, parameters=parameters)
diff --git a/generate_chinese_poetry/index.html b/generate_chinese_poetry/index.html
deleted file mode 100644
index a5dba006b9c5c272061d9d83589e0f4c2fd6eb13..0000000000000000000000000000000000000000
--- a/generate_chinese_poetry/index.html
+++ /dev/null
@@ -1,65 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Figure 1. DSSM In the original paper
-
-
-Figure 2. DSSM generic structure
-
-
-Figure 3. DSSM for REGRESSION or CLASSIFICATION
-
-
-图 4. DSSM for Pairwise Rank
-
-
-
-
-
-[TBD]
-
-
-
-
-
-
diff --git a/generate_chinese_poetry/network_conf.py b/generate_chinese_poetry/network_conf.py
index 5aec3c06b1b2cb9918d3489379df3d2083b39658..1aee1aa249014a70fe09c3fb5ea5da5d81db59a3 100755
--- a/generate_chinese_poetry/network_conf.py
+++ b/generate_chinese_poetry/network_conf.py
@@ -73,8 +73,10 @@ def encoder_decoder_network(word_count,
encoder_hidden_dim,
decoder_depth,
decoder_hidden_dim,
+ bos_id,
+ eos_id,
+ max_length,
beam_size=10,
- max_length=15,
is_generating=False):
src_emb = paddle.layer.embedding(
input=paddle.layer.data(
@@ -106,8 +108,8 @@ def encoder_decoder_network(word_count,
name=decoder_group_name,
step=_attended_decoder_step,
input=group_inputs + [gen_trg_emb],
- bos_id=0,
- eos_id=1,
+ bos_id=bos_id,
+ eos_id=eos_id,
beam_size=beam_size,
max_length=max_length)
diff --git a/generate_chinese_poetry/preprocess.py b/generate_chinese_poetry/preprocess.py
new file mode 100755
index 0000000000000000000000000000000000000000..4018e2e3cb83e00b4c65489f88b46b71f6f20a8f
--- /dev/null
+++ b/generate_chinese_poetry/preprocess.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import os
+import io
+import re
+import json
+import click
+import collections
+
+
+def build_vocabulary(dataset, cutoff=0):
+ dictionary = collections.defaultdict(int)
+ for data in dataset:
+ for sent in data[2]:
+ for char in sent:
+ dictionary[char] += 1
+ dictionary = filter(lambda x: x[1] >= cutoff, dictionary.items())
+ dictionary = sorted(dictionary, key=lambda x: (-x[1], x[0]))
+ vocab, _ = list(zip(*dictionary))
+ return (u"
-
-
-
-
-# 使用循环神经网语言模型生成文本
-
-语言模型(Language Model)是一个概率分布模型，简单来说，就是用来计算一个句子的概率的模型。利用它可以确定哪个词序列的可能性更大，或者给定若干个词，可以预测下一个最可能出现的词。语言模型是自然语言处理领域里一个重要的基础模型。
-
-## 应用场景
-**语言模型被应用在很多领域**，如：
-
-* **自动写作**：语言模型可以根据上文生成下一个词，递归下去可以生成整个句子、段落、篇章。
-* **QA**：语言模型可以根据Question生成Answer。
-* **机器翻译**：当前主流的机器翻译模型大多基于Encoder-Decoder模式，其中Decoder就是一个待条件的语言模型，用来生成目标语言。
-* **拼写检查**：语言模型可以计算出词序列的概率，一般在拼写错误处序列的概率会骤减，可以用来识别拼写错误并提供改正候选集。
-* **词性标注、句法分析、语音识别......**
-
-## 关于本例
-本例实现基于RNN的语言模型，以及利用语言模型生成文本，本例的目录结构如下：
-
-```text
-.
-├── data
-│ └── train_data_examples.txt # 示例数据，可参考示例数据的格式，提供自己的数据
-├── config.py # 配置文件，包括data、train、infer相关配置
-├── generate.py # 预测任务脚本，即生成文本
-├── beam_search.py # beam search 算法实现
-├── network_conf.py # 本例中涉及的各种网络结构均定义在此文件中，希望进一步修改模型结构，请修改此文件
-├── reader.py # 读取数据接口
-├── README.md
-├── train.py # 训练任务脚本
-└── utils.py # 定义通用的函数，例如：构建字典、加载字典等
-```
-
-## RNN 语言模型
-### 简介
-
-RNN是一个序列模型，基本思路是：在时刻$t$，将前一时刻$t-1$的隐藏层输出和$t$时刻的词向量一起输入到隐藏层从而得到时刻$t$的特征表示，然后用这个特征表示得到$t$时刻的预测输出，如此在时间维上递归下去。可以看出RNN善于使用上文信息、历史知识，具有“记忆”功能。理论上RNN能实现“长依赖”（即利用很久之前的知识），但在实际应用中发现效果并不理想，研究提出了LSTM和GRU等变种，通过引入门机制对传统RNN的记忆单元进行了改进，弥补了传统RNN在学习长序列时遇到的难题。本例模型使用了LSTM或GRU，可通过配置进行修改。下图是RNN（广义上包含了LSTM、GRU等）语言模型“循环”思想的示意图：
-
-`：不出现在字典中的词
- 2. ``：句子的结束符
-
- *注：需要注意的是，词典越大生成的内容越丰富，但训练耗时越久。一般中文分词之后，语料中不同的词能有几万乃至几十万，如果`max_word_num`取值过小则导致``占比过高，如果`max_word_num`取值较大，则严重影响训练速度（对精度也有影响）。所以，也有“按字”训练模型的方式，即：把每个汉字当做一个词，常用汉字也就几千个，使得字典的大小不会太大、不会丢失太多信息，但汉语中同一个字在不同词中语义相差很大，有时导致模型效果不理想。建议多试试、根据实际情况选择是“按词训练”还是“按字训练”。*
-
-### 模型适配、训练
-
-* 按需调整`config.py`中如下配置，来修改 rnn 语言模型的网络结果：
-
- ```python
- rnn_type = "lstm" # "gru" or "lstm"
- emb_dim = 256
- hidden_size = 256
- stacked_rnn_num = 2
- ```
- 1. `rnn_type`：支持 ”gru“ 或者 ”lstm“ 两种参数，选择使用何种 RNN 单元。
- 2. `emb_dim`：设置词向量的维度。
- 3. `hidden_size`：设置 RNN 单元隐层大小。
- 4. `stacked_rnn_num`：设置堆叠 RNN 单元的个数，构成一个更深的模型。
-
-* 运行`python train.py`命令训练模型，模型将被保存到`model_save_dir`指定的目录。
-
-### 按需生成文本
-
-* 按需调整`config.py`中以下变量，详解如下：
-
- ```python
- gen_file = "data/train_data_examples.txt"
- gen_result = "data/gen_result.txt"
- max_gen_len = 25 # the max number of words to generate
- beam_size = 5
- model_path = "models/rnn_lm_pass_00000.tar.gz"
- ```
- 1. `gen_file`：指定输入数据文件，每行是一个句子的前缀，**需要预先分词**。
- 2. `gen_result`：指定输出文件路径，生成结果将写入此文件。
- 3. `max_gen_len`：指定每一句生成的话最长长度，如果模型无法生成出``，当生成 `max_gen_len` 个词语后，生成过程会自动终止。
- 4. `beam_size`：Beam Search 算法每一步的展开宽度。
- 5. `model_path`：指定训练好的模型的路径。
-
- 其中，`gen_file` 中保存的是待生成的文本前缀，每个前缀占一行，形如：
-
- ```text
- 若隐若现 地像 幽灵 , 像 死神
- ```
- 将需要生成的文本前缀按此格式存入文件即可；
-
-* 运行`python generate.py`命令运行beam search 算法为输入前缀生成文本，下面是模型生成的结果：
-
- ```text
- 81 若隐若现 地像 幽灵 , 像 死神
- -12.2542 一样 。 他 是 个 怪物
- -12.6889 一样 。 他 是 个 英雄
- -13.9877 一样 。 他 是 我 的 敌人
- -14.2741 一样 。 他 是 我 的
- -14.6250 一样 。 他 是 我 的 朋友
- ```
- 其中：
- 1. 第一行 `81 若隐若现 地像 幽灵 , 像 死神`以`\t`为分隔，共有两列：
- - 第一列是输入前缀在训练样本集中的序号。
- - 第二列是输入的前缀。
- 2. 第二 ~ `beam_size + 1` 行是生成结果，同样以 `\t` 分隔为两列：
- - 第一列是该生成序列的对数概率（log probability）。
- - 第二列是生成的文本序列，正常的生成结果会以符号``结尾，如果没有以``结尾，意味着超过了最大序列长度，生成强制终止。
-
-
-
-
-
-
diff --git a/globally_normalized_reader/index.html b/globally_normalized_reader/index.html
deleted file mode 100644
index c8c23c5bad340c7f043f662e4334e9c0f772e55e..0000000000000000000000000000000000000000
--- a/globally_normalized_reader/index.html
+++ /dev/null
@@ -1,119 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# Globally Normalized Reader
-
-This model implements the work in the following paper:
-
-Jonathan Raiman and John Miller. Globally Normalized Reader. Empirical Methods in Natural Language Processing (EMNLP), 2017.
-
-If you use the dataset/code in your research, please cite the above paper:
-
-```text
-@inproceedings{raiman2015gnr,
- author={Raiman, Jonathan and Miller, John},
- booktitle={Empirical Methods in Natural Language Processing (EMNLP)},
- title={Globally Normalized Reader},
- year={2017},
-}
-```
-
-You can also visit https://github.com/baidu-research/GloballyNormalizedReader to get more information.
-
-
-# Installation
-
-1. Please use [docker image](http://doc.paddlepaddle.org/develop/doc/getstarted/build_and_install/docker_install_en.html) to install the latest PaddlePaddle, by running:
- ```bash
- docker pull paddledev/paddle
- ```
-2. Download all necessary data by running:
- ```bash
- cd data && ./download.sh && cd ..
- ```
-3. Preprocess and featurizer data:
- ```bash
- python featurize.py --datadir data --outdir data/featurized --glove-path data/glove.840B.300d.txt
- ```
-
-# Training a Model
-
-- Configurate the model by modifying `config.py` if needed, and then run:
-
- ```bash
- python train.py 2>&1 | tee train.log
- ```
-
-# Inferring by a Trained Model
-
-- Infer by a trained model by running:
- ```bash
- python infer.py \
- --model_path models/pass_00000.tar.gz \
- --data_dir data/featurized/ \
- --batch_size 2 \
- --use_gpu 0 \
- --trainer_count 1 \
- 2>&1 | tee infer.log
- ```
-
-
-
-
-
-
diff --git a/hsigmoid/index.html b/hsigmoid/index.html
deleted file mode 100644
index 738e81f25a01cfce2ef948f1bef70a38932de6fa..0000000000000000000000000000000000000000
--- a/hsigmoid/index.html
+++ /dev/null
@@ -1,226 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# Hsigmoid加速词向量训练
-## 背景介绍
-在自然语言处理领域中，传统做法通常使用one-hot向量来表示词，比如词典为['我', '你', '喜欢']，可以用[1,0,0]、[0,1,0]和[0,0,1]这三个向量分别表示'我'、'你'和'喜欢'。这种表示方式比较简洁，但是当词表很大时，容易产生维度爆炸问题；而且任意两个词的向量是正交的，向量包含的信息有限。为了避免或减轻one-hot表示的缺点，目前通常使用词向量来取代one-hot表示，词向量也就是word embedding，即使用一个低维稠密的实向量取代高维稀疏的one-hot向量。训练词向量的方法有很多种，神经网络模型是其中之一，包括CBOW、Skip-gram等，这些模型本质上都是一个分类模型，当词表较大即类别较多时，传统的softmax将非常消耗时间。PaddlePaddle提供了Hsigmoid Layer、NCE Layer，来加速模型的训练过程。本文主要介绍如何使用Hsigmoid Layer来加速训练，词向量相关内容请查阅PaddlePaddle Book中的[词向量章节](https://github.com/PaddlePaddle/book/tree/develop/04.word2vec)。
-
-## Hsigmoid Layer
-Hsigmoid Layer引用自论文\[[1](#参考文献)\]，Hsigmoid指Hierarchical-sigmoid，原理是通过构建一个分类二叉树来降低计算复杂度，二叉树中每个叶子节点代表一个类别，每个非叶子节点代表一个二类别分类器。例如我们一共有4个类别分别是0、1、2、3，softmax会分别计算4个类别的得分，然后归一化得到概率。当类别数很多时，计算每个类别的概率非常耗时，Hsigmoid Layer会根据类别数构建一个平衡二叉树，如下：
-
-以及结束符号\，然后依据窗口大小（本文为5），从头到尾每次向右滑动窗口并生成一条数据。如"I have a dream that one day"可以生成\ I have a dream、I have a dream that、have a dream that one、a dream that one day、dream that one day \，PaddlePaddle会把词转换成id数据作为预处理的输出。
-
-### 自定义数据
-用户可以使用自己的数据集训练模型，自定义数据集最关键的地方是实现reader接口做数据处理，reader需要产生一个迭代器，迭代器负责解析文件中的每一行数据，返回一个python list，例如[1, 2, 3, 4, 5]，分别是第一个到第四个词在字典中的id，PaddlePaddle会进一步将该list转化成`paddle.data_type.inter_value`类型作为data layer的输入，一个封装样例如下：
-
-```python
-def reader_creator(filename, word_dict, n):
- def reader():
- with open(filename) as f:
- UNK = word_dict['']
- for l in f:
- l = [''] + l.strip().split() + ['']
- if len(l) >= n:
- l = [word_dict.get(w, UNK) for w in l]
- for i in range(n, len(l) + 1):
- yield tuple(l[i - n:i])
- return reader
-
-
-def train_data(filename, word_dict, n):
- """
- Reader interface for training data.
-
- It returns a reader creator, each sample in the reader is a word ID tuple.
-
- :param filename: path of data file
- :type filename: str
- :param word_dict: word dictionary
- :type word_dict: dict
- :param n: sliding window size
- :type n: int
- """
- return reader_creator(filename, word_dict, n)
-```
-
-## 网络结构
-本文通过训练N-gram语言模型来获得词向量，具体地使用前4个词来预测当前词。网络输入为词在字典中的id，然后查询词向量词表获取词向量，接着拼接4个词的词向量，然后接入一个全连接隐层，最后是`Hsigmoid`层。详细网络结构见图2：
-
-
-
-
-
-
diff --git a/image_classification/index.html b/image_classification/index.html
deleted file mode 100644
index 48009093f9505fa425890d3103bf0c8e21073b63..0000000000000000000000000000000000000000
--- a/image_classification/index.html
+++ /dev/null
@@ -1,302 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. （a）为平衡二叉树，（b）为根节点到类别1的路径
-
-
-图2. 网络配置结构
-
-
-
-
-
-图像分类
-=======================
-
-这里将介绍如何在PaddlePaddle下使用AlexNet、VGG、GoogLeNet和ResNet模型进行图像分类。图像分类问题的描述和这四种模型的介绍可以参考[PaddlePaddle book](https://github.com/PaddlePaddle/book/tree/develop/03.image_classification)。
-
-## 训练模型
-
-### 初始化
-
-在初始化阶段需要导入所用的包，并对PaddlePaddle进行初始化。
-
-```python
-import gzip
-import paddle.v2.dataset.flowers as flowers
-import paddle.v2 as paddle
-import reader
-import vgg
-import resnet
-import alexnet
-import googlenet
-
-
-# PaddlePaddle init
-paddle.init(use_gpu=False, trainer_count=1)
-```
-
-### 定义参数和输入
-
-设置算法参数（如数据维度、类别数目和batch size等参数），定义数据输入层`image`和类别标签`lbl`。
-
-```python
-DATA_DIM = 3 * 224 * 224
-CLASS_DIM = 102
-BATCH_SIZE = 128
-
-image = paddle.layer.data(
- name="image", type=paddle.data_type.dense_vector(DATA_DIM))
-lbl = paddle.layer.data(
- name="label", type=paddle.data_type.integer_value(CLASS_DIM))
-```
-
-### 获得所用模型
-
-这里可以选择使用AlexNet、VGG、GoogLeNet和ResNet模型中的一个模型进行图像分类。通过调用相应的方法可以获得网络最后的Softmax层。
-
-1. 使用AlexNet模型
-
-指定输入层`image`和类别数目`CLASS_DIM`后，可以通过下面的代码得到AlexNet的Softmax层。
-
-```python
-out = alexnet.alexnet(image, class_dim=CLASS_DIM)
-```
-
-2. 使用VGG模型
-
-根据层数的不同，VGG分为VGG13、VGG16和VGG19。使用VGG16模型的代码如下：
-
-```python
-out = vgg.vgg16(image, class_dim=CLASS_DIM)
-```
-
-类似地，VGG13和VGG19可以分别通过`vgg.vgg13`和`vgg.vgg19`方法获得。
-
-3. 使用GoogLeNet模型
-
-GoogLeNet在训练阶段使用两个辅助的分类器强化梯度信息并进行额外的正则化。因此`googlenet.googlenet`共返回三个Softmax层，如下面的代码所示：
-
-```python
-out, out1, out2 = googlenet.googlenet(image, class_dim=CLASS_DIM)
-loss1 = paddle.layer.cross_entropy_cost(
- input=out1, label=lbl, coeff=0.3)
-paddle.evaluator.classification_error(input=out1, label=lbl)
-loss2 = paddle.layer.cross_entropy_cost(
- input=out2, label=lbl, coeff=0.3)
-paddle.evaluator.classification_error(input=out2, label=lbl)
-extra_layers = [loss1, loss2]
-```
-
-对于两个辅助的输出，这里分别对其计算损失函数并评价错误率，然后将损失作为后文SGD的extra_layers。
-
-4. 使用ResNet模型
-
-ResNet模型可以通过下面的代码获取：
-
-```python
-out = resnet.resnet_imagenet(image, class_dim=CLASS_DIM)
-```
-
-### 定义损失函数
-
-```python
-cost = paddle.layer.classification_cost(input=out, label=lbl)
-```
-
-### 创建参数和优化方法
-
-```python
-# Create parameters
-parameters = paddle.parameters.create(cost)
-
-# Create optimizer
-optimizer = paddle.optimizer.Momentum(
- momentum=0.9,
- regularization=paddle.optimizer.L2Regularization(rate=0.0005 *
- BATCH_SIZE),
- learning_rate=0.001 / BATCH_SIZE,
- learning_rate_decay_a=0.1,
- learning_rate_decay_b=128000 * 35,
- learning_rate_schedule="discexp", )
-```
-
-通过 `learning_rate_decay_a` (简写$a$） 、`learning_rate_decay_b` (简写$b$) 和 `learning_rate_schedule` 指定学习率调整策略，这里采用离散指数的方式调节学习率，计算公式如下， $n$ 代表已经处理过的累计总样本数，$lr_{0}$ 即为参数里设置的 `learning_rate`。
-
-$$ lr = lr_{0} * a^ {\lfloor \frac{n}{ b}\rfloor} $$
-
-
-### 定义数据读取
-
-首先以[花卉数据](http://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html)为例说明如何定义输入。下面的代码定义了花卉数据训练集和验证集的输入：
-
-```python
-train_reader = paddle.batch(
- paddle.reader.shuffle(
- flowers.train(),
- buf_size=1000),
- batch_size=BATCH_SIZE)
-test_reader = paddle.batch(
- flowers.valid(),
- batch_size=BATCH_SIZE)
-```
-
-若需要使用其他数据，则需要先建立图像列表文件。`reader.py`定义了这种文件的读取方式，它从图像列表文件中解析出图像路径和类别标签。
-
-图像列表文件是一个文本文件，其中每一行由一个图像路径和类别标签构成，二者以跳格符（Tab）隔开。类别标签用整数表示，其最小值为0。下面给出一个图像列表文件的片段示例：
-
-```
-dataset_100/train_images/n03982430_23191.jpeg 1
-dataset_100/train_images/n04461696_23653.jpeg 7
-dataset_100/train_images/n02441942_3170.jpeg 8
-dataset_100/train_images/n03733281_31716.jpeg 2
-dataset_100/train_images/n03424325_240.jpeg 0
-dataset_100/train_images/n02643566_75.jpeg 8
-```
-
-训练时需要分别指定训练集和验证集的图像列表文件。这里假设这两个文件分别为`train.list`和`val.list`，数据读取方式如下：
-
-```python
-train_reader = paddle.batch(
- paddle.reader.shuffle(
- reader.train_reader('train.list'),
- buf_size=1000),
- batch_size=BATCH_SIZE)
-test_reader = paddle.batch(
- reader.test_reader('val.list'),
- batch_size=BATCH_SIZE)
-```
-
-### 定义事件处理程序
-```python
-# End batch and end pass event handler
-def event_handler(event):
- if isinstance(event, paddle.event.EndIteration):
- if event.batch_id % 1 == 0:
- print "\nPass %d, Batch %d, Cost %f, %s" % (
- event.pass_id, event.batch_id, event.cost, event.metrics)
- if isinstance(event, paddle.event.EndPass):
- with gzip.open('params_pass_%d.tar.gz' % event.pass_id, 'w') as f:
- parameters.to_tar(f)
-
- result = trainer.test(reader=test_reader)
- print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)
-```
-
-### 定义训练方法
-
-对于AlexNet、VGG和ResNet，可以按下面的代码定义训练方法：
-
-```python
-# Create trainer
-trainer = paddle.trainer.SGD(
- cost=cost,
- parameters=parameters,
- update_equation=optimizer)
-```
-
-GoogLeNet有两个额外的输出层，因此需要指定`extra_layers`，如下所示：
-
-```python
-# Create trainer
-trainer = paddle.trainer.SGD(
- cost=cost,
- parameters=parameters,
- update_equation=optimizer,
- extra_layers=extra_layers)
-```
-
-### 开始训练
-
-```python
-trainer.train(
- reader=train_reader, num_passes=200, event_handler=event_handler)
-```
-
-## 应用模型
-模型训练好后，可以使用下面的代码预测给定图片的类别。
-
-```python
-# load parameters
-with gzip.open('params_pass_10.tar.gz', 'r') as f:
- parameters = paddle.parameters.Parameters.from_tar(f)
-
-file_list = [line.strip() for line in open(image_list_file)]
-test_data = [(paddle.image.load_and_transform(image_file, 256, 224, False)
- .flatten().astype('float32'), )
- for image_file in file_list]
-probs = paddle.infer(
- output_layer=out, parameters=parameters, input=test_data)
-lab = np.argsort(-probs)
-for file_name, result in zip(file_list, lab):
- print "Label of %s is: %d" % (file_name, result[0])
-```
-
-首先从文件中加载训练好的模型（代码里以第10轮迭代的结果为例），然后读取`image_list_file`中的图像。`image_list_file`是一个文本文件，每一行为一个图像路径。代码使用`paddle.infer`判断`image_list_file`中每个图像的类别，并进行输出。
-
-## 使用预训练模型
-为方便进行测试和fine-tuning，我们提供了一些对应于示例中模型配置的预训练模型，目前包括在ImageNet 1000类上训练的ResNet50、ResNet101和Vgg16，请使用`models`目录下的脚本`model_download.sh`进行模型下载，如下载ResNet50可进入`models`目录并执行"`sh model_download.sh ResNet50`"，完成后同目录下的`Paddle_ResNet50.tar.gz`即是训练好的模型，可以在代码中使用如下两种方式进行加载模：
-
-```python
-parameters = paddle.parameters.Parameters.from_tar(gzip.open('Paddle_ResNet50.tar.gz', 'r'))
-```
-
-```python
-parameters = paddle.parameters.create(cost)
-parameters.init_from_tar(gzip.open('Paddle_ResNet50.tar.gz', 'r'))
-```
-
-### 注意事项
-模型压缩包中所含各文件的文件名和模型配置中的参数名一一对应，是加载模型参数的依据。我们提供的预训练模型均使用了示例代码中的配置，如需修改网络配置，请多加注意，需要保证网络配置中的参数名和压缩包中的文件名能够正确对应。
-
-
-
-
-
-
diff --git a/ltr/index.html b/ltr/index.html
deleted file mode 100644
index 59fb2d3260e7d88841ae099fac96b00890463fdf..0000000000000000000000000000000000000000
--- a/ltr/index.html
+++ /dev/null
@@ -1,422 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# 排序学习(Learning To Rank)
-
-排序学习技术\[[1](#参考文献1)\]是构建排序模型的机器学习方法，在信息检索、自然语言处理，数据挖掘等机器学场景中具有重要作用。排序学习的主要目的是对给定一组文档，对任意查询请求给出反映相关性的文档排序。在本例子中，利用标注过的语料库训练两种经典排序模型RankNet[[4](#参考文献4)\]和LamdaRank[[6](#参考文献6)\]，分别可以生成对应的排序模型，能够对任意查询请求，给出相关性文档排序。
-
-RankNet模型在命令行输入：
-
-```bash
-bash ./run_ranknet.sh
-```
-
-LambdaRank模型在命令行输入：
-
-```bash
-bash ./run_lambdarank.sh
-```
-
-用户只需要使用以上命令就完成排序模型的训练和预测，程序会自动下载内置数据集，无需手动下载。
-
-## 背景介绍
-
-排序学习技术随着互联网的快速增长而受到越来越多关注，是机器学习中的常见任务之一。一方面人工排序规则不能处理海量规模的候选数据，另一方面无法为不同渠道的候选数据给于合适的权重，因此排序学习在日常生活中应用非常广泛。排序学习起源于信息检索领域，目前仍然是许多信息检索场景中的核心模块，例如搜索引擎搜索结果排序，推荐系统候选集排序，在线广告排序等等。本例以文档检索任务阐述排序学习模型。
-
-
-
-
-
-
diff --git a/nce_cost/index.html b/nce_cost/index.html
deleted file mode 100644
index 1a7d8271a0f8ee3a951359eda0609044f3cf5542..0000000000000000000000000000000000000000
--- a/nce_cost/index.html
+++ /dev/null
@@ -1,217 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. 排序模型在文档检索的典型应用搜索引擎中的作用
-
-
-图2. 排序模型三类方法
-
-
-图3. RankNet网络结构示意图
-
-
-
-
-
-# 使用噪声对比估计加速语言模型训练
-
-## 为什么需要噪声对比估计
-
-语言模型是许多自然语言处理任务的基础，也是获得词向量表示的一种有效方法。神经概率语言模型（Neural Probabilistic Language Model, NPLM）刻画了词语序列 $\omega_1,...,\omega_T$ 属于某个固定语言的概率 $P(\omega_1^T)$ ：
-$$P(\omega_1^T)= \prod_{t=1}^{T}P(\omega_t|\omega_1^{t-1})$$
-
-为了降低建模和求解的难度，通常会引入一定条件独立假设：词语$w_t$的概率只受之前$n-1$个词语的影响，于是有：
-
-$$ P(\omega_1^T) \approx \prod P(\omega_t|\omega_{t-n-1}^{t-1}) \tag{1}$$
-
-从式($1$)中看到，可以通过建模条件概率 $P(\omega_t|w_{t-n-1},...,\omega_{t-1})$ 进而计算整个序列 $\omega_1,...,\omega_T$ 的概率。于是，我们可以将语言模型求解的任务简单地概括为：
-
-**给定词语序列的向量表示 $h$ ，称之为上下文（context），模型预测下一个目标词语 $\omega$ 的概率。**
-
-在[$n$-gram 语言模型](https://github.com/PaddlePaddle/book/tree/develop/04.word2vec)中，上下文取固定的 $n-1$ 个词，[RNN 语言模型](https://github.com/PaddlePaddle/models/tree/develop/generate_sequence_by_rnn_lm)可以处理任意长度的上下文。
-
-给定上下文 $h$，NPLM 学习一个分值函数（scoring function）$s_\theta(\omega, h)$，$s$ 刻画了上下文 $h$ 向量和所有可能的下一个词的向量表示 $\omega'$ 之间的相似度，再通过在全词表空间对打分函数 $s$ 的取值进行归一化（除以归一化因子 $Z$），得到目标词 $\omega$ 的概率分布，其中：$\theta$ 是可学习参数，这一过程用式($2$)表示，也就是 `Softmax` 函数的计算过程。
-
-$$P_\theta^h(\omega) = \frac{\text{exp}{s_\theta(\omega, h)}}{Z}，Z=\sum_{\omega'} \exp{s_\theta(\omega', h)}\tag{2}$$
-
-极大似然估计（MLE，Maximum Likelihood Estimation）是求解概率($2$)最常用的学习准则。然而，不论是估计概率 $P_\theta^h(\omega)$ 还是计算似然（likelihood）的梯度时，都要计算归一化因子$Z$。$Z$ 的计算随着词典大小线性增长，当训练大规模语言模型时，例如，当词典增长到百万级别甚至更大，训练时间将变得十分漫长，因此，我们**需要其它可能的学习准则，他的求解过程从计算上应该更加轻便可解。**
-
-models 的另一篇介绍了使用[Hsigmoid加速词向量训练](https://github.com/PaddlePaddle/models/tree/develop/hsigmoid) ，这里我们介绍另一种基于采样的提高语言模型训练速度的方法：使用噪声对比估计（Noise-contrastive estimation, NCE）\[[1](#参考文献)\]。
-
-## 什么是噪声对比估计
-
-噪声对比估计是一种基于采样思想的概率密度估计准则，用于估计/拟合：概率函数由非归一化的分值函数和归一化因子两部分构成，这样一类特殊的概率函数\[[1](#参考文献)\] 。噪声对比估计通过构造下面这样一个辅助问题避免在全词典空间计算归一化因子 $Z$ ，从而降低计算代价：
-
-给定上下文 $h$ 和任意已知的噪声分布 $P_n$ ，学习一个二类分类器来拟合：目标 $\omega$ 来自真实分布 $P_\theta$ ($D = 1$) 还是噪声分布 $P_n$（$D = 0$）的概率。假设来自噪声分布的负类样本的数量 $k$ 倍于目标样本，于是有：
-
-$$P(D=1|h,\omega) = \frac{P_\theta(h, \omega)}{P_\theta (h, \omega) + kP_n} \tag{3}$$
-
-我们直接用`Sigmoid`函数来刻画式($3$)这样一个二分类概率：
-
-$$P(D=1|h,\omega) = \sigma (\Delta s_\theta(w,h)) \tag{4}$$
-
-有了上面的问题设置便可以基于二分类来进行极大似然估计：增大正样本的概率同时降低负样本的概率[[2,3](#参考文献)]，也就是最小化下面这样一个损失函数：
-
-$$
-J^h(\theta )=E_{ P_d^h }\left[ \log { P^h(D=1|w,\theta ) } \right] +kE_{ P_n }\left[ \log P^h (D=0|w,\theta ) \right]$$
-$$
- \\\\\qquad =E_{ P_d^h }\left[ \log { \sigma (\Delta s_\theta(w,h)) } \right] +kE_{ P_n }\left[ \log (1-\sigma (\Delta s_\theta(w,h))) \right] \tag{5}$$
-
-式($5$)便是基于噪声对比估计而定义的NCE损失函数，至此，我们还剩下两个问题：
-1. 式($5$)中的 $s_\theta(w,h)$ 是什么？
- - 在神经网络的实现中，$s_\theta(h,\omega)$ 是未归一化的分值。
- - NCE cost 层的可学习参数 $W$ 是一个 $|V| \times d$ 维度的矩阵，$|V|$ 是词典大小，$d$ 是上下文向量$h$的维度；
- - 训练时下一个词的真实类别 $t$ 是正类，从指定的噪声分布中采样 $k$ 个负类样本它们的类别分别记作： $\{n_1, ..., n_k\}$；
- - 抽取 $W$ 中第 $\{t, n_1, ..., n_k\}$ 行（共计 $k + 1$ 行）分别与 $h$ 计算分值 $s_\theta(w,h)$ ，再通过($5$)式计算最终的损失；
-2. 噪声分布如何选择？
- - 实践中，可以任意选择合适的噪声分布（噪声分布暗含着一定的先验）。
- - 最常用选择有：使用基于全词典之上的`unigram`分布（词频统计），无偏的均匀分布。
- - 在PaddlePaddle中用户如果用户未指定噪声分布，默认采用均匀分布。
-
-使用NCE准确训练时，最后一层的计算代价只与负采样数目线性相关，当负采样数目逐渐增大时，NCE 估计准则会收敛到极大似然估计。因此，在使用NCE准则训练时，可以通过控制负采样数目来控制对归一化的概率分布近似的质量。
-
-## 实验数据
-本例采用 Penn Treebank (PTB) 数据集（[Tomas Mikolov预处理版本](http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz)）来训练一个 5-gram 语言模型。PaddlePaddle 提供了 [paddle.dataset.imikolov](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/dataset/imikolov.py) 接口来方便地使用PTB数据。当没有找到下载好的数据时，脚本会自动下载并验证文件的完整性。语料语种为英文，共有42068句训练数据，3761句测试数据。
-
-## 网络结构
-在 5-gram 神经概率语言模型详细网络结构见图1：
-
-
-
-
-
-
diff --git a/nested_sequence/index.html b/nested_sequence/index.html
deleted file mode 100644
index 51f66f93f70eeb7a52e848f190b8e33ead14bbb0..0000000000000000000000000000000000000000
--- a/nested_sequence/index.html
+++ /dev/null
@@ -1,73 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. 5-gram 网络配置结构
-
-
-
-
-
-## 简介
-
-序列是许多机器学习和数据挖掘任务面对的一种输入数据类型，以自然语言处理任务为例：句子由词语构成，而多个句子进一步构成了段落。因此，段落可以看作是一个嵌套的序列（或者叫作：双层序列），这个序列的每个元素又是一个序列。
-
-双层序列是 PaddlePaddle 支持的一种非常灵活的数据组织方式， 能够帮助我们更好地描述段落、多轮对话等更为复杂的数据。以双层序列作为输入，我们可以设计一个层次化的网络，从而更好地完成一些复杂的任务。
-
-本单元将介绍如何在 PaddlePaddle 中使用双层序列。
-
-- [基于双层序列的文本分类](https://github.com/PaddlePaddle/models/tree/develop/nested_sequence/text_classification)
-
-
-
-
-
-
diff --git a/nested_sequence/text_classification/index.html b/nested_sequence/text_classification/index.html
deleted file mode 100644
index 1838415cecd63ec95c4966d31bf0f3d0bf6beb63..0000000000000000000000000000000000000000
--- a/nested_sequence/text_classification/index.html
+++ /dev/null
@@ -1,302 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# 基于双层序列的文本分类
-
-## 简介
-本例将演示如何在 PaddlePaddle 中将长文本输入（通常能达到段落或者篇章基本）组织为双层序列，完成对长文本的分类任务。
-
-## 模型介绍
-我们将一段文本看成句子的序列，而每个句子又是词语的序列。
-
-我们首先用卷积神经网络编码段落中的每一句话；然后，将每句话的表示向量经过池化层得到段落的编码向量；最后将段落的编码向量作为分类器（以softmax层的全连接层）输入，得到最终的分类结果。
-
-**模型结构如下图所示**
-']
- word_col = 1
- lbl_col = 0
-
- for file_name in os.listdir(data_dir):
- file_path = os.path.join(data_dir, file_name)
- if not os.path.isfile(file_path):
- continue
- with open(file_path, "r") as f:
- for line in f:
- line_split = line.strip().split("\t")
- doc = line_split[word_col]
- doc_ids = []
- for sent in doc.strip().split("."):
- sent_ids = [
- word_dict.get(w, UNK_ID)
- for w in sent.split()]
- if sent_ids:
- doc_ids.append(sent_ids)
-
- yield doc_ids, label_dict[line_split[lbl_col]]
-
- return reader
-```
-需要注意的是， 本例中以英文句号`'.'`作为分隔符， 将一段文本分隔为一定数量的句子， 且每个句子表示为对应词表的索引数组（`sent_ids`）。 由于当前样本的表示(`doc_ids`)中包含了该段文本的所有句子， 因此，它的类型为：`paddle.data_type.integer_value_sub_sequence`。
-
-
-3.指定命令行参数进行训练
-
-`train.py`训练脚本中包含以下参数：
-```
-Options:
- --train_data_dir TEXT The path of training dataset (default: None). If
- this parameter is not set, imdb dataset will be
- used.
- --test_data_dir TEXT The path of testing dataset (default: None). If this
- parameter is not set, imdb dataset will be used.
- --word_dict_path TEXT The path of word dictionary (default: None). If this
- parameter is not set, imdb dataset will be used. If
- this parameter is set, but the file does not exist,
- word dictionay will be built from the training data
- automatically.
- --label_dict_path TEXT The path of label dictionary (default: None).If this
- parameter is not set, imdb dataset will be used. If
- this parameter is set, but the file does not exist,
- label dictionay will be built from the training data
- automatically.
- --model_save_dir TEXT The path to save the trained models (default:
- 'models').
- --help Show this message and exit.
-```
-
-修改`train.py`脚本中的启动参数，可以直接运行本例。 以`data`目录下的示例数据为例，在终端执行：
-```bash
-python train.py \
- --train_data_dir 'data/train_data' \
- --test_data_dir 'data/test_data' \
- --word_dict_path 'word_dict.txt' \
- --label_dict_path 'label_dict.txt'
-```
-即可对样例数据进行训练。
-
-### 预测
-
-1.指定命令行参数
-
-`infer.py`训练脚本中包含以下参数：
-
-```
-Options:
- --data_path TEXT The path of data for inference (default: None). If
- this parameter is not set, imdb test dataset will be
- used.
- --model_path TEXT The path of saved model. [required]
- --word_dict_path TEXT The path of word dictionary (default: None). If this
- parameter is not set, imdb dataset will be used.
- --label_dict_path TEXT The path of label dictionary (default: None).If this
- parameter is not set, imdb dataset will be used.
- --batch_size INTEGER The number of examples in one batch (default: 32).
- --help Show this message and exit.
-```
-
-2.以`data`目录下的示例数据为例，在终端执行：
-```bash
-python infer.py \
- --data_path 'data/infer.txt' \
- --word_dict_path 'word_dict.txt' \
- --label_dict_path 'label_dict.txt' \
- --model_path 'models/params_pass_00000.tar.gz'
-```
-
-即可对样例数据进行预测。
-
-
-
-
-
-
diff --git a/neural_qa/index.html b/neural_qa/index.html
deleted file mode 100644
index 53786d97abb674d298d151437035e4bdfc6b9321..0000000000000000000000000000000000000000
--- a/neural_qa/index.html
+++ /dev/null
@@ -1,188 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. 基于双层序列的文本分类模型
-
-
-
-
-
-# Neural Recurrent Sequence Labeling Model for Open-Domain Factoid Question Answering
-
-This model implements the work in the following paper:
-
-Peng Li, Wei Li, Zhengyan He, Xuguang Wang, Ying Cao, Jie Zhou, and Wei Xu. Dataset and Neural Recurrent Sequence Labeling Model for Open-Domain Factoid Question Answering. [arXiv:1607.06275](https://arxiv.org/abs/1607.06275).
-
-If you use the dataset/code in your research, please cite the above paper:
-
-```text
-@article{li:2016:arxiv,
- author = {Li, Peng and Li, Wei and He, Zhengyan and Wang, Xuguang and Cao, Ying and Zhou, Jie and Xu, Wei},
- title = {Dataset and Neural Recurrent Sequence Labeling Model for Open-Domain Factoid Question Answering},
- journal = {arXiv:1607.06275v2},
- year = {2016},
- url = {https://arxiv.org/abs/1607.06275v2},
-}
-```
-
-
-## Installation
-
-1. Install PaddlePaddle v0.10.5 by the following commond. Note that v0.10.0 is not supported.
- ```bash
- # either one is OK
- # CPU
- pip install paddlepaddle
- # GPU
- pip install paddlepaddle-gpu
- ```
-2. Download the [WebQA](http://idl.baidu.com/WebQA.html) dataset by running
- ```bash
- cd data && ./download.sh && cd ..
- ```
-
-## Hyperparameters
-
-All the hyperparameters are defined in `config.py`. The default values are aligned with the paper.
-
-## Training
-
-Training can be launched using the following command:
-
-```bash
-PYTHONPATH=data/evaluation:$PYTHONPATH python train.py 2>&1 | tee train.log
-```
-## Validation and Test
-
-WebQA provides two versions of validation and test sets. Automatic validation and test can be lauched by
-
-```bash
-PYTHONPATH=data/evaluation:$PYTHONPATH python val_and_test.py models [ann|ir]
-```
-
-where
-
-* `models`: the directory where model files are stored. You can use `models` if `config.py` is not changed.
-* `ann`: using the validation and test sets with annotated evidence.
-* `ir`: using the validation and test sets with retrieved evidence.
-
-Note that validation and test can run simultaneously with training. `val_and_test.py` will handle the synchronization related problems.
-
-Intermediate results are stored in the directory `tmp`. You can delete them safely after validation and test.
-
-The results should be comparable with those shown in Table 3 in the paper.
-
-## Inferring using a Trained Model
-
-Infer using a trained model by running:
-```bash
-PYTHONPATH=data/evaluation:$PYTHONPATH python infer.py \
- MODEL_FILE \
- INPUT_DATA \
- OUTPUT_FILE \
- 2>&1 | tee infer.log
-```
-
-where
-
-* `MODEL_FILE`: a trained model produced by `train.py`.
-* `INPUT_DATA`: input data in the same format as the validation/test sets of the WebQA dataset.
-* `OUTPUT_FILE`: results in the format specified in the WebQA dataset for the evaluation scripts.
-
-## Pre-trained Models
-
-We have provided two pre-trained models, one for the validation and test sets with annotated evidence, and one for those with retrieved evidence. These two models are selected according to the performance on the corresponding version of validation set, which is consistent with the paper.
-
-The models can be downloaded with
-```bash
-cd pre-trained-models && ./download-models.sh && cd ..
-```
-
-The evaluation result on the test set with annotated evidence can be achieved by
-
-```bash
-PYTHONPATH=data/evaluation:$PYTHONPATH python infer.py \
- pre-trained-models/params_pass_00010.tar.gz \
- data/data/test.ann.json.gz \
- test.ann.output.txt.gz
-
-PYTHONPATH=data/evaluation:$PYTHONPATH \
- python data/evaluation/evaluate-tagging-result.py \
- test.ann.output.txt.gz \
- data/data/test.ann.json.gz \
- --fuzzy --schema BIO2
-# The result should be
-# chunk_f1=0.739091 chunk_precision=0.686119 chunk_recall=0.800926 true_chunks=3024 result_chunks=3530 correct_chunks=2422
-```
-
-And the evaluation result on the test set with retrieved evidence can be achieved by
-
-```bash
-PYTHONPATH=data/evaluation:$PYTHONPATH python infer.py \
- pre-trained-models/params_pass_00021.tar.gz \
- data/data/test.ir.json.gz \
- test.ir.output.txt.gz
-
-PYTHONPATH=data/evaluation:$PYTHONPATH \
- python data/evaluation/evaluate-voting-result.py \
- test.ir.output.txt.gz \
- data/data/test.ir.json.gz \
- --fuzzy --schema BIO2
-# The result should be
-# chunk_f1=0.749358 chunk_precision=0.727868 chunk_recall=0.772156 true_chunks=3024 result_chunks=3208 correct_chunks=2335
-```
-
-
-
-
-
-
diff --git a/nmt_without_attention/index.html b/nmt_without_attention/index.html
deleted file mode 100644
index cf610710ddec3b6510d1fa48ce414c4a441aa59a..0000000000000000000000000000000000000000
--- a/nmt_without_attention/index.html
+++ /dev/null
@@ -1,412 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# Neural Machine Translation Model
-
-## Background Introduction
-Neural Machine Translation (NMT) is a simple new architecture for getting machines to learn to translate. Traditional machine translation methods are mainly based on phrase-based statistical translation approaches that use separately engineered subcomponents rules or statistical models. NMT models use deep learning and representation learning. This example describes how to construct an end-to-end neural machine translation (NMT) model using the recurrent neural network (RNN) in PaddlePaddle.
-
-## Model Overview
-RNN-based neural machine translation follows the encoder-decoder architecture. A common choice for the encoder and decoder is the recurrent neural network (RNN), used by most NMT models. Below is an example diagram of a general approach for NMT.
-
-
--4.445528 They know their businesses better than anyone .
--5.026885 They know their business better than anybody .
-
-```
-- The first line of input for the source language.
-- Second ~ beam_size + 1 line is the result of the `beam_size` translation generated by the column search
- - the output of the same row is separated into two columns by "\ t", the first column is the log probability of the sentence, and the second column is the text of the translation result.
- - the symbol `` represents the beginning of the sentence, the symbol `` indicates the end of a sentence, and if there is a word that is not included in the dictionary, it is replaced with the symbol ``.
-
-So far, we have implemented a basic machine translation model using PaddlePaddle. We can see, PaddlePaddle provides a flexible and rich API. This enables users to easily choose and use a various complex network configuration. NMT itself is also a rapidly developing field, and many new ideas continue to emerge. This example is a basic implementation of NMT. Users can also implement more complex NMT models using PaddlePaddle.
-
-
-## References
-[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 exclusive learning to align and translate] (https://arxiv.org/abs/1409.0473) [C]. Proceedings of ICLR 2015, 2015
-
-
-
-
-
-
diff --git a/scene_text_recognition/index.html b/scene_text_recognition/index.html
deleted file mode 100644
index 4331b2b9636c159aedc1e96f0731e44cca9889cf..0000000000000000000000000000000000000000
--- a/scene_text_recognition/index.html
+++ /dev/null
@@ -1,192 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Figure 1. Encoder - Decoder frame
-
-The input and output of the neural machine translation model can be any of character, word or phrase. This example illustrates the word-based NMT.
-
-- **Encoder**: Encodes the source language sentence into a vector as input to the decoder. The original input of the decoder is the `id` sequence $ w = {w_1, w_2, ..., w_T} $ of the word, expressed in the one-hot code. In order to reduce the input dimension, and to establish the semantic association between words, the model is a word that is expressed by hot independent code. Word embedding is a word vector. For more information about word vector, please refer to PaddleBook [word vector] (https://github.com/PaddlePaddle/book/blob/develop/04.word2vec/README.cn.md) chapter. Finally, the RNN unit processes the input word by word to get the encoding vector of the complete sentence.
-
-- **Decoder**: Accepts the input of the encoder, decoding the target language sequence $ u = {u_1, u_2, ..., u_ {T '}} $ one by one. For each time step, the RNN unit outputs a hidden vector. Then the conditional probability of the next target word is calculated by `Softmax` normalization, i.e. $ P (u_i | w, u_1, u_2, ..., u_ {t- 1}) $. Thus, given the input $ w $, the corresponding translation result is $ 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})$$
-
-In Chinese to English translation, for example, the source language is Chinese, and the target language is English. The following is a sentence after the source language word segmentation.
-
-```
-祝愿 祖国 繁荣 昌盛
-```
-
-Corresponding target language English translation results for:
-
-```
-Wish motherland rich and powerful
-```
-
-In the preprocessing step, we prepare the parallel corpus data of the source language and the target language. Then we construct the dictionaries of the source language and the target language respectively. In the training stage, we use the pairwise parallel corpus training model. In the model test stage, the model automatically generates the corresponding English translation, and then it evaluates the resulting results with standard translations. For the evaluation metric, BLEU is most commonly used.
-
-### RNN unit
-The original structure of the RNN uses a vector to store the hidden state. However, the RNN of this structure is prone to have gradient vanishing problem, which is difficult to model for a long time. This issue can be addressed by using LSTM \[[1](#References)] and GRU (Gated Recurrent Unit) \[[2](#References)]. This solves the problem of long-term dependency by carefully forgetting the previous information. In this example, we demonstrate the GRU based model.
-
-
-
-图 2. GRU 单元
-
-
-Figure 3. Bi-directional encoder structure diagram
-
-
-
-
-
-# 场景文字识别 (STR, Scene Text Recognition)
-
-## STR任务简介
-
-许多场景图像中包含着丰富的文本信息，它们可以从很大程度上帮助人们去认知场景图像的内容及含义，因此场景图像中的文本识别对所在图像的信息获取具有极其重要的作用。同时，场景图像文字识别技术的发展也促进了一些新型应用的产生，例如：\[[1](#参考文献)\]通过使用深度学习模型来自动识别路牌中的文字，帮助街景应用获取更加准确的地址信息。
-
-本例将演示如何用 PaddlePaddle 完成 **场景文字识别 (STR, Scene Text Recognition)** 。任务如下图所示，给定一张场景图片，`STR` 需要从中识别出对应的文字"keep"。
-
-
-
-
-
-
diff --git a/scheduled_sampling/index.html b/scheduled_sampling/index.html
deleted file mode 100644
index 8d327c4b1ad687ef18ca81302cf6dccf049cab51..0000000000000000000000000000000000000000
--- a/scheduled_sampling/index.html
+++ /dev/null
@@ -1,277 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图 1. 输入数据示例 "keep"
-
-
-
-
-
-# Scheduled Sampling
-
-## 概述
-
-序列生成任务的生成目标是在给定源输入的条件下，最大化目标序列的概率。训练时该模型将目标序列中的真实元素作为解码器每一步的输入，然后最大化下一个元素的概率。生成时上一步解码得到的元素被用作当前的输入，然后生成下一个元素。可见这种情况下训练阶段和生成阶段的解码器输入数据的概率分布并不一致。
-
-Scheduled Sampling \[[1](#参考文献)\]是一种解决训练和生成时输入数据分布不一致的方法。在训练早期该方法主要使用目标序列中的真实元素作为解码器输入，可以将模型从随机初始化的状态快速引导至一个合理的状态。随着训练的进行，该方法会逐渐更多地使用生成的元素作为解码器输入，以解决数据分布不一致的问题。
-
-标准的序列到序列模型中，如果序列前面生成了错误的元素，后面的输入状态将会收到影响，而该误差会随着生成过程不断向后累积。Scheduled Sampling以一定概率将生成的元素作为解码器输入，这样即使前面生成错误，其训练目标仍然是最大化真实目标序列的概率，模型会朝着正确的方向进行训练。因此这种方式增加了模型的容错能力。
-
-## 算法简介
-Scheduled Sampling主要应用在序列到序列模型的训练阶段，而生成阶段则不需要使用。
-
-训练阶段解码器在最大化第$t$个元素概率时，标准序列到序列模型使用上一时刻的真实元素$y_{t-1}$作为输入。设上一时刻生成的元素为$g_{t-1}$，Scheduled Sampling算法会以一定概率使用$g_{t-1}$作为解码器输入。
-
-设当前已经训练到了第$i$个mini-batch，Scheduled Sampling定义了一个概率$\epsilon_i$控制解码器的输入。$\epsilon_i$是一个随着$i$增大而衰减的变量，常见的定义方式有：
-
- - 线性衰减：$\epsilon_i=max(\epsilon,k-c*i)$，其中$\epsilon$限制$\epsilon_i$的最小值，$k$和$c$控制线性衰减的幅度。
-
- - 指数衰减：$\epsilon_i=k^i$，其中$01$，$k$同样控制衰减的幅度。
-
-图1给出了这三种方式的衰减曲线，
-
-
-
-
-
-
diff --git a/sequence_tagging_for_ner/index.html b/sequence_tagging_for_ner/index.html
deleted file mode 100644
index 389f4d502c94af9f46a5e5af0a7e3c812dca8d2f..0000000000000000000000000000000000000000
--- a/sequence_tagging_for_ner/index.html
+++ /dev/null
@@ -1,236 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. 线性衰减、指数衰减和反向Sigmoid衰减的衰减曲线
-
-
-图2. Scheduled Sampling选择不同元素作为解码器输入示意图
-
-
-
-
-
-# 命名实体识别
-
-以下是本例的简要目录结构及说明：
-
-```text
-.
-├── data # 存储运行本例所依赖的数据
-│ ├── download.sh
-├── images # README 文档中的图片
-├── index.html
-├── infer.py # 测试脚本
-├── network_conf.py # 模型定义
-├── reader.py # 数据读取接口
-├── README.md # 文档
-├── train.py # 训练脚本
-└── utils.py # 定义同样的函数
-```
-
-
-## 简介
-
-命名实体识别（Named Entity Recognition，NER）又称作“专名识别”，是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等，是自然语言处理研究的一个基础问题。NER任务通常包括实体边界识别、确定实体类别两部分，可以将其作为序列标注问题解决。
-
-序列标注可以分为Sequence Classification、Segment Classification和Temporal Classification三类[[1](#参考文献)]，本例只考虑Segment Classification，即对输入序列中的每个元素在输出序列中给出对应的标签。对于NER任务，由于需要标识边界，一般采用[BIO标注方法](http://book.paddlepaddle.org/07.label_semantic_roles/)定义的标签集，如下是一个NER的标注结果示例：
-
-
-
-
-
-
diff --git a/ssd/index.html b/ssd/index.html
deleted file mode 100644
index 6a2788901657e770a0e2f320637bdf3c705e19d9..0000000000000000000000000000000000000000
--- a/ssd/index.html
+++ /dev/null
@@ -1,293 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. BIO标注方法示例
-
-
-图2. NER 模型网络结构图
-
-
-
-
-
-# Single Shot MultiBox Detector (SSD) Object Detection
-
-## Introduction
-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.
-
-## 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)
-
-
-
-
-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 Data set
-
-### 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
-def prepare_filelist(devkit_dir, years, output_dir):
- trainval_list = []
- test_list = []
- for year in years:
- trainval, test = walk_dir(devkit_dir, year)
- trainval_list.extend(trainval)
- test_list.extend(test)
- random.shuffle(trainval_list)
- with open(osp.join(output_dir, 'trainval.txt'), 'w') as ftrainval:
- for item in trainval_list:
- ftrainval.write(item[0] + ' ' + item[1] + '\n')
-
- with open(osp.join(output_dir, 'test.txt'), 'w') as ftest:
- for item in test_list:
- ftest.write(item[0] + ' ' + item[1] + '\n')
-```
-
-The data in ```trainval.txt``` will look like:
-
-```
-VOCdevkit/VOC2007/JPEGImages/000005.jpg VOCdevkit/VOC2007/Annotations/000005.xml
-VOCdevkit/VOC2007/JPEGImages/000007.jpg VOCdevkit/VOC2007/Annotations/000007.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
-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```。
-
-### 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
-paddle.init(use_gpu=True, trainer_count=4)
-data_args = data_provider.Settings(
- data_dir='./data',
- label_file='label_list',
- resize_h=cfg.IMG_HEIGHT,
- resize_w=cfg.IMG_WIDTH,
- mean_value=[104,117,124])
-train(train_file_list='./data/trainval.txt',
- dev_file_list='./data/test.txt',
- data_args=data_args,
- init_model_path='./vgg/vgg_model.tar.gz')
-```
-
-Below is a description about this script:
-
-1. Call ```paddle.init``` with 4 GPUs.
-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. 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. 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).
-
-The following shows the SDD300x300 in the VOC data set.
-
-
-
-
-
-
diff --git a/text_classification/index.html b/text_classification/index.html
deleted file mode 100644
index 21e4e14dacb01f9ed373798d27e3f8482f2cd13c..0000000000000000000000000000000000000000
--- a/text_classification/index.html
+++ /dev/null
@@ -1,262 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-图1. SSD网络结构
-
| File | Description |
|---|---|
| train.py | Training script |
| eval.py | Evaluation |
| infer.py | Prediction using the trained model |
| visual.py | Visualization of the test results |
| image_util.py | Image preprocessing required common function |
| data_provider.py | Data processing scripts, generate training, evaluate or detect the required data |
| config/pascal_voc_conf.py | Neural network hyperparameter configuration file |
| data/label_list | Label list |
| data/prepare_voc_data.py | Prepare training PASCAL VOC data list |
-
-图2. SSD300x300 mAP收敛曲线
-
-
-
-
-
-Figure 3. SSD300x300 Visualization Example
-
-
-
-
-
-# 文本分类
-
-以下是本例目录包含的文件以及对应说明:
-
-```text
-.
-├── images # 文档中的图片
-│ ├── cnn_net.png
-│ └── dnn_net.png
-├── index.html # 文档
-├── infer.py # 预测脚本
-├── network_conf.py # 本例中涉及的各种网络结构均定义在此文件中，若进一步修改模型结构，请查看此文件
-├── reader.py # 读取数据接口，若使用自定义格式的数据，请查看此文件
-├── README.md # 文档
-├── run.sh # 训练任务运行脚本，直接运行此脚本，将以默认参数开始训练任务
-├── train.py # 训练脚本
-└── utils.py # 定义通用的函数，例如：打印日志、解析命令行参数、构建字典、加载字典等
-```
-
-## 简介
-文本分类任务根据给定一条文本的内容，判断该文本所属的类别，是自然语言处理领域的一项重要的基础任务。[PaddleBook](https://github.com/PaddlePaddle/book) 中的[情感分类](https://github.com/PaddlePaddle/book/blob/develop/06.understand_sentiment/README.cn.md)一课，正是一个典型的文本分类任务，任务流程如下：
-
-1. 收集电影评论网站的用户评论数据。
-2. 清洗，标记。
-3. 模型设计。
-4. 模型学习效果评估。
-
-训练好的分类器能够**自动判断**新出现的用户评论的情感是正面还是负面，在舆情监控、营销策划、产品品牌价值评估等任务中，能够起到重要作用。以上过程也是我们去完成一个新的文本分类任务需要遵循的常规流程。可以看到，深度学习方法的巨大优势体现在：**免除复杂的特征的设计，只需要对原始文本进行基础的清理、标注即可**。
-
-[PaddleBook](https://github.com/PaddlePaddle/book) 中的[情感分类](https://github.com/PaddlePaddle/book/blob/develop/06.understand_sentiment/README.cn.md)介绍了一个较为复杂的栈式双向 LSTM 模型，循环神经网络在一些需要理解语言语义的复杂任务中有着明显的优势，但计算量大，通常对调参技巧也有着更高的要求。在对计算时间有一定限制的任务中，也会考虑其它模型。除了计算时间的考量，更重要的一点：**模型选择往往是机器学习任务成功的基础**。机器学习任务的目标始终是提高泛化能力，也就是对未知的新的样本预测的能力：
-
-1. 简单模型拟合能力不足，无法精确拟合训练样本，更加无法期待模型能够准确地预测没有出现在训练样本集中的未知样本，这就是**欠拟合**问题。
-2. 然而，过于复杂的模型轻松“记忆”了训练样本集中的每一个样本，但对于没有出现在训练样本集中的未知样本却毫无识别能力，这就是**过拟合**问题。
-
-"No Free Lunch (NFL)" 是机器学习任务基本原则之一：没有任何一种模型是天生优于其他模型的。模型的设计和选择建立在了解不同模型特性的基础之上，但同时也是一个多次实验评估的过程。在本例中，我们继续向大家介绍几种最常用的文本分类模型，它们的能力和复杂程度不同，帮助大家对比学习这些模型学习效果之间的差异，针对不同的场景选择使用。
-
-## 模型详解
-
-`network_conf.py` 中包括以下模型：
-
-1. `fc_net`： DNN 模型，是一个非序列模型。使用基本的全连接结构。
-2. `convolution_net`：浅层 CNN 模型，是一个基础的序列模型，能够处理变长的序列输入，提取一个局部区域之内的特征。
-
-我们以情感分类任务为例，简单说明序列模型和非序列模型之间的差异。情感分类是一项常见的文本分类任务，模型自动判断文本中表现出的情感是正向还是负向。以句子 "The apple is not bad" 为例，"not bad" 是决定这个句子情感的关键：
-
-- 对于 DNN 模型来说，只知道句子中有一个 "not" 和一个 "bad"，两者之间的顺序关系在输入网络时已丢失，网络不再有机会学习序列之间的顺序信息。
-- CNN 模型接受文本序列作为输入，保留了 "not bad" 之间的顺序信息。
-
-两者各自的一些特点简单总结如下：
-
-1. DNN 的计算量可以远低于 CNN / RNN 模型，在对响应时间有要求的任务中具有优势。
-2. DNN 刻画的往往是频繁词特征，潜在会受到分词错误的影响，但对一些依赖关键词特征也能做的不错的任务：如 Spam 短信检测，依然是一个有效的模型。
-3. 在大多数需要一定语义理解（例如，借助上下文消除语义中的歧义）的文本分类任务上，以 CNN / RNN 为代表的序列模型的效果往往好于 DNN 模型。
-
-### 1. DNN 模型
-
-**DNN 模型结构入下图所示：**
-
- gave a much better of the films plot details than i could what i recall mostly is that it was just so beautiful in every sense emotionally visually just br if you like movies that are wonderful to look at and also have emotional content to which that beauty is relevant i think you will be glad to have seen this extraordinary and unusual work of br on a scale of 1 to 10 id give it about an the only reason i shy away from 9 is that it is a mood piece if you are in the mood for a really artistic very romantic film then its a 10 i definitely think its a mustsee but none of us can be in that mood all the time so overall
-negative 0.0300 0.9700 i love scifi and am willing to put up with a lot scifi are usually and i tried to like this i really did but it is to good tv scifi as 5 is to star trek the original silly cheap cardboard sets stilted dialogues cg that doesnt match the background and painfully onedimensional characters cannot be overcome with a scifi setting im sure there are those of you out there who think 5 is good scifi tv its not its clichéd and while us viewers might like emotion and character development scifi is a genre that does not take itself seriously star trek it may treat important issues yet not as a serious philosophy its really difficult to care about the characters here as they are not simply just missing a of life their actions and reactions are wooden and predictable often painful to watch the makers of earth know its rubbish as they have to always say gene earth otherwise people would not continue watching must be turning in their as this dull cheap poorly edited watching it without breaks really brings this home of a show into space spoiler so kill off a main character and then bring him back as another actor all over again
-```
-
-输出日志每一行是对一条样本预测的结果，以 `\t` 分隔，共 3 列，分别是：（1）预测类别标签；（2）样本分别属于每一类的概率，内部以空格分隔；（3）输入文本。
-
-## 使用自定义数据训练和预测
-
-### 如何训练
-
-1. 数据组织
-
- 假设有如下格式的训练数据：每一行为一条样本，以 `\t` 分隔，第一列是类别标签，第二列是输入文本的内容，文本内容中的词语以空格分隔。以下是两条示例数据：
-
- ```
- positive PaddlePaddle is good
- negative What a terrible weather
- ```
-
-2. 编写数据读取接口
-
- 自定义数据读取接口只需编写一个 Python 生成器实现**从原始输入文本中解析一条训练样本**的逻辑。以下代码片段实现了读取原始数据返回类型为： `paddle.data_type.integer_value_sequence`（词语在字典的序号）和 `paddle.data_type.integer_value`（类别标签）的 2 个输入给网络中定义的 2 个 `data_layer` 的功能。
- ```python
- def train_reader(data_dir, word_dict, label_dict):
- def reader():
- UNK_ID = word_dict[""]
- word_col = 0
- lbl_col = 1
-
- for file_name in os.listdir(data_dir):
- with open(os.path.join(data_dir, file_name), "r") as f:
- for line in f:
- line_split = line.strip().split("\t")
- word_ids = [
- word_dict.get(w, UNK_ID)
- for w in line_split[word_col].split()
- ]
- yield word_ids, label_dict[line_split[lbl_col]]
-
- return reader
- ```
-
- - 关于 PaddlePaddle 中 `data_layer` 接受输入数据的类型，以及数据读取接口对应该返回数据的格式，请参考 [input-types](http://www.paddlepaddle.org/release_doc/0.9.0/doc_cn/ui/data_provider/pydataprovider2.html#input-types) 一节。
- - 以上代码片段详见本例目录下的 `reader.py` 脚本，`reader.py` 同时提供了读取测试数据的全部代码。
-
- 接下来，只需要将数据读取函数 `train_reader` 作为参数传递给 `train.py` 脚本中的 `paddle.batch` 接口即可使用自定义数据接口读取数据，调用方式如下：
-
- ```python
- train_reader = paddle.batch(
- paddle.reader.shuffle(
- reader.train_reader(train_data_dir, word_dict, lbl_dict),
- buf_size=1000),
- batch_size=batch_size)
- ```
-
-3. 修改命令行参数
-
- - 如果将数据组织成示例数据的同样的格式，只需在 `run.sh` 脚本中修改 `train.py` 启动参数，指定 `train_data_dir` 参数，可以直接运行本例，无需修改数据读取接口 `reader.py`。
- - 执行 `python train.py --help` 可以获取`train.py` 脚本各项启动参数的详细说明，主要参数如下：
- - `nn_type`：选择要使用的模型，目前支持两种：“dnn” 或者 “cnn”。
- - `train_data_dir`：指定训练数据所在的文件夹，使用自定义数据训练，必须指定此参数，否则使用`paddle.dataset.imdb`训练，同时忽略`test_data_dir`，`word_dict`，和 `label_dict` 参数。
- - `test_data_dir`：指定测试数据所在的文件夹，若不指定将不进行测试。
- - `word_dict`：字典文件所在的路径，若不指定，将从训练数据根据词频统计，自动建立字典。
- - `label_dict`：类别标签字典，用于将字符串类型的类别标签，映射为整数类型的序号。
- - `batch_size`：指定多少条样本后进行一次神经网络的前向运行及反向更新。
- - `num_passes`：指定训练多少个轮次。
-
-### 如何预测
-
-1. 修改 `infer.py` 中以下变量，指定使用的模型、指定测试数据。
-
- ```python
- model_path = "dnn_params_pass_00000.tar.gz" # 指定模型所在的路径
- nn_type = "dnn" # 指定测试使用的模型
- test_dir = "./data/test" # 指定测试文件所在的目录
- word_dict = "./data/dict/word_dict.txt" # 指定字典所在的路径
- label_dict = "./data/dict/label_dict.txt" # 指定类别标签字典的路径
- ```
-2. 在终端中执行 `python infer.py`。
-
-
-
-
-
-
-
-图1. 本例中的 DNN 文本分类模型
-
-
-图2. 本例中的 CNN 文本分类模型
-