Repository: FlagAI-Open/FlagAI (language: python)

Issue:
Fix document yzd



Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 7879eaba..46037518 100644
--- a/README.md
+++ b/README.md
@@ -124,7 +124,8 @@ for text in test_data:
 * [NER with RoBerta-WWM](/docs/TUTORIAL_17_BERT_EXAMPLE_NER.md)
 * [Writing with GPT-2](/docs/TUTORIAL_18_GPT2_WRITING.md)
 * [Title generation with T5](/docs/TUTORIAL_19_T5_EXAMPLE_TITLE_GENERATION.md)
-* [Supported tasks](/docs/TUTORIAL_20_SUPPORTED_TASKS.md)
+
+[//]: # (* [Supported tasks]&#40;/docs/TUTORIAL_20_SUPPORTED_TASKS.md&#41;)
 
 
 This session explains how the base NLP classes work, how you can load pre-trained models to tag your
diff --git a/README_zh.md b/README_zh.md
index ce2b01e8..c525b02d 100644
--- a/README_zh.md
+++ b/README_zh.md
@@ -5,16 +5,16 @@
 
 --------------------------------------------------------------------------------
 
-FlagAI 是一个快速、易于使用和可扩展的大模型工具包。 我们的目标是支持在多模态的各种下游任务上训练、微调和部署大规模模型。 目前，我们专注于 NLP 模型和任务。 在不久的将来，我们将支持其他模态。
+飞智是一个快速、易于使用和可扩展的大模型工具包。 我们的目标是支持在多模态的各种下游任务上训练、微调和部署大规模模型。 目前，我们专注于 NLP 模型和任务。 在不久的将来，我们将支持其他模态。
 <br><br>
 
-* 现在它支持最高百亿参数的**WUDAO GLM**(详见[GLM介绍](/doc_zh/GLM.md))。它同时也支持**BERT**、**RoBERTa**、**GPT2**、**T5** 模型和 Huggingface Transformers 的模型。
+* 现在它支持最高百亿参数的**悟道GLM**(详见[GLM介绍](/doc_zh/GLM.md))。它同时也支持**BERT**、**RoBERTa**、**GPT2**、**T5** 模型和 Huggingface Transformers 的模型。
 
 * 它提供 API 以快速下载并在给定（中/英文）文本上使用这些预训练模型，在您自己的数据集上对其进行微调(fine-tuning)或者应用[提示学习(prompt-tuning)](/doc_zh/TUTORIAL_7_PROMPT_LERANING.md)，然后在我们的模型中心与社区共享它们。 
 
 * 这些模型可以应用于文本，用于文本分类、信息提取、问答、摘要、文本生成等任务，尤其是中文。
 
-* FlagAI 由三个最流行的数据/模型并行库（[PyTorch](https://pytorch.org/)/[Deepspeed](https://www.deepspeed.ai/)/[Megatron-LM](https://github.com/NVIDIA/Megatron-LM)）提供支持，它们之间实现了无缝集成。 你可以用不到十行代码来并行你的训练/测试过程。
+* 飞智由三个最流行的数据/模型并行库（[PyTorch](https://pytorch.org/)/[Deepspeed](https://www.deepspeed.ai/)/[Megatron-LM](https://github.com/NVIDIA/Megatron-LM)）提供支持，它们之间实现了无缝集成。 你可以用不到十行代码来并行你的训练/测试过程。
 
 
 本项目的部分代码基于[GLM](https://github.com/THUDM/GLM),[Transformers](https://github.com/huggingface/transformers) 和 [DeepSpeedExamples](https://github.com/microsoft/DeepSpeedExamples).
@@ -190,7 +190,7 @@ for text_pair in test_data:
 * [RoBERTa-base-ch用于命名实体识别](/doc_zh/TUTORIAL_17_BERT_EXAMPLE_NER.md)
 * [GPT-2用于文本续写](/doc_zh/TUTORIAL_18_GPT2_WRITING.md)
 * [T5用于标题生成](/doc_zh/TUTORIAL_19_T5_EXAMPLE_TITLE_GENERATION.md)
-* [所有支持的任务](doc_zh/TUTORIAL_20_SUPPORTED_TASKS.md)
+* [用GLM10b模型在TNEWS短文本分类数据集上微调](doc_zh/TUTORIAL_20_GLM_TNEWS.md)
 
 
 本节解释了本项目中基础NLP类是如何工作的，如何加载预先训练的模型来标记您的文本，如何使用不同的词或文档嵌入来得到表示，以及如何训练自己的语言模型、序列标注模型和文本分类模型。更多样例见 `FlagAI/examples`。
@@ -198,15 +198,15 @@ for text_pair in test_data:
 
 # 教程
 我们提供了一组教程来帮助您快速上手使用本库：
-* [Tutorial 1: 构建和应用分词器](/doc_zh/TUTORIAL_1_TOKENIZER.md)
+* [Tutorial 1: 如何构建和应用分词器](/doc_zh/TUTORIAL_1_TOKENIZER.md)
 * [Tutorial 2: 数据集预处理流程](/doc_zh/TUTORIAL_2_DATASET.md)
 * [Tutorial 3: 模型的主要功能及相关结构](/doc_zh/TUTORIAL_3_MODEL.md)
-* [Tutorial 4: 模型训练(支持并行化)](/doc_zh/TUTORIAL_4_TRAINER.md)
-* [Tutorial 5: 使用AutoLoader工具快速构建模型](/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md)
-* [Tutorial 6: 使用Predictor工具进行预测](/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md)
-* [Tutorial 7: FlagAI提示学习功能](/doc_zh/TUTORIAL_7_PROMPT_LERANING.md)
-* [Tutorial 8: 数据/模型并行的环境设置](/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md)
-* [Tutorial 9: 使用**编码器/解码器/编解码**器模型进行文本生成](/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md)
+* [Tutorial 4: 为模型和数据并行训练定制训练器](/doc_zh/TUTORIAL_4_TRAINER.md)
+* [Tutorial 5: 使用 Autoloader 简化模型和分词器初始化过程](/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md)
+* [Tutorial 6: 将现成的推理算法与 Predictor 结合使用](/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md)
+* [Tutorial 7: 使用飞智提示学习工具包来提高在SuperGLUE任务上的表现](/doc_zh/TUTORIAL_7_PROMPT_LERANING.md)
+* [Tutorial 8: 多机训练模型搭建环境](/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md)
+* [Tutorial 9: 使用encoder/decoder/encoder-decoder模型进行文本生成](/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md)
 * [Tutorial 10: 转化一个模型为Megatron-LM的模型并行版本](/doc_zh/TUTORIAL_10_MEGATRON.md)
 
 
diff --git a/doc_zh/GLM.md b/doc_zh/GLM.md
index 1458d6e6..a42ae357 100644
--- a/doc_zh/GLM.md
+++ b/doc_zh/GLM.md
@@ -12,6 +12,7 @@
 | Autoencoding    | ✅   | ×         | ×          |
 | Encoder-Decoder | -   | ✅         | -          |
 | GLM             | ✅   | ✅         | ✅          |
+
 GLM的主要功能包括：
 
 - 任务一：文本的一些区间会被屏蔽（参照自动编码的做法）。 这些区间将被随机重新排列，并以自动回归方式进行预测。屏蔽的区间覆盖原始文本的15%。
diff --git a/doc_zh/TUTORIAL_10_METATRON.md b/doc_zh/TUTORIAL_10_METATRON.md
index 0f028d26..ae837dac 100644
--- a/doc_zh/TUTORIAL_10_METATRON.md
+++ b/doc_zh/TUTORIAL_10_METATRON.md
@@ -1,4 +1,4 @@
-# 转化model为Megatron-LM版本
+# 转化一个模型为Megatron-LM的模型并行版本
 - [转化model为Megatron-LM版本](#转化model为megatron-lm版本)
   - [1.将MLP层转化为column/rowParallel版本](#1将mlp层转化为columnrowparallel版本)
   - [2.转化`self-Attention`](#2转化self-attention)
@@ -6,7 +6,7 @@
     - [2.2 将输出的`dense`层转化为`rowparallelLinear`](#22-将输出的dense层转化为rowparallellinear)
   - [3.将`cross-Attention`中的两个`Linear Layer `转化为`column/rowParallel`版本](#3将cross-attention中的两个linear-layer-转化为columnrowparallel版本)
 
-FlagAI支持了BERT，GLM，GPT2 以及T5模型的megatron-lm模型并行. 其主要的操作都是从`Megatron-LM`中拿出来的，放在了`mpu`模块中。
+飞智支持了BERT，GLM，GPT2 以及T5模型的megatron-lm模型并行. 其主要的操作都是从`Megatron-LM`中拿出来的，放在了`mpu`模块中。
 
 ## 1.将MLP层转化为column/rowParallel版本
 代码位置：`flagai/model/layers/embeddings_mpu.py` 
diff --git a/doc_zh/TUTORIAL_11_GLM_BLANK_FILLING_QA.md b/doc_zh/TUTORIAL_11_GLM_BLANK_FILLING_QA.md
index dbc73b39..4324e35c 100644
--- a/doc_zh/TUTORIAL_11_GLM_BLANK_FILLING_QA.md
+++ b/doc_zh/TUTORIAL_11_GLM_BLANK_FILLING_QA.md
@@ -1,4 +1,3 @@
-
 # GLM 完形填空式生成
 
 ![img.png](./img/glm_blank_filling.png)
diff --git a/doc_zh/TUTORIAL_14_HUGGINGFACE_T5.md b/doc_zh/TUTORIAL_14_HUGGINGFACE_T5.md
index e0dad603..42f94f00 100644
--- a/doc_zh/TUTORIAL_14_HUGGINGFACE_T5.md
+++ b/doc_zh/TUTORIAL_14_HUGGINGFACE_T5.md
@@ -159,18 +159,7 @@ trainer = MyTrainer(
 在forward阶段不将中间结果保存。我们可以运行`batch size`=1的t5-11b。
 现在，我们可以用 `gradient_accumulation_steps` train/finetune 一个 t5-11b。
 ```python
-trainer = MyTrainer(
-    env_type='pytorch',
-    epochs=1,
-    batch_size=1,
-    eval_interval=10,
-    log_interval=10,
-    experiment_name='t5-11b',
-    pytorch_device='cuda:0',
-    load_dir=None,
-    lr=1e-4,
-    fp16=True
-    checkpoint_activations = True) # setting as `True`
+model.gradient_checkpointing = True
 ```  
 ### 第三步：数据并行(DDP)
 为了增加batch size，我们可以在多个GPU上使用数据并行。
diff --git a/doc_zh/TUTORIAL_1_TOKENIZER.md b/doc_zh/TUTORIAL_1_TOKENIZER.md
index 1ec6448f..b7c957b3 100644
--- a/doc_zh/TUTORIAL_1_TOKENIZER.md
+++ b/doc_zh/TUTORIAL_1_TOKENIZER.md
@@ -1,4 +1,4 @@
-# 分词器
+# 如何构建和应用分词器
 
 ## 什么是分词？
 分词是 NLP 项目预处理阶段的一个基本步骤，其目的是将散乱的原始文本转换为规整的数字序列， 以便机器学习系统使用。
@@ -26,7 +26,7 @@
 from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer
 tokenizer = GLMLargeEnWordPieceTokenizer()
 ```
-在这一步里，Modelhub中的词表文件将被自动下载到`cache_dir`参数中指定的路径。默认设置为分词器文件下的 ./vocab 目录。
+在这一步里，模型仓库中的词表文件将被自动下载到`cache_dir`参数中指定的路径。默认设置为分词器文件下的 ./vocab 目录。
 
 ## 应用分词器
 让我们使用一个分词器将原始文本编码成数字序列，然后将数字序列恢复成原始文本：
diff --git a/doc_zh/TUTORIAL_20_SUPPORTED_TASKS.md b/doc_zh/TUTORIAL_20_GLM_TNEWS.md
similarity index 100%
rename from doc_zh/TUTORIAL_20_SUPPORTED_TASKS.md
rename to doc_zh/TUTORIAL_20_GLM_TNEWS.md
diff --git a/doc_zh/TUTORIAL_20_SUPPORTED_TASKS_backup.md b/doc_zh/TUTORIAL_20_SUPPORTED_TASKS_backup.md
new file mode 100644
index 00000000..c36eaf24
--- /dev/null
+++ b/doc_zh/TUTORIAL_20_SUPPORTED_TASKS_backup.md
@@ -0,0 +1,1 @@
+# 用GLM10b模型在TNEWS短文本分类数据集上微调
diff --git a/doc_zh/TUTORIAL_2_DATASET.md b/doc_zh/TUTORIAL_2_DATASET.md
index 2e5d742c..41b71a62 100644
--- a/doc_zh/TUTORIAL_2_DATASET.md
+++ b/doc_zh/TUTORIAL_2_DATASET.md
@@ -5,13 +5,36 @@
 
 目前项目里存在三种数据预处理的情况，即对分类任务的微调，预训练, 以及对生成任务的微调。我们在接下来会分别展开。
 
-## 数据处理：分类任务微调([prompt-learning模式](TUTORIAL_7_PROMPT_LEARNING.md))
-### 应用代码
+<!-- toc -->
+
+- [1 分类任务微调](#分类任务微调)
+  - [1.1 应用代码](#分类任务应用代码)
+  - [1.2 初步读取并处理数据集](#初步读取并处理数据集)
+    - [1.2a 加载数据集](#加载数据集)
+    - [1.2b 统一数据集结构](#统一数据集结构)
+  - [1.3 将数据整理成模型的输入](#将数据整理成模型的输入)
+    - [1.3a 构建完形填空模板](#构建完形填空模板)
+    - [1.3b 分词并构造输入样例](#分词并构造输入样例)
+  - [1.4 创建加载器](#创建加载器)
+- [2 预训练](#预训练)
+  - [2.1 预训练任务数据格式样例](#预训练任务数据格式样例)
+  - [2.2 预训练的任务处理实例代码](#预训练的任务处理实例代码)
+- [3 生成任务微调](#生成任务微调)
+  - [3.1 生成任务应用代码](#生成任务应用代码)
+  - [3.2 生成任务里将数据整理成模型的输入](#生成任务里将数据整理成模型的输入)
+    - [3.2a 生成任务里构建填空模板](#生成任务里构建填空模板)
+    - [3.2b 生成任务里分词并构造输入样例](#生成任务里分词并构造输入样例)
+
+  
+
+## 分类任务微调
+分类任务微调有着两种形式：一种是普通的微调，一种是提示学习的方法。提示学习需要为任务额外构建一个完形填空的模板，它更适用于低资源以及小样本的情况。接下来我们以提示学习为例来介绍分类任务中的数据处理方法：
+### 分类任务应用代码
 ```python
-import torch.utils.data
-from flagai.data.dataset import SuperGlueDataset
+import torch
 from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer
-from tests.test_dataset_new_superglue import CollateArguments
+from flagai.data.dataset import SuperGlueDataset
+from flagai.test_utils import CollateArguments
 from flagai.data.dataset import ConstructSuperglueStrategy
 
 # 得到默认参数
@@ -47,10 +70,21 @@ dataset = SuperGlueDataset(task_name='cb',
                            dataset_type='train',
                            tokenizer=tokenizer)
 ```
-#### 1.加载数据集
 
-将`task_name`设置成数据集对应的简称后，运行以上代码，相关数据会在后台自动下载。FlagAI目前支持自动加载下列分类数据集：
+其中`SuperGlueDataset`是我们这一步的主函数，它的主要参数及其作用如下所示：
+
+`task_name`: 数据集的简称, FlagAI支持的数据集及其对应的简称如[加载数据集](#加载数据集)所示。
+
+`data_dir`: 数据集会被自动下载到`data_dir`对应的地址，默认为项目的`./dataset`目录。
 
+`dataset_type`: 可以为 train/dev/test, 分别代表要处理的是训练集/验证集/测试集
+
+`tokenizer`: 如[Tutorial1](/doc_zh/TUTORIAL_1_TOKENIZER.md)所介绍的构建完成的分词器
+
+
+#### 加载数据集
+
+FlagAI目前支持自动加载下列分类数据集：
 
 | 数据集名称                                     | 数据集简称    | 语言   | 所属评测基准   |
 |----------------------------------------------|----------|------|----------|
@@ -64,8 +98,6 @@ dataset = SuperGlueDataset(task_name='cb',
 | Ant Financial Question Matching Corpus       | afqmc    | 中文   | CLUE     |
 | Short Text Classificaiton for News           | tnews    | 中文   | CLUE     |
 
-数据集会被自动下载到`data_dir`对应的地址，默认为项目的`./dataset`目录。
-
 下载好的数据集目录下会包含三个文件，对应训练集数据，验证集数据，以及测试集数据, 以`CommitmentBank`数据集为例，目录下的`train.jsonl`对应训练集，`val.jsonl`对应验证集，`test.jsonl`对应测试集。一般来说训练集和测试集会包含标签信息，而测试集则没有。这些数据文件在接下来的流程中会分开处理。
 
 不同的数据集可能会有不同的文件格式，以及不同的结构。以`CommitmentBank`数据集为例，下面是其中的一个样例
@@ -83,7 +115,7 @@ dataset = SuperGlueDataset(task_name='cb',
 
 目前所有FlagAI支持数据集的具体结构可以在[这里](DATASET_EXAMPLE.md)查看。
 
-#### 2. 统一数据集结构
+#### 统一数据集结构
 在这一步里，我们会统一不同数据集的数据结构，以方便接下来处理。此结构的细节如下：
 
 
@@ -97,17 +129,16 @@ dataset = SuperGlueDataset(task_name='cb',
 | meta   | an optional dictionary to store arbitrary meta information                        | dict |
 | ids    | an optional numeric index                                                    | int  |
 
-例如上一步`CommitmentBank`的样例会被处理成如下的形式
+如果想要查看某个样例的数据结构，也可以直接在代码里通过索引的方式得到：
+```python
+example = dataset[3]  # 数据集里第3个样例
+```
+比如说，上一步`CommitmentBank`的样例会被处理成如下的形式:
 
 <div align=center><img src="img/dataset_figure_2.png" width="500px"></div>
 
-需要注意的是如果因为数据结构太复杂，导致text_a和text_b无法塞下背景文本信息的话，可以把剩下的信息放在`meta`里。
+需要注意的是如果因为数据结构太复杂，导致text_a和text_b无法塞下背景文本信息的话，剩下的信息会被放在`meta`里。
 
-当数据集被构造好以后，可以直接在代码里通过索引的方式查看其中某个样例：
-
-```python
-example = dataset[3]  # 数据集里第3个样例
-```
 
 ### 将数据整理成模型的输入
 
@@ -118,7 +149,7 @@ collate_fn = ConstructSuperglueStrategy(cl_args,
                                         task_name=task_name)
 ```
 
-#### 1.构建完形填空模板
+#### 构建完形填空模板
 
 一个完形填空模板包含了背景文本，空位，以及在提供给空位的选项。模型需要找到正确的选项，并填进空位里。
 
@@ -128,7 +159,7 @@ collate_fn = ConstructSuperglueStrategy(cl_args,
 
 可以看到，大体上可以分成两步：第一步是组合已有的文本，使其看上去符合完形填空格式；第二步是将原始的标签文本转化为新的标签，作为可能会填入空位的选项。        
 
-#### 2.分词并构造输入样例
+#### 分词并构造输入样例
 接下来，我们需要构造模型的输入，第一步是分词，而接下来则需要分成两种情况：
 
 第一种情况下，数据集包含的标签类别是有限的，比如`CommitmentBank`数据集里只会存在`entailment/contradiction/neutral`三种标签文本。第二类情况里每一段完型填空都会给出不同的选项(一般是一段长文本)。比如在一些阅读理解数据集里，每一个选项都是一段对于文本的不同理解。这两类情况的处理方法如下所示：
@@ -148,7 +179,7 @@ collate_fn = ConstructSuperglueStrategy(cl_args,
 
 <sup>1</sup>: seq_length代表规定的每个输入向量的最大长度
 
-<sup>2</sup>: 特殊字符添加流程：在句首添加[CLS]符号，句尾添加[EOS]符号，直到长度达到seq_length, 如果完形填空输出的文本有两段，则在中间添加[SEP]符号
+<sup>2</sup>: 特殊字符添加流程如下图所示：在句首添加[CLS]符号，句尾添加[EOS]符号，直到长度达到seq_length。
 <div align=center><img src="img/dataset_example_4.png" width="500px"></div>
 
 <sup>3</sup>: num_labels代表完形填空问题中选项的个数
@@ -189,9 +220,105 @@ for data_iterator in loader:
 ```
 加载器构造好之后即可用于接下来的训练和预测过程。<br /><br /><br />
 
+### 自定义数据处理
+如果要处理不支持的数据集，需要您手动实现以下功能
+
+1. 在`flagai/data/dataset/superglue/control.py`文件里, 如下所示创建自定义的processor函数， 然后把它与自定义数据集名字的映射关系添加到control.py下的`PROCESSOR_DICT`字典里。
+
+其中最主要的函数是`_create_example`, 需要在这里读取对应的数据集，并如[之前](#统一数据集结构)所示初步处理成统一的结构。
+
+```python
+class ExampleProcessor(DataProcessor):
+
+    def get_train_examples(self, data_dir):
+        # Assign the filename of train set
+        return self._create_examples(os.path.join(data_dir, "train.tsv"), "train")
+
+    def get_dev_examples(self, data_dir, for_train=False):
+        # Assign the filename of dev set
+        return self._create_examples(os.path.join(data_dir, "dev.tsv"), "dev")
+
+    def get_test_examples(self, data_dir) -> List[InputExample]:
+        # Assign the filename of test set
+        return self._create_examples(os.path.join(data_dir, "test.tsv"), "test")
+
+    def get_labels(self):
+        # Return all label categories
+        return ["0", "1"]
+
+    @staticmethod
+    def _create_examples(path: str, set_type: str) -> List[InputExample]:
+        """
+        InputExample包含下列信息
+        text_a (str, required): 文本1
+        text_b (str, optional): 文本2
+        label (str, required): 标签
+        guid (str, required): 每一个InputExample的唯一序号
+        """
+        examples = []
+        df = read_tsv(path)
+
+        for idx, row in df.iterrows():
+            guid = f"{set_type}-{idx}"
+            text_a = punctuation_standardization(row['sentence'])
+            label = row.get('label', None)
+            example = InputExample(guid=guid, text_a=text_a, label=label)
+            examples.append(example)
+        return examples
+
+
+
+```
+2. 在`flagai/data/dataset/superglue/control.py`文件里, 如下所示创建自定义的pvp函数， 然后把它与自定义数据集名字的映射关系添加到control.py下的`PVPS`字典里。
+
+此函数的主要功能是如[之前](#将数据整理成模型的输入)所说的构建完形填空模板，其主要函数有
+
+`get_parts`: 构造完形填空文本
+
+`verbalize`：把数据集的标签映射到完形填空的选项上
+
+
+```python
+class ExamplePVP(PVP):
+    # 把标签映射到对应的含义文本上
+    VERBALIZER = {
+        "contradiction": [" No"],
+        "entailment": [" Yes"],
+        "neutral": [" Maybe"]
+    }
+
+    @staticmethod
+    def available_patterns():
+        # 输出所有可用的模板
+        return [0]
+
+    @property
+    def is_multi_token(self):
+        # 如果标签包含大于一个token，就输出True
+        return False
+
+    def get_parts(self, example: InputExample) -> FilledPattern:
+       # 把InputExample里面的元素通过设计组合成一个完形填空模板  
+
+        text_a = self.shortenable(example.text_a)
+        text_b = self.shortenable(" " + example.text_b)
+        parts_a, parts_b = [
+            None, text_a, None, ' question:', text_b,
+            ' true, false or neither?', None, ' answer:', [self.mask]
+        ], []
+        parts_a, parts_b = self.replace_prompt_tokens(parts_a, parts_b)
+        return parts_a, parts_b
+    
+    def verbalize(self, label) -> List[str]:
+        # 借用类里自定义的VERBALIZER完成初始标签到完形填空选项的映射
+        return [' true'] if label == 'entailment' else [
+            ' false'
+        ] if label == 'contradiction' else [' neither']
+
+```
 
 ## 数据处理：GLM预训练任务
-预训练任务数据格式样例：
+### 预训练任务数据格式样例
 ```text
 {
     "RECORDS": [
@@ -216,14 +343,19 @@ for data_iterator in loader:
     ]
 }
 ```
-预训练的任务处理实例代码:
+### 预训练的任务处理实例代码
 ```python
+from flagai.data.tokenizer import GLMLargeChTokenizer
+from flagai.data.dataset import BlockDataset
+from flagai.data.dataset.block.data_utils import split_ds, get_dataset_lazy, add_args
+from flagai.test_utils import PretrainDatasetArguments
+
 tokenizer = GLMLargeChTokenizer(add_block_symbols=True,
                                 add_task_mask=True,
                                 add_decoder_mask=False,
                                 fix_command_token=True)
 
-ds_args = DatasetArguments()
+ds_args = PretrainDatasetArguments()
 
 tokenizer = GLMLargeChTokenizer(fix_command_token=True,
                                 add_block_symbols=True,
@@ -261,23 +393,24 @@ datasets = create_dataset(tokenizer, should_split=True)
 3. 预训练的时候，collate function会随机按照三种不同的模式处理数据: bert模式（遮挡随机区间），sentence模式(按照完整句子进行遮挡)以及gpt模式（只遮挡一段长区间）。模型的输入相比一般生成任务也会多一个`mode`键。
 4. 预训练不用添加模板，直接按下表构建模型输入即可
 
-| 键值             | 维度                                   | 含义         | 构造方法                                             |
-|----------------|--------------------------------------|------------|--------------------------------------------------|
-| input_ids      | torch.Size([seq_length<sup>1</sup>]) | 输入矩阵       | 由上一步的模板文本，加上一些特殊字符组成                             |
-| position_ids   | torch.Size([2， seq_length])          | 位置编码         | 参考[GLM流程](GLM.md)，第一行代表token的绝对位置，第二行代表遮挡部分的相对位置 |
-| attention_mask | torch.Size([1])                      | 分隔符位置         | 对于生成类的模式，得到源文本结束的位置；否则得到输入文本结束的位置                                          |
-| target_ids     | torch.Size([num_labels<sup>3</sup>]) | 全量标签列表     | 被遮挡住的文本                                          |
-| logit_mask     | torch.Size([seq_length])             | 通过遮挡使得模型只会处理目标文本部分的loss | 对于每个token, 如果是回答，则对应的地方为1，否则为0                   |                                                   
-| mode           | str                                  | 数据处理模式 |                    |  
+| 键值             | 维度                                   | 含义                            | 构造方法                                             |
+|----------------|--------------------------------------|-------------------------------|--------------------------------------------------|
+| input_ids      | torch.Size([seq_length<sup>1</sup>]) | 输入矩阵                          | 由上一步的模板文本，加上一些特殊字符组成                             |
+| position_ids   | torch.Size([2， seq_length])          | 位置编码                          | 参考[GLM流程](GLM.md)，第一行代表token的绝对位置，第二行代表遮挡部分的相对位置 |
+| attention_mask | torch.Size([1])                      | 分隔符位置                         | 对于生成类的模式，得到源文本结束的位置；否则得到输入文本结束的位置                                          |
+| target_ids     | torch.Size([num_labels<sup>3</sup>]) | 全量标签列表                        | 被遮挡住的文本                                          |
+| logit_mask     | torch.Size([seq_length])             | 通过遮挡使得模型只会处理目标文本部分的loss       | 对于每个token, 如果是回答，则对应的地方为1，否则为0                   |                                                   
+| mode           | str                                  | 数据处理模式，取值范围：bert/sentence/gpt |                    |  
+
 <br /><br /><br />
 
-## 数据处理：生成任务微调
-代码实现如下所示：
+## 数据处理：生成任务微调 
+### 生成任务应用代码
 ```python 
-import torch.utils.data
+import torch
 from flagai.data.dataset import Seq2SeqDataset
 from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer
-from tests.test_dataset_new_superglue import Seq2SeqCollateArguments
+from flagai.test_utils import CollateArguments
 from flagai.data.dataset import ConstructSeq2seqStrategy
 
 # 得到默认参数
@@ -308,9 +441,9 @@ loader = torch.utils.data.DataLoader(dataset,
                                     collate_fn=collate_fn)
 ```
 
-### 初步读取并处理数据集
+### 生成任务里初步读取并处理数据集
 
-目前支持[CMRC2018](https://www.clue.ai/introduce.html)任务，CMRC是一个阅读理解类的任务，需要根据背景文本来回答一系列提问，其数据结构示例如下：
+以[CMRC2018](https://www.clue.ai/introduce.html)为例，CMRC是一个阅读理解类的任务，需要根据背景文本来回答一系列提问，其数据结构示例如下：
 
 ```text
 {'paragraphs': 
@@ -340,7 +473,7 @@ dataset = Seq2SeqDataset(task_name='cmrc', data_dir='./datasets/',
                             dataset_type='train', tokenizer=tokenizer) 
 ```
 
-### 将数据整理成模型的输入
+### 生成任务里将数据整理成模型的输入
 
 代码如下所示。与生成任务相比，同样是构造模板以及模型输入，区别在于构造的方式不一样
 ```python 
@@ -349,12 +482,12 @@ collate_fn = ConstructSeq2seqStrategy(cl_args,
                                         task_name=task_name) 
 ```
 
-#### 1.构建填空模板
+#### 生成任务里构建填空模板
 由于是阅读理解任务，所以在模板里需要体现出是针对指定的阅读理解问题进行回答的，参考如下构建方式
 <div align=center><img src="img/dataset_figure_4.png" width="500px"></div>
 
 
 
-#### 2.分词并构造输入样例
+#### 生成任务里分词并构造输入样例
 与预训练类似，区别在于没有mode这个键值。
 
diff --git a/doc_zh/TUTORIAL_4_TRAINER.md b/doc_zh/TUTORIAL_4_TRAINER.md
index 7caa89ae..ebe39595 100644
--- a/doc_zh/TUTORIAL_4_TRAINER.md
+++ b/doc_zh/TUTORIAL_4_TRAINER.md
@@ -1,4 +1,4 @@
-# Trainer
+# 为模型和数据并行训练定制训练器
 - [Trainer](#trainer)
   - [入门](#入门)
   - [Trainer主要参数env_type](#trainer主要参数env_type)
@@ -100,9 +100,6 @@ FlagAI 项目的example目录位置：`examples/t5_huggingface
 t5-11b`
 
 ```python
-# Copyright © 2022 BAAI. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License")
 from flagai.trainer import Trainer
 from transformers import T5ForConditionalGeneration, T5Tokenizer
 from torch.utils.data import Dataset
@@ -112,7 +109,6 @@ import torch
 class MyTrainer(Trainer):
 
     def forward_step(self, data, model, mems):
-
         model_outputs = model(**data)
         output = {}
         output['loss'] = model_outputs.loss
@@ -238,7 +234,7 @@ trainer.train(model,
 ```
 
 ## 分布式训练
-为了加速模型训练，FlagAI支持三种模式的并行方式，但是在上述训练T5-11b的例子中，只能使用`deepspeed`框架的数据并行模式。
+为了加速模型训练，飞智支持三种模式的并行方式，但是在上述训练T5-11b的例子中，只能使用`deepspeed`框架的数据并行模式。
 
 ### deepspeed
 deepspeed主要在优化器方面做了优化，其提供了cpu-offload的optimizer，可以极大的降低gpu显存的占用。对deepspeed优化器的相关设置，需要提供`deepspeed.json`的配置文件 
@@ -311,7 +307,7 @@ trainer = MyTrainer(
 ```
 ### deepspeed + megatron-lm
 现在百亿级模型GLM-10-ch采用了`Megatron-LM`的模型并行技术加上`deepspeed`的数据并行技术。在模型参数scaling到10b以上级别，单卡的显存就很难将单个模型以及训练时的中间变量全部加载进来。为此，Megatron-LM提供了Tensor的切分方法，主要思想是将矩阵按照行/列进行切分。 FlagAI 将model转化为Megatron-LM版本。
-如下，FlagAI内部模型（GLM，T5，BERT【包括RoBERTa】，GPT2）支持了Megatron-LM，只要在配置文件中将环境变量修改为deepspeed+mpu，就能启动模型并行的功能。
+如下，飞智内部模型（GLM，T5，BERT【包括RoBERTa】，GPT2）支持了Megatron-LM，只要在配置文件中将环境变量修改为deepspeed+mpu，就能启动模型并行的功能。
 对于huggingface版本的模型，暂时没有提供模型并行的支持。
 ```python
 trainer = MyTrainer(
diff --git a/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md b/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md
index 42442a55..3448e816 100644
--- a/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md
+++ b/doc_zh/TUTORIAL_5_INSTRUCTIONS_FOR_AutoLoader.md
@@ -1,9 +1,9 @@
-## 自动加载器
+## 使用 Autoloader 简化模型和分词器初始化过程
 
-### 通过 AutoLoader 快速构建支持不同下游任务的大型模型和对应切词器。
+### 通过 AutoLoader 快速构建支持不同下游任务的大型模型。
 ![](./img/autoloader_map.png)
 
-AutoLoader 可以快速找到对应的预训练模型和切词器，只需输入 task_name 和 model_name 即可。
+AutoLoader 可以快速找到对应的预训练模型和分词器，只需输入 task_name 和 model_name 即可。
 
 以标题生成任务为例：
 
@@ -70,17 +70,17 @@ tokenizer = auto_loader.get_tokenizer()
 7. ...
 
 ### 所有支持的模型
-所有支持的模型都可以在 **model hub** 中找到。
+所有支持的模型都可以在 **[这里](./TUTORIAL_3_MODEL.md#所有支持模型)** 中找到。
 不同的模型适应不同的任务。
 
-#### Transfomrer 编码器:
+#### Transfomrer encoder:
 
 例如，model_name="GLM-large-ch" 或 "RoBERTa-base-ch" 这些模型支持上一节中提到的所有任务。
 
-#### Transformer 解码器:
+#### Transformer decoder:
 
 例如，model_name="GPT2-base-ch"，模型支持“seq2seq”相关任务。
 
-#### Transformer 编码器+解码器:
+#### Transformer encoder + decoder:
 
 例如model_name="t5-base-ch"，模型支持“seq2seq”相关任务。
\ No newline at end of file
diff --git a/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md b/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md
index d75719c2..b072ddb9 100644
--- a/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md
+++ b/doc_zh/TUTORIAL_6_INSTRUCTIONS_FOR_PREDICTOR.md
@@ -1,4 +1,4 @@
-## 预测器 Predictor
+## 将现成的推理算法与 Predictor 结合使用
 
 ### 通过Predictor调用一行代码得到理想的预测结果
 
diff --git a/doc_zh/TUTORIAL_7_PROMPT_LEARNING.md b/doc_zh/TUTORIAL_7_PROMPT_LEARNING.md
index ada0e194..84a35c06 100644
--- a/doc_zh/TUTORIAL_7_PROMPT_LEARNING.md
+++ b/doc_zh/TUTORIAL_7_PROMPT_LEARNING.md
@@ -1,4 +1,4 @@
-# 提示学习介绍
+# 使用 FlagAI 提示学习工具包来提高在SuperGLUE任务上的表现
 
 ## 背景
 提示学习(prompt-learning)是一种自然语言处理 (NLP) 领域广泛使用的范式，尤其是在数据有限的情况下表现良好。它遵循预训练-微调范式的思想：即预训练好的语言模型将被适配到各种下游任务上。不过与微调不同的是，提示学习会将原本的任务转化为一个特定的模板，这个过程被称为提示工程。
@@ -19,43 +19,19 @@
 
 我们可以设计一个如下的模板：
 
-<div align=center><img src="img/prompt_figure_1.png" width="500px"></div>
-
-相关的代码实现如下：
-
-```python
-def get_parts(self, example: InputExample):  
-    '''A simplified version of the actual code'''
-    # Construct the template
-    cloze_ids = [
-        example.text_a,' question: is it true, false or neither that',
-         example.text_b, ' answer:', [self.mask]]
-    return cloze_ids
-```
-
-各种数据集中的标签可以有多种类型，包括布尔值、整数和字符串。我们需要实现一个语言器，将标签映射到完形填空问题中的选项。例如，这里的“entailment”、“contradiction”和“neutral”标签可以映射到“true”、“false”和“neither”，并且每次要填的答案总是在这些选项中选择。
-
-语言器本质上是一种映射关系, 所以我们可以用一个Python字典来定义它：
-```python
-VERBALIZER = {
-    "contradiction": [" false"],
-    "entailment": [" true"],
-    "neutral": [" neither"]
-}
-def verbalize(self, label) -> List[str]:
-    return CbPVP.VERBALIZER[label]
-```
+<div align=center><img src="img/dataset_example_3.png" width="500px"></div>
 
 ### 前缀提示
 前缀提示并没有用真正的自然语言设计模板，而是直接修改嵌入空间。如下图所示，它在Transformer里插入一个前缀向量，并冻结语言模型的其余参数。与完形填空提示对比，这么做相当于从离散的tokens变成了连续的向量，避免了人工设计模板的好坏对于模型性能的影响过大的问题。
 <div align=center><img src="img/prompt_figure_2.png" width="600px"></div>
 
 
-## Reference
-[Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing](https://arxiv.org/abs/2107.13586)
+## 引用
 
-[OpenPrompt: An Open-source Framework for Prompt-learning](https://arxiv.org/abs/2111.01998)
+Liu, P. (2021, July 28). Pre-train, Prompt, and Predict: A Systematic Survey of Prompting. . . arXiv.Org. https://arxiv.org/abs/2107.13586 
 
-[Exploiting Cloze Questions for Few Shot Text Classification and Natural Language Inference](https://arxiv.org/abs/2001.07676)
+Ding, N. (2021, November 3). OpenPrompt: An Open-source Framework for Prompt-learning. arXiv.Org. https://arxiv.org/abs/2111.01998
 
-[Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://arxiv.org/abs/2101.00190)
\ No newline at end of file
+Schick, T. (2020, January 21). Exploiting Cloze Questions for Few Shot Text Classification and. . . arXiv.Org. https://arxiv.org/abs/2001.07676
+
+Li, X. L. (2021, January 1). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv.Org. https://arxiv.org/abs/2101.00190
diff --git a/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md b/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md
index 8712c78f..fc4a1c2f 100644
--- a/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md
+++ b/doc_zh/TUTORIAL_8_ENVIRONMENT_SETUP.md
@@ -1,4 +1,4 @@
-# 预训练分布式环境搭建
+# 多机训练模型搭建环境
 
 # 一.  Docker
 
diff --git a/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md b/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md
index efbba1c9..2a85c838 100644
--- a/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md
+++ b/doc_zh/TUTORIAL_9_SEQ2SEQ_METHOD.md
@@ -1,4 +1,4 @@
-# 序列到序列生成方法
+# 使用encoder/decoder/encoder-decoder模型进行文本生成
 
 支持三种方式进行序列到序列任务的生成，包括
 1. 只用Encoder模型进行序列到序列的生成任务 
diff --git a/doc_zh/img/dataset_figure_3.png b/doc_zh/img/dataset_figure_3.png
index be869428..20e38840 100644
Binary files a/doc_zh/img/dataset_figure_3.png and b/doc_zh/img/dataset_figure_3.png differ
diff --git a/doc_zh/img/prompt_figure_1.png b/doc_zh/img/prompt_figure_1.png
index 28dbd5fd..c67ba6d1 100644
Binary files a/doc_zh/img/prompt_figure_1.png and b/doc_zh/img/prompt_figure_1.png differ
diff --git a/doc_zh/img/tokenize.png b/doc_zh/img/tokenize.png
new file mode 100644
index 00000000..71888a1a
Binary files /dev/null and b/doc_zh/img/tokenize.png differ
diff --git a/doc_zh/tokenization.md b/doc_zh/tokenization.md
index f22461f7..1ede7e80 100644
--- a/doc_zh/tokenization.md
+++ b/doc_zh/tokenization.md
@@ -1,5 +1,3 @@
-[TOC]
-
 # sub-word algorithm
 
 ## Tokenization
@@ -38,7 +36,7 @@
 
 ​		三种不同的切分方法效果对比如下：
 
-![3 different tokenization scheme: on rules, on punctuaction, on white spaces](tokenization.assets/tokenize.png)
+![3 different tokenization scheme: on rules, on punctuaction, on white spaces](img/tokenize.png)
 
 ​		上面说的三种分词方法，都是词级别的分词方法（word tokenization），简单来说，就是以词为单位对文本进行切分。尽管这是将文本切分为更小的单位的最直观的方式，但是这种方式在处理大量语料的时候会产生一个非常严重的问题——生成一个巨大的词表（因为大量的语料中会存在大量的只出现一次/少次的token）。
 
@@ -182,14 +180,17 @@
 
 ​		与 BPE 的主要区别在于，选择两个子词进行合并的规则：BPE 选择频数最高的相邻子词合并，而 WordPiece 使用的是通过语言模型来计算合并两个单词可能造成的影响，然后选择使得似然函数提升最大的字符对。这个提升是通过结合后的字符对减去结合前的字符对之和得到的。
 
-​		假设句子$S=（t1,t2,...,t_n）$由 n 个 token 组成，$t_i$表示第$i$个 token，假设各个 token 之间是相互独立的，则句子$S$的语言模型似然值等于所有子词概率的乘积
-$$
-logP(S) = \sum^n_{i=1}logP(t_i)
-$$
+​		假设句子$ S=（t1,t2,...,t_n）$由 n 个 token 组成，$t_i$表示第$i$个 token，假设各个 token 之间是相互独立的，则句子$S$的语言模型似然值等于所有子词概率的乘积
+
+<img src="https://render.githubusercontent.com/render/math?math={logP(S) = \sum^n_{i=1}logP(t_i)}} = -1">
+`$ logP(S) = \sum^n_{i=1}logP(t_i) $`
+
+<img src="https://render.githubusercontent.com/render/math?math={\color{white}\L = -\sum_{j}[T_{j}ln(O_{j})] + \frac{\lambda W_{ij}^{2}}{2} \rightarrow \text{one-hot} \rightarrow -ln(O_{c}) + \frac{\lambda W_{ij}^{2}}{2}}">
+
 ​		假设把相邻位置的两个 token $x$ 和 $y$ 进行合并，合并后的 token 记为 $z$，此时句子 $S$ 的似然值变化可以表示为：
-$$
+`$
 logP(t_z)-(logP(t_x)+logP(t_y)) = log(\frac{P(t_z)}{P(t_x)P(T_y)})
-$$
+$`
 ​		也就是说，判断`tokenization`相较于`token` + `ization`是否更适合出现。选择能够提升语言模型概率最大的相邻子词加入词表。
 
 
diff --git a/docs/GLM.md b/docs/GLM.md
index 4c1e7a68..598510a0 100644
--- a/docs/GLM.md
+++ b/docs/GLM.md
@@ -9,12 +9,14 @@ The **GLM model**, proposed in [GLM: General Language Model Pretraining
 with Autoregressive Blank Infilling](https://arxiv.org/abs/2103.10360), is based on a slightly different strategy: autoregressive blank infilling. 
 
 It claims to perform well in the three main categories of NLP taks: classification, unconditional generation, and conditional generation tasks.
+
 | Framwork        | NLU | Cond.Gen. | Uncond.Gen |
 |-----------------|-----|-----------|------------|
 | Augoregressive  | -   | -         | ✅          |
 | Autoencoding    | ✅   | ×         | ×          |
 | Encoder-Decoder | -   | ✅         | -          |
 | GLM             | ✅   | ✅         | ✅          |
+
 The key features of GLM include:
 
 - First task: Several spans of the text are masked following the idea of autoencoding. Those spans will be randomly rearranged and be predicted in an autoregressive manner. The masked spans covers 15% original tokens.
diff --git a/docs/TUTORIAL_14_HUGGINGFACE_T5.md b/docs/TUTORIAL_14_HUGGINGFACE_T5.md
index acd18f81..b78227fd 100644
--- a/docs/TUTORIAL_14_HUGGINGFACE_T5.md
+++ b/docs/TUTORIAL_14_HUGGINGFACE_T5.md
@@ -159,18 +159,7 @@ trainer = MyTrainer(
 Do not save the itermedia results in forward stage. Now you may run t5-11b with `batch size`=1.
 Now, we can train/finetune a t5-11b with `gradient_accumulation_steps`.
 ```python
-trainer = MyTrainer(
-    env_type='pytorch',
-    epochs=1,
-    batch_size=1,
-    eval_interval=10,
-    log_interval=10,
-    experiment_name='t5-11b',
-    pytorch_device='cuda:0',
-    load_dir=None,
-    lr=1e-4,
-    fp16=True
-    checkpoint_activations = True) # setting as `True`
+model.gradient_checkpointing = True
 ```  
 ### step3. data parallel (DDP)
 To multiply your batch size, we can use data paralle on multiple GPUs.
diff --git a/docs/TUTORIAL_1_TOKENIZER.md b/docs/TUTORIAL_1_TOKENIZER.md
index bc38f365..bb116385 100644
--- a/docs/TUTORIAL_1_TOKENIZER.md
+++ b/docs/TUTORIAL_1_TOKENIZER.md
@@ -13,7 +13,9 @@ input text `Jack is walking a dog.` is shown below:
 <div align=center><img src="img/tokenizer_example_1.png" width="500px"></div>
 
 It is noticeable that different tokenizers can have different ways to split text,
-and have different vocabulary files. An introduction to those algorithms can be viewed [here](tokenization.md).
+and have different vocabulary files. 
+
+[//]: # (An introduction to those algorithms can be viewed [here]&#40;tokenization.md&#41;.)
 
 Our projects currently support six tokenizers
 as listed below:
diff --git a/docs/TUTORIAL_2_DATASET.md b/docs/TUTORIAL_2_DATASET.md
index 230c419c..222ef66b 100644
--- a/docs/TUTORIAL_2_DATASET.md
+++ b/docs/TUTORIAL_2_DATASET.md
@@ -5,14 +5,16 @@ The process of constructing a dataset is the data preprocessing process of NLP.
 
 At present, there are three kinds of data preprocessing in the project, namely, fine-tuning for classification tasks, pre-training, and fine-tuning for generation tasks. We will expand on them separately in the following.
 
-## Data processing: fine-tuning for classification tasks ([prompt-learning mode](TUTORIAL_7_PROMPT_LEARNING.md))
+## Data processing: fine-tuning for classification tasks 
+
+There are two forms of tuning for classification tasks: one is fine-tuning, and the other is the [prompt-tuning](/docs/TUTORIAL_7_PROMPT_LEARNING.md). Prompt-tuning requires an additional cloze template for the task, which is more suitable for limited data. Let's take prompt learning as an example to introduce the data processing method in classification tasks:
 ### Application code
 
 ```python
-import torch.utils.data
-from flagai.data.dataset import SuperGlueDataset
+import torch
 from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer
-from tests.test_dataset_new_superglue import CollateArguments
+from flagai.data.dataset import SuperGlueDataset
+from flagai.test_utils import CollateArguments
 from flagai.data.dataset import ConstructSuperglueStrategy
 
 # get default parameters
@@ -49,23 +51,34 @@ dataset = SuperGlueDataset(task_name='cb',
                            dataset_type='train',
                            tokenizer=tokenizer)
 ```
-#### 1. Load the dataset
+`SuperGlueDataset`is the function in this step，and its major parameters are introduced below：
+
+`task_name`: Identifier of dataset, Supported datasets and their identifiers are given at the table in [1.Load the dataset](#1.Load the dataset).
+
+`data_dir`: Data will be automatically downloaded to `data_dir` directory, which is `./dataset` by default.
+
+`dataset_type`: It can be train/dev/test, which represents train/validation/test set is going to be preprocessed.
+
+`tokenizer`: Constructed tokenizer as introduced in [Tutorial1](/docs/TUTORIAL_1_TOKENIZER.md).
+
+
 
-After setting `task_name` to the abbreviation of the task name, the relevant data will be automatically downloaded in the background. FlagAI currently supports automatic loading of the following classification datasets:
 
-| dataset name                                 | short name| Language | Benchmark   |
-|----------------------------------------------|----------|------|----------|
-| Broadcoverage Diagnostics                    | boolq    | Eng   | SuperGLUE |
-| CommitmentBank                               | cb       | Eng   | SuperGLUE |
-| Choice of Plausible Alternatives             | copa     | Eng   | SuperGLUE |
-| Multi-Sentence Reading Comprehension         | muiltirc | Eng   | SuperGLUE |
-| Recognizing Textual Entailment               | rte      | Eng   | SuperGLUE |
-| Words in Context                             | wic      | Eng   | SuperGLUE |                                                   
-| The Winograd Schema Challenge                | wsc      | Eng   | SuperGLUE |
-| Ant Financial Question Matching Corpus       | afqmc    | Zh    | CLUE     |
-| Short Text Classificaiton for News           | tnews    | Zh    | CLUE     |
+#### 1.Load the dataset
 
-The dataset will be automatically downloaded to the address corresponding to `data_dir`, which defaults to the `./dataset` directory of the project.
+FlagAI currently supports automatic loading of the following classification datasets:
+
+| dataset name                                 | Identifier | Language | Benchmark   |
+|----------------------------------------------|------------|------|----------|
+| Broadcoverage Diagnostics                    | boolq      | Eng   | SuperGLUE |
+| CommitmentBank                               | cb         | Eng   | SuperGLUE |
+| Choice of Plausible Alternatives             | copa       | Eng   | SuperGLUE |
+| Multi-Sentence Reading Comprehension         | muiltirc   | Eng   | SuperGLUE |
+| Recognizing Textual Entailment               | rte        | Eng   | SuperGLUE |
+| Words in Context                             | wic        | Eng   | SuperGLUE |                                                   
+| The Winograd Schema Challenge                | wsc        | Eng   | SuperGLUE |
+| Ant Financial Question Matching Corpus       | afqmc      | Zh    | CLUE     |
+| Short Text Classificaiton for News           | tnews      | Zh    | CLUE     |
 
 The downloaded dataset directory will contain three files, corresponding to the training set data, the validation set data, and the test set data. Take the CommitmentBank dataset as an example, the `train.jsonl` in the directory corresponds to the training set, `val.jsonl `corresponds to the validation set, `test.jsonl` corresponds to the test set. Generally, the training set and test set contain label information, but the test set does not. These data files will be processed separately in the next process.
 
@@ -98,18 +111,19 @@ In this step, we will unify the data structures of different datasets to facilit
 | meta   | an optional dictionary to store arbitrary meta information                        | dict |
 | ids    | an optional numeric index                                                    | int  |
 
-For example, the example of CommitBank in the previous step will be processed into the following form
+When the dataset is built, you can view one of the samples directly in the code by indexing:
+
+```python
+example = dataset[3]  # The third example in dataset 
+```
+
+For instance, the example of CommitBank in the previous step will be processed into the following form
 
 <div align=center><img src="img/dataset_figure_2.png" width="500px"></div>
 
 Noted that if text_a and text_b cannot be filled with background text information because the data structure is too complex, you can put the rest of the information in meta.
 
-When the dataset is constructed, you can view one of the samples directly in the code by indexing:
-
 
-```python
-example = dataset[3]  # The third example in dataset 
-```
 
 ### Organize the data into input to the model
 
@@ -148,7 +162,7 @@ In the first case, the label categories contained in the dataset are limited. Fo
 
 <sup>1</sup>: seq_length represents the specified maximum length of each input vector
 
-<sup>2</sup>: The process of adding special characters: add the [CLS] symbol at the beginning of the sentence and the [EOS] symbol at the end of the sentence until the length reaches seq_length. If the text output by cloze has two paragraphs, it will be in the middle Add [SEP] symbol
+<sup>2</sup>: As illustrated in the following figure, the process of adding special characters: add the [CLS] symbol at the beginning of the sentence and the [EOS] symbol at the end of the sentence until the length reaches seq_length. If the text output by cloze has two paragraphs, it will be in the middle Add [SEP] symbol
 <div align=center><img src="img/dataset_figure_5.png" width="500px"></div>
 
 <sup>3</sup>: num_labels represents the number of options in the cloze problem
diff --git a/docs/TUTORIAL_7_PROMPT_LERANING.md b/docs/TUTORIAL_7_PROMPT_LERANING.md
index 144b5100..86c342ce 100644
--- a/docs/TUTORIAL_7_PROMPT_LERANING.md
+++ b/docs/TUTORIAL_7_PROMPT_LERANING.md
@@ -19,32 +19,6 @@ We can design a meaningful cloze template as below
 
 <div align=center><img src="img/prompt_figure_1.png" width="500px"></div>
 
-And we can implement the template through the following code:
-
-```python
-def get_parts(self, example: InputExample):  
-    '''A simplified version of the actual code'''
-    # Construct the template
-    cloze_ids = [
-        example.text_a,' question: is it true, false or neither that',
-         example.text_b, ' answer:', [self.mask]]
-    return cloze_ids
-```
-
-The label in various datasets can have multiple types including boolean, integer and string. We need to implement a verbalizer that maps the labels to the text string of choices in cloze question. For example, here the 'entailment', 'contradiction' and 'neutral' labels can be mapped to 'true' ,'false' and 'neither', and each time the answer to be filled is always selected among those choices. 
-
-Verbalizer is essentially a mapping relationship, and we can define it in a Python dictionary as shown below:
-
-```python
-VERBALIZER = {
-    "contradiction": [" false"],
-    "entailment": [" true"],
-    "neutral": [" neither"]
-}
-def verbalize(self, label) -> List[str]:
-    return CbPVP.VERBALIZER[label]
-```
-
 ### Prefix Prompts
 Instead of designing a prompt in real natural language, prefix prompts directly modifies the embedding space. It inserts a sequence of task-specific vectors and freezes the LM parameters. An advantage of prefix prompts is that embeddings of templates are no longer limited by parameters in pre-trained LMs. 
 
@@ -54,10 +28,10 @@ Here is an example that compares prefix tuning and fine-tuning in the embedding
 
 
 ## Reference
-[Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing](https://arxiv.org/abs/2107.13586)
+Liu, P. (2021, July 28). Pre-train, Prompt, and Predict: A Systematic Survey of Prompting. . . arXiv.Org. https://arxiv.org/abs/2107.13586 
 
-[OpenPrompt: An Open-source Framework for Prompt-learning](https://arxiv.org/abs/2111.01998)
+Ding, N. (2021, November 3). OpenPrompt: An Open-source Framework for Prompt-learning. arXiv.Org. https://arxiv.org/abs/2111.01998
 
-[Exploiting Cloze Questions for Few Shot Text Classification and Natural Language Inference](https://arxiv.org/abs/2001.07676)
+Schick, T. (2020, January 21). Exploiting Cloze Questions for Few Shot Text Classification and. . . arXiv.Org. https://arxiv.org/abs/2001.07676
 
-[Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://arxiv.org/abs/2101.00190)
\ No newline at end of file
+Li, X. L. (2021, January 1). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv.Org. https://arxiv.org/abs/2101.00190
diff --git a/docs/tokenization.md b/docs/tokenization.md
index f22461f7..8a582dc1 100644
--- a/docs/tokenization.md
+++ b/docs/tokenization.md
@@ -1,5 +1,3 @@
-[TOC]
-
 # sub-word algorithm
 
 ## Tokenization
@@ -38,7 +36,7 @@
 
 ​		三种不同的切分方法效果对比如下：
 
-![3 different tokenization scheme: on rules, on punctuaction, on white spaces](tokenization.assets/tokenize.png)
+![3 different tokenization scheme: on rules, on punctuaction, on white spaces](img/tokenize.png)
 
 ​		上面说的三种分词方法，都是词级别的分词方法（word tokenization），简单来说，就是以词为单位对文本进行切分。尽管这是将文本切分为更小的单位的最直观的方式，但是这种方式在处理大量语料的时候会产生一个非常严重的问题——生成一个巨大的词表（因为大量的语料中会存在大量的只出现一次/少次的token）。
 
@@ -174,22 +172,20 @@
 
 ***
 
-
-
 ## WordPiece
 
 ​		WordPiece 算法最早发表于 [Japanese and Korean Voice Search (Schuster et al., 2012)](https://static.googleusercontent.com/media/research.google.com/ja//pubs/archive/37842.pdf)，它和 BPE 算法非常相似。也有一些预训练模型的分词器用的是这个算法，比如 BERT、DistilBERT 和 Electra。与 BPE 算法类似，WordPiece 算法也是初始化一个基础词表，然后每次从词表中选出两个子词合并成新的子词。
 
 ​		与 BPE 的主要区别在于，选择两个子词进行合并的规则：BPE 选择频数最高的相邻子词合并，而 WordPiece 使用的是通过语言模型来计算合并两个单词可能造成的影响，然后选择使得似然函数提升最大的字符对。这个提升是通过结合后的字符对减去结合前的字符对之和得到的。
 
-​		假设句子$S=（t1,t2,...,t_n）$由 n 个 token 组成，$t_i$表示第$i$个 token，假设各个 token 之间是相互独立的，则句子$S$的语言模型似然值等于所有子词概率的乘积
-$$
-logP(S) = \sum^n_{i=1}logP(t_i)
-$$
-​		假设把相邻位置的两个 token $x$ 和 $y$ 进行合并，合并后的 token 记为 $z$，此时句子 $S$ 的似然值变化可以表示为：
-$$
-logP(t_z)-(logP(t_x)+logP(t_y)) = log(\frac{P(t_z)}{P(t_x)P(T_y)})
-$$
+​		假设句子<img src="https://latex.codecogs.com/png.latex? S=(t1,t2,...,t_n)"> 由 n 个 token 组成，<img src="https://latex.codecogs.com/png.latex? t_i">表示第i个 token，假设各个 token 之间是相互独立的，则句子`S`的语言模型似然值等于所有子词概率的乘积
+
+<img src="https://latex.codecogs.com/png.latex? logP(S) = \sum^n_{i=1}logP(t_i)">
+
+​		假设把相邻位置的两个 token `x` 和 `y` 进行合并，合并后的 token 记为 `z`，此时句子 `S` 的似然值变化可以表示为：
+
+<img src="https://latex.codecogs.com/png.latex? logP(t_z)-(logP(t_x)+logP(t_y)) = log(\frac{P(t_z)}{P(t_x)P(T_y)})">
+
 ​		也就是说，判断`tokenization`相较于`token` + `ization`是否更适合出现。选择能够提升语言模型概率最大的相邻子词加入词表。
 
 
@@ -200,20 +196,20 @@ $$
 
 ​		并没有预训练模型单独使用 ULM 作为分词的算法，但是它常与 SentencePiece 一起使用。
 
-​		对于句子$S$，$\mathop{x}\limits ^{\rightarrow} = (x_1,x_2,...,x_m)$为句子的一个分词结果，由 m 个子词组成。所以，当前分词下句子$S$的似然值可以表示为：
-$$
-P(\mathop{x}\limits ^{\rightarrow}) = \prod^m_{i=1}P(x_i)
-$$
+​		对于句子S，<img src="https://latex.codecogs.com/png.latex? \mathop{x}\limits ^{\rightarrow} = (x_1,x_2,...,x_m)">为句子的一个分词结果，由 m 个子词组成。所以，当前分词下句子$S$的似然值可以表示为：
+
+<img src="https://latex.codecogs.com/png.latex? P(\mathop{x}\limits ^{\rightarrow}) = \prod^m_{i=1}P(x_i)">
+
 ​		对于句子$S$，挑选似然值最大的作为分词结果，则可以表示为：
-$$
-x^* = \mathop{argmax}\limits_{x \in U(x)}~P(\mathop{x}\limits ^{\rightarrow})
-$$
-​		这里的$U(x)$包含了句子的所有分词结果。在实际应用中，词表大小有上万个，直接罗列所有的分词组合不具有操作性。针对这个问题，可以通过维特比算法得到 $x^*$来解决。
-
-​		ULM 通过 EM 算法来估计每个子词的概率$P(x_i)$，假设当前词表为V，训练数据为|D|，则当前训练数据中所有句子的所有分词组合形成的概率相加，表示为：
-$$
-L = \sum^{|D|}_{s=1}log(P(X^{(s)}))=\sum^{|D|}_{s=1}log(\mathop{\sum_{x \in U(X^{(s)})}}P(x))
-$$
+
+<img src="https://latex.codecogs.com/png.latex? x^* = \mathop{argmax}\limits_{x \in U(x)}~P(\mathop{x}\limits ^{\rightarrow})">
+
+​		这里的$U(x)$包含了句子的所有分词结果。在实际应用中，词表大小有上万个，直接罗列所有的分词组合不具有操作性。针对这个问题，可以通过维特比算法得到 <img src="https://latex.codecogs.com/png.latex? x^*">来解决。
+
+​		ULM 通过 EM 算法来估计每个子词的概率<img src="https://latex.codecogs.com/png.latex? P(x_i)">，假设当前词表为V，训练数据为|D|，则当前训练数据中所有句子的所有分词组合形成的概率相加，表示为：
+
+<img src="https://latex.codecogs.com/png.latex? L = \sum^{|D|}_{s=1}log(P(X^{(s)}))=\sum^{|D|}_{s=1}log(\mathop{\sum_{x \in U(X^{(s)})}}P(x))">
+
 ​		在训练的开始阶段，ULM 初始化一个巨大的基础词表，然后针对当前词表，用上面的算法计算每个子词在训练数据上的概率，然后计算移除每个子词时，语言模型整体的损失上升了多少，记为这个子词的损失值。然后通过排序，按照一定比例移除掉词表中损失值最低的一部分子词（这个比例一般是10%或者20%），这些子词的损失值最低，意味着他们对语言模型的影响最小。每训练一步，都会移除掉部分的子词，直到词表大小达到预设值为止。（ULM 算法训练的过程中会保留基础的字符以保证任何词语都能被处理）。
 
 ​		训练完成的 UML 模型对一个句子给出多种的分词可能，比如说一个训练好的 ULM 分词器的词表如下：
diff --git a/examples/glm_pretrain/train.py b/examples/glm_pretrain/train.py
index 5e72f260..cad5e9d2 100644
--- a/examples/glm_pretrain/train.py
+++ b/examples/glm_pretrain/train.py
@@ -1,6 +1,7 @@
 # Copyright © 2022 BAAI. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License")
+
 from flagai.data.tokenizer import GLMLargeChTokenizer
 from flagai.model.glm_model import GLMForSeq2Seq
 from flagai.trainer import Trainer
@@ -8,20 +9,7 @@
 from flagai.data.dataset import BlockDataset
 from flagai.data.dataset.block.data_utils import split_ds, get_dataset_lazy, add_args
 from flagai.data.dataset.superglue.control import DEFAULT_METRICS
-
-
-class DatasetArguments:
-
-    def __init__(self):
-        self.task_mask = True  # Distinguished the generation and gap-sentence mask
-        self.block_mask_prob = 0.1
-        self.block_lm = True  # Whether do masking
-        self.masked_lm = False  # Whether do simple masking (same symbol among masks)
-
-        self.pre_tokenize = True
-        self.no_lazy_loader = True
-        self.half_lazy_loader = False
-        self.sentinel_token = False
+from flagai.test_utils import PretrainDatasetArguments
 
 
 if __name__ == '__main__':
@@ -39,7 +27,7 @@ def __init__(self):
 
     model = GLMForSeq2Seq.from_pretrain(model_name='GLM-large-ch')
 
-    ds_args = DatasetArguments()
+    ds_args = PretrainDatasetArguments()
 
     tokenizer = GLMLargeChTokenizer()
 
@@ -73,35 +61,9 @@ def create_dataset(tokenizer, should_split):
         collate_fn = ConstructBlockStrategy(
             tokenizer, 512, eod_token=tokenizer.get_command('eos').Id)
     metric_methods = DEFAULT_METRICS['pretrain']
-    # trainer.train(model,
-    #               collate_fn=collate_fn,
-    #               train_dataset=datasets[0],
-    #               valid_dataset=datasets[1],
-    #               metric_methods=metric_methods)
-    import torch
-
-    train_loader = torch.utils.data.DataLoader(datasets[0],
-                                               batch_size=16,
-                                               shuffle=False,
-                                               num_workers=1,
-                                               drop_last=False,
-                                               pin_memory=False,
-                                               collate_fn=collate_fn)
-    for data_iterator in train_loader:
-        dct = data_iterator
-        '''
-        input_ids torch.Size([16, 2, 256])
-        labels torch.Size([16])
-        position_ids torch.Size([16, 2, 2, 256])
-        attention_mask torch.Size([16, 2])
-        target_ids torch.Size([16, 2, 256])
-        logit_mask torch.Size([16, 2, 256])
-        loss_mask torch.Size([16, 2])
+    trainer.train(model,
+                  collate_fn=collate_fn,
+                  train_dataset=datasets[0],
+                  valid_dataset=datasets[1],
+                  metric_methods=metric_methods)
 
-        '''
-        for key, value in dct.items():
-            try:
-                print(key, value.size())
-            except:
-                print(key, len(value))
-        break
diff --git a/examples/glm_seq2seq/train.py b/examples/glm_seq2seq/train.py
index ffc4b185..91d9ec43 100644
--- a/examples/glm_seq2seq/train.py
+++ b/examples/glm_seq2seq/train.py
@@ -25,7 +25,7 @@ def test_init_trainer_pytorch(self):
                           eval_interval=5,
                           log_interval=50,
                           experiment_name='glm_large',
-                          pytorch_device='cpu',
+                          pytorch_device='cuda',
                           load_dir=None,
                           lr=1e-4)
         print("downloading...")
diff --git a/examples/glm_superglue/train.py b/examples/glm_superglue/train.py
deleted file mode 100644
index d1cdb2d2..00000000
--- a/examples/glm_superglue/train.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# Copyright © 2022 BAAI. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License")
-from flagai.trainer import Trainer
-from flagai.model.glm_model import GLMForSingleTokenCloze, GLMForMultiTokenCloze, GLMForMultiTokenClozeFast
-from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer, GLMLargeChTokenizer
-
-from flagai.data.dataset import SuperGlueDataset
-from flagai.test_utils import CollateArguments
-from flagai.data.dataset.superglue.control import DEFAULT_METRICS, MULTI_TOKEN_TASKS, CH_TASKS
-import unittest
-from flagai.data.dataset import ConstructSuperglueStrategy
-
-
-# task_name options: ['boolq', 'cb', 'copa', 'multirc', 'rte', 'wic', 'wsc', 'afqmc', 'tnews']
-task_name = "afqmc"
-
-trainer = Trainer(env_type='pytorch',
-                    epochs=10,
-                    batch_size=4,
-                    eval_interval=100,
-                    log_interval=50,
-                    experiment_name='glm_large',
-                    pytorch_device='cuda',
-                    load_dir=None,
-                    lr=1e-4)
-print("downloading...")
-
-cl_args = CollateArguments()
-cl_args.multi_token = task_name in MULTI_TOKEN_TASKS
-
-if task_name in CH_TASKS:
-    model_name = 'GLM-large-ch'
-    tokenizer = GLMLargeChTokenizer()
-else:
-    model_name = 'GLM-large-en'
-    tokenizer = GLMLargeEnWordPieceTokenizer()
-
-if cl_args.multi_token:
-    model = GLMForMultiTokenCloze.from_pretrain(model_name=model_name)
-else:
-    model = GLMForSingleTokenCloze.from_pretrain(model_name=model_name)
-
-train_dataset = SuperGlueDataset(task_name=task_name,
-                                    data_dir='./datasets/',
-                                    dataset_type='train',
-                                    tokenizer=tokenizer)
-
-collate_fn = ConstructSuperglueStrategy(cl_args,
-                                        tokenizer,
-                                        task_name=task_name)
-
-valid_dataset = SuperGlueDataset(task_name=task_name,
-                                    data_dir='./datasets/',
-                                    dataset_type='dev',
-                                    tokenizer=tokenizer)
-
-metric_methods = DEFAULT_METRICS[task_name]
-trainer.train(model,
-                collate_fn=collate_fn,
-                train_dataset=train_dataset,
-                valid_dataset=valid_dataset,
-                metric_methods=metric_methods)
diff --git a/examples/glm_superglue/train_10b_clue.py b/examples/glm_superglue/train_10b_clue.py
index fbfd6882..d97f331a 100644
--- a/examples/glm_superglue/train_10b_clue.py
+++ b/examples/glm_superglue/train_10b_clue.py
@@ -1,19 +1,21 @@
 # Copyright © 2022 BAAI. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License")
+import os
 from flagai.trainer import Trainer
 from flagai.model.glm_model import GLMForSingleTokenCloze
 from flagai.data.tokenizer import GLMLargeChTokenizer
 from flagai.metrics import accuracy_metric
 from flagai.data.dataset import SuperGlueDataset
 from flagai.test_utils import CollateArguments
+from flagai.data.dataset import ConstructSuperglueStrategy
 
 
 task_name = 'tnews'
 trainer = Trainer(env_type='deepspeed',
                   epochs=2,
-                  batch_size=1,
-                  eval_interval=1000,
+                  batch_size=4,
+                  eval_interval=10,
                   checkpoint_activations=False,
                   fp16=True,
                   log_interval=1,
@@ -33,28 +35,24 @@
 
 tokenizer =  GLMLargeChTokenizer()
 train_dataset = SuperGlueDataset(task_name=task_name,
-                                 data_dir='/mnt/datasets/yan/',
+                                 data_dir='./datasets/',
                                  dataset_type='train',
                                  tokenizer=tokenizer,
                                  cloze_eval=True)
 valid_dataset = SuperGlueDataset(task_name=task_name,
-                                 data_dir='/mnt/datasets/yan/',
+                                 data_dir='./datasets/',
                                  dataset_type='dev',
                                  tokenizer=tokenizer,
                                  cloze_eval=True)
 
 cl_args = CollateArguments()
 cl_args.cloze_eval = True
-if task_name in ['copa', 'wsc', 'record']:
-    cl_args.multi_token = True
-
-from flagai.data.dataset import ConstructSuperglueStrategy
+cl_args.multi_token = False
 
 collate_fn = ConstructSuperglueStrategy(cl_args,
                                         tokenizer,
                                         task_name=task_name)
 trainer.train(model,
-
               train_dataset=train_dataset,
               valid_dataset=valid_dataset,
               collate_fn=collate_fn,
diff --git a/examples/glm_superglue/train_10b_superglue.py b/examples/glm_superglue/train_10b_superglue.py
index 49ce9414..082c86a6 100644
--- a/examples/glm_superglue/train_10b_superglue.py
+++ b/examples/glm_superglue/train_10b_superglue.py
@@ -3,12 +3,13 @@
 # Licensed under the Apache License, Version 2.0 (the "License")
 from flagai.trainer import Trainer
 from flagai.model.glm_model import GLMForSingleTokenCloze
-from flagai.data.tokenizer import GLMLargeEnWordPieceTokenizer
+from flagai.data.tokenizer import GLM10bENBPETokenizer
 from flagai.metrics import accuracy_metric
 from flagai.data.dataset import SuperGlueDataset
 from flagai.test_utils import CollateArguments
 
 
+
 task_name = 'boolq'
 trainer = Trainer(env_type='deepspeed+mpu',
                   epochs=2,
@@ -30,14 +31,15 @@
 model = GLMForSingleTokenCloze.from_pretrain(download_path="/mnt/test_10b_models",
                                              model_name="GLM-10b-en")
 
-tokenizer = GLMLargeEnWordPieceTokenizer()
+tokenizer = GLM10bENBPETokenizer()
+
 train_dataset = SuperGlueDataset(task_name=task_name,
-                                 data_dir='/mnt/datasets/yan/',
+                                 data_dir='./datasets/',
                                  dataset_type='train',
                                  tokenizer=tokenizer,
                                  cloze_eval=True)
 valid_dataset = SuperGlueDataset(task_name=task_name,
-                                 data_dir='/mnt/datasets/yan/',
+                                 data_dir='./datasets/',
                                  dataset_type='dev',
                                  tokenizer=tokenizer,
                                  cloze_eval=True)
diff --git a/examples/glm_title_generation/train.py b/examples/glm_title_generation/train.py
index 78841045..6c68375d 100644
--- a/examples/glm_title_generation/train.py
+++ b/examples/glm_title_generation/train.py
@@ -29,8 +29,9 @@
     num_checkpoints=1,
 )
 
-src_dir = './data/train.src'
-tgt_dir = './data/train.tgt'
+cur_dir = os.path.dirname(os.path.abspath(__file__))
+src_dir = cur_dir + '/data/train.src'
+tgt_dir = cur_dir + '/data/train.tgt'
 
 maxlen = 256
 auto_loader = AutoLoader("seq2seq",
diff --git a/examples/t5_huggingface/train_t5_11b.py b/examples/t5_huggingface/train_t5_11b.py
index a70c85e8..ed4f0d66 100644
--- a/examples/t5_huggingface/train_t5_11b.py
+++ b/examples/t5_huggingface/train_t5_11b.py
@@ -5,7 +5,7 @@
 from transformers import T5ForConditionalGeneration, T5Tokenizer
 from torch.utils.data import Dataset
 import torch
-
+import os
 
 class MyTrainer(Trainer):
 
@@ -36,8 +36,9 @@ def forward_step(self, data, model, mems):
 model.gradient_checkpointing = True
 
 print("loading model & tokenizer is done!")
-src_dir = './data/train.src'
-tgt_dir = './data/train.tgt'
+cur_dir = os.path.dirname(os.path.abspath(__file__))
+src_dir = cur_dir + '/data/train.src'
+tgt_dir = cur_dir + '/data/train.tgt'
 maxlen = 1024
 
 
diff --git a/flagai/trainer.py b/flagai/trainer.py
index 151ed339..ea3e28c8 100644
--- a/flagai/trainer.py
+++ b/flagai/trainer.py
@@ -392,7 +392,7 @@ def train(self,
             optimizer = get_optimizer(param_groups=param_groups,
                                       lr=self.lr,
                                       weight_decay=self.weight_decay,
-                                      cpu_optimizer=True,
+                                      cpu_optimizer=False,
                                       cpu_torch_adam=False,
                                       fp16=self.fp16)
 
@@ -568,7 +568,6 @@ def train_step(self,
             step_output = self.forward_step(data, model, mems)
             self.timers('forward').stop()
             lm_loss = step_output['loss']
-
             if 'deepspeed' not in self.env_type:
                 lm_loss /= self.gradient_accumulation_steps
 
@@ -583,7 +582,6 @@ def train_step(self,
             if 'deepspeed' in self.env_type:
                 reduced_loss.data = reduced_loss.data / \
                     (self.world_size / self.model_parallel_size)
-
             if not DynamicLossScaler._has_inf_or_nan(reduced_loss):
                 lm_loss_total += reduced_loss
                 count += 1
@@ -625,6 +623,7 @@ def train_step(self,
                 mems = []
             if single_step:
                 break
+
         # if train_args.deepspeed:
         if 'deepspeed' in self.env_type:
             lm_loss_total = lm_loss_total / count


Test patch:
diff --git a/flagai/test_utils.py b/flagai/test_utils.py
index 62af5cf2..3473fd53 100644
--- a/flagai/test_utils.py
+++ b/flagai/test_utils.py
@@ -153,7 +153,9 @@ def __init__(self):
         #
         # self.few_superglue = False
         # self.pattern_text = False
-class DatasetArguments:
+
+
+class PretrainDatasetArguments:
 
     def __init__(self):
         self.task_mask = True  # Distinguished the generation and gap-sentence mask
@@ -164,4 +166,5 @@ def __init__(self):
         self.pre_tokenize = True
         self.no_lazy_loader = True
         self.half_lazy_loader = False
-        self.sentinel_token = False
\ No newline at end of file
+        self.sentinel_token = False
+