fastNLP/io 部分文档调整

fastNLP/io/__init__.py

@@ -1,13 +1,13 @@
 r"""
-用于IO的模块, 具体包括:
+用于 **IO** 的模块, 具体包括:
 
-1. 用于读入 embedding 的 :mod:`EmbedLoader <fastNLP.io.embed_loader>` 类,
+1. 用于读入 embedding 的 :mod:`EmbedLoader <fastNLP.io.embed_loader>` 类
 
 2. 用于读入不同格式数据的 :mod:`Loader <fastNLP.io.loader>` 类
 
 3. 用于处理读入数据的 :mod:`Pipe <fastNLP.io.pipe>` 类
 
-4. 用于保存和载入模型的类, 参考 :mod:`model_io模块 <fastNLP.io.model_io>`
+4. 用于管理数据集的类 :mod:`DataBundle <fastNLP.io.data_bundle>` 类
 
 这些类的使用方法如下:
 """

fastNLP/io/data_bundle.py

@@ -1,7 +1,7 @@
-r"""
-.. todo::
-    doc
 """
+:class:`DataBundle` 是 **fastNLP** 提供的用于方便快捷地管理多个数据集的工具，并有诸多接口来进行批量的数据处理。
+"""
+
 __all__ = [
     'DataBundle',
 ]
@@ -15,45 +15,40 @@ from fastNLP.core import logger
 
 class DataBundle:
     r"""
-    经过处理的数据信息，包括一系列数据集（比如：分开的训练集、验证集和测试集）以及各个field对应的vocabulary。该对象一般由fastNLP中各种
-    Loader的load函数生成，可以通过以下的方法获取里面的内容
-
-    Example::
+    经过处理的数据信息，包括一系列数据集（比如：分开的训练集、验证集和测试集）以及各个 field 对应的 vocabulary。该对象一般由
+    **fastNLP** 中各种 :class:`~fastNLP.io.loader.Loader` 的 :meth:`load` 函数生成，可以通过以下的方法获取里面的内容::
 
         data_bundle = YelpLoader().load({'train':'/path/to/train', 'dev': '/path/to/dev'})
         train_vocabs = data_bundle.vocabs['train']
         train_data = data_bundle.datasets['train']
         dev_data = data_bundle.datasets['train']
 
+    :param vocabs: 从名称（字符串）到 :class:`~fastNLP.core.Vocabulary` 类型的字典
+    :param datasets: 从名称（字符串）到 :class:`~fastNLP.core.dataset.DataSet` 类型的字典。建议不要将相同的 ``DataSet`` 对象重复传入，
+        否则可能会在使用 :class:`~fastNLP.io.pipe.Pipe` 处理数据的时候遇到问题，若多个数据集确需一致，请手动 ``deepcopy`` 后传入。
     """
 
     def __init__(self, vocabs=None, datasets=None):
-        r"""
-
-        :param vocabs: 从名称(字符串)到 :class:`~fastNLP.Vocabulary` 类型的dict
-        :param datasets: 从名称(字符串)到 :class:`~fastNLP.DataSet` 类型的dict。建议不要将相同的DataSet对象重复传入，可能会在
-            使用Pipe处理数据的时候遇到问题，若多个数据集确需一致，请手动deepcopy后传入。
-        """
         self.vocabs = vocabs or {}
         self.datasets = datasets or {}
 
     def set_vocab(self, vocab: Vocabulary, field_name: str):
         r"""
-        向DataBunlde中增加vocab
+        向 :class:`DataBunlde` 中增加 ``vocab``
 
-        :param ~fastNLP.Vocabulary vocab: 词表
-        :param str field_name: 这个vocab对应的field名称
+        :param vocab: :class:`~fastNLP.core.Vocabulary` 类型的词表
+        :param field_name: 这个 vocab 对应的 field 名称
         :return: self
         """
-        assert isinstance(vocab, Vocabulary), "Only fastNLP.Vocabulary supports."
+        assert isinstance(vocab, Vocabulary), "Only fastNLP.core.Vocabulary supports."
         self.vocabs[field_name] = vocab
         return self
 
     def set_dataset(self, dataset: DataSet, name: str):
         r"""
 
-        :param ~fastNLP.DataSet dataset: 传递给DataBundle的DataSet
-        :param str name: dataset的名称
+        :param dataset: 传递给 :class:`DataBundle` 的 :class:`~fastNLP.core.dataset.DataSet` 
+        :param name: ``dataset`` 的名称
         :return: self
         """
         assert isinstance(dataset, DataSet), "Only fastNLP.DataSet supports."
@@ -62,10 +57,10 @@ class DataBundle:
 
     def get_dataset(self, name: str) -> DataSet:
         r"""
-        获取名为name的dataset
+        获取名为 ``name`` 的 dataset
 
-        :param str name: dataset的名称，一般为'train', 'dev', 'test'
-        :return: DataSet
+        :param name: dataset的名称，一般为 'train', 'dev', 'test' 。
+        :return:
         """
         if name in self.datasets.keys():
             return self.datasets[name]
@@ -77,33 +72,34 @@ class DataBundle:
 
     def delete_dataset(self, name: str):
         r"""
-        删除名为name的DataSet
+        删除名为 ``name`` 的 dataset
 
-        :param str name:
+        :param name:
         :return: self
         """
         self.datasets.pop(name, None)
         return self
 
-    def get_vocab(self, field_name: str) -> Vocabulary:
+    def get_vocab(self, name: str) -> Vocabulary:
         r"""
-        获取field名为field_name对应的vocab
+        获取 field 名为 ``field_name`` 对应的词表
 
-        :param str field_name: 名称
-        :return: Vocabulary
+        :param field_name: 名称
+        :return: :class:`~fastNLP.core.Vocabulary`
         """
-        if field_name in self.vocabs.keys():
-            return self.vocabs[field_name]
+        if name in self.vocabs.keys():
+            return self.vocabs[name]
         else:
-            error_msg = f'DataBundle do NOT have Vocabulary named {field_name}. ' \
+            error_msg = f'DataBundle do NOT have Vocabulary named {name}. ' \
                         f'It should be one of {self.vocabs.keys()}.'
             logger.error(error_msg)
             raise KeyError(error_msg)
 
     def delete_vocab(self, field_name: str):
         r"""
-        删除vocab
-        :param str field_name:
+        删除名为 ``field_name`` 的 vocab
+
+        :param field_name:
         :return: self
         """
         self.vocabs.pop(field_name, None)
@@ -117,14 +113,14 @@ class DataBundle:
     def num_vocab(self):
         return len(self.vocabs)
 
-    def copy_field(self, field_name: str, new_field_name: str, ignore_miss_dataset=True):
+    def copy_field(self, field_name: str, new_field_name: str, ignore_miss_dataset: bool=True):
         r"""
-        将DataBundle中所有的DataSet中名为field_name的Field复制一份并命名为叫new_field_name.
+        将所有的 dataset 中名为 ``field_name`` 的 Field 复制一份并命名为 ``new_field_name``。
 
-        :param str field_name:
-        :param str new_field_name:
-        :param bool ignore_miss_dataset: 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet;
-            如果为False，则报错
+        :param field_name:
+        :param new_field_name:
+        :param ignore_miss_dataset: 如果为 ``True`` ，则当 ``field_name`` 在某个 dataset 内不存在时，直接忽略该 dataset，
+            如果为 ``False`` 则会报错。
         :return: self
         """
         for name, dataset in self.datasets.items():
@@ -134,15 +130,15 @@ class DataBundle:
                 raise KeyError(f"{field_name} not found DataSet:{name}.")
         return self
 
-    def rename_field(self, field_name: str, new_field_name: str, ignore_miss_dataset=True, rename_vocab=True):
+    def rename_field(self, field_name: str, new_field_name: str, ignore_miss_dataset: bool=True, rename_vocab: bool=True):
         r"""
-        将DataBundle中所有DataSet中名为field_name的field重命名为new_field_name.
+        将所有的 dataset 中名为 ``field_name`` 的 Field 重命名为 ``new_field_name``。
 
-        :param str field_name:
-        :param str new_field_name:
-        :param bool ignore_miss_dataset: 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet;
-            如果为False，则报错
-        :param bool rename_vocab: 如果该field同时也存在于vocabs中，会将该field的名称对应修改
+        :param field_name:
+        :param new_field_name:
+        :param ignore_miss_dataset: 如果为 ``True`` ，则当 ``field_name`` 在某个 dataset 内不存在时，直接忽略该 dataset，
+            如果为 ``False`` 则会报错。
+        :param rename_vocab: 如果该 ``field_name`` 同时也存在于 vocabs 中，则也会进行重命名
         :return: self
         """
         for name, dataset in self.datasets.items():
@@ -156,14 +152,14 @@ class DataBundle:
 
         return self
 
-    def delete_field(self, field_name: str, ignore_miss_dataset=True, delete_vocab=True):
+    def delete_field(self, field_name: str, ignore_miss_dataset: bool=True, delete_vocab: bool=True):
         r"""
-        将DataBundle中所有DataSet中名为field_name的field删除掉.
+        将所有的 dataset 中名为 ``field_name`` 的 Field 删除。
 
-        :param str field_name:
-        :param bool ignore_miss_dataset: 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet;
-            如果为False，则报错
-        :param bool delete_vocab: 如果该field也在vocabs中存在，将该值也一并删除
+        :param field_name:
+        :param ignore_miss_dataset: 如果为 ``True`` ，则当 ``field_name`` 在某个 dataset 内不存在时，直接忽略该 dataset，
+            如果为 ``False`` 则会报错。
+        :param delete_vocab: 如果该 ``field_name`` 也在 vocabs 中存在，则也会删除。
         :return: self
         """
         for name, dataset in self.datasets.items():
@@ -178,44 +174,38 @@ class DataBundle:
 
     def iter_datasets(self) -> Union[str, DataSet]:
         r"""
-        迭代data_bundle中的DataSet
+        迭代 dataset
 
         Example::
 
             for name, dataset in data_bundle.iter_datasets():
                 pass
 
-        :return:
         """
         for name, dataset in self.datasets.items():
             yield name, dataset
 
     def get_dataset_names(self) -> List[str]:
         r"""
-        返回DataBundle中DataSet的名称
-
-        :return:
+        :return: 所有 dataset 的名称
         """
         return list(self.datasets.keys())
 
     def get_vocab_names(self) -> List[str]:
         r"""
-        返回DataBundle中Vocabulary的名称
-
-        :return:
+        :return: 所有词表的名称
         """
         return list(self.vocabs.keys())
 
     def iter_vocabs(self):
         r"""
-        迭代data_bundle中的DataSet
+        迭代词表
 
-        Example:
+        Example::
 
             for field_name, vocab in data_bundle.iter_vocabs():
                 pass
 
-        :return:
         """
         for field_name, vocab in self.vocabs.items():
             yield field_name, vocab
@@ -223,25 +213,24 @@ class DataBundle:
     def apply_field(self, func: Callable, field_name: str, new_field_name: str, num_proc: int = 0,
                     ignore_miss_dataset: bool = True, progress_desc: str = '', progress_bar: str = 'rich'):
         r"""
-        对 :class:`~fastNLP.io.DataBundle` 中所有的dataset使用 :meth:`~fastNLP.DataSet.apply_field` 方法
-
-        :param callable func: input是instance中名为 `field_name` 的field的内容。
-        :param str field_name: 传入func的是哪个field。
-        :param str new_field_name: 将func返回的内容放入到 `new_field_name` 这个field中，如果名称与已有的field相同，则覆
-            盖之前的field。如果为None则不创建新的field。
-        :param bool ignore_miss_dataset: 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet;
-            如果为False，则报错
-        :param num_proc: 使用进程的数量。
+        对 :class:`DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.core.dataset.DataSet.apply_field` 方法
 
+        :param func: 对指定 field 进行处理的函数，注意其输入应为 ``instance`` 中名为 ``field_name`` 的 field 的内容；
+        :param field_name: 传入 ``func`` 的 field 名称；
+        :param new_field_name: 函数执行结果写入的 ``field`` 名称。该函数会将 ``func`` 返回的内容放入到 ``new_field_name`` 对
+            应的 ``field`` 中，注意如果名称与已有的 field 相同则会进行覆盖。如果为 ``None`` 则不会覆盖和创建 field ；
+        :param num_proc: 使用进程的数量。
+        
             .. note::
-
+            
                 由于 ``python`` 语言的特性，设置该参数后会导致相应倍数的内存增长，这可能会对您程序的执行带来一定的影响。另外，使用多进程时，
                 ``func`` 函数中的打印将不会输出。
 
-        :param ignore_miss_dataset: 如果 dataset 没有 {field_name} ，就直接跳过这个 dataset 。
-        :param progress_desc: 当显示 progress 时，可以显示当前正在处理的名称
-    	:param progress_bar: 显示 progress_bar 的方式，支持 `["rich", "tqdm", None]`。
-
+        :param ignore_miss_dataset: 如果为 ``True`` ，则当 ``field_name`` 在某个 dataset 内不存在时，直接忽略该 dataset，
+            如果为 ``False`` 则会报错。
+        :param progress_desc: 如果不为 ``None``，则会显示当前正在处理的进度条的名称；
+        :param progress_bar: 显示进度条的方式，支持 ``["rich", "tqdm", None]``。
+        :return: self
         """
         _progress_desc = progress_desc
         for name, dataset in self.datasets.items():
@@ -255,32 +244,30 @@ class DataBundle:
                 raise KeyError(f"{field_name} not found DataSet:{name}.")
         return self
 
-    def apply_field_more(self, func: Callable, field_name: str, num_proc: int = 0, modify_fields=True,
+    def apply_field_more(self, func: Callable, field_name: str,  modify_fields: str=True, num_proc: int = 0,
                          ignore_miss_dataset=True, progress_bar: str = 'rich', progress_desc: str = ''):
         r"""
-        对 :class:`~fastNLP.io.DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.DataSet.apply_field_more` 方法
+        对 :class:`DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.core.DataSet.apply_field_more` 方法
 
         .. note::
             ``apply_field_more`` 与 ``apply_field`` 的区别参考 :meth:`fastNLP.DataSet.apply_more` 中关于 ``apply_more`` 与
             ``apply`` 区别的介绍。
 
-        :param callable func: 参数是 ``DataSet`` 中的 ``Instance`` ，返回值是一个字典，key 是field 的名字，value 是对应的结果
-        :param str field_name: 传入func的是哪个field。
-        :param bool modify_fields: 是否用结果修改 `DataSet` 中的 `Field`， 默认为 True
+        :param func: 对指定 field 进行处理的函数，注意其输入应为 ``instance`` 中名为 ``field_name`` 的 field 的内容；
+        :param field_name: 传入 ``func`` 的 field 名称；
+        :param modify_fields: 是否用结果修改 ``DataSet`` 中的 ``Field`` ， 默认为 ``True``
         :param num_proc: 使用进程的数量。
-
+        
             .. note::
-
+            
                 由于 ``python`` 语言的特性，设置该参数后会导致相应倍数的内存增长，这可能会对您程序的执行带来一定的影响。另外，使用多进程时，
                 ``func`` 函数中的打印将不会输出。
 
-        :param bool ignore_miss_dataset: 当某个field名称在某个dataset不存在时，如果为True，则直接忽略该DataSet;
-            如果为False，则报错
-        :param progress_bar: 显示 progress_bar 的方式，支持 `["rich", "tqdm", None]`。
-        :param progress_desc: 当显示 progress_bar 时，可以显示 ``progress`` 的名称。
-
-        :return Dict[str:Dict[str:Field]]: 返回一个字典套字典，第一层的 key 是 dataset 的名字，第二层的 key 是 field 的名字
-
+        :param ignore_miss_dataset: 如果为 ``True`` ，则当 ``field_name`` 在某个 dataset 内不存在时，直接忽略该 dataset，
+            如果为 ``False`` 则会报错。
+        :param progress_desc: 如果不为 ``None``，则会显示当前正在处理的进度条的名称；
+        :param progress_bar: 显示进度条的方式，支持 ``["rich", "tqdm", None]``。
+        :return: 一个字典套字典，第一层的 key 是 dataset 的名字，第二层的 key 是 field 的名字
         """
         res = {}
         _progress_desc = progress_desc
@@ -299,13 +286,11 @@ class DataBundle:
     def apply(self, func: Callable, new_field_name: str, num_proc: int = 0,
               progress_desc: str = '', progress_bar: bool = True):
         r"""
-        对 :class:`~fastNLP.io.DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.DataSet.apply` 方法
-
-        对DataBundle中所有的dataset使用apply方法
+        对 :class:`~DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.core.DataSet.apply` 方法
 
-        :param callable func: input是instance中名为 `field_name` 的field的内容。
-        :param str new_field_name: 将func返回的内容放入到 `new_field_name` 这个field中，如果名称与已有的field相同，则覆
-            盖之前的field。如果为None则不创建新的field。
+        :param func: 参数是 ``DataSet`` 中的 ``Instance`` ，返回值是一个字典，key 是field 的名字，value 是对应的结果
+        :param new_field_name: 将 ``func`` 返回的内容放入到 ``new_field_name`` 这个 field中 ，如果名称与已有的 field 相同，则覆
+            盖之前的 field。如果为 ``None`` 则不创建新的 field。
         :param num_proc: 使用进程的数量。
 
             .. note::
@@ -313,9 +298,9 @@ class DataBundle:
                 由于 ``python`` 语言的特性，设置该参数后会导致相应倍数的内存增长，这可能会对您程序的执行带来一定的影响。另外，使用多进程时，
                 ``func`` 函数中的打印将不会输出。
 
-        :param progress_bar: 显示 progress_bar 的方式，支持 `["rich", "tqdm", None]`。
-        :param progress_desc: 当显示 progress bar 时，可以显示当前正在处理的名称
-
+        :param progress_bar: 显示进度条的方式，支持 ``["rich", "tqdm", None]``。
+        :param progress_desc: 如果不为 ``None``，则会显示当前正在处理的进度条的名称。
+        :return: self
         """
         _progress_desc = progress_desc
         for name, dataset in self.datasets.items():
@@ -326,7 +311,7 @@ class DataBundle:
                           progress_desc=progress_desc)
         return self
 
-    def apply_more(self, func: Callable, modify_fields=True, num_proc: int = 0,
+    def apply_more(self, func: Callable, modify_fields: bool=True, num_proc: int = 0,
                    progress_desc: str = '', progress_bar: str = 'rich'):
         r"""
         对 :class:`~fastNLP.io.DataBundle` 中所有的 dataset 使用 :meth:`~fastNLP.DataSet.apply_more` 方法
@@ -335,8 +320,8 @@ class DataBundle:
             ``apply_more`` 与 ``apply`` 的区别参考 :meth:`fastNLP.DataSet.apply_more` 中关于 ``apply_more`` 与
             ``apply`` 区别的介绍。
 
-        :param callable func: 参数是 ``DataSet`` 中的 ``Instance`` ，返回值是一个字典，key 是field 的名字，value 是对应的结果
-        :param bool modify_fields: 是否用结果修改 ``DataSet`` 中的 ``Field`` ， 默认为 True
+        :param func: 参数是 ``DataSet`` 中的 ``Instance`` ，返回值是一个字典，key 是field 的名字，value 是对应的结果
+        :param modify_fields: 是否用结果修改 ``DataSet`` 中的 ``Field`` ， 默认为 ``True``
         :param num_proc: 使用进程的数量。
 
             .. note::
@@ -344,10 +329,10 @@ class DataBundle:
                 由于 ``python`` 语言的特性，设置该参数后会导致相应倍数的内存增长，这可能会对您程序的执行带来一定的影响。另外，使用多进程时，
                 ``func`` 函数中的打印将不会输出。
 
-        :param progress_bar: 显示 progress_bar 的方式，支持 `["rich", "tqdm", None]`。
-        :param progress_desc: 当显示 progress_bar 时，可以显示当前正在处理的名称
+        :param progress_desc: 当 progress_bar 不为 ``None`` 时，可以显示当前正在处理的进度条名称
+        :param progress_bar: 显示进度条的方式，支持 ``["rich", "tqdm", None]``。
 
-        :return Dict[str:Dict[str:Field]]: 返回一个字典套字典，第一层的 key 是 dataset 的名字，第二层的 key 是 field 的名字
+        :return: 一个字典套字典，第一层的 key 是 dataset 的名字，第二层的 key 是 field 的名字
         """
         res = {}
         _progress_desc = progress_desc
@@ -363,19 +348,19 @@ class DataBundle:
         """
         如果需要对某个 field 的内容进行特殊的调整，请使用这个函数。
 
-        :param field_name: 需要调整的 field 的名称。如果 Dataset 的 __getitem__ 方法返回的是 dict 类型的，则可以直接使用对应的
-            field 的 key 来表示，如果是 nested 的 dict，可以使用元组表示多层次的 key，例如 {'a': {'b': 1}} 中的使用 ('a', 'b');
-            如果 __getitem__ 返回的是 Sequence 类型的，则可以使用 '_0', '_1' 表示序列中第 0 或 1 个元素。如果该 field 在数据中没
-            有找到，则报错；如果 __getitem__ 返回的是就是整体内容，请使用 "_single" 。
-        :param pad_val: 这个 field 的默认 pad 值。如果设置为 None，则表示该 field 不需要 pad , fastNLP 默认只会对可以 pad 的
-            field 进行 pad，所以如果对应 field 本身就不是可以 pad 的形式，可以不需要主动设置为 None 。如果 backend 为 None ，该值
-            无意义。
-        :param dtype: 对于需要 pad 的 field ，该 field 的数据 dtype 应该是什么。
-        :param backend: 可选['raw', 'numpy', 'torch', 'paddle', 'jittor', 'auto']，分别代表，输出为 list, numpy.ndarray,
-            torch.Tensor, paddle.Tensor, jittor.Var 类型。若 pad_val 为 None ，该值无意义 。
-        :param pad_fn: 指定当前 field 的 pad 函数，传入该函数则 pad_val, dtype, backend 等参数失效。pad_fn 的输入为当前 field 的
-            batch 形式。 Collator 将自动 unbatch 数据，然后将各个 field 组成各自的 batch 。pad_func 的输入即为 field 的 batch
-            形式，输出将被直接作为结果输出。
+        :param field_name: 需要调整的 field 的名称。如果 :meth:`Dataset.__getitem__` 方法返回的是字典类型，则可以直接使用对应的
+            field 的 key 来表示，如果是嵌套字典，可以使用元组表示多层次的 key，例如 ``{'a': {'b': 1}}`` 中可以使用 ``('a', 'b')``;
+            如果 :meth:`Dataset.__getitem__` 返回的是 Sequence 类型，则可以使用 ``'_0'``, ``'_1'`` 表示序列中第 **0** 或 **1** 个元素。
+            如果该 field 在数据中没有找到，则报错；如果 :meth:`Dataset.__getitem__` 返回的是就是整体内容，请使用 "_single" 。
+        :param pad_val: 这个 field 的默认 pad 值。如果设置为 ``None``，则表示该 field 不需要 pad , fastNLP 默认只会对可以 pad 的
+            field 进行 pad，所以如果对应 field 本身就不是可以 pad 的形式，可以不需要主动设置为 ``None`` 。如果 ``backend`` 为 ``None``，
+            该值无意义。
+        :param dtype: 对于需要 pad 的 field ，该 field 数据的 ``dtype`` 。
+        :param backend: 可选 ``['raw', 'numpy', 'torch', 'paddle', 'jittor', 'oneflow', 'auto']`` ，分别代表，输出为 :class:`list`, 
+            :class:`numpy.ndarray`, :class:`torch.Tensor`, :class:`paddle.Tensor`, :class:`jittor.Var`, :class:`oneflow.Tensor` 类型。
+            若 ``pad_val`` 为 ``None`` ，该值无意义 。
+        :param pad_fn: 指定当前 field 的 pad 函数，传入该函数则 ``pad_val``, ``dtype``, ``backend`` 等参数失效。``pad_fn`` 的输入为当前 field 的
+            batch 形式。 Collator 将自动 unbatch 数据，然后将各个 field 组成各自的 batch 。
         :return: self
         """
         for _, ds in self.iter_datasets():
@@ -385,14 +370,14 @@ class DataBundle:
 
     def set_ignore(self, *field_names) -> "DataBundle":
         """
-        如果有的内容不希望输出，可以在此处进行设置，被设置的 field 将在 batch 的输出中被忽略。
-        Example::
+        ``DataSet`` 中想要对绑定的 collator 进行调整可以调用此函数。 ``collator`` 为 :class:`~fastNLP.core.collators.Collator`
+        时该函数才有效。调用该函数可以设置忽略输出某些 field 的内容，被设置的 field 将在 batch 的输出中被忽略::
 
-            collator.set_ignore('field1', 'field2')
+            databundle.set_ignore('field1', 'field2')
 
-        :param field_names: 需要忽略的 field 的名称。如果 Dataset 的 __getitem__ 方法返回的是 dict 类型的，则可以直接使用对应的
-            field 的 key 来表示，如果是 nested 的 dict，可以使用元组来表示，例如 {'a': {'b': 1}} 中的使用 ('a', 'b'); 如果
-            __getitem__ 返回的是 Sequence 类型的，则可以使用 '_0', '_1' 表示序列中第 0 或 1 个元素。
+        :param field_names: field_name: 需要调整的 field 的名称。如果 :meth:`Dataset.__getitem__` 方法返回的是字典类型，则可以直接使用对应的
+            field 的 key 来表示，如果是嵌套字典，可以使用元组表示多层次的 key，例如 ``{'a': {'b': 1}}`` 中可以使用 ``('a', 'b')``;
+            如果 :meth:`Dataset.__getitem__` 返回的是 Sequence 类型，则可以使用 ``'_0'``, ``'_1'`` 表示序列中第 **0** 或 **1** 个元素。
         :return: self
         """
         for _, ds in self.iter_datasets():

fastNLP/io/embed_loader.py

@@ -1,7 +1,3 @@
-r"""
-.. todo::
-    doc
-"""
 __all__ = [
     "EmbedLoader",
     "EmbeddingOption",
@@ -9,6 +5,7 @@ __all__ = [
 
 import logging
 import os
+from typing import Callable
 
 import numpy as np
 
@@ -33,30 +30,30 @@ class EmbeddingOption(Option):
 
 class EmbedLoader:
     r"""
-    用于读取预训练的embedding, 读取结果可直接载入为模型参数。
+    用于读取预训练的 embedding, 读取结果可直接载入为模型参数。
     """
     
     def __init__(self):
         super(EmbedLoader, self).__init__()
 
     @staticmethod
-    def load_with_vocab(embed_filepath, vocab, dtype=np.float32, padding='<pad>', unknown='<unk>', normalize=True,
-                        error='ignore', init_method=None):
+    def load_with_vocab(embed_filepath: str, vocab, dtype=np.float32, padding: str='<pad>', unknown: str='<unk>', normalize: bool=True,
+                        error: str='ignore', init_method: Callable=None):
         r"""
-        从embed_filepath这个预训练的词向量中抽取出vocab这个词表的词的embedding。EmbedLoader将自动判断embed_filepath是
-        word2vec(第一行只有两个元素)还是glove格式的数据。
+        从 ``embed_filepath`` 这个预训练的词向量中抽取出 ``vocab`` 这个词表的词的 embedding。 :class:`EmbedLoader` 将自动判断 ``embed_filepath``
+        是 **word2vec** （第一行只有两个元素） 还是 **glove** 格式的数据。
 
-        :param str embed_filepath: 预训练的embedding的路径。
-        :param vocab: 词表 :class:`~fastNLP.Vocabulary` 类型，读取出现在vocab中的词的embedding。
-            没有出现在vocab中的词的embedding将通过找到的词的embedding的正态分布采样出来，以使得整个Embedding是同分布的。
-        :param dtype: 读出的embedding的类型
-        :param str padding: 词表中padding的token
-        :param str unknown: 词表中unknown的token
-        :param bool normalize: 是否将每个vector归一化到norm为1
-        :param str error: `ignore` , `strict` ; 如果 `ignore` ，错误将自动跳过; 如果 `strict` , 错误将抛出。
+        :param embed_filepath: 预训练的 embedding 的路径。
+        :param vocab: 词表 :class:`~fastNLP.core.Vocabulary` 类型，读取出现在 ``vocab`` 中的词的 embedding。
+            没有出现在 ``vocab`` 中的词的 embedding 将通过找到的词的 embedding 的 *正态分布* 采样出来，以使得整个 Embedding 是同分布的。
+        :param dtype: 读出的 embedding 的类型
+        :param padding: 词表中 *padding* 的 token
+        :param unknown: 词表中 *unknown* 的 token
+        :param normalize: 是否将每个 vector 归一化到 norm 为 1
+        :param error: 可以为以下值之一： ``['ignore', 'strict']`` 。如果为  ``ignore`` ，错误将自动跳过；如果是 ``strict`` ，错误将抛出。
             这里主要可能出错的地方在于词表有空行或者词表出现了维度不一致。
-        :param callable init_method: 传入numpy.ndarray, 返回numpy.ndarray, 用以初始化embedding
-        :return numpy.ndarray:  shape为 [len(vocab), dimension], dimension由pretrain的embedding决定。
+        :param init_method: 用于初始化 embedding 的函数。该函数接受一个 :class:`numpy.ndarray` 类型，返回 :class:`numpy.ndarray`。
+        :return: 返回类型为 :class:`numpy.ndarray`，形状为 ``[len(vocab), dimension]``，其中 *dimension*由预训练的 embedding 决定。
         """
         assert isinstance(vocab, Vocabulary), "Only fastNLP.Vocabulary is supported."
         if not os.path.exists(embed_filepath):
@@ -112,20 +109,21 @@ class EmbedLoader:
             return matrix
     
     @staticmethod
-    def load_without_vocab(embed_filepath, dtype=np.float32, padding='<pad>', unknown='<unk>', normalize=True,
-                           error='ignore'):
+    def load_without_vocab(embed_filepath: str, dtype=np.float32, padding: str='<pad>', unknown: str='<unk>', normalize: bool=True,
+                           error: str='ignore'):
         r"""
-        从embed_filepath中读取预训练的word vector。根据预训练的词表读取embedding并生成一个对应的Vocabulary。
+        从 ``embed_filepath`` 中读取预训练的 word vector。根据预训练的词表读取 embedding 并生成一个对应的 :class:`~fastNLP.core.Vocabulary` 。
 
-        :param str embed_filepath: 预训练的embedding的路径。
-        :param dtype: 读出的embedding的类型
-        :param str padding: 词表中的padding的token. 并以此用做vocab的padding。
-        :param str unknown: 词表中的unknown的token. 并以此用做vocab的unknown。
-        :param bool normalize: 是否将每个vector归一化到norm为1
-        :param str error: `ignore` , `strict` ; 如果 `ignore` ，错误将自动跳过; 如果 `strict` , 错误将抛出。这里主要可能出错的地
-            方在于词表有空行或者词表出现了维度不一致。
-        :return (numpy.ndarray, Vocabulary): Embedding的shape是[词表大小+x, 词表维度], "词表大小+x"是由于最终的大小还取决与
-            是否使用padding, 以及unknown有没有在词表中找到对应的词。 Vocabulary中的词的顺序与Embedding的顺序是一一对应的。
+        :param embed_filepath: 预训练的 embedding 的路径。
+        :param dtype: 读出的 embedding 的类型
+        :param padding: 词表中的 *padding* 的 token。
+        :param unknown: 词表中的 *unknown* 的 token。
+        :param normalize: 是否将每个 vector 归一化到 norm 为 1
+        :param error: 可以为以下值之一： ``['ignore', 'strict']`` 。如果为  ``ignore`` ，错误将自动跳过；如果是 ``strict`` ，错误将抛出。
+            这里主要可能出错的地方在于词表有空行或者词表出现了维度不一致。
+        :return: 返回两个结果，第一个返回值为 :class:`numpy.ndarray`，大小为 ``[词表大小+x, 词表维度]`` 。 ``词表大小+x`` 是由于最终的大小还取决于
+            是否使用 ``padding``，以及 ``unknown`` 有没有在词表中找到对应的词。 第二个返回值为 :class:`~fastNLP.core.Vocabulary` 类型的词表，其中
+            词的顺序与 embedding 的顺序是一一对应的。
 
         """
         vocab = Vocabulary(padding=padding, unknown=unknown)

fastNLP/io/file_reader.py

@@ -1,7 +1,3 @@
-r"""undocumented
-此模块用于给其它模块提供读取文件的函数，没有为用户提供 API
-"""
-
 __all__ = []
 
 import json

fastNLP/io/file_utils.py

@@ -1,8 +1,3 @@
-r"""
-.. todo::
-    doc
-"""
-
 __all__ = [
     "cached_path",
     "get_filepath",
@@ -160,21 +155,16 @@ FASTNLP_EXTEND_EMBEDDING_URL = {'elmo': 'fastnlp_elmo_url.txt',
 
 def cached_path(url_or_filename: str, cache_dir: str = None, name=None) -> Path:
     r"""
-    给定一个url，尝试通过url中的解析出来的文件名字filename到{cache_dir}/{name}/{filename}下寻找这个文件，
-    
-    1. 如果cache_dir=None, 则cache_dir=~/.fastNLP/; 否则cache_dir=cache_dir
-    2. 如果name=None, 则没有中间的{name}这一层结构；否者中间结构就为{name}
-
-    如果有该文件，就直接返回路径
+    给定一个 url，尝试通过 url 中解析出来的文件名字 filename 到 ``{cache_dir}/{name}/{filename}`` 下寻找这个文件或文件夹：
     
-    如果没有该文件，则尝试用传入的url下载
+    1. 如果 ``cache_dir`` 为 ``None``，则默认为 ``~/.fastNLP/``；
+    2. 如果 ``name=None`` ，则没有中间的 {name} 这一层结构。
 
-    或者文件名(可以是具体的文件名，也可以是文件夹)，先在cache_dir下寻找该文件是否存在，如果不存在则去下载, 并
-    将文件放入到cache_dir中.
+    如果有该文件，就直接返回路径；如果没有该文件，则尝试用传入的 url 下载，并将文件放入 ``cache_dir`` 中。
 
-    :param str url_or_filename: 文件的下载url或者文件名称。
-    :param str cache_dir: 文件的缓存文件夹。如果为None，将使用"~/.fastNLP"这个默认路径
-    :param str name: 中间一层的名称。如embedding, dataset
+    :param url_or_filename: 文件的下载 url 或者文件名称。
+    :param cache_dir: 文件的缓存文件夹。如果为 ``None``，将使 ``"~/.fastNLP`` 这个默认路径
+    :param name: 中间一层的名称。如 embedding, dataset
     :return:
     """
     if cache_dir is None:
@@ -205,17 +195,10 @@ def cached_path(url_or_filename: str, cache_dir: str = None, name=None) -> Path:
 
 def get_filepath(filepath):
     r"""
-    如果filepath为文件夹，
-    
-        如果内含多个文件, 返回filepath
-        
-        如果只有一个文件, 返回filepath + filename
-
-    如果filepath为文件
-        
-        返回filepath
+    如果 ``filepath`` 为文件夹且包含多个文件，则直接返回 ``filepath``；反之若只包含一个文件，返回该文件的路径 ``{filepath}/{filename}``。
+    如果 ``filepath`` 为一个文件，也会直接返回 ``filepath``。
 
-    :param str filepath: 路径
+    :param filepath: 路径
     :return:
     """
     if os.path.isdir(filepath):
@@ -232,9 +215,7 @@ def get_filepath(filepath):
 
 def get_cache_path():
     r"""
-    获取fastNLP默认cache的存放路径, 如果将FASTNLP_CACHE_PATH设置在了环境变量中，将使用环境变量的值，使得不用每个用户都去下载。
-
-    :return str:  存放路径
+    获取 **fastNLP** 默认 cache 的存放路径, 如果将 ``FASTNLP_CACHE_PATH`` 设置在了环境变量中，将使用环境变量的值，使得不用每个用户都去下载。
     """
     if 'FASTNLP_CACHE_DIR' in os.environ:
         fastnlp_cache_dir = os.environ.get('FASTNLP_CACHE_DIR')
@@ -342,10 +323,10 @@ def _get_dataset_url(name, dataset_dir: dict = None):
 
 def split_filename_suffix(filepath):
     r"""
-    给定filepath 返回对应的name和suffix. 如果后缀是多个点，仅支持.tar.gz类型
+    给定 ``filepath`` 返回对应的文件名和后缀。如果后缀是多个点，仅支持 **.tar.gz** 类型
     
     :param filepath: 文件路径
-    :return: filename, suffix
+    :return: 文件名 ``filename`` 和后缀 ``suffix``
     """
     filename = os.path.basename(filepath)
     if filename.endswith('.tar.gz'):
@@ -355,10 +336,10 @@ def split_filename_suffix(filepath):
 
 def get_from_cache(url: str, cache_dir: Path = None) -> Path:
     r"""
-    尝试在cache_dir中寻找url定义的资源; 如果没有找到; 则从url下载并将结果放在cache_dir下，缓存的名称由url的结果推断而来。会将下载的
-    文件解压，将解压后的文件全部放在cache_dir文件夹中。
+    尝试在 ``cache_dir``中寻找 ``url`` 定义的资源，如果没有找到，则从 ``url`` 下载并将结果放在 ``cache_dir`` 下，
+    缓存的名称由 ``url`` 的结果推断而来。会将下载的文件解压，将解压后的文件全部放在 ``cache_dir`` 文件夹中。
 
-    如果从url中下载的资源解压后有多个文件，则返回目录的路径; 如果只有一个资源文件，则返回具体的路径。
+    如果从 ``url``中下载的资源解压后有多个文件，则返回目录的路径；如果只有一个资源文件，则返回具体的路径。
     
     :param url: 资源的 url
     :param cache_dir: cache 目录

fastNLP/io/loader/__init__.py

@@ -1,8 +1,8 @@
 r"""
-Loader用于读取数据，并将内容读取到 :class:`~fastNLP.DataSet` 或者 :class:`~fastNLP.io.DataBundle` 中。所有的Loader都支持以下的
-三个方法： ``__init__`` ， ``_load`` , ``loads`` . 其中 ``__init__(...)`` 用于申明读取参数，以及说明该Loader支持的数据格式，
-读取后 :class:`~fastNLP.DataSet` 中的 `field` ; ``_load(path)`` 方法传入文件路径读取单个文件，并返回 :class:`~fastNLP.DataSet` ;
-``load(paths)`` 用于读取文件夹下的文件，并返回 :class:`~fastNLP.io.DataBundle` 类型的对象 , load()方法支持以下几种类型的参数:
+**Loader** 用于读取数据，并将内容读取到 :class:`~fastNLP.core.DataSet` 或者 :class:`~fastNLP.io.DataBundle` 中。所有的 ``Loader`` 都支持以下的
+三个方法： ``__init__`` ， ``_load`` , ``loads`` . 其中 ``__init__(...)`` 用于申明读取参数，以及说明该 ``Loader`` 支持的数据格式，
+读取后 :class:`~fastNLP.core.DataSet` 中的 `field` ； ``_load(path)`` 方法传入文件路径读取单个文件，并返回 :class:`~fastNLP.core.DataSet` ；
+``load(paths)`` 用于读取文件夹下的文件，并返回 :class:`~fastNLP.io.DataBundle` 类型的对象 ， load()方法支持以下几种类型的参数:
 
 0.传入None
     将尝试自动下载数据集并缓存。但不是所有的数据都可以直接下载。
@@ -38,10 +38,7 @@ Loader用于读取数据，并将内容读取到 :class:`~fastNLP.DataSet` 或
     在 Loader().load(paths)  返回的 `data_bundle` 中可以用 ``data_bundle.get_dataset('train')`` , ``data_bundle.get_dataset('dev')`` ,
     ``data_bundle.get_dataset('test')`` 来获取对应的 `dataset`
 
-fastNLP 目前提供了如下的 Loader
-
-
-
+**fastNLP** 目前提供了如下的 Loader：
 """
 
 __all__ = [

fastNLP/io/loader/classification.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "CLSBaseLoader",
     "YelpFullLoader",
@@ -30,22 +28,18 @@ from .loader import Loader
 from fastNLP.core.dataset import Instance, DataSet
 from fastNLP.core.log import logger
 
-
-# from ...core._logger import log
-
-
 class CLSBaseLoader(Loader):
     r"""
-    文本分类Loader的一个基类
+    文本分类 Loader 的一个基类
 
-    原始数据中内容应该为, 每一行为一个sample，第一个逗号之前为target，第一个逗号之后为文本内容。
+    原始数据中内容应该为：每一行为一个 sample ，第一个逗号之前为 **target** ，第一个逗号之后为 **文本内容** 。
 
     Example::
 
         "1","I got 'new' tires from the..."
         "1","Don't waste your time..."
 
-    读取的DataSet将具备以下的数据结构
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
        :header: "raw_words", "target"
@@ -124,32 +118,36 @@ def _split_dev(dataset_name, data_dir, dev_ratio=0.0, re_download=False, suffix=
 
 
 class AGsNewsLoader(CLSBaseLoader):
-    def download(self):
-        r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
+    """
+    **AG's News** 数据集的 **Loader**，如果您使用了这个数据集，请引用以下的文章
 
         Xiang Zhang, Junbo Zhao, Yann LeCun. Character-level Convolutional Networks for Text Classification. Advances
         in Neural Information Processing Systems 28 (NIPS 2015)
+    """
+    def download(self):
+        r"""
+        自动下载数据集。
 
-        :return: str, 数据集的目录地址
+        :return: 数据集的目录地址
         """
         return self._get_dataset_path(dataset_name='ag-news')
 
 
 class DBPediaLoader(CLSBaseLoader):
-    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
-        r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
+    """
+    **DBpedia** 数据集的 **Loader**。如果您使用了这个数据集，请引用以下的文章
 
         Xiang Zhang, Junbo Zhao, Yann LeCun. Character-level Convolutional Networks for Text Classification. Advances
         in Neural Information Processing Systems 28 (NIPS 2015)
+    """
+    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
+        r"""
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-        如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-        下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
-
-        :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = 'dbpedia'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -163,15 +161,18 @@ class DBPediaLoader(CLSBaseLoader):
 
 class IMDBLoader(CLSBaseLoader):
     r"""
-    原始数据中内容应该为, 每一行为一个sample，制表符之前为target，制表符之后为文本内容。
+    **IMDb** 数据集的 **Loader** ，如果您使用了这个数据集，请引用以下的文章
+
+        http://www.aclweb.org/anthology/P11-1015。
+        
+    原始数据中内容应该为：每一行为一个 sample ，制表符之前为 **target** ，制表符之后为 **文本内容** 。
 
     Example::
 
         neg	Alan Rickman & Emma...
         neg	I have seen this...
 
-    IMDBLoader读取后的数据将具有以下两列内容: raw_words: str, 需要分类的文本; target: str, 文本的标签
-    读取的DataSet具备以下的结构:
+    **IMDBLoader** 读取后的 :class:`~fastNLP.core.DataSet` 将具有以下两列内容: ``raw_words`` 代表需要分类的文本，``target`` 代表文本的标签：
 
     .. csv-table::
        :header: "raw_words", "target"
@@ -187,15 +188,13 @@ class IMDBLoader(CLSBaseLoader):
 
     def download(self, dev_ratio: float = 0.0, re_download=False):
         r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
+        自动下载数据集。
 
-        http://www.aclweb.org/anthology/P11-1015
+        根据 ``dev_ratio`` 的值随机将 train 中的数据取出一部分作为 dev 数据。
 
-        根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后不从train中切分dev
-
-        :param float dev_ratio: 如果路径中没有dev.txt。从train划分多少作为dev的数据. 如果为0，则不划分dev
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有 ``dev.txt`` ，从 train 划分多少作为 dev 的数据。 如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = 'aclImdb'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -209,23 +208,25 @@ class IMDBLoader(CLSBaseLoader):
 
 class SSTLoader(Loader):
     r"""
-    原始数据中内容应该为:
+    **SST** 数据集的 **Loader**，如果您使用了这个数据集，请引用以下的文章
 
-    Example::
+            https://nlp.stanford.edu/~socherr/EMNLP2013_RNTN.pdf
+
+    原始数据中内容应该为::
 
         (2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)...
         (3 (3 (2 If) (3 (2 you) (3 (2 sometimes)...
 
-    读取之后的DataSet具有以下的结构
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
-    .. csv-table:: 下面是使用SSTLoader读取的DataSet所具备的field
+    .. csv-table:: 下面是使用 SSTLoader 读取的 DataSet 所具备的 field
         :header: "raw_words"
 
         "(2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)..."
         "(3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ..."
         "..."
 
-    raw_words列是str。
+    ``raw_words`` 列是 :class:`str` 。
 
     """
 
@@ -249,30 +250,29 @@ class SSTLoader(Loader):
 
     def download(self):
         r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
-
-            https://nlp.stanford.edu/~socherr/EMNLP2013_RNTN.pdf
+        自动下载数据集。
 
-        :return: str, 数据集的目录地址
+        :return: 数据集的目录地址
         """
         output_dir = self._get_dataset_path(dataset_name='sst')
         return output_dir
 
 
 class YelpFullLoader(CLSBaseLoader):
-    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
-        r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
+    """
+    **Yelp Review Full** 数据集的 **Loader**，如果您使用了这个数据集，请引用以下的文章
 
         Xiang Zhang, Junbo Zhao, Yann LeCun. Character-level Convolutional Networks for Text Classification. Advances
         in Neural Information Processing Systems 28 (NIPS 2015)
+    """
+    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
+        r"""
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-        如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-        下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
-
-        :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = 'yelp-review-full'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -285,19 +285,20 @@ class YelpFullLoader(CLSBaseLoader):
 
 
 class YelpPolarityLoader(CLSBaseLoader):
-    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
-        r"""
-        自动下载数据集，如果你使用了这个数据集，请引用以下的文章
+    """
+    **Yelp Review Polarity** 数据集的 **Loader**，如果您使用了这个数据集，请引用以下的文章
 
         Xiang Zhang, Junbo Zhao, Yann LeCun. Character-level Convolutional Networks for Text Classification. Advances
         in Neural Information Processing Systems 28 (NIPS 2015)
+    """
+    def download(self, dev_ratio: float = 0.0, re_download: bool = False):
+        r"""
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-        如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-        下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
-
-        :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = 'yelp-review-polarity'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -311,7 +312,12 @@ class YelpPolarityLoader(CLSBaseLoader):
 
 class SST2Loader(Loader):
     r"""
-    原始数据中内容为：第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是句子，第一个制表符之后认为是label
+    **SST-2** 数据集的 **Loader**，如果您使用了该数据集，请引用以下的文章
+
+    https://nlp.stanford.edu/pubs/SocherBauerManningNg_ACL2013.pdf
+    
+    原始数据中内容应该为：第一行为标题（具体内容会被忽略），之后每一行为一个 sample ，第一个制表符之前是 **句子** ，
+    第一个制表符之后认为是 **label** 。
 
     Example::
 
@@ -319,7 +325,7 @@ class SST2Loader(Loader):
         it 's a charming and often affecting journey . 	1
         unflinchingly bleak and desperate 	0
 
-    读取之后DataSet将如下所示
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_words", "target"
@@ -328,7 +334,7 @@ class SST2Loader(Loader):
         "unflinchingly bleak and desperate", "0"
         "..."
 
-    test的DataSet没有target列。
+    测试集的 :class:`~fastNLP.core.DataSet` 没有 ``target`` 列。
     """
 
     def __init__(self):
@@ -366,8 +372,8 @@ class SST2Loader(Loader):
 
     def download(self):
         r"""
-        自动下载数据集，如果你使用了该数据集，请引用以下的文章
-        https://nlp.stanford.edu/pubs/SocherBauerManningNg_ACL2013.pdf
+        自动下载数据集。
+
         :return:
         """
         output_dir = self._get_dataset_path(dataset_name='sst-2')
@@ -376,8 +382,11 @@ class SST2Loader(Loader):
 
 class ChnSentiCorpLoader(Loader):
     r"""
-    支持读取的数据的格式为，第一行为标题(具体内容会被忽略)，之后一行为一个sample，第一个制表符之前被认为是label，第
-    一个制表符之后认为是句子
+    **ChnSentiCorp** 数据集的 **Loader**，该数据取自 https://github.com/pengming617/bert_classification/tree/master/data，在
+    https://arxiv.org/pdf/1904.09223.pdf 与 https://arxiv.org/pdf/1906.08101.pdf 有使用。
+
+    支持读取的数据的格式为：第一行为标题（具体内容会被忽略），之后每一行为一个 sample，第一个制表符之前被认为是 **label** ，第
+    一个制表符之后认为是 **句子** 。
 
     Example::
 
@@ -385,7 +394,7 @@ class ChnSentiCorpLoader(Loader):
         1	基金痛所有投资项目一样，必须先要有所了解...
         1	系统很好装，LED屏是不错，就是16比9的比例...
 
-    读取后的DataSet具有以下的field
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_chars", "target"
@@ -421,10 +430,9 @@ class ChnSentiCorpLoader(Loader):
 
     def download(self) -> str:
         r"""
-        自动下载数据，该数据取自https://github.com/pengming617/bert_classification/tree/master/data，在
-        https://arxiv.org/pdf/1904.09223.pdf与https://arxiv.org/pdf/1906.08101.pdf有使用
+        自动下载数据。
 
-        :return:
+        :return: 数据集的目录地址
         """
         output_dir = self._get_dataset_path('chn-senti-corp')
         return output_dir
@@ -432,14 +440,17 @@ class ChnSentiCorpLoader(Loader):
 
 class THUCNewsLoader(Loader):
     r"""
-    数据集简介：document-level分类任务，新闻10分类
-    原始数据内容为：每行一个sample，第一个 "\\t" 之前为target，第一个 "\\t" 之后为raw_words
+    **THUCNews** 数据集的 **Loader**，该数据取自
+    http://thuctc.thunlp.org/#%E4%B8%AD%E6%96%87%E6%96%87%E6%9C%AC%E5%88%86%E7%B1%BB%E6%95%B0%E6%8D%AE%E9%9B%86THUCNews
+    
+    数据用于 document-level 分类任务，新闻 10 分类。
+    原始数据内容为：每行一个 sample，第一个 ``"\t"`` 之前为 **target** ，第一个 ``"\t"`` 之后为 **raw_words** 。
 
     Example::
 
         体育	调查-您如何评价热火客场胜绿军总分3-1夺赛点？...
 
-    读取后的Dataset将具有以下数据结构：
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_words", "target"
@@ -466,11 +477,9 @@ class THUCNewsLoader(Loader):
 
     def download(self) -> str:
         r"""
-        自动下载数据，该数据取自
-
-        http://thuctc.thunlp.org/#%E4%B8%AD%E6%96%87%E6%96%87%E6%9C%AC%E5%88%86%E7%B1%BB%E6%95%B0%E6%8D%AE%E9%9B%86THUCNews
+        自动下载数据。
 
-        :return:
+        :return: 数据集目录地址
         """
         output_dir = self._get_dataset_path('thuc-news')
         return output_dir
@@ -478,8 +487,8 @@ class THUCNewsLoader(Loader):
 
 class WeiboSenti100kLoader(Loader):
     r"""
-    别名：
-    数据集简介：微博sentiment classification，二分类
+    **WeiboSenti100k** 数据集的 **Loader**，该数据取自 https://github.com/SophonPlus/ChineseNlpCorpus/，
+    在 https://arxiv.org/abs/1906.08101 有使用。微博 sentiment classification，二分类。
 
     Example::
 
@@ -487,7 +496,7 @@ class WeiboSenti100kLoader(Loader):
         1	多谢小莲，好运满满[爱你]
         1	能在他乡遇老友真不赖，哈哈，珠儿，我也要用...
 
-    读取后的Dataset将具有以下数据结构：
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_chars", "target"
@@ -515,28 +524,29 @@ class WeiboSenti100kLoader(Loader):
 
     def download(self) -> str:
         r"""
-        自动下载数据，该数据取自 https://github.com/SophonPlus/ChineseNlpCorpus/
-        在 https://arxiv.org/abs/1906.08101 有使用
-        :return:
+        自动下载数据。
+
+        :return: 数据集目录地址
         """
         output_dir = self._get_dataset_path('weibo-senti-100k')
         return output_dir
 
 
 class MRLoader(CLSBaseLoader):
+    """
+    **MR** 数据集的 **Loader**
+    """
     def __init__(self):
         super(MRLoader, self).__init__()
 
     def download(self, dev_ratio: float = 0.0, re_download: bool = False) -> str:
         r"""
-            自动下载数据集
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-            如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-            下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
-
-            :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-            :param bool re_download: 是否重新下载数据，以重新切分数据。
-            :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = r'mr'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -549,19 +559,20 @@ class MRLoader(CLSBaseLoader):
 
 
 class R8Loader(CLSBaseLoader):
+    """
+    **R8** 数据集的 **Loader**
+    """
     def __init__(self):
         super(R8Loader, self).__init__()
 
     def download(self, dev_ratio: float = 0.0, re_download: bool = False) -> str:
         r"""
-            自动下载数据集
-
-            如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-            下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-            :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-            :param bool re_download: 是否重新下载数据，以重新切分数据。
-            :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = r'R8'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -574,19 +585,20 @@ class R8Loader(CLSBaseLoader):
 
 
 class R52Loader(CLSBaseLoader):
+    """
+    **R52** 数据集的 **Loader**
+    """
     def __init__(self):
         super(R52Loader, self).__init__()
 
     def download(self, dev_ratio: float = 0.0, re_download: bool = False) -> str:
         r"""
-            自动下载数据集
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-            如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-            下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
-
-            :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-            :param bool re_download: 是否重新下载数据，以重新切分数据。
-            :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = r'R52'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -599,19 +611,20 @@ class R52Loader(CLSBaseLoader):
 
 
 class NG20Loader(CLSBaseLoader):
+    """
+    **NG20** 数据集的 **Loader**
+    """
     def __init__(self):
         super(NG20Loader, self).__init__()
 
     def download(self, dev_ratio: float = 0.0, re_download: bool = False) -> str:
         r"""
-            自动下载数据集
-
-            如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-            下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-            :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-            :param bool re_download: 是否重新下载数据，以重新切分数据。
-            :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = r'20ng'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -624,19 +637,20 @@ class NG20Loader(CLSBaseLoader):
 
 
 class OhsumedLoader(CLSBaseLoader):
+    """
+    **Ohsumed** 数据集的 **Loader**
+    """
     def __init__(self):
         super(OhsumedLoader, self).__init__()
 
     def download(self, dev_ratio: float = 0.0, re_download: bool = False) -> str:
         r"""
-            自动下载数据集
-
-            如果dev_ratio不等于0,则根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。
-            下载完成后在output_dir中有train.csv, test.csv, dev.csv三个文件。否则只有train.csv和test.csv
+        自动下载数据集。下载完成后在 ``output_dir`` 中有 ``train.csv`` , ``test.csv`` , ``dev.csv`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.csv`` 和 ``test.csv`` 。
 
-            :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-            :param bool re_download: 是否重新下载数据，以重新切分数据。
-            :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         dataset_name = r'ohsumed'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)

fastNLP/io/loader/conll.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "ConllLoader",
     "Conll2003Loader",
@@ -17,6 +15,7 @@ import os
 import random
 import shutil
 import time
+from typing import List
 
 from .loader import Loader
 from ..file_reader import _read_conll
@@ -26,9 +25,7 @@ from fastNLP.core.dataset import DataSet, Instance
 
 class ConllLoader(Loader):
     r"""
-    ConllLoader支持读取的数据格式: 以空行隔开两个sample，除了分割行，每一行用空格或者制表符隔开不同的元素。如下例所示:
-
-    Example::
+    :class:`ConllLoader` 支持读取的数据格式：以空行隔开两个 sample，除了分割行之外的每一行用空格或者制表符隔开不同的元素。如下例所示::
 
         # 文件中的内容
         Nadim NNP B-NP B-PER
@@ -48,19 +45,16 @@ class ConllLoader(Loader):
         # 如果用以下的参数读取，返回的DataSet将包含raw_words, pos和ner三个field
         dataset = ConllLoader(headers=['raw_words', 'pos', 'ner'], indexes=[0, 1, 3])._load('/path/to/train.conll')
 
-    ConllLoader返回的DataSet的field由传入的headers确定。
+    :class:`ConllLoader` 返回的 :class:`~fastNLP.core.DataSet` 的 `field` 由传入的 ``headers`` 确定。
 
+    :param headers: 每一列数据的名称， ``header`` 与 ``indexes`` 一一对应
+    :param sep: 指定分隔符，默认为制表符
+    :param indexes: 需要保留的数据列下标，从 **0** 开始。若为 ``None`` ，则所有列都保留。
+    :param dropna: 是否忽略非法数据，若为 ``False`` ，则遇到非法数据时抛出 :class:`ValueError` 。
+    :param drophashtag: 是否忽略以 ``#`` 开头的句子。
     """
     
-    def __init__(self, headers, sep=None, indexes=None, dropna=True, drophash=True):
-        r"""
-        
-        :param list headers: 每一列数据的名称，需为List or Tuple  of str。``header`` 与 ``indexes`` 一一对应
-        :param str sep: 指定分隔符，默认为制表符
-        :param list indexes: 需要保留的数据列下标，从0开始。若为 ``None`` ，则所有列都保留。Default: ``None``
-        :param bool dropna: 是否忽略非法数据，若 ``False`` ，遇到非法数据时抛出 ``ValueError`` 。Default: ``True``
-        :param bool drophashtag: 是否忽略以 ``#`` 开头的句子。
-        """
+    def __init__(self, headers: List[str], sep: str=None, indexes: List[int]=None, dropna: bool=True, drophash: bool=True):
         super(ConllLoader, self).__init__()
         if not isinstance(headers, (list, tuple)):
             raise TypeError(
@@ -93,8 +87,9 @@ class ConllLoader(Loader):
 
 class Conll2003Loader(ConllLoader):
     r"""
-    用于读取conll2003任务的数据。数据的内容应该类似与以下的内容, 第一列为raw_words, 第二列为pos, 第三列为chunking，第四列为ner。
-    数据中以"-DOCSTART-"开头的行将被忽略，因为该符号在conll 2003中被用为文档分割符。
+    用于读取 **conll2003** 任务的数据。数据的内容应该类似于以下的内容：第一列为 **raw_words** ，第二列为 **pos** ，
+    第三列为 **chunking** ，第四列为 **ner** 。
+    数据中以 ``"-DOCSTART-"`` 开头的行将被忽略，因为该符号在 **conll2003** 中被用为文档分割符。
 
     Example::
 
@@ -108,9 +103,9 @@ class Conll2003Loader(ConllLoader):
         1996-12-06 CD I-NP O
         ...
 
-    返回的DataSet的内容为
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
-    .. csv-table:: 下面是Conll2003Loader加载后数据具备的结构。
+    .. csv-table:: 下面是 Conll2003Loader 加载后数据具备的结构。
        :header: "raw_words", "pos", "chunk", "ner"
 
        "[Nadim, Ladki]", "[NNP, NNP]", "[B-NP, I-NP]", "[B-PER, I-PER]"
@@ -152,10 +147,9 @@ class Conll2003Loader(ConllLoader):
 
 class Conll2003NERLoader(ConllLoader):
     r"""
-    用于读取conll2003任务的NER数据。每一行有4列内容，空行意味着隔开两个句子
+    用于读取 **conll2003** 任务的 NER 数据。每一行有 4 列内容，空行意味着隔开两个句子。
 
-    支持读取的内容如下
-    Example::
+    支持读取的内容如下::
 
         Nadim NNP B-NP B-PER
         Ladki NNP I-NP I-PER
@@ -167,9 +161,9 @@ class Conll2003NERLoader(ConllLoader):
         1996-12-06 CD I-NP O
         ...
 
-    返回的DataSet的内容为
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
-    .. csv-table:: 下面是Conll2003Loader加载后数据具备的结构, target是BIO2编码
+    .. csv-table:: 下面是 Conll2003Loader 加载后数据具备的结构, target 是 BIO2 编码
        :header: "raw_words", "target"
 
        "[Nadim, Ladki]", "[B-PER, I-PER]"
@@ -213,18 +207,16 @@ class Conll2003NERLoader(ConllLoader):
 
 class OntoNotesNERLoader(ConllLoader):
     r"""
-    用以读取OntoNotes的NER数据，同时也是Conll2012的NER任务数据。将OntoNote数据处理为conll格式的过程可以参考
-    https://github.com/yhcc/OntoNotes-5.0-NER。OntoNoteNERLoader将取第4列和第11列的内容。
-
-    读取的数据格式为：
+    用以读取 **OntoNotes** 的 NER 数据，同时也是 **Conll2012** 的 NER 任务数据。将 **OntoNote** 数据处理为 conll 格式的过程可以参考
+    https://github.com/yhcc/OntoNotes-5.0-NER。:class:`OntoNotesNERLoader` 将取第 **4** 列和第 **11** 列的内容。
 
-    Example::
+    读取的数据格式为::
 
         bc/msnbc/00/msnbc_0000   0   0          Hi   UH   (TOP(FRAG(INTJ*)  -   -   -    Dan_Abrams  *   -
         bc/msnbc/00/msnbc_0000   0   1    everyone   NN              (NP*)  -   -   -    Dan_Abrams  *   -
         ...
 
-    返回的DataSet的内容为
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_words", "target"
@@ -291,7 +283,8 @@ class OntoNotesNERLoader(ConllLoader):
 
 class CTBLoader(Loader):
     r"""
-    支持加载的数据应该具备以下格式, 其中第二列为词语，第四列为pos tag，第七列为依赖树的head，第八列为依赖树的label
+    **CTB** 数据集的 **Loader**。支持加载的数据应该具备以下格式, 其中第二列为 **词语** ，第四列为 **pos tag** ，第七列为 **依赖树的 head** ，
+    第八列为 **依赖树的 label** 。
 
     Example::
 
@@ -306,7 +299,7 @@ class CTBLoader(Loader):
         3       １２月  _       NT      NT      _       7       dep     _       _
         ...
 
-    读取之后DataSet具备的格式为
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_words", "pos", "dep_head", "dep_label"
@@ -335,30 +328,30 @@ class CTBLoader(Loader):
         由于版权限制，不能提供自动下载功能。可参考
 
         https://catalog.ldc.upenn.edu/LDC2013T21
-
-        :return:
         """
         raise RuntimeError("CTB cannot be downloaded automatically.")
 
 
 class CNNERLoader(Loader):
-    def _load(self, path: str):
-        r"""
-        支持加载形如以下格式的内容，一行两列，以空格隔开两个sample
+    r"""
+    支持加载形如以下格式的内容，一行两列，以空格隔开两个 sample
 
-        Example::
+    Example::
 
-            我 O
-            们 O
-            变 O
-            而 O
-            以 O
-            书 O
-            会 O
-            ...
+        我 O
+        们 O
+        变 O
+        而 O
+        以 O
+        书 O
+        会 O
+        ...
 
-        :param str path: 文件路径
-        :return: DataSet，包含raw_words列和target列
+    """
+    def _load(self, path: str):
+        """
+        :param path: 文件路径
+        :return: :class:`~fastNLP.core.DataSet` ，包含 ``raw_words`` 列和 ``target`` 列
         """
         ds = DataSet()
         with open(path, 'r', encoding='utf-8') as f:
@@ -382,9 +375,11 @@ class CNNERLoader(Loader):
 
 class MsraNERLoader(CNNERLoader):
     r"""
-    读取MSRA-NER数据，数据中的格式应该类似与下列的内容
-
-    Example::
+    读取 **MSRA-NER** 数据，如果您要使用该数据，请引用以下的文章：
+    
+    Gina-Anne Levow, 2006, The Third International Chinese Language Processing Bakeoff: Word Segmentation and Named Entity Recognition.
+        
+    数据中的格式应该类似于下列的内容::
 
         把	O
         欧	B-LOC
@@ -404,7 +399,7 @@ class MsraNERLoader(CNNERLoader):
 
         ...
 
-    读取后的DataSet包含以下的field
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_chars", "target"
@@ -420,15 +415,14 @@ class MsraNERLoader(CNNERLoader):
     
     def download(self, dev_ratio: float = 0.1, re_download: bool = False) -> str:
         r"""
-        自动下载MSAR-NER的数据，如果你使用该数据，请引用 Gina-Anne Levow, 2006, The Third International Chinese Language
-        Processing Bakeoff: Word Segmentation and Named Entity Recognition.
+        自动下载 **MSAR-NER** 的数据。
 
-        根据dev_ratio的值随机将train中的数据取出一部分作为dev数据。下载完成后在output_dir中有train.conll, test.conll,
-        dev.conll三个文件。
+        下载完成后在 ``output_dir`` 中有 ``train.conll`` , ``test.conll`` , ``dev.conll`` 三个文件。
+        如果 ``dev_ratio`` 为 0，则只有 ``train.conll`` 和 ``test.conll`` 。
 
-        :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str, 数据集的目录地址
+        :param dev_ratio: 如果路径中没有验证集 ，从 train 划分多少作为 dev 的数据。如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         :return:
         """
         dataset_name = 'msra-ner'
@@ -470,9 +464,11 @@ class MsraNERLoader(CNNERLoader):
 
 class WeiboNERLoader(CNNERLoader):
     r"""
-    读取WeiboNER数据，数据中的格式应该类似与下列的内容
-
-    Example::
+    读取 **WeiboNER** 数据，如果您要使用该数据，请引用以下的文章：
+    
+    Nanyun Peng and Mark Dredze, 2015, Named Entity Recognition for Chinese Social Media with Jointly Trained Embeddings.
+    
+    数据中的格式应该类似与下列的内容::
 
         老	B-PER.NOM
         百	I-PER.NOM
@@ -482,7 +478,7 @@ class WeiboNERLoader(CNNERLoader):
 
         ...
 
-        读取后的DataSet包含以下的field
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
         .. csv-table::
 
@@ -498,10 +494,9 @@ class WeiboNERLoader(CNNERLoader):
     
     def download(self) -> str:
         r"""
-        自动下载Weibo-NER的数据，如果你使用了该数据，请引用 Nanyun Peng and Mark Dredze, 2015, Named Entity Recognition for
-        Chinese Social Media with Jointly Trained Embeddings.
+        自动下载 **Weibo-NER** 的数据。
 
-        :return: str
+        :return: 数据集目录地址
         """
         dataset_name = 'weibo-ner'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
@@ -511,9 +506,7 @@ class WeiboNERLoader(CNNERLoader):
 
 class PeopleDailyNERLoader(CNNERLoader):
     r"""
-    支持加载的数据格式如下
-
-    Example::
+    加载 **People's Daily NER** 数据集的 **Loader** 。支持加载的数据格式如下::
 
         中 B-ORG
         共 I-ORG
@@ -524,9 +517,9 @@ class PeopleDailyNERLoader(CNNERLoader):
         中 B-ORG
         ...
 
-    读取后的DataSet包含以下的field
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
-    .. csv-table:: target列是基于BIO的编码方式
+    .. csv-table:: target 列是基于 BIO 的编码方式
         :header: "raw_chars", "target"
 
         "['中', '共', '中', '央']", "['B-ORG', 'I-ORG', 'I-ORG', 'I-ORG']"
@@ -538,6 +531,11 @@ class PeopleDailyNERLoader(CNNERLoader):
         super().__init__()
     
     def download(self) -> str:
+        """
+        自动下载数据集。
+
+        :return: 数据集目录地址
+        """
         dataset_name = 'peopledaily'
         data_dir = self._get_dataset_path(dataset_name=dataset_name)
         

fastNLP/io/loader/csv.py

@@ -1,9 +1,9 @@
-r"""undocumented"""
-
 __all__ = [
     "CSVLoader",
 ]
 
+from typing import List
+
 from .loader import Loader
 from ..file_reader import _read_csv
 from fastNLP.core.dataset import DataSet, Instance
@@ -11,19 +11,15 @@ from fastNLP.core.dataset import DataSet, Instance
 
 class CSVLoader(Loader):
     r"""
-    读取CSV格式的数据集, 返回 ``DataSet`` 。
+    读取CSV格式的数据集, 返回 :class:`~fastNLP.core.DataSet` 。
 
+    :param headers: CSV文件的文件头，定义每一列的属性名称，即返回的 :class:`~fastNLP.core.DataSet` 中 ``field`` 的名称。
+        若为 ``None`` ，则将读入文件的第一行视作 ``headers`` 。
+    :param sep: CSV文件中列与列之间的分隔符。
+    :param dropna: 是否忽略非法数据，若为 ``True`` 则忽略；若为 ``False`` 则在遇到非法数据时抛出 :class:`ValueError`。
     """
 
-    def __init__(self, headers=None, sep=",", dropna=False):
-        r"""
-        
-        :param List[str] headers: CSV文件的文件头.定义每一列的属性名称,即返回的DataSet中`field`的名称
-            若为 ``None`` ,则将读入文件的第一行视作 ``headers`` . Default: ``None``
-        :param str sep: CSV文件中列与列之间的分隔符. Default: ","
-        :param bool dropna: 是否忽略非法数据,若 ``True`` 则忽略,若 ``False`` ,在遇到非法数据时,抛出 ``ValueError`` .
-            Default: ``False``
-        """
+    def __init__(self, headers: List[str]=None, sep: str=",", dropna: bool=False):
         super().__init__()
         self.headers = headers
         self.sep = sep

fastNLP/io/loader/cws.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "CWSLoader"
 ]
@@ -16,15 +14,16 @@ from fastNLP.core.dataset import DataSet, Instance
 
 class CWSLoader(Loader):
     r"""
-    CWSLoader支持的数据格式为，一行一句话，不同词之间用空格隔开, 例如：
+    **Chinese word segmentor** 的 **Loader** 。如果您使用了该数据集，请引用以下的文章：Thomas Emerson, The Second International Chinese Word Segmentation Bakeoff,
+    2005. 更多信息可以在 http://sighan.cs.uchicago.edu/bakeoff2005/ 查看。
 
-    Example::
+    :class:`CWSLoader` 支持的数据格式为：一行一句话，不同词之间用空格隔开，例如::
 
         上海 浦东 开发 与 法制 建设 同步
         新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ）
         ...
 
-    该Loader读取后的DataSet具有如下的结构
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
        :header: "raw_words"
@@ -32,14 +31,11 @@ class CWSLoader(Loader):
        "上海 浦东 开发 与 法制 建设 同步"
        "新华社 上海 二月 十日 电 （ 记者 谢金虎 、 张持坚 ）"
        "..."
-       
+
+    :param dataset_name: data 的名称，支持 ``['pku', 'msra', 'cityu'(繁体), 'as'(繁体), None]``
     """
 
     def __init__(self, dataset_name: str = None):
-        r"""
-        
-        :param str dataset_name: data的名称，支持pku, msra, cityu(繁体), as(繁体), None
-        """
         super().__init__()
         datanames = {'pku': 'cws-pku', 'msra': 'cws-msra', 'as': 'cws-as', 'cityu': 'cws-cityu'}
         if dataset_name in datanames:
@@ -58,12 +54,11 @@ class CWSLoader(Loader):
 
     def download(self, dev_ratio=0.1, re_download=False) -> str:
         r"""
-        如果你使用了该数据集，请引用以下的文章:Thomas Emerson, The Second International Chinese Word Segmentation Bakeoff,
-        2005. 更多信息可以在http://sighan.cs.uchicago.edu/bakeoff2005/查看
+        自动下载数据集。
 
-        :param float dev_ratio: 如果路径中没有dev集，从train划分多少作为dev的数据. 如果为0，则不划分dev。
-        :param bool re_download: 是否重新下载数据，以重新切分数据。
-        :return: str
+        :param dev_ratio: 如果路径中没有验证集，从 train 划分多少作为 dev 的数据。 如果为 **0** ，则不划分 dev
+        :param re_download: 是否重新下载数据，以重新切分数据。
+        :return: 数据集的目录地址
         """
         if self.dataset_name is None:
             return ''

fastNLP/io/loader/json.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "JsonLoader"
 ]
@@ -11,19 +9,16 @@ from fastNLP.core.dataset import DataSet, Instance
 
 class JsonLoader(Loader):
     r"""
-    别名：:class:`fastNLP.io.JsonLoader` :class:`fastNLP.io.loader.JsonLoader`
-
-    读取json格式数据.数据必须按行存储,每行是一个包含各类属性的json对象
+    读取 *json* 格式数据，数据必须按行存储，每行是一个包含各类属性的 json 对象。
 
-    :param dict fields: 需要读入的json属性名称, 和读入后在DataSet中存储的field_name
-        ``fields`` 的 `key` 必须是json对象的属性名. ``fields`` 的 `value` 为读入后在DataSet存储的 `field_name` ,
-        `value` 也可为 ``None`` , 这时读入后的 `field_name` 与json对象对应属性同名
-        ``fields`` 可为 ``None`` , 这时,json对象所有属性都保存在DataSet中. Default: ``None``
-    :param bool dropna: 是否忽略非法数据,若 ``True`` 则忽略,若 ``False`` ,在遇到非法数据时,抛出 ``ValueError`` .
-        Default: ``False``
+    :param fields: 需要读入的 json 属性名称，和读入后在 :class:`~fastNLP.core.DataSet` 中存储的 `field_name`。
+        ``fields`` 的 `key` 必须是 json 对象的 **属性名**， ``fields`` 的 `value` 为读入后在 ``DataSet`` 存储的 `field_name` ，
+        `value` 也可为 ``None`` ，这时读入后的  `field_name` 与 json 对象对应属性同名。
+        ``fields`` 可为 ``None`` ，这时 json 对象所有属性都保存在 ``DataSet`` 中。
+    :param dropna: 是否忽略非法数据，若为 ``True`` 则忽略；若为 ``False`` 则在遇到非法数据时抛出 :class:`ValueError`。
     """
 
-    def __init__(self, fields=None, dropna=False):
+    def __init__(self, fields: dict=None, dropna=False):
         super(JsonLoader, self).__init__()
         self.dropna = dropna
         self.fields = None

fastNLP/io/loader/loader.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "Loader"
 ]
@@ -14,24 +12,23 @@ from fastNLP.core.dataset import DataSet
 
 class Loader:
     r"""
-    各种数据 Loader 的基类，提供了 API 的参考.
-    Loader支持以下的三个函数
+    各种数据 **Loader** 的基类，提供了 API 的参考。
+    :class:`Loader` 支持以下的三个函数
 
-    - download() 函数：自动将该数据集下载到缓存地址，默认缓存地址为~/.fastNLP/datasets/。由于版权等原因，不是所有的Loader都实现了该方法。该方法会返回下载后文件所处的缓存地址。
-    - _load() 函数：从一个数据文件中读取数据，返回一个 :class:`~fastNLP.DataSet` 。返回的DataSet的内容可以通过每个Loader的文档判断出。
-    - load() 函数：将文件分别读取为DataSet，然后将多个DataSet放入到一个DataBundle中并返回
-    
+    - :meth:`download` 函数：自动将该数据集下载到缓存地址，默认缓存地址为 ``~/.fastNLP/datasets/`` 。由于版权等原因，不是所有的 ``Loader`` 都实现了该方法。
+      该方法会返回下载后文件所处的缓存地址。
+    - :meth:`_load` 函数：从一个数据文件中读取数据，返回一个 :class:`~fastNLP.core.DataSet` 。返回的 DataSet 的内容可以通过每个 ``Loader`` 的文档判断出。
+    - :meth:`load` 函数：将文件分别读取为 :class:`~fastNLP.core.DataSet` ，然后将多个 DataSet 放入到一个 :class:`~fastNLP.io.DataBundle` 中并返回
     """
-    
     def __init__(self):
         pass
     
     def _load(self, path: str) -> DataSet:
         r"""
-        给定一个路径，返回读取的DataSet。
+        给定一个路径，返回读取的 :class:`~fastNLP.core.DataSet` 。
 
-        :param str path: 路径
-        :return: DataSet
+        :param path: 路径
+        :return: :class:`~fastNLP.core.DataSet`
         """
         raise NotImplementedError
     
@@ -39,29 +36,29 @@ class Loader:
         r"""
         从指定一个或多个路径中的文件中读取数据，返回 :class:`~fastNLP.io.DataBundle` 。
 
-        :param Union[str, Dict[str, str]] paths: 支持以下的几种输入方式：
-
-            0.如果为None，则先查看本地是否有缓存，如果没有则自动下载并缓存。
+        :param paths: 支持以下的几种输入方式：
 
-            1.传入一个目录, 该目录下名称包含train的被认为是train，包含test的被认为是test，包含dev的被认为是dev，如果检测到多个文件名包含'train'、 'dev'、 'test'则会报错::
+            - ``None`` -- 先查看本地是否有缓存，如果没有则自动下载并缓存。
+            - 一个目录，该目录下名称包含 ``'train'`` 的被认为是训练集，包含 ``'test'`` 的被认为是测试集，包含 ``'dev'`` 的被认为是验证集 / 开发集，
+              如果检测到多个文件名包含 ``'train'``、 ``'dev'``、 ``'test'`` 则会报错::
 
                 data_bundle = xxxLoader().load('/path/to/dir')  # 返回的DataBundle中datasets根据目录下是否检测到train
-                #  dev、 test等有所变化，可以通过以下的方式取出DataSet
+                #  dev、 test 等有所变化，可以通过以下的方式取出 DataSet
                 tr_data = data_bundle.get_dataset('train')
                 te_data = data_bundle.get_dataset('test')  # 如果目录下有文件包含test这个字段
 
-            2.传入一个dict，比如train，dev，test不在同一个目录下，或者名称中不包含train, dev, test::
+            - 传入一个 :class:`dict` ，比如训练集、验证集和测试集不在同一个目录下，或者名称中不包含 ``'train'``、 ``'dev'``、 ``'test'`` ::
 
                 paths = {'train':"/path/to/tr.conll", 'dev':"/to/validate.conll", "test":"/to/te.conll"}
                 data_bundle = xxxLoader().load(paths)  # 返回的DataBundle中的dataset中包含"train", "dev", "test"
                 dev_data = data_bundle.get_dataset('dev')
 
-            3.传入文件路径::
+            - 传入文件路径::
 
                 data_bundle = xxxLoader().load("/path/to/a/train.conll") # 返回DataBundle对象, datasets中仅包含'train'
                 tr_data = data_bundle.get_dataset('train')  # 取出DataSet
 
-        :return: 返回的 :class:`~fastNLP.io.DataBundle`
+        :return: :class:`~fastNLP.io.DataBundle`
         """
         if paths is None:
             paths = self.download()

fastNLP/io/loader/matching.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "MNLILoader",
     "SNLILoader",
@@ -26,17 +24,19 @@ from fastNLP.core.log import logger
 
 class MNLILoader(Loader):
     r"""
-    读取的数据格式为：
+    **MNLI** 数据集的 **Loader**，如果您使用了这个数据，请引用
 
-    Example::
+        https://www.nyu.edu/projects/bowman/multinli/paper.pdf
+    
+    读取的数据格式为::
 
         index	promptID	pairID	genre	sentence1_binary_parse	sentence2_binary_parse	sentence1_parse	sentence2_parse	sentence1	sentence2	label1	gold_label
         0	31193	31193n	government	( ( Conceptually ( cream skimming ) ) ...
         1	101457	101457e	telephone	( you ( ( know ( during ( ( ( the season ) and ) ( i guess ) ) )...
         ...
 
-    读取MNLI任务的数据，读取之后的DataSet中包含以下的内容，words0是sentence1, words1是sentence2, target是gold_label, 测试集中没
-    有target列。
+    读取之后的 :class:`~fastNLP.core.DataSet` 中包含以下的内容： ``raw_words`` 是 ``sentence1`` ， ``raw_words2`` 是 ``sentence2`` ，
+    ``target`` 是 ``gold_label``。测试集中没有 ``target`` 列。
 
     .. csv-table::
        :header: "raw_words1", "raw_words2", "target"
@@ -80,10 +80,9 @@ class MNLILoader(Loader):
     
     def load(self, paths: str = None):
         r"""
-
-        :param str paths: 传入数据所在目录，会在该目录下寻找dev_matched.tsv, dev_mismatched.tsv, test_matched.tsv,
-            test_mismatched.tsv, train.tsv文件夹
-        :return: DataBundle
+        :param paths: 传入数据所在目录，会在该目录下寻找 ``dev_matched.tsv``, ``dev_mismatched.tsv``, ``test_matched.tsv``,
+            ``test_mismatched.tsv``, ``train.tsv`` 文件。
+        :return: :class:`~fastNLP.io.DataBundle`
         """
         if paths:
             paths = os.path.abspath(os.path.expanduser(paths))
@@ -112,10 +111,9 @@ class MNLILoader(Loader):
     
     def download(self):
         r"""
-        如果你使用了这个数据，请引用
+        自动下载数据集。
 
-        https://www.nyu.edu/projects/bowman/multinli/paper.pdf
-        :return:
+        :return: 数据集目录地址
         """
         output_dir = self._get_dataset_path('mnli')
         return output_dir
@@ -123,9 +121,11 @@ class MNLILoader(Loader):
 
 class SNLILoader(JsonLoader):
     r"""
-    文件每一行是一个sample，每一行都为一个json对象，其数据格式为：
+    **SNLI** 数据集的 **Loader**，如果您的文章使用了这份数据，请引用
 
-    Example::
+        http://nlp.stanford.edu/pubs/snli_paper.pdf
+    
+    文件每一行是一个 sample，每一行都为一个 ``json`` 对象，其数据格式为::
 
         {"annotator_labels": ["neutral", "entailment", "neutral", "neutral", "neutral"], "captionID": "4705552913.jpg#2",
          "gold_label": "neutral", "pairID": "4705552913.jpg#2r1n",
@@ -137,7 +137,7 @@ class SNLILoader(JsonLoader):
          "sentence2_parse": "(ROOT (S (NP (DT The) (NNS sisters)) (VP (VBP are) (VP (VBG hugging) (NP (UH goodbye)) (PP (IN while) (S (VP (VBG holding) (S (VP (TO to) (VP (VB go) (NP (NNS packages)) (PP (IN after) (S (ADVP (RB just)) (VP (VBG eating) (NP (NN lunch))))))))))))) (. .)))"
          }
 
-    读取之后的DataSet中的field情况为
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table:: 下面是使用SNLILoader加载的DataSet所具备的field
        :header: "target", "raw_words1", "raw_words2",
@@ -158,13 +158,11 @@ class SNLILoader(JsonLoader):
     def load(self, paths: Union[str, Dict[str, str]] = None) -> DataBundle:
         r"""
         从指定一个或多个路径中的文件中读取数据，返回 :class:`~fastNLP.io.DataBundle` 。
+        读取的 field 根据 :class:`SNLILoader` 初始化时传入的 ``fields`` 决定。
 
-        读取的field根据Loader初始化时传入的field决定。
-
-        :param str paths: 传入一个目录, 将在该目录下寻找snli_1.0_train.jsonl, snli_1.0_dev.jsonl
-            和snli_1.0_test.jsonl三个文件。
-
-        :return: :class:`~fastNLP.io.DataBundle`
+        :param str paths: 传入一个目录, 将在该目录下寻找 ``snli_1.0_train.jsonl``, ``snli_1.0_dev.jsonl``
+            和 ``snli_1.0_test.jsonl`` 三个文件。
+        :return:
         """
         _paths = {}
         if paths is None:
@@ -187,26 +185,26 @@ class SNLILoader(JsonLoader):
     
     def download(self):
         r"""
-        如果您的文章使用了这份数据，请引用
-
-        http://nlp.stanford.edu/pubs/snli_paper.pdf
+        自动下载数据集。
 
-        :return: str
+        :return: 数据集目录地址
         """
         return self._get_dataset_path('snli')
 
 
 class QNLILoader(JsonLoader):
     r"""
-    第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、问题、句子和标签构成（以制表符分割），数据结构如下：
+    **QNLI** 数据集的 **Loader** ，如果您的实验使用到了该数据，请引用
 
-    Example::
+        https://arxiv.org/pdf/1809.05053.pdf
+        
+    读取数据的格式为：第一行为标题（具体内容会被忽略），之后每一行是一个 sample，由 **index** 、**问题** 、**句子** 和 **标签** 构成（以制表符分割），数据结构如下::
 
         index	question	sentence	label
         0	What came into force after the new constitution was herald?	As of that day, the new constitution heralding the Second Republic came into force.	entailment
 
-    QNLI数据集的Loader,
-    加载的DataSet将具备以下的field, raw_words1是question, raw_words2是sentence, target是label
+    加载的 :class:`~fastNLP.core.DataSet` 将具备以下的内容： ``raw_words1`` 是 ``question`` ， ``raw_words2`` 是 ``sentence`` ， ``target`` 是 ``label`` 。
+    测试集中没有 ``target`` 列。
 
     .. csv-table::
         :header: "raw_words1", "raw_words2", "target"
@@ -214,8 +212,6 @@ class QNLILoader(JsonLoader):
         "What came into force after the new...", "As of that day...", "entailment"
         "...","."
 
-    test数据集没有target列
-
     """
     
     def __init__(self):
@@ -250,26 +246,27 @@ class QNLILoader(JsonLoader):
     
     def download(self):
         r"""
-        如果您的实验使用到了该数据，请引用
+        自动下载数据集。
 
-        https://arxiv.org/pdf/1809.05053.pdf
-
-        :return:
+        :return: 数据集目录地址
         """
         return self._get_dataset_path('qnli')
 
 
 class RTELoader(Loader):
     r"""
-    第一行为标题(具体内容会被忽略)，之后每一行是一个sample，由index、句子1、句子2和标签构成（以制表符分割），数据结构如下：
+    **RTE** 数据集的 **Loader**，如果您使用了该数据，请引用 **GLUE Benchmark** ：
 
-    Example::
+        https://openreview.net/pdf?id=rJ4km2R5t7
+        
+    读取数据的格式为：第一行为标题（具体内容会被忽略），之后每一行是一个 sample，由 **index** 、**句子1** 、**句子2** 和 **标签** 
+    构成（以制表符分割），数据结构如下::
 
         index	sentence1	sentence2	label
         0	Dana Reeve, the widow of the actor Christopher Reeve, has died of lung cancer at age 44, according to the Christopher Reeve Foundation.	Christopher Reeve had an accident.	not_entailment
 
-    RTE数据的loader
-    加载的DataSet将具备以下的field, raw_words1是sentence0，raw_words2是sentence1, target是label
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的内容：``raw_words1`` 是 ``sentence1`` ， ``raw_words2`` 是 ``sentence2`` ， ``target`` 是 ``label`` 。
+    测试集中没有 ``target`` 列。
 
     .. csv-table::
         :header: "raw_words1", "raw_words2", "target"
@@ -277,7 +274,6 @@ class RTELoader(Loader):
         "Dana Reeve, the widow of the actor...", "Christopher Reeve had an...", "not_entailment"
         "...","..."
 
-    test数据集没有target列
     """
     
     def __init__(self):
@@ -312,20 +308,17 @@ class RTELoader(Loader):
     
     def download(self):
         r"""
-        如果您的实验使用到了该数据，请引用GLUE Benchmark
+        自动下载数据集。
 
-        https://openreview.net/pdf?id=rJ4km2R5t7
-
-        :return:
+        :return: 数据集目录地址
         """
         return self._get_dataset_path('rte')
 
 
 class QuoraLoader(Loader):
     r"""
-    Quora matching任务的数据集Loader
-
-    支持读取的文件中的内容，应该有以下的形式, 以制表符分隔，且前三列的内容必须是：第一列是label，第二列和第三列是句子
+    **Quora matching** 任务的数据集 **Loader**。
+    支持读取的文件中的内容应该有以下的形式：以制表符分隔，且前三列一定分别为 **label** ， **句子1** ， **句子2** 。
 
     Example::
 
@@ -333,7 +326,7 @@ class QuoraLoader(Loader):
         0	Is honey a viable alternative to sugar for diabetics ?	How would you compare the United States ' euthanasia laws to Denmark ?	90348
         ...
 
-    加载的DataSet将具备以下的field
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
         :header: "raw_words1", "raw_words2", "target"
@@ -370,21 +363,27 @@ class QuoraLoader(Loader):
 
         :return:
         """
+        r"""
+        自动下载数据集。
+
+        :return: 数据集目录地址
+        """
         raise RuntimeError("Quora cannot be downloaded automatically.")
 
 
 class CNXNLILoader(Loader):
     r"""
-    数据集简介：中文句对NLI（本为multi-lingual的数据集，但是这里只取了中文的数据集）。原句子已被MOSES tokenizer处理，这里我们将其还原并重新按字tokenize
-    原始数据数据为：
-
-    Example::
+    **XNLI Chinese** 数据集的 **Loader** ，该数据取自 https://arxiv.org/abs/1809.05053 ，在 https://arxiv.org/pdf/1905.05526.pdf
+    、 https://arxiv.org/pdf/1901.10125.pdf 和 https://arxiv.org/pdf/1809.05053.pdf 有使用。
+    
+    该数据集为中文句对 NLI（本为 ``multi-lingual`` 的数据集，但是这里只取了中文的数据集）。原句子已被
+    ``MOSES tokenizer`` 处理，这里我们将其还原并重新按字 tokenize 。原始数据为::
 
         premise	hypo	label
         我们 家里 有 一个 但 我 没 找到 我 可以 用 的 时间	我们 家里 有 一个 但 我 从来 没有 时间 使用 它 .	entailment
 
-    dev和test中的数据为csv或json格式，包括十多个field，这里只取与以上三个field中的数据
-    读取后的Dataset将具有以下数据结构：
+    验证集和测试集中的数据为 csv 或 json 格式，这里只取以上三个 field 中的数据。
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
        :header: "raw_chars1", "raw_chars2", "target"
@@ -444,6 +443,13 @@ class CNXNLILoader(Loader):
         return ds
 
     def load(self, paths: Union[str, Dict[str, str]] = None) -> DataBundle:
+        """
+        从指定一个或多个路径中的文件中读取数据，返回 :class:`~fastNLP.io.DataBundle` 。
+        读取的 field 根据 :class:`SNLILoader` 初始化时传入的 ``fields`` 决定。
+
+        :param paths:
+        :return:
+        """
         if paths is None:
             paths = self.download()
         paths = check_loader_paths(paths)
@@ -459,10 +465,9 @@ class CNXNLILoader(Loader):
 
     def download(self) -> str:
         r"""
-        自动下载数据，该数据取自 https://arxiv.org/abs/1809.05053
-        在 https://arxiv.org/pdf/1905.05526.pdf https://arxiv.org/pdf/1901.10125.pdf
-        https://arxiv.org/pdf/1809.05053.pdf 有使用
-        :return:
+        自动下载数据集。
+
+        :return: 数据集目录地址
         """
         output_dir = self._get_dataset_path('cn-xnli')
         return output_dir
@@ -470,23 +475,19 @@ class CNXNLILoader(Loader):
 
 class BQCorpusLoader(Loader):
     r"""
-    别名：
-    数据集简介:句子对二分类任务（判断是否具有相同的语义）
-    原始数据结构为：
-
-    Example::
+    **BQ Corpus** 数据集的 **Loader** 。句子对二分类任务，判断是否具有相同的语义。原始数据结构为::
 
         sentence1,sentence2,label
         综合评分不足什么原因,综合评估的依据,0
-        什么时候我能使用微粒贷,你就赶快给我开通就行了,0
+        什么时候我能使用微粒贷,您就赶快给我开通就行了,0
 
-    读取后的Dataset将具有以下数据结构：
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
 
     .. csv-table::
        :header: "raw_chars1", "raw_chars2", "target"
        
        "综合评分不足什么原因", "综合评估的依据", "0"
-       "什么时候我能使用微粒贷", "你就赶快给我开通就行了", "0"
+       "什么时候我能使用微粒贷", "您就赶快给我开通就行了", "0"
        "...", "...", "..."
 
     """
@@ -514,31 +515,25 @@ class BQCorpusLoader(Loader):
         由于版权限制，不能提供自动下载功能。可参考
 
         https://github.com/ymcui/Chinese-BERT-wwm
-
-        :return:
         """
         raise RuntimeError("BQCorpus cannot be downloaded automatically.")
 
 
 class LCQMCLoader(Loader):
     r"""
-    数据集简介：句对匹配（question matching）
-    
-    原始数据为：
-
-    Example::
+    **LCQMC** 数据集的 **Loader**，该数据集用于句对匹配（question matching）。原始数据为::
 
         喜欢打篮球的男生喜欢什么样的女生	爱打篮球的男生喜欢什么样的女生	1
-        你帮我设计小说的封面吧	谁能帮我给小说设计个封面？	0
+        您帮我设计小说的封面吧	谁能帮我给小说设计个封面？	0
 
     
-    读取后的Dataset将具有以下的数据结构
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
     
     .. csv-table::
        :header: "raw_chars1", "raw_chars2", "target"
        
        "喜欢打篮球的男生喜欢什么样的女生", "爱打篮球的男生喜欢什么样的女生", "1"
-       "你帮我设计小说的封面吧", "妇可以戴耳机听音乐吗?", "0"
+       "您帮我设计小说的封面吧", "妇可以戴耳机听音乐吗?", "0"
        "...", "...", "..."
     
     
@@ -569,8 +564,6 @@ class LCQMCLoader(Loader):
         由于版权限制，不能提供自动下载功能。可参考
 
         https://github.com/ymcui/Chinese-BERT-wwm
-
-        :return:
         """
         raise RuntimeError("LCQMC cannot be downloaded automatically.")
 

fastNLP/io/loader/qa.py

@@ -1,6 +1,5 @@
 r"""
-该文件中的Loader主要用于读取问答式任务的数据
-
+该文件中的 **Loader** 主要用于读取问答式任务的数据
 """
 
 
@@ -13,20 +12,23 @@ __all__ = ['CMRC2018Loader']
 
 class CMRC2018Loader(Loader):
     r"""
-    请直接使用从fastNLP下载的数据进行处理。该数据集未提供测试集，测试需要通过上传到对应的系统进行评测
+    **CMRC2018** 数据集的 **Loader** ，如果您使用了本数据，请引用
+    A Span-Extraction Dataset for Chinese Machine Reading Comprehension. Yiming Cui, Ting Liu, etc.
+    
+    请直接使用从 **fastNLP** 下载的数据进行处理。该数据集未提供测试集，测试需要通过上传到对应的系统进行评测。
 
-    读取之后训练集DataSet将具备以下的内容，每个问题的答案只有一个
+    读取之后训练集 :class:`~fastNLP.core.DataSet` 将具备以下的内容，每个问题的答案只有一个：
 
     .. csv-table::
-       :header:"title", "context", "question", "answers", "answer_starts", "id"
+       :header: "title", "context", "question", "answers", "answer_starts", "id"
 
        "范廷颂", "范廷颂枢机（，），圣名保禄·若瑟（）...", "范廷颂是什么时候被任为主教的？", ["1963年"], ["30"], "TRAIN_186_QUERY_0"
        "范廷颂", "范廷颂枢机（，），圣名保禄·若瑟（）...", "1990年，范廷颂担任什么职务？", ["1990年被擢升为天..."], ["41"],"TRAIN_186_QUERY_1"
        "...", "...", "...","...", ".", "..."
 
-    其中title是文本的标题，多条记录可能是相同的title；id是该问题的id，具备唯一性
+    其中 ``title`` 是文本的标题，多条记录可能是相同的 ``title`` ；``id`` 是该问题的 id，具备唯一性。
 
-    验证集DataSet将具备以下的内容，每个问题的答案可能有三个(有时候只是3个重复的答案)
+    验证集 :class:`~fastNLP.core.DataSet` 将具备以下的内容，每个问题的答案可能有三个（有时候只是3个重复的答案）：
 
     .. csv-table::
        :header: "title", "context", "question", "answers", "answer_starts", "id"
@@ -35,8 +37,8 @@ class CMRC2018Loader(Loader):
        "战国无双3", "《战国无双3》（）是由光荣和ω-force开发...", "男女主角亦有专属声优这一模式是由谁改编的？", "['村雨城', '村雨城', '任天堂游戏谜之村雨城']", "[226, 226, 219]", "DEV_0_QUERY_1"
        "...", "...", "...","...", ".", "..."
 
-    其中answer_starts是从0开始的index。例如"我来自a复旦大学？"，其中"复"的开始index为4。另外"Russell评价说"中的说的index为9, 因为
-    英文和数字都直接按照character计量的。
+    其中 ``answer_starts`` 是从 0 开始的 index。例如 ``"我来自a复旦大学？"`` ，其中 ``"复"`` 的开始 index 为 **4**。另外 ``"Russell评价说"``
+    中的 ``"说"`` 的 index 为 **9** ， 因为英文和数字都直接按照 character 计量的。
     """
     def __init__(self):
         super().__init__()
@@ -65,9 +67,9 @@ class CMRC2018Loader(Loader):
 
     def download(self) -> str:
         r"""
-        如果您使用了本数据，请引用A Span-Extraction Dataset for Chinese Machine Reading Comprehension. Yiming Cui, Ting Liu, etc.
+        自动下载数据集。
 
-        :return:
+        :return: 数据集目录地址
         """
         output_dir = self._get_dataset_path('cmrc2018')
         return output_dir

fastNLP/io/loader/summarization.py

@@ -0,0 +1,64 @@
+__all__ = [
+    "ExtCNNDMLoader"
+]
+
+import os
+from typing import Union, Dict
+
+from ..data_bundle import DataBundle
+from ..utils import check_loader_paths
+from .json import JsonLoader
+
+
+class ExtCNNDMLoader(JsonLoader):
+    r"""
+    **CNN / Daily Mail** 数据集的 **Loader** ，用于 **extractive summarization task** 任务。
+    如果你使用了这个数据，请引用 https://arxiv.org/pdf/1506.03340.pdf
+    
+    读取的 :class:`~fastNLP.core.DataSet` 将具备以下的数据结构：
+
+    .. csv-table::
+       :header: "text", "summary", "label", "publication"
+
+       "['I got new tires from them and... ','...']", "['The new tires...','...']", "[0, 1]", "cnndm"
+       "['Don't waste your time.  We had two...','...']", "['Time is precious','...']", "[1]", "cnndm"
+       "['...']", "['...']", "[]", "cnndm"
+
+    :param fields:
+    """
+
+    def __init__(self, fields=None):
+        fields = fields or {"text": None, "summary": None, "label": None, "publication": None}
+        super(ExtCNNDMLoader, self).__init__(fields=fields)
+
+    def load(self, paths: Union[str, Dict[str, str]] = None):
+        r"""
+        从指定一个或多个路径中的文件中读取数据，返回 :class:`~fastNLP.io.DataBundle` 。
+
+        读取的 field 根据 :class:`ExtCNNDMLoader` 初始化时传入的 ``fields`` 决定。
+
+        :param paths: 传入一个目录, 将在该目录下寻找 ``train.label.jsonl`` , ``dev.label.jsonl`` , 
+            ``test.label.jsonl`` 三个文件（该目录还应该需要有一个名字为 ``vocab`` 的文件，在 :class:`~fastNLP.io.pipe.ExtCNNDMPipe`
+            当中需要用到）。
+
+        :return: :class:`~fastNLP.io.DataBundle`
+        """
+        if paths is None:
+            paths = self.download()
+        paths = check_loader_paths(paths)
+        if ('train' in paths) and ('test' not in paths):
+            paths['test'] = paths['train']
+            paths.pop('train')
+
+        datasets = {name: self._load(path) for name, path in paths.items()}
+        data_bundle = DataBundle(datasets=datasets)
+        return data_bundle
+
+    def download(self):
+        r"""
+        自动下载数据集。
+
+        :return: 数据集目录地址
+        """
+        output_dir = self._get_dataset_path('ext-cnndm')
+        return output_dir

fastNLP/io/pipe/classification.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "CLSBasePipe",
     "AGsNewsPipe",
@@ -36,8 +34,17 @@ from fastNLP.core.log import logger
 
 
 class CLSBasePipe(Pipe):
+    """
+    处理分类数据集 **Pipe** 的基类。
+
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw', 'cn-char']`` 。``'raw'`` 表示使用空格作为切分， ``'cn-char'`` 表示
+        按字符切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param lang: :mod:`spacy` 使用的语言，当前仅支持 ``'en'`` 。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
     
-    def __init__(self, lower: bool = False, tokenizer: str = 'raw', lang='en', num_proc=0):
+    def __init__(self, lower: bool = False, tokenizer: str = 'raw', lang: str='en', num_proc: int=0):
         super().__init__()
         self.lower = lower
         self.tokenizer = get_tokenizer(tokenizer, lang=lang)
@@ -61,7 +68,7 @@ class CLSBasePipe(Pipe):
 
     def process(self, data_bundle: DataBundle):
         r"""
-        传入的DataSet应该具备如下的结构
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：
 
         .. csv-table::
             :header: "raw_words", "target"
@@ -71,7 +78,7 @@ class CLSBasePipe(Pipe):
             "...", "..."
 
         :param data_bundle:
-        :return:
+        :return: 处理后的 ``data_bundle``
         """
         # 复制一列words
         data_bundle = _add_words_field(data_bundle, lower=self.lower)
@@ -87,46 +94,32 @@ class CLSBasePipe(Pipe):
 
     def process_from_file(self, paths) -> DataBundle:
         r"""
-        传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：:meth:`fastNLP.io.Loader.load()`
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
         :param paths:
-        :return: DataBundle
+        :return:
         """
         raise NotImplementedError
 
 
 class YelpFullPipe(CLSBasePipe):
     r"""
-    处理YelpFull的数据, 处理之后DataSet中的内容如下
+    处理 **Yelp Review Full** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
-    .. csv-table:: 下面是使用YelpFullPipe处理后的DataSet所具备的field
+    .. csv-table:: 下面是使用 YelpFullPipe 处理后的 DataSet 所具备的 field
         :header: "raw_words", "target", "words",  "seq_len"
 
         "I got 'new' tires from them and within...", 0 ,"[7, 110, 22, 107, 22, 499, 59, 140, 3,...]", 160
         " Don't waste your time.  We had two dif... ", 0, "[277, 17, 278, 38, 30, 112, 24, 85, 27...", 40
         "...", ., "[...]", .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param lower: 是否对输入进行小写化。
+    :param granularity: 支持 ``[2, 3, 5]`` 。若为 ``2`` ，则认为是二分类问题，将 **1、2** 归为一类， **4、5** 归为一类，
+        丢掉 3；若为 ``3`` ，则认为是三分类问题，将 **1、2** 归为一类， **3** 归为一类， **4、5** 归为一类；若为 ``5`` ，则认为是五分类问题。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
-
-    def __init__(self, lower: bool = False, granularity=5, tokenizer: str = 'spacy', num_proc=0):
-        r"""
-
-        :param bool lower: 是否对输入进行小写化。
-        :param int granularity: 支持2, 3, 5。若为2, 则认为是2分类问题，将1、2归为1类，4、5归为一类，丢掉2；若为3, 则有3分类问题，将
-            1、2归为1类，3归为1类，4、5归为1类；若为5, 则有5分类问题。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-        """
+    def __init__(self, lower: bool = False, granularity: int=5, tokenizer: str = 'spacy', num_proc: int=0):
         super().__init__(lower=lower, tokenizer=tokenizer, lang='en', num_proc=num_proc)
         assert granularity in (2, 3, 5), "granularity can only be 2,3,5."
         self.granularity = granularity
@@ -140,7 +133,7 @@ class YelpFullPipe(CLSBasePipe):
 
     def process(self, data_bundle):
         r"""
-        传入的DataSet应该具备如下的结构
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：
 
         .. csv-table::
            :header: "raw_words", "target"
@@ -150,7 +143,7 @@ class YelpFullPipe(CLSBasePipe):
            "...", "..."
 
         :param data_bundle:
-        :return:
+        :return: 处理后的 ``data_bundle``
         """
         if self.tag_map is not None:
             data_bundle = _granularize(data_bundle, self.tag_map)
@@ -159,11 +152,12 @@ class YelpFullPipe(CLSBasePipe):
 
         return data_bundle
 
-    def process_from_file(self, paths=None):
+    def process_from_file(self, paths=None) -> DataBundle:
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
         :param paths:
-        :return: DataBundle
+        :return:
         """
         data_bundle = YelpFullLoader().load(paths)
         return self.process(data_bundle=data_bundle)
@@ -171,7 +165,7 @@ class YelpFullPipe(CLSBasePipe):
 
 class YelpPolarityPipe(CLSBasePipe):
     r"""
-    处理YelpPolarity的数据, 处理之后DataSet中的内容如下
+    处理 **Yelp Review Polarity** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table:: 下面是使用YelpFullPipe处理后的DataSet所具备的field
         :header: "raw_words", "target", "words", "seq_len"
@@ -180,32 +174,20 @@ class YelpPolarityPipe(CLSBasePipe):
         " Don't waste your time.  We had two dif... ", 0, "[277, 17, 278, 38, 30, 112, 24, 85, 27...", 40
         "...", ., "[...]", .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
-        r"""
-
-        :param bool lower: 是否对输入进行小写化。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-        """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int=0):
         super().__init__(lower=lower, tokenizer=tokenizer, lang='en', num_proc=num_proc)
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param str paths:
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         data_bundle = YelpPolarityLoader().load(paths)
         return self.process(data_bundle=data_bundle)
@@ -213,7 +195,7 @@ class YelpPolarityPipe(CLSBasePipe):
 
 class AGsNewsPipe(CLSBasePipe):
     r"""
-    处理AG's News的数据, 处理之后DataSet中的内容如下
+    处理 **AG's News** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table:: 下面是使用AGsNewsPipe处理后的DataSet所具备的field
         :header: "raw_words", "target", "words", "seq_len"
@@ -222,31 +204,20 @@ class AGsNewsPipe(CLSBasePipe):
         " Don't waste your time.  We had two dif... ", 0, "[277, 17, 278, 38, 30, 112, 24, 85, 27...", 40
         "...", ., "[...]", .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
     def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
-        r"""
-
-        :param bool lower: 是否对输入进行小写化。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-        """
         super().__init__(lower=lower, tokenizer=tokenizer, lang='en', num_proc=num_proc)
 
     def process_from_file(self, paths=None):
         r"""
-        :param str paths:
-        :return: DataBundle
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
         """
         data_bundle = AGsNewsLoader().load(paths)
         return self.process(data_bundle=data_bundle)
@@ -254,7 +225,7 @@ class AGsNewsPipe(CLSBasePipe):
 
 class DBPediaPipe(CLSBasePipe):
     r"""
-    处理DBPedia的数据, 处理之后DataSet中的内容如下
+    处理 **DBPedia** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table:: 下面是使用DBPediaPipe处理后的DataSet所具备的field
         :header: "raw_words", "target", "words", "seq_len"
@@ -263,31 +234,20 @@ class DBPediaPipe(CLSBasePipe):
         " Don't waste your time.  We had two dif... ", 0, "[277, 17, 278, 38, 30, 112, 24, 85, 27...", 40
         "...", ., "[...]", .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
-        r"""
-
-        :param bool lower: 是否对输入进行小写化。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-        """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int=0):
         super().__init__(lower=lower, tokenizer=tokenizer, lang='en', num_proc=num_proc)
 
     def process_from_file(self, paths=None):
         r"""
-        :param str paths:
-        :return: DataBundle
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
         """
         data_bundle = DBPediaLoader().load(paths)
         return self.process(data_bundle=data_bundle)
@@ -295,7 +255,7 @@ class DBPediaPipe(CLSBasePipe):
 
 class SSTPipe(CLSBasePipe):
     r"""
-    经过该Pipe之后，DataSet中具备的field如下所示
+    处理 **SST** 的数据，处理之后， :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table:: 下面是使用SSTPipe处理后的DataSet所具备的field
         :header: "raw_words", "words", "target", "seq_len"
@@ -304,29 +264,15 @@ class SSTPipe(CLSBasePipe):
         "No one goes unindicted here , which is...", 0, "[191, 126, 192, 193, 194, 4, 195, 17, ...", 13
         "...", ., "[...]", .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param subtree: 是否将训练集、测试集和验证集数据展开为子树，扩充数据量。
+    :param train_subtree: 是否将训练集通过子树扩展数据。
+    :param lower: 是否对输入进行小写化。
+    :param granularity: 支持 ``[2, 3, 5]`` 。若为 ``2`` ，则认为是二分类问题，将 **1、2** 归为一类， **4、5** 归为一类，
+        丢掉 3；若为 ``3`` ，则认为是三分类问题，将 **1、2** 归为一类， **3** 归为一类， **4、5** 归为一类；若为 ``5`` ，则认为是五分类问题。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
-
-    def __init__(self, subtree=False, train_subtree=True, lower=False, granularity=5, tokenizer='spacy', num_proc=0):
-        r"""
-
-        :param bool subtree: 是否将train, test, dev数据展开为子树，扩充数据量。 Default: ``False``
-        :param bool train_subtree: 是否将train集通过子树扩展数据。
-        :param bool lower: 是否对输入进行小写化。
-        :param int granularity: 支持2, 3, 5。若为2, 则认为是2分类问题，将0、1归为1类，3、4归为一类，丢掉2；若为3, 则有3分类问题，将
-            0、1归为1类，2归为1类，3、4归为1类；若为5, 则有5分类问题。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。支持'spacy'和'raw'。raw使用空格作为切分。
-        """
+    def __init__(self, subtree: bool=False, train_subtree: bool=True, lower: bool=False, granularity: int=5, tokenizer: int='spacy', num_proc: int=0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.subtree = subtree
         self.train_tree = train_subtree
@@ -341,19 +287,19 @@ class SSTPipe(CLSBasePipe):
         else:
             self.tag_map = None
 
-    def process(self, data_bundle: DataBundle):
+    def process(self, data_bundle: DataBundle) -> DataBundle:
         r"""
-        对DataBundle中的数据进行预处理。输入的DataSet应该至少拥有raw_words这一列，且内容类似与
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` ` 应该至少拥有 ``raw_words`` 列，内容类似于：
 
-        .. csv-table:: 下面是使用SSTLoader读取的DataSet所具备的field
+        .. csv-table:: 下面是使用 SSTLoader 读取的 DataSet 所具备的 field
             :header: "raw_words"
 
             "(2 (3 (3 Effective) (2 but)) (1 (1 too-tepid)..."
             "(3 (3 (2 If) (3 (2 you) (3 (2 sometimes) ..."
             "..."
 
-        :param ~fastNLP.io.DataBundle data_bundle: 需要处理的DataBundle对象
-        :return:
+        :param data_bundle: 需要处理的 :class:`~fastNLP.io.DataBundle` 对象
+        :return: 处理后的 ``data_bundle``
         """
         #  先取出subtree
         for name in list(data_bundle.datasets.keys()):
@@ -381,13 +327,19 @@ class SSTPipe(CLSBasePipe):
         return data_bundle
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = SSTLoader().load(paths)
         return self.process(data_bundle=data_bundle)
 
 
 class SST2Pipe(CLSBasePipe):
     r"""
-    加载SST2的数据, 处理完成之后DataSet将拥有以下的field
+    处理 **SST-2** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_words", "target", "words", "seq_len"
@@ -396,32 +348,20 @@ class SST2Pipe(CLSBasePipe):
        "unflinchingly bleak and desperate", 0, "[115, 116, 5, 117]", 4
        "...", "...", ., .
 
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
     def __init__(self, lower=False, tokenizer='raw', num_proc=0):
-        r"""
-
-        :param bool lower: 是否对输入进行小写化。
-        :param str tokenizer: 使用哪种tokenize方式将数据切成单词。
-        """
         super().__init__(lower=lower, tokenizer=tokenizer, lang='en', num_proc=num_proc)
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param str paths: 如果为None，则自动下载并缓存到fastNLP的缓存地址。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         data_bundle = SST2Loader().load(paths)
         return self.process(data_bundle)
@@ -429,43 +369,31 @@ class SST2Pipe(CLSBasePipe):
 
 class IMDBPipe(CLSBasePipe):
     r"""
-    经过本Pipe处理后DataSet将如下
+    处理 **IMDb** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
-    .. csv-table:: 输出DataSet的field
+    .. csv-table:: 输出 DataSet 的 field
        :header: "raw_words", "target", "words", "seq_len"
 
        "Bromwell High is a cartoon ... ", 0, "[3, 5, 6, 9, ...]", 20
        "Story of a man who has ...", 1, "[20, 43, 9, 10, ...]", 31
        "...", ., "[...]", .
 
-    其中raw_words为str类型，是原文; words是转换为index的输入; target是转换为index的目标值;
-    words列被设置为input; target列被设置为target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   | False  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
+    其中 ``raw_words`` 为 :class:`str` 类型，是原文； ``words`` 是转换为 index 的输入； ``target`` 是转换为 index 的目标值。
+    ``words`` 列被设置为 input， ``target`` 列被设置为 target。
 
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
     def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
-        r"""
-
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process(self, data_bundle: DataBundle):
         r"""
-        期待的DataBunlde中输入的DataSet应该类似于如下，有两个field，raw_words和target，且均为str类型
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：有两个 field ， ``raw_words`` 和 ``target`` ，
+        且均为 :class:`str` 类型。
 
         .. csv-table:: 输入DataSet的field
            :header: "raw_words", "target"
@@ -476,7 +404,7 @@ class IMDBPipe(CLSBasePipe):
 
         :param DataBunlde data_bundle: 传入的DataBundle中的DataSet必须包含raw_words和target两个field，且raw_words列应该为str,
             target列应该为str。
-        :return: DataBundle
+        :return:  处理后的 ``data_bundle``
         """
 
         # 替换<br />
@@ -493,9 +421,10 @@ class IMDBPipe(CLSBasePipe):
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = IMDBLoader().load(paths)
@@ -506,7 +435,7 @@ class IMDBPipe(CLSBasePipe):
 
 class ChnSentiCorpPipe(Pipe):
     r"""
-    处理之后的DataSet有以下的结构
+    处理 **ChnSentiCorp** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容为：
 
     .. csv-table::
         :header: "raw_chars", "target", "chars", "seq_len"
@@ -515,30 +444,18 @@ class ChnSentiCorpPipe(Pipe):
         "<荐书> 推荐所有喜欢<红楼>...", 1, "[10, 21, ....]", 25
         "..."
 
-    其中chars, seq_len是input，target是target
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
+    其中 ``chars`` , ``seq_len`` 是 input， ``target`` 是 target。
 
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
-    def __init__(self, bigrams=False, trigrams=False, num_proc: int = 0):
-        r"""
-
-        :param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果
-            设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-            data_bundle.get_vocab('bigrams')获取.
-        :param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]
-            。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-            data_bundle.get_vocab('trigrams')获取.
-        """
+    def __init__(self, bigrams: bool=False, trigrams: bool=False, num_proc: int = 0):
         super().__init__()
 
         self.bigrams = bigrams
@@ -557,7 +474,7 @@ class ChnSentiCorpPipe(Pipe):
 
     def process(self, data_bundle: DataBundle):
         r"""
-        可以处理的DataSet应该具备以下的field
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：
 
         .. csv-table::
             :header: "raw_chars", "target"
@@ -567,7 +484,7 @@ class ChnSentiCorpPipe(Pipe):
             "..."
 
         :param data_bundle:
-        :return:
+        :return:  处理后的 ``data_bundle``
         """
         _add_chars_field(data_bundle, lower=False)
 
@@ -601,9 +518,10 @@ class ChnSentiCorpPipe(Pipe):
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = ChnSentiCorpLoader().load(paths)
@@ -614,7 +532,7 @@ class ChnSentiCorpPipe(Pipe):
 
 class THUCNewsPipe(CLSBasePipe):
     r"""
-    处理之后的DataSet有以下的结构
+    处理 **THUCNews** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容为：
 
     .. csv-table::
         :header: "raw_chars", "target", "chars", "seq_len"
@@ -622,27 +540,18 @@ class THUCNewsPipe(CLSBasePipe):
         "马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道...", 0, "[409, 1197, 2146, 213, ...]", 746
         "..."
 
-    其中chars, seq_len是input，target是target
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
-    :param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果
-        设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-        data_bundle.get_vocab('bigrams')获取.
-    :param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]
-        。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-        data_bundle.get_vocab('trigrams')获取.
+    其中 ``chars`` , ``seq_len`` 是 input， ``target`` 是target
+
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
-    def __init__(self, bigrams=False, trigrams=False, num_proc=0):
+    def __init__(self, bigrams: int=False, trigrams: int=False, num_proc: int=0):
         super().__init__(num_proc=num_proc)
 
         self.bigrams = bigrams
@@ -663,7 +572,7 @@ class THUCNewsPipe(CLSBasePipe):
 
     def process(self, data_bundle: DataBundle):
         r"""
-        可处理的DataSet应具备如下的field
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：
 
         .. csv-table::
             :header: "raw_words", "target"
@@ -672,7 +581,7 @@ class THUCNewsPipe(CLSBasePipe):
             "...", "..."
 
         :param data_bundle:
-        :return:
+        :return:  处理后的 ``data_bundle``
         """
         # 根据granularity设置tag
         tag_map = {'体育': 0, '财经': 1, '房产': 2, '家居': 3, '教育': 4, '科技': 5, '时尚': 6, '时政': 7, '游戏': 8, '娱乐': 9}
@@ -713,8 +622,10 @@ class THUCNewsPipe(CLSBasePipe):
 
     def process_from_file(self, paths=None):
         r"""
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
         """
         data_loader = THUCNewsLoader()  # 此处需要实例化一个data_loader，否则传入load()的参数为None
         data_bundle = data_loader.load(paths)
@@ -724,32 +635,23 @@ class THUCNewsPipe(CLSBasePipe):
 
 class WeiboSenti100kPipe(CLSBasePipe):
     r"""
-    处理之后的DataSet有以下的结构
+    处理 **WeiboSenti100k** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容为：
 
     .. csv-table::
         :header: "raw_chars", "target", "chars", "seq_len"
 
-        "六一出生的？好讽刺…… //@祭春姬:他爸爸是外星人吧 //@面孔小高:现在的孩子都怎么了 [怒][怒][怒]", 0, "[0, 690, 18, ...]", 56
+        "马晓旭意外受伤让国奥警惕 无奈大雨格外青睐殷家军记者傅亚雨沈阳报道...", 0, "[409, 1197, 2146, 213, ...]", 746
         "..."
 
-    其中chars, seq_len是input，target是target
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |  False  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
-    :param bool bigrams: 是否增加一列bigrams. bigrams的构成是['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]。如果
-        设置为True，返回的DataSet将有一列名为bigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-        data_bundle.get_vocab('bigrams')获取.
-    :param bool trigrams: 是否增加一列trigrams. trigrams的构成是 ['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]
-        。如果设置为True，返回的DataSet将有一列名为trigrams, 且已经转换为了index并设置为input，对应的vocab可以通过
-        data_bundle.get_vocab('trigrams')获取.
+    其中 ``chars`` , ``seq_len`` 是 input， ``target`` 是target
+
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 `~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
 
     def __init__(self, bigrams=False, trigrams=False, num_proc=0):
@@ -770,7 +672,7 @@ class WeiboSenti100kPipe(CLSBasePipe):
 
     def process(self, data_bundle: DataBundle):
         r"""
-        可处理的DataSet应具备以下的field
+        ``data_bunlde`` 中的 :class:`~fastNLP.core.DataSet` 应该具备如下的结构：
 
         .. csv-table::
             :header: "raw_chars", "target"
@@ -779,7 +681,7 @@ class WeiboSenti100kPipe(CLSBasePipe):
             "...", "..."
 
         :param data_bundle:
-        :return:
+        :return:  处理后的 ``data_bundle``
         """
         # clean,lower
 
@@ -811,8 +713,10 @@ class WeiboSenti100kPipe(CLSBasePipe):
     
     def process_from_file(self, paths=None):
         r"""
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
         """
         data_loader = WeiboSenti100kLoader()  # 此处需要实例化一个data_loader，否则传入load()的参数为None
         data_bundle = data_loader.load(paths)
@@ -820,20 +724,23 @@ class WeiboSenti100kPipe(CLSBasePipe):
         return data_bundle
 
 class MRPipe(CLSBasePipe):
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
-        r"""
+    """
+    加载 **MR** 的数据。
 
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc=0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = MRLoader().load(paths)
@@ -843,20 +750,23 @@ class MRPipe(CLSBasePipe):
 
 
 class R8Pipe(CLSBasePipe):
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc = 0):
-        r"""
+    """
+    加载 **R8** 的数据。
 
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc = 0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = R8Loader().load(paths)
@@ -866,20 +776,23 @@ class R8Pipe(CLSBasePipe):
 
 
 class R52Pipe(CLSBasePipe):
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
-        r"""
+    """
+    加载 **R52** 的数据。
 
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = R52Loader().load(paths)
@@ -889,20 +802,23 @@ class R52Pipe(CLSBasePipe):
 
 
 class OhsumedPipe(CLSBasePipe):
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
-        r"""
+    """
+    加载 **Ohsumed** 的数据。
 
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = OhsumedLoader().load(paths)
@@ -912,20 +828,23 @@ class OhsumedPipe(CLSBasePipe):
 
 
 class NG20Pipe(CLSBasePipe):
-    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
-        r"""
+    """
+    加载 **NG20** 的数据。
 
-        :param bool lower: 是否将words列的数据小写。
-        :param str tokenizer: 使用什么tokenizer来将句子切分为words. 支持spacy, raw两种。raw即使用空格拆分。
-        """
+    :param lower: 是否对输入进行小写化。
+    :param tokenizer: 使用哪种 tokenize 方式将数据切成单词。支持 ``['spacy', 'raw']`` 。``'raw'`` 表示使用空格作为切分，``'spacy'`` 则使用 :mod:`spacy` 库进行分词。
+    :param num_proc: 处理数据时使用的进程数目。
+    """
+    def __init__(self, lower: bool = False, tokenizer: str = 'spacy', num_proc: int = 0):
         super().__init__(tokenizer=tokenizer, lang='en', num_proc=num_proc)
         self.lower = lower
 
     def process_from_file(self, paths=None):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.Loader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = NG20Loader().load(paths)

fastNLP/io/pipe/conll.py

@@ -1,5 +1,3 @@
-r"""undocumented"""
-
 __all__ = [
     "Conll2003NERPipe",
     "Conll2003Pipe",
@@ -60,7 +58,7 @@ class _NERPipe(Pipe):
            "[...]", "[...]"
 
         :param ~fastNLP.DataBundle data_bundle: 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]在传入DataBundle基础上原位修改。
-        :return DataBundle:
+        :return: 处理后的 ``data_bundle``
         """
         # 转换tag
         for name, dataset in data_bundle.iter_datasets():
@@ -79,10 +77,14 @@ class _NERPipe(Pipe):
 
 class Conll2003NERPipe(_NERPipe):
     r"""
-    Conll2003的NER任务的处理Pipe, 该Pipe会（1）复制raw_words列，并命名为words; (2）在words, target列建立词表
-    (创建 :class:`fastNLP.Vocabulary` 对象，所以在返回的DataBundle中将有两个Vocabulary); (3）将words，target列根据相应的
-    Vocabulary转换为index。
-    经过该Pipe过后，DataSet中的内容如下所示
+    **Conll2003** 的 **NER** 任务的处理 **Pipe** ， 该Pipe会：
+    
+        1. 复制 ``raw_words`` 列，并命名为 ``words`` ；
+        2. 在 ``words`` , ``target`` 列建立词表，即创建 :class:`~fastNLP.core.Vocabulary` 对象，所以在返回的
+          :class:`~fastNLP.io.DataBundle` 中将有两个 ``Vocabulary`` ；
+        3. 将 ``words`` , ``target`` 列根据相应的词表转换为 index。
+    
+    处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table:: Following is a demo layout of DataSet returned by Conll2003Loader
        :header: "raw_words", "target", "words", "seq_len"
@@ -91,27 +93,21 @@ class Conll2003NERPipe(_NERPipe):
        "[AL-AIN, United, Arab, ...]", "[3, 4,...]", "[4, 5, 6,...]", 6
        "[...]", "[...]", "[...]", .
 
-    raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的
-    target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |   True  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
+    ``raw_words`` 列为 :class:`List` [ :class:`str` ], 是未转换的原始数据； ``words`` 列为 :class:`List` [ :class:`int` ]，
+    是转换为 index 的输入数据； ``target`` 列是 :class:`List` [ :class:`int` ] ，是转换为 index 的 target。返回的 :class:`~fastNLP.core.DataSet` 
+    中被设置为 input 有 ``words`` , ``target``, ``seq_len``；target 有 ``target`` 。
 
+    :param encoding_type: ``target`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param lower: 是否将 ``words`` 小写化后再建立词表，绝大多数情况都不需要设置为 ``True`` 。
+    :param num_proc: 处理数据时使用的进程数目。
     """
     
     def process_from_file(self, paths) -> DataBundle:
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param paths: 支持路径类型参见 :class:`fastNLP.io.loader.ConllLoader` 的load函数。
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         # 读取数据
         data_bundle = Conll2003NERLoader().load(paths)
@@ -122,7 +118,7 @@ class Conll2003NERPipe(_NERPipe):
 
 class Conll2003Pipe(Pipe):
     r"""
-    经过该Pipe后，DataSet中的内容如下
+    处理 **Conll2003** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_words" , "pos", "chunk", "ner", "words", "seq_len"
@@ -131,27 +127,14 @@ class Conll2003Pipe(Pipe):
        "[AL-AIN, United, Arab, ...]", "[1, 2...]", "[3, 4...]", "[3, 4...]", "[4, 5, 6,...]", 6
        "[...]", "[...]", "[...]", "[...]", "[...]", .
 
-    其中words, seq_len是input; pos, chunk, ner, seq_len是target
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+-------+-------+-------+-------+---------+
-        | field_names | raw_words |  pos  | chunk |  ner  | words | seq_len |
-        +-------------+-----------+-------+-------+-------+-------+---------+
-        |   is_input  |   False   | False | False | False |  True |   True  |
-        |  is_target  |   False   |  True |  True |  True | False |   True  |
-        | ignore_type |           | False | False | False | False |  False  |
-        |  pad_value  |           |   0   |   0   |   0   |   0   |    0    |
-        +-------------+-----------+-------+-------+-------+-------+---------+
-
+    其中``words``, ``seq_len`` 是 input; ``pos``, ``chunk``, ``ner``, ``seq_len`` 是 target
 
+    :param chunk_encoding_type: ``chunk`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param ner_encoding_type: ``ner`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param lower: 是否将 ``words`` 小写化后再建立词表，绝大多数情况都不需要设置为 ``True`` 。
+    :param num_proc: 处理数据时使用的进程数目。
     """
-    def __init__(self, chunk_encoding_type='bioes', ner_encoding_type='bioes', lower: bool = False, num_proc: int = 0):
-        r"""
-
-        :param str chunk_encoding_type: 支持bioes, bio。
-        :param str ner_encoding_type: 支持bioes, bio。
-        :param bool lower: 是否将words列小写化后再建立词表
-        """
+    def __init__(self, chunk_encoding_type: str='bioes', ner_encoding_type: str='bioes', lower: bool = False, num_proc: int = 0):
         if chunk_encoding_type == 'bio':
             self.chunk_convert_tag = iob2
         elif chunk_encoding_type == 'bioes':
@@ -175,7 +158,7 @@ class Conll2003Pipe(Pipe):
     
     def process(self, data_bundle) -> DataBundle:
         r"""
-        输入的DataSet应该类似于如下的形式
+        输入的 `~fastNLP.core.DataSet` 应该类似于如下的形式：
 
         .. csv-table::
            :header: "raw_words", "pos", "chunk", "ner"
@@ -185,7 +168,7 @@ class Conll2003Pipe(Pipe):
            "[...]", "[...]", "[...]", "[...]", .
 
         :param data_bundle:
-        :return: 传入的DataBundle
+        :return: 处理后的 ``data_bundle``
         """
         # 转换tag
         for name, dataset in data_bundle.datasets.items():
@@ -210,6 +193,7 @@ class Conll2003Pipe(Pipe):
     
     def process_from_file(self, paths):
         r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
         :param paths:
         :return:
@@ -220,7 +204,7 @@ class Conll2003Pipe(Pipe):
 
 class OntoNotesNERPipe(_NERPipe):
     r"""
-    处理OntoNotes的NER数据，处理之后DataSet中的field情况为
+    处理 **OntoNotes** 的 **NER** 数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_words", "target", "words", "seq_len"
@@ -229,23 +213,19 @@ class OntoNotesNERPipe(_NERPipe):
        "[AL-AIN, United, Arab, ...]", "[3, 4]", "[4, 5, 6,...]", 6
        "[...]", "[...]", "[...]", .
 
-    raw_words列为List[str], 是未转换的原始数据; words列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的
-    target。返回的DataSet中被设置为input有words, target, seq_len; 设置为target有target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_words | target | words | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |   True  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
+    ``raw_words`` 列为 :class:`List` [ :class:`str` ], 是未转换的原始数据； ``words`` 列为 :class:`List` [ :class:`int` ]，
+    是转换为 index 的输入数据； ``target`` 列是 :class:`List` [ :class:`int` ] ，是转换为 index 的 target。返回的 :class:`~fastNLP.core.DataSet` 
+    中被设置为 input 有 ``words`` , ``target``, ``seq_len``；target 有 ``target`` 。
 
     """
     
     def process_from_file(self, paths):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = OntoNotesNERLoader().load(paths)
         return self.process(data_bundle)
 
@@ -301,7 +281,7 @@ class _CNNERPipe(Pipe):
         是转换为index的target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
 
         :param ~fastNLP.DataBundle data_bundle: 传入的DataBundle中的DataSet必须包含raw_words和ner两个field，且两个field的内容均为List[str]。在传入DataBundle基础上原位修改。
-        :return: DataBundle
+        :return: 处理后的 ``data_bundle``
         """
         # 转换tag
         for name, dataset in data_bundle.datasets.items():
@@ -338,7 +318,7 @@ class _CNNERPipe(Pipe):
 
 class MsraNERPipe(_CNNERPipe):
     r"""
-    处理MSRA-NER的数据，处理之后的DataSet的field情况为
+    处理 **MSRA-NER** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_chars", "target", "chars", "seq_len"
@@ -347,30 +327,34 @@ class MsraNERPipe(_CNNERPipe):
        "[青, 岛, 海, 牛, 队, 和, ...]", "[1, 2, 3, ...]", "[10, 21, ....]", 21
        "[...]", "[...]", "[...]", .
 
-    raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的
-    target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |   True  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    ``raw_chars`` 列为 :class:`List` [ :class:`str` ], 是未转换的原始数据； ``chars`` 列为 :class:`List` [ :class:`int` ]，
+    是转换为 index 的输入数据； ``target`` 列是 :class:`List` [ :class:`int` ] ，是转换为 index 的 target。返回的 :class:`~fastNLP.core.DataSet` 
+    中被设置为 input 有 ``chars`` , ``target``, ``seq_len``；target 有 ``target`` 。
+
+    :param encoding_type: ``target`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
     
     def process_from_file(self, paths=None) -> DataBundle:
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = MsraNERLoader().load(paths)
         return self.process(data_bundle)
 
 
 class PeopleDailyPipe(_CNNERPipe):
     r"""
-    处理people daily的ner的数据，处理之后的DataSet的field情况为
+    处理 **People's Daily NER** 的 **ner** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_chars", "target", "chars", "seq_len"
@@ -379,30 +363,34 @@ class PeopleDailyPipe(_CNNERPipe):
        "[青, 岛, 海, 牛, 队, 和, ...]", "[1, 2, 3, ...]", "[10, 21, ....]", 21
        "[...]", "[...]", "[...]", .
 
-    raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的
-    target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |   True  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    ``raw_chars`` 列为 :class:`List` [ :class:`str` ], 是未转换的原始数据； ``chars`` 列为 :class:`List` [ :class:`int` ]，
+    是转换为 index 的输入数据； ``target`` 列是 :class:`List` [ :class:`int` ] ，是转换为 index 的 target。返回的 :class:`~fastNLP.core.DataSet` 
+    中被设置为 input 有 ``chars`` , ``target``, ``seq_len``；target 有 ``target`` 。
+
+    :param encoding_type: ``target`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
     
     def process_from_file(self, paths=None) -> DataBundle:
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = PeopleDailyNERLoader().load(paths)
         return self.process(data_bundle)
 
 
 class WeiboNERPipe(_CNNERPipe):
     r"""
-    处理weibo的ner的数据，处理之后的DataSet的field情况为
+    处理 **Weibo** 的 **BER** 的数据，处理之后 :class:`~fastNLP.core.DataSet` 中的内容如下：
 
     .. csv-table::
        :header: "raw_chars", "chars", "target", "seq_len"
@@ -411,22 +399,26 @@ class WeiboNERPipe(_CNNERPipe):
        "['心']", "[0]", "[41]", 1
        "[...]", "[...]", "[...]", .
 
-    raw_chars列为List[str], 是未转换的原始数据; chars列为List[int]，是转换为index的输入数据; target列是List[int]，是转换为index的
-    target。返回的DataSet中被设置为input有chars, target, seq_len; 设置为target有target。
-
-    dataset的print_field_meta()函数输出的各个field的被设置成input和target的情况为::
-
-        +-------------+-----------+--------+-------+---------+
-        | field_names | raw_chars | target | chars | seq_len |
-        +-------------+-----------+--------+-------+---------+
-        |   is_input  |   False   |  True  |  True |   True  |
-        |  is_target  |   False   |  True  | False |   True  |
-        | ignore_type |           | False  | False |  False  |
-        |  pad_value  |           |   0    |   0   |    0    |
-        +-------------+-----------+--------+-------+---------+
-
+    ``raw_chars`` 列为 :class:`List` [ :class:`str` ], 是未转换的原始数据； ``chars`` 列为 :class:`List` [ :class:`int` ]，
+    是转换为 index 的输入数据； ``target`` 列是 :class:`List` [ :class:`int` ] ，是转换为 index 的 target。返回的 :class:`~fastNLP.core.DataSet` 
+    中被设置为 input 有 ``chars`` , ``target``, ``seq_len``；target 有 ``target`` 。
+
+    :param encoding_type: ``target`` 列使用什么类型的 encoding 方式，支持 ``['bioes', 'bio']`` 两种。
+    :param bigrams: 是否增加一列 ``bigrams`` 。 ``bigrams`` 会对原文进行如下转化： ``['复', '旦', '大', '学', ...]->["复旦", "旦大", ...]`` 。如果
+        设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``bigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('bigrams')`` 获取。
+    :param trigrams: 是否增加一列 ``trigrams`` 。 ``trigrams`` 会对原文进行如下转化 ``['复', '旦', '大', '学', ...]->["复旦大", "旦大学", ...]`` 。
+        如果设置为 ``True`` ，返回的 :class:`~fastNLP.core.DataSet` 将有一列名为 ``trigrams`` ，且已经转换为了 index 并设置为 input，对应的词表可以通过
+        ``data_bundle.get_vocab('trigrams')`` 获取。
+    :param num_proc: 处理数据时使用的进程数目。
     """
     
     def process_from_file(self, paths=None) -> DataBundle:
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = WeiboNERLoader().load(paths)
         return self.process(data_bundle)

fastNLP/io/pipe/construct_graph.py

@@ -173,14 +173,20 @@ class GraphBuilderBase:
 
 
 class MRPmiGraphPipe(GraphBuilderBase):
+    """
+    构建 **MR** 数据集的 **Graph** 。
 
+    :param graph_type: 
+    :param widow_size:
+    :param threshold:
+    """
     def __init__(self, graph_type='pmi', widow_size=10, threshold=0.):
         super().__init__(graph_type=graph_type, widow_size=widow_size, threshold=threshold)
 
     def build_graph(self, data_bundle: DataBundle):
         r"""
-            params: ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象.
-            return 返回csr类型的稀疏矩阵图;训练集，验证集，测试集，在图中的index.
+        :param data_bundle: 需要处理的 :class:`fastNLP.io.DataBundle` 对象。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         self._get_doc_edge(data_bundle)
         self._get_word_edge()
@@ -190,19 +196,31 @@ class MRPmiGraphPipe(GraphBuilderBase):
                self.tr_doc_index, self.dev_doc_index, self.te_doc_index)
 
     def build_graph_from_file(self, path: str):
+        r"""
+        传入文件路径，生成处理好的 ``scipy_sparse_matrix`` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load`
+    
+        :param path: 数据集的路径。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
+        """
         data_bundle = MRLoader().load(path)
         return self.build_graph(data_bundle)
 
 
 class R8PmiGraphPipe(GraphBuilderBase):
+    """
+    构建 **R8** 数据集的 **Graph** 。
 
+    :param graph_type: 
+    :param widow_size:
+    :param threshold:
+    """
     def __init__(self, graph_type='pmi', widow_size=10, threshold=0.):
         super().__init__(graph_type=graph_type, widow_size=widow_size, threshold=threshold)
 
     def build_graph(self, data_bundle: DataBundle):
         r"""
-            params: ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象.
-            return 返回csr类型的稀疏矩阵图;训练集，验证集，测试集，在图中的index.
+        :param data_bundle: 需要处理的 :class:`fastNLP.io.DataBundle` 对象。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         self._get_doc_edge(data_bundle)
         self._get_word_edge()
@@ -212,19 +230,31 @@ class R8PmiGraphPipe(GraphBuilderBase):
                self.tr_doc_index, self.dev_doc_index, self.te_doc_index)
 
     def build_graph_from_file(self, path: str):
+        r"""
+        传入文件路径，生成处理好的 ``scipy_sparse_matrix`` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load`
+
+        :param path: 数据集的路径。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
+        """
         data_bundle = R8Loader().load(path)
         return self.build_graph(data_bundle)
 
 
 class R52PmiGraphPipe(GraphBuilderBase):
+    """
+    构建 **R52** 数据集的 **Graph** 。
 
+    :param graph_type: 
+    :param widow_size:
+    :param threshold:
+    """
     def __init__(self, graph_type='pmi', widow_size=10, threshold=0.):
         super().__init__(graph_type=graph_type, widow_size=widow_size, threshold=threshold)
 
     def build_graph(self, data_bundle: DataBundle):
         r"""
-            params: ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象.
-            return 返回csr类型的稀疏矩阵;训练集，验证集，测试集，在图中的index.
+        :param data_bundle: 需要处理的 :class:`fastNLP.io.DataBundle` 对象。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         self._get_doc_edge(data_bundle)
         self._get_word_edge()
@@ -234,19 +264,31 @@ class R52PmiGraphPipe(GraphBuilderBase):
                self.tr_doc_index, self.dev_doc_index, self.te_doc_index)
 
     def build_graph_from_file(self, path: str):
+        r"""
+        传入文件路径，生成处理好的 ``scipy_sparse_matrix`` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load`
+
+        :param path: 数据集的路径。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
+        """
         data_bundle = R52Loader().load(path)
         return self.build_graph(data_bundle)
 
 
 class OhsumedPmiGraphPipe(GraphBuilderBase):
+    """
+    构建 **Ohsuned** 数据集的 **Graph** 。
 
+    :param graph_type: 
+    :param widow_size:
+    :param threshold:
+    """
     def __init__(self, graph_type='pmi', widow_size=10, threshold=0.):
         super().__init__(graph_type=graph_type, widow_size=widow_size, threshold=threshold)
 
     def build_graph(self, data_bundle: DataBundle):
         r"""
-            params: ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象.
-            return 返回csr类型的稀疏矩阵图;训练集，验证集，测试集，在图中的index.
+        :param data_bundle: 需要处理的 :class:`fastNLP.io.DataBundle` 对象。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         self._get_doc_edge(data_bundle)
         self._get_word_edge()
@@ -256,19 +298,31 @@ class OhsumedPmiGraphPipe(GraphBuilderBase):
                self.tr_doc_index, self.dev_doc_index, self.te_doc_index)
 
     def build_graph_from_file(self, path: str):
+        r"""
+        传入文件路径，生成处理好的 ``scipy_sparse_matrix`` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load`
+        
+        :param path: 数据集的路径。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
+        """
         data_bundle = OhsumedLoader().load(path)
         return self.build_graph(data_bundle)
 
 
 class NG20PmiGraphPipe(GraphBuilderBase):
+    """
+    构建 **NG20** 数据集的 **Graph** 。
 
+    :param graph_type: 
+    :param widow_size:
+    :param threshold:
+    """
     def __init__(self, graph_type='pmi', widow_size=10, threshold=0.):
         super().__init__(graph_type=graph_type, widow_size=widow_size, threshold=threshold)
 
     def build_graph(self, data_bundle: DataBundle):
         r"""
-            params: ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象.
-            return 返回csr类型的稀疏矩阵图;训练集，验证集，测试集，在图中的index.
+        :param data_bundle: 需要处理的 :class:`fastNLP.io.DataBundle` 对象。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         self._get_doc_edge(data_bundle)
         self._get_word_edge()
@@ -279,8 +333,10 @@ class NG20PmiGraphPipe(GraphBuilderBase):
 
     def build_graph_from_file(self, path: str):
         r"""
-            param: path->数据集的路径.
-            return: 返回csr类型的稀疏矩阵图;训练集，验证集，测试集，在图中的index.
+        传入文件路径，生成处理好的 ``scipy_sparse_matrix`` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load`
+
+        :param path: 数据集的路径。
+        :return: 返回 ``csr`` 类型的稀疏矩阵图；包含训练集，验证集，测试集，在图中的 index 。
         """
         data_bundle = NG20Loader().load(path)
         return self.build_graph(data_bundle)

fastNLP/io/pipe/cws.py

@@ -230,7 +230,7 @@ class CWSPipe(Pipe):
            "..."
 
         :param data_bundle:
-        :return:
+        :return: 处理后的 ``data_bundle``
         """
         data_bundle.copy_field('raw_words', 'chars')
         
@@ -276,8 +276,9 @@ class CWSPipe(Pipe):
     
     def process_from_file(self, paths=None) -> DataBundle:
         r"""
-        
-        :param str paths:
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
         :return:
         """
         if self.dataset_name is None and paths is None:

fastNLP/io/pipe/matching.py

@@ -165,30 +165,60 @@ class MatchingBertPipe(Pipe):
 
 class RTEBertPipe(MatchingBertPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = RTELoader().load(paths)
         return self.process(data_bundle)
 
 
 class SNLIBertPipe(MatchingBertPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = SNLILoader().load(paths)
         return self.process(data_bundle)
 
 
 class QuoraBertPipe(MatchingBertPipe):
     def process_from_file(self, paths):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = QuoraLoader().load(paths)
         return self.process(data_bundle)
 
 
 class QNLIBertPipe(MatchingBertPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = QNLILoader().load(paths)
         return self.process(data_bundle)
 
 
 class MNLIBertPipe(MatchingBertPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = MNLILoader().load(paths)
         return self.process(data_bundle)
 
@@ -308,30 +338,60 @@ class MatchingPipe(Pipe):
 
 class RTEPipe(MatchingPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = RTELoader().load(paths)
         return self.process(data_bundle)
 
 
 class SNLIPipe(MatchingPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = SNLILoader().load(paths)
         return self.process(data_bundle)
 
 
 class QuoraPipe(MatchingPipe):
     def process_from_file(self, paths):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = QuoraLoader().load(paths)
         return self.process(data_bundle)
 
 
 class QNLIPipe(MatchingPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = QNLILoader().load(paths)
         return self.process(data_bundle)
 
 
 class MNLIPipe(MatchingPipe):
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = MNLILoader().load(paths)
         return self.process(data_bundle)
 
@@ -341,6 +401,12 @@ class LCQMCPipe(MatchingPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = LCQMCLoader().load(paths)
         data_bundle = RenamePipe().process(data_bundle)
         data_bundle = self.process(data_bundle)
@@ -353,6 +419,12 @@ class CNXNLIPipe(MatchingPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = CNXNLILoader().load(paths)
         data_bundle = GranularizePipe(task='XNLI').process(data_bundle)
         data_bundle = RenamePipe().process(data_bundle)  # 使中文数据的field
@@ -366,6 +438,12 @@ class BQCorpusPipe(MatchingPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = BQCorpusLoader().load(paths)
         data_bundle = RenamePipe().process(data_bundle)
         data_bundle = self.process(data_bundle)
@@ -380,6 +458,10 @@ class RenamePipe(Pipe):
         self.num_proc = num_proc
     
     def process(self, data_bundle: DataBundle):  # rename field name for Chinese Matching dataset
+        """
+
+        :return: 处理后的 ``data_bundle``
+        """
         if (self.task == 'cn-nli'):
             for name, dataset in data_bundle.datasets.items():
                 if (dataset.has_field('raw_chars1')):
@@ -437,6 +519,10 @@ class GranularizePipe(Pipe):
         return data_bundle
     
     def process(self, data_bundle: DataBundle):
+        """
+
+        :return: 处理后的 ``data_bundle``
+        """
         task_tag_dict = {
             'XNLI': {'neutral': 0, 'entailment': 1, 'contradictory': 2, 'contradiction': 2}
         }
@@ -452,6 +538,10 @@ class MachingTruncatePipe(Pipe):  # truncate sentence for bert, modify seq_len
         super().__init__()
     
     def process(self, data_bundle: DataBundle):
+        """
+
+        :return: None
+        """
         for name, dataset in data_bundle.datasets.items():
             pass
         return None
@@ -462,6 +552,12 @@ class LCQMCBertPipe(MatchingBertPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = LCQMCLoader().load(paths)
         data_bundle = RenamePipe(task='cn-nli-bert').process(data_bundle)
         data_bundle = self.process(data_bundle)
@@ -475,6 +571,12 @@ class BQCorpusBertPipe(MatchingBertPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = BQCorpusLoader().load(paths)
         data_bundle = RenamePipe(task='cn-nli-bert').process(data_bundle)
         data_bundle = self.process(data_bundle)
@@ -488,6 +590,12 @@ class CNXNLIBertPipe(MatchingBertPipe):
         super().__init__(tokenizer=tokenizer, num_proc=num_proc)
 
     def process_from_file(self, paths=None):
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = CNXNLILoader().load(paths)
         data_bundle = GranularizePipe(task='XNLI').process(data_bundle)
         data_bundle = RenamePipe(task='cn-nli-bert').process(data_bundle)
@@ -522,6 +630,10 @@ class TruncateBertPipe(Pipe):
         return words_before_sep + words_after_sep
 
     def process(self, data_bundle: DataBundle) -> DataBundle:
+        """
+
+        :return: 处理后的 ``data_bundle``
+        """
         for name in data_bundle.datasets.keys():
             dataset = data_bundle.get_dataset(name)
             sep_index_vocab = data_bundle.get_vocab('words').to_index('[SEP]')

fastNLP/io/pipe/pipe.py

@@ -27,15 +27,15 @@ class Pipe:
         对输入的DataBundle进行处理，然后返回该DataBundle。
 
         :param ~fastNLP.DataBundle data_bundle: 需要处理的DataBundle对象
-        :return: DataBundle
+        :return: 处理后的 ``data_bundle``
         """
         raise NotImplementedError
 
     def process_from_file(self, paths: str) -> DataBundle:
         r"""
-        传入文件路径，生成处理好的DataBundle对象。paths支持的路径形式可以参考 ：:meth:`fastNLP.io.Loader.load()`
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
 
-        :param str paths:
-        :return: DataBundle
+        :param paths:
+        :return:
         """
         raise NotImplementedError

fastNLP/io/pipe/qa.py

@@ -122,7 +122,7 @@ class CMRC2018BertPipe(Pipe):
            "...", "...", "...","...", ".", "..."
 
         :param data_bundle:
-        :return:
+        :return: 处理后的 ``data_bundle``
         """
         data_bundle = _concat_clip(data_bundle, max_len=self.max_len, concat_field_name='raw_chars')
 
@@ -138,5 +138,11 @@ class CMRC2018BertPipe(Pipe):
         return data_bundle
 
     def process_from_file(self, paths=None) -> DataBundle:
+        r"""
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
+        """
         data_bundle = CMRC2018Loader().load(paths)
         return self.process(data_bundle)

fastNLP/io/pipe/summarization.py

@@ -54,7 +54,7 @@ class ExtCNNDMPipe(Pipe):
            ["..."], ["..."], [], "cnndm"
 
         :param data_bundle:
-        :return: 处理得到的数据包括
+        :return: 处理后的 ``data_bundle``
         .. csv-table::
            :header: "text_wd", "words", "seq_len", "target"
 
@@ -117,8 +117,10 @@ class ExtCNNDMPipe(Pipe):
 
     def process_from_file(self, paths=None):
         r"""
-        :param paths: dict or string
-        :return: DataBundle
+        传入文件路径，生成处理好的 :class:`~fastNLP.io.DataBundle` 对象。``paths`` 支持的路径形式可以参考 :meth:`fastNLP.io.Loader.load()`
+
+        :param paths:
+        :return:
         """
         loader = ExtCNNDMLoader()
         if self.vocab_path is None:

fastNLP/io/pipe/utils.py

@@ -82,7 +82,7 @@ def get_tokenizer(tokenize_method: str, lang='en'):
         import spacy
         spacy.prefer_gpu()
         if lang != 'en':
-            raise RuntimeError("Spacy only supports en right right.")
+            raise RuntimeError("Spacy only supports en right now.")
         if parse_version(spacy.__version__) >= parse_version('3.0'):
             en = spacy.load('en_core_web_sm')
         else:

fastNLP/io/utils.py

@@ -1,8 +1,3 @@
-r"""
-.. todo::
-    doc
-"""
-
 __all__ = [
     "check_loader_paths"
 ]
@@ -16,7 +11,7 @@ from typing import Union, Dict
 
 def check_loader_paths(paths: Union[str, Dict[str, str]]) -> Dict[str, str]:
     r"""
-    检查传入dataloader的文件的合法性。如果为合法路径，将返回至少包含'train'这个key的dict。类似于下面的结果::
+    检查传入 ``dataloader`` 的文件的合法性。如果为合法路径，将返回至少包含 ``'train'`` 这个 key 的字典。类似于下面的结果::
 
         {
             'train': '/some/path/to/', # 一定包含，建词表应该在这上面建立，剩下的其它文件应该只需要处理并index。
@@ -24,10 +19,13 @@ def check_loader_paths(paths: Union[str, Dict[str, str]]) -> Dict[str, str]:
             ...
         }
 
-    如果paths为不合法的，将直接进行raise相应的错误. 如果paths内不包含train也会报错。
+    如果 ``paths`` 为不合法的，将直接进行 raise 相应的错误。如果 ``paths`` 内不包含 ``'train'`` 也会报错。
 
-    :param str paths: 路径. 可以为一个文件路径(则认为该文件就是train的文件); 可以为一个文件目录，将在该目录下寻找包含train(文件名
-        中包含train这个字段), test, dev这三个字段的文件或文件夹; 可以为一个dict, 则key是用户自定义的某个文件的名称，value是这个文件的路径。
+    :param str paths: 路径。可以为：
+    
+            - 一个文件路径，此时认为该文件就是 train 的文件；
+            - 一个文件目录，将在该目录下寻找包含 ``train`` （文件名中包含 train 这个字段）， ``test`` ，``dev`` 这三个字段的文件或文件夹；
+            - 一个 dict, 则 key 是用户自定义的某个文件的名称，value 是这个文件的路径。
     :return:
     """
     if isinstance(paths, (str, Path)):

fastNLP/transformers/__init__.py

@@ -1 +1,4 @@
-"""基于 transformers-4.11.3 版本迁移"""
+"""
+:mod:`transformers` 模块，包含了常用的预训练模型。
+"""
+import sphinx-multiversion

fastNLP/transformers/torch/__init__.py

@@ -1,9 +1,15 @@
 """
-为了防止因 https://github.com/huggingface/transformers 版本变化导致代码不兼容，当前 folder 以及子 folder 
-都复制自 https://github.com/huggingface/transformers 的4.11.3版本。
-In order to avoid the code change of https://github.com/huggingface/transformers to cause version
-mismatch, we copy code from https://github.com/huggingface/transformers(version:4.11.3) in this
+为了防止因 `transformers <https://github.com/huggingface/transformers>`_ 版本变化导致代码不兼容，当前文件夹以及子文件夹
+都复制自 `transformers <https://github.com/huggingface/transformers>`_  的 4.11.3 版本。
+
+In order to avoid the code change of `transformers <https://github.com/huggingface/transformers>`_ to cause version
+mismatch, we copy code from `transformers <https://github.com/huggingface/transformers>`_ (version:4.11.3) in this
 folder and its subfolder.
+
+您可以如下面代码所示使用 transformers::
+
+    from fastNLP.transformers.torch import BertModel
+    ...
 """
 __version__ = "4.11.3"
 from .models import *