add Chinese translation (#661)

df4f05c7 · Chi Song · GitHub · b38c0431 · df4f05c7 · df4f05c7
Unverified Commit df4f05c7 authored Jan 31, 2019 by Chi Song Committed by GitHub Jan 31, 2019
20 changed files
--- a/README.md
+++ b/README.md
@@ -11,6 +11,8 @@
 [![Pull Requests](https://img.shields.io/github/issues-pr-raw/Microsoft/nni.svg)](https://github.com/Microsoft/nni/pulls?q=is%3Apr+is%3Aopen)
 [![Version](https://img.shields.io/github/release/Microsoft/nni.svg)](https://github.com/Microsoft/nni/releases) [![Join the chat at https://gitter.im/Microsoft/nni](https://badges.gitter.im/Microsoft/nni.svg)](https://gitter.im/Microsoft/nni?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[简体中文](zh_CN/README.md)
 NNI (Neural Network Intelligence) is a toolkit to help users run automated machine learning (AutoML) experiments. 
 The tool dispatches and runs trial jobs generated by tuning algorithms to search the best neural architecture and/or hyper-parameters in different environments like local machine, remote servers and cloud.

--- a/docs/RELEASE.md
+++ b/docs/RELEASE.md
@@ -79,8 +79,8 @@
 * [Kubeflow Training service](./KubeflowMode.md)
  * Support tf-operator
  * [Distributed trial example](https://github.com/Microsoft/nni/tree/master/examples/trials/mnist-distributed/dist_mnist.py) on Kubeflow
-* [Grid search tuner](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/README.md#Grid) 
+* [Grid search tuner](Builtin_Tuner.md#GridSearch) 
-* [Hyperband tuner](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/README.md#Hyperband)
+* [Hyperband tuner](Builtin_Tuner.md#Hyperband)
 * Support launch NNI experiment on MAC
 * WebUI
  * UI support for hyperband tuner

--- a/zh_CN/README.Makefile.md
+++ b/zh_CN/README.Makefile.md
+# Makefile 文件和安装配置
+NNI 使用 GNU 来生成和安装。
+`Makefile` 提供标准的目标 `生成`、`安装` 和 `卸载`, 以及不同设置的安装对象：
+* `easy-install`: 针对非专家用户，自动处理所有内容；
+* `dev-easy-install`: 针对专家用户，自动处理所有内容；
+* `install`: 针对 NNI 普通用户，通过复制文件来安装 NNI;
+* `dev-install`: 针对 NNI 贡献者，通过创建 symlinks 而不是复制文件来安装 NNI;
+* `pip-install`: 针对使用 `setup.py` 安装的情况;
+下文会有更详细的介绍。
+## 依赖项
+NNI 依赖于 Node.js, Yarn, 和 pip 来生成，推荐安装 TypeScript。
+NNI 需要 Node.js 以及运行所需要的所有库。 需要的 Node.js 库 (包括 TypeScript) 可以通过 Yarn 来安装， 需要的 Python 库可以通过 setuptools 或者 PIP 来安装。
+NNI *用户*可以用 `make install-dependencies` 来安装 Node.js 和 Yarn。 Node.js 会被安装到 NNI 的安装目录，Yarn 会被安装到 `/tmp/nni-yarn`。 安装过程需要 wget。
+NNI *开发人员*推荐手工安装 Node.js 和 Yarn。 可浏览相应的官方文档了解安装过程。
+## 生成 NNI
+当依赖项安装好后，运行 `make` 即可。
+## 安装
+### 目录层次
+NNI 项目主要由两个 Node.js 模块 (`nni_manager`, `webui`) 以及两个 Python 包 (`nni`, `nnictl`) 所组成。
+默认情况下，Node.js 模块可以为所有用户安装在 `/usr/share/nni` 目录下，也可为只安装在当前用户的 `~/.local/nni` 目录下。
+Python 包使用 setuptools 安装，所以安装路径依赖于 Python 配置。 如果为没有权限的用户安装，并且没有虚拟环境的时候，要加上 `--user` 参数。
+此外，`nnictl` 是一个 bash 脚本，会被安装在 `/usr/share/bash-completion/completions` 或 `~/.bash_completion.d` 目录下。
+在某些配置情况下，NNI 也会将 Node.js 安装到 `/usr/share/nni` 目录下。
+以上所有目录都可以配置。 可参考下一章节。
+### 配置
+`Makefile` 中可以用环境变量来替换默认设置。
+支持的变量如下：
+| 名称                 | 说明                             | 普通用户下的默认值                          | root 下的默认值                                      |
+| ------------------ | ------------------------------ | ---------------------------------- | ----------------------------------------------- |
+| `BIN_PATH`         | 执行文件路径                         | `~/.local/bin`                     | `/usr/bin`                                      |
+| `INSTALL_PREFIX`   | Node.js 模块的路径 (最后会加上 `nni`)    | `~/.local`                         | `/usr/share`                                    |
+| `BASH_COMP_SCRIPT` | Bash 自动完成脚本的路径                 | `~/.bash_completion.d/nnictl`      | `/usr/share/bash-completion/completions/nnictl` |
+| `PIP_MODE`         | `python3 setup.py install` 的参数 | 如果 `VIRTUAL_ENV` 没有设置，会加上 `--user` | (无)                                             |
+| `NODE_PATH`        | Node.js 运行时的路径                 | `$INSTALL_PREFIX/nni/node`         | `$INSTALL_PREFIX/nni/node`                      |
+| `YARN_PATH`        | Yarn 的安装路径                     | `/tmp/nni-yarn`                    | `/tmp/nni-yarn`                                 |
+| `NODE`             | Node.js 命令                     | 参考源代码                              | 参考源代码                                           |
+| `YARN`             | Yarn 命令                        | 参考源代码                              | 参考源代码                                           |
+注意，这些变量不仅会影响安装路径，也会影响申城的 `nnictl` 和 `nnimanager` 脚本。 如果复制文件的路径和运行时的不一样（例如，创建发行版本包时），需要手工编辑 `nnictl` 和 `nnimanager`。
+### 目标
+安装目标的流程如下：
+| 目标                 | 流程                                               |
+| ------------------ | ------------------------------------------------ |
+| `easy-install`     | 安装依赖项，生成，安装 NNI，并编辑 `~/.bashrc`                  |
+| `dev-easy-install` | 安装依赖项，生成，将 NNI 作为 symlinks 来安装，并编辑 `~/.bashrc`   |
+| `install`          | 安装 Python 包，Node.js 模块，NNI 脚本和样例                 |
+| `dev-install`      | 将 Python 和 Node.js 模块作为 symlinks 安装，然后安装 scripts |
+| `pip-install`      | 安装依赖项，生成，安装 NNI，但不安装 Python 包                    |
+## TODO
+* `clean` 目标
+* `test` 目标
+* `lint` 目标
+* 每个目标的测试用例
+* 评审变量
\ No newline at end of file
--- a/zh_CN/README.md
+++ b/zh_CN/README.md
+<p align="center">
+<img src="https://microsoft.github.io/nni/docs/img/nni_logo.png" width="300"/>
+</p>
+* * *
+[![MIT 许可证](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://github.com/Microsoft/nni/blob/master/LICENSE) [![生成状态](https://msrasrg.visualstudio.com/NNIOpenSource/_apis/build/status/Microsoft.nni)](https://msrasrg.visualstudio.com/NNIOpenSource/_build/latest?definitionId=6) [![问题](https://img.shields.io/github/issues-raw/Microsoft/nni.svg)](https://github.com/Microsoft/nni/issues?q=is%3Aissue+is%3Aopen) [![Bug](https://img.shields.io/github/issues/Microsoft/nni/bug.svg)](https://github.com/Microsoft/nni/issues?q=is%3Aissue+is%3Aopen+label%3Abug) [![拉取请求](https://img.shields.io/github/issues-pr-raw/Microsoft/nni.svg)](https://github.com/Microsoft/nni/pulls?q=is%3Apr+is%3Aopen) [![版本](https://img.shields.io/github/release/Microsoft/nni.svg)](https://github.com/Microsoft/nni/releases) [![进入 https://gitter.im/Microsoft/nni 聊天室提问](https://badges.gitter.im/Microsoft/nni.svg)](https://gitter.im/Microsoft/nni?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[English](../README.md)
+NNI (Neural Network Intelligence) 是自动机器学习（AutoML）的工具包。 它通过多种调优的算法来搜索最好的神经网络结构和（或）超参，并支持单机、本地多机、云等不同的运行环境。
+### **NNI [v0.5](https://github.com/Microsoft/nni/releases) 已发布！**
+<p align="center">
+  <a href="#nni-v05-has-been-released"><img src="https://microsoft.github.io/nni/docs/img/overview.svg" /></a>
+</p>
+<table>
+  <tbody>
+    <tr align="center" valign="bottom">
+      <td>
+        <b>支持的框架</b>
+        <img src="https://user-images.githubusercontent.com/44491713/51381727-e3d0f780-1b4f-11e9-96ab-d26b9198ba65.png"/>
+      </td>
+      <td>
+        <b>调优算法</b>
+        <img src="https://user-images.githubusercontent.com/44491713/51381727-e3d0f780-1b4f-11e9-96ab-d26b9198ba65.png"/>
+      </td>
+      <td>
+        <b>训练服务</b>
+        <img src="https://user-images.githubusercontent.com/44491713/51381727-e3d0f780-1b4f-11e9-96ab-d26b9198ba65.png"/>
+      </td>
+    </tr>
+    <tr/>
+    <tr valign="top">
+      <td>
+        <ul>
+          <li>PyTorch</li>
+          <li>TensorFlow</li>
+          <li>Keras</li>
+          <li>MXNet</li>
+          <li>Caffe2</li>
+          <li>CNTK (Python 语言)</li>
+          <li>Chainer</li>
+          <li>Theano</li>
+        </ul>
+      </td>
+      <td>
+        <a href="docs/Builtin_Tuner.md">Tuner（调参器）</a>
+        <ul>
+          <li><a href="docs/Builtin_Tuner.md#TPE">TPE</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Random">Random Search（随机搜索）</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Anneal">Anneal（退火算法）</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Evolution">Naive Evolution（进化算法）</a></li>
+          <li><a href="docs/Builtin_Tuner.md#SMAC">SMAC</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Batch">Batch（批处理）</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Grid">Grid Search（遍历搜索）</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Hyperband">Hyperband</a></li>
+          <li><a href="docs/Builtin_Tuner.md#NetworkMorphism">Network Morphism</a></li>
+          <li><a href="examples/tuners/enas_nni/README.md">ENAS</a></li>
+          <li><a href="docs/Builtin_Tuner.md#NetworkMorphism#MetisTuner">Metis Tuner</a></li>
+        </ul> 
+          <a href="docs/Builtin_Tuner.md#assessor">Assessor（评估器）</a> 
+        <ul>
+          <li><a href="docs/Builtin_Tuner.md#Medianstop">Median Stop</a></li>
+          <li><a href="docs/Builtin_Tuner.md#Curvefitting">Curve Fitting</a></li>
+        </ul>
+      </td>
+      <td>
+      <ul>
+        <li><a href="docs/tutorial_1_CR_exp_local_api.md">本地计算机</a></li>
+        <li><a href="docs/RemoteMachineMode.md">远程计算机</a></li>
+        <li><a href="docs/PAIMode.md">OpenPAI</a></li>
+        <li><a href="docs/KubeflowMode.md">Kubeflow</a></li>
+        <li><a href="docs/FrameworkControllerMode.md">基于 Kubernetes（AKS 等等）的 FrameworkController</a></li>
+      </ul>
+      </td>
+    </tr>
+  </tbody>
+</table>
+## **使用场景**
+* 在本地 Trial 不同的自动机器学习算法来训练模型。
+* 在分布式环境中加速自动机器学习（如：远程 GPU 工作站和云服务器）。
+* 定制自动机器学习算法，或比较不同的自动机器学习算法。
+* 在自己的机器学习平台中支持自动机器学习。
+## 相关项目
+以开发和先进技术为目标，[Microsoft Research (MSR)](https://www.microsoft.com/en-us/research/group/systems-research-group-asia/) 发布了一些开源项目。
+* [OpenPAI](https://github.com/Microsoft/pai)：作为开源平台，提供了完整的 AI 模型训练和资源管理能力，能轻松扩展，并支持各种规模的私有部署、云和混合环境。
+* [FrameworkController](https://github.com/Microsoft/frameworkcontroller)：开源的通用 Kubernetes Pod 控制器，通过单个控制器来编排 Kubernetes 上所有类型的应用。
+* [MMdnn](https://github.com/Microsoft/MMdnn)：一个完成、跨框架的解决方案，能够转换、可视化、诊断深度神经网络模型。 MMdnn 中的 "MM" 表示model management（模型管理），而 "dnn" 是 deep neural network（深度神经网络）的缩写。 我们鼓励研究人员和学生利用这些项目来加速 AI 开发和研究。
+## **安装和验证**
+**通过 pip 命令安装**
+* 当前支持 Linux 和 MacOS。测试并支持的版本包括：Ubuntu 16.04 及更高版本，MacOS 10.14.1。 在 `python >= 3.5` 的环境中，只需要运行 `pip install` 即可完成安装。 
+```bash
+    python3 -m pip install --upgrade nni
+```
+注意：
+* 如果需要将 NNI 安装到自己的 home 目录中，可使用 `--user`，这样也不需要任何特殊权限。
+* 如果遇到如`Segmentation fault` 这样的任何错误请参考[常见问题](docs/FAQ.md)。
+**通过源代码安装**
+* 当前支持 Linux（Ubuntu 16.04 及更高版本） 和 MacOS（10.14.1）。 
+* 在 `python >= 3.5` 的环境中运行命令： `git` 和 `wget`，确保安装了这两个组件。
+```bash
+    git clone -b v0.5 https://github.com/Microsoft/nni.git
+    cd nni  
+    source install.sh   
+```
+参考[安装 NNI](docs/Installation.md) 了解系统需求。
+**验证安装**
+以下示例 Experiment 依赖于 TensorFlow 。 在运行前确保安装了 **TensorFlow**。
+* 通过克隆源代码下载示例。 
+```bash
+    git clone -b v0.5 https://github.com/Microsoft/nni.git
+```
+* 运行 mnist 示例。
+```bash
+    nnictl create --config nni/examples/trials/mnist/config.yml
+```
+* 在命令行中等待输出 `INFO: Successfully started experiment!`。 此消息表明 Experiment 已成功启动。 通过命令行输出的 `Web UI url` 来访问 Experiment 的界面。
+    ```
+    INFO: Starting restful server...
+    INFO: Successfully started Restful server!
+    INFO: Setting local config...
+    INFO: Successfully set local config!
+    INFO: Starting experiment...
+    INFO: Successfully started experiment!
+    -----------------------------------------------------------------------
+    The experiment id is egchD4qy
+    The Web UI urls are: http://223.255.255.1:8080   http://127.0.0.1:8080
+    -----------------------------------------------------------------------
+    You can use these commands to get more information about the experiment
+    -----------------------------------------------------------------------
+             commands                       description
+    1. nnictl experiment show        show the information of experiments
+    2. nnictl trial ls               list all of trial jobs
+    3. nnictl top                    monitor the status of running experiments
+    4. nnictl log stderr             show stderr log content
+    5. nnictl log stdout             show stdout log content
+    6. nnictl stop                   stop an experiment
+    7. nnictl trial kill             kill a trial job by id
+    8. nnictl --help                 get help information about nnictl
+    -----------------------------------------------------------------------
+* 在浏览器中打开 `Web UI url`，可看到下图的 Experiment 详细信息，以及所有的 Trial 任务。 查看[这里的](docs/WebUI.md)更多页面示例。
+<table style="border: none">
+    <th><img src="./docs/img/webui_overview_page.png" alt="drawing" width="395"/></th>
+    <th><img src="./docs/img/webui_trialdetail_page.png" alt="drawing" width="410"/></th>
+</table>
+## **文档**
+* [NNI 概述](docs/Overview.md)
+* [快速入门](docs/QuickStart.md)
+## **入门**
+* [安装 NNI](docs/Installation.md)
+* [使用命令行工具 nnictl](docs/NNICTLDOC.md)
+* [使用 NNIBoard](docs/WebUI.md)
+* [如何定义搜索空间](docs/SearchSpaceSpec.md)
+* [如何定义一次 Trial](docs/Trials.md)
+* [如何选择 Tuner、搜索算法](docs/Builtin_Tuner.md)
+* [配置 Experiment](docs/ExperimentConfig.md)
+* [如何使用 Annotation](docs/Trials.md#nni-python-annotation)
+## **教程**
+* [在本机运行 Experiment (支持多 GPU 卡)](docs/tutorial_1_CR_exp_local_api.md)
+* [在多机上运行 Experiment](docs/RemoteMachineMode.md)
+* [在 OpenPAI 上运行 Experiment](docs/PAIMode.md)
+* [在 Kubeflow 上运行 Experiment。](docs/KubeflowMode.md)
+* [尝试不同的 Tuner](docs/tuners.rst)
+* [尝试不同的 Assessor](docs/assessors.rst)
+* [实现自定义 Tuner](docs/Customize_Tuner.md)
+* [实现自定义 Assessor](examples/assessors/README.md)
+* [使用进化算法为阅读理解任务找到好模型](examples/trials/ga_squad/README.md)
+## **贡献**
+欢迎贡献代码或提交建议，可在 [GitHub issues](https://github.com/Microsoft/nni/issues) 跟踪需求和 Bug。
+推荐新贡献者从标有 **good first issue** 的简单需求开始。
+如要安装 NNI 开发环境，参考： [配置 NNI 开发环境](docs/SetupNNIDeveloperEnvironment.md)。
+在写代码之前，请查看并熟悉 NNI 代码贡献指南：[贡献](docs/CONTRIBUTING.md)。
+我们正在编写 [如何调试](docs/HowToDebug.md) 的页面，欢迎提交建议和问题。
+## **许可协议**
+整个代码库遵循 [MIT 许可协议](https://github.com/Microsoft/nni/blob/master/LICENSE)
\ No newline at end of file
--- a/zh_CN/deployment/docker/README.md
+++ b/zh_CN/deployment/docker/README.md
+# Dockerfile
+## 1. 说明
+这是 NNI 项目的 Dockerfile 文件。 其中包含了 NNI 以及多个流行的深度学习框架。 在 `Ubuntu 16.04 LTS` 上进行过测试：
+    CUDA 9.0, CuDNN 7.0
+    numpy 1.14.3,scipy 1.1.0
+    TensorFlow 1.10.0
+    Keras 2.1.6
+    PyTorch 0.4.1
+    scikit-learn 0.20.0
+    pandas 0.23.4
+    lightgbm 2.2.2
+    NNI v0.5
+此 Dockerfile 可作为定制的参考。
+## 2.如何生成和运行
+**使用 `nni/deployment/docker` 的下列命令来生成 docker 映像。**
+        docker build -t nni/nni .
+**运行 docker 映像**
+* 如果 docker 容器中没有 GPU，运行下面的命令
+        docker run -it nni/nni
+* 如果 docker 容器中有 GPU，确保安装了 [NVIDIA 容器运行包](https://github.com/NVIDIA/nvidia-docker)，然后运行下面的命令
+        nvidia-docker run -it nni/nni
+或者
+        docker run --runtime=nvidia -it nni/nni
+## 3.拉取 docker 映像
+使用下列命令从 docker Hub 中拉取 NNI docker 映像。
+    docker pull msranni/nni:latest
\ No newline at end of file
--- a/zh_CN/deployment/pypi/README.md
+++ b/zh_CN/deployment/pypi/README.md
+# 用于 NNI 的 python 包索引 (pypi)
+## 1. 说明
+这是用于 NNI 项目的 PyPI 生成和上传的工具。
+## 2.准备环境
+在生成和上传 NNI 包之前，确保使用了下列环境。
+    Ubuntu 16.04 LTS
+    make
+    wget
+    Python >= 3.5
+    Pip
+    Node.js
+    Yarn
+## 2.如何生成
+```bash
+make
+```
+## 3.如何上传
+### 上传测试包
+```bash
+TWINE_REPOSITORY_URL=https://test.pypi.org/legacy/ make upload
+```
+上传过程中，可能需要输入 https://test.pypi.org 的用户和密码。
+### 上传发布包
+```bash
+make upload
+```
+上传过程中，可能需要输入 https://pypi.org 的用户和密码。
\ No newline at end of file
--- a/zh_CN/docs/.gitignore
+++ b/zh_CN/docs/.gitignore
+_build
+_static
+_templates
\ No newline at end of file
--- a/zh_CN/docs/AdvancedNAS.md
+++ b/zh_CN/docs/AdvancedNAS.md
+# 高级神经网络架构搜索教程
+目前，许多 NAS（Neural Architecture Search，神经网络架构搜索）算法都在 Trial 上使用了 **权重共享（weight sharing）** 的方法来加速训练过程。 例如，[ENAS](https://arxiv.org/abs/1802.03268) 与以前的 [NASNet](https://arxiv.org/abs/1707.07012) 算法相比，通过'*子模型间的参数共享（parameter sharing between child models）*'提高了 1000 倍的效率。 而例如 [DARTS](https://arxiv.org/abs/1806.09055), [Network Morphism](https://arxiv.org/abs/1806.10282), 和 [Evolution](https://arxiv.org/abs/1703.01041) 等算法也利用或者隐式的利用了权重共享。
+本教程介绍了如何使用权重共享。
+## 权重共享
+推荐通过 NFS （Network File System）进行权重共享，它是轻量、相对高效的多机共享文件方案。 欢迎社区来共享更多高效的技术。
+### 通过 NFS 文件使用权重共享
+使用 NFS 配置（见下文），Trial 代码可以通过读写文件来共享模型权重。 建议使用 Tuner 的存储路径：
+```yaml
+tuner:
+  codeDir: path/to/customer_tuner
+  classFileName: customer_tuner.py 
+  className: CustomerTuner
+  classArgs:
+    ...
+    save_dir_root: /nfs/storage/path/
+```
+并让 Tuner 来决定在什么路径读写权重文件，通过 `nni.get_next_parameters()` 来获取路径：
+<img src="https://user-images.githubusercontent.com/23273522/51817667-93ebf080-2306-11e9-8395-b18b322062bc.png" alt="drawing" width="700" />
+例如，在 Tensorflow 中：
+```python
+# 保存 models
+saver = tf.train.Saver()
+saver.save(sess, os.path.join(params['save_path'], 'model.ckpt'))
+# 读取 models
+tf.init_from_checkpoint(params['restore_path'])
+```
+超参中的 `'save_path'` 和 `'restore_path'` 可以通过 Tuner 来管理。
+### NFS 配置
+NFS 使用了客户端/服务器架构。通过一个 NFS 服务器来提供物理存储，远程计算机上的 Trial 使用 NFS 客户端来读写文件，操作上和本地文件相同。
+#### NFS 服务器
+如果有足够的存储空间，并能够让 NNI 的 Trial 通过**远程机器**来连接，NFS 服务可以安装在任何计算机上。 通常，可以选择一台远程服务器作为 NFS 服务。
+在 Ubuntu 上，可通过 `apt-get` 安装 NFS 服务：
+```bash
+sudo apt-get install nfs-kernel-server
+```
+假设 `/tmp/nni/shared` 是物理存储位置，然后运行：
+```bash
+mkdir -p /tmp/nni/shared
+sudo echo "/tmp/nni/shared *(rw,sync,no_subtree_check,no_root_squash)" >> /etc/exports
+sudo service nfs-kernel-server restart
+```
+可以通过命令 `sudo showmount -e localhost` 来检查上述目录是否通过 NFS 成功导出了
+#### NFS 客户端
+为了通过 NFS 访问远程共享文件，需要安装 NFS 客户端。 例如，在 Ubuntu 上运行：
+```bash
+sudo apt-get install nfs-common
+```
+然后创建并装载上共享目录：
+```bash
+mkdir -p /mnt/nfs/nni/
+sudo mount -t nfs 10.10.10.10:/tmp/nni/shared /mnt/nfs/nni
+```
+实际使用时，IP `10.10.10.10` 需要替换为 NFS 服务器的真实地址。
+## Trial 依赖控制的异步调度模式
+多机间启用权重的 Trial，一般是通过**先写后读**的方式来保持一致性。 子节点在父节点的 Trial 完成训练前，不应该读取父节点模型。 要解决这个问题，要通过 `multiThread: true` 来启用**异步调度模式**。在 `config.yml` 中，每次收到 `NEW_TRIAL` 请求，分派一个新的 Trial 时，Tuner 线程可以决定是否阻塞当前线程。 例如：
+```python
+    def generate_parameters(self, parameter_id):
+        self.thread_lock.acquire()
+        indiv = # 新 Trial 的配置
+        self.events[parameter_id] = threading.Event()
+        self.thread_lock.release()
+        if indiv.parent_id is not None:
+            self.events[indiv.parent_id].wait()
+    def receive_trial_result(self, parameter_id, parameters, reward):
+        self.thread_lock.acquire()
+        # 处理 Trial 结果的配置
+        self.thread_lock.release()
+        self.events[parameter_id].set()
+```
+## 样例
+详细内容参考：[简单的参数共享样例](https://github.com/Microsoft/nni/tree/master/test/async_sharing_test)。 基于上一个 [ga_squad](https://github.com/Microsoft/nni/tree/master/examples/trials/ga_squad) 样例，还提供了新的 [样例](https://github.com/Microsoft/nni/tree/master/examples/trials/weight_sharing/ga_squad)。
\ No newline at end of file
--- a/zh_CN/docs/AnnotationSpec.md
+++ b/zh_CN/docs/AnnotationSpec.md
+# NNI Annotation
+## 概述
+为了获得良好的用户体验并减少对以后代码的影响，NNI 设计了通过 Annotation（标记）来使用的语法。 通过 Annotation，只需要在代码中加入一些注释字符串，就能启用 NNI，完全不影响代码原先的执行逻辑。
+样例如下：
+```python
+'''@nni.variable(nni.choice(0.1, 0.01, 0.001), name=learning_rate)'''
+learning_rate = 0.1
+```
+此样例中，NNI 会从 (0.1, 0.01, 0.001) 中选择一个值赋给 learning_rate 变量。 第一行就是 NNI 的 Annotation，是 Python 中的一个字符串。 接下来的一行需要是赋值语句。 NNI 会根据 Annotation 行的信息，来给这一行的变量赋上相应的值。
+通过这种方式，不需要修改任何代码，代码既可以直接运行，又可以使用 NNI 来调参。
+## Annotation 的类型：
+NNI 中，有 4 种类型的 Annotation；
+### 1. 变量
+`'''@nni.variable(sampling_algo, name)'''`
+`@nni.variable` 用来标记变量。
+**参数**
+- **sampling_algo**: 指定搜索空间的采样算法。 可将其换成 NNI 支持的其它采样函数，函数要以 `nni.` 开头。例如，`choice` 或 `uniform`，详见 [SearchSpaceSpec](SearchSpaceSpec.md)。 
+- **name**: 将被赋值的变量名称。 注意，此参数应该与下面一行等号左边的值相同。
+例如：
+```python
+'''@nni.variable(nni.choice(0.1, 0.01, 0.001), name=learning_rate)'''
+learning_rate = 0.1
+```
+### 2. 函数
+`'''@nni.function_choice(*functions, name)'''`
+`@nni.function_choice` 可以从几个函数中选择一个来执行。
+**参数**
+- **\*functions**: 可选择的函数。 注意，必须是包括参数的完整函数调用。 例如 `max_pool(hidden_layer, pool_size)`。
+- **name**: 将被替换的函数名称。
+例如：
+```python
+"""@nni.function_choice(max_pool(hidden_layer, pool_size), avg_pool(hidden_layer, pool_size), name=max_pool)"""
+h_pooling = max_pool(hidden_layer, pool_size)
+```
+### 3. 中间结果
+`'''@nni.report_intermediate_result(metrics)'''`
+`@nni.report_intermediate_result` 用来返回中间结果，这和 <Trials.md> 中的 `nni.report_intermediate_result` 用法一样。
+### 4. 最终结果
+`'''@nni.report_final_result(metrics)'''`
+`@nni.report_final_result` 用来返回当前 Trial 的最终结果，这和 <Trials.md> 中的 `nni.report_final_result` 用法一样。
\ No newline at end of file
--- a/zh_CN/docs/Builtin_Assessors.md
+++ b/zh_CN/docs/Builtin_Assessors.md
+# 内置 Assessor
+NNI 提供了先进的调优算法，使用上也很简单。 下面是内置 Assessor 的介绍：
+| Assessor                                                                                   | 算法简介                                                                                                                                                                                             |
+| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Medianstop** [(用法)](#MedianStop)                                                         | Medianstop 是一种简单的提前终止策略，可参考[论文](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/46180.pdf)。 如果 Trial X 的在步骤 S 的最好目标值比所有已完成 Trial 的步骤 S 的中位数值明显要低，就会停止运行 Trial X。 |
+| [Curvefitting](../src/sdk/pynni/nni/curvefitting_assessor/README.md) [(用法)](#Curvefitting) | Curve Fitting Assessor 是一个 LPA (learning, predicting, assessing，即学习、预测、评估) 的算法。 如果预测的 Trial X 在 step S 比性能最好的 Trial要差，就会提前终止它。 此算法中采用了 12 种曲线来拟合精度。                                              |
+## 用法
+要使用 NNI 内置的 Assessor，需要在 `config.yml` 文件中添加 **builtinAssessorName** 和 **classArgs**。 这一节会介绍推荐的场景、参数等详细用法以及样例。
+注意：参考样例中的格式来创建新的 `config.yml` 文件。
+<a name="MedianStop"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Median Stop Assessor`
+> 名称：**Medianstop**
+**建议场景**
+适用于各种性能曲线，可用到各种场景中来加速优化过程。
+**参数**
+* **optimize_mode** (*maximize 或 minimize, 可选, 默认值为 maximize*) - 如果为 'maximize', Assessor 会在结果小于期望值时**终止** Trial。 如果为 'minimize'，Assessor 会在结果大于期望值时**终止** Trial。
+* **start_step** (*int, 可选, 默认值为 0*) - 只有收到 start_step 个中间结果后，才开始判断是否一个 Trial 应该被终止。
+**使用样例：**
+```yaml
+# config.yml
+assessor:
+    builtinAssessorName: Medianstop
+    classArgs:
+      optimize_mode: maximize
+      start_step: 5
+```
+<br />
+<a name="Curvefitting"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Curve Fitting Assessor`
+> 名称：**Curvefitting**
+**建议场景**
+适用于各种性能曲线，可用到各种场景中来加速优化过程。 更好的是，它能够处理并评估性能类似的曲线。
+**参数**
+* **epoch_num** (*int, **必需***) - epoch 的总数。 需要此数据来决定需要预测点的总数。
+* **optimize_mode** (*maximize 或 minimize, 可选, 默认值为 maximize*) - 如果为 'maximize', Assessor 会在结果小于期望值时**终止** Trial。 如果为 'minimize'，Assessor 会在结果大于期望值时**终止** Trial。
+* **start_step** (*int, 可选, 默认值为 6*) - 只有收到 start_step 个中间结果后，才开始判断是否一个 Trial 应该被终止。
+* **threshold** (*float, 可选, 默认值为 0.95*) - 用来确定提前终止较差结果的阈值。 例如，如果 threshold = 0.95, optimize_mode = maximize，最好的历史结果是 0.9，那么会在 Trial 的预测值低于 0.95 * 0.9 = 0.855 时停止。
+**使用样例：**
+```yaml
+# config.yml
+assessor:
+    builtinAssessorName: Curvefitting
+    classArgs:
+      epoch_num: 20
+      optimize_mode: maximize
+      start_step: 6
+      threshold: 0.95
+```
\ No newline at end of file
--- a/zh_CN/docs/Builtin_Tuner.md
+++ b/zh_CN/docs/Builtin_Tuner.md
+# 内置 Tuner
+NNI 提供了先进的调优算法，使用上也很简单。 下面是内置 Tuner 的简单介绍：
+| Tuner                                                                                                            | 算法简介                                                                                                                                                |
+| ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **TPE** [(用法)](#TPE)                                                                                             | Tree-structured Parzen Estimator (TPE) 是一种 sequential model-based optimization（SMBO，即基于序列模型优化）的方法。 SMBO 方法根据历史指标数据来按顺序构造模型，来估算超参的性能，随后基于此模型来选择新的超参。 |
+| **Random Search** [(用法)](#Random)                                                                                | 在超参优化时，随机搜索算法展示了其惊人的简单和效果。 建议当不清楚超参的先验分布时，采用随机搜索作为基准。                                                                                               |
+| **Anneal** [(用法)](#Anneal)                                                                                       | 这种简单的退火算法从先前的采样开始，会越来越靠近发现的最佳点取样。 此算法是随机搜索的简单变体，利用了反应曲面的平滑性。 退火率不是自适应的。                                                                             |
+| **Naive Evolution** [(用法)](#Evolution)                                                                           | 朴素进化算法来自于大规模图像分类进化。 它会基于搜索空间随机生成一个种群。 在每一代中，会选择较好的结果，并对其下一代进行一些变异（例如，改动一个超参，增加或减少一层）。 进化算法需要很多次 Trial 才能有效，但它也非常简单，也很容易扩展新功能。                       |
+| **SMAC** [(用法)](#SMAC)                                                                                           | SMAC 基于 Sequential Model-Based Optimization (SMBO，即序列的基于模型优化方法)。 它会利用使用过的结果好的模型（高斯随机过程模型），并将随机森林引入到 SMBO 中，来处理分类参数。 SMAC 算法包装了 Github 的 SMAC3。      |
+| **Batch tuner** [(用法)](#Batch)                                                                                   | Batch Tuner 能让用户简单的提供几组配置（如，超参选项的组合）。 当所有配置都执行完后，Experiment 即结束。 Batch Tuner 仅支持 choice 类型。                                                         |
+| **Grid Search** [(用法)](#GridSearch)                                                                              | 网格搜索会穷举定义在搜索空间文件中的所有超参组合。 网格搜索可以使用的类型有 choice, quniform, qloguniform。 quniform 和 qloguniform 中的数值 q 具有特别的含义（不同于搜索空间文档中的说明）。 它表示了在最高值与最低值之间采样的值的数量。  |
+| [Hyperband](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/hyperband_advisor) [(用法)](#Hyperband) | Hyperband 试图用有限的资源来探索尽可能多的组合，并发现最好的结果。 它的基本思路是生成大量的配置，并运行少量的步骤来找到有可能好的配置，然后继续训练找到其中更好的配置。                                                           |
+| [Network Morphism](../src/sdk/pynni/nni/networkmorphism_tuner/README.md) [(用法)](#NetworkMorphism)                | Network Morphism 提供了深度学习模型的自动架构搜索功能。 每个子网络都继承于父网络的知识和形态，并变换网络的不同形态，包括深度，宽度，跨层连接（skip-connection）。 然后使用历史的架构和指标，来估计子网络的值。 最后会选择最有希望的模型进行训练。          |
+| **Metis Tuner** [(用法)](#MetisTuner)                                                                              | 大多数调参工具仅仅预测最优配置，而 Metis 的优势在于有两个输出：(a) 最优配置的当前预测结果， 以及 (b) 下一次 Trial 的建议。 它不进行随机取样。 大多数工具假设训练集没有噪声数据，但 Metis 会知道是否需要对某个超参重新采样。                      |
+<br />
+## 用法
+要使用 NNI 内置的 Tuner，需要在 `config.yml` 文件中添加 **builtinTunerName** 和 **classArgs**。 这一节会介绍推荐的场景、参数等详细用法以及样例。
+注意：参考样例中的格式来创建新的 `config.yml` 文件。
+<a name="TPE"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `TPE`
+> 名称：**TPE**
+**建议场景**
+TPE 是一种黑盒优化方法，可以使用在各种场景中，通常情况下都能得到较好的结果。 特别是在计算资源有限，只能运行少量 Trial 的情况。 大量的实验表明，TPE 的性能远远优于随机搜索。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: TPE
+  classArgs:
+    optimize_mode: maximize
+```
+<br />
+<a name="Random"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Random Search`
+> 名称：**Random**
+**建议场景**
+在每个 Trial 运行时间不长（例如，能够非常快的完成，或者很快的被 Assessor 终止），并有充足计算资源的情况下。 或者需要均匀的探索搜索空间。 随机搜索可作为搜索算法的基准线。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: Random
+  classArgs:
+    optimize_mode: maximize
+```
+<br />
+<a name="Anneal"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Anneal`
+> 名称：**Anneal**
+**建议场景**
+当每个 Trial 的时间不长，并且有足够的计算资源时使用（与随机搜索基本相同）。 或者搜索空间的变量能从一些先验分布中采样。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: Anneal
+  classArgs:
+    optimize_mode: maximize
+```
+<br />
+<a name="Evolution"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Naive Evolution`
+> 名称：**Evolution**
+**建议场景**
+此算法对计算资源的需求相对较高。 需要非常大的初始种群，以免落入局部最优中。 如果 Trial 时间很短，或者利用了 Assessor，就非常适合此算法。 如果 Trial 代码支持权重迁移，即每次 Trial 会从上一轮继承已经收敛的权重，建议使用此算法。 这会大大提高训练速度。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: Evolution
+  classArgs:
+    optimize_mode: maximize
+```
+<br />
+<a name="SMAC"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `SMAC`
+> 名称：**SMAC**
+**建议场景**
+与 TPE 类似，SMAC 也是一个可以被用在各种场景中的黑盒 Tuner。在计算资源有限时，也可以使用。 此算法为离散超参而优化，因此，如果大部分超参是离散值时，建议使用此算法。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: SMAC
+  classArgs:
+    optimize_mode: maximize
+```
+<br />
+<a name="Batch"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Batch Tuner`
+> 名称：BatchTuner
+**建议场景**
+如果 Experiment 配置已确定，可通过 Batch Tuner 将它们罗列到搜索空间中运行即可。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: BatchTuner
+```
+<br />
+注意 Batch Tuner 支持的搜索空间文件如下例：
+```json
+{
+    "combine_params":
+    {
+        "_type" : "choice",
+        "_value" : [{"optimizer": "Adam", "learning_rate": 0.00001},
+                    {"optimizer": "Adam", "learning_rate": 0.0001},
+                    {"optimizer": "Adam", "learning_rate": 0.001},
+                    {"optimizer": "SGD", "learning_rate": 0.01}, 
+                    {"optimizer": "SGD", "learning_rate": 0.005}, 
+                    {"optimizer": "SGD", "learning_rate": 0.0002}]
+    }
+}
+```
+搜索空间文件使用了键 `combine_params`。 参数类型必须是 `choice` ，并且 `values` 要包含所有需要 Experiment 的参数组合。
+<a name="GridSearch"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Grid Search`
+> 名称：**Grid Search**
+**建议场景**
+注意，搜索空间仅支持 `choice`, `quniform`, `qloguniform`。 `quniform` 和 `qloguniform` 中的 **数字 `q` 有不同的含义（与[搜索空间](./SearchSpaceSpec.md)说明不同）。 在这里意味着会在 `low` 和 `high` 之间均匀取值的数量。</p> 
+当搜索空间比较小，能够遍历整个搜索空间。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: GridSearch
+```
+<br />
+<a name="Hyperband"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Hyperband`
+> 名称：**Hyperband**
+**建议场景**
+当搜索空间很大，但计算资源有限时建议使用。 中间结果能够很好的反映最终结果的情况下，此算法会非常有效。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+* **R** (*int, 可选, 默认为 60*) - 能分配给 Trial 的最大 STEPS (可以是 mini-batches 或 epochs 的数值)。 Trial 需要用 STEPS 来控制运行时间。
+* **eta** (*int, 可选, 默认为 3*) - `(eta-1)/eta` 是丢弃 Trial 的比例。
+**使用样例：**
+```yaml
+# config.yml
+advisor:
+  builtinAdvisorName: Hyperband
+  classArgs:
+    optimize_mode: maximize
+    R: 60
+    eta: 3
+```
+<br />
+<a name="NetworkMorphism"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Network Morphism`
+> 名称：**NetworkMorphism**
+**安装**
+必须先安装 [pyTorch](https://pytorch.org/get-started/locally)。
+**建议场景**
+需要将深度学习方法应用到自己的任务（自己的数据集）上，但不清楚该如何选择或设计网络。 可修改[样例](https://github.com/Microsoft/nni/tree/master/examples/trials/network_morphism/cifar10/cifar10_keras.py)来适配自己的数据集和数据增强方法。 也可以修改批处理大小，学习率或优化器。 它可以为不同的任务找到好的网络架构。 当前，此 Tuner 仅支持视觉领域。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+* **task** (*('cv'), 可选, 默认为 'cv'*) - 实验的领域，当前仅支持视觉（cv）。
+* **input_width** (*int, 可选, 默认为 = 32*) - 输入图像的宽度
+* **input_channel** (*int, 可选, 默认为 3*) - 输入图像的通道数
+* **n_output_node** (*int, 可选, 默认为 10*) - 输出分类的数量
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: NetworkMorphism
+    classArgs:
+      optimize_mode: maximize
+      task: cv
+      input_width: 32
+      input_channel: 3
+      n_output_node: 10
+```
+<br />
+<a name="MetisTuner"></a>
+![](https://placehold.it/15/1589F0/000000?text=+) `Metis Tuner`
+> 名称：**MetisTuner**
+注意，搜索空间仅支持 `choice`, `quniform`, `uniform` 和 `randint`。
+**安装**
+Metis Tuner 需要先安装 [sklearn](https://scikit-learn.org/)。 可通过 `pip3 install sklearn` 命令来安装。
+**建议场景**
+与 TPE 和 SMAC 类似，Metis 是黑盒 Tuner。 如果系统需要很长时间才能完成一次 Trial，Metis 就比随机搜索等其它方法要更合适。 此外，Metis 还为接下来的 Trial 提供了候选。 如何使用 Metis 的[样例](https://github.com/Microsoft/nni/tree/master/examples/trials/auto-gbdt/search_space_metis.json)。 通过调用 NNI 的 SDK，用户只需要发送 `精度` 这样的最终结果给 Tuner。
+**参数**
+* **optimize_mode** (*maximize 或 minimize，可选，默认值为 maximize*) - 如果为 'maximize'，Tuner 会给出有可能产生较大值的参数组合。 如果为 'minimize'，Tuner 会给出有可能产生较小值的参数组合。
+**使用样例：**
+```yaml
+# config.yml
+tuner:
+  builtinTunerName: MetisTuner
+  classArgs:
+    optimize_mode: maximize
+```
\ No newline at end of file
--- a/zh_CN/docs/CONTRIBUTING.md
+++ b/zh_CN/docs/CONTRIBUTING.md
+# 改进 Neural Network Intelligence (NNI)
+欢迎！！ 我们非常欢迎贡献者，特别是代码贡献者。
+首先，如果有什么不确定的事情，可随时提交问题或拉取请求。 不会有人因此而抱怨。:) 最有可能的是，会有礼貌的请求你修改一些内容。 我们会感激任何形式的贡献，不想用一堆规则来阻止这些贡献。
+不管怎样，如果想要更有效的贡献代码，可以阅读以下内容。 本文档包括了所有在贡献中需要注意的要点，会加快合并代码、解决问题的速度。
+查看[快速入门](./QuickStart.md)来初步了解。
+下面是一些简单的贡献指南。
+## 提交问题
+在提出问题时，请说明以下事项：
+- 按照问题模板的内容来填写安装的细节，以便评审者检查。
+- 出现问题的场景 (尽量详细，以便重现问题)。
+- 错误和日志消息。
+- 其它可能有用的细节信息。
+## 提交新功能建议
+- 在适配使用场景时，总会需要一些新的功能。 可以加入新功能的讨论，也可以直接提交新功能的拉取请求。
+- 在自己的 github 账户下 fork 存储库。 在 fork 后， 对于 add, commit, push, 或 squash (如需要) 等改动都需要详细的提交消息。 然后就可以提交拉取请求了。
+## 参与源代码和 Bug 修复
+拉取请求需要选好正确的标签，表明是 Bug 修复还是功能改进。 所有代码都需要遵循正确的命名约定和代码风格。
+参考[如何配置 NNI 的开发环境](./SetupNNIDeveloperEnvironment.md)，来安装开发环境。
+与[快速入门](QuickStart.md)类似。 其它内容，参考[NNI 文档](http://nni.readthedocs.io)。
+## 处理现有问题
+查看[问题列表](https://github.com/Microsoft/nni/issues)，找到需要贡献的问题。 可以找找有 'good-first-issue' 或 'help-wanted' 标签的来开始贡献。
+修改问题的注释和指派人来表明此问题已经开始跟进。 如果上述问题在一周内没有拉取请求或更新状态，这个问题会重新开放给所有人。 高优先级的 Bug 和回归问题需在一天内响应。
+## 代码风格和命名约定
+NNI 遵循 [PEP8](https://www.python.org/dev/peps/pep-0008/) 的 Python 代码命名约定。在提交拉取请求时，请尽量遵循此规范。 可通过`flake8`或`pylint`的提示工具来帮助遵循规范。
\ No newline at end of file
--- a/zh_CN/docs/Contribution.rst
+++ b/zh_CN/docs/Contribution.rst
+###############################
+为 NNI 做贡献
+###############################
+..  toctree::
+    设置开发环境<SetupNNIDeveloperEnvironment>
+    贡献指南<CONTRIBUTING>
+    如何调试<HowToDebug>
\ No newline at end of file
--- a/zh_CN/docs/Customize_Advisor.md
+++ b/zh_CN/docs/Customize_Advisor.md
+# **指南** - 自定义 advisor
+*Advisor 用于同时需要 Tuner 和 Assessor 方法的自动机器学习算法。 Advisor 与 Tuner 类似，它接收 Trial 的参数请求、最终结果，并生成 Trial 的参数。 另外，它也能像 Assessor 一样接收中间结果、Trial 的最终状态，并可以发送终止 Trial 的命令。 注意，在使用 Advisor 时，不能同时使用 Tuner 和 Assessor。*
+如果要自定义 Advisor，需要：
+1. 从 MsgDispatcherBase 类继承并创建新的 Advisor 类
+2. 实现所有除了 `handle_request` 外的，以 `handle_` 前缀开始的方法
+3. 在 Experiment 的 YAML 文件中配置好自定义的 Advisor
+样例如下：
+**1) 从 MsgDispatcherBase 类继承并创建新的 Advisor 类**
+```python
+from nni.msg_dispatcher_base import MsgDispatcherBase
+class CustomizedAdvisor(MsgDispatcherBase):
+    def __init__(self, ...):
+        ...
+```
+**2) 实现所有除了 `handle_request` 外的，以 `handle_` 前缀开始的方法**
+参考 Hyperband 的实现 ([src/sdk/pynni/nni/hyperband_advisor/hyperband_advisor.py](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/hyperband_advisor/hyperband_advisor.py)) 来学习如何实现这些方法。
+**3) 在 Experiment 的 YAML 文件中配置好自定义的 Advisor**
+与 Tuner 和 Assessor 类似。 NNI 需要定位到自定义的 Advisor 类，并实例化它，因此需要指定自定义 Advisor 类的文件位置，并将参数值传给 \_\_init__ 构造函数。
+```yaml
+advisor:
+  codeDir: /home/abc/myadvisor
+  classFileName: my_customized_advisor.py
+  className: CustomizedAdvisor
+  # 任何传入 __init__ 构造函数的参数
+  # 都需要声明在 classArgs 字段中，如：
+  classArgs:
+    arg1: value1
+```
\ No newline at end of file
--- a/zh_CN/docs/Customize_Assessor.md
+++ b/zh_CN/docs/Customize_Assessor.md
+# 自定义 Assessor
+NNI 支持自定义 Assessor。
+实现自定义的 Assessor，需要如下几步：
+1. 继承 Assessor 基类
+2. 实现 assess_trial 函数
+3. 在 Experiment 的 YAML 文件中配置好自定义的 Assessor
+**1. 继承 Assessor 基类**
+```python
+from nni.assessor import Assessor
+class CustomizedAssessor(Assessor):
+    def __init__(self, ...):
+        ...
+```
+**2. 实现 assess_trial 函数**
+```python
+from nni.assessor import Assessor, AssessResult
+class CustomizedAssessor(Assessor):
+    def __init__(self, ...):
+        ...
+    def assess_trial(self, trial_history):
+        """
+        确定是否要停止该 Trial。 必须重载。
+        trial_history: 中间结果列表对象。
+        返回 AssessResult.Good 或 AssessResult.Bad。
+        """
+        # 代码实现于此处。
+        ...
+```
+**3. 在 Experiment 的 YAML 文件中配置好自定义的 Assessor**
+NNI 需要定位到自定义的 Assessor 类，并实例化它，因此需要指定自定义 Assessor 类的文件位置，并将参数值传给 \_\_init__ 构造函数。
+```yaml
+assessor:
+  codeDir: /home/abc/myassessor
+  classFileName: my_customized_assessor.py
+  className: CustomizedAssessor
+  # 任何传入 __init__ 构造函数的参数，
+  # 都需要在 classArgs 字段中指定，如
+  classArgs:
+    arg1: value1
+```
+注意在 **2** 中， `trial_history` 对象与 Trial 通过 `report_intermediate_result` 函数返回给 Assessor 的对象完全一致。
+更多样例，可参考：
+> - [medianstop-assessor](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/medianstop_assessor)
+> - [curvefitting-assessor](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/curvefitting_assessor)
\ No newline at end of file
--- a/zh_CN/docs/Customize_Tuner.md
+++ b/zh_CN/docs/Customize_Tuner.md
+# 自定义 Tuner
+## 自定义 Tuner
+NNI 在内置的 Tuner 中提供了最新的调优算法。 NNI 同时也支持自定义 Tuner。
+通过自定义 Tuner，可实现自己的调优算法。主要有三步：
+1. 继承 Tuner 基类
+2. 实现 receive_trial_result 和 generate_parameter 函数
+3. 在 Experiment 的 YAML 文件中配置好自定义的 Tuner
+样例如下：
+**1. 继承 Tuner 基类**
+```python
+from nni.tuner import Tuner
+class CustomizedTuner(Tuner):
+    def __init__(self, ...):
+        ...
+```
+**2. 实现 receive_trial_result 和 generate_parameter 函数**
+```python
+from nni.tuner import Tuner
+class CustomizedTuner(Tuner):
+    def __init__(self, ...):
+        ...
+    def receive_trial_result(self, parameter_id, parameters, value):
+    '''
+    接收 Trial 的最终结果。
+    parameter_id: int
+    parameters: 'generate_parameters()' 所创建的对象
+    value: Trial 的最终指标结果
+    '''
+    # 实现代码
+    ...
+    def generate_parameters(self, parameter_id):
+    '''
+    返回 Trial 的超参组合的序列化对象
+    parameter_id: int
+    '''
+    # 代码实现位置
+    return your_parameters
+    ...
+```
+`receive_trial_result` 从输入中会接收 `parameter_id, parameters, value` 参数。 Tuner 会收到 Trial 进程发送的完全一样的 `value` 值。
+`generate_parameters` 函数返回的 `your_parameters`，会被 NNI SDK 打包为 json。 然后 SDK 会将 json 对象解包给 Trial 进程。因此，Trial 进程会收到来自 Tuner 的完全相同的 `your_parameters`。
+例如： 如下实现了 `generate_parameters`：
+```python
+def generate_parameters(self, parameter_id):
+    '''
+    返回 Trial 的超参组合的序列化对象
+    parameter_id: int
+    '''
+    # 代码实现位置
+    return {"dropout": 0.3, "learning_rate": 0.4}
+```
+这表示 Tuner 会一直生成超参组合 `{"dropout": 0.3, "learning_rate": 0.4}`。 而 Trial 进程也会在调用 API `nni.get_next_parameter()` 时得到 `{"dropout": 0.3, "learning_rate": 0.4}`。 Trial 结束后的返回值（通常是某个指标），通过调用 API `nni.report_final_result()` 返回给 Tuner。如： `nni.report_final_result(0.93)`。 而 Tuner 的 `receive_trial_result` 函数会收到如下结果：
+```python
+parameter_id = 82347
+parameters = {"dropout": 0.3, "learning_rate": 0.4}
+value = 0.93
+```
+**注意** 如果需要存取自定义的 Tuner 目录里的文件 (如, `data.txt`)，不能使用 `open('data.txt', 'r')`。 要使用：
+```python
+_pwd = os.path.dirname(__file__)
+_fd = open(os.path.join(_pwd, 'data.txt'), 'r')
+```
+这是因为自定义的 Tuner 不是在自己的目录里执行的。（即，`pwd` 返回的目录不是 Tuner 的目录）。
+**3. 在 Experiment 的 YAML 文件中配置好自定义的 Tuner**
+NNI 需要定位到自定义的 Tuner 类，并实例化它，因此需要指定自定义 Tuner 类的文件位置，并将参数值传给 \_\_init__ 构造函数。
+```yaml
+tuner:
+  codeDir: /home/abc/mytuner
+  classFileName: my_customized_tuner.py
+  className: CustomizedTuner
+  # 任何传入 __init__ 构造函数的参数
+  # 都需要声明在 classArgs 字段中，如：
+  classArgs:
+    arg1: value1
+```
+更多样例，可参考：
+> - [evolution-tuner](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/evolution_tuner)
+> - [hyperopt-tuner](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/hyperopt_tuner)
+> - [evolution-based-customized-tuner](https://github.com/Microsoft/nni/tree/master/examples/tuners/ga_customer_tuner)
+### 实现更高级的自动机器学习算法
+上述内容足够写出通用的 Tuner。 但有时可能需要更多的信息，例如，中间结果， Trial 的状态等等，从而能够实现更强大的自动机器学习算法。 因此，有另一个叫做 `advisor` 的类，直接继承于 `MsgDispatcherBase`，它位于 [`src/sdk/pynni/nni/msg_dispatcher_base.py`](https://github.com/Microsoft/nni/tree/master/src/sdk/pynni/nni/msg_dispatcher_base.py)。 参考[这里](Customize_Advisor.md)来了解如何实现自定义的 advisor。
\ No newline at end of file
--- a/zh_CN/docs/Examples.rst
+++ b/zh_CN/docs/Examples.rst
+######################
+样例
+######################
+..  toctree::
+    :maxdepth: 2
+    MNIST<mnist_examples>
+    Cifar10<cifar10_examples>
+    Scikit-learn<sklearn_examples>
+    EvolutionSQuAD<SQuAD_evolution_examples>
+    GBDT<gbdt_example>
--- a/zh_CN/docs/ExperimentConfig.md
+++ b/zh_CN/docs/ExperimentConfig.md
+# Experiment（实验）配置参考
+创建 Experiment 时，需要给 nnictl 命令提供配置文件的路径。 配置文件是 YAML 格式，需要保证其格式正确。 本文介绍了配置文件的内容，并提供了一些示例和模板。
+* [模板](#Template) (配置文件的模板)
+* [配置说明](#Configuration) (配置文件每个项目的说明)
+* [样例](#Examples) (配置文件样例)
+<a name="Template"></a>
+## 模板
+* **简化版（不包含 Annotation（标记）和 Assessor）**
+```yaml
+authorName: 
+experimentName: 
+trialConcurrency: 
+maxExecDuration: 
+maxTrialNum: 
+#可选项: local, remote, pai, kubeflow
+trainingServicePlatform: 
+searchSpacePath: 
+#可选项: true, false
+useAnnotation: 
+tuner:
+  #可选项: TPE, Random, Anneal, Evolution
+  builtinTunerName:
+  classArgs:
+    #可选项: maximize, minimize
+    optimize_mode:
+  gpuNum: 
+trial:
+  command: 
+  codeDir: 
+  gpuNum: 
+#在本地使用时，machineList 可为空
+machineList:
+  - ip: 
+    port: 
+    username: 
+    passwd:
+```
+* **使用 Assessor**
+```yaml
+authorName: 
+experimentName: 
+trialConcurrency: 
+maxExecDuration: 
+maxTrialNum: 
+#可选项: local, remote, pai, kubeflow
+trainingServicePlatform: 
+searchSpacePath: 
+#可选项: true, false
+useAnnotation: 
+tuner:
+  #可选项: TPE, Random, Anneal, Evolution
+  builtinTunerName:
+  classArgs:
+    #可选项: maximize, minimize
+    optimize_mode:
+  gpuNum: 
+assessor:
+  #可选项: Medianstop
+  builtinAssessorName:
+  classArgs:
+    #可选项: maximize, minimize
+    optimize_mode:
+  gpuNum: 
+trial:
+  command: 
+  codeDir: 
+  gpuNum: 
+#在本地使用时，machineList 可为空
+machineList:
+  - ip: 
+    port: 
+    username: 
+    passwd:
+```
+* **使用 Annotation**
+```yaml
+authorName: 
+experimentName: 
+trialConcurrency: 
+maxExecDuration: 
+maxTrialNum: 
+#可选项: local, remote, pai, kubeflow
+trainingServicePlatform: 
+#可选项: true, false
+useAnnotation: 
+tuner:
+  #可选项: TPE, Random, Anneal, Evolution
+  builtinTunerName:
+  classArgs:
+    #可选项: maximize, minimize
+    optimize_mode:
+  gpuNum: 
+assessor:
+  #可选项: Medianstop
+  builtinAssessorName:
+  classArgs:
+    #可选项: maximize, minimize
+    optimize_mode:
+  gpuNum: 
+trial:
+  command: 
+  codeDir: 
+  gpuNum: 
+#在本地使用时，machineList 可为空
+machineList:
+  - ip: 
+    port: 
+    username: 
+    passwd:
+```
+<a name="Configuration"></a>
+## 说明
+* **authorName**
+  * 说明
+    **authorName** 是创建 Experiment 的作者。 待定: 增加默认值
+* **experimentName**
+  * 说明
+    **experimentName** 是 Experiment 的名称。  
+    待实现：增加默认值
+* **trialConcurrency**
+  * 说明
+    **trialConcurrency** 定义了并发尝试任务的最大数量。
+    注意：如果 trialGpuNum 大于空闲的 GPU 数量，并且并发的 Trial 任务数量还没达到 trialConcurrency，Trial 任务会被放入队列，等待分配 GPU 资源。
+* **maxExecDuration**
+  * 说明
+    **maxExecDuration** 定义 Experiment 执行的最长时间。时间单位：{**s**, **m**, **h**, **d**}，分别代表：{*seconds*, *minutes*, *hours*, *days*}。
+    注意：maxExecDuration 设置的是 Experiment 执行的时间，不是 Trial 的。 如果 Experiment 达到了设置的最大时间，Experiment 不会停止，但不会再启动新的 Trial 作业。
+* **maxTrialNum**
+  * 说明
+    **maxTrialNum** 定义了 Trial 任务的最大数量，成功和失败的都计算在内。
+* **trainingServicePlatform**
+  * 说明
+    **trainingServicePlatform** 定义运行 Experiment 的平台，包括：{**local**, **remote**, **pai**, **kubeflow**}.
+    * **local** 在本机的 ubuntu 上运行 Experiment。
+    * **remote** 将任务提交到远程的 Ubuntu 上，必须用 **machineList** 来指定远程的 SSH 连接信息。
+    * **pai** 提交任务到微软开源的 [OpenPAI](https://github.com/Microsoft/pai) 上。 更多 OpenPAI 配置，参考 [pai 模式](./PAIMode.md)。
+    * **kubeflow** 提交任务至 [Kubeflow](https://www.kubeflow.org/docs/about/kubeflow/)。 NNI 支持基于 Kubeflow 的 Kubenetes，以及[Azure Kubernetes](https://azure.microsoft.com/en-us/services/kubernetes-service/)。
+* **searchSpacePath**
+  * 说明
+    **searchSpacePath** 定义搜索空间文件的路径，此文件必须在运行 nnictl 的本机。
+    注意: 如果设置了 useAnnotation=True，searchSpacePath 字段必须被删除。
+* **useAnnotation**
+  * 说明
+    **useAnnotation** 定义使用标记来分析代码并生成搜索空间。
+    注意: 如果设置了 useAnnotation=True，searchSpacePath 字段必须被删除。
+* **nniManagerIp**
+  * 说明
+    **nniManagerIp** 设置 NNI 管理器运行的 IP 地址。 此字段为可选项，如果没有设置，则会使用 eth0 的 IP 地址。
+    注意: 可在 NNI 管理器机器上运行 ifconfig 来检查 eth0 是否存在。 如果不存在，推荐显式设置 nnimanagerIp。
+* **logDir**
+  * 说明
+    **logDir** 配置存储日志和数据的目录。 默认值是 `<user home directory>/nni/experiment`
+* **logLevel**
+  * 说明
+    **logLevel** 为 Experiment 设置日志级别，支持的日志级别有：`trace, debug, info, warning, error, fatal`。 默认值是 `info`。
+* **Tuner**
+  * 说明
+    **tuner** 指定了 Experiment 的 Tuner 算法。有两种方法可设置 Tuner。 一种方法是使用 SDK 提供的 Tuner，需要设置 **builtinTunerName** 和 **classArgs**。 另一种方法，是使用用户自定义的 Tuner，需要设置 **codeDirectory**，**classFileName**，**className** 和 **classArgs**。
+  * **builtinTunerName** 和 **classArgs**
+    * **builtinTunerName**
+      **builtinTunerName** 指定了系统 Tuner 的名字，NNI SDK 提供了多种 Tuner，如：{**TPE**, **Random**, **Anneal**, **Evolution**, **BatchTuner**, **GridSearch**}。
+    * **classArgs**
+      **classArgs** 指定了 Tuner 算法的参数。 如果 **builtinTunerName** 是{**TPE**, **Random**, **Anneal**, **Evolution**}，用户需要设置 **optimize_mode**。
+  * **codeDir**, **classFileName**, **className** 和 **classArgs**
+    * **codeDir**
+      **codeDir** 指定 Tuner 代码的目录。
+    * **classFileName**
+      **classFileName** 指定 Tuner 文件名。
+    * **className**
+      **className** 指定 Tuner 类名。
+    * **classArgs**
+      **classArgs** 指定了 Tuner 算法的参数。
+    * **gpuNum**
+      **gpuNum** 指定了运行 Tuner 进程的 GPU 数量。 此字段的值必须是正整数。
+      注意: 只能使用一种方法来指定 Tuner，例如：设置{tunerName, optimizationMode} 或 {tunerCommand, tunerCwd}，不能同时设置。
+* **Assessor**
+  * 说明
+    **assessor** 指定了 Experiment 的 Assessor 算法。有两种方法可设置 Assessor。 一种方法是使用 SDK 提供的 Assessor，需要设置 **builtinAssessorName** 和 **classArgs**。 另一种方法，是使用用户自定义的 Assessor，需要设置 **codeDirectory**，**classFileName**，**className** 和 **classArgs**。
+  * **builtinAssessorName** 和 **classArgs**
+    * **builtinAssessorName**
+      **builtinAssessorName** 指定了系统 Assessor 的名称， NNI 内置的 Assessor 有 {**Medianstop**，等等}。
+    * **classArgs**
+      **classArgs** 指定了 Assessor 算法的参数。
+  * **codeDir**, **classFileName**, **className** 和 **classArgs**
+    * **codeDir**
+      **codeDir** 指定 Assessor 代码的目录。
+    * **classFileName**
+      **classFileName** 指定 Assessor 文件名。
+    * **className**
+      **className** 指定 Assessor 类名。
+    * **classArgs**
+      **classArgs** 指定了 Assessor 算法的参数。
+  * **gpuNum**
+    **gpuNum** 指定了运行 Assessor 进程的 GPU 数量。 此字段的值必须是正整数。
+    注意: 只能使用一种方法来指定评估器，例如：设置 {assessorName, optimizationMode} 或 {assessorCommand, assessorCwd}，不能同时设置。如果不需要使用评估器，可将其置为空。
+* **trial (local, remote)**
+  * **command**
+    **command** 指定了运行 Trial 进程的命令行。
+  * **codeDir**
+    **codeDir** 指定了 Trial 代码文件的目录。
+  * **gpuNum**
+    **gpuNum** 指定了运行 Trial 进程的 GPU 数量。 默认值为 0。
+* **trial (pai)**
+  * **command**
+    **command** 指定了运行 Trial 进程的命令行。
+  * **codeDir**
+    **codeDir** 指定了 Trial 代码文件的目录。
+  * **gpuNum**
+    **gpuNum** 指定了运行 Trial 进程的 GPU 数量。 默认值为 0。
+  * **cpuNum**
+    **cpuNum** 指定了 OpenPAI 容器中使用的 CPU 数量。
+  * **memoryMB**
+    **memoryMB** 指定了 OpenPAI 容器中使用的内存数量。
+  * **image**
+    **image** 指定了 OpenPAI 中使用的 docker 映像。
+  * **dataDir**
+    **dataDir** 是 HDFS 中用到的数据目录变量。
+  * **outputDir**
+    **outputDir** 是 HDFS 中用到的输出目录变量。在 OpenPAI 中，stdout 和 stderr 文件会在作业完成后，存放在此目录中。
+* **trial (kubeflow)**
+  * **codeDir**
+    **codeDir** 指定了代码文件的本机路径。
+  * **ps (可选)**
+    **ps** 是 Kubeflow 的 Tensorflow-operator 配置。
+    * **replicas**
+      **replicas** 是 **ps** 角色的副本数量。
+    * **command**
+      **command** 是在 **ps** 的容器中运行的脚本命令。
+    * **gpuNum**
+      **gpuNum** 是在 **ps** 容器中使用的 GPU 数量。
+    * **cpuNum**
+      **cpuNum** 是在 **ps** 容器中使用的 CPU 数量。
+    * **memoryMB**
+      **memoryMB** 指定了容器中使用的内存数量。
+    * **image**
+      **iamge** 设置了 **ps** 使用的 docker 映像。
+  * **worker**
+    **worker** 是 Kubeflow 的 Tensorflow-operator 配置。
+    * **replicas**
+      **replicas** 是 **worker** 角色的副本数量。
+    * **command**
+      **command** 是在 **worker** 的容器中运行的脚本命令。
+    * **gpuNum**
+      **gpuNum** 是在 **worker** 容器中使用的 GPU 数量。
+    * **cpuNum**
+      **cpuNum** 是在 **worker** 容器中使用的 CPU 数量。
+    * **memoryMB**
+      **memoryMB** 指定了容器中使用的内存数量。
+    * **image**
+      **image** 设置了 **worker** 使用的 docker 映像。
+* **machineList**
+  如果 **trainingServicePlatform** 为 remote，则需要设置 **machineList**。否则应将其置为空。
+  * **ip**
+    **ip** 是远程计算机的 ip 地址。
+  * **port**
+    **端口** 是用于连接远程计算机的 ssh 端口。
+    注意：如果 port 设为空，则为默认值 22。
+  * **username**
+    **username** 是远程计算机的用户名。
+  * **passwd**
+    **passwd** 指定了账户的密码。
+  * **sshKeyPath**
+    如果要使用 ssh 密钥登录远程计算机，则需要设置 **sshKeyPath**。 **sshKeyPath** 为有效的 ssh 密钥文件路径。
+    注意：如果同时设置了 passwd 和 sshKeyPath，NNI 会使用 passwd。
+  * **passphrase**
+    **passphrase** 用于保护 ssh 密钥，如果没有使用，可为空。
+* **kubeflowConfig**:
+  * **operator**
+    **operator** 指定了 kubeflow 使用的 operator，NNI 当前版本支持 **tf-operator**。
+  * **存储**
+    **storage** 指定了 kubeflow 的存储类型，包括 {**nfs**，**azureStorage**}。 此字段可选，默认值为 **nfs**。 如果使用了 azureStorage，此字段必须填写。
+  * **nfs**
+    **server** 是 NFS 服务器的地址
+    **path** 是 NFS 挂载的路径
+  * **keyVault**
+    如果用户使用 Azure Kubernetes Service，需要设置 keyVault 来使用 Azure 存储账户的私钥。 参考: https://docs.microsoft.com/en-us/azure/key-vault/key-vault-manage-with-cli2
+    * **vaultName**
+      **vaultName** 是 az 命令中 `--vault-name` 的值。
+    * **name**
+      **name** 是 az 命令中 `--name` 的值。
+  * **azureStorage**
+    如果用户使用了 Azure Kubernetes Service，需要设置 Azure 存储账户来存放代码文件。
+    * **accountName**
+      **accountName** 是 Azure 存储账户的名称。
+    * **azureShare**
+      **azureShare** 是 Azure 文件存储的共享参数。
+* **paiConfig**
+  * **userName**
+    **userName** 是 OpenPAI 的用户名。
+  * **password**
+    **password** 是 OpenPAI 用户的密码。
+  * **host**
+    **host** 是 OpenPAI 的主机地址。
+<a name="Examples"></a>
+## 样例
+* **本机模式**
+  如果要在本机运行 Trial 任务，并使用标记来生成搜索空间，可参考下列配置：
+  ```yaml
+  authorName: test
+  experimentName: test_experiment
+  trialConcurrency: 3
+  maxExecDuration: 1h
+  maxTrialNum: 10
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: local
+  #可选项: true, false
+  useAnnotation: true
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  trial:
+    command: python3 mnist.py
+    codeDir: /nni/mnist
+    gpuNum: 0
+  ```
+  增加 Assessor 配置
+  ```yaml
+  authorName: test
+  experimentName: test_experiment
+  trialConcurrency: 3
+  maxExecDuration: 1h
+  maxTrialNum: 10
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: local
+  searchSpacePath: /nni/search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  assessor:
+    #可选项: Medianstop
+    builtinAssessorName: Medianstop
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  trial:
+    command: python3 mnist.py
+    codeDir: /nni/mnist
+    gpuNum: 0
+  ```
+  或者可以指定自定义的 Tuner 和 Assessor：
+  ```yaml
+  authorName: test
+  experimentName: test_experiment
+  trialConcurrency: 3
+  maxExecDuration: 1h
+  maxTrialNum: 10
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: local
+  searchSpacePath: /nni/search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  tuner:
+    codeDir: /nni/tuner
+    classFileName: mytuner.py
+    className: MyTuner
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  assessor:
+    codeDir: /nni/assessor
+    classFileName: myassessor.py
+    className: MyAssessor
+    classArgs:
+      #choice: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  trial:
+    command: python3 mnist.py
+    codeDir: /nni/mnist
+    gpuNum: 0
+  ```
+* **远程模式**
+  如果在远程服务器上运行 Trial 任务，需要增加服务器信息：
+  ```yaml
+  authorName: test
+  experimentName: test_experiment
+  trialConcurrency: 3
+  maxExecDuration: 1h
+  maxTrialNum: 10
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: remote
+  searchSpacePath: /nni/search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+    gpuNum: 0
+  trial:
+    command: python3 mnist.py
+    codeDir: /nni/mnist
+    gpuNum: 0
+  # 如果是本地 Experiment，machineList 可为空。
+  machineList:
+    - ip: 10.10.10.10
+      port: 22
+      username: test
+      passwd: test
+    - ip: 10.10.10.11
+      port: 22
+      username: test
+      passwd: test
+    - ip: 10.10.10.12
+      port: 22
+      username: test
+      sshKeyPath: /nni/sshkey
+      passphrase: qwert
+  ```
+* **pai 模式**
+  ```yaml
+  authorName: test
+  experimentName: nni_test1
+  trialConcurrency: 1
+  maxExecDuration:500h
+  maxTrialNum: 1
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: pai
+  searchSpacePath: search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution, BatchTuner
+    #SMAC (SMAC 需要使用 nnictl package 单独安装)
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+  trial:
+    command: python3 main.py
+    codeDir: .
+    gpuNum: 4
+    cpuNum: 2
+    memoryMB: 10000
+    # 在 OpenPAI 上用来运行 Nni 作业的 docker 映像
+    image: msranni/nni:latest
+    # 在 OpenPAI 的 hdfs 上存储数据的目录，如：'hdfs://host:port/directory'
+    dataDir: hdfs://10.11.12.13:9000/test
+    # 在 OpenPAI 的 hdfs 上存储输出的目录，如：'hdfs://host:port/directory'
+    outputDir: hdfs://10.11.12.13:9000/test
+  paiConfig:
+    # OpenPAI 用户名
+    userName: test
+    # OpenPAI 密码
+    passWord: test
+    # OpenPAI 服务器 Ip
+    host: 10.10.10.10
+  ```
+* **Kubeflow 模式**
+  使用 NFS 存储。
+  ```yaml
+  authorName: default
+  experimentName: example_mni
+  trialConcurrency: 1
+  maxExecDuration: 1h
+  maxTrialNum: 1
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: kubeflow
+  searchSpacePath: search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+  trial:
+    codeDir: .
+    worker:
+      replicas: 1
+      command: python3 mnist.py
+      gpuNum: 0
+      cpuNum: 1
+      memoryMB: 8192
+      image: msranni/nni:latest
+  kubeflowConfig:
+    operator: tf-operator
+    nfs:
+      server: 10.10.10.10
+      path: /var/nfs/general
+  ```
+  使用 Azure 存储。
+  ```yaml
+  authorName: default
+  experimentName: example_mni
+  trialConcurrency: 1
+  maxExecDuration: 1h
+  maxTrialNum: 1
+  #可选项: local, remote, pai, kubeflow
+  trainingServicePlatform: kubeflow
+  searchSpacePath: search_space.json
+  #可选项: true, false
+  useAnnotation: false
+  #nniManagerIp: 10.10.10.10
+  tuner:
+    #可选项: TPE, Random, Anneal, Evolution
+    builtinTunerName: TPE
+    classArgs:
+      #可选项: maximize, minimize
+      optimize_mode: maximize
+  assessor:
+    builtinAssessorName: Medianstop
+    classArgs:
+      optimize_mode: maximize
+    gpuNum: 0
+  trial:
+    codeDir: .
+    worker:
+      replicas: 1
+      command: python3 mnist.py
+      gpuNum: 0
+      cpuNum: 1
+      memoryMB: 4096
+      image: msranni/nni:latest
+  kubeflowConfig:
+    operator: tf-operator
+    keyVault:
+      vaultName: Contoso-Vault
+      name: AzureStorageAccountKey
+    azureStorage:
+      accountName: storage
+      azureShare: share01
+  ```
\ No newline at end of file
--- a/zh_CN/docs/FAQ.md
+++ b/zh_CN/docs/FAQ.md
+# 常见问答
+此页为常见问题
+### tmp 目录没空间了
+nnictl 在执行时，使用 tmp 目录作为临时目录来复制 codeDir 下的文件。 当遇到下列错误时，先试试清空 **tmp** 目录。
+> OSError: [Errno 28] No space left on device
+### OpenPAI 模式下无法获得 Trial 的数据
+在 OpenPAI 的训练模式下，NNI 管理器会在端口 51189 启动一个 RESTful 服务，来接收 OpenPAI 集群中 Trial 任务的指标数据。 如果在 OpenPAI 模式下的网页中不能看到任何指标，需要检查 51189 端口是否在防火墙规则中已打开。
+### 安装时出现 Segmentation Fault (core dumped)
+> make: *** [install-XXX] Segmentation fault (core dumped)
+可依次试试以下方法：
+* 更新或重新安装 Python 中的 pip： `python3 -m pip install -U pip`
+* 在安装 NNI 时，添加 `--no-cache-dir` 参数：`python3 -m pip install nni --no-cache-dir`
+### Job management error: getIPV4Address() failed because os.networkInterfaces().eth0 is undefined.
+计算机没有 eth0 设备，需要在配置中设置 [nniManagerIp](ExperimentConfig.md)。
+### 运行时间超过了 MaxDuration ，但没有停止
+当 Experiment 到达最长运行时间时，nniManager 不会创建新的 Trial ，但除非手动停止 Experiment，运行中的 Trial 会继续运行直到结束。
+### 使用 `nnictl stop` 无法停止 Experiment
+如果在实验运行时，升级了 nni 或删除了一些配置文件，会因为丢失配置文件而出现这类错误。 可以使用 `ps -ef | grep node` 命令来找到 Experiment 的 pid，并用 `kill -9 {pid}` 命令来停止 Experiment 进程。
+### 无法在虚拟机的 NNI 网页中看到 `指标数据`
+将虚拟机的网络配置为桥接模式来让虚拟机能被网络访问，并确保虚拟机的防火墙没有禁止相关端口。
+### 帮助改进
+在创建新问题前，请在 https://github.com/Microsoft/nni/issues 查看是否有人已经报告了相似的问题。
\ No newline at end of file
--- a/zh_CN/docs/FrameworkControllerMode.md
+++ b/zh_CN/docs/FrameworkControllerMode.md
+# **在 FrameworkController 上运行 Experiment**
+NNI 支持使用 [FrameworkController](https://github.com/Microsoft/frameworkcontroller)，来运行 Experiment，称之为 frameworkcontroller 模式。 FrameworkController 构建于 Kubernetes 上，用于编排各种应用。这样，可以不用为某个深度学习框架安装 Kubeflow 的 tf-operator 的 pytorch-operator 等。 而直接用 frameworkcontroller 作为 NNI Experiment 的训练服务。
+## 私有部署的 Kubernetes 的准备工作
+1. 采用 Kubernetes 1.8 或更高版本。 根据[指南](https://kubernetes.io/docs/setup/)来安装 Kubernetes。
+2. 配置 **kubeconfig** 文件，NNI 将使用此配置与 Kubernetes API 服务交互。 默认情况下，NNI 管理器会使用 $(HOME)/.kube/config 作为 kubeconfig 文件的路径。 也可以通过环境变量 **KUBECONFIG** 来指定其它 kubeconfig 文件。 根据[指南](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig)了解更多 kubeconfig 的信息。
+3. 如果 NNI Trial 作业需要 GPU 资源，需按照[指南](https://github.com/NVIDIA/k8s-device-plugin)来配置 **Kubernetes 下的 Nvidia 插件**。
+4. 准备 **NFS 服务器** 并导出通用的装载 (mount)，推荐将 NFS 服务器路径映射到 `root_squash 选项`，否则可能会在 NNI 复制文件到 NFS 时出现权限问题。 参考[页面](https://linux.die.net/man/5/exports)，来了解关于 root_squash 选项，或 **Azure File Storage**。
+5. 在安装 NNI 并运行 nnictl 的计算机上安装 **NFS 客户端**。 运行此命令安装 NFSv4 客户端： ```apt-get install nfs-common```
+6. 参考[指南](QuickStart.md)安装 **NNI**。
+## Azure 部署的 Kubernetes 的准备工作
+1. NNI 支持基于 Azure Kubernetes Service 的 Kubeflow，参考[指南](https://azure.microsoft.com/en-us/services/kubernetes-service/)来设置 Azure Kubernetes Service。
+2. 安装 [Azure CLI](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest) 和 **kubectl**。 使用 `az login` 命令来设置 Azure 账户吗，并将 kubectl 客户端连接到 AKS，参考此[指南](https://docs.microsoft.com/en-us/azure/aks/kubernetes-walkthrough#connect-to-the-cluster)。
+3. 参考此[指南](https://docs.microsoft.com/en-us/azure/storage/common/storage-quickstart-create-account?tabs=portal)来创建 Azure 文件存储账户。 NNI 需要 Azure Storage Service 来存取代码和输出文件。
+4. NNI 需要访问密钥来连接 Azure 存储服务，NNI 使用 [Azure Key Vault](https://azure.microsoft.com/en-us/services/key-vault/) 服务来保护私钥。 设置 Azure Key Vault 服务，并添加密钥到 Key Vault 中来存取 Azure 存储账户。 参考[指南](https://docs.microsoft.com/en-us/azure/key-vault/quick-create-cli)来存储访问密钥。
+## 安装 FrameworkController
+参考[指南](https://github.com/Microsoft/frameworkcontroller/tree/master/example/run)来在 Kubernetes 集群中配置 Frameworkcontroller。NNI 通过 statefulset 模式来 支持 Frameworkcontroller。
+## 设计
+参考[Kubeflow 训练服务](./KubeflowMode.md)，Frameworkcontroller 服务管道非常类似。
+## 样例
+Frameworkcontroller 配置文件的格式如下：
+    authorName: default
+    experimentName: example_mnist
+    trialConcurrency: 1
+    maxExecDuration: 10h
+    maxTrialNum: 100
+    #可选项: local, remote, pai, kubeflow, frameworkcontroller
+    trainingServicePlatform: frameworkcontroller
+    searchSpacePath: ~/nni/examples/trials/mnist/search_space.json
+    #可选项: true, false
+    useAnnotation: false
+    tuner:
+      #可选项: TPE, Random, Anneal, Evolution
+      builtinTunerName: TPE
+      classArgs:
+        #可选项: maximize, minimize
+        optimize_mode: maximize
+    assessor:
+      builtinAssessorName: Medianstop
+      classArgs:
+        optimize_mode: maximize
+      gpuNum: 0
+    trial:
+      codeDir: ~/nni/examples/trials/mnist
+      taskRoles:
+        - name: worker
+          taskNum: 1
+          command: python3 mnist.py
+          gpuNum: 1
+          cpuNum: 1
+          memoryMB: 8192
+          image: msranni/nni:latest
+          frameworkAttemptCompletionPolicy:
+            minFailedTaskCount: 1
+            minSucceededTaskCount: 1
+    frameworkcontrollerConfig:
+      storage: nfs
+      nfs:
+        server: {your_nfs_server}
+        path: {your_nfs_server_exported_path}
+如果使用了 Azure Kubernetes Service，需要在 YAML 文件中如下设置 `frameworkcontrollerConfig`：
+    frameworkcontrollerConfig:
+      storage: azureStorage
+      keyVault:
+        vaultName: {your_vault_name}
+        name: {your_secert_name}
+      azureStorage:
+        accountName: {your_storage_account_name}
+        azureShare: {your_azure_share_name}
+注意：如果用 FrameworkController 模式运行，需要在 YAML 文件中显式设置 `trainingServicePlatform: frameworkcontroller`。
+FrameworkController 模式的 Trial 配置格式，是 FrameworkController 官方配置的简化版。参考 [frameworkcontroller 的 tensorflow 样例](https://github.com/Microsoft/frameworkcontroller/blob/master/example/framework/scenario/tensorflow/cpu/tensorflowdistributedtrainingwithcpu.yaml) 了解详情。  
+frameworkcontroller 模式中的 Trial 配置使用以下主键：
+* taskRoles: 配置文件中可以设置多个任务角色，每个任务角色都是在 Kubernetes 集群中的基本执行单元。 
+   * name: 任务角色的名字，例如，"worker", "ps", "master"。
+   * taskNum: 任务角色的实例数量。
+   * command: 在容器中要执行的用户命令。
+   * gpuNum: 容器要使用的 GPU 数量。
+   * cpuNum: 容器中要使用的 CPU 数量。
+   * memoryMB: 容器的内存限制。
+   * image: 用来创建 pod，并运行程序的 Docker 映像。
+   * frameworkAttemptCompletionPolicy: 运行框架的策略，参考[用户手册](https://github.com/Microsoft/frameworkcontroller/blob/master/doc/user-manual.md#frameworkattemptcompletionpolicy)了解更多信息。 这些策略可以用来控制 pod，例如，如果 worker 任务停止了，但 ps 没有停止，CompletionPolicy 策略可以停止 ps。
+## 如何运行示例
+准备好配置文件后，通过运行 nnictl 来启动 Experiment。 在 Frameworkcontroller 上开始 Experiment 的方法与 Kubeflow 类似，可参考[指南](./KubeflowMode.md)了解更多信息。
\ No newline at end of file