From 8a9deea376a1057ab1e5fd5dbee69b120575b05d Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Sat, 12 Jun 2021 23:31:20 +0800
Subject: [PATCH 01/17] get_started_docs_zh

---
 docs_zh-CN/get_started.md | 207 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 207 insertions(+)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index abbd958777..03678bb07a 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -1 +1,208 @@
 ## 依赖
+
+- Linux or macOS (Windows下支持需要mmcv-full，但运行时可能会有一些问题。)
+- Python 3.6+
+- PyTorch 1.3+
+- CUDA 9.2+ (If you build PyTorch from source, CUDA 9.0 is also compatible)
+- GCC 5+
+- [MMCV](https://mmcv.readthedocs.io/en/latest/#installation)
+
+可编译的MMSegmentation和MMCV版本如下所示，请对照对应版本安装以避免安装问题。
+
+| MMSegmentation 版本 |    MMCV 版本     |
+|:-------------------:|:-------------------:|
+| master              | mmcv-full>=1.3.1, <1.4.0 |
+| 0.13.0              | mmcv-full>=1.3.1, <1.4.0 |
+| 0.12.0              | mmcv-full>=1.1.4, <1.4.0 |
+| 0.11.0              | mmcv-full>=1.1.4, <1.3.0 |
+| 0.10.0              | mmcv-full>=1.1.4, <1.3.0 |
+| 0.9.0               | mmcv-full>=1.1.4, <1.3.0 |
+| 0.8.0               | mmcv-full>=1.1.4, <1.2.0 |
+| 0.7.0               | mmcv-full>=1.1.2, <1.2.0 |
+| 0.6.0               | mmcv-full>=1.1.2, <1.2.0 |
+
+注意: 如果您已经安装好mmcv, 您首先需要运行 `pip uninstall mmcv`。如果mmcv和mmcv-full同时被安装，会报错 `ModuleNotFoundError`。
+
+## 安装
+
+a. 创建一个conda虚拟环境并激活它。
+
+```shell
+conda create -n open-mmlab python=3.7 -y
+conda activate open-mmlab
+
+```
+
+b. 按照[官方教程](https://pytorch.org/) 安装PyTorch和totchvision。
+这里我们使用PyTorch1.6.0和CUDA10.1。
+您也可以切换至其他版本。
+
+```shell
+conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
+```
+
+c. 按照 [官方教程](https://mmcv.readthedocs.io/en/latest/#installation) 安装 [MMCV](https://mmcv.readthedocs.io/en/latest/) 。
+`mmcv` 或 `mmcv-full`和MMSegmentation均兼容，但对于CCNet和PSANet，`mmcv-full` 里的CUDA运算是必须的。
+
+**在Linux下安装mmcv:**
+
+通过运行
+
+```shell
+pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.5.0/index.html
+```
+
+可以安装好 mmcv-full (PyTorch 1.5 和 CUDA 10.1) 版本。
+其他PyTorch和CUDA版本的MMCV安装请参照[这里](https://mmcv.readthedocs.io/en/latest/#install-with-pip)
+
+**在Windows下安装mmcv(有风险):**
+
+对于 Windows, MMCV 的安装需要本地 C++ 编译工具, 例如 cl.exe. 请添加编译工具至 %PATH%.
+
+如果您已经在电脑上安装好Windows SDK 和 Visual Studio， cl.exe 的一个典型路径看起来如下：
+
+```shell
+C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.26.28801\bin\Hostx86\x64
+```
+
+或者您需要从网上下载cl编译工具并安装至路径。
+
+随后，从github克隆mmcv并通过pip安装：
+
+```shell
+git clone https://github.com/open-mmlab/mmcv.git
+cd mmcv
+pip install -e .
+```
+
+或直接:
+
+```shell
+pip install mmcv
+```
+
+当前，mmcv-full并不完全在windows上支持。
+
+d. 安装 MMSegmentation.
+
+```shell
+pip install mmsegmentation # 安装最新版本
+```
+
+或者
+
+```shell
+pip install git+https://github.com/open-mmlab/mmsegmentation.git # 安装 master 分支
+```
+
+此外，如果您想安装 `dev` 模式的MMSegmentation, 运行如下命令：
+
+```shell
+git clone https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -e .  # 或者 "python setup.py develop"
+```
+
+注意:
+
+1. 当在windows下训练和测试模型时，请确保路径下所有的'\\' 被替换成 '/'。在python代码里可以使用`.replace('\\', '/')`处理路径的字符串。
+2. `version+git_hash`也将被保存进meta训练模型里，即0.5.0+c415a2e。
+3. 当 MMsegmentation 以 `dev` 模式被安装时，本地对代码的修改将不需要重新安装即可产生作用。
+4. 如果您想使用`opencv-python-headless` 替换 `opencv-python`，您可以在安装MMCV前安装它。
+5. 一些依赖项是可选的。简单的运行`pip install -e .`将仅安装最必要的一些依赖。为了使用可选的依赖项如`cityscapessripts`，要么手动使用`pip install -r requirements/optional.txt`安装，要么专门从pip下安装(即 `pip install -e .[optional]`， 其中选项可设置为`all`, `tests`, `build`, 和 `optional`).
+
+### 即刻安装脚本
+
+#### Linux
+
+这里便是一个完整安装mmsegmentation 的脚本，使用conda并链接了数据集的路径（以您的数据集路径为$DATA_ROOT 来安装）。
+
+```shell
+conda create -n open-mmlab python=3.7 -y
+conda activate open-mmlab
+
+conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
+pip install mmcv-full==latest+torch1.5.0+cu101 -f https://download.openmmlab.com/mmcv/dist/index.html
+git clone https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -e .  # 或者 "python setup.py develop"
+
+mkdir data
+ln -s $DATA_ROOT data
+```
+
+#### Windows(有风险)
+
+这里便是一个完整安装mmsegmentation 的脚本，使用conda并链接了数据集的路径（以您的数据集路径为%DATA_ROOT% 来安装）。注意：它必须是一个绝对路径。
+
+```shell
+conda create -n open-mmlab python=3.7 -y
+conda activate open-mmlab
+
+conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
+set PATH=full\path\to\your\cpp\compiler;%PATH%
+pip install mmcv
+
+git clone https://github.com/open-mmlab/mmsegmentation.git
+cd mmsegmentation
+pip install -e .  # 或者 "python setup.py develop"
+
+mklink /D data %DATA_ROOT%
+```
+
+#### 使用多版本 MMSegmentation 进行开发
+
+训练和测试脚本已经修改了`PYTHONPATH`来确保使用当前路径的MMSegmentation。
+
+为了使用当前环境默认安装的MMSegmentation而不是正在工作的MMSegmentation，您可以在那些脚本里移除下面的内容：
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
+
+## 验证
+
+为了验证MMSegmentation和它所需要的环境是否正确安装，我们可以使用样例python代码来初始化一个segmentor并推理一张demo图像。
+
+```python
+from mmseg.apis import inference_segmentor, init_segmentor
+import mmcv
+
+config_file = 'configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py'
+checkpoint_file = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
+
+# 从一个config配置文件和checkpoint文件里创建分割模型
+model = init_segmentor(config_file, checkpoint_file, device='cuda:0')
+
+# 测试一张样例图片并得到结果
+img = 'test.jpg'  # or img = mmcv.imread(img), which will only load it once
+result = inference_segmentor(model, img)
+# 在新的窗口里可视化结果
+model.show_result(img, result, show=True)
+# 或者保存图片文件的可视化结果
+# 您可以改变segmentation map的不透明度(opacity)，在(0, 1]之间。
+model.show_result(img, result, out_file='result.jpg', opacity=0.5)
+
+# 测试一个视频并得到结果
+video = mmcv.VideoReader('video.mp4')
+for frame in video:
+   result = inference_segmentor(model, frame)
+   model.show_result(frame, result, wait_time=1)
+```
+
+当您完成MMSegmentation的安装时，上述代码应该可以成功运行。
+
+我们还提供一个demo脚本去测试单张图片：
+
+```shell
+python demo/image_demo.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${DEVICE_NAME}] [--palette-thr ${PALETTE}]
+```
+
+样例：
+
+```shell
+python demo/image_demo.py demo/demo.jpg configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --palette cityscapes
+```
+
+推理的demo文档可在此查询：[demo/inference_demo.ipynb](../demo/inference_demo.ipynb).

From 5369c211cc216fe2c2b47c4cd746449f9279214d Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 10:50:40 +0800
Subject: [PATCH 02/17] inference_zh.md

---
 docs_zh-CN/inference.md | 101 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 100 insertions(+), 1 deletion(-)

diff --git a/docs_zh-CN/inference.md b/docs_zh-CN/inference.md
index 2b50abb43a..a7cc6b8bba 100644
--- a/docs_zh-CN/inference.md
+++ b/docs_zh-CN/inference.md
@@ -1 +1,100 @@
-## 用预训练模型进行推理
+## 使用预训练模型推理
+
+我们提供测试脚本来评估完整数据集（Cityscapes, PASCAL VOC, ADE20k等） 上的结果，同时为了对其他项目的整合更容易，也提供一些高级API。
+
+### 测试一个数据集
+
+- 单卡 GPU
+- 单节点 多卡GPU
+- 多节点
+
+您可以使用以下命令来测试一个数据集。
+
+```shell
+# 单卡GPU 测试
+python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}] [--eval ${评估指标}] [--show]
+
+# 多卡GPU 测试
+./tools/dist_test.sh ${配置文件} ${检查点文件} ${GPU数目} [--out ${结果文件}] [--eval ${评估指标}]
+```
+
+可选参数:
+
+- `RESULT_FILE`: pickle格式的输出结果的文件名，如果不专门指定，结果将不会被专门保存成文件。
+- `EVAL_METRICS`: 在结果里将被评估的指标。这主要取决于数据集，  `mIoU`  对于所有数据集都可获得，像Cityscapes数据集可以通过 `cityscapes` 命令来专门评估，就像标准的 `mIoU`一样。
+- `--show`: 如果被指定，分割结果将会在一张图像里画出来并且在另一个窗口展示。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。请确认GUI在您的环境里可用，否则您也许会遇到报错 `cannot connect to X server`
+- `--show-dir`: 如果被指定，分割结果将会在一张图像里画出来并且保存在指定文件夹里。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。使用该参数时，您的环境不需要GUI。
+- `--eval-options`: 评估时的可选参数，当设置`efficient_test=True`时，它将会保存中间结果至本地文件里以节约CPU内存。请确认您本地硬盘有足够的存储空间（大于20GB）。
+
+例子:
+
+假设您已经下载检查点文件至文件夹`checkpoints/`里。
+
+1. 测试 PSPNet 并可视化结果。按下任何键会进行到下一张图。
+
+    ```shell
+    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+        --show
+    ```
+
+2. 测试 PSPNet 并保存画出的图以便于之后的可视化。
+
+    ```shell
+    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+        --show-dir psp_r50_512x1024_40ki_cityscapes_results
+    ```
+
+3. 在数据集PASCAL VOC (不保存测试结果) 上测试 PSPNet 并评估mIoU。
+
+    ```shell
+    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_20k_voc12aug.py \
+        checkpoints/pspnet_r50-d8_512x1024_20k_voc12aug_20200605_003338-c57ef100.pth \
+        --eval mAP
+    ```
+
+4. 使用4卡GPU测试 PSPNet，并且在标准 mIoU和cityscapes指标里评估模型。
+
+    ```shell
+    ./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+        4 --out results.pkl --eval mIoU cityscapes
+    ```
+
+   注意：在cityscapes mIoU 和我们的mIoU指标会有一些差异 (~0.1%) 。原因是因为cityscapes会以默认的类的大小去平均每一类。而我们不去平均，是更简单的，适用于所有数据集的方法。
+
+5. 在cityscapes数据集上4卡GPU测试 PSPNet， 并生成png文件以便提交给官方评估服务器。
+
+   首先，在配置文件里添加内容： `configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py`，
+
+    ```python
+    data = dict(
+        test=dict(
+            img_dir='leftImg8bit/test',
+            ann_dir='gtFine/test'))
+    ```
+
+   随后，进行测试。
+
+    ```shell
+    ./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
+        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
+        4 --format-only --eval-options "imgfile_prefix=./pspnet_test_results"
+    ```
+
+   您会在文件夹`./pspnet_test_results`里得到生成的png文件。
+   您也许可以运行 `zip -r results.zip pspnet_test_results/` 并提交zip文件给 [evaluation server](https://www.cityscapes-dataset.com/submit/)。
+
+6. CPU memory efficient test DeeplabV3+ on Cityscapes (without saving the test results) and evaluate the mIoU.
+6. 在Cityscapes数据集上测试CPU内存高效率版本的DeeplabV3+ (没有保存测试结果) 并且评估 mIoU。
+
+    ```shell
+    python tools/test.py \
+    configs/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes.py \
+    deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth \
+    --eval-options efficient_test=True \
+    --eval mIoU
+    ```
+
+    使用 ```pmap``` 可查看 CPU 内存情况,  ```efficient_test=True``` 会使用约 2.25GB 的CPU 内存， ```efficient_test=False``` 会使用约 11.06GB 的CPU 内存。 这个可选参数可以节约很多CPU内存。

From 04d2e67fffcf41904bc571a08f699f17762a89ac Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 11:06:02 +0800
Subject: [PATCH 03/17] train_zh.md

---
 docs_zh-CN/train.md | 83 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/docs_zh-CN/train.md b/docs_zh-CN/train.md
index 6a3aa82ff0..bcba97325d 100644
--- a/docs_zh-CN/train.md
+++ b/docs_zh-CN/train.md
@@ -1 +1,84 @@
 ## 训练一个模型
+
+MMSegmentation 可以执行分布式训练和非分布式训练，分别使用`MMDistributedDataParallel` 和 `MMDataParallel`命令。
+
+所有的输出(日志log和检查点checkpoints)将被保存到工作路径文件夹里，它可以通过配置文件里的`work_dir`指定。
+
+在一定迭代轮次后，我们默认在验证集上评估模型表现。您可以在训练配置文件中添加间隔参数来改变评估间隔。
+
+```python
+evaluation = dict(interval=4000)  # 每4000 iterations评估一次模型的表现
+```
+
+**\*Important\***: 在配置文件里的默认学习率是针对4卡GPU和2张图/GPU (此时batchsize = 4x2 = 8)来设置的。
+同样，您也可以使用8卡GPU和 1张图/GPU的设置，因为所有的模型均使用cross-GPU的SyncBN模式。
+
+为了以GPU显存为代价提升运行速度，您也可以通过传递`--options model.backbone.with_cp=True` 来在backbone骨架里有checkpoints检查点。
+
+### 使用单卡GPU训练
+
+```shell
+python tools/train.py ${配置文件} [可选参数]
+```
+
+如果您想在命令里定义工作文件夹路径，您可以添加一个参数`--work-dir ${YOUR_WORK_DIR}`。
+
+### 使用多卡GPU训练
+
+```shell
+./tools/dist_train.sh ${配置文件} ${GPU个数} [可选参数]
+```
+
+可选参数可以为:
+
+- `--no-validate` (**不推荐**): 训练时代码库默认会在每k轮迭代后在验证集上进行评估，如果不需评估使用命令 `--no-validate`。
+- `--work-dir ${工作路径}`: 在配置文件里重写工作路径文件夹。
+- `--resume-from ${检查点文件}`: 继续使用先前的检查点文件（可以继续训练过程）。
+- `--load-from ${检查点文件}`: 从一个检查点文件里加载权重（对另一个任务进行精调）。
+
+
+`resume-from` 和 `load-from`的区别:
+
+- `resume-from` 加载出模型权重和优化器状态包括迭代轮数等。
+- `load-from` 仅加载模型权重，从第0轮开始训练。
+
+
+### 使用多个机器训练
+
+如果您在一个集群上以[slurm](https://slurm.schedmd.com/) 运行MMSegmentation，
+您可以使用脚本`slurm_train.sh`（这个脚本同样支持单个机器的训练）。
+
+```shell
+[GPUS=${GPU号码}] ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件} --work-dir ${工作路径}
+```
+
+这里是在dev分区里使用16块GPU训练PSPNet的例子。
+
+```shell
+GPUS=16 ./tools/slurm_train.sh dev pspr50 configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py /nfs/xxxx/psp_r50_512x1024_40ki_cityscapes
+```
+
+您可以查看 [slurm_train.sh](../tools/slurm_train.sh) 以熟悉全部的参数与环境变量。
+
+如果您多个机器已经有以太网连接， 您可以参考PyTorch
+[launch utility](https://pytorch.org/docs/stable/distributed_deprecated.html#launch-utility) 。
+若您没有像InfiniBand这样高速的网络连接，多机器训练通常会比较慢。
+
+### 在单个机器上启动多个任务
+
+如果您在单个机器上启动多个任务，例如在8卡GPU的一个机器上有2个4卡GPU的训练任务，您需要特别对每个任务指定不同的端口（默认为29500）来避免通讯冲突。
+否则，将会有报错信息`RuntimeError: Address already in use`。
+
+如果您使用命令`dist_train.sh`来启动一个训练任务，您可以在命令行的用环境变量`PORT`设置端口。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${配置文件} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${配置文件} 4
+```
+
+如果您使用命令`slurm_train.sh`来启动训练任务，您可以在命令行的用环境变量`MASTER_PORT`设置端口。
+
+```shell
+MASTER_PORT=29500 ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件}
+MASTER_PORT=29501 ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件}
+```

From 178194ee9b21a1d88101cb2f27c260ffbeba584f Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 11:09:22 +0800
Subject: [PATCH 04/17] get_started_zh.md

---
 docs_zh-CN/get_started.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index 03678bb07a..eb9378c6ad 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -3,10 +3,9 @@
 - Linux or macOS (Windows下支持需要mmcv-full，但运行时可能会有一些问题。)
 - Python 3.6+
 - PyTorch 1.3+
-- CUDA 9.2+ (If you build PyTorch from source, CUDA 9.0 is also compatible)
+- CUDA 9.2+ (如果您基于源文件编译 PyTorch, CUDA 9.0也可以使用)
 - GCC 5+
 - [MMCV](https://mmcv.readthedocs.io/en/latest/#installation)
-
 可编译的MMSegmentation和MMCV版本如下所示，请对照对应版本安装以避免安装问题。
 
 | MMSegmentation 版本 |    MMCV 版本     |

From 5d9055adefc80680290b923dd09ea5718323c8f7 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 11:16:26 +0800
Subject: [PATCH 05/17] train_zh.md

---
 docs_zh-CN/train.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs_zh-CN/train.md b/docs_zh-CN/train.md
index bcba97325d..50d477df19 100644
--- a/docs_zh-CN/train.md
+++ b/docs_zh-CN/train.md
@@ -36,13 +36,11 @@ python tools/train.py ${配置文件} [可选参数]
 - `--resume-from ${检查点文件}`: 继续使用先前的检查点文件（可以继续训练过程）。
 - `--load-from ${检查点文件}`: 从一个检查点文件里加载权重（对另一个任务进行精调）。
 
-
 `resume-from` 和 `load-from`的区别:
 
 - `resume-from` 加载出模型权重和优化器状态包括迭代轮数等。
 - `load-from` 仅加载模型权重，从第0轮开始训练。
 
-
 ### 使用多个机器训练
 
 如果您在一个集群上以[slurm](https://slurm.schedmd.com/) 运行MMSegmentation，

From 60cbc6e64d7bac8e9de7cd7c0b7448a6690f506e Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 11:46:50 +0800
Subject: [PATCH 06/17] get_started_zh

---
 docs_zh-CN/get_started.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index eb9378c6ad..0a9b257d6c 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -6,6 +6,7 @@
 - CUDA 9.2+ (如果您基于源文件编译 PyTorch, CUDA 9.0也可以使用)
 - GCC 5+
 - [MMCV](https://mmcv.readthedocs.io/en/latest/#installation)
+
 可编译的MMSegmentation和MMCV版本如下所示，请对照对应版本安装以避免安装问题。
 
 | MMSegmentation 版本 |    MMCV 版本     |

From da616df1cfb5f7f840c78c4eb0782b29dedea45a Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 13:50:13 +0800
Subject: [PATCH 07/17] fix nospace between ZH and ENG

---
 docs_zh-CN/get_started.md | 44 +++++++++++++++++++--------------------
 docs_zh-CN/inference.md   | 28 ++++++++++++-------------
 docs_zh-CN/train.md       | 36 ++++++++++++++++----------------
 3 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index 0a9b257d6c..b65b3dda21 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -7,7 +7,7 @@
 - GCC 5+
 - [MMCV](https://mmcv.readthedocs.io/en/latest/#installation)
 
-可编译的MMSegmentation和MMCV版本如下所示，请对照对应版本安装以避免安装问题。
+可编译的 MMSegmentation 和 MMCV 版本如下所示，请对照对应版本安装以避免安装问题。
 
 | MMSegmentation 版本 |    MMCV 版本     |
 |:-------------------:|:-------------------:|
@@ -21,7 +21,7 @@
 | 0.7.0               | mmcv-full>=1.1.2, <1.2.0 |
 | 0.6.0               | mmcv-full>=1.1.2, <1.2.0 |
 
-注意: 如果您已经安装好mmcv, 您首先需要运行 `pip uninstall mmcv`。如果mmcv和mmcv-full同时被安装，会报错 `ModuleNotFoundError`。
+注意: 如果您已经安装好 mmcv, 您首先需要运行 `pip uninstall mmcv`。如果 mmcv 和 mmcv-full 同时被安装，会报错 `ModuleNotFoundError`。
 
 ## 安装
 
@@ -33,8 +33,8 @@ conda activate open-mmlab
 
 ```
 
-b. 按照[官方教程](https://pytorch.org/) 安装PyTorch和totchvision。
-这里我们使用PyTorch1.6.0和CUDA10.1。
+b. 按照[官方教程](https://pytorch.org/) 安装 PyTorch 和 totchvision。
+这里我们使用 PyTorch1.6.0 和 CUDA10.1。
 您也可以切换至其他版本。
 
 ```shell
@@ -42,7 +42,7 @@ conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
 ```
 
 c. 按照 [官方教程](https://mmcv.readthedocs.io/en/latest/#installation) 安装 [MMCV](https://mmcv.readthedocs.io/en/latest/) 。
-`mmcv` 或 `mmcv-full`和MMSegmentation均兼容，但对于CCNet和PSANet，`mmcv-full` 里的CUDA运算是必须的。
+`mmcv` 或 `mmcv-full` 和 MMSegmentation 均兼容，但对于 CCNet 和 PSANet，`mmcv-full` 里的 CUDA 运算是必须的。
 
 **在Linux下安装mmcv:**
 
@@ -53,7 +53,7 @@ pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.5
 ```
 
 可以安装好 mmcv-full (PyTorch 1.5 和 CUDA 10.1) 版本。
-其他PyTorch和CUDA版本的MMCV安装请参照[这里](https://mmcv.readthedocs.io/en/latest/#install-with-pip)
+其他 PyTorch 和 CUDA 版本的 MMCV 安装请参照[这里](https://mmcv.readthedocs.io/en/latest/#install-with-pip)
 
 **在Windows下安装mmcv(有风险):**
 
@@ -67,7 +67,7 @@ C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\1
 
 或者您需要从网上下载cl编译工具并安装至路径。
 
-随后，从github克隆mmcv并通过pip安装：
+随后，从 github 克隆 mmcv 并通过 pip 安装：
 
 ```shell
 git clone https://github.com/open-mmlab/mmcv.git
@@ -81,7 +81,7 @@ pip install -e .
 pip install mmcv
 ```
 
-当前，mmcv-full并不完全在windows上支持。
+当前，mmcv-full 并不完全在 windows 上支持。
 
 d. 安装 MMSegmentation.
 
@@ -105,17 +105,17 @@ pip install -e .  # 或者 "python setup.py develop"
 
 注意:
 
-1. 当在windows下训练和测试模型时，请确保路径下所有的'\\' 被替换成 '/'。在python代码里可以使用`.replace('\\', '/')`处理路径的字符串。
-2. `version+git_hash`也将被保存进meta训练模型里，即0.5.0+c415a2e。
+1. 当在 windows 下训练和测试模型时，请确保路径下所有的'\\' 被替换成 '/'。在 python 代码里可以使用`.replace('\\', '/')`处理路径的字符串。
+2. `version+git_hash` 也将被保存进 meta 训练模型里，即0.5.0+c415a2e。
 3. 当 MMsegmentation 以 `dev` 模式被安装时，本地对代码的修改将不需要重新安装即可产生作用。
-4. 如果您想使用`opencv-python-headless` 替换 `opencv-python`，您可以在安装MMCV前安装它。
-5. 一些依赖项是可选的。简单的运行`pip install -e .`将仅安装最必要的一些依赖。为了使用可选的依赖项如`cityscapessripts`，要么手动使用`pip install -r requirements/optional.txt`安装，要么专门从pip下安装(即 `pip install -e .[optional]`， 其中选项可设置为`all`, `tests`, `build`, 和 `optional`).
+4. 如果您想使用 `opencv-python-headless` 替换 `opencv-python`，您可以在安装 MMCV 前安装它。
+5. 一些依赖项是可选的。简单的运行 `pip install -e .` 将仅安装最必要的一些依赖。为了使用可选的依赖项如`cityscapessripts`，要么手动使用 `pip install -r requirements/optional.txt` 安装，要么专门从pip下安装(即 `pip install -e .[optional]`， 其中选项可设置为 `all`, `tests`, `build`, 和 `optional`).
 
 ### 即刻安装脚本
 
 #### Linux
 
-这里便是一个完整安装mmsegmentation 的脚本，使用conda并链接了数据集的路径（以您的数据集路径为$DATA_ROOT 来安装）。
+这里便是一个完整安装 MMSegmentation 的脚本，使用 conda 并链接了数据集的路径（以您的数据集路径为 $DATA_ROOT 来安装）。
 
 ```shell
 conda create -n open-mmlab python=3.7 -y
@@ -133,7 +133,7 @@ ln -s $DATA_ROOT data
 
 #### Windows(有风险)
 
-这里便是一个完整安装mmsegmentation 的脚本，使用conda并链接了数据集的路径（以您的数据集路径为%DATA_ROOT% 来安装）。注意：它必须是一个绝对路径。
+这里便是一个完整安装 MMSegmentation 的脚本，使用 conda 并链接了数据集的路径（以您的数据集路径为 %DATA_ROOT% 来安装）。注意：它必须是一个绝对路径。
 
 ```shell
 conda create -n open-mmlab python=3.7 -y
@@ -152,9 +152,9 @@ mklink /D data %DATA_ROOT%
 
 #### 使用多版本 MMSegmentation 进行开发
 
-训练和测试脚本已经修改了`PYTHONPATH`来确保使用当前路径的MMSegmentation。
+训练和测试脚本已经修改了 `PYTHONPATH` 来确保使用当前路径的MMSegmentation。
 
-为了使用当前环境默认安装的MMSegmentation而不是正在工作的MMSegmentation，您可以在那些脚本里移除下面的内容：
+为了使用当前环境默认安装的 MMSegmentation 而不是正在工作的 MMSegmentation，您可以在那些脚本里移除下面的内容：
 
 ```shell
 PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
@@ -162,7 +162,7 @@ PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
 
 ## 验证
 
-为了验证MMSegmentation和它所需要的环境是否正确安装，我们可以使用样例python代码来初始化一个segmentor并推理一张demo图像。
+为了验证 MMSegmentation 和它所需要的环境是否正确安装，我们可以使用样例 python 代码来初始化一个 segmentor 并推理一张 demo 图像。
 
 ```python
 from mmseg.apis import inference_segmentor, init_segmentor
@@ -171,7 +171,7 @@ import mmcv
 config_file = 'configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py'
 checkpoint_file = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
 
-# 从一个config配置文件和checkpoint文件里创建分割模型
+# 从一个 config 配置文件和 checkpoint 文件里创建分割模型
 model = init_segmentor(config_file, checkpoint_file, device='cuda:0')
 
 # 测试一张样例图片并得到结果
@@ -180,7 +180,7 @@ result = inference_segmentor(model, img)
 # 在新的窗口里可视化结果
 model.show_result(img, result, show=True)
 # 或者保存图片文件的可视化结果
-# 您可以改变segmentation map的不透明度(opacity)，在(0, 1]之间。
+# 您可以改变 segmentation map 的不透明度(opacity)，在(0, 1]之间。
 model.show_result(img, result, out_file='result.jpg', opacity=0.5)
 
 # 测试一个视频并得到结果
@@ -190,9 +190,9 @@ for frame in video:
    model.show_result(frame, result, wait_time=1)
 ```
 
-当您完成MMSegmentation的安装时，上述代码应该可以成功运行。
+当您完成 MMSegmentation 的安装时，上述代码应该可以成功运行。
 
-我们还提供一个demo脚本去测试单张图片：
+我们还提供一个 demo 脚本去测试单张图片：
 
 ```shell
 python demo/image_demo.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${DEVICE_NAME}] [--palette-thr ${PALETTE}]
@@ -205,4 +205,4 @@ python demo/image_demo.py demo/demo.jpg configs/pspnet/pspnet_r50-d8_512x1024_40
     checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --palette cityscapes
 ```
 
-推理的demo文档可在此查询：[demo/inference_demo.ipynb](../demo/inference_demo.ipynb).
+推理的 demo 文档可在此查询：[demo/inference_demo.ipynb](../demo/inference_demo.ipynb).
diff --git a/docs_zh-CN/inference.md b/docs_zh-CN/inference.md
index a7cc6b8bba..6260fe64d2 100644
--- a/docs_zh-CN/inference.md
+++ b/docs_zh-CN/inference.md
@@ -1,11 +1,11 @@
 ## 使用预训练模型推理
 
-我们提供测试脚本来评估完整数据集（Cityscapes, PASCAL VOC, ADE20k等） 上的结果，同时为了对其他项目的整合更容易，也提供一些高级API。
+我们提供测试脚本来评估完整数据集（Cityscapes, PASCAL VOC, ADE20k 等） 上的结果，同时为了对其他项目的整合更容易，也提供一些高级 API。
 
 ### 测试一个数据集
 
 - 单卡 GPU
-- 单节点 多卡GPU
+- 单节点 多卡 GPU
 - 多节点
 
 您可以使用以下命令来测试一个数据集。
@@ -20,15 +20,15 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
 
 可选参数:
 
-- `RESULT_FILE`: pickle格式的输出结果的文件名，如果不专门指定，结果将不会被专门保存成文件。
-- `EVAL_METRICS`: 在结果里将被评估的指标。这主要取决于数据集，  `mIoU`  对于所有数据集都可获得，像Cityscapes数据集可以通过 `cityscapes` 命令来专门评估，就像标准的 `mIoU`一样。
-- `--show`: 如果被指定，分割结果将会在一张图像里画出来并且在另一个窗口展示。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。请确认GUI在您的环境里可用，否则您也许会遇到报错 `cannot connect to X server`
-- `--show-dir`: 如果被指定，分割结果将会在一张图像里画出来并且保存在指定文件夹里。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。使用该参数时，您的环境不需要GUI。
-- `--eval-options`: 评估时的可选参数，当设置`efficient_test=True`时，它将会保存中间结果至本地文件里以节约CPU内存。请确认您本地硬盘有足够的存储空间（大于20GB）。
+- `RESULT_FILE`: pickle 格式的输出结果的文件名，如果不专门指定，结果将不会被专门保存成文件。
+- `EVAL_METRICS`: 在结果里将被评估的指标。这主要取决于数据集，  `mIoU`  对于所有数据集都可获得，像 Cityscapes 数据集可以通过 `cityscapes` 命令来专门评估，就像标准的 `mIoU`一样。
+- `--show`: 如果被指定，分割结果将会在一张图像里画出来并且在另一个窗口展示。它仅仅是用来调试与可视化，并且仅针对单卡 GPU 测试。请确认 GUI 在您的环境里可用，否则您也许会遇到报错 `cannot connect to X server`
+- `--show-dir`: 如果被指定，分割结果将会在一张图像里画出来并且保存在指定文件夹里。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。使用该参数时，您的环境不需要 GUI。
+- `--eval-options`: 评估时的可选参数，当设置 `efficient_test=True` 时，它将会保存中间结果至本地文件里以节约CPU内存。请确认您本地硬盘有足够的存储空间（大于20GB）。
 
 例子:
 
-假设您已经下载检查点文件至文件夹`checkpoints/`里。
+假设您已经下载检查点文件至文件夹 `checkpoints/` 里。
 
 1. 测试 PSPNet 并可视化结果。按下任何键会进行到下一张图。
 
@@ -46,7 +46,7 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
         --show-dir psp_r50_512x1024_40ki_cityscapes_results
     ```
 
-3. 在数据集PASCAL VOC (不保存测试结果) 上测试 PSPNet 并评估mIoU。
+3. 在数据集 PASCAL VOC (不保存测试结果) 上测试 PSPNet 并评估 mIoU。
 
     ```shell
     python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_20k_voc12aug.py \
@@ -54,7 +54,7 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
         --eval mAP
     ```
 
-4. 使用4卡GPU测试 PSPNet，并且在标准 mIoU和cityscapes指标里评估模型。
+4. 使用4卡 GPU 测试 PSPNet，并且在标准 mIoU 和 cityscapes 指标里评估模型。
 
     ```shell
     ./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
@@ -62,9 +62,9 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
         4 --out results.pkl --eval mIoU cityscapes
     ```
 
-   注意：在cityscapes mIoU 和我们的mIoU指标会有一些差异 (~0.1%) 。原因是因为cityscapes会以默认的类的大小去平均每一类。而我们不去平均，是更简单的，适用于所有数据集的方法。
+   注意：在 cityscapes mIoU 和我们的 mIoU 指标会有一些差异 (~0.1%) 。原因是因为 cityscapes 会以默认的类的大小去平均每一类。而我们不去平均，是更简单的，适用于所有数据集的方法。
 
-5. 在cityscapes数据集上4卡GPU测试 PSPNet， 并生成png文件以便提交给官方评估服务器。
+5. 在 cityscapes 数据集上4卡 GPU 测试 PSPNet， 并生成 png 文件以便提交给官方评估服务器。
 
    首先，在配置文件里添加内容： `configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py`，
 
@@ -83,8 +83,8 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
         4 --format-only --eval-options "imgfile_prefix=./pspnet_test_results"
     ```
 
-   您会在文件夹`./pspnet_test_results`里得到生成的png文件。
-   您也许可以运行 `zip -r results.zip pspnet_test_results/` 并提交zip文件给 [evaluation server](https://www.cityscapes-dataset.com/submit/)。
+   您会在文件夹 `./pspnet_test_results` 里得到生成的png文件。
+   您也许可以运行 `zip -r results.zip pspnet_test_results/` 并提交 zip 文件给 [evaluation server](https://www.cityscapes-dataset.com/submit/)。
 
 6. CPU memory efficient test DeeplabV3+ on Cityscapes (without saving the test results) and evaluate the mIoU.
 6. 在Cityscapes数据集上测试CPU内存高效率版本的DeeplabV3+ (没有保存测试结果) 并且评估 mIoU。
diff --git a/docs_zh-CN/train.md b/docs_zh-CN/train.md
index 50d477df19..3808317ae6 100644
--- a/docs_zh-CN/train.md
+++ b/docs_zh-CN/train.md
@@ -1,21 +1,21 @@
 ## 训练一个模型
 
-MMSegmentation 可以执行分布式训练和非分布式训练，分别使用`MMDistributedDataParallel` 和 `MMDataParallel`命令。
+MMSegmentation 可以执行分布式训练和非分布式训练，分别使用 `MMDistributedDataParallel` 和 `MMDataParallel` 命令。
 
-所有的输出(日志log和检查点checkpoints)将被保存到工作路径文件夹里，它可以通过配置文件里的`work_dir`指定。
+所有的输出(日志 log 和检查点 checkpoints)将被保存到工作路径文件夹里，它可以通过配置文件里的 `work_dir` 指定。
 
 在一定迭代轮次后，我们默认在验证集上评估模型表现。您可以在训练配置文件中添加间隔参数来改变评估间隔。
 
 ```python
-evaluation = dict(interval=4000)  # 每4000 iterations评估一次模型的表现
+evaluation = dict(interval=4000)  # 每4000 iterations 评估一次模型的表现
 ```
 
-**\*Important\***: 在配置文件里的默认学习率是针对4卡GPU和2张图/GPU (此时batchsize = 4x2 = 8)来设置的。
-同样，您也可以使用8卡GPU和 1张图/GPU的设置，因为所有的模型均使用cross-GPU的SyncBN模式。
+**\*Important\***: 在配置文件里的默认学习率是针对4卡 GPU 和2张图/GPU (此时 batchsize = 4x2 = 8)来设置的。
+同样，您也可以使用8卡 GPU 和 1张图/GPU的设置，因为所有的模型均使用 cross-GPU 的 SyncBN 模式。
 
-为了以GPU显存为代价提升运行速度，您也可以通过传递`--options model.backbone.with_cp=True` 来在backbone骨架里有checkpoints检查点。
+为了以 GPU 显存为代价提升运行速度，您也可以通过传递`--options model.backbone.with_cp=True` 来在 backbone 骨架里有 checkpoints 检查点。
 
-### 使用单卡GPU训练
+### 使用单卡 GPU 训练
 
 ```shell
 python tools/train.py ${配置文件} [可选参数]
@@ -26,7 +26,7 @@ python tools/train.py ${配置文件} [可选参数]
 ### 使用多卡GPU训练
 
 ```shell
-./tools/dist_train.sh ${配置文件} ${GPU个数} [可选参数]
+./tools/dist_train.sh ${配置文件} ${GPU 个数} [可选参数]
 ```
 
 可选参数可以为:
@@ -36,21 +36,21 @@ python tools/train.py ${配置文件} [可选参数]
 - `--resume-from ${检查点文件}`: 继续使用先前的检查点文件（可以继续训练过程）。
 - `--load-from ${检查点文件}`: 从一个检查点文件里加载权重（对另一个任务进行精调）。
 
-`resume-from` 和 `load-from`的区别:
+`resume-from` 和 `load-from` 的区别:
 
 - `resume-from` 加载出模型权重和优化器状态包括迭代轮数等。
 - `load-from` 仅加载模型权重，从第0轮开始训练。
 
 ### 使用多个机器训练
 
-如果您在一个集群上以[slurm](https://slurm.schedmd.com/) 运行MMSegmentation，
-您可以使用脚本`slurm_train.sh`（这个脚本同样支持单个机器的训练）。
+如果您在一个集群上以[slurm](https://slurm.schedmd.com/) 运行 MMSegmentation，
+您可以使用脚本 `slurm_train.sh`（这个脚本同样支持单个机器的训练）。
 
 ```shell
 [GPUS=${GPU号码}] ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件} --work-dir ${工作路径}
 ```
 
-这里是在dev分区里使用16块GPU训练PSPNet的例子。
+这里是在 dev 分区里使用16块 GPU 训练 PSPNet 的例子。
 
 ```shell
 GPUS=16 ./tools/slurm_train.sh dev pspr50 configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py /nfs/xxxx/psp_r50_512x1024_40ki_cityscapes
@@ -58,23 +58,23 @@ GPUS=16 ./tools/slurm_train.sh dev pspr50 configs/pspnet/pspnet_r50-d8_512x1024_
 
 您可以查看 [slurm_train.sh](../tools/slurm_train.sh) 以熟悉全部的参数与环境变量。
 
-如果您多个机器已经有以太网连接， 您可以参考PyTorch
+如果您多个机器已经有以太网连接， 您可以参考 PyTorch
 [launch utility](https://pytorch.org/docs/stable/distributed_deprecated.html#launch-utility) 。
-若您没有像InfiniBand这样高速的网络连接，多机器训练通常会比较慢。
+若您没有像 InfiniBand 这样高速的网络连接，多机器训练通常会比较慢。
 
 ### 在单个机器上启动多个任务
 
-如果您在单个机器上启动多个任务，例如在8卡GPU的一个机器上有2个4卡GPU的训练任务，您需要特别对每个任务指定不同的端口（默认为29500）来避免通讯冲突。
-否则，将会有报错信息`RuntimeError: Address already in use`。
+如果您在单个机器上启动多个任务，例如在8卡 GPU 的一个机器上有2个4卡 GPU 的训练任务，您需要特别对每个任务指定不同的端口（默认为29500）来避免通讯冲突。
+否则，将会有报错信息 `RuntimeError: Address already in use`。
 
-如果您使用命令`dist_train.sh`来启动一个训练任务，您可以在命令行的用环境变量`PORT`设置端口。
+如果您使用命令 `dist_train.sh` 来启动一个训练任务，您可以在命令行的用环境变量 `PORT` 设置端口。
 
 ```shell
 CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${配置文件} 4
 CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${配置文件} 4
 ```
 
-如果您使用命令`slurm_train.sh`来启动训练任务，您可以在命令行的用环境变量`MASTER_PORT`设置端口。
+如果您使用命令 `slurm_train.sh` 来启动训练任务，您可以在命令行的用环境变量 `MASTER_PORT` 设置端口。
 
 ```shell
 MASTER_PORT=29500 ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件}

From 6adb79e52f2b030235655ba156870b8ad572cd68 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Tue, 15 Jun 2021 23:53:11 +0800
Subject: [PATCH 08/17] change README_zh-CN link

---
 README_zh-CN.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README_zh-CN.md b/README_zh-CN.md
index 849a358437..482d65d9d9 100644
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -90,11 +90,11 @@ MMSegmentation 是一个基于 PyTorch 的语义分割开源工具箱。它是 O
 
 ## 安装
 
-请参考[快速入门文档](docs/get_started.md#installation)进行安装和数据集准备。
+请参考[快速入门文档](docs_zh-CN/get_started.md#installation)进行安装和数据集准备。
 
 ## 快速入门
 
-请参考[训练教程](docs/train.md)和[测试教程](docs/inference.md)学习 MMSegmentation 的基本使用。
+请参考[训练教程](docs_zh-CN/train.md)和[测试教程](docs_zh-CN/inference.md)学习 MMSegmentation 的基本使用。
 我们也提供了一些进阶教程，内容覆盖了[增加自定义数据集](docs/tutorials/customize_datasets.md)，[设计新的数据预处理流程](docs/tutorials/data_pipeline.md)，[增加自定义模型](docs/tutorials/customize_models.md)，[增加自定义的运行时配置](docs/tutorials/customize_runtime.md)。
 除此之外，我们也提供了很多实用的[训练技巧说明](docs/tutorials/training_tricks.md)。
 

From 12afb800bbceaf96902f9625035e29b00822d426 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Mon, 21 Jun 2021 16:39:55 +0800
Subject: [PATCH 09/17] checkout space again

---
 docs_zh-CN/get_started.md | 6 +++---
 docs_zh-CN/inference.md   | 6 +++---
 docs_zh-CN/train.md       | 6 +++---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index b65b3dda21..aa7b2046ca 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -55,11 +55,11 @@ pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.5
 可以安装好 mmcv-full (PyTorch 1.5 和 CUDA 10.1) 版本。
 其他 PyTorch 和 CUDA 版本的 MMCV 安装请参照[这里](https://mmcv.readthedocs.io/en/latest/#install-with-pip)
 
-**在Windows下安装mmcv(有风险):**
+**在 Windows 下安装 mmcv (有风险):**
 
 对于 Windows, MMCV 的安装需要本地 C++ 编译工具, 例如 cl.exe. 请添加编译工具至 %PATH%.
 
-如果您已经在电脑上安装好Windows SDK 和 Visual Studio， cl.exe 的一个典型路径看起来如下：
+如果您已经在电脑上安装好Windows SDK 和 Visual Studio，cl.exe 的一个典型路径看起来如下：
 
 ```shell
 C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.26.28801\bin\Hostx86\x64
@@ -95,7 +95,7 @@ pip install mmsegmentation # 安装最新版本
 pip install git+https://github.com/open-mmlab/mmsegmentation.git # 安装 master 分支
 ```
 
-此外，如果您想安装 `dev` 模式的MMSegmentation, 运行如下命令：
+此外，如果您想安装 `dev` 模式的 MMSegmentation, 运行如下命令：
 
 ```shell
 git clone https://github.com/open-mmlab/mmsegmentation.git
diff --git a/docs_zh-CN/inference.md b/docs_zh-CN/inference.md
index 6260fe64d2..4ea4f2c67a 100644
--- a/docs_zh-CN/inference.md
+++ b/docs_zh-CN/inference.md
@@ -83,11 +83,11 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
         4 --format-only --eval-options "imgfile_prefix=./pspnet_test_results"
     ```
 
-   您会在文件夹 `./pspnet_test_results` 里得到生成的png文件。
+   您会在文件夹 `./pspnet_test_results` 里得到生成的 png 文件。
    您也许可以运行 `zip -r results.zip pspnet_test_results/` 并提交 zip 文件给 [evaluation server](https://www.cityscapes-dataset.com/submit/)。
 
 6. CPU memory efficient test DeeplabV3+ on Cityscapes (without saving the test results) and evaluate the mIoU.
-6. 在Cityscapes数据集上测试CPU内存高效率版本的DeeplabV3+ (没有保存测试结果) 并且评估 mIoU。
+6. 在 Cityscapes 数据集上测试 CPU 内存高效率版本的 DeeplabV3+ (没有保存测试结果) 并且评估 mIoU。
 
     ```shell
     python tools/test.py \
@@ -97,4 +97,4 @@ python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}]
     --eval mIoU
     ```
 
-    使用 ```pmap``` 可查看 CPU 内存情况,  ```efficient_test=True``` 会使用约 2.25GB 的CPU 内存， ```efficient_test=False``` 会使用约 11.06GB 的CPU 内存。 这个可选参数可以节约很多CPU内存。
+    使用 ```pmap``` 可查看 CPU 内存情况,  ```efficient_test=True``` 会使用约 2.25GB 的 CPU 内存， ```efficient_test=False``` 会使用约 11.06GB 的 CPU 内存。 这个可选参数可以节约很多 CPU 内存。
diff --git a/docs_zh-CN/train.md b/docs_zh-CN/train.md
index 3808317ae6..93057dcb1b 100644
--- a/docs_zh-CN/train.md
+++ b/docs_zh-CN/train.md
@@ -2,7 +2,7 @@
 
 MMSegmentation 可以执行分布式训练和非分布式训练，分别使用 `MMDistributedDataParallel` 和 `MMDataParallel` 命令。
 
-所有的输出(日志 log 和检查点 checkpoints)将被保存到工作路径文件夹里，它可以通过配置文件里的 `work_dir` 指定。
+所有的输出(日志 log 和检查点 checkpoints )将被保存到工作路径文件夹里，它可以通过配置文件里的 `work_dir` 指定。
 
 在一定迭代轮次后，我们默认在验证集上评估模型表现。您可以在训练配置文件中添加间隔参数来改变评估间隔。
 
@@ -11,7 +11,7 @@ evaluation = dict(interval=4000)  # 每4000 iterations 评估一次模型的表
 ```
 
 **\*Important\***: 在配置文件里的默认学习率是针对4卡 GPU 和2张图/GPU (此时 batchsize = 4x2 = 8)来设置的。
-同样，您也可以使用8卡 GPU 和 1张图/GPU的设置，因为所有的模型均使用 cross-GPU 的 SyncBN 模式。
+同样，您也可以使用8卡 GPU 和 1张图/GPU 的设置，因为所有的模型均使用 cross-GPU 的 SyncBN 模式。
 
 为了以 GPU 显存为代价提升运行速度，您也可以通过传递`--options model.backbone.with_cp=True` 来在 backbone 骨架里有 checkpoints 检查点。
 
@@ -23,7 +23,7 @@ python tools/train.py ${配置文件} [可选参数]
 
 如果您想在命令里定义工作文件夹路径，您可以添加一个参数`--work-dir ${YOUR_WORK_DIR}`。
 
-### 使用多卡GPU训练
+### 使用多卡 GPU 训练
 
 ```shell
 ./tools/dist_train.sh ${配置文件} ${GPU 个数} [可选参数]

From 6ddb19d502084c99f5fae58330e3ea88e306c027 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Mon, 21 Jun 2021 17:31:30 +0800
Subject: [PATCH 10/17] checkout space again

---
 docs_zh-CN/get_started.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index aa7b2046ca..2af6c5fbfb 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -25,7 +25,7 @@
 
 ## 安装
 
-a. 创建一个conda虚拟环境并激活它。
+a. 创建一个 conda 虚拟环境并激活它。
 
 ```shell
 conda create -n open-mmlab python=3.7 -y

From 42908c549a29e172f0742aa24886d54a64f3540e Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Mon, 21 Jun 2021 17:33:20 +0800
Subject: [PATCH 11/17] checkout space again

---
 docs_zh-CN/get_started.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index 2af6c5fbfb..d4d48e37fa 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -44,7 +44,7 @@ conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
 c. 按照 [官方教程](https://mmcv.readthedocs.io/en/latest/#installation) 安装 [MMCV](https://mmcv.readthedocs.io/en/latest/) 。
 `mmcv` 或 `mmcv-full` 和 MMSegmentation 均兼容，但对于 CCNet 和 PSANet，`mmcv-full` 里的 CUDA 运算是必须的。
 
-**在Linux下安装mmcv:**
+**在 Linux 下安装 mmcv:**
 
 通过运行
 

From e5a0265198a13e7ebcd4286c81c66e3389b695bc Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Wed, 23 Jun 2021 16:11:02 +0800
Subject: [PATCH 12/17] pipeline

---
 docs_zh-CN/get_started.md             | 207 --------------------------
 docs_zh-CN/inference.md               | 101 +------------
 docs_zh-CN/train.md                   |  81 ----------
 docs_zh-CN/tutorials/data_pipeline.md |  79 +++++-----
 4 files changed, 38 insertions(+), 430 deletions(-)

diff --git a/docs_zh-CN/get_started.md b/docs_zh-CN/get_started.md
index d4d48e37fa..abbd958777 100644
--- a/docs_zh-CN/get_started.md
+++ b/docs_zh-CN/get_started.md
@@ -1,208 +1 @@
 ## 依赖
-
-- Linux or macOS (Windows下支持需要mmcv-full，但运行时可能会有一些问题。)
-- Python 3.6+
-- PyTorch 1.3+
-- CUDA 9.2+ (如果您基于源文件编译 PyTorch, CUDA 9.0也可以使用)
-- GCC 5+
-- [MMCV](https://mmcv.readthedocs.io/en/latest/#installation)
-
-可编译的 MMSegmentation 和 MMCV 版本如下所示，请对照对应版本安装以避免安装问题。
-
-| MMSegmentation 版本 |    MMCV 版本     |
-|:-------------------:|:-------------------:|
-| master              | mmcv-full>=1.3.1, <1.4.0 |
-| 0.13.0              | mmcv-full>=1.3.1, <1.4.0 |
-| 0.12.0              | mmcv-full>=1.1.4, <1.4.0 |
-| 0.11.0              | mmcv-full>=1.1.4, <1.3.0 |
-| 0.10.0              | mmcv-full>=1.1.4, <1.3.0 |
-| 0.9.0               | mmcv-full>=1.1.4, <1.3.0 |
-| 0.8.0               | mmcv-full>=1.1.4, <1.2.0 |
-| 0.7.0               | mmcv-full>=1.1.2, <1.2.0 |
-| 0.6.0               | mmcv-full>=1.1.2, <1.2.0 |
-
-注意: 如果您已经安装好 mmcv, 您首先需要运行 `pip uninstall mmcv`。如果 mmcv 和 mmcv-full 同时被安装，会报错 `ModuleNotFoundError`。
-
-## 安装
-
-a. 创建一个 conda 虚拟环境并激活它。
-
-```shell
-conda create -n open-mmlab python=3.7 -y
-conda activate open-mmlab
-
-```
-
-b. 按照[官方教程](https://pytorch.org/) 安装 PyTorch 和 totchvision。
-这里我们使用 PyTorch1.6.0 和 CUDA10.1。
-您也可以切换至其他版本。
-
-```shell
-conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
-```
-
-c. 按照 [官方教程](https://mmcv.readthedocs.io/en/latest/#installation) 安装 [MMCV](https://mmcv.readthedocs.io/en/latest/) 。
-`mmcv` 或 `mmcv-full` 和 MMSegmentation 均兼容，但对于 CCNet 和 PSANet，`mmcv-full` 里的 CUDA 运算是必须的。
-
-**在 Linux 下安装 mmcv:**
-
-通过运行
-
-```shell
-pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu101/torch1.5.0/index.html
-```
-
-可以安装好 mmcv-full (PyTorch 1.5 和 CUDA 10.1) 版本。
-其他 PyTorch 和 CUDA 版本的 MMCV 安装请参照[这里](https://mmcv.readthedocs.io/en/latest/#install-with-pip)
-
-**在 Windows 下安装 mmcv (有风险):**
-
-对于 Windows, MMCV 的安装需要本地 C++ 编译工具, 例如 cl.exe. 请添加编译工具至 %PATH%.
-
-如果您已经在电脑上安装好Windows SDK 和 Visual Studio，cl.exe 的一个典型路径看起来如下：
-
-```shell
-C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.26.28801\bin\Hostx86\x64
-```
-
-或者您需要从网上下载cl编译工具并安装至路径。
-
-随后，从 github 克隆 mmcv 并通过 pip 安装：
-
-```shell
-git clone https://github.com/open-mmlab/mmcv.git
-cd mmcv
-pip install -e .
-```
-
-或直接:
-
-```shell
-pip install mmcv
-```
-
-当前，mmcv-full 并不完全在 windows 上支持。
-
-d. 安装 MMSegmentation.
-
-```shell
-pip install mmsegmentation # 安装最新版本
-```
-
-或者
-
-```shell
-pip install git+https://github.com/open-mmlab/mmsegmentation.git # 安装 master 分支
-```
-
-此外，如果您想安装 `dev` 模式的 MMSegmentation, 运行如下命令：
-
-```shell
-git clone https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -e .  # 或者 "python setup.py develop"
-```
-
-注意:
-
-1. 当在 windows 下训练和测试模型时，请确保路径下所有的'\\' 被替换成 '/'。在 python 代码里可以使用`.replace('\\', '/')`处理路径的字符串。
-2. `version+git_hash` 也将被保存进 meta 训练模型里，即0.5.0+c415a2e。
-3. 当 MMsegmentation 以 `dev` 模式被安装时，本地对代码的修改将不需要重新安装即可产生作用。
-4. 如果您想使用 `opencv-python-headless` 替换 `opencv-python`，您可以在安装 MMCV 前安装它。
-5. 一些依赖项是可选的。简单的运行 `pip install -e .` 将仅安装最必要的一些依赖。为了使用可选的依赖项如`cityscapessripts`，要么手动使用 `pip install -r requirements/optional.txt` 安装，要么专门从pip下安装(即 `pip install -e .[optional]`， 其中选项可设置为 `all`, `tests`, `build`, 和 `optional`).
-
-### 即刻安装脚本
-
-#### Linux
-
-这里便是一个完整安装 MMSegmentation 的脚本，使用 conda 并链接了数据集的路径（以您的数据集路径为 $DATA_ROOT 来安装）。
-
-```shell
-conda create -n open-mmlab python=3.7 -y
-conda activate open-mmlab
-
-conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
-pip install mmcv-full==latest+torch1.5.0+cu101 -f https://download.openmmlab.com/mmcv/dist/index.html
-git clone https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -e .  # 或者 "python setup.py develop"
-
-mkdir data
-ln -s $DATA_ROOT data
-```
-
-#### Windows(有风险)
-
-这里便是一个完整安装 MMSegmentation 的脚本，使用 conda 并链接了数据集的路径（以您的数据集路径为 %DATA_ROOT% 来安装）。注意：它必须是一个绝对路径。
-
-```shell
-conda create -n open-mmlab python=3.7 -y
-conda activate open-mmlab
-
-conda install pytorch=1.6.0 torchvision cudatoolkit=10.1 -c pytorch
-set PATH=full\path\to\your\cpp\compiler;%PATH%
-pip install mmcv
-
-git clone https://github.com/open-mmlab/mmsegmentation.git
-cd mmsegmentation
-pip install -e .  # 或者 "python setup.py develop"
-
-mklink /D data %DATA_ROOT%
-```
-
-#### 使用多版本 MMSegmentation 进行开发
-
-训练和测试脚本已经修改了 `PYTHONPATH` 来确保使用当前路径的MMSegmentation。
-
-为了使用当前环境默认安装的 MMSegmentation 而不是正在工作的 MMSegmentation，您可以在那些脚本里移除下面的内容：
-
-```shell
-PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
-```
-
-## 验证
-
-为了验证 MMSegmentation 和它所需要的环境是否正确安装，我们可以使用样例 python 代码来初始化一个 segmentor 并推理一张 demo 图像。
-
-```python
-from mmseg.apis import inference_segmentor, init_segmentor
-import mmcv
-
-config_file = 'configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py'
-checkpoint_file = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
-
-# 从一个 config 配置文件和 checkpoint 文件里创建分割模型
-model = init_segmentor(config_file, checkpoint_file, device='cuda:0')
-
-# 测试一张样例图片并得到结果
-img = 'test.jpg'  # or img = mmcv.imread(img), which will only load it once
-result = inference_segmentor(model, img)
-# 在新的窗口里可视化结果
-model.show_result(img, result, show=True)
-# 或者保存图片文件的可视化结果
-# 您可以改变 segmentation map 的不透明度(opacity)，在(0, 1]之间。
-model.show_result(img, result, out_file='result.jpg', opacity=0.5)
-
-# 测试一个视频并得到结果
-video = mmcv.VideoReader('video.mp4')
-for frame in video:
-   result = inference_segmentor(model, frame)
-   model.show_result(frame, result, wait_time=1)
-```
-
-当您完成 MMSegmentation 的安装时，上述代码应该可以成功运行。
-
-我们还提供一个 demo 脚本去测试单张图片：
-
-```shell
-python demo/image_demo.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} [--device ${DEVICE_NAME}] [--palette-thr ${PALETTE}]
-```
-
-样例：
-
-```shell
-python demo/image_demo.py demo/demo.jpg configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-    checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth --device cuda:0 --palette cityscapes
-```
-
-推理的 demo 文档可在此查询：[demo/inference_demo.ipynb](../demo/inference_demo.ipynb).
diff --git a/docs_zh-CN/inference.md b/docs_zh-CN/inference.md
index 4ea4f2c67a..2b50abb43a 100644
--- a/docs_zh-CN/inference.md
+++ b/docs_zh-CN/inference.md
@@ -1,100 +1 @@
-## 使用预训练模型推理
-
-我们提供测试脚本来评估完整数据集（Cityscapes, PASCAL VOC, ADE20k 等） 上的结果，同时为了对其他项目的整合更容易，也提供一些高级 API。
-
-### 测试一个数据集
-
-- 单卡 GPU
-- 单节点 多卡 GPU
-- 多节点
-
-您可以使用以下命令来测试一个数据集。
-
-```shell
-# 单卡GPU 测试
-python tools/test.py ${配置文件} ${检查点文件} [--out ${结果文件}] [--eval ${评估指标}] [--show]
-
-# 多卡GPU 测试
-./tools/dist_test.sh ${配置文件} ${检查点文件} ${GPU数目} [--out ${结果文件}] [--eval ${评估指标}]
-```
-
-可选参数:
-
-- `RESULT_FILE`: pickle 格式的输出结果的文件名，如果不专门指定，结果将不会被专门保存成文件。
-- `EVAL_METRICS`: 在结果里将被评估的指标。这主要取决于数据集，  `mIoU`  对于所有数据集都可获得，像 Cityscapes 数据集可以通过 `cityscapes` 命令来专门评估，就像标准的 `mIoU`一样。
-- `--show`: 如果被指定，分割结果将会在一张图像里画出来并且在另一个窗口展示。它仅仅是用来调试与可视化，并且仅针对单卡 GPU 测试。请确认 GUI 在您的环境里可用，否则您也许会遇到报错 `cannot connect to X server`
-- `--show-dir`: 如果被指定，分割结果将会在一张图像里画出来并且保存在指定文件夹里。它仅仅是用来调试与可视化，并且仅针对单卡GPU测试。使用该参数时，您的环境不需要 GUI。
-- `--eval-options`: 评估时的可选参数，当设置 `efficient_test=True` 时，它将会保存中间结果至本地文件里以节约CPU内存。请确认您本地硬盘有足够的存储空间（大于20GB）。
-
-例子:
-
-假设您已经下载检查点文件至文件夹 `checkpoints/` 里。
-
-1. 测试 PSPNet 并可视化结果。按下任何键会进行到下一张图。
-
-    ```shell
-    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
-        --show
-    ```
-
-2. 测试 PSPNet 并保存画出的图以便于之后的可视化。
-
-    ```shell
-    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
-        --show-dir psp_r50_512x1024_40ki_cityscapes_results
-    ```
-
-3. 在数据集 PASCAL VOC (不保存测试结果) 上测试 PSPNet 并评估 mIoU。
-
-    ```shell
-    python tools/test.py configs/pspnet/pspnet_r50-d8_512x1024_20k_voc12aug.py \
-        checkpoints/pspnet_r50-d8_512x1024_20k_voc12aug_20200605_003338-c57ef100.pth \
-        --eval mAP
-    ```
-
-4. 使用4卡 GPU 测试 PSPNet，并且在标准 mIoU 和 cityscapes 指标里评估模型。
-
-    ```shell
-    ./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
-        4 --out results.pkl --eval mIoU cityscapes
-    ```
-
-   注意：在 cityscapes mIoU 和我们的 mIoU 指标会有一些差异 (~0.1%) 。原因是因为 cityscapes 会以默认的类的大小去平均每一类。而我们不去平均，是更简单的，适用于所有数据集的方法。
-
-5. 在 cityscapes 数据集上4卡 GPU 测试 PSPNet， 并生成 png 文件以便提交给官方评估服务器。
-
-   首先，在配置文件里添加内容： `configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py`，
-
-    ```python
-    data = dict(
-        test=dict(
-            img_dir='leftImg8bit/test',
-            ann_dir='gtFine/test'))
-    ```
-
-   随后，进行测试。
-
-    ```shell
-    ./tools/dist_test.sh configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py \
-        checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth \
-        4 --format-only --eval-options "imgfile_prefix=./pspnet_test_results"
-    ```
-
-   您会在文件夹 `./pspnet_test_results` 里得到生成的 png 文件。
-   您也许可以运行 `zip -r results.zip pspnet_test_results/` 并提交 zip 文件给 [evaluation server](https://www.cityscapes-dataset.com/submit/)。
-
-6. CPU memory efficient test DeeplabV3+ on Cityscapes (without saving the test results) and evaluate the mIoU.
-6. 在 Cityscapes 数据集上测试 CPU 内存高效率版本的 DeeplabV3+ (没有保存测试结果) 并且评估 mIoU。
-
-    ```shell
-    python tools/test.py \
-    configs/deeplabv3plus/deeplabv3plus_r18-d8_512x1024_80k_cityscapes.py \
-    deeplabv3plus_r18-d8_512x1024_80k_cityscapes_20201226_080942-cff257fe.pth \
-    --eval-options efficient_test=True \
-    --eval mIoU
-    ```
-
-    使用 ```pmap``` 可查看 CPU 内存情况,  ```efficient_test=True``` 会使用约 2.25GB 的 CPU 内存， ```efficient_test=False``` 会使用约 11.06GB 的 CPU 内存。 这个可选参数可以节约很多 CPU 内存。
+## 用预训练模型进行推理
diff --git a/docs_zh-CN/train.md b/docs_zh-CN/train.md
index 93057dcb1b..6a3aa82ff0 100644
--- a/docs_zh-CN/train.md
+++ b/docs_zh-CN/train.md
@@ -1,82 +1 @@
 ## 训练一个模型
-
-MMSegmentation 可以执行分布式训练和非分布式训练，分别使用 `MMDistributedDataParallel` 和 `MMDataParallel` 命令。
-
-所有的输出(日志 log 和检查点 checkpoints )将被保存到工作路径文件夹里，它可以通过配置文件里的 `work_dir` 指定。
-
-在一定迭代轮次后，我们默认在验证集上评估模型表现。您可以在训练配置文件中添加间隔参数来改变评估间隔。
-
-```python
-evaluation = dict(interval=4000)  # 每4000 iterations 评估一次模型的表现
-```
-
-**\*Important\***: 在配置文件里的默认学习率是针对4卡 GPU 和2张图/GPU (此时 batchsize = 4x2 = 8)来设置的。
-同样，您也可以使用8卡 GPU 和 1张图/GPU 的设置，因为所有的模型均使用 cross-GPU 的 SyncBN 模式。
-
-为了以 GPU 显存为代价提升运行速度，您也可以通过传递`--options model.backbone.with_cp=True` 来在 backbone 骨架里有 checkpoints 检查点。
-
-### 使用单卡 GPU 训练
-
-```shell
-python tools/train.py ${配置文件} [可选参数]
-```
-
-如果您想在命令里定义工作文件夹路径，您可以添加一个参数`--work-dir ${YOUR_WORK_DIR}`。
-
-### 使用多卡 GPU 训练
-
-```shell
-./tools/dist_train.sh ${配置文件} ${GPU 个数} [可选参数]
-```
-
-可选参数可以为:
-
-- `--no-validate` (**不推荐**): 训练时代码库默认会在每k轮迭代后在验证集上进行评估，如果不需评估使用命令 `--no-validate`。
-- `--work-dir ${工作路径}`: 在配置文件里重写工作路径文件夹。
-- `--resume-from ${检查点文件}`: 继续使用先前的检查点文件（可以继续训练过程）。
-- `--load-from ${检查点文件}`: 从一个检查点文件里加载权重（对另一个任务进行精调）。
-
-`resume-from` 和 `load-from` 的区别:
-
-- `resume-from` 加载出模型权重和优化器状态包括迭代轮数等。
-- `load-from` 仅加载模型权重，从第0轮开始训练。
-
-### 使用多个机器训练
-
-如果您在一个集群上以[slurm](https://slurm.schedmd.com/) 运行 MMSegmentation，
-您可以使用脚本 `slurm_train.sh`（这个脚本同样支持单个机器的训练）。
-
-```shell
-[GPUS=${GPU号码}] ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件} --work-dir ${工作路径}
-```
-
-这里是在 dev 分区里使用16块 GPU 训练 PSPNet 的例子。
-
-```shell
-GPUS=16 ./tools/slurm_train.sh dev pspr50 configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py /nfs/xxxx/psp_r50_512x1024_40ki_cityscapes
-```
-
-您可以查看 [slurm_train.sh](../tools/slurm_train.sh) 以熟悉全部的参数与环境变量。
-
-如果您多个机器已经有以太网连接， 您可以参考 PyTorch
-[launch utility](https://pytorch.org/docs/stable/distributed_deprecated.html#launch-utility) 。
-若您没有像 InfiniBand 这样高速的网络连接，多机器训练通常会比较慢。
-
-### 在单个机器上启动多个任务
-
-如果您在单个机器上启动多个任务，例如在8卡 GPU 的一个机器上有2个4卡 GPU 的训练任务，您需要特别对每个任务指定不同的端口（默认为29500）来避免通讯冲突。
-否则，将会有报错信息 `RuntimeError: Address already in use`。
-
-如果您使用命令 `dist_train.sh` 来启动一个训练任务，您可以在命令行的用环境变量 `PORT` 设置端口。
-
-```shell
-CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${配置文件} 4
-CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${配置文件} 4
-```
-
-如果您使用命令 `slurm_train.sh` 来启动训练任务，您可以在命令行的用环境变量 `MASTER_PORT` 设置端口。
-
-```shell
-MASTER_PORT=29500 ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件}
-MASTER_PORT=29501 ./tools/slurm_train.sh ${分区} ${任务名称} ${配置文件}
-```
diff --git a/docs_zh-CN/tutorials/data_pipeline.md b/docs_zh-CN/tutorials/data_pipeline.md
index 6ec54982cd..9285db90be 100644
--- a/docs_zh-CN/tutorials/data_pipeline.md
+++ b/docs_zh-CN/tutorials/data_pipeline.md
@@ -1,22 +1,17 @@
 # 教程 3: 自定义数据流程
 
-## Design of Data pipelines
+## 设计数据流程
 
-Following typical conventions, we use `Dataset` and `DataLoader` for data loading
-with multiple workers. `Dataset` returns a dict of data items corresponding
-the arguments of models' forward method.
-Since the data in semantic segmentation may not be the same size,
-we introduce a new `DataContainer` type in MMCV to help collect and distribute
-data of different size.
-See [here](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py) for more details.
+按照通常的惯例，我们使用`Dataset` 和 `DataLoader` 做多线程的数据加载。`Dataset` 返回一个数据内容的字典，里面对应于模型前传方法的各个参数。
+因为语义分割里的数据可能不是相同的大小尺寸，我们在 MMCV 里引入一个新的 `DataContainer` 类别去帮助收集和分发不同大小的输入数据。
 
-The data preparation pipeline and the dataset is decomposed. Usually a dataset
-defines how to process the annotations and a data pipeline defines all the steps to prepare a data dict.
-A pipeline consists of a sequence of operations. Each operation takes a dict as input and also output a dict for the next transform.
+更多细节，请查看[这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py).
 
-The operations are categorized into data loading, pre-processing, formatting and test-time augmentation.
+数据的准备流程和数据集是解耦的。通常一个数据集定义了如何处理注释信息，而一个数据流程定义了准备一个数据字典的所有步骤。一个流程包括了一系列操作，每个操作里都把一个字典作为输入，然后再输出一个新的字典给下一个变换操作。
 
-Here is an pipeline example for PSPNet.
+这些操作可分为数据加载 (data loading)，预处理 (pre-processing)，格式变化 (formatting) 和测试时数据增强 (test-time augmentation) 。
+
+下面的例子就是 PSPNet 的一个流程:
 
 ```python
 img_norm_cfg = dict(
@@ -51,86 +46,86 @@ test_pipeline = [
 ]
 ```
 
-For each operation, we list the related dict fields that are added/updated/removed.
+对于每个操作，我们列出它添加、更新、移除的相关字典域 (dict fields)：
 
-### Data loading
+### 数据加载 Data loading
 
 `LoadImageFromFile`
 
-- add: img, img_shape, ori_shape
+- 增加: img, img_shape, ori_shape
 
 `LoadAnnotations`
 
-- add: gt_semantic_seg, seg_fields
+- 增加: gt_semantic_seg, seg_fields
 
-### Pre-processing
+### 预处理 Pre-processing
 
 `Resize`
 
-- add: scale, scale_idx, pad_shape, scale_factor, keep_ratio
-- update: img, img_shape, *seg_fields
+- 增加: scale, scale_idx, pad_shape, scale_factor, keep_ratio
+- 更新: img, img_shape, *seg_fields
 
 `RandomFlip`
 
-- add: flip
-- update: img, *seg_fields
+- 增加: flip
+- 更新: img, *seg_fields
 
 `Pad`
 
-- add: pad_fixed_size, pad_size_divisor
-- update: img, pad_shape, *seg_fields
+- 增加: pad_fixed_size, pad_size_divisor
+- 更新: img, pad_shape, *seg_fields
 
 `RandomCrop`
 
-- update: img, pad_shape, *seg_fields
+- 更新: img, pad_shape, *seg_fields
 
 `Normalize`
 
-- add: img_norm_cfg
-- update: img
+- 增加: img_norm_cfg
+- 更新: img
 
 `SegRescale`
 
-- update: gt_semantic_seg
+- 更新: gt_semantic_seg
 
 `PhotoMetricDistortion`
 
-- update: img
+- 更新: img
 
-### Formatting
+### 格式 Formatting
 
 `ToTensor`
 
-- update: specified by `keys`.
+- 更新: 由 `keys` 指定.
 
 `ImageToTensor`
 
-- update: specified by `keys`.
+- 更新: 由 `keys` 指定.
 
 `Transpose`
 
-- update: specified by `keys`.
+- 更新: 由 `keys` 指定.
 
 `ToDataContainer`
 
-- update: specified by `fields`.
+- 更新: 由 `keys` 指定.
 
 `DefaultFormatBundle`
 
-- update: img, gt_semantic_seg
+- 更新: img, gt_semantic_seg
 
 `Collect`
 
-- add: img_meta (the keys of img_meta is specified by `meta_keys`)
-- remove: all other keys except for those specified by `keys`
+- 增加: img_meta (the keys of img_meta is specified by `meta_keys`)
+- 移除: all other keys except for those specified by `keys`
 
-### Test time augmentation
+### 测试时数据增强 Test time augmentation
 
 `MultiScaleFlipAug`
 
-## Extend and use custom pipelines
+## 拓展和使用自定义的流程
 
-1. Write a new pipeline in any file, e.g., `my_pipeline.py`. It takes a dict as input and return a dict.
+1. 在任何一个文件里写一个新的流程，例如 `my_pipeline.py`。它以一个字典作为输入并且输出一个字典。
 
     ```python
     from mmseg.datasets import PIPELINES
@@ -143,13 +138,13 @@ For each operation, we list the related dict fields that are added/updated/remov
             return results
     ```
 
-2. Import the new class.
+2. 导入一个新类
 
     ```python
     from .my_pipeline import MyTransform
     ```
 
-3. Use it in config files.
+3. 在配置文件里使用它
 
     ```python
     img_norm_cfg = dict(

From 0b942b1480b2bde518359184ce27d2cf381414ff Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Wed, 23 Jun 2021 16:19:41 +0800
Subject: [PATCH 13/17] cus_model

---
 docs_zh-CN/tutorials/customize_models.md | 229 +++++++++++++++++++++++
 1 file changed, 229 insertions(+)

diff --git a/docs_zh-CN/tutorials/customize_models.md b/docs_zh-CN/tutorials/customize_models.md
index 11a0325497..299e231fc1 100644
--- a/docs_zh-CN/tutorials/customize_models.md
+++ b/docs_zh-CN/tutorials/customize_models.md
@@ -1 +1,230 @@
 # 教程 4: 自定义模型
+
+## 自定义优化器 (optimizer)
+
+假设您想增加一个新的叫 `MyOptimizer` 的优化器，它的参数分别为 `a`, `b`, 和 `c`。
+您首先需要在一个文件里实施这个新优化器，例如在 `mmseg/core/optimizer/my_optimizer.py` 里面：
+
+```python
+from mmcv.runner import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+
+```
+
+然后增加这个模块到 `mmseg/core/optimizer/__init__.py` 里面，这样注册表 (registry) 将会发现这个新的模块并添加它：
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+之后您可以在配置文件的 `optimizer` 域里使用 `MyOptimizer`，
+如下所示，在配置文件里，优化器被 `optimizer` 域所定义：
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+为了使用您自己的优化器，域可以被修改为：
+
+```python
+optimizer = dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)
+```
+
+我们已经支持了 PyTorch 自带的全部优化器，唯一修改的地方是在配置文件里的 `optimizer` 域。例如，如果您想使用 `ADAM`，尽管数值表现会掉点，还是可以如下修改：
+
+```python
+optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
+```
+
+使用者可以直接按照 PyTorch [文档教程](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) 去设置参数。
+
+## 定制优化器的构造器 (optimizer constructor)
+
+对于优化，一些模型可能会有一些特别定义的参数，例如 批归一化 (BatchNorm) 层里面的权重衰减 (weight decay)。
+使用者可以通过定制优化器的构造器来微调这些细粒度的优化器参数。
+
+```
+from mmcv.utils import build_from_cfg
+
+from mmcv.runner import OPTIMIZER_BUILDERS
+from .cocktail_optimizer import CocktailOptimizer
+
+
+@OPTIMIZER_BUILDERS.register_module
+class CocktailOptimizerConstructor(object):
+
+    def __init__(self, optimizer_cfg, paramwise_cfg=None):
+
+    def __call__(self, model):
+
+        return my_optimizer
+
+```
+
+## 开发新的组件
+
+MMSegmentation 里主要有2种组件：
+
+- 骨架 (backbone): 通常是卷积网络的堆叠，来做特征提取，例如 ResNet, HRNet。
+- 头 (head): 用于语义分割图的解码的组件。
+
+### 添加新的骨架
+
+这里我们以 MobileNet 为例，展示如何增加新的骨架组件：
+
+1. 创建一个新的文件 `mmseg/models/backbones/mobilenet.py`.
+
+```python
+import torch.nn as nn
+
+from ..registry import BACKBONES
+
+
+@BACKBONES.register_module
+class MobileNet(nn.Module):
+
+    def __init__(self, arg1, arg2):
+        pass
+
+    def forward(self, x):  # should return a tuple
+        pass
+
+    def init_weights(self, pretrained=None):
+        pass
+```
+
+2. 在 `mmseg/models/backbones/__init__.py` 里面导入模块。
+
+```python
+from .mobilenet import MobileNet
+```
+
+3. 在您的配置文件里使用它。
+
+```python
+model = dict(
+    ...
+    backbone=dict(
+        type='MobileNet',
+        arg1=xxx,
+        arg2=xxx),
+    ...
+```
+
+### 增加新的头组件
+
+在 MMSegmentation 里面，对于所有的分割头，我们提供一个基础的 [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/master/mmseg/models/decode_heads/decode_head.py) 。
+所有创新的解码头都应该由它生成。这里我们以 [PSPNet](https://arxiv.org/abs/1612.01105) 为例，
+展示如何开发一个新的头组件：
+
+首先，在 `mmseg/models/decode_heads/psp_head.py` 里添加一个新的解码头。
+PSPNet 为了语义分割的解码，已经设置了一个解码头，基于这个已有的解码头我们想添加如下包含3个函数的新模块：
+
+```python
+@HEADS.register_module()
+class PSPHead(BaseDecodeHead):
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super(PSPHead, self).__init__(**kwargs)
+
+    def init_weights(self):
+
+    def forward(self, inputs):
+
+```
+
+接着，使用者需要在 `mmseg/models/decode_heads/__init__.py` 里面添加这个模块，这样对应的注册表 (registry) 可以查找并加载它们。
+
+PSPNet的配置文件如下所示：
+
+```python
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoder',
+    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
+
+```
+
+### 增加新的损失函数
+
+假设您想添加一个新的损失函数 `MyLoss` 到语义分割解码器里。
+为了添加一个新的损失函数，使用者需要在 `mmseg/models/losses/my_loss.py` 里面去实施它。
+`weighted_loss` 可以对计算损失时的每个成分做加权。
+
+```python
+import torch
+import torch.nn as nn
+
+from ..builder import LOSSES
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+    assert pred.size() == target.size() and target.numel() > 0
+    loss = torch.abs(pred - target)
+    return loss
+
+@LOSSES.register_module
+class MyLoss(nn.Module):
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(MyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss = self.loss_weight * my_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss
+```
+
+然后使用者需要在 `mmseg/models/losses/__init__.py` 里面添加它：
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+为了使用它，修改 `loss_xxx` 域。之后您需要在头组件里修改 `loss_decode` 域。
+`loss_weight` 可以被用来对不同的损失函数做加权。
+
+```python
+loss_decode=dict(type='MyLoss', loss_weight=1.0))
+```

From faec079cfdf83d3661540af1ab78392d3a524c30 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Wed, 23 Jun 2021 16:24:00 +0800
Subject: [PATCH 14/17] cus_model

---
 docs_zh-CN/tutorials/data_pipeline.md | 81 ++++++++++++++-------------
 1 file changed, 43 insertions(+), 38 deletions(-)

diff --git a/docs_zh-CN/tutorials/data_pipeline.md b/docs_zh-CN/tutorials/data_pipeline.md
index 9285db90be..1eecfe91d4 100644
--- a/docs_zh-CN/tutorials/data_pipeline.md
+++ b/docs_zh-CN/tutorials/data_pipeline.md
@@ -1,17 +1,22 @@
-# 教程 3: 自定义数据流程
+# Tutorial 3: Customize Data Pipelines
 
-## 设计数据流程
+## Design of Data pipelines
 
-按照通常的惯例，我们使用`Dataset` 和 `DataLoader` 做多线程的数据加载。`Dataset` 返回一个数据内容的字典，里面对应于模型前传方法的各个参数。
-因为语义分割里的数据可能不是相同的大小尺寸，我们在 MMCV 里引入一个新的 `DataContainer` 类别去帮助收集和分发不同大小的输入数据。
+Following typical conventions, we use `Dataset` and `DataLoader` for data loading
+with multiple workers. `Dataset` returns a dict of data items corresponding
+the arguments of models' forward method.
+Since the data in semantic segmentation may not be the same size,
+we introduce a new `DataContainer` type in MMCV to help collect and distribute
+data of different size.
+See [here](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py) for more details.
 
-更多细节，请查看[这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py).
+The data preparation pipeline and the dataset is decomposed. Usually a dataset
+defines how to process the annotations and a data pipeline defines all the steps to prepare a data dict.
+A pipeline consists of a sequence of operations. Each operation takes a dict as input and also output a dict for the next transform.
 
-数据的准备流程和数据集是解耦的。通常一个数据集定义了如何处理注释信息，而一个数据流程定义了准备一个数据字典的所有步骤。一个流程包括了一系列操作，每个操作里都把一个字典作为输入，然后再输出一个新的字典给下一个变换操作。
+The operations are categorized into data loading, pre-processing, formatting and test-time augmentation.
 
-这些操作可分为数据加载 (data loading)，预处理 (pre-processing)，格式变化 (formatting) 和测试时数据增强 (test-time augmentation) 。
-
-下面的例子就是 PSPNet 的一个流程:
+Here is an pipeline example for PSPNet.
 
 ```python
 img_norm_cfg = dict(
@@ -46,86 +51,86 @@ test_pipeline = [
 ]
 ```
 
-对于每个操作，我们列出它添加、更新、移除的相关字典域 (dict fields)：
+For each operation, we list the related dict fields that are added/updated/removed.
 
-### 数据加载 Data loading
+### Data loading
 
 `LoadImageFromFile`
 
-- 增加: img, img_shape, ori_shape
+- add: img, img_shape, ori_shape
 
 `LoadAnnotations`
 
-- 增加: gt_semantic_seg, seg_fields
+- add: gt_semantic_seg, seg_fields
 
-### 预处理 Pre-processing
+### Pre-processing
 
 `Resize`
 
-- 增加: scale, scale_idx, pad_shape, scale_factor, keep_ratio
-- 更新: img, img_shape, *seg_fields
+- add: scale, scale_idx, pad_shape, scale_factor, keep_ratio
+- update: img, img_shape, *seg_fields
 
 `RandomFlip`
 
-- 增加: flip
-- 更新: img, *seg_fields
+- add: flip
+- update: img, *seg_fields
 
 `Pad`
 
-- 增加: pad_fixed_size, pad_size_divisor
-- 更新: img, pad_shape, *seg_fields
+- add: pad_fixed_size, pad_size_divisor
+- update: img, pad_shape, *seg_fields
 
 `RandomCrop`
 
-- 更新: img, pad_shape, *seg_fields
+- update: img, pad_shape, *seg_fields
 
 `Normalize`
 
-- 增加: img_norm_cfg
-- 更新: img
+- add: img_norm_cfg
+- update: img
 
 `SegRescale`
 
-- 更新: gt_semantic_seg
+- update: gt_semantic_seg
 
 `PhotoMetricDistortion`
 
-- 更新: img
+- update: img
 
-### 格式 Formatting
+### Formatting
 
 `ToTensor`
 
-- 更新: 由 `keys` 指定.
+- update: specified by `keys`.
 
 `ImageToTensor`
 
-- 更新: 由 `keys` 指定.
+- update: specified by `keys`.
 
 `Transpose`
 
-- 更新: 由 `keys` 指定.
+- update: specified by `keys`.
 
 `ToDataContainer`
 
-- 更新: 由 `keys` 指定.
+- update: specified by `fields`.
 
 `DefaultFormatBundle`
 
-- 更新: img, gt_semantic_seg
+- update: img, gt_semantic_seg
 
 `Collect`
 
-- 增加: img_meta (the keys of img_meta is specified by `meta_keys`)
-- 移除: all other keys except for those specified by `keys`
+- add: img_meta (the keys of img_meta is specified by `meta_keys`)
+- remove: all other keys except for those specified by `keys`
 
-### 测试时数据增强 Test time augmentation
+### Test time augmentation
 
 `MultiScaleFlipAug`
 
-## 拓展和使用自定义的流程
+## Extend and use custom pipelines
 
-1. 在任何一个文件里写一个新的流程，例如 `my_pipeline.py`。它以一个字典作为输入并且输出一个字典。
+1. Write a new pipeline in any file, e.g., `my_pipeline.py`. It takes a dict as input and return a dict.
 
     ```python
     from mmseg.datasets import PIPELINES
@@ -138,13 +143,13 @@ test_pipeline = [
             return results
     ```
 
-2. 导入一个新类
+2. Import the new class.
 
     ```python
     from .my_pipeline import MyTransform
     ```
 
-3. 在配置文件里使用它
+3. Use it in config files.
 
     ```python
     img_norm_cfg = dict(

From fb7ef563e6b2c09fc7eef97c6ada1a08fc438745 Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Wed, 23 Jun 2021 16:25:31 +0800
Subject: [PATCH 15/17] cus_model

---
 docs_zh-CN/tutorials/data_pipeline.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs_zh-CN/tutorials/data_pipeline.md b/docs_zh-CN/tutorials/data_pipeline.md
index 1eecfe91d4..6ec54982cd 100644
--- a/docs_zh-CN/tutorials/data_pipeline.md
+++ b/docs_zh-CN/tutorials/data_pipeline.md
@@ -1,4 +1,4 @@
-# Tutorial 3: Customize Data Pipelines
+# 教程 3: 自定义数据流程
 
 ## Design of Data pipelines
 

From 6b4d9fa06080efaa8b4dc22f6ecd9f1cdf686dcf Mon Sep 17 00:00:00 2001
From: MengzhangLI <mcmong@pku.edu.cn>
Date: Thu, 24 Jun 2021 21:18:27 +0800
Subject: [PATCH 16/17] runtime_md

---
 docs_zh-CN/tutorials/customize_models.md  | 229 --------------------
 docs_zh-CN/tutorials/customize_runtime.md | 245 ++++++++++++++++++++++
 2 files changed, 245 insertions(+), 229 deletions(-)

diff --git a/docs_zh-CN/tutorials/customize_models.md b/docs_zh-CN/tutorials/customize_models.md
index 299e231fc1..11a0325497 100644
--- a/docs_zh-CN/tutorials/customize_models.md
+++ b/docs_zh-CN/tutorials/customize_models.md
@@ -1,230 +1 @@
 # 教程 4: 自定义模型
-
-## 自定义优化器 (optimizer)
-
-假设您想增加一个新的叫 `MyOptimizer` 的优化器，它的参数分别为 `a`, `b`, 和 `c`。
-您首先需要在一个文件里实施这个新优化器，例如在 `mmseg/core/optimizer/my_optimizer.py` 里面：
-
-```python
-from mmcv.runner import OPTIMIZERS
-from torch.optim import Optimizer
-
-
-@OPTIMIZERS.register_module
-class MyOptimizer(Optimizer):
-
-    def __init__(self, a, b, c)
-
-```
-
-然后增加这个模块到 `mmseg/core/optimizer/__init__.py` 里面，这样注册表 (registry) 将会发现这个新的模块并添加它：
-
-```python
-from .my_optimizer import MyOptimizer
-```
-
-之后您可以在配置文件的 `optimizer` 域里使用 `MyOptimizer`，
-如下所示，在配置文件里，优化器被 `optimizer` 域所定义：
-
-```python
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
-```
-
-为了使用您自己的优化器，域可以被修改为：
-
-```python
-optimizer = dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)
-```
-
-我们已经支持了 PyTorch 自带的全部优化器，唯一修改的地方是在配置文件里的 `optimizer` 域。例如，如果您想使用 `ADAM`，尽管数值表现会掉点，还是可以如下修改：
-
-```python
-optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
-```
-
-使用者可以直接按照 PyTorch [文档教程](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) 去设置参数。
-
-## 定制优化器的构造器 (optimizer constructor)
-
-对于优化，一些模型可能会有一些特别定义的参数，例如 批归一化 (BatchNorm) 层里面的权重衰减 (weight decay)。
-使用者可以通过定制优化器的构造器来微调这些细粒度的优化器参数。
-
-```
-from mmcv.utils import build_from_cfg
-
-from mmcv.runner import OPTIMIZER_BUILDERS
-from .cocktail_optimizer import CocktailOptimizer
-
-
-@OPTIMIZER_BUILDERS.register_module
-class CocktailOptimizerConstructor(object):
-
-    def __init__(self, optimizer_cfg, paramwise_cfg=None):
-
-    def __call__(self, model):
-
-        return my_optimizer
-
-```
-
-## 开发新的组件
-
-MMSegmentation 里主要有2种组件：
-
-- 骨架 (backbone): 通常是卷积网络的堆叠，来做特征提取，例如 ResNet, HRNet。
-- 头 (head): 用于语义分割图的解码的组件。
-
-### 添加新的骨架
-
-这里我们以 MobileNet 为例，展示如何增加新的骨架组件：
-
-1. 创建一个新的文件 `mmseg/models/backbones/mobilenet.py`.
-
-```python
-import torch.nn as nn
-
-from ..registry import BACKBONES
-
-
-@BACKBONES.register_module
-class MobileNet(nn.Module):
-
-    def __init__(self, arg1, arg2):
-        pass
-
-    def forward(self, x):  # should return a tuple
-        pass
-
-    def init_weights(self, pretrained=None):
-        pass
-```
-
-2. 在 `mmseg/models/backbones/__init__.py` 里面导入模块。
-
-```python
-from .mobilenet import MobileNet
-```
-
-3. 在您的配置文件里使用它。
-
-```python
-model = dict(
-    ...
-    backbone=dict(
-        type='MobileNet',
-        arg1=xxx,
-        arg2=xxx),
-    ...
-```
-
-### 增加新的头组件
-
-在 MMSegmentation 里面，对于所有的分割头，我们提供一个基础的 [BaseDecodeHead](https://github.com/open-mmlab/mmsegmentation/blob/master/mmseg/models/decode_heads/decode_head.py) 。
-所有创新的解码头都应该由它生成。这里我们以 [PSPNet](https://arxiv.org/abs/1612.01105) 为例，
-展示如何开发一个新的头组件：
-
-首先，在 `mmseg/models/decode_heads/psp_head.py` 里添加一个新的解码头。
-PSPNet 为了语义分割的解码，已经设置了一个解码头，基于这个已有的解码头我们想添加如下包含3个函数的新模块：
-
-```python
-@HEADS.register_module()
-class PSPHead(BaseDecodeHead):
-
-    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
-        super(PSPHead, self).__init__(**kwargs)
-
-    def init_weights(self):
-
-    def forward(self, inputs):
-
-```
-
-接着，使用者需要在 `mmseg/models/decode_heads/__init__.py` 里面添加这个模块，这样对应的注册表 (registry) 可以查找并加载它们。
-
-PSPNet的配置文件如下所示：
-
-```python
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
-    type='EncoderDecoder',
-    pretrained='pretrain_model/resnet50_v1c_trick-2cccc1ad.pth',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        dilations=(1, 1, 2, 4),
-        strides=(1, 2, 1, 1),
-        norm_cfg=norm_cfg,
-        norm_eval=False,
-        style='pytorch',
-        contract_dilation=True),
-    decode_head=dict(
-        type='PSPHead',
-        in_channels=2048,
-        in_index=3,
-        channels=512,
-        pool_scales=(1, 2, 3, 6),
-        dropout_ratio=0.1,
-        num_classes=19,
-        norm_cfg=norm_cfg,
-        align_corners=False,
-        loss_decode=dict(
-            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)))
-
-```
-
-### 增加新的损失函数
-
-假设您想添加一个新的损失函数 `MyLoss` 到语义分割解码器里。
-为了添加一个新的损失函数，使用者需要在 `mmseg/models/losses/my_loss.py` 里面去实施它。
-`weighted_loss` 可以对计算损失时的每个成分做加权。
-
-```python
-import torch
-import torch.nn as nn
-
-from ..builder import LOSSES
-from .utils import weighted_loss
-
-@weighted_loss
-def my_loss(pred, target):
-    assert pred.size() == target.size() and target.numel() > 0
-    loss = torch.abs(pred - target)
-    return loss
-
-@LOSSES.register_module
-class MyLoss(nn.Module):
-
-    def __init__(self, reduction='mean', loss_weight=1.0):
-        super(MyLoss, self).__init__()
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None):
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss = self.loss_weight * my_loss(
-            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
-        return loss
-```
-
-然后使用者需要在 `mmseg/models/losses/__init__.py` 里面添加它：
-
-```python
-from .my_loss import MyLoss, my_loss
-
-```
-
-为了使用它，修改 `loss_xxx` 域。之后您需要在头组件里修改 `loss_decode` 域。
-`loss_weight` 可以被用来对不同的损失函数做加权。
-
-```python
-loss_decode=dict(type='MyLoss', loss_weight=1.0))
-```
diff --git a/docs_zh-CN/tutorials/customize_runtime.md b/docs_zh-CN/tutorials/customize_runtime.md
index e13a6b3dd1..5f21f08767 100644
--- a/docs_zh-CN/tutorials/customize_runtime.md
+++ b/docs_zh-CN/tutorials/customize_runtime.md
@@ -1 +1,246 @@
 # 教程 6: 自定义运行设定
+
+## 自定义优化设定
+
+### 自定义 PyTorch 支持的优化器
+
+我们已经支持 PyTorch 自带的所有优化器，唯一需要修改的地方是在配置文件里的 `optimizer` 域里面。
+例如，如果您想使用 `ADAM` (注意如下操作可能会让模型表现下降)，可以使用如下修改：
+
+```python
+optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
+```
+
+为了修改模型的学习率，使用者仅需要修改配置文件里 optimizer 的 `lr` 即可。
+使用者可以参照 PyTorch 的 [API 文档](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim)
+直接设置参数。
+
+### 自定义 自己实现的优化器
+
+#### 1. 定义一个新的优化器
+
+一个自定义的优化器可以按照如下去定义：
+
+假如您想增加一个叫做 `MyOptimizer` 的优化器，它的参数分别有 `a`, `b`, 和 `c`。
+您需要创建一个叫 `mmseg/core/optimizer` 的新文件夹。
+然后再在文件，即  `mmseg/core/optimizer/my_optimizer.py` 里面去实行这个新优化器：
+
+```python
+from .registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+
+```
+
+#### 2. 增加优化器到注册表 (registry)
+
+为了让上述定义的模块被框架发现，首先这个模块应该被导入到主命名空间 (main namespace) 里。
+有两种方式可以实现它。
+
+- 修改 `mmseg/core/optimizer/__init__.py` 来导入它。
+
+    新的被定义的模块应该被导入到 `mmseg/core/optimizer/__init__.py` 这样注册表将会发现新的模块并添加它。
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件里使用 `custom_imports` 去手动添加它。
+
+```python
+custom_imports = dict(imports=['mmseg.core.optimizer.my_optimizer'], allow_failed_imports=False)
+```
+
+`mmseg.core.optimizer.my_optimizer` 模块将会在程序运行的开始被导入，并且 `MyOptimizer` 类将会自动注册。
+需要注意只有包含 `MyOptimizer`  类的包 (package) 应当被导入。
+而 `mmseg.core.optimizer.my_optimizer.MyOptimizer` **不能** 被直接导入。
+
+事实上，使用者完全可以用另一个按这样导入方法的文件夹结构，只要模块的根路径已经被设置到 `PYTHONPATH` 里面。
+
+#### 3. 在配置文件里定义优化器
+
+之后您可以在配置文件的 `optimizer` 域里面使用 `MyOptimizer`
+在配置文件里，优化器被定义在 `optimizer` 域里，如下所示：
+
+```python
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+```
+
+为了使用您自己的优化器，这个域可以被改成：
+
+```python
+optimizer = dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value)
+```
+
+### 自定义优化器的构造器 (constructor)
+
+有些模型可能需要在优化器里有一些特别参数的设置，例如 批归一化层 (BatchNorm layers) 的 权重衰减 (weight decay)。
+使用者可以通过自定义优化器的构造器去微调这些细粒度参数。
+
+```python
+from mmcv.utils import build_from_cfg
+
+from mmcv.runner.optimizer import OPTIMIZER_BUILDERS, OPTIMIZERS
+from mmseg.utils import get_root_logger
+from .my_optimizer import MyOptimizer
+
+
+@OPTIMIZER_BUILDERS.register_module()
+class MyOptimizerConstructor(object):
+
+    def __init__(self, optimizer_cfg, paramwise_cfg=None):
+
+    def __call__(self, model):
+
+        return my_optimizer
+
+```
+
+默认的优化器构造器的实施可以参照 [这里](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/optimizer/default_constructor.py#L11) ，它也可以被用作新的优化器构造器的模板。
+
+### 额外的设置
+
+优化器没有实施的一些技巧应该通过优化器构造器 (optimizer constructor) 或者钩 (hook) 去实施，如设置基于参数的学习率 (parameter-wise learning rates)。我们列出一些常见的设置，它们可以稳定或加速模型的训练。
+如果您有更多的设置，欢迎在 PR 和 issue 里面提交。
+
+- __使用梯度截断 (gradient clip) 去稳定训练__:
+    一些模型需要梯度截断去稳定训练过程，如下所示：
+
+    ```python
+    optimizer_config = dict(
+        _delete_=True, grad_clip=dict(max_norm=35, norm_type=2))
+    ```
+
+    如果您的配置继承自已经设置了  `optimizer_config` 的基础配置 (base config)，您可能需要 `_delete_=True` 来重写那些不需要的设置。更多细节请参照 [配置文件文档](https://mmsegmentation.readthedocs.io/en/latest/config.html) 。
+
+- __使用动量计划表 (momentum schedule) 去加速模型收敛__:
+    我们支持动量计划表去让模型基于学习率修改动量，这样可能让模型收敛地更快。
+    动量计划表经常和学习率计划表 (LR scheduler) 一起使用，例如如下配置文件就在 3D 检测里经常使用以加速收敛。
+    更多细节请参考 [CyclicLrUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327) 和 [CyclicMomentumUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130) 的实施。
+
+    ```python
+    lr_config = dict(
+        policy='cyclic',
+        target_ratio=(10, 1e-4),
+        cyclic_times=1,
+        step_ratio_up=0.4,
+    )
+    momentum_config = dict(
+        policy='cyclic',
+        target_ratio=(0.85 / 0.95, 1),
+        cyclic_times=1,
+        step_ratio_up=0.4,
+    )
+    ```
+
+## 自定义训练计划表
+
+我们根据默认的训练迭代步数 40k/80k 来设置学习率，这在 MMCV 里叫做 [`PolyLrUpdaterHook`](https://github.com/open-mmlab/mmcv/blob/826d3a7b68596c824fa1e2cb89b6ac274f52179c/mmcv/runner/hooks/lr_updater.py#L196) 。
+我们也支持许多其他的学习率计划表：[这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/lr_updater.py) ，例如 `CosineAnnealing` 和 `Poly` 计划表。下面是一些例子：
+
+- 步计划表 Step schedule:
+
+    ```python
+    lr_config = dict(policy='step', step=[9, 10])
+    ```
+
+- 余弦退火计划表 ConsineAnnealing schedule:
+
+    ```python
+    lr_config = dict(
+        policy='CosineAnnealing',
+        warmup='linear',
+        warmup_iters=1000,
+        warmup_ratio=1.0 / 10,
+        min_lr_ratio=1e-5)
+    ```
+
+## 自定义工作流 (workflow)
+
+工作流是一个专门定义运行阶数和轮数 (running order and epochs) 的阶段或轮数 (phase, epochs) 的列表。
+默认情况下它设置成：
+
+```python
+workflow = [('train', 1)]
+```
+
+意思是训练是跑 1 个 epoch。有时候使用者可能想检查模型在验证集上的一些指标（如 损失 loss，精确性 accuracy），我们可以这样设置工作流：
+
+```python
+[('train', 1), ('val', 1)]
+```
+
+于是 1 个 epoch 训练，1 个 epoch 验证将交替运行。
+
+**注意**:
+
+1. 模型的参数在验证的阶段不会被自动更新。
+2. 配置文件里的关键词 `total_epochs` 仅控制训练的 epochs 数目，而不会影响验证时的工作流。
+3. 工作流 `[('train', 1), ('val', 1)]` 和 `[('train', 1)]` 将不会改变 `EvalHook` 的行为，因为 `EvalHook` 被 `after_train_epoch`
+   召唤而且验证的工作流仅仅影响通过 `after_val_epoch` 召唤的钩 (hooks)。因此， `[('train', 1), ('val', 1)]` 和 `[('train', 1)]`
+    的区别仅在于 runner 将在每次训练 epoch 结束后计算在验证集上的损失。
+
+## 自定义钩 (hooks)
+
+### 使用 MMCV 实施的 钩 (hooks)
+
+如果钩已经在 MMCV 里被实施，如下所示，您可以直接修改配置文件来使用钩：
+
+```python
+custom_hooks = [
+    dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+### 修改默认的运行时间钩 (runtime hooks)
+
+以下的常用的钩没有被 `custom_hooks` 注册：
+
+- log_config
+- checkpoint_config
+- evaluation
+- lr_config
+- optimizer_config
+- momentum_config
+
+在这些钩里，只有 logger hook 有 `VERY_LOW` 优先级，其他的优先级都是 `NORMAL`。
+上述提及的教程已经包括了如何修改 `optimizer_config`，`momentum_config` 和 `lr_config`。
+这里我们展示我们如何处理 `log_config`， `checkpoint_config` 和 `evaluation`。
+
+#### 检查点配置文件 (Checkpoint config)
+
+MMCV runner 将使用 `checkpoint_config` 去初始化 [`CheckpointHook`](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/hooks/checkpoint.py#L9).
+
+```python
+checkpoint_config = dict(interval=1)
+```
+
+使用者可以设置 `max_keep_ckpts` 来仅保存一小部分检查点或者通过 `save_optimizer` 来决定是否保存优化器的状态字典 (state dict of optimizer)。 更多使用参数的细节请参考 [这里](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.CheckpointHook) 。
+
+#### 日志配置文件 (Log config)
+
+`log_config` 包裹了许多日志钩 (logger hooks) 而且能去设置间隔 (intervals)。现在 MMCV 支持 `WandbLoggerHook`， `MlflowLoggerHook` 和 `TensorboardLoggerHook`。
+详细的使用请参照 [文档](https://mmcv.readthedocs.io/en/latest/api.html#mmcv.runner.LoggerHook) 。
+
+```python
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook')
+    ])
+```
+
+#### 评估配置文件 (Evaluation config)
+
+`evaluation` 的配置文件将被用来初始化 [`EvalHook`](https://github.com/open-mmlab/mmsegmentation/blob/e3f6f655d69b777341aec2fe8829871cc0beadcb/mmseg/core/evaluation/eval_hooks.py#L7) 。
+除了 `interval` 键，其他的像 `metric` 这样的参数将被传递给 `dataset.evaluate()` 。
+
+```python
+evaluation = dict(interval=1, metric='mIoU')
+```

From 3022fbd0a3a33b258af8727ca6505a53e7e7d5f8 Mon Sep 17 00:00:00 2001
From: Junjun2016 <hejunjun@sjtu.edu.cn>
Date: Fri, 2 Jul 2021 22:59:53 +0800
Subject: [PATCH 17/17] Update customize_runtime.md

---
 docs_zh-CN/tutorials/customize_runtime.md | 26 +++++++++++------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/docs_zh-CN/tutorials/customize_runtime.md b/docs_zh-CN/tutorials/customize_runtime.md
index 5f21f08767..f67dd00b8a 100644
--- a/docs_zh-CN/tutorials/customize_runtime.md
+++ b/docs_zh-CN/tutorials/customize_runtime.md
@@ -23,7 +23,7 @@ optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
 
 假如您想增加一个叫做 `MyOptimizer` 的优化器，它的参数分别有 `a`, `b`, 和 `c`。
 您需要创建一个叫 `mmseg/core/optimizer` 的新文件夹。
-然后再在文件，即  `mmseg/core/optimizer/my_optimizer.py` 里面去实行这个新优化器：
+然后再在文件，即  `mmseg/core/optimizer/my_optimizer.py` 里面去实现这个新优化器：
 
 ```python
 from .registry import OPTIMIZERS
@@ -50,7 +50,7 @@ class MyOptimizer(Optimizer):
 from .my_optimizer import MyOptimizer
 ```
 
-- 在配置文件里使用 `custom_imports` 去手动添加它。
+- 在配置文件里使用 `custom_imports` 去手动导入它。
 
 ```python
 custom_imports = dict(imports=['mmseg.core.optimizer.my_optimizer'], allow_failed_imports=False)
@@ -60,7 +60,7 @@ custom_imports = dict(imports=['mmseg.core.optimizer.my_optimizer'], allow_faile
 需要注意只有包含 `MyOptimizer`  类的包 (package) 应当被导入。
 而 `mmseg.core.optimizer.my_optimizer.MyOptimizer` **不能** 被直接导入。
 
-事实上，使用者完全可以用另一个按这样导入方法的文件夹结构，只要模块的根路径已经被设置到 `PYTHONPATH` 里面。
+事实上，使用者完全可以用另一个按这样导入方法的文件夹结构，只要模块的根路径已经被添加到 `PYTHONPATH` 里面。
 
 #### 3. 在配置文件里定义优化器
 
@@ -101,11 +101,11 @@ class MyOptimizerConstructor(object):
 
 ```
 
-默认的优化器构造器的实施可以参照 [这里](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/optimizer/default_constructor.py#L11) ，它也可以被用作新的优化器构造器的模板。
+默认的优化器构造器的实现可以参照 [这里](https://github.com/open-mmlab/mmcv/blob/9ecd6b0d5ff9d2172c49a182eaa669e9f27bb8e7/mmcv/runner/optimizer/default_constructor.py#L11) ，它也可以被用作新的优化器构造器的模板。
 
 ### 额外的设置
 
-优化器没有实施的一些技巧应该通过优化器构造器 (optimizer constructor) 或者钩 (hook) 去实施，如设置基于参数的学习率 (parameter-wise learning rates)。我们列出一些常见的设置，它们可以稳定或加速模型的训练。
+优化器没有实现的一些技巧应该通过优化器构造器 (optimizer constructor) 或者钩子 (hook) 去实现，如设置基于参数的学习率 (parameter-wise learning rates)。我们列出一些常见的设置，它们可以稳定或加速模型的训练。
 如果您有更多的设置，欢迎在 PR 和 issue 里面提交。
 
 - __使用梯度截断 (gradient clip) 去稳定训练__:
@@ -121,7 +121,7 @@ class MyOptimizerConstructor(object):
 - __使用动量计划表 (momentum schedule) 去加速模型收敛__:
     我们支持动量计划表去让模型基于学习率修改动量，这样可能让模型收敛地更快。
     动量计划表经常和学习率计划表 (LR scheduler) 一起使用，例如如下配置文件就在 3D 检测里经常使用以加速收敛。
-    更多细节请参考 [CyclicLrUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327) 和 [CyclicMomentumUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130) 的实施。
+    更多细节请参考 [CyclicLrUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327) 和 [CyclicMomentumUpdater](https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130) 的实现。
 
     ```python
     lr_config = dict(
@@ -162,7 +162,7 @@ class MyOptimizerConstructor(object):
 
 ## 自定义工作流 (workflow)
 
-工作流是一个专门定义运行阶数和轮数 (running order and epochs) 的阶段或轮数 (phase, epochs) 的列表。
+工作流是一个专门定义运行顺序和轮数 (running order and epochs) 的列表 (phase, epochs)。
 默认情况下它设置成：
 
 ```python
@@ -182,14 +182,14 @@ workflow = [('train', 1)]
 1. 模型的参数在验证的阶段不会被自动更新。
 2. 配置文件里的关键词 `total_epochs` 仅控制训练的 epochs 数目，而不会影响验证时的工作流。
 3. 工作流 `[('train', 1), ('val', 1)]` 和 `[('train', 1)]` 将不会改变 `EvalHook` 的行为，因为 `EvalHook` 被 `after_train_epoch`
-   召唤而且验证的工作流仅仅影响通过 `after_val_epoch` 召唤的钩 (hooks)。因此， `[('train', 1), ('val', 1)]` 和 `[('train', 1)]`
+   调用而且验证的工作流仅仅影响通过调用 `after_val_epoch` 的钩子 (hooks)。因此， `[('train', 1), ('val', 1)]` 和 `[('train', 1)]`
     的区别仅在于 runner 将在每次训练 epoch 结束后计算在验证集上的损失。
 
 ## 自定义钩 (hooks)
 
-### 使用 MMCV 实施的 钩 (hooks)
+### 使用 MMCV 实现的钩子 (hooks)
 
-如果钩已经在 MMCV 里被实施，如下所示，您可以直接修改配置文件来使用钩：
+如果钩子已经在 MMCV 里被实现，如下所示，您可以直接修改配置文件来使用钩子：
 
 ```python
 custom_hooks = [
@@ -197,9 +197,9 @@ custom_hooks = [
 ]
 ```
 
-### 修改默认的运行时间钩 (runtime hooks)
+### 修改默认的运行时间钩子 (runtime hooks)
 
-以下的常用的钩没有被 `custom_hooks` 注册：
+以下的常用的钩子没有被 `custom_hooks` 注册：
 
 - log_config
 - checkpoint_config
@@ -208,7 +208,7 @@ custom_hooks = [
 - optimizer_config
 - momentum_config
 
-在这些钩里，只有 logger hook 有 `VERY_LOW` 优先级，其他的优先级都是 `NORMAL`。
+在这些钩子里，只有 logger hook 有 `VERY_LOW` 优先级，其他的优先级都是 `NORMAL`。
 上述提及的教程已经包括了如何修改 `optimizer_config`，`momentum_config` 和 `lr_config`。
 这里我们展示我们如何处理 `log_config`， `checkpoint_config` 和 `evaluation`。