Update Chinese Translation (#2871)

* New Crowdin translations by Github Action * remove removed files in en_US Co-authored-by: Crowdin Bot <support+bot@crowdin.com>

Update Chinese Translation (#2871)
* New Crowdin translations by Github Action * remove removed files in en_US Co-authored-by: Crowdin Bot <support+bot@crowdin.com>
0e49e659 · Junwei Sun · GitHub · 171400ee · 0e49e659 · 0e49e659
Unverified Commit 0e49e659 authored Sep 18, 2020 by Junwei Sun Committed by GitHub Sep 18, 2020
20 changed files
--- a/README_zh_CN.md
+++ b/README_zh_CN.md
@@ -10,7 +10,7 @@
 **NNI (Neural Network Intelligence)** 是一个轻量但强大的工具包，帮助用户**自动**的进行[特征工程](docs/zh_CN/FeatureEngineering/Overview.md)，[神经网络架构搜索](docs/zh_CN/NAS/Overview.md)，[超参调优](docs/zh_CN/Tuner/BuiltinTuner.md)以及[模型压缩](docs/zh_CN/Compressor/Overview.md)。
-NNI 管理自动机器学习 (AutoML) 的 Experiment，**调度运行**由调优算法生成的 Trial 任务来找到最好的神经网络架构和/或超参，支持**各种训练环境**，如[本机](docs/zh_CN/TrainingService/LocalMode.md)，[远程服务器](docs/zh_CN/TrainingService/RemoteMachineMode.md)，[OpenPAI](docs/zh_CN/TrainingService/PaiMode.md)，[Kubeflow](docs/zh_CN/TrainingService/KubeflowMode.md)，[基于 K8S 的 FrameworkController（如，AKS 等)](docs/zh_CN/TrainingService/FrameworkControllerMode.md)， [DLWorkspace (又称 DLTS)](docs/zh_CN/TrainingService/DLTSMode.md) 和其它云服务。
+NNI 管理自动机器学习 (AutoML) 的 Experiment，**调度运行**由调优算法生成的 Trial 任务来找到最好的神经网络架构和/或超参，支持**各种训练环境**，如[本机](docs/zh_CN/TrainingService/LocalMode. md)，[远程服务器](docs/zh_CN/TrainingService/RemoteMachineMode. md)，[OpenPAI](docs/zh_CN/TrainingService/PaiMode. md)，[Kubeflow](docs/zh_CN/TrainingService/KubeflowMode. md)，[基于 K8S 的 FrameworkController（如，AKS 等)](docs/zh_CN/TrainingService/FrameworkControllerMode. md)， [DLWorkspace](docs/zh_CN/TrainingService/DLTSMode. md) (又称 DLTS)</a>, [AML](docs/zh_CN/TrainingService/AMLMode.md) (Azure Machine Learning) 以及其它环境。
 ## **使用场景**
@@ -19,7 +19,7 @@ NNI 管理自动机器学习 (AutoML) 的 Experiment，**调度运行**由调优
 * 想要更容易**实现或试验新的自动机器学习算法**的研究员或数据科学家，包括：超参调优算法，神经网络搜索算法以及模型压缩算法。
 * 在机器学习平台中**支持自动机器学习**。
-### **[NNI v1.6 已发布！](https://github.com/microsoft/nni/releases) &nbsp;[<img width="48" src="docs/img/release_icon.png" />](#nni-released-reminder)**
+### **[NNI v1.8 已发布！](https://github.com/microsoft/nni/releases) &nbsp;[<img width="48" src="docs/img/release_icon.png" />](#nni-released-reminder)**
 ## **NNI 功能一览**
@@ -164,6 +164,7 @@ NNI 提供命令行工具以及友好的 WebUI 来管理训练的 Experiment。
      <ul>
        <li><a href="docs/zh_CN/TrainingService/LocalMode.md">本机</a></li>
        <li><a href="docs/zh_CN/TrainingService/RemoteMachineMode.md">远程计算机</a></li>
+        <li><a href="docs/zh_CN/TrainingService/AMLMode.md">AML(Azure Machine Learning)</a></li>
        <li><b>基于 Kubernetes 的平台</b></li>
            <ul><li><a href="docs/zh_CN/TrainingService/PaiMode.md">OpenPAI</a></li>
            <li><a href="docs/zh_CN/TrainingService/KubeflowMode.md">Kubeflow</a></li>
@@ -208,7 +209,7 @@ NNI 提供命令行工具以及友好的 WebUI 来管理训练的 Experiment。
 ### **安装**
-NNI 支持并在 Ubuntu >= 16.04, macOS >= 10.14.1, 和 Windows 10 >= 1809 通过了测试。 在 `python 64-bit >= 3.5` 的环境中，只需要运行 `pip install` 即可完成安装。
+NNI 支持并在 Ubuntu >= 16.04, macOS >= 10.14.1, 和 Windows 10 >= 1809 通过了测试。 在 `python 64-bit >= 3.6` 的环境中，只需要运行 `pip install` 即可完成安装。
 Linux 或 macOS
@@ -239,7 +240,7 @@ Linux 和 macOS 下 NNI 系统需求[参考这里](https://nni.readthedocs.io/zh
 * 通过克隆源代码下载示例。
   ```bash
-   git clone -b v1.6 https://github.com/Microsoft/nni.git
+   git clone -b v1.8 https://github.com/Microsoft/nni.git
   ```
 * 运行 MNIST 示例。

--- a/deployment/docker/README_zh_CN.md
+++ b/deployment/docker/README_zh_CN.md
-# Dockerfile
+# Dockerfile 
 ## 1. 说明
 这是 NNI 项目的 Dockerfile 文件。 其中包含了 NNI 以及多个流行的深度学习框架。 在 `Ubuntu 16.04 LTS` 上进行过测试：
-    CUDA 9.0, CuDNN 7.0
+    CUDA 9.0
-    numpy 1.14.3,scipy 1.1.0
+    CuDNN 7.0
-    TensorFlow-gpu 1.10.0
+    numpy 1.14.3
-    Keras 2.1.6
+    scipy 1.1.0
-    PyTorch 0.4.1
+    tensorflow-gpu 1.15.0
-    scikit-learn 0.20.0
+    keras 2.1.6
+    torch 1.4.0
+    scikit-learn 0.23.2
    pandas 0.23.4
    lightgbm 2.2.2
-    NNI v0.7
+    nni
 此 Dockerfile 可作为定制的参考。
@@ -47,4 +49,4 @@
 使用下列命令从 docker Hub 中拉取 NNI docker 映像。
    docker pull msranni/nni:latest
\ No newline at end of file
--- a/docs/zh_CN/Assessor/CustomizeAssessor.md
+++ b/docs/zh_CN/Assessor/CustomizeAssessor.md
@@ -54,7 +54,7 @@ assessor:
 注意在 **2** 中， `trial_history` 对象与 Trial 通过 `report_intermediate_result` 函数返回给 Assessor 的对象完全一致。
-Assessor 的工作目录是`<home>/nni/experiments/<experiment_id>/log` 可从环境变量 `NNI_LOG_DIRECTORY` 中获取。
+Assessor 的工作目录是`<home>/nni-experiments/<experiment_id>/log` 可从环境变量 `NNI_LOG_DIRECTORY` 中获取。
 更多示例，可参考：

--- a/docs/zh_CN/CommunitySharings/HpoComparision.md
+++ b/docs/zh_CN/CommunitySharings/HpoComparision.md
 # 超参数优化的对比
 *匿名作者*
 超参优化算法（HPO）在几个问题上的对比。
 超参数优化算法如下：
- [Random Search（随机搜索）](../Tuner/BuiltinTuner.md)
+- [Random Search](../Tuner/BuiltinTuner.md)
- [Grid Search（遍历搜索）](../Tuner/BuiltinTuner.md)
+- [Grid Search](../Tuner/BuiltinTuner.md)
 - [Evolution](../Tuner/BuiltinTuner.md)
- [Anneal（退火算法）](../Tuner/BuiltinTuner.md)
+- [Anneal](../Tuner/BuiltinTuner.md)
 - [Metis](../Tuner/BuiltinTuner.md)
 - [TPE](../Tuner/BuiltinTuner.md)
 - [SMAC](../Tuner/BuiltinTuner.md)
@@ -20,15 +19,16 @@
 环境：
-    OS: Linux Ubuntu 16.04 LTS
+```
-    CPU: Intel(R) Xeon(R) CPU E5-2690 v3 @ 2.60GHz 2600 MHz
+OS: Linux Ubuntu 16.04 LTS
-    Memory: 112 GB
+CPU: Intel(R) Xeon(R) CPU E5-2690 v3 @ 2.60GHz 2600 MHz
-    NNI Version: v0.7
+Memory: 112 GB
-    NNI 模式(local|pai|remote): local
+NNI Version: v0.7
-    Python 版本: 3.6
+NNI 模式(local|pai|remote): local
-    使用的虚拟环境: Conda
+Python 版本: 3.6
-    是否在 Docker 中运行: no
+使用的虚拟环境: Conda
+是否在 Docker 中运行: no
+```
 ## AutoGBDT 示例
@@ -67,40 +67,40 @@
 }
 ```
-总搜索空间为 1, 204, 224 次，将最大 Trial 次数设置为1000。 时间限制为 48 小时。
+总搜索空间为 1, 204, 224 次，将最大 Trial 次数设置为 1000。 时间限制为 48 小时。
 ### 结果
-| 算法            | 最好的损失值       | 最好的 5 次损失的平均值 | 最好的 10 次损失的平均 |
+| 算法            | 最好的损失值       | 最好的 5 次损失的平均值 | 最好的 10 次损失的平均值 |
-| ------------- | ------------ | ------------- | ------------- |
+| ------------- | ------------ | ------------- | -------------- |
-| Random Search | 0.418854     | 0.420352      | 0.421553      |
+| Random Search | 0.418854     | 0.420352      | 0.421553       |
-| Random Search | 0.417364     | 0.420024      | 0.420997      |
+| Random Search | 0.417364     | 0.420024      | 0.420997       |
-| Random Search | 0.417861     | 0.419744      | 0.420642      |
+| Random Search | 0.417861     | 0.419744      | 0.420642       |
-| Grid Search   | 0.498166     | 0.498166      | 0.498166      |
+| Grid Search   | 0.498166     | 0.498166      | 0.498166       |
-| Evolution     | 0.409887     | 0.409887      | 0.409887      |
+| Evolution     | 0.409887     | 0.409887      | 0.409887       |
-| Evolution     | 0.413620     | 0.413875      | 0.414067      |
+| Evolution     | 0.413620     | 0.413875      | 0.414067       |
-| Evolution     | 0.409887     | 0.409887      | 0.409887      |
+| Evolution     | 0.409887     | 0.409887      | 0.409887       |
-| Anneal        | 0.414877     | 0.417289      | 0.418281      |
+| Anneal        | 0.414877     | 0.417289      | 0.418281       |
-| Anneal        | 0.409887     | 0.409887      | 0.410118      |
+| Anneal        | 0.409887     | 0.409887      | 0.410118       |
-| Anneal        | 0.413683     | 0.416949      | 0.417537      |
+| Anneal        | 0.413683     | 0.416949      | 0.417537       |
-| Metis         | 0.416273     | 0.420411      | 0.422380      |
+| Metis         | 0.416273     | 0.420411      | 0.422380       |
-| Metis         | 0.420262     | 0.423175      | 0.424816      |
+| Metis         | 0.420262     | 0.423175      | 0.424816       |
-| Metis         | 0.421027     | 0.424172      | 0.425714      |
+| Metis         | 0.421027     | 0.424172      | 0.425714       |
-| TPE           | 0.414478     | 0.414478      | 0.414478      |
+| TPE           | 0.414478     | 0.414478      | 0.414478       |
-| TPE           | 0.415077     | 0.417986      | 0.418797      |
+| TPE           | 0.415077     | 0.417986      | 0.418797       |
-| TPE           | 0.415077     | 0.417009      | 0.418053      |
+| TPE           | 0.415077     | 0.417009      | 0.418053       |
-| SMAC          | **0.408386** | **0.408386**  | **0.408386**  |
+| SMAC          | **0.408386** | **0.408386**  | **0.408386**   |
-| SMAC          | 0.414012     | 0.414012      | 0.414012      |
+| SMAC          | 0.414012     | 0.414012      | 0.414012       |
-| SMAC          | **0.408386** | **0.408386**  | **0.408386**  |
+| SMAC          | **0.408386** | **0.408386**  | **0.408386**   |
-| BOHB          | 0.410464     | 0.415319      | 0.417755      |
+| BOHB          | 0.410464     | 0.415319      | 0.417755       |
-| BOHB          | 0.418995     | 0.420268      | 0.422604      |
+| BOHB          | 0.418995     | 0.420268      | 0.422604       |
-| BOHB          | 0.415149     | 0.418072      | 0.418932      |
+| BOHB          | 0.415149     | 0.418072      | 0.418932       |
-| HyperBand     | 0.414065     | 0.415222      | 0.417628      |
+| HyperBand     | 0.414065     | 0.415222      | 0.417628       |
-| HyperBand     | 0.416807     | 0.417549      | 0.418828      |
+| HyperBand     | 0.416807     | 0.417549      | 0.418828       |
-| HyperBand     | 0.415550     | 0.415977      | 0.417186      |
+| HyperBand     | 0.415550     | 0.415977      | 0.417186       |
-| GP            | 0.414353     | 0.418563      | 0.420263      |
+| GP            | 0.414353     | 0.418563      | 0.420263       |
-| GP            | 0.414395     | 0.418006      | 0.420431      |
+| GP            | 0.414395     | 0.418006      | 0.420431       |
-| GP            | 0.412943     | 0.416566      | 0.418443      |
+| GP            | 0.412943     | 0.416566      | 0.418443       |
 此例中，所有算法都使用了默认参数。 Metis 算法因为其高斯计算过程的复杂度为 O(n^3) 而运行非常慢，因此仅执行了 300 次 Trial。
@@ -114,21 +114,22 @@
 #### 计算机配置
-    RocksDB:    version 6.1
+```
-    CPU:        6 * Intel(R) Xeon(R) CPU E5-2690 v4 @ 2.60GHz
+RocksDB:    version 6.1
-    CPUCache:   35840 KB
+CPU:        6 * Intel(R) Xeon(R) CPU E5-2690 v4 @ 2.60GHz
-    Keys:       16 bytes each
+CPUCache:   35840 KB
-    Values:     100 bytes each (50 bytes after compression)
+Keys:       16 bytes each
-    Entries:    1000000
+Values:     100 bytes each (50 bytes after compression)
+Entries:    1000000
+```
 #### 存储性能
 **延迟**：每个 IO 请求都需要一些时间才能完成，这称为平均延迟。 有几个因素会影响此时间，包括网络连接质量和硬盘IO性能。
-**IOPS**： **每秒的 IO 操作数量**，这意味着可以在一秒钟内完成的*读取或写入操作次数*。
+**IOPS**：**每秒的 IO 操作数量**，这意味着可以在一秒钟内完成的_读取或写入操作次数_。
-**IO 大小**： **每个 IO 请求的大小**。 根据操作系统和需要磁盘访问的应用程序、服务，它将同时发出读取或写入一定数量数据的请求。
+**IO 大小**：**每个 IO 请求的大小**。 根据操作系统和需要磁盘访问的应用程序、服务，它将同时发出读取或写入一定数量数据的请求。
 **吞吐量（以 MB/s 为单位）= 平均 IO 大小 x IOPS **
@@ -200,7 +201,7 @@ IOPS 与在线处理能力有关，我们在实验中使用 IOPS 作为指标。
 | SMAC      | 491067          | 490472          | **491136**      |
 | Metis     | 444920          | 457060          | 454438          |
-Figure:
+图：
 ![](../../img/hpo_rocksdb_fillrandom.png)
@@ -215,6 +216,6 @@ Figure:
 | SMAC      | 2270874         | 2284904         | 2282266         |
 | Metis     | **2287696**     | 2283496         | 2277701         |
-Figure:
+图：
 ![](../../img/hpo_rocksdb_readrandom.png)
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/ModelCompressionComparison.md
+++ b/docs/zh_CN/CommunitySharings/ModelCompressionComparison.md
+# 滤波器剪枝算法比较
+为了初步了解各种滤波器剪枝算法的性能，在一些基准模型和数据集上使用各种剪枝算法进行了广泛的实验。 此文档中展示了实验结果。 此外，还对这些实验的复现提供了友好的说明，以促进对这项工作的进一步贡献。
+## 实验设置
+实验使用以下剪枝器/数据集/模型进行:
+* 模型：[VGG16, ResNet18, ResNet50](https://github.com/microsoft/nni/tree/master/examples/model_compress/models/cifar10)
+* 数据集：CIFAR-10
+* 剪枝器：
+    - 剪枝器包括：
+        - 迭代式剪枝器 : `SimulatedAnnealing Pruner`, `NetAdapt Pruner`, `AutoCompress Pruner`。 给定总体稀疏度要求，这类剪枝器可以在不同层中自动分配稀疏度。
+        - 单轮剪枝器：`L1Filter Pruner`，`L2Filter Pruner`，`FPGM Pruner`。 每层的稀疏度与实验设置的总体稀疏度相同。
+    - 这里只比较 **filter pruning** 的剪枝效果。
+    对于迭代式剪枝器，使用 `L1Filter Pruner` 作为基础算法。 也就是说, 在迭代式剪枝器决定了稀疏度分布之后，使用 `L1Filter Pruner` 进行真正的剪枝。
+    - 上面列出来的所有的剪枝器都已经在 [NNI](https://github.com/microsoft/nni/tree/master/docs/zh_CN/Compressor/Overview.md) 中实现。
+## 实验结果
+对于每一个数据集/模型/剪枝器的组合，设置不同的目标稀疏度对模型进行剪枝。
+这里展示了**权重数量 - 性能**曲线，还展示了**FLOPs - 性能**曲线。 同时在图上画出论文 [AutoCompress: An Automatic DNN Structured Pruning Framework for Ultra-High Compression Rates](http://arxiv.org/abs/1907.03141) 中对 VGG16 和 ResNet18 在 CIFAR-10 上的剪枝结果作为对比。
+实验结果如下图所示：
+CIFAR-10, VGG16:
+![](../../../examples/model_compress/comparison_of_pruners/img/performance_comparison_vgg16.png)
+CIFAR-10, ResNet18:
+![](../../../examples/model_compress/comparison_of_pruners/img/performance_comparison_resnet18.png)
+CIFAR-10, ResNet50:
+![](../../../examples/model_compress/comparison_of_pruners/img/performance_comparison_resnet50.png)
+## 分析
+从实验结果中，得到以下结论：
+* 如果稀疏度是通过限制参数量，那么迭代式剪枝器 ( `AutoCompress Pruner` , `SimualatedAnnealing Pruner` ) 比单轮剪枝器表现好。 但是在以 FLOPs 稀疏度为标准的情况下，它们相比于单轮剪枝器就没有了优势，因为当前的这些剪枝算法都是根据参数稀疏度来剪枝的。
+* 在上述实验中，简单的单轮剪枝器 `L1Filter Pruner` , `L2Filter Pruner` , `FPGM Pruner` 表现比较相近。
+* `NetAdapt Pruner` 无法达到比较高的压缩率。 因为它的机制是一次迭代只剪枝一层。 这就导致如果每次迭代剪掉的稀疏度远小于指定的总的稀疏度的话，会导致不可接受的剪枝复杂度。
+## 实验复现
+### 实现细节
+* 实验结果都是在 NNI 中使用剪枝器的默认配置收集的，这意味着当我们在 NNI 中调用一个剪枝器类时，我们不会更改任何默认的类参数。
+* FLOPs 和 参数数量均通过 [模型 FLOPs 和参数计数器](https://github.com/microsoft/nni/blob/master/docs/zh_CN/Compressor/CompressionUtils.md#model-flopsparameters-counter)在[模型加速](https://github.com/microsoft/nni/blob/master/docs/zh_CN/Compressor/ModelSpeedup.md)后计算。 这避免了依据掩码模型计算的潜在问题。
+* 实验代码在[这里](https://github.com/microsoft/nni/tree/master/examples/model_compress/auto_pruners_torch.py)。
+### 实验结果展示
+* 如果遵循[示例](https://github.com/microsoft/nni/tree/master/examples/model_compress/auto_pruners_torch.py)的做法，对于每一次剪枝实验，实验结果将以JSON格式保存如下：
+    ``` json
+    {
+        "performance": {"original": 0.9298, "pruned": 0.1, "speedup": 0.1, "finetuned": 0.7746}, 
+        "params": {"original": 14987722.0, "speedup": 167089.0}, 
+        "flops": {"original": 314018314.0, "speedup": 38589922.0}
+    }
+    ```
+* 实验结果保存在[这里](https://github.com/microsoft/nni/tree/master/examples/model_compress/comparison_of_pruners)。 可以参考[分析](https://github.com/microsoft/nni/blob/master/examples/model_compress/comparison_of_pruners/analyze.py)来绘制新的性能比较图。
+## 贡献
+### 待办事项
+* 有 FLOPS/延迟 限制的剪枝器
+* 更多剪枝算法/数据集/模型
+### 问题
+关于算法实现及实验问题，请[发起 issue](https://github.com/microsoft/nni/issues/new/)。
--- a/docs/zh_CN/CommunitySharings/NNI_colab_support.md
+++ b/docs/zh_CN/CommunitySharings/NNI_colab_support.md
+# 在 Google Colab 上使用 NNI
+在 Google Colab 上轻松使用 NNI。 Colab 没有暴露它的公网 IP 及端口，因此默认情况下无法在 Colab 中访问 NNI 的 Web 界面。 为解决此问题，需要使用反向代理软件，例如 `ngrok` 或 `frp`。 此教程将展示如何使用 ngrok 在 Colab 上访问 NNI 的Web 界面。
+## 如何在 Google Colab 上打开 NNI 的 Web 界面
+1. 安装需要的包和软件。
+```
+! pip install nni # install nni
+! wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip # download ngrok and unzip it
+! unzip ngrok-stable-linux-amd64.zip
+! mkdir -p nni_repo
+! git clone https://github.com/microsoft/nni.git nni_repo/nni # clone NNI's offical repo to get examples
+```
+2. 在[此处](https://ngrok.com/)注册 ngrok 账号，然后通过 authtoken 来连接。
+```
+! ./ngrok authtoken <your-authtoken>
+```
+3. 在大于 1024 的端口号上启动 NNI 样例，之后在相同端口上启动 ngrok。 如果希望使用 GPU，确保 config.yml 中 gpuNum >= 1 。 因为使用 `! ngrok http 5000 &` 会停止响应，要使用 </0> get_ipython()</code> 来启动 ngrok。
+```
+! nnictl create --config nni_repo/nni/examples/trials/mnist-pytorch/config.yml --port 5000 &
+get_ipython().system_raw('./ngrok http 5000 &')
+```
+4. 查看公网 url 。
+```
+! curl -s http://localhost:4040/api/tunnels # don't change the port number 4040
+```
+在步骤 4 后将会看到类似 http://xxxx.ngrok.io 的 url，打开此url即可看到 NNI 的Web 界面。 玩得开心 :)
+## 使用 frp 访问 Web 界面
+frp 是另一款提供了相似功能的反向代理软件。 但 frp 不提供免费的公网 url，因此可能需要一台拥有公网 IP 的服务器来作为 frp 的服务器端。 参考[这里](https://github.com/fatedier/frp)来了解如何部署 frp。
--- a/docs/zh_CN/CommunitySharings/NasComparision.md
+++ b/docs/zh_CN/CommunitySharings/NasComparision.md
 # 神经网络结构搜索的对比
 *匿名作者*
 训练和比较 NAS（神经网络架构搜索）的模型，包括 Autokeras，DARTS，ENAS 和 NAO。
 源码链接如下：
- Autokeras: <https://github.com/jhfjhfj1/autokeras>
+- Autokeras: [https://github.com/jhfjhfj1/autokeras](https://github.com/jhfjhfj1/autokeras)
- DARTS: <https://github.com/quark0/darts>
+- DARTS: [https://github.com/quark0/darts](https://github.com/quark0/darts)
- ENAS: <https://github.com/melodyguan/enas>
+- ENAS: [https://github.com/melodyguan/enas](https://github.com/melodyguan/enas)
- NAO: <https://github.com/renqianluo/NAO>
+- NAO: [https://github.com/renqianluo/NAO](https://github.com/renqianluo/NAO)
 ## 实验说明
@@ -27,9 +26,11 @@
 | [ImageNet-10-1](http://www.image-net.org/)                                              | 9,750   | 10    | 咖啡杯、电脑键盘、餐桌、衣柜、割草机、麦克风、秋千、缝纫机、里程表和燃气泵。                      |
 | [ImageNet-10-2](http://www.image-net.org/)                                              | 9,750   | 10    | 鼓，班吉，口哨，三角钢琴，小提琴，管风琴，原声吉他，长号，长笛和萨克斯。                        |
 没有改变源码中的 Fine-tuning 方法。 为了匹配每个任务，改变了源码中模型的输入图片大小和输出类别数目的部分。
-所有 NAS 方法模型搜索时间和重训练时间都是**两天**。 所有结果都是基于**三次重复实验**。 评估计算机有一块 Nvidia Tesla P100 GPU、112GB 内存和 2.60GHz CPU (Intel E5-2690)。
+所有 NAS 方法模型搜索时间和重训练时间都是**两天**。  所有结果都是基于**三次重复实验**。 评估计算机有一块 Nvidia Tesla P100 GPU、112GB 内存和 2.60GHz CPU (Intel E5-2690)。
 NAO 需要太多的计算资源，因此只使用提供 Pipeline 脚本的 NAO-WS。
@@ -54,15 +55,15 @@ NAO 需要太多的计算资源，因此只使用提供 Pipeline 脚本的 NAO-W
 | --------- | ------------ |:----------------:|:----------------:|:--------------:|:-----------:|
 | CIFAR- 10 | 88.56(best)  |   96.13(best)    |   97.11(best)    | 97.17(average) | 96.47(best) |
-AutoKeras，由于其算法中的随机因素，它在所有数据集中的表现相对较差。
+对于 AutoKeras，由于其算法中的随机因素，它在所有数据集中的表现相对较差。
-ENAS，ENAS（macro）在 OUI-Adience-Age 数据集中表现较好，并且 ENAS（micro）在 CIFAR-10 数据集中表现较好。
+对于 ENAS，ENAS（macro）在 OUI-Adience-Age 数据集中表现较好，并且 ENAS（micro）在 CIFAR-10 数据集中表现较好。
-对于DARTS，在某些数据集上具有良好的结果，但在某些数据集中具有比较大的方差。 DARTS 三次实验中的差异在 OUI-Audience-Age 数据集上可达 5.37％（绝对值），在 ImageNet-10-1 数据集上可达4.36％（绝对值）。
+对于 DARTS，在某些数据集上具有良好的结果，但在某些数据集中具有比较大的方差。 DARTS 三次实验中的差异在 OUI-Audience-Age 数据集上可达 5.37％（绝对值），在 ImageNet-10-1 数据集上可达4.36％（绝对值）。
 NAO-WS 在 ImageNet-10-2 中表现良好，但在 OUI-Adience-Age 中表现非常差。
-## 参考文献
+## 参考
 1. Jin, Haifeng, Qingquan Song, and Xia Hu. "Efficient neural architecture search with network morphism." *arXiv preprint arXiv:1806.10282* (2018).
@@ -70,4 +71,4 @@ NAO-WS 在 ImageNet-10-2 中表现良好，但在 OUI-Adience-Age 中表现非
 3. Pham, Hieu, et al. "Efficient Neural Architecture Search via Parameters Sharing." international conference on machine learning (2018): 4092-4101.
 4. Luo, Renqian, et al. "Neural Architecture Optimization." neural information processing systems (2018): 7827-7838.
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/RecommendersSvd.md
+++ b/docs/zh_CN/CommunitySharings/RecommendersSvd.md
-# 在 NNI 上自动调优 SVD
+# 自动调优 SVD（在推荐系统中使用 NNI）
 本教程中，会首先介绍 GitHub 存储库：[Recommenders](https://github.com/Microsoft/Recommenders)。 它使用 Jupyter Notebook 提供了构建推荐系统的一些示例和实践技巧。 其中大量的模型被广泛的应用于推荐系统中。 为了提供完整的体验，每个示例都通过以下五个关键任务中展示：

--- a/docs/zh_CN/CommunitySharings/TuningSystems.md
+++ b/docs/zh_CN/CommunitySharings/TuningSystems.md
-# 使用 NNI 自动调优系统
-随着计算机系统和网络变得越来越复杂，通过显式的规则和启发式的方法来手工优化已经越来越难，甚至不可能了。 下面是使用 NNI 来优化系统的两个示例。 可根据这些示例来调优自己的系统。
-* [在 NNI 上调优 RocksDB](../TrialExample/RocksdbExamples.md)
-* [使用 NNI 调优 SPTAG (Space Partition Tree And Graph) 参数](SptagAutoTune.md)
-参考[论文](https://dl.acm.org/citation.cfm?id=3352031)了解详情：
-Mike Liang, Chieh-Jan, et al. "The Case for Learning-and-System Co-design." ACM SIGOPS Operating Systems Review 53.1 (2019): 68-74.
--- a/docs/zh_CN/CommunitySharings/automodel.rst
+++ b/docs/zh_CN/CommunitySharings/automodel.rst
+######################
+自动模型调优
+######################
+NNI 可以应用于各种模型调优任务。 一些最先进的模型搜索算法，如EfficientNet，可以很容易地在NNI上构建。 流行的模型，例如，推荐模型，可以使用 NNI 进行调优。 下面是一些用例，展示了如何在您的模型调优任务中使用 NNI，以及如何使用 NNI 构建您自己的流水线。
+..  toctree::
+    :maxdepth: 1
+    SVD 自动调优 <RecommendersSvd>
+    NNI 中的 EfficientNet <./TrialExample/EfficientNet>
+    用于阅读理解的自动模型架构搜索<../TrialExample/SquadEvolutionExamples>
+    TPE 的并行优化<ParallelizingTpeSearch>
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/autosys.rst
+++ b/docs/zh_CN/CommunitySharings/autosys.rst
+#######################
+自动系统调优
+#######################
+数据库、张量算子实现等系统的性能往往需要进行调优，以适应特定的硬件配置、目标工作负载等。 手动调优系统非常复杂，并且通常需要对硬件和工作负载有详细的了解。 NNI 可以使这些任务变得更容易，并帮助系统所有者自动找到系统的最佳配置。 自动系统调优的详细设计思想可以在[这篇文章](https://dl.acm.org/doi/10.1145/3352020.3352031)中找到。 以下是 NNI 可以发挥作用的一些典型案例。
+..  toctree::
+    :maxdepth: 1
+    自动调优 SPTAG（Space Partition Tree And Graph）<SptagAutoTune>
+    调优 RocksDB 的性能<../TrialExample/RocksdbExamples>
+    自动调优张量算子<../TrialExample/OpEvoExamples>
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/community_sharings.rst
+++ b/docs/zh_CN/CommunitySharings/community_sharings.rst
-######################
+#######################
-社区分享
+用例与解决方案
-######################
+#######################
-除了官方的教程和示例之外，也支持社区贡献者分享自己的自动机器学习实践经验，特别是使用 NNI 的实践经验。
+与文档其他部分中展示功能用法的教程和示例不同，本部分主要介绍端到端方案和用例，以帮助用户进一步了解NNI如何为他们提供帮助。 NNI 可广泛应用于各种场景。 除了官方的教程和示例之外，也支持社区贡献者分享自己的自动机器学习实践经验，特别是使用 NNI 的实践经验。
 ..  toctree::
    :maxdepth: 2
-    Recommenders 中使用 NNI<RecommendersSvd>
+    自动模型调优（HPO/NAS）<automodel>
-    使用 NNI 为 SPTAG 自动调参 <SptagAutoTune>
+    自动系统调优（AutoSys）<autosys>
-    神经网络结构搜索（NAS）的对比<NasComparision>
+    模型压缩<model_compression>
-    超参调优算法的对比<HpoComparision>
+    特征工程<feature_engineering>
-    TPE 的并行优化<ParallelizingTpeSearch>
+    性能测量，比较和分析<perf_compare>
-    使用 NNI 自动调优系统 <TuningSystems>
+    在 Google Colab 中使用 NNI <NNI_colab_support>
-    来自知乎的评论：作者 Garvin Li <NNI_AutoFeatureEng>
--- a/docs/zh_CN/CommunitySharings/feature_engineering.rst
+++ b/docs/zh_CN/CommunitySharings/feature_engineering.rst
+###################
+特征工程
+###################
+以下是关于 NNI 如何助力特征工程的文章，由社区贡献者分享。 将来会添加更多用例和解决方案。
+..  toctree::
+    :maxdepth: 1
+    来自知乎的评论：作者 Garvin Li <NNI_AutoFeatureEng>
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/model_compression.rst
+++ b/docs/zh_CN/CommunitySharings/model_compression.rst
+#################
+模型压缩
+#################
+以下介绍了如何将知识蒸馏应用于 NNI 模型压缩。 将来会添加更多用例和解决方案。
+..  toctree::
+    :maxdepth: 1
+    使用 NNI 模型压缩进行知识蒸馏<../TrialExample/KDExample>
\ No newline at end of file
--- a/docs/zh_CN/CommunitySharings/perf_compare.rst
+++ b/docs/zh_CN/CommunitySharings/perf_compare.rst
+################################################
+性能测量，比较和分析
+################################################
+性能比较和分析可以帮助用户在他们的场景中选择适合的算法（例如 Tuner，NAS 算法）。 以下是一些供用户参考的测量和比较数据。
+..  toctree::
+    :maxdepth: 1
+    神经网络结构搜索（NAS）的对比<NasComparison>
+    超参调优算法的对比<HpoComparison>
+    模型压缩算法的对比<ModelCompressionComparison>
\ No newline at end of file
--- a/docs/zh_CN/Compressor/AutoCompression.md
+++ b/docs/zh_CN/Compressor/AutoCompression.md
@@ -84,7 +84,7 @@ config_list_agp = [{'initial_sparsity': 0, 'final_sparsity': conv0_sparsity,
                   {'initial_sparsity': 0, 'final_sparsity': conv1_sparsity,
                    'start_epoch': 0, 'end_epoch': 3,
                    'frequency': 1,'op_name': 'conv1' },]
-PRUNERS = {'level':LevelPruner(model, config_list_level), 'agp':AGP_Pruner(model, config_list_agp)}
+PRUNERS = {'level':LevelPruner(model, config_list_level), 'agp':AGPPruner(model, config_list_agp)}
 pruner = PRUNERS(params['prune_method']['_name'])
 pruner.compress()
 ... # fine tuning

--- a/docs/zh_CN/Compressor/CompressionUtils.md
+++ b/docs/zh_CN/Compressor/CompressionUtils.md
@@ -125,7 +125,8 @@ NNI 提供了模型计数器，用于计算模型的 FLOPs 和参数。 此计
 ```
 from nni.compression.torch.utils.counter import count_flops_params
-# 给定输入大小 (1, 1, 28, 28)
+# 给定输入大小 (1, 1, 28, 28) 
 flops, params = count_flops_params(model, (1, 1, 28, 28))
+# 将输出大小格式化为 M (例如, 10^6)
 print(f'FLOPs: {flops/1e6:.3f}M,  Params: {params/1e6:.3f}M)
 ```
\ No newline at end of file
--- a/docs/zh_CN/Compressor/LotteryTicketHypothesis.md
+++ b/docs/zh_CN/Compressor/LotteryTicketHypothesis.md
-Lottery Ticket 假设
-===
-## 介绍
-[The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks](https://arxiv.org/abs/1803.03635) 是主要衡量和分析的论文，它提供了非常有意思的见解。 为了在 NNI 上支持此算法，主要实现了找到*获奖彩票*的训练方法。
-本文中，作者使用叫做*迭代*修剪的方法：
-> 1. 随机初始化一个神经网络 f(x;theta_0) (其中 theta_0 为 D_{theta}).
-> 2. 将网络训练 j 次，得出参数 theta_j。
-> 3. 在 theta_j 修剪参数的 p%，创建掩码 m。
-> 4. 将其余参数重置为 theta_0 的值，创建获胜彩票 f(x;m*theta_0)。
-> 5. 重复步骤 2、3 和 4。
-如果配置的最终稀疏度为 P (e.g., 0.8) 并且有 n 次修建迭代，每次迭代修剪前一轮中剩余权重的 1-(1-P)^(1/n)。
-## 重现结果
-在重现时，在 MNIST 使用了与论文相同的配置。 [此处](https://github.com/microsoft/nni/tree/master/examples/model_compress/lottery_torch_mnist_fc.py)为实现代码。 在次实验中，修剪了10次，在每次修剪后，训练了 50 个 epoch。
-![](../../img/lottery_ticket_mnist_fc.png)
-上图展示了全连接网络的结果。 `round0-sparsity-0.0` 是没有剪枝的性能。 与论文一致，修剪约 80% 也能获得与不修剪时相似的性能，收敛速度也会更快。 如果修剪过多（例如，大于 94%），则精度会降低，收敛速度会稍慢。 与本文稍有不同，论文中数据的趋势比较明显。
--- a/docs/zh_CN/Compressor/Overview.md
+++ b/docs/zh_CN/Compressor/Overview.md
@@ -42,6 +42,7 @@ NNI 的模型压缩工具包，提供了最先进的模型压缩算法和策略
 | [SimulatedAnnealing Pruner](https://nni.readthedocs.io/zh/latest/Compressor/Pruner.html#simulatedannealing-pruner)           | 通过启发式的模拟退火算法进行自动剪枝 [参考论文](https://arxiv.org/abs/1907.03141)                                                                                   |
 | [AutoCompress Pruner](https://nni.readthedocs.io/zh/latest/Compressor/Pruner.html#autocompress-pruner)                       | 通过迭代调用 SimulatedAnnealing Pruner 和 ADMM Pruner 进行自动剪枝 [参考论文](https://arxiv.org/abs/1907.03141)                                                |
+参考此[基准测试](https://github.com/microsoft/nni/blob/master/docs/zh_CN/CommunitySharings/ModelCompressionComparison.md)来查看这些剪枝器在一些基准问题上的表现。
 ### 量化算法
@@ -64,7 +65,7 @@ NNI 的模型压缩工具包，提供了最先进的模型压缩算法和策略
 ## 压缩工具
-压缩工具包括了一些有用的工具，能帮助用户理解并分析要压缩的模型。 例如，可检查每层对剪枝的敏感度。 可很容易的计算模型的 FLOPs 和参数数量。 [点击这里](./CompressionUtils.md)，查看压缩工具的完整列表。
+压缩工具包括了一些有用的工具，能帮助用户理解并分析要压缩的模型。 例如，可检查每层对剪枝的敏感度。 可很容易地计算模型的 FLOPs 和参数数量。 点击[这里](./CompressionUtils.md)，查看压缩工具的完整列表。
 ## 自定义压缩算法

--- a/docs/zh_CN/Compressor/Pruner.md
+++ b/docs/zh_CN/Compressor/Pruner.md
@@ -11,19 +11,21 @@ NNI 提供了一些支持细粒度权重剪枝和结构化的滤波器剪枝算
 * [FPGM Pruner](#fpgm-pruner)
 * [L1Filter Pruner](#l1filter-pruner)
 * [L2Filter Pruner](#l2filter-pruner)
-* [APoZ Rank Pruner](#activationapozrankfilterpruner)
+* [Activation APoZ Rank Filter Pruner](#activationAPoZRankFilter-pruner)
-* [Activation Mean Rank Pruner](#activationmeanrankfilterpruner)
+* [Activation Mean Rank Filter Pruner](#activationmeanrankfilter-pruner)
-* [Taylor FO On Weight Pruner](#taylorfoweightfilterpruner)
+* [Taylor FO On Weight Pruner](#taylorfoweightfilter-pruner)
 **剪枝计划**
 * [AGP Pruner](#agp-pruner)
 * [NetAdapt Pruner](#netadapt-pruner)
 * [SimulatedAnnealing Pruner](#simulatedannealing-pruner)
 * [AutoCompress Pruner](#autocompress-pruner)
+* [AutoML for Model Compression Pruner](#automl-for-model-compression-pruner)
+* [Sensitivity Pruner](#sensitivity-pruner)
 **其它**
 * [ADMM Pruner](#admm-pruner)
-* [Lottery Ticket 假设](#lottery-ticket-hypothesis)
+* [Lottery Ticket 假设](#Lottery-Ticket-假设)
 ## Level Pruner
@@ -50,9 +52,19 @@ pruner.compress()
 ```
 #### Level Pruner 的用户配置
-* **sparsity:**，指定压缩的稀疏度。
-***
+##### PyTorch
+```eval_rst
+..  autoclass:: nni.compression.torch.LevelPruner
+```
+##### Tensorflow
+```eval_rst
+..  autoclass:: nni.compression.tensorflow.LevelPruner
+```
 ## Slim Pruner
@@ -75,8 +87,11 @@ pruner.compress()
 #### Slim Pruner 的用户配置
- **sparsity:**，指定压缩的稀疏度。
+##### PyTorch
- **op_types:** 在 Slim Pruner 中仅支持 BatchNorm2d。
+```eval_rst
+..  autoclass:: nni.compression.torch.SlimPruner
+```
 ### 重现实验
@@ -95,7 +110,7 @@ pruner.compress()
 这是一种一次性的 Pruner，FPGM Pruner 是论文 [Filter Pruning via Geometric Median for Deep Convolutional Neural Networks Acceleration](https://arxiv.org/pdf/1811.00250.pdf) 的实现
-具有最小几何中位数的 FPGMPruner 修剪滤波器
+具有最小几何中位数的 FPGMPruner 修剪过滤器。
 ![](../../img/fpgm_fig1.png)
 > 以前的方法使用 “smaller-norm-less-important” 准则来修剪卷积神经网络中规范值较小的。 本文中，分析了基于规范的准则，并指出其所依赖的两个条件不能总是满足：(1) 滤波器的规范偏差应该较大；(2) 滤波器的最小规范化值应该很小。 为了解决此问题，提出了新的滤波器修剪方法，即 Filter Pruning via Geometric Median (FPGM)，可不考虑这两个要求来压缩模型。 与以前的方法不同，FPGM 通过修剪冗余的，而不是相关性更小的部分来压缩 CNN 模型。
@@ -114,10 +129,11 @@ pruner.compress()
 ```
 #### FPGM Pruner 的用户配置
- **sparsity:** 卷积滤波器要修剪的百分比。
- **op_types:** 在 L1Filter Pruner 中仅支持 Conv2d。
-***
+##### PyTorch
+```eval_rst
+..  autoclass:: nni.compression.torch.FPGMPruner
+```
 ## L1Filter Pruner
@@ -147,8 +163,10 @@ pruner.compress()
 #### L1Filter Pruner 的用户配置
- **sparsity:**，指定压缩的稀疏度。
+##### PyTorch
- **op_types:** 在 L1Filter Pruner 中仅支持 Conv2d。
+```eval_rst
+..  autoclass:: nni.compression.torch.L1FilterPruner
+```
 ### 重现实验
@@ -180,14 +198,15 @@ pruner.compress()
 ### L2Filter Pruner 的用户配置
- **sparsity:**，指定压缩的稀疏度。
+##### PyTorch
- **op_types:** 在 L2Filter Pruner 中仅支持 Conv2d。
+```eval_rst
+..  autoclass:: nni.compression.torch.L2FilterPruner
+```
 ***
-## ActivationAPoZRankFilterPruner
+## ActivationAPoZRankFilter Pruner
-ActivationAPoZRankFilterPruner 是从卷积层激活的输出，用最小的重要性标准 `APoZ` 修剪滤波器，来达到预设的网络稀疏度。 剪枝标准 `APoZ` 的解释在论文 [Network Trimming: A Data-Driven Neuron Pruning Approach towards Efficient Deep Architectures](https://arxiv.org/abs/1607.03250) 中。
+ActivationAPoZRankFilter Pruner 是从卷积层激活的输出，用最小的重要性标准 `APoZ` 修剪滤波器，来达到预设的网络稀疏度。 剪枝标准 `APoZ` 的解释在论文 [Network Trimming: A Data-Driven Neuron Pruning Approach towards Efficient Deep Architectures](https://arxiv.org/abs/1607.03250) 中。
 APoZ 定义为：
@@ -209,18 +228,20 @@ pruner.compress()
 注意：ActivationAPoZRankFilterPruner 用于修剪深度神经网络中的卷积层，因此 `op_types` 字段仅支持卷积层。
-查看示例进一步了解
+参考[示例](https://github.com/microsoft/nni/blob/master/examples/model_compress/model_prune_torch.py)了解更多信息。
 ### ActivationAPoZRankFilterPruner 的用户配置
- **sparsity:** 卷积滤波器要修剪的百分比。
+##### PyTorch
- **op_types:** 在 ActivationAPoZRankFilterPruner 中仅支持 Conv2d。
+```eval_rst
+..  autoclass:: nni.compression.torch.ActivationAPoZRankFilterPruner
+```
 ***
-## ActivationMeanRankFilterPruner
-ActivationMeanRankFilterPruner 是从卷积层激活的输出，用最小的重要性标准`平均激活`来修剪滤波器，来达到预设的网络稀疏度。 剪枝标准`平均激活`，在论文 [Pruning Convolutional Neural Networks for Resource Efficient Inference](https://arxiv.org/abs/1611.06440) 的 2.2 节中进行了介绍。 本文中提到的其他修剪标准将在以后的版本中支持。
+## ActivationMeanRankFilter Pruner
+ActivationMeanRankFilter Pruner 是从卷积层激活的输出，用最小的重要性标准`平均激活`来修剪滤波器，来达到预设的网络稀疏度。 剪枝标准`平均激活`，在论文 [Pruning Convolutional Neural Networks for Resource Efficient Inference](https://arxiv.org/abs/1611.06440) 的 2.2 节中进行了介绍。 本文中提到的其他修剪标准将在以后的版本中支持。
 ### 用法
@@ -238,18 +259,19 @@ pruner.compress()
 注意：ActivationMeanRankFilterPruner 用于修剪深度神经网络中的卷积层，因此 `op_types` 字段仅支持卷积层。
-查看示例进一步了解
+参考[示例](https://github.com/microsoft/nni/blob/master/examples/model_compress/model_prune_torch.py)了解更多信息。
 ### ActivationMeanRankFilterPruner 的用户配置
- **sparsity:** 卷积滤波器要修剪的百分比。
+##### PyTorch
- **op_types:** 在 ActivationMeanRankFilterPruner 中仅支持 Conv2d。
+```eval_rst
+..  autoclass:: nni.compression.torch.ActivationMeanRankFilterPruner
+```
 ***
-## TaylorFOWeightFilterPruner
+## TaylorFOWeightFilter Pruner
-TaylorFOWeightFilterPruner 根据权重上的一阶泰勒展开式，来估计重要性并进行剪枝，从而达到预设的网络稀疏度。 滤波器的估计重要性在论文 [Importance Estimation for Neural Network Pruning](http://jankautz.com/publications/Importance4NNPruning_CVPR19.pdf) 中有定义。 本文中提到的其他修剪标准将在以后的版本中支持。
+TaylorFOWeightFilter Pruner 根据权重上的一阶泰勒展开式，来估计重要性并进行剪枝，从而达到预设的网络稀疏度。 过滤器的估计重要性在论文 [Importance Estimation for Neural Network Pruning](http://jankautz.com/publications/Importance4NNPruning_CVPR19.pdf) 中有定义。 本文中提到的其他修剪标准将在以后的版本中支持。
 >
 ![](../../img/importance_estimation_sum.png)
@@ -268,25 +290,29 @@ pruner = TaylorFOWeightFilterPruner(model, config_list, statistics_batch_num=1)
 pruner.compress()
 ```
-查看示例进一步了解
-### TaylorFOWeightFilterPruner 的用户配置
- **sparsity:** 卷积滤波器要修剪的百分比。
+#### TaylorFOWeightFilter Pruner 的用户配置
- **op_types:** 当前 TaylorFOWeightFilterPruner 中仅支持 Conv2d。
+##### PyTorch
+```eval_rst
+..  autoclass:: nni.compression.torch.TaylorFOWeightFilterPruner
+```
 ***
 ## AGP Pruner
 这是一种迭代的 Pruner，在 [To prune, or not to prune: exploring the efficacy of pruning for model compression](https://arxiv.org/abs/1710.01878)中，作者 Michael Zhu 和 Suyog Gupta 提出了一种逐渐修建权重的算法。
-> 我们引入了一种新的自动梯度剪枝算法。这种算法从初始的稀疏度值 si（一般为 0）开始，通过 n 步的剪枝操作，增加到最终所需的稀疏度 sf。从训练步骤 t0 开始，以 ∆t 为剪枝频率： ![](../../img/agp_pruner.png) 在神经网络训练时‘逐步增加网络稀疏度时，每训练  ∆t 步更新一次权重剪枝的二进制掩码。同时也允许训练步骤恢复因为剪枝而造成的精度损失。 根据我们的经验，∆t 设为 100 到 1000 个训练步骤之间时，对于模型最终精度的影响可忽略不计。 一旦模型达到了稀疏度目标 sf，权重掩码将不再更新。 公式背后的稀疏函数直觉。
+> 引入了一种新的自动逐步剪枝算法，在 n 个剪枝步骤中，稀疏度从初始的稀疏度值 si（通常为 0）增加到最终的稀疏度值 sf，从训练步骤 t0 开始，剪枝频率 ∆t：  ![](../../img/agp_pruner.png)
+> 在训练网络时，每隔 ∆t 步更新二值权重掩码，以逐渐增加网络的稀疏性，同时允许网络训练步骤从任何剪枝导致的精度损失中恢复。 根据我们的经验，∆t 设为 100 到 1000 个训练步骤之间时，对于模型最终精度的影响可忽略不计。 一旦模型达到了稀疏度目标 sf，权重掩码将不再更新。 背后的稀疏函数直觉在公式（1）。
 ### 用法
 通过下列代码，可以在 10 个 Epoch 中将权重稀疏度从 0% 剪枝到 80%。
 PyTorch 代码
 ```python
-from nni.compression.torch import AGP_Pruner
+from nni.compression.torch import AGPPruner
 config_list = [{
    'initial_sparsity': 0,
    'final_sparsity': 0.8,
@@ -304,7 +330,7 @@ config_list = [{
 # 因此，必须要有 optimizer 才能完成模型剪枝。
 optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4)
-pruner = AGP_Pruner(model, config_list, optimizer, pruning_algorithm='level')
+pruner = AGPPruner(model, config_list, optimizer, pruning_algorithm='level')
 pruner.compress()
 ```
@@ -324,14 +350,15 @@ PyTorch 代码
 ```python
 pruner.update_epoch(epoch)
 ```
-查看示例进一步了解
+参考[示例](https://github.com/microsoft/nni/blob/master/examples/model_compress/model_prune_torch.py)了解更多信息。
 #### AGP Pruner 的用户配置
-* **initial_sparsity:** 指定了 Compressor 开始压缩的稀疏度。
-* **final_sparsity:** 指定了 Compressor 压缩结束时的稀疏度。
+##### PyTorch
-* **start_epoch:** 指定了 Compressor 开始压缩时的 Epoch 数值，默认为 0。
-* **end_epoch:** 指定了 Compressor 结束压缩时的 Epoch 数值。
+```eval_rst
-* **frequency:** 指定了 Compressor 每过多少个 Epoch 进行一次剪枝，默认 frequency=1。
+..  autoclass:: nni.compression.torch.AGPPruner
+```
 ***
@@ -360,50 +387,11 @@ pruner.compress()
 #### NetAdapt Pruner 的用户配置
- **sparsity:** 整体的稀疏度目标。
+##### PyTorch
- **op_types:** 要剪枝的操作类型。 如果 `base_algo` 是 `l1` 或 `l2`，那么 `op_types` 仅支持 `Conv2d`。
- **short_term_fine_tuner:** 用于快速微调掩码模型。 此函数只有 `model` 参数，在每次剪枝迭代后，对模型进行快速微调。
+```eval_rst
+..  autoclass:: nni.compression.torch.NetAdaptPruner
-    示例：
+```
-    ```python
-    >>> def short_term_fine_tuner(model, epoch=3):
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     train_loader = ...
-    >>>     criterion = torch.nn.CrossEntropyLoss()
-    >>>     optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
-    >>>     model.train()
-    >>>     for _ in range(epoch):
-    >>>         for batch_idx, (data, target) in enumerate(train_loader):
-    >>>             data, target = data.to(device), target.to(device)
-    >>>             optimizer.zero_grad()
-    >>>             output = model(data)
-    >>>             loss = criterion(output, target)
-    >>>             loss.backward()
-    >>>             optimizer.step()
-    ```
- **evaluator:** 用于评估掩码模型。 此函数只有 `model` 参数，会返回一个标量值。
-    示例::
-    ```python
-    >>> def evaluator(model):
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     val_loader = ...
-    >>>     model.eval()
-    >>>     correct = 0
-    >>>     with torch.no_grad():
-    >>>         for data, target in val_loader:
-    >>>             data, target = data.to(device), target.to(device)
-    >>>             output = model(data)
-    >>>             # 获得最大 log 概率分布的索引
-    >>>             pred = output.argmax(dim=1, keepdim=True)
-    >>>             correct += pred.eq(target.view_as(pred)).sum().item()
-    >>>     accuracy = correct / len(val_loader.dataset)
-    >>>     return accuracy
-    ```
- **optimize_mode:** 优化模式，`maximize` 或 `minimize`，默认为`maximize`。
- **base_algo:** 基础的剪枝算法。 `level`，`l1` 或 `l2`，默认为 `l1`。 给定不同运算符的系数分布，指定的 `base_algo` 会决定对哪个滤波器、通道、权重进行剪枝。
- **sparsity_per_iteration:** 每次迭代要剪枝的稀疏度。 NetAdapt Pruner 在每次迭代时，按相同水平对模型进行剪枝，以便逐步满足计算资源预算。
- **experiment_data_dir:** 保存实验数据的路径，包括为基本剪枝算法生成的 config_list，以及剪枝后模型的性能。
 ## SimulatedAnnealing Pruner
@@ -437,38 +425,17 @@ pruner.compress()
 #### SimulatedAnnealing Pruner 的用户配置
- **sparsity:** 整体的稀疏度目标。
+##### PyTorch
- **op_types:** 要剪枝的操作类型。 如果 `base_algo` 是 `l1` 或 `l2`，那么 `op_types` 仅支持 `Conv2d`。
- **evaluator:** 用于评估掩码模型。 此函数只有 `model` 参数，会返回一个标量值。 示例::
+```eval_rst
-    ```python
+..  autoclass:: nni.compression.torch.SimulatedAnnealingPruner
-    >>> def evaluator(model):
+```
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     val_loader = ...
-    >>>     model.eval()
-    >>>     correct = 0
-    >>>     with torch.no_grad():
-    >>>         for data, target in val_loader:
-    >>>             data, target = data.to(device), target.to(device)
-    >>>             output = model(data)
-    >>>             # 获得最大 log 概率分布的索引
-    >>>             pred = output.argmax(dim=1, keepdim=True)
-    >>>             correct += pred.eq(target.view_as(pred)).sum().item()
-    >>>     accuracy = correct / len(val_loader.dataset)
-    >>>     return accuracy
-    ```
- **optimize_mode:** 优化模式，`maximize` 或 `minimize`，默认为`maximize`。
- **base_algo:** 基础的剪枝算法。 `level`，`l1` 或 `l2`，默认为 `l1`。 给定不同运算符的系数分布，指定的 `base_algo` 会决定对哪个滤波器、通道、权重进行剪枝。
- **start_temperature:** 模拟退火算法相关参数。
- **stop_temperature:** 模拟退火算法相关参数。
- **cool_down_rate:** 模拟退火算法相关参数。
- **perturbation_magnitude:** 初始化对稀疏度的扰动幅度。 幅度会随着当前温度变小。
- **experiment_data_dir:** 保存实验数据的路径，包括为基本剪枝算法生成的 config_list，剪枝后模型的性能，以及剪枝历史。
 ## AutoCompress Pruner
 每一轮中，AutoCompressPruner 会用相同的稀疏度对模型进行剪枝，从而达到总体的稀疏度：
-        1. 使用 SimualtedAnnealingPruner 生成稀疏度分布
+        1. 使用 SimulatedAnnealingPruner 生成稀疏度分布
        2. 执行基于 ADMM 的结构化剪枝，为下一轮生成剪枝结果。
           这里会使用 `speedup` 来执行真正的剪枝。
@@ -495,54 +462,43 @@ pruner.compress()
 #### AutoCompress Pruner 的用户配置
- **sparsity:** 整体的稀疏度目标。
+##### PyTorch
- **op_types:** 要剪枝的操作类型。 如果 `base_algo` 是 `l1` 或 `l2`，那么 `op_types` 仅支持 `Conv2d`。
- **trainer:** 用于第一个子问题的函数。 用户需要实现此函数，来训练 PyTorch 模型，其参数包括：`model, optimizer, criterion, epoch, callback`。 这里的 `callback` 是 L2 规范化，参考原始论文中的公式 (7)。 `callback` 的逻辑在 Pruner 中实现，用户只需要在 `loss.backward()` 和 `optimizer.step()` 之间插入 `callback()` 即可。 示例：
+```eval_rst
-    ```python
+..  autoclass:: nni.compression.torch.AutoCompressPruner
-    >>> def trainer(model, criterion, optimizer, epoch, callback):
+```
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     train_loader = ...
+## AutoML for Model Compression Pruner
-    >>>     model.train()
-    >>>     for batch_idx, (data, target) in enumerate(train_loader):
+自动机器学习用于模型压缩剪枝器（AMCPruner）借助强化学习来提供模型压缩策略。 这种基于学习的压缩策略比传统的基于规则的压缩策略有更高的压缩比，更好地保存了精度，节省了人力。
-    >>>         data, target = data.to(device), target.to(device)
-    >>>         optimizer.zero_grad()
-    >>>         output = model(data)
-    >>>         loss = criterion(output, target)
-    >>>         loss.backward()
-    >>>         # 在 loss.backward() 和 optimizer.step() 中插入 callback
-    >>>         if callback:
-    >>>             callback()
-    >>>         optimizer.step()
-    ```
- **evaluator:** 用于评估掩码模型。 此函数只有 `model` 参数，会返回一个标量值。 示例::
-    ```python
-    >>> def evaluator(model):
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     val_loader = ...
-    >>>     model.eval()
-    >>>     correct = 0
-    >>>     with torch.no_grad():
-    >>>         for data, target in val_loader:
-    >>>             data, target = data.to(device), target.to(device)
-    >>>             output = model(data)
-    >>>             # 获得最大 log 概率分布的索引
-    >>>             pred = output.argmax(dim=1, keepdim=True)
-    >>>             correct += pred.eq(target.view_as(pred)).sum().item()
-    >>>     accuracy = correct / len(val_loader.dataset)
-    >>>     return accuracy
-    ```
- **dummy_input:** 用于模型加速的模拟输入，在传入前应该复制到正确的设备上。
- **iterations:** 总共的迭代次数。
- **optimize_mode:** 优化模式，`maximize` 或 `minimize`，默认为`maximize`。
- **base_algo:** 基础的剪枝算法。 `level`，`l1` 或 `l2`，默认为 `l1`。 给定不同运算符的系数分布，指定的 `base_algo` 会决定对哪个滤波器、通道、权重进行剪枝。
- **start_temperature:** 模拟退火算法相关参数。
- **stop_temperature:** 模拟退火算法相关参数。
- **cool_down_rate:** 模拟退火算法相关参数。
- **perturbation_magnitude:** 初始化对稀疏度的扰动幅度。 幅度会随着当前温度变小。
- **admm_num_iterations:** ADMM Pruner 的迭代次数。
- **admm_training_epochs:** ADMMPruner 的第一个优化子问题训练的 Epoch 数量。
- **experiment_data_dir:** 存储临时实验数据的目录。
+![](../../img/amc_pruner.jpg)
+更多详细信息，参考 [AMC: AutoML for Model Compression and Acceleration on Mobile Devices](https://arxiv.org/pdf/1802.03494.pdf)。
+#### 用法
+PyTorch 代码
+```python
+from nni.compression.torch import AMCPruner
+config_list = [{
+        'op_types': ['Conv2d', 'Linear']
+    }]
+pruner = AMCPruner(model, config_list, evaluator, val_loader, flops_ratio=0.5)
+pruner.compress()
+```
+参考[示例](https://github.com/microsoft/nni/blob/master/examples/model_compress/amc/)了解更多信息。
+#### AutoCompress Pruner 的用户配置
+##### PyTorch
+```eval_rst
+..  autoclass:: nni.compression.torch.AMCPruner
+```
 ## ADMM Pruner
 Alternating Direction Method of Multipliers (ADMM) 是一种数学优化技术，它将原始的非凸问题分解为两个可以迭代解决的子问题。 在权重修剪问题中，这两个子问题分别通过 1) 梯度下降算法和 2) 欧几里得投影来解决。
@@ -576,37 +532,17 @@ pruner.compress()
 #### ADMM Pruner 的用户配置
- **sparsity:**，指定压缩的稀疏度。
+##### PyTorch
- **op_types:** 要剪枝的操作类型。 如果 `base_algo` 是 `l1` 或 `l2`，那么 `op_types` 仅支持 `Conv2d`。
- **trainer:** 用于 ADMM 优化中第一个子问题的函数。注意，微调中不会使用它。 用户需要实现此函数，来训练 PyTorch 模型，其参数包括：`model, optimizer, criterion, epoch, callback`。 这里的 `callback` 是 L2 规范化，参考原始论文中的公式 (7)。 `callback` 的逻辑在 Pruner 中实现，用户只需要在 `loss.backward()` 和 `optimizer.step()` 之间插入 `callback()` 即可。
+```eval_rst
+..  autoclass:: nni.compression.torch.ADMMPruner
-    示例：
+```
-    ```python
-    >>> def trainer(model, criterion, optimizer, epoch, callback):
-    >>>     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    >>>     train_loader = ...
-    >>>     model.train()
-    >>>     for batch_idx, (data, target) in enumerate(train_loader):
-    >>>         data, target = data.to(device), target.to(device)
-    >>>         optimizer.zero_grad()
-    >>>         output = model(data)
-    >>>         loss = criterion(output, target)
-    >>>         loss.backward()
-    >>>         # 在 loss.backward() 和 optimizer.step() 中插入 callback
-    >>>         if callback:
-    >>>             callback()
-    >>>         optimizer.step()
-    ```
- **num_iterations:** 迭代次数。
- **training_epochs:** 第一个子问题训练的 Epoch 数量。
- **row:** ADMM 训练的惩罚参数。
- **base_algo:** 基础的剪枝算法。 `level`，`l1` 或 `l2`，默认为 `l1`。 给定不同运算符的系数分布，指定的 `base_algo` 会决定对哪个滤波器、通道、权重进行剪枝。
 ## Lottery Ticket 假设
 [The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks](https://arxiv.org/abs/1803.03635), 作者 Jonathan Frankle 和 Michael Carbin，提供了全面的测量和分析，并阐明了 *lottery ticket 假设*: 密集的、随机初始化的、包含子网络的前馈网络 (*winning tickets*) -- 在单独训练时 -- 在相似的迭代次数后达到了与原始网络相似的准确度。
-本文中，作者使用叫做*迭代剪枝*的方法：
+本文中，作者使用叫做*迭代*修剪的方法：
 > 1. 随机初始化一个神经网络 f(x;theta_0) (其中 theta_0 为 D_{theta}).
 > 2. 将网络训练 j 次，得出参数 theta_j。
 > 3. 在 theta_j 修剪参数的 p%，创建掩码 m。
@@ -638,15 +574,51 @@ for _ in pruner.get_prune_iterations():
 *稍后支持 TensorFlow 版本。*
-#### LotteryTicketPruner 的用户配置
+#### LotteryTicket Pruner 的用户配置
+##### PyTorch
-* **prune_iterations:** 迭代修剪的次数。
+```eval_rst
-* **sparsity:** 压缩完成后的最终稀疏度。
+..  autoclass:: nni.compression.torch.LotteryTicketPruner
+```
 ### 重现实验
-在重现时，在 MNIST 使用了与论文相同的配置。 [此处](https://github.com/microsoft/nni/tree/master/examples/model_compress/lottery_torch_mnist_fc.py)为实现代码。 在此实验中，修剪了10次，在每次修剪后，训练了 50 个 epoch。
+在重现时，在 MNIST 使用了与论文相同的配置。 [此处](https://github.com/microsoft/nni/tree/master/examples/model_compress/lottery_torch_mnist_fc.py)为实现代码。 在次实验中，修剪了10次，在每次修剪后，训练了 50 个 epoch。
 ![](../../img/lottery_ticket_mnist_fc.png)
 上图展示了全连接网络的结果。 `round0-sparsity-0.0` 是没有剪枝的性能。 与论文一致，修剪约 80% 也能获得与不修剪时相似的性能，收敛速度也会更快。 如果修剪过多（例如，大于 94%），则精度会降低，收敛速度会稍慢。 与本文稍有不同，论文中数据的趋势比较明显。
+## Sensitivity Pruner
+在每一轮，SensitivityPruner 根据对每一层准确率的敏感度对模型进行剪枝，直到满足整个模型最终配置的稀疏度：
+        1. 分析模型当前状态下各层的敏感度。
+        2. 根据敏感度对每一层剪枝。
+更多详细信息，参考 [Learning both Weights and Connections for Efficient Neural Networks ](https://arxiv.org/abs/1506.02626)。
+#### 用法
+PyTorch 代码
+```python
+from nni.compression.torch import SensitivityPruner
+config_list = [{
+        'sparsity': 0.5,
+        'op_types': ['Conv2d']
+    }]
+pruner = SensitivityPruner(model, config_list, finetuner=fine_tuner, evaluator=evaluator)
+# eval_args and finetune_args are the parameters passed to the evaluator and finetuner respectively
+pruner.compress(eval_args=[model], finetune_args=[model])
+```
+#### Sensitivity Pruner 的用户配置
+##### PyTorch
+```eval_rst
+..  autoclass:: nni.compression.torch.SensitivityPruner
+```