Merge pull request #15 from hpcaitech/feature/zhdoc

made some modifications to the documents

README.md

-# ColossalAI
+# Colossal-AI
 
 An integrated large-scale model training system with efficient parallelization techniques.
 
-arXiv: [Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training](https://arxiv.org/abs/2110.14883)
+Paper: [Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training](https://arxiv.org/abs/2110.14883)
+
+Blog: [Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training](https://www.hpcaitech.com/blog)
 
 ## Installation
 
@@ -91,16 +93,25 @@ class MLP_2D(nn.Module):
 
 ## Features
 
-ColossalAI provides a collection of parallel training components for you. We aim to support you to write your
+Colossal-AI provides a collection of parallel training components for you. We aim to support you to write your
 distributed deep learning models just like how you write your single-GPU model. We provide friendly tools to kickstart
 distributed training in a few lines.
 
 - [Data Parallelism](./docs/parallelization.md)
 - [Pipeline Parallelism](./docs/parallelization.md)
 - [1D, 2D, 2.5D, 3D and sequence parallelism](./docs/parallelization.md)
-- [friendly trainer and engine](./docs/trainer_engine.md)
+- [Friendly trainer and engine](./docs/trainer_engine.md)
 - [Extensible for new parallelism](./docs/add_your_parallel.md)
 - [Mixed Precision Training](./docs/amp.md)
 - [Zero Redundancy Optimizer (ZeRO)](./docs/zero.md)
 
+## Cite Us
 
+```
+@article{bian2021colossal,
+  title={Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training},
+  author={Bian, Zhengda and Liu, Hongxin and Wang, Boxiang and Huang, Haichen and Li, Yongbin and Wang, Chuanrui and Cui, Fan and You, Yang},
+  journal={arXiv preprint arXiv:2110.14883},
+  year={2021}
+}
+```

docs/add_your_parallel.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-To enable researchers and engineers to extend our framework to other novel large-scale distributed training algorithm
+To enable researchers and engineers to extend our system to other novel large-scale distributed training algorithm
 with less effort, we have decoupled various components in the training lifecycle. You can implement your own
 parallelism by simply inheriting from the base class.
 
@@ -15,7 +15,7 @@ The main components are:
 ## Process Group Initializer
 
 Parallelism is often managed by process groups where processes involved in the same parallel algorithm are placed in the same
-process group. For different parallel algorithms, different process groups need to be created. ColossalAI provides a
+process group. For different parallel algorithms, different process groups need to be created. Colossal-AI provides a
 global context for users to easily manage their process groups. If you wish to add new process group, you can easily
 define a new class and set it in your configuration file. To define your own way of creating process groups, you can
 follow the steps below to create a new distributed initialization.
@@ -110,7 +110,7 @@ dist_initializer = [
 
 ## Schedule
 
-Schedule entails how to execute a forward and backward pass. Currently, ColossalAI provides pipeline and non-pipeline
+Schedule entails how to execute a forward and backward pass. Currently, Colossal-AI provides pipeline and non-pipeline
 schedules. If you want to modify how the forward and backward passes are executed, you can
 inherit `colossalai.engine.BaseSchedule` and implement your idea. You can also add your schedule to the engine before
 training.
\ No newline at end of file

docs/add_your_parallel_zh.md

 # 添加新的并行技术
 
-为了方便科研人员和工程师们更方便地拓展我们的框架来兼容一些新的大规模分布式训练算法，我们对训练过程中的几个组件进行了解耦，您可以通过继承基类的方式
-来实现新的并行技术。
+为了方便科研人员和工程师们更方便地拓展我们的系统来兼容一些新的大规模分布式训练算法，我们对训练过程中的几个组件进行了解耦，您可以通过继承基类的方式来实现新的并行技术。
 
 主要的组件如下所示：
 
@@ -11,9 +10,7 @@
 
 ## 进程组初始化器
 
-并行化一般是通过进程组来进行管理的，同属于一个并行化算法的进程将被分到一个进程组中，如果系统中存在多种不同的并行化技术，那么需要创建多个不同的进程组。
-ColossalAI为用户提供了一个全局上下文变量来便捷地管理他们的进程组。如果您希望增加新的进程组，您可以定义一个新的类并且在您的配置文件中进行设置。下方的
-代码块中介绍了如果在系统中加入您的新并行技术以及如何进行初始化。
+并行化一般是通过进程组来进行管理的，同属于一个并行化算法的进程将被分到一个进程组中，如果系统中存在多种不同的并行化技术，那么需要创建多个不同的进程组。Colossal-AI为用户提供了一个全局上下文变量来便捷地管理他们的进程组。如果您希望增加新的进程组，您可以定义一个新的类并且在您的配置文件中进行设置。下方的代码块介绍了如何在系统中加入您的新颖并行技术以及如何进行初始化。
 
 1. 在`colossalai.context.parallel_mode.ParallelMode`中添加新的并行模式。
 ```python
@@ -28,9 +25,7 @@ class ParallelMode(Enum):
     NEW_MODE = 'new_mode'  # define your mode here
 ```
 
-2. 创建一个`ProcessGroupInitializer`的子类，您可以参考`colossalai.context.dist_group_initializer`中给出的例子。前六个参数将由`ParallelContext`
-决定。如果您需要设置新的参数，您可以用新的参数替换下面例子中的`arg1`与`arg2`。最后，您需要使用`@DIST_GROUP_INITIALIZER.register_module`装饰器
-在我们的注册表注册您的初始化器。
+2. 创建一个`ProcessGroupInitializer`的子类，您可以参考`colossalai.context.dist_group_initializer`中给出的例子。前六个参数将由`ParallelContext`决定。如果您需要设置新的参数，您可以用新的参数替换下面例子中的`arg1`与`arg2`。最后，您需要使用`@DIST_GROUP_INITIALIZER.register_module`装饰器在我们的注册表中注册您的初始化器。
 ```python
 # sample initializer class
 @DIST_GROUP_INITIALIZER.register_module
@@ -55,14 +50,13 @@ class MyParallelInitializer(ProcessGroupInitializer):
         pass
 ```
 
-在此之后，您可以将您的初始化器插入到当前的mode-to-initialize映射`colossalai.constants.INITIALIZER_MAPPING`中，您也可以通过更改该文件来动态变更名称与
-并行模式的映射。
+在此之后，您可以将您的初始化器插入到当前的mode-to-initialize映射`colossalai.constants.INITIALIZER_MAPPING`中，您也可以通过更改该文件来动态变更名称与并行模式的映射。
 
 ```python
 colossalai.constants.INITIALIZER_MAPPING['new_mode'] = 'MyParallelInitializer'
 ```
 
-3. 在配置文件中设置您的初始化器，如果您的初始化器需要参数，您可以自行传入，下面的代码可以让`ParallelContext`来创建您的初始化器并初始化您需要的进程组。
+3. 在配置文件中设置您的初始化器。如果您的初始化器需要参数，您可以自行传入。下面的代码可以让`ParallelContext`来创建您的初始化器并初始化您需要的进程组。
 
 ```python
 parallel = dict(
@@ -73,9 +67,7 @@ parallel = dict(
 
 ## 梯度处理器
 
-梯度处理器的功能是对模型参数的梯度进行all-reduce操作。由于不同的并行技术可能需要不同的all-reduce操作，用户们可以通过继承
-`colossalai.engine.gradient_handler.BaseGradientHandler`来执行其个性化操作。目前，ColossalAI使用普通的数据并行梯度处理器，该处理器在所有的数据
-并行rank上执行all-reduce操作，且当ColossalAI监测到当前系统使用了数据并行时，该处理器会被自动创建。您可以使用下方代码块中的代码添加您自定义的梯度处理器：
+梯度处理器的功能是对模型参数的梯度进行all-reduce操作。由于不同的并行技术可能需要不同的all-reduce操作，用户们可以通过继承`colossalai.engine.gradient_handler.BaseGradientHandler`来执行其个性化操作。目前，Colossal-AI使用普通的数据并行梯度处理器，该处理器在所有的数据并行rank上执行all-reduce操作，且当Colossal-AI检测到当前系统使用了数据并行时，该处理器会被自动创建。您可以使用下方代码块中的代码添加您自定义的梯度处理器：
 
 ```python
 from colossalai.registry import GRADIENT_HANDLER
@@ -99,5 +91,4 @@ dist_initializer = [
 
 ## 调度器
 
-调度器中指定了在前向传播和后向传播时需要执行哪些操作，ColossalAI提供了支持流水线和不支持流水线的调度器。如果您想要修改前向传播和后向传播的执行方式，您可以
-继承`colossalai.engine.BaseSchedule`并实现您想要的操作。您也可以在训练模型之前将您的调度器添加到我们的引擎中来。
+调度器中指定了在前向传播和后向传播时需要执行哪些操作，Colossal-AI提供了流水线和非流水线的调度器。如果您想要修改前向传播和后向传播的执行方式，您可以继承`colossalai.engine.BaseSchedule`并实现您想要的操作。您也可以在训练模型之前将您的调度器添加到我们的引擎中来。

docs/amp.md

 # Mixed precision training
 
-In ColossalAI, we have incorporated different implementations of mixed precision training:
+In Colossal-AI, we have incorporated different implementations of mixed precision training:
 1. torch.cuda.amp
 2. apex.amp
 3. tensor-parallel amp

docs/amp_zh.md

 # 混合精度训练
 
-ColossalAI可以使用如下三种不同的混合精度训练方式：
+Colossal-AI可以使用如下三种不同的混合精度训练方式：
 1. torch.cuda.amp
 2. apex.amp
 3. 张量并行AMP
 
-前两种混合精度训练方式依赖于[PyTorch](https://pytorch.org/docs/stable/amp.html)的原生实现（1.6或以上版本）以及
-[Nvidia Apex](https://github.com/NVIDIA/apex)，但这两种方法与张量并行并不兼容，因为在张量并行中我们需要将张量进行切分并保存在不同的设备上，
-因此，实现兼容张量并行的混合精度训练需要在不同进程之间不断通信来交流`inf`以及`nan`是否存在于模型参数中，因此我们才用了
-[Megatron-LM](https://github.com/NVIDIA/Megatron-LM)的实现方式。
+前两种混合精度训练方式依赖于[PyTorch](https://pytorch.org/docs/stable/amp.html)的原生实现（1.6或以上版本）以及[Nvidia Apex](https://github.com/NVIDIA/apex)，但这两种方法与张量并行并不兼容，因为在张量并行中我们需要将张量进行切分并保存在不同的设备上，因此，实现兼容张量并行的混合精度训练需要在不同进程之间不断通信来交流`inf`以及`nan`是否存在于模型参数中，因此我们采用了[Megatron-LM](https://github.com/NVIDIA/Megatron-LM)的实现方式。
 
-您可以简单地将配置文件中的`fp16`字段设置为True来使用混合精度训练。目前，PyTorch与Apex的amp不能保证与张量和流水线并行兼容，因此，我们推荐您使用
-最后一种混合精度训练方式。
+您可以简单地将配置文件中的`fp16`字段设置为True来使用混合精度训练。目前，PyTorch与Apex的amp不能保证与张量和流水线并行兼容，因此，我们推荐您使用最后一种混合精度训练方式。
 
 ## PyTorch AMP
 
-PyTorch在1.6及以上版本中提供了混合精度训练，其可以在保持一些操作的精度为`fp32`的同时，将数据转换成`fp16`格式，您可以在配置文件中配置使用。
+PyTorch在1.6及以上版本中提供了混合精度训练，它可以在保持一些操作的精度为`fp32`的同时，将数据转换成`fp16`格式，您可以在配置文件中配置使用。
 
 ```python
 from colossalai.engine import AMP_TYPE
@@ -33,8 +29,7 @@ fp16=dict(
 
 ## Apex AMP
 
-我们使用了[Apex](https://nvidia.github.io/apex/)中的混合精度训练，因为该模式提供了细粒度的混合精度控制，例如，`O2`级（第二级优化器）将会保持
-批标准化在`fp32`上进行。下面的代码块展示了使用Apex AMP的配置文件。
+我们使用了[Apex](https://nvidia.github.io/apex/)中的混合精度训练，因为该模式提供了细粒度的混合精度控制，例如，`O2`级（第二级优化器）将会保持批标准化在`fp32`上进行。下面的代码块展示了使用Apex AMP的配置文件。
 
 ```python
 from colossalai.engine import AMP_TYPE
@@ -59,7 +54,7 @@ fp16 = dict(
 
 ## 张量并行AMP
 
-我们借鉴了Megatron-LM的混合精度训练实现，该实现方式与张量并行与流水线并行相兼容。下面的代码块展示了使用张量并行AMP的配置文件。
+我们借鉴了Megatron-LM的混合精度训练实现，该实现方式与张量并行、流水线并行相兼容。下面的代码块展示了使用张量并行AMP的配置文件。
 
 ```python
 from colossalai.engine import AMP_TYPE

docs/conf.py

@@ -17,7 +17,7 @@ sys.path.insert(0, os.path.abspath('..'))
 
 # -- Project information -----------------------------------------------------
 
-project = 'ColossalAI'
+project = 'Colossal-AI'
 copyright = '2021, HPC-AI Tech'
 author = 'HPC-AI Technology Inc.'
 

docs/config.md

 # Config file
 
-Here is a config file example showing how to train a ViT model on the CIFAR10 dataset using ColossalAI:
+Here is a config file example showing how to train a ViT model on the CIFAR10 dataset using Colossal-AI:
 
 ```python
 # build train_dataset and train_dataloader from this dictionary

docs/config_zh.md

 # 配置文件
 
-下方代码块中的示例展示了如何在CIFAR10数据集上使用ColossalAI训练ViT模型。
+下方代码块中的示例展示了如何在CIFAR10数据集上使用Colossal-AI训练ViT模型。
 
 ```python
 # build train_dataset and train_dataloader from this dictionary

docs/index.rst

-.. ColossalAI documentation master file, created by
+.. Colossal-AI documentation master file, created by
    sphinx-quickstart on Mon Oct 11 17:05:05 2021.
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-ColossalAI开发文档
+夸父AI系统（Colossal-AI）开发文档
 ======================================
 .. toctree::
    :maxdepth: 1

docs/index_en.rst

-.. ColossalAI documentation master file, created by
+.. Colossal-AI documentation master file, created by
    sphinx-quickstart on Mon Oct 11 17:05:05 2021.
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-ColossalAI documentation
+Colossal-AI documentation
 ======================================
 .. toctree::
    :maxdepth: 1

docs/model.md

 # Define your own parallel model
 
 Let's say that you have a huge MLP model with billions of parameters and its extremely large hidden layer size makes it
-impossible to fit into a single GPU. Don't worry, ColossalAI is here to help you sort things out. With the help of ColossalAI, 
+impossible to fit into a single GPU directly. Don't worry, ColossalAI is here to help you sort things out. With the help of ColossalAI, 
 you can write your model in the familiar way in which you used to write models for a single GPU, while ColossalAI automatically 
 splits your model weights and fit them perfectly into a set of GPUs. We give a simple example showing how to write a simple 
-2D parallel model in the ColossalAI context.
+2D parallel model in the Colossal-AI context.
 
 ## Write a simple 2D parallel model
 

docs/model_zh.md

 # 定义符合您需求的并行模型
 
-如果您在训练一个拥有数亿级参数的巨大MLP模型，那么该模型一定无法在单个GPU上进行训练，不用担心，ColossalAI可以帮您解决这一问题。您仍旧可以像写单GPU模型
-那样来写您的模型，ColossalAI会按照您的并行设置自动将模型参数进行切割，并将它们均匀地存入一组GPU中。下面是一个简单的例子，来向您展示如何在ColossalAI
-环境下写一个2D张量并行的模型。
+如果您在训练一个拥有数亿级参数的巨大MLP模型，那么该模型一定无法在单个GPU上直接进行训练，不用担心，Colossal-AI可以帮您解决这一问题。您仍旧可以像写单GPU模型那样来写您的模型，Colossal-AI会按照您的并行设置自动将模型参数进行切割，并将它们均匀地存入一组GPU中。下面是一个简单的例子，来向您展示如何在Colossal-AI环境下写一个2D张量并行的模型。
 
 ## 简单的2D张量并行模型
 
@@ -25,4 +23,4 @@ class MLP_2D(nn.Module):
 
 ## 使用事先定义好的模型
 
-为了您使用的方便，我们事先在我们的Model Zoo中定义好了一些现在流行的模型，比如*BERT*、*VIT*以及*MLP-Mixer*，您可以根据您的需求来自定义这些模型的规模。
+为了您使用的方便，我们事先在我们的Model Zoo中定义好了一些现在流行的模型，比如*BERT*、*VIT*以及*MLP-Mixer*等，您可以根据您的需求来自定义这些模型的规模。

docs/parallelization.md

@@ -26,13 +26,13 @@ represents the way of tensor parallelism.
 
 Data parallel is the most common way to distribute your training task by splitting data into several shards and train 
 on a single shard on each device. The configuration for data parallel is detected automatically and set for you. You do 
-not have to explicitly set them in your configurations. When data parallel size is larger than 1, ColossalAI automatically 
+not have to explicitly set them in your configurations. When data parallel size is larger than 1, Colossal-AI automatically 
 adds the distributed data sampler to the dataloader to shard the dataset.
 
 ## 1D, 2D, 2.5D and 3D Parallel
 
 To enable hybrid parallelism, we provide an array of tensor parallelism. We provide the list of papers which match each 
-tensor parallel method. These parallel modes need to work with the distributed layers provided by ColossalAI.
+tensor parallel method. These parallel modes need to work with the distributed layers provided by Colossal-AI.
 - 1D: [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053)
 
 - 2D: [An Efficient 2D Method for Training Super-Large Deep Learning Models](https://arxiv.org/abs/2104.05343)  
@@ -84,7 +84,7 @@ and the second layer to the second GPU. This example of course wastes the comput
 the idea of pipeline parallelism. 
 
 As PyTorch is based on dynamic computation graph, the computation flow is not known until execution. To support pipeline 
-parallelism in PyTorch, you may need to add one more attribute, `layers_cfg` in your model class which tells ColossalAI
+parallelism in PyTorch, you may need to add one more attribute, `layers_cfg` in your model class which tells Colossal-AI
 the sequence of execution. One example you can refer is `colossalai.nn.model.VanillaResNet`.
 
 ```python
@@ -192,7 +192,7 @@ class VanillaResNet(BaseModel):
         ]
 ```
 
-You can set the number of pipeline stages in your configuration file. When pipeline size is larger than 1, ColossalAI 
+You can set the number of pipeline stages in your configuration file. When pipeline size is larger than 1, Colossal-AI 
 will automatically creates the pipeline schedule which defines the forward and backward step. You can specify how many microbatches
 to run in each step in the `schedule` configuration.
 

docs/parallelization_zh.md

@@ -2,9 +2,7 @@
 
 ## 配置并行技术组合
 
-ColossalAI支持多种并行技术，包括数据并行、张量并行（1D、2D、2.5D、3D）、流水线并行以及序列并行。您可以通过更改配置文件中的`parallel`字典变量
-来初始化分布式系统中的进程组，配置文件中的`parallel`字典变量必须满足下面的格式。数据并行的规模可以通过`parallel`中流水线并行的规模和张量并行的
-规模计算得出。
+Colossal-AI支持多种并行技术，包括数据并行、张量并行（1D、2D、2.5D、3D）、流水线并行以及序列并行。您可以通过更改配置文件中的`parallel`字典变量来初始化分布式系统中的进程组，配置文件中的`parallel`字典变量必须满足下面的格式。数据并行的规模可以通过`parallel`中流水线并行的规模和张量并行的规模计算得出。
 
 ```python
 parallel = dict(
@@ -13,31 +11,25 @@ parallel = dict(
 )
 ```
 
-注意该字典变量的名称必须为**parallel**。该变量中所有的参数，包括`parallel`本身都是非必需的，如果您的代码中没有提供该变量，则所有并行规模都将被
-设定为默认值1，即不使用任何并行技术的情况。`parallel`中data、pipeline以及tensor的值分别代表了数据并行、流水线并行、以及张量并行的规模，而mode
-的值代表了张量并行的模式。
+注意该字典变量的名称必须为**parallel**。该变量中所有的参数，包括`parallel`本身都是非必需的，如果您的代码中没有提供该变量，则所有并行规模都将被设定为默认值1，即不使用任何并行技术的情况。`parallel`中data、pipeline以及tensor的值分别代表了数据并行、流水线并行、以及张量并行的规模，而`mode`的值代表了张量并行的模式。
 
 ## 数据并行
 
-数据并行是一种最常见的并行技术，可以将数据分成几个不同的部分，并对每一个部分在一台设备上进行训练。ColossalAI可以自动检测数据并行设置并为您设置好环境，
-您不需要在您的环境配置中显式地设置。当数据并行规模大于1时，ColossalAI会自动为数据读取器增加分布式数据采样器，以此来达到切分数据集的目的。
+数据并行是一种最常见的并行技术，可以将数据分成几个不同的部分，并对每一个部分在一台设备上进行训练。Colossal-AI可以自动检测数据并行设置并为您设置好环境，您不需要在您的环境配置中显式地设置。当数据并行规模大于1时，Colossal-AI会自动为数据读取器增加分布式数据采样器，以此来达到切分数据集的目的。
 
 ## 1D、2D、2.5D与3D张量并行
 
-为了方便混合并行技术，我们提供了一系列的张量并行技术，同时下面罗列了每一种张量并行技术对应的论文，这些张量并行技术需要ColossalAI提供的分布式层结构的支持。
+为了方便混合并行技术，我们提供了一系列的张量并行技术，同时下面罗列了每一种张量并行技术对应的论文，这些张量并行技术需要Colossal-AI提供的分布式层结构的支持。
 - 1D：[Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053)
 
 - 2D：[An Efficient 2D Method for Training Super-Large Deep Learning Models](https://arxiv.org/abs/2104.05343)
-2D张量并行依赖SUMMA矩阵乘法技术，其在两个不同的维度上对于输入数据进行切分。切分后的张量分布在一个的2D网格上，使用的总设备数量为$P = N^2$，其中$N$为
-一个维度上的切分张量数量。
+2维张量并行依赖SUMMA矩阵乘法技术，其在两个不同的维度上对于输入数据进行切分。切分后的张量分布在一个的2维网格上，使用的总设备数量为$P = N^2$，其中$N$为一个维度上的切分张量数量。
 
 - 2.5D：[2.5-dimensional distributed model training](https://arxiv.org/abs/2105.14500)
-2.5D并行技术受到了2.5D矩阵乘法的启发，其对于2D张量并行的结果进行进一步切分，在$d$层上面安排$P = N^2 ∗ d$个处理器，相应地，矩阵乘法操作也被切分为$d$份
-在不同的层上面进行。
+2.5维并行技术受到了2.5D矩阵乘法的启发，其对于2维张量并行的结果进行进一步切分，在$d$层上面安排$P = N^2 ∗ d$个处理器，相应地，矩阵乘法操作也被切分为$d$份在不同的层上面进行。
 
 - 3D：[Maximizing Parallelism in Distributed Training for Huge Neural Networks](https://arxiv.org/abs/2105.14450)
-我们还引入了3D张量并行技术，该技术在一个3D处理器立方体中对神经网络参数进行并行化。使用$P$个处理器时，该并行技术可以在付出$O(P^{1/3})$的通信开销的情况下
-达到最优表现，且计算资源和内存使用都可以在$P$个处理器上达到平均分配。
+我们还引入了3维张量并行技术，该技术在一个3维处理器立方体中对神经网络参数进行并行化。使用$P$个处理器时，该并行技术可以在付出$O(P^{1/3})$的通信开销的情况下达到最优表现，且计算资源和内存使用都可以在$P$个处理器上达到平均分配。
 
 使用上述几种张量并行的`parallel`字典变量示例参见下方代码。
 
@@ -69,11 +61,9 @@ parallel = dict(
 
 ## 流水线并行（开发中）
 
-流水线并行指的是在将深度学习模型按照层切分为几个不同的部分，例如，假设一个由两个线性层组成的简单模型，我们可以使用两个GPU，那么我们可以把第一个线性层
-的工作分配给一个GPU，把第二个线性层的工作分配给另一个GPU。当然这个例子只是为了说明流水线并行的工作方式，没有实际意义。
+流水线并行指的是在将深度学习模型按照层切分为几个不同的部分。例如，对于一个由两个线性层组成的简单模型，我们可以使用两个GPU，并把第一个线性层的工作分配给一个GPU，把第二个线性层的工作分配给另一个GPU。当然这个例子只是为了说明流水线并行的工作方式，没有实际意义。
 
-由于PyTorch的计算基于动态计算图，所以在执行前无法确定计算流。为了支持PyTorch中的流水线并行，您需要为您的模型类加入一个额外的特征`layers_cfg`，
-使ColossalAI清楚具体的计算流程，`colossalai.nn.VanillaResNet`给出了一个您可以参考的示例。
+由于PyTorch的计算基于动态计算图，所以在执行前无法确定计算流。为了支持PyTorch中的流水线并行，您需要为您的模型类加入一个额外的特征`layers_cfg`，使Colossal-AI清楚具体的计算流程，`colossalai.nn.VanillaResNet`给出了一个您可以参考的示例。
 
 ```python
 from colossalai.nn import BaseModel
@@ -180,8 +170,7 @@ class VanillaResNet(BaseModel):
         ]
 ```
 
-您可以在配置文件中手动设置流水线并行的级数，当柳树线并行级数大于1时，ColossalAI将会自动创建定义前向传播和后向传播的流水线调度程序。同时您还可以在配置文件
-中的`schedule`字典变量来定义每一个步骤中训练的微批数量。下面的代码给出了一个配置流水线并行的例子。
+您可以在配置文件中手动设置流水线并行的级数，当流水线的并行级数大于1时，Colossal-AI将会自动创建定义前向传播和后向传播的流水线调度程序。同时，您还可以在配置文件中的`schedule`字典变量来定义每一个步骤中训练的微批次数量。下面的代码给出了一个配置流水线并行的例子。
 
 ```python
 parallel = dict(
@@ -197,6 +186,4 @@ schedule = dict(
 
 ## 序列并行（开发中）
 
-序列并行是为了支持对于长序列数据的建模，这类数据包括文档级别的文本理解以及医学影像分析，该并行技术由论文
-[Sequence Parallelism: Making 4D Parallelism Possible](https://arxiv.org/abs/2105.13120)提出。
-目前该并行技术仍处于实验开发阶段。
+序列并行是为了支持对于长序列数据的建模，这类数据包括文档级别的文本理解以及医学影像分析，该并行技术由论文[Sequence Parallelism: Making 4D Parallelism Possible](https://arxiv.org/abs/2105.13120)提出。目前该并行技术仍处于实验开发阶段。

docs/run_demo.md

 # Quick demo
 
-ColossalAI is an integrated large-scale deep learning framework with efficient parallelization techniques. The framework
+Colossal-AI is an integrated large-scale deep learning system with efficient parallelization techniques. The system
 can accelerate model training on distributed systems with multiple GPUs by applying parallelization techniques. The
-framework can also run on systems with only one GPU. Quick demos showing how to use ColossalAI are given below.
+system can also run on systems with only one GPU. Quick demos showing how to use Colossal-AI are given below.
 
 ## Single GPU
 
-ColossalAI can be used to train deep learning models on systems with only one GPU and achieve baseline
+Colossal-AI can be used to train deep learning models on systems with only one GPU and achieve baseline
 performances. [Here](https://colab.research.google.com/drive/1fJnqqFzPuzZ_kn1lwCpG2nh3l2ths0KE?usp=sharing#scrollTo=cQ_y7lBG09LS)
-is an example showing how to train a LeNet model on the CIFAR10 dataset using ColossalAI.
+is an example showing how to train a LeNet model on the CIFAR10 dataset using Colossal-AI.
 
 ## Multiple GPUs
 
-ColossalAI can be used to train deep learning models on distributed systems with multiple GPUs and accelerate the
+Colossal-AI can be used to train deep learning models on distributed systems with multiple GPUs and accelerate the
 training process drastically by applying efficient parallelization techiniques, which will be elaborated in
 the [Parallelization](parallelization.md) section below. Run the code below on your distributed system with 4 GPUs,
 where `HOST` is the IP address of your system. Note that we use
@@ -23,7 +23,7 @@ HOST=xxx.xxx.xxx.xxx srun ./scripts/slurm_dist_train.sh ./examples/run_trainer.p
 ```
 
 `./configs/vit/vit_2d.py` is a config file, which is introduced in the [Config file](config.md) section below. These
-config files are used by ColossalAI to define all kinds of training arguments, such as the model, dataset and training
+config files are used by Colossal-AI to define all kinds of training arguments, such as the model, dataset and training
 method (optimizer, lr_scheduler, epoch, etc.). Config files are highly customizable and can be modified so as to train
 different models.
 `./examples/run_trainer.py` contains a standard training script and is presented below, it reads the config file and
@@ -72,7 +72,7 @@ Zoo. The detailed substitution process is elaborated [here](model.md).
 
 ## Features
 
-ColossalAI provides a collection of parallel training components for you. We aim to support you with your development of
+Colossal-AI provides a collection of parallel training components for you. We aim to support you with your development of
 distributed deep learning models just like how you write single-GPU deep learning models. We provide friendly tools to
 kickstart distributed training in a few lines.
 

docs/run_demo_zh.md

 # 快速上手
 
-ColossalAI是一个大规模深度学习框架，其中包含高效的并行技术。该框架可以在多GPU的分布式系统上使用并行技术有效地加速模型训练，同时该框架也可以运行在
-带有GPU的非分布式系统上。下面是ColossalAI的快速上手指南。
+Colossal-AI是一个大规模深度学习系统，其中包含高效的并行技术。该系统可以在多GPU的分布式系统上使用并行技术有效地加速模型训练，同时该系统也可以运行在带有GPU的非分布式系统上。下面是ColossalAI的快速上手指南。
 
 ## 单GPU系统
 
-在带有GPU的非分布式系统上进行模型训练时，ColossalAI可以达到当前的基线效率。
-[这里](https://colab.research.google.com/drive/1fJnqqFzPuzZ_kn1lwCpG2nh3l2ths0KE?usp=sharing#scrollTo=cQ_y7lBG09LS)我们给出一个Google Colab
-示例展现如何使用ColossalAI与CIFAR10数据集在非分布式系统上训练一个LeNet模型。
+在带有GPU的非分布式系统上进行模型训练时，Colossal-AI可以达到当前的基线效率。[这里](https://colab.research.google.com/drive/1fJnqqFzPuzZ_kn1lwCpG2nh3l2ths0KE?usp=sharing#scrollTo=cQ_y7lBG09LS)我们给出一个Google Colab示例展现如何使用Colossal-AI与CIFAR10数据集在非分布式系统上训练一个LeNet模型。
 
 ## 多GPU系统
 
-在多GPU的分布式系统上训练深度学习模型时，ColossalAI可以使用高效的并行技术来显著地加速训练过程，这些技术将在下面的[并行技术](parallelization.md)章节中被详述。
-下面的代码将在拥有四个GPU的分布式系统上训练一个ViT模型，其中`HOST`变量为您分布式系统的IP地址。请注意下面的代码使用了
-[Slurm](https://slurm.schedmd.com/documentation.html)作业调度系统。
+在多GPU的分布式系统上训练深度学习模型时，Colossal-AI可以使用高效的并行技术来显著地加速训练过程，这些技术将在下面的[并行技术](parallelization.md)章节中被详述。下面的代码将在拥有四个GPU的分布式系统上训练一个ViT模型，其中`HOST`变量为您分布式系统的IP地址。请注意下面的代码使用了[Slurm](https://slurm.schedmd.com/documentation.html)作业调度系统。
 
 ```bash
 HOST=xxx.xxx.xxx.xxx srun ./scripts/slurm_dist_train.sh ./examples/run_trainer.py ./configs/vit/vit_2d.py
 ```
 
-`./configs/vit/vit_2d.py`是一个[配置文件](config.md)，ColossalAI使用配置文件来定义训练过程中需要用到的参数，比如模型类型、数据集、以及优化器、学习率调度器等。
-您可以通过编写配置文件的方式来训练不同的模型。`./examples/run_trainer.py`是一个标准的训练脚本，具体代码已经附在下面。该脚本可以读入配置文件中的训练参数并训练模型。
+`./configs/vit/vit_2d.py`是一个[配置文件](config.md)，Colossal-AI使用配置文件来定义训练过程中需要用到的参数，比如模型类型、数据集、以及优化器、学习率调度器等。您可以通过编写配置文件的方式来训练不同的模型。`./examples/run_trainer.py`是一个标准的训练脚本，具体代码已经附在下面。该脚本可以读入配置文件中的训练参数并训练模型。
 
 ```python
 import colossalai
@@ -64,7 +58,7 @@ if __name__ == '__main__':
 
 ## 系统功能
 
-ColossalAI提供了一系列并行组件来加速您的模型训练，我们在下面的章节提供了关于这些并行组件的介绍。我们的目标是使您的分布式深度学习模型开发像单卡深度学习模型开发那样方便。
+Colossal-AI提供了一系列并行组件来加速您的模型训练，我们在下面的章节提供了关于这些并行组件的介绍。我们的目标是使您的分布式深度学习模型开发像单卡深度学习模型开发那样方便。
 
 - [数据并行](parallelization.md)
 - [1D、2D、2.5D、3D张量并行以及序列并行](parallelization.md)

docs/trainer_engine.md

@@ -54,7 +54,7 @@ More information regarding the class can be found in the API references.
 To learn how to customize a trainer which meets your needs, let's first give a look at the `Trainer` class. We highly recommend that you read *Get Started* 
 section and *Build your engine* first.
 
-The `Trainer` class enables researchers and engineers to use our framework more conveniently. Instead of having to write your own scripts, you can simply 
+The `Trainer` class enables researchers and engineers to use our system more conveniently. Instead of having to write your own scripts, you can simply 
 construct your own trainer by calling the `Trainer` class, just like what we did in the following code block.
 
 ```python
@@ -86,7 +86,7 @@ accuracy to let users monitor the performance of the model.
 ### Hook
 
 If you have your specific needs, feel free to extend our `BaseHook` class to add your own functions, or our `MetricHook` class to write a metric collector. 
-These hook functions can be called at twelve points in time. Besides, you can define the priorities of all hooks to arrange the execution order of them.
+These hook functions can be called at twelve timing in the trainer's life cycle. Besides, you can define the priorities of all hooks to arrange the execution order of them.
 More information can be found in the API references. 
 
 ### Metric

docs/trainer_engine_zh.md

@@ -2,8 +2,7 @@
 
 ## 引擎
 
-为了更好的理解我们的`Engine`类是如何工作的，我们首先需要了解常见引擎中进程函数的概念。进程函数控制数据集中一个批的行为，`Engine`类控制的正是该进程函数。我们在下方的代码块
-中给出了一个标准的进程函数例子。
+为了更好的理解我们的`Engine`类是如何工作的，我们首先需要了解常见引擎中进程函数的概念。进程函数控制数据集中一个批次的行为，`Engine`类控制的正是该进程函数。我们在下方的代码块中给出了一个标准的进程函数例子。
 
 ```python
 def process_function(dataloader, model, criterion, optim):
@@ -15,8 +14,7 @@ def process_function(dataloader, model, criterion, optim):
     optim.setp()
 ```
 
-在`ignite.engine`与`keras.engine`中，进程函数需要由用户提供，然而，用户很难为流水线并行编写进程函数。为了为用户提供方便的混合并行，我们提供了具备强大功能的`Engine`类，
-该类提供前向传播后向传播不交织的策略，并支持流水线并行。同时，我们`Engine`类在使用事先定义好的学习率调度器来在训练过程中调整学习率。
+在`ignite.engine`与`keras.engine`中，进程函数需要由用户提供，然而，用户很难为流水线并行编写进程函数。为了向用户提供方便的混合并行，我们提供了具备强大功能的`Engine`类，该类支持流水线并行，并提供前向传播后向传播不交织的策略。同时，您可以在`Engine`类中使用您事先定义好的学习率调度器来在训练过程中调整学习率。
 
 您在构造引擎时只需要定义`model`、`criterion`、`optimizer`、`lr_scheduler`与`schedule`等变量即可，下面的代码块给出了一个这样的例子。
 
@@ -47,15 +45,13 @@ MyEngine = Engine(
 
 要了解如何个性化适应您需求的训练器，首先需要了解我们的`Trainer`类。
 
-`Trainer`类旨在让科研工作者和工程师更加方便地使用我们的框架，您不需要自己写脚本，只需要调用`Trainer`类来构造您的训练器即可，就像下面的代码块中所做的。
+`Trainer`类旨在让科研工作者和工程师更加方便地使用我们的系统，您不需要自己写脚本，只需要调用`Trainer`类来构造您的训练器即可，就像下面的代码块中所做的。
 
 ```python
 MyTrainer = Trainer(MyEngine)
 ```
 
-在此之后，您可以使用`fit`方法来训练或调用您的模型。除此之外，为了让我们的`Trainer`类拥有更强大的功能，我们加入了一系列方便您使用的工具，例如，您可以在训练过程中持续监测并记录模型目前
-的运行状态和表现，这些功能都是通过钩子函数来实现的。我们提供的`BasicHook`类让您可以在您指定的时间运行我们提供的钩子函数，或者您自行定义的钩子函数。我们事先为您定义好了一些实用的钩子
-函数，列在下面的代码块中，您需要做的就是找到符合您需求的钩子函数。更多该类的相关信息可以在API信息中找到。
+在此之后，您可以使用`fit`方法来训练或调用您的模型。除此之外，为了让我们的`Trainer`类拥有更强大的功能，我们加入了一系列方便您使用的工具。例如，您可以在训练过程中持续监测并记录模型目前的运行状态和表现，这些功能都是通过钩子函数来实现的。我们提供的`BasicHook`类让您可以在指定时间执行您的钩子函数。如下方的代码块所示，我们事先为您定义好了一些实用的钩子函数，您需要做的就是找到符合您需求的钩子函数。更多该类的相关信息可以在API信息中找到。
 
 ```python
 hooks = [
@@ -70,16 +66,14 @@ hooks = [
 ]
 ```
 
-上面这些钩子函数可以记录模型性能指标，训练时间，显存使用等，并在每一个epoch结束后将这些信息写入到日志中。除此之外，这些钩子函数还可以即时输出当前的损失以及准确率，让用户可以监测模型的性能。
+上面这些钩子函数可以记录模型性能指标，训练时间，显存使用等信息，并在每一个epoch结束后将这些信息写入到日志中。除此之外，这些钩子函数还可以即时输出当前的损失以及准确率，让用户可以监测模型的性能。
 
 ### 钩子函数
 
-如果您有个性化需求，您可以继承我们的`BaseHook`类并添加您的函数，或者继承我们的`MetricHook`来编写您需要的度量标准。这些钩子函数可以在12个不同的时间点被执行。更多该类的相关信息可以在API
-信息中找到。
+如果您有个性化需求，您可以继承我们的`BaseHook`类并添加您的钩子函数，或者继承我们的`MetricHook`来编写您需要的度量标准。这些钩子函数可以在`Trainer`生命周期的12个时间点被执行。更多该类的相关信息可以在API信息中找到。
 
 ### 度量标准
 
-您可以通过继承我们的`Metric`类来提供您需要的度量标准，该类需要与`MetricHook`类一同使用。当您编写您的度量标准钩子函数时，请用心设置您的优先级来确保该钩子函数的优先级高于那些需要度量结果的
-钩子函数。
+您可以通过继承我们的`Metric`类来提供您需要的度量标准，该类需要与`MetricHook`类一同使用。当您编写您的度量标准钩子函数时，请用心设置您的优先级来确保该钩子函数的优先级高于那些需要度量结果的钩子函数。
 
 我们已经为您定义好了一些度量标准钩子函数在`runner.states['metrics']`供您参考。

docs/zero.md

@@ -14,7 +14,7 @@ partition them during the forward and backward passes.
 
 ## Getting Started with ZeRO
 
-If you are training models with ColossalAI, enabling ZeRO-3 offload is as simple as enabling it in your ColossalAI configuration! 
+If you are training models with Colossal-AI, enabling ZeRO-3 offload is as simple as enabling it in your Colossal-AI configuration! 
 Below are a few examples of ZeRO-3 configurations.
 
 ### Example of ZeRO-3 Configurations

docs/zero_zh.md

 # ZeRO优化器与offload
 
-ZeRO优化器可以切分三种模型状态（优化器状态、梯度、参数），并将它们存储在不同的进程中，以此来减少数据并行的存储冗余，传统的数据并行需要将上述三种状态
-复制很多份保存在每一个进程中。与传统的做法相比，ZeRO优化器可以极大地提高内存存储效率，并保持较好的通信效率。
+ZeRO优化器可以切分三种模型状态（优化器状态、梯度、参数），并将它们存储在不同的进程中，以此来减少数据并行的存储冗余，传统的数据并行需要将上述三种状态复制很多份保存在每一个进程中。与传统的做法相比，ZeRO优化器可以极大地提高内存的存储效率，并保持较好的通信效率。
 
-1. **ZeRO Level 1**: 优化器状态（如对于[Adam优化器](https://arxiv.org/abs/1412.6980)而言，32比特的参数，以及第一和第二动量的预测值）被切分
-存储在不同的进程中，这样每一个进程只需要更新它对应的那一部分参数。
-2. **ZeRO Level 2**: 用于更新模型参数的32比特的梯度在这一级被切分存储在不同的进程中，这里梯度的切分与level 1中模型参数的切分是一一对应的，每一个
-进程上的梯度正好被用来更新该进程上的保存的模型参数。
+1. **ZeRO Level 1**: 优化器状态（如对于[Adam优化器](https://arxiv.org/abs/1412.6980)而言，32比特的参数，以及第一和第二动量的预测值）被切分存储在不同的进程中，这样每一个进程只需要更新它对应的那一部分参数。
+2. **ZeRO Level 2**: 用于更新模型参数的32比特的梯度在这一级被切分存储在不同的进程中，这里梯度的切分与level 1中模型参数的切分是一一对应的，每一个进程上的梯度恰好被用来更新该进程上的保存的模型参数。
 3. **ZeRO Level 3**: 16比特的模型参数在这一级被切分存储在不同的进程中，ZeRO-3可以在前向传播和后向传播期间自动收集或切分这些参数。
 
 ## 使用ZeRO优化器
 
-在ColossalAI中启用ZeRO优化器只需要您在配置文件中进行配置即可，下面是一些使用ZeRO-3的配置文件例子。
+在Colossal-AI中启用ZeRO优化器只需要您在配置文件中进行配置即可，下面是一些使用ZeRO-3的配置文件例子。
 
 ### 使用ZeRO优化器以及offload
 
-这里我们使用`Adam`作为我们的初始优化器.
+这里我们使用`Adam`作为我们的初始优化器。
 
 1. 使用ZeRO来切分优化器状态（level 1），梯度（level 2），以及模型参数（level 3）：
     ```python