modify index and error format.

docs/api/api_python/dataset/mindspore.dataset.BuiltinSampler.rst

@@ -4,7 +4,7 @@
     
     **参数：**
 
-    **sampler** (Sampler)：用于从数据集中选择样本的对象。仅支持内置采样器（DistributedSampler、PKSampler、RandomSampler、SequentialSampler、SubsetRandomSampler、WeightedRandomSampler）。
+    - **sampler** (Sampler) - 用于从数据集中选择样本的对象。仅支持内置采样器（DistributedSampler、PKSampler、RandomSampler、SequentialSampler、SubsetRandomSampler、WeightedRandomSampler）。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.CLUEDataset.rst

@@ -39,26 +39,26 @@ mindspore.dataset.CLUEDataset
 
     **参数：**
 
-    - **dataset_files** (Union[str, list[str]])：数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
-    - **task** (str, 可选)：任务类型，可取值为 `AFQMC` 、`Tnews`、`IFLYTEK`、`CMNLI`、`WSC` 或 `CSL` （默认为： `AFQMC` ）。
-    - **usage** (str, 可选)：指定数据集的子集，可取值为 `train`、`test` 或 `eval` （默认为： `train` ）。
-    - **num_samples** (int, 可选)：指定从数据集中读取的样本数（默认为None，即读取所有图像样本）。
-    - **num_parallel_workers** (int, 可选)：指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (Union[bool, Shuffle level], 可选)：每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
-        
+    - **dataset_files** (Union[str, list[str]]) - 数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
+    - **task** (str, 可选) - 任务类型，可取值为 `AFQMC` 、`Tnews`、`IFLYTEK`、`CMNLI`、`WSC` 或 `CSL` （默认为： `AFQMC` ）。
+    - **usage** (str, 可选) - 指定数据集的子集，可取值为 `train`、`test` 或 `eval` （默认为： `train` ）。
+    - **num_samples** (int, 可选) - 指定从数据集中读取的样本数（默认为None，即读取所有图像样本）。
+    - **num_parallel_workers** (int, 可选) - 指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (Union[bool, Shuffle level], 可选) - 每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
+
       - **Shuffle.GLOBAL**：混洗文件和样本。
       - **Shuffle.FILES**：仅混洗文件。
 
-    - **num_shards** (int, 可选)：指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
-    - **shard_id** (int, 可选)：指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
+    - **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：`dataset_files` 所指的文件无效或不存在。
-    - **RuntimeError**：`num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**：指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**：指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **RuntimeError** - `dataset_files` 所指的文件无效或不存在。
+    - **RuntimeError** - `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.CSVDataset.rst

@@ -7,27 +7,27 @@
 
     **参数：**
 
-    - **dataset_files** (Union[str, list[str]])：数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
-    - **field_delim** (str，可选)：指定用于分隔字段的分隔符（默认为','）。
-    - **column_defaults** (list，可选)：以列表形式指定每个CSV字段的数据类型（默认为None），有效的类型包括float、int或string。如果未指定该列表，则所有列的数据类型将被视为string。
-    - **column_names** (list[str]，可选)：指定数据集生成的列名（默认值为None）。如果未指定该列表，则将CSV文件第一行的字段作为列名生成。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认为None，即读取所有样本）。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (Union[bool, Shuffle level], 可选)：每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
-        
+    - **dataset_files** (Union[str, list[str]]) - 数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
+    - **field_delim** (str，可选) - 指定用于分隔字段的分隔符（默认为','）。
+    - **column_defaults** (list，可选) - 以列表形式指定每个CSV字段的数据类型（默认为None），有效的类型包括float、int或string。如果未指定该列表，则所有列的数据类型将被视为string。
+    - **column_names** (list[str]，可选) - 指定数据集生成的列名（默认值为None）。如果未指定该列表，则将CSV文件第一行的字段作为列名生成。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认为None，即读取所有样本）。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (Union[bool, Shuffle level], 可选) - 每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
+
       - Shuffle.GLOBAL：混洗文件和样本。
       - Shuffle.FILES：仅混洗文件。
 
-    - **num_shards** (int, 可选)：指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
-    - **shard_id** (int, 可选)：指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
+    - **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：参数 `dataset_files` 所指的文件无效或不存在。
-    - **RuntimeError**：参数 `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**：指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**：指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **RuntimeError** - 参数 `dataset_files` 所指的文件无效或不存在。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.CelebADataset.rst

@@ -9,27 +9,27 @@ mindspore.dataset.CelebADataset
 
     **参数：**
 
-    - **dataset_dir** (str)：包含数据集文件的根目录路径。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (bool，可选)：是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
-    - **usage** (str，可选)：指定数据集的子集，可取值为'train'，'valid'，'test'或'all'。（默认值为'all'，即全部样本图片）。
-    - **sampler** (Sampler，可选)：指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
-    - **decode** (bool，可选)：是否对读取的图像进行解码操作（默认为False）。
-    - **extensions** (list[str]，可选)：指定文件扩展后缀，仅读取这些后缀的文件到数据集中（默认为None）。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（可以小于数据集总数，默认值为None，即全部样本图片)。
-    - **num_shards** (int, 可选)：指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
-    - **shard_id** (int, 可选)：指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **dataset_dir** (str) - 包含数据集文件的根目录路径。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (bool，可选) - 是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
+    - **usage** (str，可选) - 指定数据集的子集，可取值为'train'，'valid'，'test'或'all'。（默认值为'all'，即全部样本图片）。
+    - **sampler** (Sampler，可选) - 指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
+    - **decode** (bool，可选) - 是否对读取的图像进行解码操作（默认为False）。
+    - **extensions** (list[str]，可选) - 指定文件扩展后缀，仅读取这些后缀的文件到数据集中（默认为None）。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（可以小于数据集总数，默认值为None，即全部样本图片)。
+    - **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
+    - **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：参数 `dataset_dir` 不包含任何数据文件。
-    - **RuntimeError**：参数 `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `shuffle` 。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `num_shards` 。
-    - **RuntimeError**: 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**: 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
-    - **ValueError**: `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
+    - **RuntimeError** - 参数 `dataset_dir` 不包含任何数据文件。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **ValueError** - `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
 
     .. note:: 此数据集可以指定 `sampler` 参数，但 `sampler` 和 `shuffle` 是互斥的。下表展示了几种合法的输入参数及预期的行为。
 
@@ -71,11 +71,11 @@ mindspore.dataset.CelebADataset
     **关于CelebA数据集：**
 
     CelebFaces Attributes Dataset（CelebA）数据集是一个大规模的人脸属性数据集，拥有超过20万名人图像，每个图像都有40个属性标注。此数据集包含了大量不同姿态、各种背景的人脸图像，种类丰富、数量庞大、标注充分。数据集总体包含：
-    
+
     - 10177个不同的身份
     - 202599张人脸图像
     - 每张图像拥有5个五官位置标注，40个属性标签。
-    
+
     此数据集可用于各种计算机视觉任务的训练和测试，包括人脸识别、人脸检测、五官定位、人脸编辑和合成等。
 
     原始CelebA数据集结构：

docs/api/api_python/dataset/mindspore.dataset.cifar100dataset.rst → docs/api/api_python/dataset/mindspore.dataset.Cifar100Dataset.rst

@@ -1,7 +1,7 @@
 mindspore.dataset.Cifar100Dataset
 =================================
 
-.. py:class:: Cifar100Dataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
+.. py:class:: mindspore.dataset.Cifar100Dataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
 
     用于读取和解析CIFAR-100数据集的源数据文件。
 
@@ -72,12 +72,12 @@ mindspore.dataset.Cifar100Dataset
     **关于CIFAR-100数据集:**
 
     CIFAR-100数据集和CIFAR-10数据集非常相似，CIFAR-100有100个类别，每类包含600张图片，其中500张训练图片和100张测试图片。这100个类别又被分成20个超类。每个图片都有一个"fine"标签（所属子类）和一个"coarse"标签(所属超类)。
-    
+
     以下为原始CIFAR-100数据集结构。您可以将数据集解压成如下的文件结构，并通过MindSpore的API进行读取。
 
     .. code-block::
 
-        . 
+        .
         └── cifar-100-binary
             ├── train.bin
             ├── test.bin

docs/api/api_python/dataset/mindspore.dataset.cifar10dataset.rst → docs/api/api_python/dataset/mindspore.dataset.Cifar10Dataset.rst

@@ -1,7 +1,7 @@
 mindspore.dataset.Cifar10Dataset
 ================================
 
-.. py:class:: Cifar10Dataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
+.. py:class:: mindspore.dataset.Cifar10Dataset(dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None, sampler=None, num_shards=None, shard_id=None, cache=None)
 
     用于读取和解析CIFAR-10数据集的源数据集文件。该API目前仅支持解析二进制版本的CIFAR-10文件（CIFAR-10 binary version）。
 
@@ -10,7 +10,7 @@ mindspore.dataset.Cifar10Dataset
     **参数：**
 
     - **dataset_dir** (str): 包含数据集文件的根目录路径。
-    - **usage** (str, 可选): 指定数据集的子集，可取值为 `train`，`test 或`all`。使用 `train` 参数将会读取50,000个训练样本，`test` 将会读取10,000个测试样本， `all` 将会读取全部60,000个样本（默认值为None，即全部样本图片）。
+    - **usage** (str, 可选): 指定数据集的子集，可取值为 `train` ， `test` 或 `all` 。使用 `train` 参数将会读取50,000个训练样本，`test` 将会读取10,000个测试样本， `all` 将会读取全部60,000个样本（默认值为None，即全部样本图片）。
     - **num_samples** (int, 可选): 指定从数据集中读取的样本数（可以小于数据集总数，默认值为None，即全部样本图片)。
     - **num_parallel_workers** (int, 可选): 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
     - **shuffle** (bool, 可选): 是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。

docs/api/api_python/dataset/mindspore.dataset.CocoDataset.rst

@@ -6,6 +6,7 @@
     用于读取和解析COCO数据集的源数据文件。该API支持解析COCO2017数据集，支持四种类型的机器学习任务，分别是目标检测、关键点检测、物体分割和全景分割。
 
     根据不同 `task` 参数设置，生成数据集具有不同的输出列：
+
     - `task` = `Detection`, 输出列: `[image, dtype=uint8]`, `[bbox, dtype=float32]`, `[category_id, dtype=uint32]`, `[iscrowd, dtype=uint32]`。
     - `task` = `Stuff`, 输出列: `[image, dtype=uint8]`, `[segmentation,dtype=float32]`, `[iscrowd,dtype=uint32]`。
     - `task` = `Keypoint`, 输出列: `[image, dtype=uint8]`, `[keypoints, dtype=float32]`, `[num_keypoints, dtype=uint32]`。
@@ -13,36 +14,36 @@
 
     **参数：**
 
-    - **dataset_dir** (str)：包含数据集文件的根目录路径。
-    - **annotation_file** (str)：数据集标注JSON文件的路径。
-    - **task** (str，可选)：指定COCO数据的任务类型。支持的任务类型包括：`Detection` 、 `Stuff` 、 `Panoptic` 和 `Keypoint` （默认为 `Detection` ）。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（可以小于数据集总数，默认值为None，即全部样本图片)。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (bool，可选)：是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
-    - **decode** (bool，可选)：是否对读取的图像进行解码操作（默认为False）。
-    - **sampler** (Sampler，可选)：指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
-    - **num_shards** (int, 可选)：指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
-    - **shard_id** (int, 可选)：指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
-    - **extra_metadata** (bool，可选)：用于指定是否额外输出一列数据用于表示图像元信息。如果为True，则将额外输出一列数据，名为 `[_meta-filename, dtype=string]` （默认值为False）。
+    - **dataset_dir** (str) - 包含数据集文件的根目录路径。
+    - **annotation_file** (str) - 数据集标注JSON文件的路径。
+    - **task** (str，可选) - 指定COCO数据的任务类型。支持的任务类型包括：`Detection` 、 `Stuff` 、 `Panoptic` 和 `Keypoint` （默认为 `Detection` ）。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（可以小于数据集总数，默认值为None，即全部样本图片)。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (bool，可选) - 是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
+    - **decode** (bool，可选) - 是否对读取的图像进行解码操作（默认为False）。
+    - **sampler** (Sampler，可选) - 指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
+    - **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
+    - **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **extra_metadata** (bool，可选) - 用于指定是否额外输出一列数据用于表示图像元信息。如果为True，则将额外输出一列数据，名为 `[_meta-filename, dtype=string]` （默认值为False）。
 
     **异常：**
 
-    - **RuntimeError**: 参数 `dataset_dir` 不包含任何数据文件。
-    - **RuntimeError**: 参数 `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `shuffle` 。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `num_shards` 。
-    - **RuntimeError**: 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**: 指定了 `shard_id` 参数，但是未指定 num_shards` 参数。
-    - **RuntimeError**: 解析JSON文件失败。
-    - **ValueError**： 指定的任务不为 `Detection` ， `Stuff` ， `Panoptic` 或 `Keypoint`。
-    - **ValueError**： 参数 `annotation_file` 对应的文件不存在。
-    - **ValueError**： 参数 `dataset_dir` 路径不存在。
-    - **ValueError**: 参数 `shard_id` 错误（小于0或者大于等于 `num_shards` ）。
-
-    .. note:: 
+    - **RuntimeError** - 参数 `dataset_dir` 不包含任何数据文件。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **RuntimeError** - 解析JSON文件失败。
+    - **ValueError** - 指定的任务不为 `Detection` ， `Stuff` ， `Panoptic` 或 `Keypoint`。
+    - **ValueError** - 参数 `annotation_file` 对应的文件不存在。
+    - **ValueError** - 参数 `dataset_dir` 路径不存在。
+    - **ValueError** - 参数 `shard_id` 错误（小于0或者大于等于 `num_shards` ）。
+
+    .. note::
         - 当指定 `extra_metadata` 为True时，除非显式使用 `rename` 算子以删除元信息列明的前缀('_meta-')，否则迭代的数据行中不会出现'[_meta-filename, dtype=string]'列。
-        - CocoDataset的 `sampler` 参数不支持指定PKSampler。  
+        - CocoDataset的 `sampler` 参数不支持指定PKSampler。
         - 此数据集可以指定 `sampler` 参数，但 `sampler` 和 `shuffle` 是互斥的。下表展示了几种合法的输入参数及预期的行为。
 
     .. list-table:: 配置 `sampler` 和 `shuffle` 的不同组合得到的预期排序结果
@@ -63,7 +64,7 @@
          - 顺序排列
        * - 参数 `sampler`
          - No ne
-         - 由`sampler`行为定义的顺序
+         - 由 `sampler` 行为定义的顺序
        * - 参数 `sampler`
          - True
          - 不允许
@@ -76,22 +77,22 @@
     >>> coco_dataset_dir = "/path/to/coco_dataset_directory/images"
     >>> coco_annotation_file = "/path/to/coco_dataset_directory/annotation_file"
     >>>
-    >>> # 1）读取COCO数据集中`Detection`任务中的数据。
+    >>> # 1）读取COCO数据集中 `Detection` 任务中的数据。
     >>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
     ...                          annotation_file=coco_annotation_file,
     ...                          task='Detection')
     >>>
-    >>> # 2）读取COCO数据集中`Stuff`任务中的数据。
+    >>> # 2）读取COCO数据集中 `Stuff` 任务中的数据。
     >>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
     ...                          annotation_file=coco_annotation_file,
     ...                          task='Stuff')
     >>>
-    >>> # 3）读取COCO数据集中`Panoptic`任务中的数据。
+    >>> # 3）读取COCO数据集中 `Panoptic` 任务中的数据。
     >>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
     ...                          annotation_file=coco_annotation_file,
     ...                          task='Panoptic')
     >>>
-    >>> # 4）读取COCO数据集中`Keypoint`任务中的数据。
+    >>> # 4）读取COCO数据集中 `Keypoint` 任务中的数据。
     >>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
     ...                          annotation_file=coco_annotation_file,
     ...                          task='Keypoint')

docs/api/api_python/dataset/mindspore.dataset.DSCallback.rst

@@ -7,7 +7,7 @@ mindspore.dataset.DSCallback
 
     **参数：**
 
-    **step_size** (int, optional)：调用 `ds_step_begin` 和 `ds_step_end` 之间间隔的step数（默认为1）。
+    - **step_size** (int, optional) - 调用 `ds_step_begin` 和 `ds_step_end` 之间间隔的step数（默认为1）。
 
     **样例：**
 
@@ -27,7 +27,7 @@ mindspore.dataset.DSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_epoch_begin(ds_run_context)
 
@@ -35,7 +35,7 @@ mindspore.dataset.DSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_epoch_end(ds_run_context)
 
@@ -43,7 +43,7 @@ mindspore.dataset.DSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_step_begin(ds_run_context)
 
@@ -51,7 +51,7 @@ mindspore.dataset.DSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_step_end(ds_run_context)
 
@@ -59,4 +59,4 @@ mindspore.dataset.DSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。

docs/api/api_python/dataset/mindspore.dataset.Dataset.add_sampler.rst

@@ -1,13 +1,14 @@
     .. py:method:: add_sampler(new_sampler)
 
-       为当前数据集添加采样器。
+        为当前数据集添加采样器。
 
-       **参数：**
+        **参数：**
 
-       **new_sampler** (Sampler) ：作用于当前数据集的采样器。
+        - **new_sampler** (Sampler) ：作用于当前数据集的采样器。
 
-       样例：
-            >>> # dataset为任意数据集实例
-            >>> # 对该数据集应用DistributedSampler
-            >>> new_sampler = ds.DistributedSampler(10, 2)
-            >>> dataset.add_sampler(new_sampler)
+        **样例：**
+
+        >>> # dataset为任意数据集实例
+        >>> # 对该数据集应用DistributedSampler
+        >>> new_sampler = ds.DistributedSampler(10, 2)
+        >>> dataset.add_sampler(new_sampler)

docs/api/api_python/dataset/mindspore.dataset.Dataset.rst

@@ -38,14 +38,14 @@
 
         **参数：**
 
-        - **batch_size** (int or function)：每个批处理数据包含的条数。参数需要是int或可调用对象，该对象接收1个参数，即BatchInfo。
-        - **drop_remainder** (bool, optional)：是否删除最后一个数据条数小于批处理大小的batch（默认值为False）。如果为True，并且最后一个批次中数据行数少于 `batch_size`，则这些数据将被丢弃，不会传递给后续的操作。
-        - **num_parallel_workers** (int, optional)：用于进行batch操作的的线程数（threads），默认值为None。
-        - **per_batch_map** (callable, optional)：是一个以(list[Tensor], list[Tensor], ..., BatchInfo)作为输入参数的可调用对象。每个list[Tensor]代表给定列上的一批Tensor。入参中list[Tensor]的个数应与 `input_columns` 中传入列名的数量相匹配。该可调用对象的最后一个参数始终是BatchInfo对象。`per_batch_map`应返回(list[Tensor], list[Tensor], ...)。其出中list[Tensor]的个数应与输入相同。如果输出列数与输入列数不一致，则需要指定 `output_columns`。        - **input_columns** (Union[str, list[str]], optional)：由输入列名组成的列表。如果 `per_batch_map` 不为None，列表中列名的个数应与 `per_batch_map` 中包含的列数匹配（默认为None）。
-        - **output_columns** (Union[str, list[str]], optional)：当前操作所有输出列的列名列表。如果len(input_columns) != len(output_columns)，则此参数必须指定。此列表中列名的数量必须与给定操作的输出列数相匹配（默认为None，输出列将与输入列具有相同的名称）。
-        - **column_order** (Union[str, list[str]], optional)：指定整个数据集对象中包含的所有列名的顺序。如果len(input_column) != len(output_column)，则此参数必须指定。 注意：这里的列名不仅仅是在 `input_columns` 和 `output_columns` 中指定的列。
-        - **pad_info** (dict, optional)：用于对给定列进行填充。例如 `pad_info={"col1":([224,224],0)}` ，则将列名为"col1"的列填充到大小为[224,224]的张量，并用0填充缺失的值（默认为None)。
-        - **python_multiprocessing** (bool, optional)：针对 `per_batch_map` 函数，使用Python多进执行的方式进行调用。如果函数计算量大，开启这个选项可能会很有帮助（默认值为False）。
+        - **batch_size** (int or function) - 每个批处理数据包含的条数。参数需要是int或可调用对象，该对象接收1个参数，即BatchInfo。
+        - **drop_remainder** (bool, optional) - 是否删除最后一个数据条数小于批处理大小的batch（默认值为False）。如果为True，并且最后一个批次中数据行数少于 `batch_size`，则这些数据将被丢弃，不会传递给后续的操作。
+        - **num_parallel_workers** (int, optional) - 用于进行batch操作的的线程数（threads），默认值为None。
+        - **per_batch_map** (callable, optional) - 是一个以(list[Tensor], list[Tensor], ..., BatchInfo)作为输入参数的可调用对象。每个list[Tensor]代表给定列上的一批Tensor。入参中list[Tensor]的个数应与 `input_columns` 中传入列名的数量相匹配。该可调用对象的最后一个参数始终是BatchInfo对象。`per_batch_map` 应返回(list[Tensor], list[Tensor], ...)。其出中list[Tensor]的个数应与输入相同。如果输出列数与输入列数不一致，则需要指定 `output_columns`。        - **input_columns** (Union[str, list[str]], optional)：由输入列名组成的列表。如果 `per_batch_map` 不为None，列表中列名的个数应与 `per_batch_map` 中包含的列数匹配（默认为None）。
+        - **output_columns** (Union[str, list[str]], optional) - 当前操作所有输出列的列名列表。如果len(input_columns) != len(output_columns)，则此参数必须指定。此列表中列名的数量必须与给定操作的输出列数相匹配（默认为None，输出列将与输入列具有相同的名称）。
+        - **column_order** (Union[str, list[str]], optional) - 指定整个数据集对象中包含的所有列名的顺序。如果len(input_column) != len(output_column)，则此参数必须指定。 注意：这里的列名不仅仅是在 `input_columns` 和 `output_columns` 中指定的列。
+        - **pad_info** (dict, optional) - 用于对给定列进行填充。例如 `pad_info={"col1":([224,224],0)}` ，则将列名为"col1"的列填充到大小为[224,224]的张量，并用0填充缺失的值（默认为None)。
+        - **python_multiprocessing** (bool, optional) - 针对 `per_batch_map` 函数，使用Python多进执行的方式进行调用。如果函数计算量大，开启这个选项可能会很有帮助（默认值为False）。
 
         **返回：**
 
@@ -68,7 +68,7 @@
         ...         index += 1
         ...     return (output,)
         >>> dataset = dataset.batch(batch_size=8, input_columns=["image"], per_batch_map=np_resize)
-    
+
     .. py:method:: bucket_batch_by_length(column_names, bucket_boundaries, bucket_batch_sizes, element_length_function=None, pad_info=None, pad_to_bucket_boundary=False, drop_remainder=False)
 
         依据数据中元素长度进行分桶。每个桶将在满了的时候进行元素填充和批处理操作。
@@ -77,20 +77,20 @@
 
         **参数：**
 
-        - **column_names** (list[str])：传递给长度计算函数的所有列名。
-        - **bucket_boundaries** (list[int])：由各个桶的上边界值组成的列表，必须严格递增。如果有n个边界，则创建n+1个桶，分配后桶的边界如下：[0, bucket_boundaries[0])，[bucket_boundaries[i], bucket_boundaries[i+1])（其中，0<i<n-1），[bucket_boundaries[n-1], inf)。
-        - **bucket_batch_sizes** (list[int])：由每个桶的批次大小组成的列表，必须包含 `len(bucket_boundaries)+1` 个元素。
-        - **element_length_function** (Callable, optional)：输入包含M个参数的函数，其中M等于 `len(column_names)` ，并返回一个整数。如果未指定该参数，则 `len(column_names)` 必须为1，并且该列数据第一维的shape值将用作长度（默认为None）。
-        - **pad_info** (dict, optional)：有关如何对指定列进行填充的字典对象。字典中键对应要填充的列名，值必须是包含2个元素的元组。元组中第一个元素对应要填充成的shape，第二个元素对应要填充的值。如果某一列未指定将要填充后的shape和填充值，则当前批次中该列上的每条数据都将填充至该批次中最长数据的长度，填充值为0。除非 `pad_to_bucket_boundary` 为True，否则 `pad_info` 中任何填充shape为None的列，其每条数据长度都将被填充为当前批处理中最数据的长度。如果不需要填充，请将 `pad_info` 设置为None（默认为None）。
-        - **pad_to_bucket_boundary** (bool, optional)：如果为True，则 `pad_info` 中填充shape为None的列，其长度都会被填充至 `bucket_boundary-1` 长度。如果有任何元素落入最后一个桶中，则将报错（默认为False）。
-        - **drop_remainder** (bool, optional)：如果为True，则丢弃每个桶中最后不足一个批次数据（默认为False）。
+        - **column_names** (list[str]) - 传递给长度计算函数的所有列名。
+        - **bucket_boundaries** (list[int]) - 由各个桶的上边界值组成的列表，必须严格递增。如果有n个边界，则创建n+1个桶，分配后桶的边界如下：[0, bucket_boundaries[0])，[bucket_boundaries[i], bucket_boundaries[i+1])（其中，0<i<n-1），[bucket_boundaries[n-1], inf)。
+        - **bucket_batch_sizes** (list[int]) - 由每个桶的批次大小组成的列表，必须包含 `len(bucket_boundaries)+1` 个元素。
+        - **element_length_function** (Callable, optional) - 输入包含M个参数的函数，其中M等于 `len(column_names)` ，并返回一个整数。如果未指定该参数，则 `len(column_names)` 必须为1，并且该列数据第一维的shape值将用作长度（默认为None）。
+        - **pad_info** (dict, optional) - 有关如何对指定列进行填充的字典对象。字典中键对应要填充的列名，值必须是包含2个元素的元组。元组中第一个元素对应要填充成的shape，第二个元素对应要填充的值。如果某一列未指定将要填充后的shape和填充值，则当前批次中该列上的每条数据都将填充至该批次中最长数据的长度，填充值为0。除非 `pad_to_bucket_boundary` 为True，否则 `pad_info` 中任何填充shape为None的列，其每条数据长度都将被填充为当前批处理中最数据的长度。如果不需要填充，请将 `pad_info` 设置为None（默认为None）。
+        - **pad_to_bucket_boundary** (bool, optional) - 如果为True，则 `pad_info` 中填充shape为None的列，其长度都会被填充至 `bucket_boundary-1` 长度。如果有任何元素落入最后一个桶中，则将报错（默认为False）。
+        - **drop_remainder** (bool, optional) - 如果为True，则丢弃每个桶中最后不足一个批次数据（默认为False）。
 
         **返回：**
 
         BucketBatchByLengthDataset，按长度进行分桶和批处理操作后的数据集对象。
 
         **样例：**
-        
+
         >>> # 创建一个数据集对象，其中给定条数的数据会被组成一个批次数据
         >>> # 如果最后一个批次数据小于给定的批次大小（batch_size)，则丢弃这个批次
         >>> import numpy as np
@@ -117,11 +117,11 @@
 
         **参数：**
 
-        - **columns** (list[str])：指定从哪一列中获取单词。
-        - **vocab_size** (int)：词汇表大小。
-        - **character_coverage** (int)：模型涵盖的字符百分比，必须介于0.98和1.0之间。默认值如0.9995，适用于具有丰富字符集的语言，如日语或中文字符集；1.0适用于其他字符集较小的语言，比如英语或拉丁文。
-        - **model_type** (SentencePieceModel)：模型类型，枚举值包括unigram（默认值）、bpe、char及word。当类型为word时，输入句子必须预先标记。
-        - **params** (dict)：依据原始数据内容构建祠表的附加参数，无附加参数时取值可以是空字典。
+        - **columns** (list[str]) - 指定从哪一列中获取单词。
+        - **vocab_size** (int) - 词汇表大小。
+        - **character_coverage** (int) - 模型涵盖的字符百分比，必须介于0.98和1.0之间。默认值如0.9995，适用于具有丰富字符集的语言，如日语或中文字符集；1.0适用于其他字符集较小的语言，比如英语或拉丁文。
+        - **model_type** (SentencePieceModel) - 模型类型，枚举值包括unigram（默认值）、bpe、char及word。当类型为word时，输入句子必须预先标记。
+        - **params** (dict) - 依据原始数据内容构建祠表的附加参数，无附加参数时取值可以是空字典。
 
         **返回：**
 
@@ -146,29 +146,30 @@
 
         **参数：**
 
-        **columns** (Union[str, list[str]]) ：指定从数据集对象中哪一列中获取单词。
-        **freq_range** (tuple[int])：由(min_frequency, max_frequency)组成的整数元组，在这个频率范围的词汇会被保存下来。
-        取值范围需满足：0 <= min_frequency <= max_frequency <= total_words，其中min_frequency、max_frequency的默认值分别设置为0、total_words。
-        **top_k** (int)：词汇表中包含的单词数，取`top_k`个最常见的单词。`top_k`优先级低于`freq_range`。如果`top_k`的值大于单词总数，则取所有单词。
-        **special_tokens** (list[str])：字符串列表，每个字符串都是一个特殊的标记。
-        **special_first** (bool)：是否将 `special_tokens` 添加到词汇表首尾。如果指定了 `special_tokens` 且
-        `special_first` 设置为默认值，则将`special_tokens`添加到词汇表最前面。
+        - **columns** (Union[str, list[str]]) ：指定从数据集对象中哪一列中获取单词。
+        - **freq_range** (tuple[int]) - 由(min_frequency, max_frequency)组成的整数元组，在这个频率范围的词汇会被保存下来。
+          取值范围需满足：0 <= min_frequency <= max_frequency <= total_words，其中min_frequency、max_frequency的默认值分别设置为0、total_words。
+        - **top_k** (int) - 词汇表中包含的单词数，取 `top_k` 个最常见的单词。`top_k` 优先级低于 `freq_range`。如果 `top_k` 的值大于单词总数，则取所有单词。
+        - **special_tokens** (list[str]) - 字符串列表，每个字符串都是一个特殊的标记。
+        - **special_first** (bool) - 是否将 `special_tokens` 添加到词汇表首尾。如果指定了 `special_tokens` 且
+          `special_first` 设置为默认值，则将 `special_tokens` 添加到词汇表最前面。
 
         **返回：**
             从数据集对象中构建出的词汇表对象。
 
         **样例：**
-            >>> def gen_corpus():
-            ...     # 键：单词，值：出现次数，键的取值采用字母表示有利于排序和显示。
-            ...     corpus = {"Z": 4, "Y": 4, "X": 4, "W": 3, "U": 3, "V": 2, "T": 1}
-            ...     for k, v in corpus.items():
-            ...         yield (np.array([k] * v, dtype='S'),)
-            >>> column_names = ["column1", "column2", "column3"]
-            >>> dataset = ds.GeneratorDataset(gen_corpus, column_names)
-            >>> dataset = dataset.build_vocab(columns=["column3", "column1", "column2"],
-            ...                               freq_range=(1, 10), top_k=5,
-            ...                               special_tokens=["<pad>", "<unk>"],
-            ...                               special_first=True,vocab='vocab')
+
+        >>> def gen_corpus():
+        ...     # 键：单词，值：出现次数，键的取值采用字母表示有利于排序和显示。
+        ...     corpus = {"Z": 4, "Y": 4, "X": 4, "W": 3, "U": 3, "V": 2, "T": 1}
+        ...     for k, v in corpus.items():
+        ...         yield (np.array([k] * v, dtype='S'),)
+        >>> column_names = ["column1", "column2", "column3"]
+        >>> dataset = ds.GeneratorDataset(gen_corpus, column_names)
+        >>> dataset = dataset.build_vocab(columns=["column3", "column1", "column2"],
+        ...                               freq_range=(1, 10), top_k=5,
+        ...                               special_tokens=["<pad>", "<unk>"],
+        ...                               special_first=True,vocab='vocab')
 
     .. py:method:: close_pool()
 
@@ -182,7 +183,7 @@
 
         **参数：**
 
-        **datasets** (Union[list, class Dataset])：与当前数据集对象拼接的数据集对象列表或单个数据集对象。
+        - **datasets** (Union[list, class Dataset]) - 与当前数据集对象拼接的数据集对象列表或单个数据集对象。
 
 
         **返回：**
@@ -204,8 +205,8 @@
 
         **参数：**
 
-        - **num_epochs** (int, optional)：迭代器可以迭代的最多轮次数（默认为-1，迭代器可以迭代无限次）。
-        -  **output_numpy** (bool, optional)：是否输出NumPy数据类型，如果 `output_numpy` 为False，迭代器输出的每列数据类型为MindSpore.Tensor（默认为False）。
+        - **num_epochs** (int, optional) - 迭代器可以迭代的最多轮次数（默认为-1，迭代器可以迭代无限次）。
+        - **output_numpy** (bool, optional) - 是否输出NumPy数据类型，如果 `output_numpy` 为False，迭代器输出的每列数据类型为MindSpore.Tensor（默认为False）。
 
         **返回：**
 
@@ -229,10 +230,10 @@
 
         **参数：**
 
-        - **columns** (list[str], optional)：用于指定列顺序的列名列表（默认为None，表示所有列）。
-        - **num_epochs** (int, optional)：迭代器可以迭代的最多轮次数（默认为-1，迭代器可以迭代无限次）。
-        - **output_numpy** (bool, optional)：是否输出NumPy数据类型，如果output_numpy为False，迭代器输出的每列数据类型为MindSpore.Tensor（默认为False）。
-        - **do_copy** (bool, optional)：当输出数据类型为mindspore.Tensor时，通过此参数指定转换方法，采用False主要考虑以获得更好的性能（默认为True）。
+        - **columns** (list[str], optional) - 用于指定列顺序的列名列表（默认为None，表示所有列）。
+        - **num_epochs** (int, optional) - 迭代器可以迭代的最多轮次数（默认为-1，迭代器可以迭代无限次）。
+        - **output_numpy** (bool, optional) - 是否输出NumPy数据类型，如果output_numpy为False，迭代器输出的每列数据类型为MindSpore.Tensor（默认为False）。
+        - **do_copy** (bool, optional) - 当输出数据类型为mindspore.Tensor时，通过此参数指定转换方法，采用False主要考虑以获得更好的性能（默认为True）。
 
         **返回：**
 
@@ -254,8 +255,8 @@
 
         **参数：**
 
-         **send_epoch_end** (bool, optional)：数据发送完成后是否发送结束标识到设备上（默认值为True）。
-         **create_data_info_queue** (bool, optional)：是否创建一个队列，用于存储每条数据的type和shape（默认值为False）。
+        - **send_epoch_end** (bool, optional) - 数据发送完成后是否发送结束标识到设备上（默认值为True）。
+        - **create_data_info_queue** (bool, optional) - 是否创建一个队列，用于存储每条数据的type和shape（默认值为False）。
 
 
         .. note::
@@ -263,7 +264,8 @@
 
 
         **返回：**
-            TransferDataset，用于帮助发送数据到设备上的数据集对象。
+
+        TransferDataset，用于帮助发送数据到设备上的数据集对象。
 
 
     .. py:method:: dynamic_min_max_shapes()
@@ -271,18 +273,20 @@
         获取数据集对象中单条数据的最小和最大shape，用于图编译过程。
 
         **返回：**
-            列表，原始数据集对象中单条数据的最小和最大shape分别以list形式返回。
+
+        列表，原始数据集对象中单条数据的最小和最大shape分别以list形式返回。
 
         **样例：**
-            >>> import numpy as np
-            >>>
-            >>> def generator1():
-            >>>     for i in range(1, 100):
-            >>>         yield np.ones((16, i, 83)), np.array(i)
-            >>>
-            >>> dataset = ds.GeneratorDataset(generator1, ["data1", "data2"])
-            >>> dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": []})
-            >>> min_shapes, max_shapes = dataset.dynamic_min_max_shapes()
+
+        >>> import numpy as np
+        >>>
+        >>> def generator1():
+        >>>     for i in range(1, 100):
+        >>>         yield np.ones((16, i, 83)), np.array(i)
+        >>>
+        >>> dataset = ds.GeneratorDataset(generator1, ["data1", "data2"])
+        >>> dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": []})
+        >>> min_shapes, max_shapes = dataset.dynamic_min_max_shapes()
 
 
     .. py:method:: filter(predicate, input_columns=None, num_parallel_workers=None)
@@ -290,76 +294,83 @@
         通过判断条件对数据集对象中的数据进行过滤。
 
         .. note::
-             如果`input_columns`未指定或为空，则将使用所有列。
+             如果 `input_columns` 未指定或为空，则将使用所有列。
 
         **参数：**
 
-        **predicate** (callable)：Python可调用对象，返回值为Bool类型。如果为False，则过滤掉该条数据。
-        **input_columns** (Union[str, list[str]], optional)：输入列名组成的列表，当取默认值None时，`predicate` 将应用于数据集中的所有列。
-        **num_parallel_workers** (int, optional)：用于并行处理数据集的线程数（默认为None，将使用配置文件中的值）。
+        - **predicate** (callable) - Python可调用对象，返回值为Bool类型。如果为False，则过滤掉该条数据。
+        - **input_columns** (Union[str, list[str]], optional) - 输入列名组成的列表，当取默认值None时，`predicate` 将应用于数据集中的所有列。
+        - **num_parallel_workers** (int, optional) - 用于并行处理数据集的线程数（默认为None，将使用配置文件中的值）。
 
         **返回：**
-            FilterDataset，执行给定筛选过滤操作的数据集对象。
+
+        FilterDataset，执行给定筛选过滤操作的数据集对象。
 
         **样例：**
-            >>> # 生成一个list，其取值范围为（0，63）
-            >>> # 过滤掉数值大于或等于11的数据
-            >>> dataset = dataset.filter(predicate=lambda data: data < 11, input_columns = ["data"])
+
+        >>> # 生成一个list，其取值范围为（0，63）
+        >>> # 过滤掉数值大于或等于11的数据
+        >>> dataset = dataset.filter(predicate=lambda data: data < 11, input_columns = ["data"])
 
 
     .. py:method:: flat_map(func)
 
-        对数据集对象中每一条数据执行给定的`func`操作，并将结果展平。
+        对数据集对象中每一条数据执行给定的 `func` 操作，并将结果展平。
 
-        指定的`func`是一个函数，输入必须为一个'ndarray'，返回值是一个'Dataset'对象。
+        指定的 `func` 是一个函数，输入必须为一个'ndarray'，返回值是一个'Dataset'对象。
 
         **参数：**
 
-        **func** (function)：输入'ndarray'并返回一个'Dataset'对象的函数。
+        - **func** (function) - 输入'ndarray'并返回一个'Dataset'对象的函数。
 
         **返回：**
             执行给定操作的数据集对象。
 
         **样例：**
-            >>> # 以NumpySlicesDataset为例
-            >>> dataset = ds.NumpySlicesDataset([[0, 1], [2, 3]])
-            >>>
-            >>> def flat_map_func(array):
-            ...     # 使用数组创建NumpySlicesDataset
-            ...     dataset = ds.NumpySlicesDataset(array)
-            ...     # 将数据集对象中的数据重复两次
-            ...     dataset = dataset.repeat(2)
-            ...     return dataset
-            >>>
-            >>> dataset = dataset.flat_map(flat_map_func)
+
+        >>> # 以NumpySlicesDataset为例
+        >>> dataset = ds.NumpySlicesDataset([[0, 1], [2, 3]])
+        >>>
+        >>> def flat_map_func(array):
+        ...     # 使用数组创建NumpySlicesDataset
+        ...     dataset = ds.NumpySlicesDataset(array)
+        ...     # 将数据集对象中的数据重复两次
+        ...     dataset = dataset.repeat(2)
+        ...     return dataset
+        >>>
+        >>> dataset = dataset.flat_map(flat_map_func)
             >>> # [[0, 1], [0, 1], [2, 3], [2, 3]]
 
         **异常：**
 
-        **TypeError** - `func` 不是函数。
-        **TypeError** - `func` 的返回值不是数据集对象。
+        - **TypeError** - `func` 不是函数。
+        - **TypeError** - `func` 的返回值不是数据集对象。
 
     .. py:method:: get_batch_size()
 
         获得批处理的大小，即一个批次中包含的数据条数。
 
         **返回：**
-            int，一个批次中包含的数据条数。
+
+        int，一个批次中包含的数据条数。
 
         **样例：**
-            >> # dataset是数据集类的实例化对象
-            >> batch_size = dataset.get_batch_size()
+
+        >> # dataset是数据集类的实例化对象
+        >> batch_size = dataset.get_batch_size()
 
     .. py:method:: get_class_indexing()
 
         返回类别索引。
 
         **返回：**
-            dict，描述类别名称到索引的键值对映射关系，通常为str-to-int格式。针对COCO数据集，类别名称到索引映射关系描述形式为str-to-list<int>格式，列表中的第二个数字表示超级类别。
+
+        dict，描述类别名称到索引的键值对映射关系，通常为str-to-int格式。针对COCO数据集，类别名称到索引映射关系描述形式为str-to-list<int>格式，列表中的第二个数字表示超级类别。
 
         **样例：**
-            >> # dataset是数据集类的实例化对象
-            >> class_indexing = dataset.get_class_indexing()
+
+        >> # dataset是数据集类的实例化对象
+        >> class_indexing = dataset.get_class_indexing()
 
 
     .. py:method:: get_col_names()
@@ -367,35 +378,37 @@
         返回数据集对象中包含的列名。
 
         **返回：**
-            list，数据集中所有列名组成列表。
+
+        list，数据集中所有列名组成列表。
 
         **样例：**
-            >> # dataset是数据集类的实例化对象
-            >> col_names = dataset.get_col_names()
+
+        >> # dataset是数据集类的实例化对象
+        >> col_names = dataset.get_col_names()
 
     .. py:method:: get_dataset_size()
 
         返回一个epoch中的batch数。
 
         **返回：**
-        
+
         int，batch的数目。
-        
+
     .. py:method:: get_repeat_count()
 
         获取 `RepeatDataset` 中的repeat次数（默认为1）。
 
         **返回：**
-        
+
         int，repeat次数。
-        
+
     .. py:method:: input_indexs
         :property:
 
         获取input index信息。
 
         **返回：**
-        
+
         input index信息的元组。
 
         **样例：**
@@ -405,7 +418,7 @@
         >>> dataset.input_indexs = 10
         >>> print(dataset.input_indexs)
         10
-   
+
     .. py:method:: map(operations, input_columns=None, output_columns=None, column_order=None, num_parallel_workers=None, python_multiprocessing=False, cache=None, callbacks=None)
 
         将operations列表中的每个operation作用于数据集。
@@ -416,11 +429,11 @@
         每个operation将数据集中的一列或多列作为输入，并将输出零列或多列。
         第一个operation将 `input_columns` 中指定的列作为输入。
         如果operations列表中存在多个operation，则上一个operation的输出列将用作下一个operation的输入列。
-        
+
         最后一个operation输出列的列名由 `output_columns` 指定。
-        
+
         只有在 `column_order` 中指定的列才会传播到子节点，并且列的顺序将与 `column_order` 中指定的顺序相同。
-        
+
         **参数：**
 
         - **operations** (Union[list[TensorOp], list[functions]]) - 要作用于数据集的operations列表。将按operations列表中显示的顺序作用在数据集。
@@ -433,7 +446,7 @@
         - **callbacks** (DSCallback, list[DSCallback], optional) - 要调用的Dataset回调函数列表（默认为None）。
 
         **返回：**
-        
+
         MapDataset，map操作后的数据集。
 
         **样例：**
@@ -522,29 +535,29 @@
         >>> dataset = dataset.map(operations, input_columns=["x", "y"],
         ...                       output_columns=["mod2", "mod3", "mod5", "mod7"],
         ...                       column_order=["mod7", "mod3", "col2"])
-        
+
     .. py:method:: num_classes()
 
         获取数据集中的样本的class数目。
 
         **返回：**
-        
+
         int，class数目。
-        
+
     .. py:method:: output_shapes()
 
         获取输出数据的shape。
 
         **返回：**
-        
+
         list，每列shape的列表。
-        
+
     .. py:method:: output_types()
 
         获取输出数据类型。
 
         **返回：**
-        
+
         list，每列类型的列表。
 
     .. py:method:: project(columns)
@@ -555,36 +568,36 @@
         其他列将被丢弃。
 
         **参数：**
-        
-        **columns** (Union[str, list[str]]) - 要投影列的列名列表。
+
+        - **columns** (Union[str, list[str]]) - 要投影列的列名列表。
 
         **返回：**
-        
+
         ProjectDataset，投影后的数据集对象。
 
         **样例：**
-        
+
         >>> # dataset是Dataset对象的实例
         >>> columns_to_project = ["column3", "column1", "column2"]
         >>>
         >>> # 创建一个数据集，无论列的原始顺序如何，依次包含column3, column1, column2。
         >>> dataset = dataset.project(columns=columns_to_project)
-        
+
     .. py:method:: rename(input_columns, output_columns)
 
         重命名输入数据集中的列。
 
         **参数：**
-        
+
         - **input_columns** (Union[str, list[str]]) - 输入列的列名列表。
         - **output_columns** (Union[str, list[str]]) - 输出列的列名列表。
 
         **返回：**
-        
+
         RenameDataset，重命名后数据集对象。
 
         **样例：**
-        
+
         >>> # dataset是Dataset对象的实例
         >>> input_columns = ["input_col1", "input_col2", "input_col3"]
         >>> output_columns = ["output_col1", "output_col2", "output_col3"]
@@ -593,7 +606,7 @@
         >>> # input_col2重命名为output_col2，input_col3重命名
         >>> # 为output_col3。
         >>> dataset = dataset.rename(input_columns=input_columns, output_columns=output_columns)
-        
+
     .. py:method:: repeat(count=None)
 
         重复此数据集 `count` 次。如果count为None或-1，则无限重复。
@@ -603,10 +616,10 @@
 
         **参数：**
 
-        **count** (int) - 数据集重复的次数（默认为None）。
+        - **count** (int) - 数据集重复的次数（默认为None）。
 
         **返回：**
-        
+
         RepeatDataset，重复操作后的数据集对象。
 
         **样例：**
@@ -625,9 +638,9 @@
         >>> # 整个50个epoch视作一个大数据集。
         >>> dataset = dataset.repeat(50)
         >>> dataset = dataset.shuffle(10)
-        
+
     .. py:method:: reset()
-        
+
         重置下一个epoch的数据集。
 
     .. py:method:: save(file_name, num_files=1, file_type='mindrecord')
@@ -688,7 +701,7 @@
             2. 在调用函数之前，不要使用batch算子、repeat算子或具有随机属性的数据增强的map算子。
             3. 当数据的维度可变时，只支持1维数组或者在0维变化的多维数组。
             4. 不支持DE_UINT64类型、多维的DE_UINT8类型、多维DE_STRING类型。
-               
+
         **参数：**
 
         - **file_name** (str) - 数据集文件的路径。
@@ -700,34 +713,34 @@
         设置源数据的动态shape信息，需要在定义数据处理流水线后设置。
 
         **参数：**
-        
-        **columns** (dict) - 包含数据集中每列shape信息的字典。shape[i]为 `None` 表示shape[i]的数据长度是动态的。
-        
+
+        - **columns** (dict) - 包含数据集中每列shape信息的字典。shape[i]为 `None` 表示shape[i]的数据长度是动态的。
+
     .. py:method:: shuffle(buffer_size)
 
         使用以下策略随机打乱此数据集的行：
 
         1. 生成一个shuffle缓冲区包含buffer_size条数据行。
 
-        2. 从shuffle缓冲区中随机选择一个元素，作为下一行传播到子节点。 
+        2. 从shuffle缓冲区中随机选择一个元素，作为下一行传播到子节点。
 
         3. 从父节点获取下一行（如果有的话），并将其放入shuffle缓冲区中。
 
         4. 重复步骤2和3，直到打乱缓冲区中没有数据行为止。
 
         可以提供随机种子，在第一个epoch中使用。在随后的每个epoch，种子都会被设置成一个新产生的随机值。
-        
+
         **参数：**
-        
-        **buffer_size** (int) - 用于shuffle的缓冲区大小（必须大于1）。将buffer_size设置为等于数据集大小将导致在全局shuffle。
-                
+
+        - **buffer_size** (int) - 用于shuffle的缓冲区大小（必须大于1）。将buffer_size设置为等于数据集大小将导致在全局shuffle。
+
         **返回：**
-        
+
         ShuffleDataset，打乱后的数据集对象。
 
         **异常：**
-        
-        **RuntimeError** - 打乱前存在同步操作。
+
+        - **RuntimeError** - 打乱前存在同步操作。
 
         **样例：**
 
@@ -736,14 +749,14 @@
         >>> ds.config.set_seed(58)
         >>> # 使用大小为4的shuffle缓冲区创建打乱后的数据集。
         >>> dataset = dataset.shuffle(4)
-        
+
     .. py:method:: skip(count)
 
         跳过此数据集的前N个元素。
 
         **参数：**
 
-        **count** (int) - 要跳过的数据集中的元素个数。
+        - **count** (int) - 要跳过的数据集中的元素个数。
 
         **返回：**
 
@@ -754,49 +767,49 @@
         >>> # dataset是Dataset对象的实例
         >>> # 创建一个数据集，跳过前3个元素
         >>> dataset = dataset.skip(3)
-        
+
     .. py:method:: split(sizes, randomize=True)
 
         将数据集拆分为多个不重叠的数据集。
 
         这是一个通用拆分函数，可以被数据处理流水线中的任何算子调用。
-        还有如果直接调用ds.split，其中 ds 是一个 MappableDataset，它将被自动调用。  
+        还有如果直接调用ds.split，其中 ds 是一个 MappableDataset，它将被自动调用。
 
         **参数：**
-        
+
         - **sizes** (Union[list[int], list[float]]) - 如果指定了一列整数[s1, s2, …, sn]，数据集将被拆分为n个大小为s1、s2、...、sn的数据集。如果所有输入大小的总和不等于原始数据集大小，则报错。如果指定了一列浮点数[f1, f2, …, fn]，则所有浮点数必须介于0和1之间，并且总和必须为1，否则报错。数据集将被拆分为n个大小为round(f1*K)、round(f2*K)、...、round(fn*K)的数据集，其中K是原始数据集的大小。
-                    
+
             如果舍入后：
 
                 - 任何大小等于0，都将发生错误。
-                - 如果拆分大小的总和<K，K - sigma(round(fi * k))的差值将添加到第一个子数据集。  
+                - 如果拆分大小的总和<K，K - sigma(round(fi * k))的差值将添加到第一个子数据集。
                 - 如果拆分大小的总和>K，sigma(round(fi * K)) - K的差值将从第一个足够大的拆分子集中删除，删除差值后至少有1行。
-                  
-        - **randomize** (bool, optional)：确定是否随机拆分数据（默认为True）。如果为True，则数据集将被随机拆分。否则，将使用数据集中的连续行创建每个拆分子集。
-                
+
+        - **randomize** (bool, optional) - 确定是否随机拆分数据（默认为True）。如果为True，则数据集将被随机拆分。否则，将使用数据集中的连续行创建每个拆分子集。
+
         .. note::
             1. 如果要调用 split，则无法对数据集进行分片。
             2. 强烈建议不要对数据集进行打乱，而是使用随机化（randomize=True）。对数据集进行打乱的结果具有不确定性，每个拆分子集中的数据在每个epoch可能都不同。
-               
+
         **异常：**
 
         - **RuntimeError** - get_dataset_size返回None或此数据集不支持。
-        - **RuntimeError** - sizes是整数列表，并且size中所有元素的总和不等于数据集大小。    
+        - **RuntimeError** - sizes是整数列表，并且size中所有元素的总和不等于数据集大小。
         - **RuntimeError** - sizes是float列表，并且计算后存在大小为0的拆分子数据集。
         - **RuntimeError** - 数据集在调用拆分之前已进行分片。
         - **ValueError** - sizes是float列表，且并非所有float数都在0和1之间，或者float数的总和不等于1。
 
         **返回：**
-        
+
         tuple(Dataset)，拆分后子数据集对象的元组。
 
         **样例：**
-        
+
         >>> # TextFileDataset不是可映射dataset，因此将调用通用拆分函数。
         >>> # 由于许多数据集默认都打开了shuffle，如需调用拆分函数，请将shuffle设置为False。
         >>> dataset = ds.TextFileDataset(text_file_dataset_dir, shuffle=False)
         >>> train_dataset, test_dataset = dataset.split([0.9, 0.1])
-        
+
     .. py:method:: sync_update(condition_name, num_batch=None, data=None)
 
         释放阻塞条件并使用给定数据触发回调函数。
@@ -804,26 +817,26 @@
         **参数：**
 
         - **condition_name** (str) - 用于切换发送下一行数据的条件名称。
-        - **num_batch** (Union[int, None]) - 释放的batch（row）数。当 `num_batch` 为None时，将默认为 `sync_wait` 算子指定的值（默认为None）。        
+        - **num_batch** (Union[int, None]) - 释放的batch（row）数。当 `num_batch` 为None时，将默认为 `sync_wait` 算子指定的值（默认为None）。
         - **data** (Any) - 用户自定义传递给回调函数的数据（默认为None）。
-        
+
     .. py:method:: sync_wait(condition_name, num_batch=1, callback=None)
 
         向输入数据集添加阻塞条件。 将应用同步操作。
 
         **参数：**
-        
+
         - **condition_name** (str) - 用于切换发送下一行的条件名称。
         - **num_batch** (int) - 每个epoch开始时无阻塞的batch数。
         - **callback** (function) -  `sync_update` 中将调用的回调函数。
 
         **返回：**
-        
+
         SyncWaitDataset，添加了阻塞条件的数据集对象。
 
         **异常：**
-        
-        **RuntimeError** - 条件名称已存在。
+
+        - **RuntimeError** - 条件名称已存在。
 
         **样例：**
 
@@ -855,21 +868,21 @@
         ...     count += batch_size
         ...     data = {"loss": count}
         ...     dataset.sync_update(condition_name="policy", data=data)
-        
+
     .. py:method:: take(count=-1)
 
         从数据集中获取最多给定数量的元素。
 
         .. note::
-            1. 如果count大于数据集中的元素数或等于-1，则取数据集中的所有元素。     
+            1. 如果count大于数据集中的元素数或等于-1，则取数据集中的所有元素。
             2. take和batch操作顺序很重要，如果take在batch操作之前，则取给定行数；否则取给定batch数。
-               
+
         **参数：**
-        
-        **count** (int, optional) - 要从数据集中获取的元素数（默认为-1）。
+
+        - **count** (int, optional) - 要从数据集中获取的元素数（默认为-1）。
 
         **返回：**
-        
+
         TakeDataset，取出指定数目的数据集对象。
 
         **样例：**
@@ -877,35 +890,35 @@
         >>> # dataset是Dataset对象的实例。
         >>> # 创建一个数据集，包含50个元素。
         >>> dataset = dataset.take(50)
-        
+
     .. py:method:: to_device(send_epoch_end=True, create_data_info_queue=False)
 
         将数据从CPU传输到GPU、Ascend或其他设备。
 
         **参数：**
-        
+
         - **send_epoch_end** (bool, optional) - 是否将end of sequence发送到设备（默认为True）。
         - **create_data_info_queue** (bool, optional) - 是否创建存储数据类型和shape的队列（默认值为False）。
-                
+
         .. note::
             如果设备为Ascend，则逐个传输数据。每次传输的数据最大限制为256M。
-            
+
         **返回：**
-        
+
         TransferDataset，用于传输的数据集对象。
 
         **异常：**
-        
-        **RuntimeError** - 如果提供了分布式训练的文件路径但读取失败。
-        
+
+        - **RuntimeError** - 如果提供了分布式训练的文件路径但读取失败。
+
     .. py:method:: to_json(filename='')
 
         将数据处理流水线序列化为JSON字符串，如果提供了文件名，则转储到文件中。
 
         **参数：**
 
-        **filename** (str) - 另存为JSON格式的文件名。
+        - **filename** (str) - 另存为JSON格式的文件名。
 
         **返回：**
-        
+
         str，流水线的JSON字符串。

docs/api/api_python/dataset/mindspore.dataset.Dataset.use_sampler.rst

@@ -1,13 +1,14 @@
     .. py:method:: use_sampler(new_sampler)
-    
-       为当前数据集更换一个新的采样器。
 
-       **参数：**
+        为当前数据集更换一个新的采样器。
 
-       **new_sampler** (Sampler) ：替换的新采样器。
+        **参数：**
 
-       样例：
-            >>> # dataset为任意数据集实例
-            >>> # 将该数据集的采样器更换为DistributedSampler
-            >>> new_sampler = ds.DistributedSampler(10, 2)
-            >>> dataset.use_sampler(new_sampler)
+        - **new_sampler** (Sampler) ：替换的新采样器。
+
+        **样例：**
+
+        >>> # dataset为任意数据集实例
+        >>> # 将该数据集的采样器更换为DistributedSampler
+        >>> new_sampler = ds.DistributedSampler(10, 2)
+        >>> dataset.use_sampler(new_sampler)

docs/api/api_python/dataset/mindspore.dataset.Dataset.zip.rst

@@ -3,14 +3,14 @@
         将数据集和输入的数据集或者数据集元组按列进行合并压缩。输入数据集中的列名必须不同。
 
         **参数：**
-        
-        **datasets** (Union[tuple, class Dataset]) - 数据集对象的元组或单个数据集对象与当前数据集一起合并压缩。
+
+        - **datasets** (Union[tuple, class Dataset]) - 数据集对象的元组或单个数据集对象与当前数据集一起合并压缩。
 
         **返回：**
-            
+
         ZipDataset，合并压缩后的数据集对象。
 
         **样例：**
-        
+
         >>> # 创建一个数据集，它将dataset和dataset_1进行合并
         >>> dataset = dataset.zip(dataset_1)

docs/api/api_python/dataset/mindspore.dataset.DatasetCache.rst

@@ -5,18 +5,18 @@ mindspore.dataset.DatasetCache
 
     创建数据缓存客户端实例。
 
-    有关详细信息，请查看 `教程 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_cache.html>`_ 、 
+    有关详细信息，请查看 `教程 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_cache.html>`_ 、
     `编程指南 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_。
 
     **参数：**
 
-    - **session_id** (int)：当前数据缓存客户端的会话ID，用户在命令行开启缓存服务端后可通过 `cache_admin -g` 获取。
-    - **size** (int, optional)：设置数据缓存服务可用的内存大小（默认为0，即内存使用没有上限。注意，这可能会产生计算机内存不足的风险）。
-    - **spilling** (bool, optional)：如果共享内存不足，是否将溢出部分缓存到磁盘（默认为False）。
-    - **hostname** (str, optional)：数据缓存服务客户端的主机IP（默认为None，使用默认主机名127.0.0.1）。
-    - **port** (int, optional)：指定连接到数据缓存服务端的端口号（默认为None，使用端口50052）。
-    - **num_connections** (int, optional)：TCP/IP连接数量（默认为None，使用默认值12）。
-    - **prefetch_size** (int, optional)：指定缓存队列大小，使用缓存功能算子时，将直接从缓存队列中获取数据（默认为None，使用默认值20）。
+    - **session_id** (int) - 当前数据缓存客户端的会话ID，用户在命令行开启缓存服务端后可通过 `cache_admin -g` 获取。
+    - **size** (int, optional) - 设置数据缓存服务可用的内存大小（默认为0，即内存使用没有上限。注意，这可能会产生计算机内存不足的风险）。
+    - **spilling** (bool, optional) - 如果共享内存不足，是否将溢出部分缓存到磁盘（默认为False）。
+    - **hostname** (str, optional) - 数据缓存服务客户端的主机IP（默认为None，使用默认主机名127.0.0.1）。
+    - **port** (int, optional) - 指定连接到数据缓存服务端的端口号（默认为None，使用端口50052）。
+    - **num_connections** (int, optional) - TCP/IP连接数量（默认为None，使用默认值12）。
+    - **prefetch_size** (int, optional) - 指定缓存队列大小，使用缓存功能算子时，将直接从缓存队列中获取数据（默认为None，使用默认值20）。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.DistributedSampler.rst

@@ -7,12 +7,12 @@ mindspore.dataset.DistributedSampler
 
     **参数：**
 
-    - **num_shards** (int)：数据集分片数量。
-    - **shard_id** (int)：当前分片的分片ID，应在[0, num_shards-1]范围内。
-    - **shuffle** (bool, optional)：如果为True，则索引将被打乱（默认为True）。
-    - **num_samples** (int, optional)：要采样的样本数（默认为None，对所有元素进行采样）。
-    - **offset** (int, optional)：将数据集中的元素发送到的起始分片ID，不应超过 `num_shards` 。仅当ConcatDataset以DistributedSampler为采样器时，此参数才有效。此参数影响每个分片的样本数（默认为-1，每个分片具有相同的样本数）。
-            
+    - **num_shards** (int) - 数据集分片数量。
+    - **shard_id** (int) - 当前分片的分片ID，应在[0, num_shards-1]范围内。
+    - **shuffle** (bool, optional) - 如果为True，则索引将被打乱（默认为True）。
+    - **num_samples** (int, optional) - 要采样的样本数（默认为None，对所有元素进行采样）。
+    - **offset** (int, optional) - 将数据集中的元素发送到的起始分片ID，不应超过 `num_shards` 。仅当ConcatDataset以DistributedSampler为采样器时，此参数才有效。此参数影响每个分片的样本数（默认为-1，每个分片具有相同的样本数）。
+
     **样例：**
 
     >>> # 创建一个分布式采样器，共10个分片。当前分片为分片5。
@@ -23,14 +23,14 @@ mindspore.dataset.DistributedSampler
 
     **异常：**
 
-    - **TypeError**：`num_shards` 不是整数值。
-    - **TypeError**：`shard_id` 不是整数值。
-    - **TypeError**：`shuffle` 不是Boolean值。
-    - **TypeError**：`num_samples` 不是整数值。
-    - **TypeError**：`offset` 不是整数值。
-    - **ValueError**：`num_samples` 为负值。
-    - **RuntimeError**：`num_shards` 不是正值。
-    - **RuntimeError**：`shard_id` 小于0或大于等于 `num_shards` 。
-    - **RuntimeError**：`offset` 大于 `num_shards` 。
+    - **TypeError** - `num_shards` 不是整数值。
+    - **TypeError** - `shard_id` 不是整数值。
+    - **TypeError** - `shuffle` 不是Boolean值。
+    - **TypeError** - `num_samples` 不是整数值。
+    - **TypeError** - `offset` 不是整数值。
+    - **ValueError** - `num_samples` 为负值。
+    - **RuntimeError** - `num_shards` 不是正值。
+    - **RuntimeError** - `shard_id` 小于0或大于等于 `num_shards` 。
+    - **RuntimeError** - `offset` 大于 `num_shards` 。
 
     .. include:: mindspore.dataset.BuiltinSampler.rst

docs/api/api_python/dataset/mindspore.dataset.GeneratorDataset.rst

@@ -7,24 +7,24 @@
 
     **参数：**
 
-    - **source** (Union[Callable, Iterable, Random Accessible])：
+    - **source** (Union[Callable, Iterable, Random Accessible]) -
       一个Python的可调用对象，可以是一个可迭代的Python对象，或支持随机访问的Python对象。
       要求传入的可调用对象，可以通过 `source().next()` 的方式返回一个由NumPy数组构成的元组。
       要求传入的可迭代对象，可以通过 `iter(source).next()` 的方式返回一个由NumPy数组构成的元组。
       要求传入的支持随机访问对象，可以通过 `source[idx]` 的方式返回一个由NumPy数组构成的元组。
-    - **column_names** (Union[str, list[str]]，可选)：指定数据集生成的列名（默认值为None），用户必须提供此参数或通过参数 `schema` 指定列名。
-    - **column_types** ((list[mindspore.dtype]，可选)：指定生成数据集各个数据列的数据类型（默认为None）。
+    - **column_names** (Union[str, list[str]]，可选) - 指定数据集生成的列名（默认值为None），用户必须提供此参数或通过参数 `schema` 指定列名。
+    - **column_types** ((list[mindspore.dtype]，可选) - 指定生成数据集各个数据列的数据类型（默认为None）。
       如果未指定该参数，则自动推断类型；如果指定了该参数，将在数据输出时做类型匹配检查。
-    - **schema** (Union[Schema, str]，可选)：读取模式策略，用于指定读取数据列的数据类型、数据维度等信息，支持传入JSON文件或 `schema` 对象的路径。
+    - **schema** (Union[Schema, str]，可选) - 读取模式策略，用于指定读取数据列的数据类型、数据维度等信息，支持传入JSON文件或 `schema` 对象的路径。
       对于数据集生成的列名，用户需要提供 `column_names` 或 `schema` 进行指定，如果同时指定两者，则将优先从 `schema` 获取列名信息。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认为None）。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值为1）。
-    - **shuffle** (bool，可选)：是否混洗数据集。只有输入的 `source` 参数带有可随机访问属性（__getitem__）时，才可以指定该参数。（默认值为None，下表中会展示不同配置的预期行为）。
-    - **sampler** (Union[Sampler, Iterable]，可选)：指定从数据集中选取样本的采样器。只有输入的 `source` 参数带有可随机访问属性（__getitem__）时，才可以指定该参数（默认值为None，下表中会展示不同配置的预期行为）。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认为None）。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值为1）。
+    - **shuffle** (bool，可选) - 是否混洗数据集。只有输入的 `source` 参数带有可随机访问属性（__getitem__）时，才可以指定该参数。（默认值为None，下表中会展示不同配置的预期行为）。
+    - **sampler** (Union[Sampler, Iterable]，可选) - 指定从数据集中选取样本的采样器。只有输入的 `source` 参数带有可随机访问属性（__getitem__）时，才可以指定该参数（默认值为None，下表中会展示不同配置的预期行为）。
     - **num_shards** (int, 可选): 分布式训练时，将数据集划分成指定的分片数（默认值None）。指定此参数后，`num_samples` 表示每个分片的最大样本数。需要输入 `data` 支持可随机访问才能指定该参数。
     - **shard_id** (int, 可选): 分布式训练时，指定使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **python_multiprocessing** (bool，可选)：启用Python多进程模式加速运算（默认为True）。当传入Python对象的计算量很大时，开启此选项可能会有较好效果。
-    - **max_rowsize** (int，可选)：指定在多进程之间复制数据时，共享内存分配的最大空间（数量级为MB，默认为6MB），仅当参数 `python_multiprocessing` 设为True时，此参数才会生效。
+    - **python_multiprocessing** (bool，可选) - 启用Python多进程模式加速运算（默认为True）。当传入Python对象的计算量很大时，开启此选项可能会有较好效果。
+    - **max_rowsize** (int，可选) - 指定在多进程之间复制数据时，共享内存分配的最大空间（数量级为MB，默认为6MB），仅当参数 `python_multiprocessing` 设为True时，此参数才会生效。
 
     **异常：**
 

docs/api/api_python/dataset/mindspore.dataset.GraphData.rst

@@ -7,18 +7,18 @@ mindspore.dataset.GraphData
 
     **参数：**
 
-    - **dataset_file** (str)：数据集文件路径。
-    - **num_parallel_workers** (int, 可选)：读取数据的工作线程数（默认为None）。
-    - **working_mode** (str, 可选)：设置工作模式，目前支持'local'/'client'/'server'（默认为'local'）。
+    - **dataset_file** (str) - 数据集文件路径。
+    - **num_parallel_workers** (int, 可选) - 读取数据的工作线程数（默认为None）。
+    - **working_mode** (str, 可选) - 设置工作模式，目前支持'local'/'client'/'server'（默认为'local'）。
 
       - **local**：用于非分布式训练场景。
       - **client**：用于分布式训练场景。客户端不加载数据，而是从服务器获取数据。
       - **server**：用于分布式训练场景。服务器加载数据并可供客户端使用。
 
-    - **hostname** (str, 可选)：图数据集服务器的主机名。该参数仅在工作模式设置为 'client' 或 'server' 时有效（默认为'127.0.0.1'）。
-    - **port** (int, 可选)：图数据服务器的端口，取值范围为1024-65535。此参数仅当工作模式设置为 'client' 或 'server' （默认为50051）时有效。
-    - **num_client** (int, 可选)：期望连接到服务器的最大客户端数。服务器将根据该参数分配资源。该参数仅在工作模式设置为 'server' 时有效（默认为1）。
-    - **auto_shutdown** (bool, 可选)：当工作模式设置为 'server' 时有效。当连接的客户端数量达到 `num_client` ，且没有客户端正在连接时，服务器将自动退出（默认为True）。
+    - **hostname** (str, 可选) - 图数据集服务器的主机名。该参数仅在工作模式设置为 'client' 或 'server' 时有效（默认为'127.0.0.1'）。
+    - **port** (int, 可选) - 图数据服务器的端口，取值范围为1024-65535。此参数仅当工作模式设置为 'client' 或 'server' （默认为50051）时有效。
+    - **num_client** (int, 可选) - 期望连接到服务器的最大客户端数。服务器将根据该参数分配资源。该参数仅在工作模式设置为 'server' 时有效（默认为1）。
+    - **auto_shutdown** (bool, 可选) - 当工作模式设置为 'server' 时有效。当连接的客户端数量达到 `num_client` ，且没有客户端正在连接时，服务器将自动退出（默认为True）。
 
     **样例：**
 
@@ -34,7 +34,7 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        **edge_type** (int)：指定边的类型。
+        - **edge_type** (int) - 指定边的类型。
 
         **返回：**
 
@@ -138,9 +138,9 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **node_list** (Union[list, numpy.ndarray])：给定的节点列表。
-        - **neighbor_type** (int)：指定邻居节点的类型。
-        - **output_format** (OutputFormat, 可选)：输出存储格式（默认为mindspore.dataset.engine.OutputFormat.NORMAL）取值范围：[OutputFormat.NORMAL, OutputFormat.COO, OutputFormat.CSR]。
+        - **node_list** (Union[list, numpy.ndarray]) - 给定的节点列表。
+        - **neighbor_type** (int) - 指定邻居节点的类型。
+        - **output_format** (OutputFormat, 可选) - 输出存储格式（默认为mindspore.dataset.engine.OutputFormat.NORMAL）取值范围：[OutputFormat.NORMAL, OutputFormat.COO, OutputFormat.CSR]。
 
         **返回：**
 
@@ -158,8 +158,8 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `node_list` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `neighbor_type` 的类型不为整型。
+        - **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `neighbor_type` 的类型不为整型。
 
     .. py:method:: get_all_nodes(node_type)
 
@@ -167,7 +167,7 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        **node_type** (int)：指定节点的类型。
+        - **node_type** (int) - 指定节点的类型。
 
         **返回：**
 
@@ -187,7 +187,7 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        **node_list** (Union[list[tuple], numpy.ndarray])：含一个或多个图节点ID对的列表。
+        - **node_list** (Union[list[tuple], numpy.ndarray]) - 含一个或多个图节点ID对的列表。
 
         **返回：**
 
@@ -207,8 +207,8 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **edge_list** (Union[list, numpy.ndarray])：包含边的列表。
-        - **feature_types** (Union[list, numpy.ndarray])：包含给定特征类型的列表。
+        - **edge_list** (Union[list, numpy.ndarray]) - 包含边的列表。
+        - **feature_types** (Union[list, numpy.ndarray]) - 包含给定特征类型的列表。
 
         **返回：**
 
@@ -221,8 +221,8 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `edge_list` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `feature_types` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `edge_list` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `feature_types` 的类型不为列表或numpy.ndarray。
 
 
     .. py:method:: get_neg_sampled_neighbors(node_list, neg_neighbor_num, neg_neighbor_type)
@@ -231,9 +231,9 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **node_list** (Union[list, numpy.ndarray])：包含节点的列表。
-        - **neg_neighbor_num** (int)：采样的邻居数量。
-        - **neg_neighbor_type** (int)：指定负样本邻居的类型。
+        - **node_list** (Union[list, numpy.ndarray]) - 包含节点的列表。
+        - **neg_neighbor_num** (int) - 采样的邻居数量。
+        - **neg_neighbor_type** (int) - 指定负样本邻居的类型。
 
         **返回：**
 
@@ -247,9 +247,9 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `node_list` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `neg_neighbor_num` 的类型不为整型。
-        - **TypeError**：参数 `neg_neighbor_type` 的类型不为整型。
+        - **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `neg_neighbor_num` 的类型不为整型。
+        - **TypeError** - 参数 `neg_neighbor_type` 的类型不为整型。
 
     .. py:method:: get_nodes_from_edges(edge_list)
 
@@ -257,7 +257,7 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        **edge_list** (Union[list, numpy.ndarray])：包含边的列表。
+        - **edge_list** (Union[list, numpy.ndarray]) - 包含边的列表。
 
         **返回：**
 
@@ -273,8 +273,8 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **node_list** (Union[list, numpy.ndarray])：包含节点的列表。
-        - **feature_types** (Union[list, numpy.ndarray])：指定特征的类型。
+        - **node_list** (Union[list, numpy.ndarray]) - 包含节点的列表。
+        - **feature_types** (Union[list, numpy.ndarray]) - 指定特征的类型。
 
         **返回：**
 
@@ -287,8 +287,8 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `node_list` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `feature_types` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `feature_types` 的类型不为列表或numpy.ndarray。
 
     .. py:method:: get_sampled_neighbors(node_list, neighbor_nums, neighbor_types, strategy=<SamplingStrategy.RANDOM: 0>)
 
@@ -296,11 +296,11 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **node_list** (Union[list, numpy.ndarray])：包含节点的列表。
-        - **neighbor_nums** (Union[list, numpy.ndarray])：每跳采样的邻居数。
-        - **neighbor_types** (Union[list, numpy.ndarray])：每跳采样的邻居类型。
-        - **strategy** (SamplingStrategy, 可选)：采样策略（默认为mindspore.dataset.engine.SamplingStrategy.RANDOM）。取值范围：[SamplingStrategy.RANDOM, SamplingStrategy.EDGE_WEIGHT]。
-            
+        - **node_list** (Union[list, numpy.ndarray]) - 包含节点的列表。
+        - **neighbor_nums** (Union[list, numpy.ndarray]) - 每跳采样的邻居数。
+        - **neighbor_types** (Union[list, numpy.ndarray]) - 每跳采样的邻居类型。
+        - **strategy** (SamplingStrategy, 可选) - 采样策略（默认为mindspore.dataset.engine.SamplingStrategy.RANDOM）。取值范围：[SamplingStrategy.RANDOM, SamplingStrategy.EDGE_WEIGHT]。
+
         - **SamplingStrategy.RANDOM**：随机抽样，带放回采样。
         - **SamplingStrategy.EDGE_WEIGHT**：以边缘权重为概率进行采样。
 
@@ -316,9 +316,9 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `node_list` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `neighbor_nums` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `neighbor_types`  的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `neighbor_nums` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `neighbor_types`  的类型不为列表或numpy.ndarray。
 
 
     .. py:method:: graph_info()
@@ -336,11 +336,11 @@ mindspore.dataset.GraphData
 
         **参数：**
 
-        - **target_nodes** (list[int])：随机游走中的起始节点列表。
-        - **meta_path** (list[int])：每个步长的节点类型。
-        - **step_home_param** (float, 可选)：返回node2vec算法中的超参（默认为1.0）。
-        - **step_away_param** (float, 可选)：node2vec算法中的in和out超参（默认为1.0）。
-        - **default_node** (int, 可选)：如果找不到更多邻居，则为默认节点（默认值为-1，表示不给定节点）。
+        - **target_nodes** (list[int]) - 随机游走中的起始节点列表。
+        - **meta_path** (list[int]) - 每个步长的节点类型。
+        - **step_home_param** (float, 可选) - 返回node2vec算法中的超参（默认为1.0）。
+        - **step_away_param** (float, 可选) - node2vec算法中的in和out超参（默认为1.0）。
+        - **default_node** (int, 可选) - 如果找不到更多邻居，则为默认节点（默认值为-1，表示不给定节点）。
 
         **返回：**
 
@@ -353,5 +353,5 @@ mindspore.dataset.GraphData
 
         **异常：**
 
-        - **TypeError**：参数 `target_nodes` 的类型不为列表或numpy.ndarray。
-        - **TypeError**：参数 `meta_path` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `target_nodes` 的类型不为列表或numpy.ndarray。
+        - **TypeError** - 参数 `meta_path` 的类型不为列表或numpy.ndarray。

docs/api/api_python/dataset/mindspore.dataset.ManifestDataset.rst

@@ -9,28 +9,28 @@
 
     **参数：**
 
-    - **dataset_file** (str)：数据集文件的目录路径。
-    - **usage** (str，可选)：指定数据集的子集，可取值为'train'、'eval'和'inference' （默认为'train'）。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认值为None，即全部样本图片)。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (bool，可选)：是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
-    - **sampler** (Sampler，可选)：指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
-    - **class_indexing** (dict，可选)：指定文件夹名称到类标签的映射，要求映射规则为str到int（默认为None，文件夹名称将按字母顺序排列，每类都有一个唯一的索引，从0开始）。
-    - **decode** (bool, 可选)：是否对读取的图像进行解码操作（默认为False）。
+    - **dataset_file** (str) - 数据集文件的目录路径。
+    - **usage** (str，可选) - 指定数据集的子集，可取值为'train'、'eval'和'inference' （默认为'train'）。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认值为None，即全部样本图片)。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (bool，可选) - 是否混洗数据集（默认为None，下表中会展示不同配置的预期行为）。
+    - **sampler** (Sampler，可选) - 指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。
+    - **class_indexing** (dict，可选) - 指定文件夹名称到类标签的映射，要求映射规则为str到int（默认为None，文件夹名称将按字母顺序排列，每类都有一个唯一的索引，从0开始）。
+    - **decode** (bool, 可选) - 是否对读取的图像进行解码操作（默认为False）。
     - **num_shards** (int, 可选): 分布式训练时，将数据集划分成指定的分片数（默认值None）。指定此参数后，`num_samples` 表示每个分片的最大样本数。
     - **shard_id** (int, 可选): 分布式训练时，指定使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：参数 `dataset_files` 不存在或无效。
-    - **RuntimeError**：参数 `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**：同时指定了 `sampler` 和 `shuffle` 。
-    - **RuntimeError**：同时指定了 `sampler` 和 `num_shards` 或 `shard_id`。
-    - **RuntimeError**: 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**: 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
-    - **RuntimeError**：参数 `class_indexing` 的类型不是字典。
-    - **ValueError**: `shard_id` 参数错误（小于0或者大于等于 `num_shards`）。
+    - **RuntimeError** - 参数 `dataset_files` 不存在或无效。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 或 `shard_id`。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **RuntimeError** - 参数 `class_indexing` 的类型不是字典。
+    - **ValueError** - `shard_id` 参数错误（小于0或者大于等于 `num_shards`）。
 
     .. note::
         - 如果 `decode` 参数指定为False，则 `image` 列的shape为[image_size]，否则为[H,W,C]。

docs/api/api_python/dataset/mindspore.dataset.MindDataset.rst

@@ -7,30 +7,30 @@
 
     **参数：**
 
-    - **dataset_file** (Union[str, list[str]])：MindRecord文件路径，支持单文件路径字符串、多文件路径字符串列表。如果 `dataset_file` 的类型是字符串，则它代表一组具有相同前缀名的MindRecord文件，同一路径下具有相同前缀名的其他MindRecord文件将会被自动寻找并加载。如果 `dataset_file` 的类型是列表，则它表示所需读取的MindRecord数据文件。
-    - **columns_list** (list[str]，可选)：指定从MindRecord文件中读取的数据列（默认为None，读取所有列）。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (Union[bool, Shuffle level], 可选)：每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
-      
+    - **dataset_file** (Union[str, list[str]]) - MindRecord文件路径，支持单文件路径字符串、多文件路径字符串列表。如果 `dataset_file` 的类型是字符串，则它代表一组具有相同前缀名的MindRecord文件，同一路径下具有相同前缀名的其他MindRecord文件将会被自动寻找并加载。如果 `dataset_file` 的类型是列表，则它表示所需读取的MindRecord数据文件。
+    - **columns_list** (list[str]，可选) - 指定从MindRecord文件中读取的数据列（默认为None，读取所有列）。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (Union[bool, Shuffle level], 可选) - 每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
+
       - Shuffle.GLOBAL：混洗文件和样本。
       - Shuffle.FILES：仅混洗文件。
       - Shuffle.INFILE：保持读入文件的序列，仅混洗每个文件中的数据。
 
     - **num_shards** (int, 可选): 分布式训练时，将数据集划分成指定的分片数（默认值None）。指定此参数后，`num_samples` 表示每个分片的最大样本数。
     - **shard_id** (int, 可选): 分布式训练时，指定使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **sampler** (Sampler，可选)：指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。当前此数据集仅支持以下采样器：SubsetRandomSampler、PkSampler、RandomSampler、SequentialSampler和DistributedSampler。
+    - **sampler** (Sampler，可选) - 指定从数据集中选取样本的采样器（默认为None，下表中会展示不同配置的预期行为）。当前此数据集仅支持以下采样器：SubsetRandomSampler、PkSampler、RandomSampler、SequentialSampler和DistributedSampler。
     - **padded_sample** (dict，可选): 指定额外添加到数据集的样本，可用于在分布式训练时补齐分片数据，注意字典的键名需要与 `column_list` 指定的列名相同。
-    - **num_padded** (int，可选)：指定额外添加的数据集样本的数量。在分布式训练时可用于为数据集补齐样本，使得总样本数量可被 `num_shards` 整除。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认值为None，表示所有样本)。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **num_padded** (int，可选) - 指定额外添加的数据集样本的数量。在分布式训练时可用于为数据集补齐样本，使得总样本数量可被 `num_shards` 整除。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认值为None，表示所有样本)。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：参数 `dataset_files` 无效或不存在。
-    - **RuntimeError**：参数 `num_parallel_workers` 超过最大线程数。
-    - **RuntimeError**：指定了 `num_shards` ，但 `shard_id` 为None。
-    - **RuntimeError**：指定了 `shard_id` ，但 `num_shards` 为None。
-    - **ValueError**: `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
+    - **RuntimeError** - 参数 `dataset_files` 无效或不存在。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过最大线程数。
+    - **RuntimeError** - 指定了 `num_shards` ，但 `shard_id` 为None。
+    - **RuntimeError** - 指定了 `shard_id` ，但 `num_shards` 为None。
+    - **ValueError** - `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
 
     .. note:: 此数据集可以指定 `sampler` 参数，但 `sampler` 和 `shuffle` 是互斥的。下表展示了几种合法的输入参数及预期的行为。
 

docs/api/api_python/dataset/mindspore.dataset.MnistDataset.rst

@@ -26,7 +26,7 @@ mindspore.dataset.MnistDataset
     - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 参数。
     - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 参数。
     - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定`num_shards` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
     - **ValueError** - `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
 
     .. note:: 此数据集可以指定 `sampler` 参数，但 `sampler` 和 `shuffle` 是互斥的。下表展示了几种合法的输入参数及预期的行为。

docs/api/api_python/dataset/mindspore.dataset.NumpySlicesDataset.rst

@@ -7,7 +7,7 @@ mindspore.dataset.NumpySlicesDataset
 
     **参数：**
 
-    - **data** (Union[list, tuple, dict])：输入的Python数据。支持的数据类型包括：list、tuple、dict和其他NumPy格式。输入数据将沿着第一个维度切片，并生成额外的行。如果输入是单个list，则将生成一个数据列，若是嵌套多个list，则生成多个数据列。不建议通过这种方式加载大量的数据，因为可能会在数据加载到内存时等待较长时间。
+    - **data** (Union[list, tuple, dict]) - 输入的Python数据。支持的数据类型包括：list、tuple、dict和其他NumPy格式。输入数据将沿着第一个维度切片，并生成额外的行。如果输入是单个list，则将生成一个数据列，若是嵌套多个list，则生成多个数据列。不建议通过这种方式加载大量的数据，因为可能会在数据加载到内存时等待较长时间。
     - **column_names** (list[str], 可选): 指定数据集生成的列名（默认值为None）。如果未指定列名称，且当输入数据的类型是dict时，输出列名称将被命名为dict的键名，否则它们将被命名为column_0，column_1...。
     - **num_samples** (int, 可选): 指定从数据集中读取的样本数（默认值为None，所有样本）。
     - **num_parallel_workers** (int, 可选): 指定读取数据的工作线程数（默认值为1）。
@@ -46,25 +46,25 @@ mindspore.dataset.NumpySlicesDataset
 
     **异常：**
 
-    - **RuntimeError**: `column_names` 列表的长度与数据的输出列表长度不匹配。
-    - **RuntimeError**: `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `shuffle` 。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `num_shards` 。
-    - **RuntimeError**: 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**: 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
-    - **ValueError**: `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
+    - **RuntimeError** - `column_names` 列表的长度与数据的输出列表长度不匹配。
+    - **RuntimeError** - `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **ValueError** - `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
 
     **样例：**
 
-    >>> # 1) 输入的`data`参数类型为list
+    >>> # 1) 输入的 `data` 参数类型为list
     >>> data = [1, 2, 3]
     >>> dataset = ds.NumpySlicesDataset(data=data, column_names=["column_1"])
     >>>
-    >>> # 2) 输入的`data`参数类型为dict，并且使用column_names的默认行为，即采用键名作为生成列名。
+    >>> # 2) 输入的 `data` 参数类型为dict，并且使用column_names的默认行为，即采用键名作为生成列名。
     >>> data = {"a": [1, 2], "b": [3, 4]}
     >>> dataset = ds.NumpySlicesDataset(data=data)
     >>>
-    >>> # 3) 输入的`data`参数类型是由list组成的tuple（或NumPy数组），每个元组分别生成一个输出列，共三个输出列
+    >>> # 3) 输入的 `data` 参数类型是由list组成的tuple（或NumPy数组），每个元组分别生成一个输出列，共三个输出列
     >>> data = ([1, 2], [3, 4], [5, 6])
     >>> dataset = ds.NumpySlicesDataset(data=data, column_names=["column_1", "column_2", "column_3"])
     >>>

docs/api/api_python/dataset/mindspore.dataset.PaddedDataset.rst

@@ -7,13 +7,13 @@ mindspore.dataset.PaddedDataset
 
     **参数：**
 
-    **padded_samples** (list(dict)): 用户提供的样本数据。
+    - **padded_samples** (list(dict)): 用户提供的样本数据。
 
     **异常：**
 
-    - **TypeError**：`padded_samples` 的类型不为list。
-    - **TypeError**：`padded_samples` 的元素类型不为dict。
-    - **ValueError**：`padded_samples` 为空列表。
+    - **TypeError** - `padded_samples` 的类型不为list。
+    - **TypeError** - `padded_samples` 的元素类型不为dict。
+    - **ValueError** - `padded_samples` 为空列表。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.Schema.rst

@@ -7,7 +7,7 @@ mindspore.dataset.Schema
 
     **参数：**
 
-    **schema_file** (str): schema文件的路径（默认值为None）。
+    - **schema_file** (str): schema文件的路径（默认值为None）。
 
     **返回：**
 
@@ -45,7 +45,7 @@ mindspore.dataset.Schema
 
         **参数：**
 
-        **json_obj** (dictionary): 解析的JSON对象。
+        - **json_obj** (dictionary): 解析的JSON对象。
 
         **异常：**
 

docs/api/api_python/dataset/mindspore.dataset.TFRecordDataset.rst

@@ -7,28 +7,28 @@ mindspore.dataset.TFRecordDataset
 
     **参数：**
 
-    - **dataset_files** (Union[str, list[str]])：数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
-    - **schema** (Union[str, Schema]，可选)：读取模式策略，用于指定读取数据列的数据类型、数据维度等信息。支持传入JSON文件或 `Schema` 对象的路径（默认为None，将使用TFData文件中的元数据构造 `Schema` 对象）。
-    - **columns_list** (list[str]，可选)：指定从TFRecord文件中读取的数据列（默认为None，读取所有列）。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认为None）。如果 `num_samples` 为None，并且numRows字段（由参数 `schema` 定义）不存在，则读取所有数据集；如果 `num_samples` 为None，并且numRows字段（由参数 `schema` 定义）的值大于0，则读取numRows条数据；如果 `num_samples` 和numRows字段（由参数 `schema` 定义）的值都大于0，仅有参数 `num_samples` 生效且读取给定数量的数据。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (Union[bool, Shuffle level], 可选)：每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
-      
+    - **dataset_files** (Union[str, list[str]]) - 数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
+    - **schema** (Union[str, Schema]，可选) - 读取模式策略，用于指定读取数据列的数据类型、数据维度等信息。支持传入JSON文件或 `Schema` 对象的路径（默认为None，将使用TFData文件中的元数据构造 `Schema` 对象）。
+    - **columns_list** (list[str]，可选) - 指定从TFRecord文件中读取的数据列（默认为None，读取所有列）。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认为None）。如果 `num_samples` 为None，并且numRows字段（由参数 `schema` 定义）不存在，则读取所有数据集；如果 `num_samples` 为None，并且numRows字段（由参数 `schema` 定义）的值大于0，则读取numRows条数据；如果 `num_samples` 和numRows字段（由参数 `schema` 定义）的值都大于0，仅有参数 `num_samples` 生效且读取给定数量的数据。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数（默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (Union[bool, Shuffle level], 可选) - 每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
+
       - Shuffle.GLOBAL：混洗文件和样本。
       - Shuffle.FILES：仅混洗文件。
 
     - **num_shards** (int, 可选): 分布式训练时，将数据集划分成指定的分片数（默认值None）。指定此参数后，`num_samples` 表示每个分片的最大样本数。
     - **shard_id** (int, 可选): 分布式训练时，指定使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
     - **shard_equal_rows** (bool，可选)： 分布式训练时，为所有分片获取等量的数据行数（默认为False）。如果 `shard_equal_rows` 为False，则可能会使得每个分片的数据条目不相等，从而导致分布式训练失败。因此当每个TFRecord文件的数据数量不相等时，建议将此参数设置为True。注意，只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**：参数 `dataset_files` 无效或不存在。
-    - **RuntimeError**：参数 `num_parallel_workers` 超过最大线程数。
-    - **RuntimeError**：指定了 `num_shards` ，但 `shard_id` 为None。
-    - **RuntimeError**：指定了 `shard_id` ，但 `num_shards` 为None。
-    - **ValueError**：参数 `shard_id` 无效（小于0或者大于等于 `num_shards` ）。
+    - **RuntimeError** - 参数 `dataset_files` 无效或不存在。
+    - **RuntimeError** - 参数 `num_parallel_workers` 超过最大线程数。
+    - **RuntimeError** - 指定了 `num_shards` ，但 `shard_id` 为None。
+    - **RuntimeError** - 指定了 `shard_id` ，但 `num_shards` 为None。
+    - **ValueError** - 参数 `shard_id` 无效（小于0或者大于等于 `num_shards` ）。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.TextFileDataset.rst

@@ -7,24 +7,24 @@
 
     **参数：**
 
-    - **dataset_files** (Union[str, list[str]])：数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
-    - **num_samples** (int，可选)：指定从数据集中读取的样本数（默认为None，即读取所有样本）。
-    - **num_parallel_workers** (int，可选)：指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
-    - **shuffle** (Union[bool, Shuffle level], 可选)：每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
-        
+    - **dataset_files** (Union[str, list[str]]) - 数据集文件路径，支持单文件路径字符串、多文件路径字符串列表或可被glob库模式匹配的字符串，文件列表将在内部进行字典排序。
+    - **num_samples** (int，可选) - 指定从数据集中读取的样本数（默认为None，即读取所有样本）。
+    - **num_parallel_workers** (int，可选) - 指定读取数据的工作线程数(默认值None，即使用mindspore.dataset.config中配置的线程数）。
+    - **shuffle** (Union[bool, Shuffle level], 可选) - 每个epoch中数据混洗的模式（默认为为mindspore.dataset.Shuffle.GLOBAL）。如果为False，则不混洗；如果为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。另外也可以传入枚举变量设置shuffle级别：
+
         - Shuffle.GLOBAL：混洗文件和样本。
         - Shuffle.FILES：仅混洗文件。
 
-    - **num_shards** (int, 可选)：指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
-    - **shard_id** (int, 可选)：指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
-    - **cache** (DatasetCache, 可选)：数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
+    - **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数（默认值None）。指定此参数后, `num_samples` 表示每个分片的最大样本数。
+    - **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号（默认值None）。只有当指定了 `num_shards` 时才能指定此参数。
+    - **cache** (DatasetCache, 可选) - 数据缓存客户端实例，用于加快数据集处理速度（默认为None，不使用缓存）。
 
     **异常：**
 
-    - **RuntimeError**： `dataset_files` 所指的文件无效或不存在。
-    - **RuntimeError**： `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**：指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**：指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **RuntimeError** - `dataset_files` 所指的文件无效或不存在。
+    - **RuntimeError** - `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.VOCDataset.rst

@@ -28,19 +28,19 @@ mindspore.dataset.VOCDataset
 
     **异常：**
 
-    - **RuntimeError**: `dataset_dir` 不包含任何数据文件。
-    - **RuntimeError**: `num_parallel_workers` 超过系统最大线程数。
-    - **RuntimeError**: 标注的xml文件格式异常或无效。
-    - **RuntimeError**: 标注的xml文件缺失 `object` 属性。
-    - **RuntimeError**: 标注的xml文件缺失 `bndbox` 属性。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `shuffle` 。
-    - **RuntimeError**: 同时指定了 `sampler` 和 `num_shards` 。
-    - **RuntimeError**: 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
-    - **RuntimeError**: 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
-    - **ValueError**： 指定的任务不为'Segmentation'或'Detection'。
-    - **ValueError**： 指定任务为'Segmentation'时，class_indexing不为None。
-    - **ValueError**： 与usage相关的txt文件不存在。
-    - **ValueError**:  `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
+    - **RuntimeError** - `dataset_dir` 不包含任何数据文件。
+    - **RuntimeError** - `num_parallel_workers` 超过系统最大线程数。
+    - **RuntimeError** - 标注的xml文件格式异常或无效。
+    - **RuntimeError** - 标注的xml文件缺失 `object` 属性。
+    - **RuntimeError** - 标注的xml文件缺失 `bndbox` 属性。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `shuffle` 。
+    - **RuntimeError** - 同时指定了 `sampler` 和 `num_shards` 。
+    - **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
+    - **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
+    - **ValueError** - 指定的任务不为'Segmentation'或'Detection'。
+    - **ValueError** - 指定任务为'Segmentation'时，class_indexing不为None。
+    - **ValueError** - 与usage相关的txt文件不存在。
+    - **ValueError** -  `shard_id` 参数错误（小于0或者大于等于 `num_shards` ）。
 
     .. note::
         - 当指定 `extra_metadata` 为True时，除非显式使用rename算子以删除元信息列明的前缀('_meta-')，否则迭代的数据行中不会出现'[_meta-filename, dtype=string]'列。

docs/api/api_python/dataset/mindspore.dataset.WaitedDSCallback.rst

@@ -10,7 +10,7 @@ mindspore.dataset.WaitedDSCallback
 
     **参数：**
 
-    **step_size** (int, optional)：每个step包含的数据行数。step大小通常与batch大小相等（默认值为1）。
+    - **step_size** (int, optional) - 每个step包含的数据行数。step大小通常与batch大小相等（默认值为1）。
 
     **样例：**
 
@@ -29,7 +29,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **run_context** (RunContext)：网络训练运行信息。
+        - **run_context** (RunContext) - 网络训练运行信息。
 
     .. py:method:: ds_begin(ds_run_context)
 
@@ -37,7 +37,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_epoch_begin(ds_run_context)
 
@@ -53,7 +53,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: ds_step_begin(ds_run_context)
 
@@ -70,7 +70,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **ds_run_context** (RunContext)：数据处理管道运行信息。
+        - **ds_run_context** (RunContext) - 数据处理管道运行信息。
 
     .. py:method:: end(run_context)
 
@@ -86,7 +86,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **run_context** (RunContext)：网络训练运行信息。
+        - **run_context** (RunContext) - 网络训练运行信息。
 
     .. py:method:: epoch_end(run_context)
 
@@ -102,7 +102,7 @@ mindspore.dataset.WaitedDSCallback
 
         **参数：**
 
-        **run_context** (RunContext)：网络训练运行信息。
+        - **run_context** (RunContext) - 网络训练运行信息。
 
     .. py:method:: step_end(run_context)
 

docs/api/api_python/dataset/mindspore.dataset.WeightedRandomSampler.rst

@@ -7,9 +7,9 @@ mindspore.dataset.WeightedRandomSampler
 
     **参数：**
 
-    - **weights** (list[float, int])：权重序列，总和不一定为1。
-    - **num_samples** (int, optional)：待采样的元素数量（默认值为None，代表采样所有元素）。
-    - **replacement** (bool)：如果值为True，则将样本ID放回下一次采样（默认值为True）。
+    - **weights** (list[float, int]) - 权重序列，总和不一定为1。
+    - **num_samples** (int, optional) - 待采样的元素数量（默认值为None，代表采样所有元素）。
+    - **replacement** (bool) - 如果值为True，则将样本ID放回下一次采样（默认值为True）。
 
     **样例：**
 

docs/api/api_python/dataset/mindspore.dataset.deserialize.rst

@@ -10,8 +10,8 @@ mindspore.dataset.deserialize
 
     **参数：**
 
-    - **input_dict** (dict)：包含序列化数据集图的Python字典。
-    - **json_filepath** (str)：JSON文件的路径，用户可通过 `mindspore.dataset.serialize()` 接口生成。
+    - **input_dict** (dict) - 包含序列化数据集图的Python字典。
+    - **json_filepath** (str) - JSON文件的路径，用户可通过 `mindspore.dataset.serialize()` 接口生成。
 
     **返回：**
 
@@ -22,7 +22,7 @@ mindspore.dataset.deserialize
     **OSError:** 无法打开JSON文件。
 
     **样例：**
-        
+
     >>> dataset = ds.MnistDataset(mnist_dataset_dir, 100)
     >>> one_hot_encode = c_transforms.OneHot(10)  # num_classes是输入参数
     >>> dataset = dataset.map(operation=one_hot_encode, input_column_names="label")
@@ -34,4 +34,3 @@ mindspore.dataset.deserialize
     >>> serialized_data = ds.engine.serialize(dataset)
     >>> dataset = ds.engine.deserialize(input_dict=serialized_data)
 
-    

docs/api/api_python/dataset/mindspore.dataset.zip.rst

@@ -4,7 +4,7 @@
 
     **参数：**
 
-    **datasets** (tuple of class Dataset) - 输入元组格式的多个dataset对象。 `datasets` 参数的长度必须大于1。
+    - **datasets** (tuple of class Dataset) - 输入元组格式的多个dataset对象。 `datasets` 参数的长度必须大于1。
 
     **返回：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.AllpassBiquad.rst

@@ -7,9 +7,9 @@ mindspore.dataset.audio.transforms.AllpassBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **central_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **central_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.AmplitudeToDB.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.AmplitudeToDB
 
     **参数：**
 
-    - **stype** (ScaleType, optional)：输入音频的原始标度（默认值为ScaleType.POWER）。取值可为ScaleType.MAGNITUDE或ScaleType.POWER。
-    - **ref_value** (float, optional)：系数参考值，用于计算分贝系数 `db_multiplier` ， :math:`db\_multiplier = Log10(max(ref\_value, amin))`。
-    - **amin** (float, optional)：波形取值下界，低于该值的波形将会被裁切。取值必须大于0。
-    - **top_db** (float, optional)：最小负截止分贝值，建议的取值为80.0（默认值为80.0）。
+    - **stype** (ScaleType, optional) - 输入音频的原始标度（默认值为ScaleType.POWER）。取值可为ScaleType.MAGNITUDE或ScaleType.POWER。
+    - **ref_value** (float, optional) - 系数参考值，用于计算分贝系数 `db_multiplier` ， :math:`db\_multiplier = Log10(max(ref\_value, amin))`。
+    - **amin** (float, optional) - 波形取值下界，低于该值的波形将会被裁切。取值必须大于0。
+    - **top_db** (float, optional) - 最小负截止分贝值，建议的取值为80.0（默认值为80.0）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandBiquad.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.BandBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **central_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
-    - **noise** (bool, optional)：若为True，则使用非音调音频（如打击乐）模式；若为False，则使用音调音频（如语音、歌曲或器乐）模式（默认为False）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **central_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **noise** (bool, optional) - 若为True，则使用非音调音频（如打击乐）模式；若为False，则使用音调音频（如语音、歌曲或器乐）模式（默认为False）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandpassBiquad.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.BandpassBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **central_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
-    - **const_skirt_gain** (bool, optional)：若为True，则使用恒定裙边增益（峰值增益为Q）。若为False，则使用恒定的0dB峰值增益（默认为False）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **central_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **const_skirt_gain** (bool, optional) - 若为True，则使用恒定裙边增益（峰值增益为Q）。若为False，则使用恒定的0dB峰值增益（默认为False）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandrejectBiquad.rst

@@ -7,9 +7,9 @@ mindspore.dataset.audio.transforms.BandrejectBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **central_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **central_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BassBiquad.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.BassBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **gain** (float)：期望提升（或衰减）的音频增益，单位为dB。
-    - **central_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **gain** (float) - 期望提升（或衰减）的音频增益，单位为dB。
+    - **central_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.ComplexNorm.rst

@@ -7,7 +7,7 @@ mindspore.dataset.audio.transforms.ComplexNorm
 
     **参数：**
 
-    **power** (float, optional)：范数的幂，取值非负（默认为1.0）。
+    - **power** (float, optional) - 范数的幂，取值非负（默认为1.0）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.Contrast.rst

@@ -7,7 +7,7 @@ mindspore.dataset.audio.transforms.Contrast
 
     **参数：**
 
-    **enhancement_amount** (float)：控制音频增益的量。取值范围为[0,100]（默认为75.0）。注意当 `enhancement_amount` 等于0时，对比度增强效果仍然会很显著。
+    - **enhancement_amount** (float) - 控制音频增益的量。取值范围为[0,100]（默认为75.0）。注意当 `enhancement_amount` 等于0时，对比度增强效果仍然会很显著。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.FrequencyMasking.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.FrequencyMasking
 
     **参数：**
 
-    - **iid_masks** (bool, optional)：是否添加随机掩码（默认为False）。
-    - **frequency_mask_param** (int)：当 `iid_masks` 为True时，掩码长度将从[0, frequency_mask_param]中均匀采样；当 `iid_masks` 为False时，使用该值作为掩码的长度。取值范围为[0, freq_length]，其中 `freq_length` 为波形在频域的长度（默认为0）。
-    - **mask_start** (int)：添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, freq_length - frequency_mask_param]，其中 `freq_length` 为波形在频域的长度（默认为0）。
-    - **mask_value** (double)：添加掩码的取值（默认为0.0）。
+    - **iid_masks** (bool, optional) - 是否添加随机掩码（默认为False）。
+    - **frequency_mask_param** (int) - 当 `iid_masks` 为True时，掩码长度将从[0, frequency_mask_param]中均匀采样；当 `iid_masks` 为False时，使用该值作为掩码的长度。取值范围为[0, freq_length]，其中 `freq_length` 为波形在频域的长度（默认为0）。
+    - **mask_start** (int) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, freq_length - frequency_mask_param]，其中 `freq_length` 为波形在频域的长度（默认为0）。
+    - **mask_value** (double) - 添加掩码的取值（默认为0.0）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.LowpassBiquad.rst

@@ -7,9 +7,9 @@ mindspore.dataset.audio.transforms.LowpassBiquad
 
     **参数：**
 
-    - **sample_rate** (int)：采样率，例如44100 (Hz)，不能为零。
-    - **cutoff_freq** (float)：中心频率（单位：Hz）。
-    - **Q** (float, optional)：品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
+    - **sample_rate** (int) - 采样率，例如44100 (Hz)，不能为零。
+    - **cutoff_freq** (float) - 中心频率（单位：Hz）。
+    - **Q** (float, optional) - 品质因子，参考 https://en.wikipedia.org/wiki/Q_factor，取值范围(0, 1]（默认值为0.707）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.TimeMasking.rst

@@ -7,10 +7,10 @@ mindspore.dataset.audio.transforms.TimeMasking
 
     **参数：**
 
-    - **iid_masks** (bool, optional)：是否添加随机掩码（默认为False）。
+    - **iid_masks** (bool, optional) - 是否添加随机掩码（默认为False）。
     - **time_mask_param** (int): 当 `iid_masks` 为True时，掩码长度将从[0, time_mask_param]中均匀采样；当 `iid_masks` 为False时，使用该值作为掩码的长度。取值范围为[0, time_length]，其中 `time_length` 为波形在时域的长度（默认为0）。
-    - **mask_start** (int)：添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, time_length - time_mask_param]，其中 `time_length` 为波形在时域的长度（默认为0）。
-    - **mask_value** (double)：添加掩码的取值（默认为0.0）。
+    - **mask_start** (int) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, time_length - time_mask_param]，其中 `time_length` 为波形在时域的长度（默认为0）。
+    - **mask_value** (double) - 添加掩码的取值（默认为0.0）。
 
     **样例：**
 

docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.TimeStretch.rst

@@ -7,9 +7,9 @@ mindspore.dataset.audio.transforms.TimeStretch
 
     **参数：**
 
-    - **hop_length** (int, optional)：STFT窗之间每跳的长度，即连续帧之间的样本数（默认为None，取 `n_freq - 1`）。
-    - **n_freq** (int, optional)：STFT中的滤波器组数（默认为201）。
-    - **fixed_rate** (float, optional)：频谱在时域加快或减缓的比例（默认为None，取1.0）。
+    - **hop_length** (int, optional) - STFT窗之间每跳的长度，即连续帧之间的样本数（默认为None，取 `n_freq - 1`）。
+    - **n_freq** (int, optional) - STFT中的滤波器组数（默认为201）。
+    - **fixed_rate** (float, optional) - 频谱在时域加快或减缓的比例（默认为None，取1.0）。
 
     **样例：**
 

docs/api/api_python/mindspore.common.initializer.rst

@@ -4,17 +4,17 @@ mindspore.common.initializer
 初始化神经元参数。
 
 .. py:class:: mindspore.common.initializer.Initializer(**kwargs)
-   
+
     初始化器的抽象基类。
-   
+
     **参数：**
 
-    **kwargs** (dict) – `Initializer` 的关键字参数。
+    - **kwargs** (dict) – `Initializer` 的关键字参数。
 
     .. py:method:: mindspore.common.initializer.initializer(init, shape=None, dtype=mstype.float32)
-   
+
         创建并初始化一个Tensor。
-   
+
         **参数：**
 
         - **init** (Union[Tensor, str, Initializer, numbers.Number]) – 初始化方式。
@@ -23,8 +23,8 @@ mindspore.common.initializer
           - **Initializer** - `init` 是继承自 `Initializer` ，用于初始化Tensor的类。
           - **numbers.Number** - 调用常量来初始化张量。
 
-        - **shape** (Union[[tuple, list, int]) - 被初始化的Tensor的shape，默认值为None。   
-        - **dtype** (mindspore.dtype) – 被初始化的Tensor的数据类型，默认值为 `mindspore.float32` 。 
+        - **shape** (Union[[tuple, list, int]) - 被初始化的Tensor的shape，默认值为None。
+        - **dtype** (mindspore.dtype) – 被初始化的Tensor的数据类型，默认值为 `mindspore.float32` 。
 
         **返回：**
 
@@ -38,101 +38,100 @@ mindspore.common.initializer
         **样例：**
 
         >>> import mindspore
-        >>> from mindspore.common.initializer import initializer, One        
-        >>> tensor = initializer('ones', [1, 2, 3], mindspore.float32)       
-        >>> tensor = initializer(One(), [1, 2, 3], mindspore.float32)       
+        >>> from mindspore.common.initializer import initializer, One
+        >>> tensor = initializer('ones', [1, 2, 3], mindspore.float32)
+        >>> tensor = initializer(One(), [1, 2, 3], mindspore.float32)
         >>> tensor = initializer(0, [1, 2, 3], mindspore.float32)
-        
+
 .. py:class:: mindspore.common.initializer.TruncatedNormal(sigma=0.01)
 
     生成一个数组用于初始化Tensor，数组中的数值从截断正态分布中采样得到。
-    
+
     **参数：**
 
-    **sigma** (float) - 截断正态分布的标准差，默认值为0.01。
-   
+    - **sigma** (float) - 截断正态分布的标准差，默认值为0.01。
+
 .. py:class:: mindspore.common.initializer.Normal(sigma=0.01, mean=0.0)
 
     生成一个数组用于初始化Tensor，数组中的数值从正态分布N(sigma, mean)中采样得到。
 
     .. math::
         f(x) =  \frac{1} {\sqrt{2*π} * sigma}exp(-\frac{(x - mean)^2} {2*{sigma}^2})
-     
+
     **参数：**
 
     - **sigma** (float) - 正态分布的标准差，默认值为0.01。
     - **mean** (float) - 正态分布的均值，默认值为0.0。
-          
+
 .. py:class:: mindspore.common.initializer.Uniform(scale=0.07)
 
     生成一个数组用于初始化Tensor，数组中的数值从均匀分布U(-scale, scale)中采样得到。
-    
+
     **参数：**
 
-    **scale** (float) - 均匀分布的边界，默认值为0.07。
-    
+    - **scale** (float) - 均匀分布的边界，默认值为0.07。
+
 .. py:class:: mindspore.common.initializer.HeUniform(negative_slope=0, mode="fan_in", nonlinearity="leaky_relu")
 
     生成一个数组用于初始化Tensor，数组中的数值从HeKaiming均匀分布U[-boundary,boundary]中采样得到，其中
-	
+
     .. math::
         boundary = \sqrt{\frac{6}{(1 + a^2) \times \text{fan_in}}}
-    
+
     是HeUniform分布的边界。
-    
+
     **参数：**
 
     - **negative_slope** (int, float, bool) - 本层激活函数的负数区间斜率（仅适用于非线性激活函数"leaky_relu"），默认值为0。
     - **mode** (str) - 可选"fan_in"或"fan_out"，"fan_in"会保留前向传递中权重方差的量级，"fan_out"会保留反向传递的量级，默认为"fan_in"。
     - **nonlinearity** (str) - 非线性激活函数，推荐使用"relu"或"leaky_relu"，默认为"leaky_relu"。
-             
+
 .. py:class:: mindspore.common.initializer.HeNormal(negative_slope=0, mode="fan_in", nonlinearity="leaky_relu")
 
     生成一个数组用于初始化Tensor，数组中的数值从HeKaiming正态分布N(0, sigma^2)中采样得到，其中
 
     .. math::
         sigma = \frac{gain} {\sqrt{N}}
-    
+
     其中，gain是一个可选的缩放因子。如果mode是"fan_in"， N是权重Tensor中输入单元的数量，如果mode是"fan_out"， N是权重Tensor中输出单元的数量。
 
     HeUniform 算法的详细信息，请查看 https://arxiv.org/abs/1502.01852。
-    
+
     **参数：**
 
     - **negative_slope** (int, float, bool) - 本层激活函数的负数区间斜率（仅适用于非线性激活函数"leaky_relu"），默认值为0。
     - **mode** (str) - 可选"fan_in"或"fan_out"，"fan_in"会保留前向传递中权重方差的量级，"fan_out"会保留反向传递的量级，默认为"fan_in"。
     - **nonlinearity** (str) - 非线性激活函数，推荐使用"relu"或"leaky_relu"，默认为"leaky_relu"。
-        
+
 .. py:class:: mindspore.common.initializer.XavierUniform(gain=1)
 
     生成一个数组用于初始化Tensor，数组中的数值从Xarvier均匀分布U[-boundary,boundary]中采样得到，其中
-    
+
     .. math::
         boundary = gain * \sqrt{\frac{6}{n_{in} + n_{out}}}
-	
+
     - :math:`gain` 是一个可选的缩放因子。
     - :math:`n_{in}` 为权重Tensor中输入单元的数量。
     - :math:`n_{out}` 为权重Tensor中输出单元的数量。
 
     有关 XavierUniform 算法的详细信息，请查看 http://proceedings.mlr.press/v9/glorot10a.html。
-    
-    **参数：** 
 
-    **gain** (float) - 可选的缩放因子，默认值为1。
+    **参数：**
+
+    - **gain** (float) - 可选的缩放因子，默认值为1。
 
 .. py:class:: mindspore.common.initializer.One(**kwargs)
 
     生成一个值全为1的常量数组用于初始化Tensor。
-       
+
 .. py:class:: mindspore.common.initializer.Zero(**kwargs)
 
     生成一个值全为0的常量数组用于初始化Tensor。
-       
+
 .. py:class:: mindspore.common.initializer.Constant(value)
-    
+
     生成一个常量数组用于初始化Tensor。
-    
+
     **参数：**
 
-    **value** (Union[int, numpy.ndarray]) - 用于初始化的常数值或者数组。
-    
+    - **value** (Union[int, numpy.ndarray]) - 用于初始化的常数值或者数组。

docs/api/api_python/mindspore.communication.rst

@@ -8,73 +8,73 @@ mindspore.communication
 
     - BACKEND：使用的通信库，HCCL或者NCCL。
     - GlobalComm：全局通信域。
-    
+
 .. py:method:: mindspore.communication.init(backend_name=None)
 
     初始化通信服务需要的分布式后端，例如HCCL或NCCL服务。
-    
+
     .. note::HCCL的全称是华为集合通信库（Huawei Collective Communication Library），NCCL的全称是英伟达集合通信库（NVIDIA Collective Communication Library）。`init` 方法应该在 `set_context` 方法之后使用。
-        
+
     **参数：**
 
-    **backend_name** (str) – 后台服务的名称，可选HCCL或NCCL。如果未设置则根据硬件平台类型（device_target）进行推断，默认值为None。
-        
+    - **backend_name** (str) – 后台服务的名称，可选HCCL或NCCL。如果未设置则根据硬件平台类型（device_target）进行推断，默认值为None。
+
     **异常：**
 
     - **TypeError** – 在参数 `backend_name` 不是字符串时抛出。
     - **RuntimeError** – 在以下情况将抛出：1）硬件设备类型无效；2）后台服务无效；3）分布式计算初始化失败；4）未设置环境变量 `RANK_ID` 或 `MINDSPORE_HCCL_CONFIG_PATH` 的情况下初始化HCCL服务。
     - **ValueError** – 在环境变量 `RANK_ID` 设置成非数字时抛出。
-        
+
     **样例：**
-            
+
     >>> from mindspore.context import set_context
-    >>> set_context(device_target="Ascend")       
+    >>> set_context(device_target="Ascend")
     >>> init()
 
 .. py:class:: mindspore.communication.release()
 
     释放分布式资源,例如‘HCCL’或‘NCCL’服务。
-    
+
     .. note::`release` 方法应该在 `init` 方法之后使用。
-        
+
     **异常：**
-    
-    **RuntimeError** - 在释放分布式资源失败时抛出。
-    
+
+    - **RuntimeError** - 在释放分布式资源失败时抛出。
+
 .. py:class:: mindspore.communication.get_rank(group=GlobalComm.WORLD_COMM_GROUP)
 
     在指定通信组中获取当前的设备序号。
-   
+
     .. note::`get_rank` 方法应该在 `init` 方法之后使用。
-        
+
     **参数：**
 
-    **group** (str) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组。默认值：‘WORLD_COMM_GROUP’。
-        
+    - **group** (str) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组。默认值：‘WORLD_COMM_GROUP’。
+
     **返回：**
 
     int, 调用该方法的进程对应的组内序号。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group` 不是字符串时抛出。
     - **ValueError** – 在后台不可用时抛出。
     - **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用时抛出。
-        
+
 .. py:class:: mindspore.communication.get_group_size(group=GlobalComm.WORLD_COMM_GROUP)
 
     获取指定通信组的设备总数。
-    
+
     .. note:: `get_group_size` 方法应该在 `init` 方法之后使用。
 
     **参数：**
 
-    **group** (str) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组。默认值：‘WORLD_COMM_GROUP’。
-        
+    - **group** (str) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组。默认值：‘WORLD_COMM_GROUP’。
+
     **返回：**
 
     int, 指定通信组的设备总数。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group` 不是字符串时抛出。
@@ -84,9 +84,9 @@ mindspore.communication
 .. py:class:: mindspore.communication.get_world_rank_from_group_rank(group, group_rank_id)
 
     由指定通信组中的设备序号获取通信集群中的全局设备序号。
-    
+
     .. note::
-        - GPU 版本的MindSpore不支持此方法； 
+        - GPU 版本的MindSpore不支持此方法；
         - 参数 `group` 不能是 `hccl_world_group`；
         - `get_world_rank_from_group_rank` 方法应该在 `init` 方法之后使用。
 
@@ -94,11 +94,11 @@ mindspore.communication
 
     - **group** (str) - 传入的通信组名称，通常由 `create_group` 方法创建。
     - **group_rank_id** (int) - 通信组内的设备序号。
-        
+
     **返回：**
 
     int, 通信集群中的全局设备序号。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group_rank_id` 不是数字或参数 `group` 不是字符串时抛出。
@@ -106,7 +106,7 @@ mindspore.communication
     - **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用，以及使用GPU版本的MindSpore时抛出。
 
     **样例：**
-             
+
     >>> from mindspore.context import set_context
     >>> set_context(device_target="Ascend")
     >>> init()
@@ -115,33 +115,33 @@ mindspore.communication
     >>> create_group(group, rank_ids)
     >>> world_rank_id = get_world_rank_from_group_rank(group, 1)
     >>> print("world_rank_id is: ", world_rank_id) # 全局设备序号为4
-            
+
 .. py:class:: mindspore.communication.get_group_rank_from_world_rank(world_rank_id, group)
 
     由通信集群中的全局设备序号获取指定用户通信组中的设备序号。
-    
+
     .. note::
-        - GPU 版本的MindSpore不支持此方法； 
+        - GPU 版本的MindSpore不支持此方法；
         - 参数 `group` 不能是 `hccl_world_group`；
         - `get_group_rank_from_world_rank` 方法应该在 `init` 方法之后使用。
-    
+
     **参数：**
 
     - **world_rank_id** (`int`) - 通信集群内的全局设备序号。
     - **group** (`str`) - 传入的通信组名称，通常由 `create_group` 方法创建。
-        
+
     **返回：**
 
     int, 当前用户通信组中的设备序号。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group_rank_id` 不是数字或参数 `group` 不是字符串时抛出。
     - **ValueError** – 在参数 `group` 是 `hccl_world_group` 或后台不可用时抛出。
     - **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用，以及使用GPU版本的MindSpore时抛出。
-    
+
     **样例：**
-                
+
     >>> from mindspore.context import set_context
     >>> set_context(device_target="Ascend")
     >>> init()
@@ -150,30 +150,30 @@ mindspore.communication
     >>> create_group(group, rank_ids)
     >>> group_rank_id = get_group_rank_from_world_rank(4, group)
     >>> print("group_rank_id is: ", group_rank_id) # 组内设备序号是1
-            
+
 .. py:class:: mindspore.communication.create_group(group, rank_ids)
 
     创建用户通信组。
-    
+
     .. note::
-        - GPU 版本的MindSpore不支持此方法； 
+        - GPU 版本的MindSpore不支持此方法；
         - 列表rank_ids的长度应大于1；
         - 列表rank_ids内不能有重复数据；
         - `create_group` 方法应该在 `init` 方法之后使用。
-        
+
     **参数：**
-    
+
     - **group** (str) - 将被创建的通信组名称。
     - **rank_ids** (list) - 设备编号列表。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group_rank_id` 不是数字或参数 `group` 不是字符串时抛出。
     - **ValueError** – 在列表rank_ids的长度小于1，或列表rank_ids内有重复数据，以及后台无效时抛出。
     - **RuntimeError** – 在‘HCCL’或‘NCCL’ 服务不可用，以及使用GPU版本的MindSpore时抛出。
-        
+
     **样例：**
-    
+
     >>> from mindspore.context import set_context
     >>> set_context(device_target="Ascend")
     >>> init()
@@ -184,19 +184,19 @@ mindspore.communication
 .. py:class:: mindspore.communication.get_local_rank(group=GlobalComm.WORLD_COMM_GROUP)
 
     获取指定通信组中当前设备的本地设备序号。
-    
+
     .. note::
-        - GPU 版本的MindSpore不支持此方法； 
+        - GPU 版本的MindSpore不支持此方法；
         - `get_local_rank` 方法应该在 `init` 方法之后使用。
-    
+
     **参数：**
 
-    **group** (`str`) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组名称。默认值：‘WORLD_COMM_GROUP’。
-    
+    - **group** (`str`) - 通信组名称，通常由 `create_group` 方法创建，否则将使用默认组名称。默认值：‘WORLD_COMM_GROUP’。
+
     **返回：**
 
     int, 调用该方法的进程对应的通信组内本地设备序号。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group` 不是字符串时抛出。
@@ -206,38 +206,38 @@ mindspore.communication
 .. py:class:: mindspore.communication.get_local_rank_size(group=GlobalComm.WORLD_COMM_GROUP)
 
     获取指定通信组的本地设备总数。
-    
+
     .. note::
         - GPU 版本的MindSpore不支持此方法；
         - `get_local_rank_size` 方法应该在 `init` 方法之后使用。
-        
+
     **参数：**
 
-    **group** (str) - 传入的通信组名称，通常由 `create_group` 方法创建，或默认使用‘WORLD_COMM_GROUP’。
-        
+    - **group** (str) - 传入的通信组名称，通常由 `create_group` 方法创建，或默认使用‘WORLD_COMM_GROUP’。
+
     **返回：**
 
     int, 调用该方法的进程对应的通信组设备总数。
-        
+
     **异常：**
 
     - **TypeError** – 在参数 `group` 不是字符串时抛出。
     - **ValueError** – 在后台不可用时抛出。
     - **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用时抛出。
-        
+
 .. py:class:: mindspore.communication.destroy_group(group)
 
     销毁用户通信组。
- 
+
     .. note::
-        - GPU 版本的MindSpore不支持此方法； 
+        - GPU 版本的MindSpore不支持此方法；
         - 参数 `group` 不能是 `hccl_world_group`；
-        - `destroy_group` 方法应该在 `init` 方法之后使用。    
-    
+        - `destroy_group` 方法应该在 `init` 方法之后使用。
+
     **参数：**
 
-    **group** (str) - 将被销毁的通信组，通常由 `create_group` 方法创建。
-        
+    - **group** (str) - 将被销毁的通信组，通常由 `create_group` 方法创建。
+
     **异常：**
 
     - **TypeError** – 在参数 `group` 不是字符串时抛出。

docs/api/api_python/mindspore.context.rst

@@ -16,7 +16,7 @@
 
     某些配置适用于特定的设备，有关详细信息，请参见下表：
 
-    +-------------------------+------------------------------+----------------------------+ 
+    +-------------------------+------------------------------+----------------------------+
     | Function Classification |   Configuration Parameters   |   Hardware Platform Support|
     +=========================+==============================+============================+
     | System Configuration    |   device_id                  |   CPU/GPU/Ascend           |
@@ -73,20 +73,20 @@
     +-------------------------+------------------------------+----------------------------+
 
     **参数：**
-    
-    - **device_id** (int)：表示目标设备的ID，其值必须在[0, device_num_per_host-1]范围中，且 `device_num_per_host` 的值不应超过4096。默认值：0。
-    - **device_target** (str)：表示待运行的目标设备，支持Ascend、GPU和CPU。如果未设置设备目标，则使用MindSpore包的版本。
-    - **max_device_memory** (str)：设置设备可用的最大内存。目前，仅在GPU上支持。格式为“xxGB”。默认值：1024GB。实际使用的内存大小是设备的可用内存和 `max_device_memory` 值中的最小值。
-    - **variable_memory_max_size** (str)：设置可变内存的最大值。默认值：30GB。设置此参数后，框架使用的最大内存受配置值的限制。
-    - **save_graphs** (bool)：表示是否保存图形。默认值：False。当 `save_graphs` 属性设为True时， `save_graphs_path` 属性用于设置中间编译图的存储路径。默认情况下，图形保存在当前目录下。
-    - **save_graphs_path** (str)：表示保存图形的路径。默认值："."。如果指定的目录不存在，系统将自动创建该目录。在分布式训练中，图形将被保存到 `save_graphs_path/rank_${rank_id}/` 目录下。 `rank_id` 为集群中当前设备的ID。
-    - **enable_dump** (bool)：此参数已弃用，将在下一版本中删除。
-    - **save_dump_path** (str)：此参数已弃用，将在下一版本中删除。
-    - **enable_profiling** (bool)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
-    - **profiling_options** (str)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
-    - **print_file_path** (str)：表示用于保存打印数据的路径。如果设置了该参数，默认将打印数据保存到文件中。如果不设置 `print_file_path` ，则显示该屏幕。如果保存的文件已经存在，将添加时间戳后缀到文件中。将数据保存到文件中，解决了在产生大量数据时屏幕打印中数据丢失的问题。如果没有设置该参数，则会报错：prompt to set the upper absolute path。
-    - **env_config_path** (str)：通过context.set_context(env_config_path="./mindspore_config.json")来配置DFX的路径。
-        
+
+    - **device_id** (int) - 表示目标设备的ID，其值必须在[0, device_num_per_host-1]范围中，且 `device_num_per_host` 的值不应超过4096。默认值：0。
+    - **device_target** (str) - 表示待运行的目标设备，支持Ascend、GPU和CPU。如果未设置设备目标，则使用MindSpore包的版本。
+    - **max_device_memory** (str) - 设置设备可用的最大内存。目前，仅在GPU上支持。格式为“xxGB”。默认值：1024GB。实际使用的内存大小是设备的可用内存和 `max_device_memory` 值中的最小值。
+    - **variable_memory_max_size** (str) - 设置可变内存的最大值。默认值：30GB。设置此参数后，框架使用的最大内存受配置值的限制。
+    - **save_graphs** (bool) - 表示是否保存图形。默认值：False。当 `save_graphs` 属性设为True时， `save_graphs_path` 属性用于设置中间编译图的存储路径。默认情况下，图形保存在当前目录下。
+    - **save_graphs_path** (str) - 表示保存图形的路径。默认值："."。如果指定的目录不存在，系统将自动创建该目录。在分布式训练中，图形将被保存到 `save_graphs_path/rank_${rank_id}/` 目录下。 `rank_id` 为集群中当前设备的ID。
+    - **enable_dump** (bool) - 此参数已弃用，将在下一版本中删除。
+    - **save_dump_path** (str) - 此参数已弃用，将在下一版本中删除。
+    - **enable_profiling** (bool) - 此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
+    - **profiling_options** (str) - 此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
+    - **print_file_path** (str) - 表示用于保存打印数据的路径。如果设置了该参数，默认将打印数据保存到文件中。如果不设置 `print_file_path` ，则显示该屏幕。如果保存的文件已经存在，将添加时间戳后缀到文件中。将数据保存到文件中，解决了在产生大量数据时屏幕打印中数据丢失的问题。如果没有设置该参数，则会报错：prompt to set the upper absolute path。
+    - **env_config_path** (str) - 通过context.set_context(env_config_path="./mindspore_config.json")来配置DFX的路径。
+
       配置Running Data Recorder：
 
       - **enable**：表示在发生故障时是否启用Running Data Recorder去收集和保存训练中的关键数据。设置为True时，将打开Running Data Recorder。设置为False时，将关闭Running Data Recorder。
@@ -96,17 +96,17 @@
 
       - **mem_Reuse**：表示内存复用功能是否打开。设置为True时，将打开内存复用功能。设置为False时，将关闭内存复用功能。
 
-    - **precompile_only** (bool)：表示是否仅预编译网络。默认值：False。设置为True时，仅编译网络，而不执行网络。
-    - **reserve_class_name_in_scope** (bool)：表示是否将网络类名称保存到所属作用域中。默认值：True。每个节点都有一个作用域。子节点的作用域是其父节点。如果 `reserve_class_name_in_scope` 设置为True，则类名将保存在作用域中的关键字“net-”之后。例如：
+    - **precompile_only** (bool) - 表示是否仅预编译网络。默认值：False。设置为True时，仅编译网络，而不执行网络。
+    - **reserve_class_name_in_scope** (bool) - 表示是否将网络类名称保存到所属作用域中。默认值：True。每个节点都有一个作用域。子节点的作用域是其父节点。如果 `reserve_class_name_in_scope` 设置为True，则类名将保存在作用域中的关键字“net-”之后。例如：
 
       Default/net-Net1/net-Net2 (reserve_class_name_in_scope=True)
 
       Default/net/net (reserve_class_name_in_scope=False)
 
-    - **pynative_synchronize** (bool)：表示是否在PyNative模式下启动设备同步执行。默认值：False。设置为False时，将在设备上异步执行算子。当算子执行出错时，将无法定位特定错误脚本代码的位置。当设置为True时，将在设备上同步执行算子。这将降低程序的执行性能。此时，当算子执行出错时，可以根据错误的调用栈来定位错误脚本代码的位置。
-    - **mode** (int)：表示在GRAPH_MODE(0)或PYNATIVE_MODE(1)模式中的运行。默认值：GRAPH_MODE(0)。GRAPH_MODE或PYNATIVE_MODE可以通过 `mode` 属性设置，两种模式都支持所有后端。默认模式为GRAPH_MODE。
-    - **enable_graph_kernel** (bool)：表示是否启用图算融合去优化网络执行性能。默认值：False。表示是否启用图算融合去优化网络执行性能。如果 `enable_graph_kernel` 设置为True，则可以启用加速。有关图算融合的详细信息，请查看 `使能图算融合 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_graph_kernel_fusion.html>`_ 。
-    - **graph_kernel_flags** (str)：图算融合的优化选项，当与enable_graph_kernel冲突时，它的优先级更高。其仅适用于有经验的用户。例如，context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")。一些常用选项：
+    - **pynative_synchronize** (bool) - 表示是否在PyNative模式下启动设备同步执行。默认值：False。设置为False时，将在设备上异步执行算子。当算子执行出错时，将无法定位特定错误脚本代码的位置。当设置为True时，将在设备上同步执行算子。这将降低程序的执行性能。此时，当算子执行出错时，可以根据错误的调用栈来定位错误脚本代码的位置。
+    - **mode** (int) - 表示在GRAPH_MODE(0)或PYNATIVE_MODE(1)模式中的运行。默认值：GRAPH_MODE(0)。GRAPH_MODE或PYNATIVE_MODE可以通过 `mode` 属性设置，两种模式都支持所有后端。默认模式为GRAPH_MODE。
+    - **enable_graph_kernel** (bool) - 表示是否启用图算融合去优化网络执行性能。默认值：False。表示是否启用图算融合去优化网络执行性能。如果 `enable_graph_kernel` 设置为True，则可以启用加速。有关图算融合的详细信息，请查看 `使能图算融合 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_graph_kernel_fusion.html>`_ 。
+    - **graph_kernel_flags** (str) - 图算融合的优化选项，当与enable_graph_kernel冲突时，它的优先级更高。其仅适用于有经验的用户。例如，context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")。一些常用选项：
 
       - **opt_level**：设置优化级别。默认值：2。当opt_level的值大于0时，启动图算融合。可选值包括：
 
@@ -119,22 +119,22 @@
 
         有关更多选项，可以参考实现代码。
 
-    - **enable_reduce_precision** (bool)：表示是否开启降低精度计算。默认值：True。设置为True时，不支持用户指定的精度，且精度将自动更改。设置为False时，如果未指定用例的精度，则会报错并退出。
-    - **auto_tune_mode** (str)：表示算子构建时的自动调整模式，以获得最佳的切分性能。默认值：NO_TUNE。其值必须在['RL', 'GA', 'RL,GA']范围中。
+    - **enable_reduce_precision** (bool) - 表示是否开启降低精度计算。默认值：True。设置为True时，不支持用户指定的精度，且精度将自动更改。设置为False时，如果未指定用例的精度，则会报错并退出。
+    - **auto_tune_mode** (str) - 表示算子构建时的自动调整模式，以获得最佳的切分性能。默认值：NO_TUNE。其值必须在['RL', 'GA', 'RL,GA']范围中。
 
       - RL：强化学习调优。
       - GA：遗传算法调优。
       - RL，GA：当RL和GA优化同时打开时，工具会根据网络模型中的不同算子类型自动选择RL或GA。RL和GA的顺序没有区别。（自动选择）。
 
-        
-    有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_auto_tune.html>`_。
 
-    - **check_bprop** (bool)：表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。
-    - **max_call_depth** (int)：指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。
-    - **enable_sparse** (bool)：表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/tensor.html#sparse-tensor>`_。
+      有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_auto_tune.html>`_。
+
+    - **check_bprop** (bool) - 表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。
+    - **max_call_depth** (int) - 指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。
+    - **enable_sparse** (bool) - 表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/tensor.html#sparse-tensor>`_。
     - **grad_for_scalar** (bool)：  表示是否获取标量梯度。默认值：False。当 `grad_for_scalar` 设置为True时，则衍生函数的标量输入。默认值为False。由于后端目前不支持伸缩操作，所以该接口只支持在前端可推演的简单操作。
-    - **enable_compile_cache** (bool)：表示是否加载或者保存前端编译的图。当 `enable_compile_cache` 被设置为True时，在第一次执行的过程中，一个硬件无关的编译缓存会被生成并且导出为一个MINDIR文件。当该网络被再次执行时，如果 `enable_compile_cache` 仍然为True并且网络脚本没有被更改，那么这个编译缓存会被加载。注意目前只支持有限的Python脚本更改的自动检测，这意味着可能有正确性风险。默认值：False。这是一个实验原型，可能会被更改或者删除。
-    - **compile_cache_path** (str)：保存前端图编译缓存的路径。默认值："."。如果目录不存在，系统会自动创建这个目录。缓存会被保存到如下目录：`compile_cache_path/rank_${rank_id}/` 。 `rank_id` 是集群上当前设备的ID。
+    - **enable_compile_cache** (bool) - 表示是否加载或者保存前端编译的图。当 `enable_compile_cache` 被设置为True时，在第一次执行的过程中，一个硬件无关的编译缓存会被生成并且导出为一个MINDIR文件。当该网络被再次执行时，如果 `enable_compile_cache` 仍然为True并且网络脚本没有被更改，那么这个编译缓存会被加载。注意目前只支持有限的Python脚本更改的自动检测，这意味着可能有正确性风险。默认值：False。这是一个实验原型，可能会被更改或者删除。
+    - **compile_cache_path** (str) - 保存前端图编译缓存的路径。默认值："."。如果目录不存在，系统会自动创建这个目录。缓存会被保存到如下目录：`compile_cache_path/rank_${rank_id}/` 。 `rank_id` 是集群上当前设备的ID。
 
     **异常：**
 
@@ -173,7 +173,7 @@
 
     **参数：**
 
-    **attr_key** (str)：属性的key。
+    - **attr_key** (str) - 属性的key。
 
     **返回：**
 
@@ -194,7 +194,7 @@
 
     应在init之前配置自动并行。
 
-    .. note:: 
+    .. note::
         配置时，必须输入配置的名称。如果某个程序具有不同并行模式下的任务，则需要再为下一个任务设置新的并行模式之前，调用reset_auto_parallel_context()接口来重置配置。若要设置或更改并行模式，必须在创建任何Initializer之前调用接口，否则，在编译网络时，可能会出现RuntimeError。
 
     某些配置适用于特定的并行模式，有关详细信息，请参见下表：
@@ -214,11 +214,11 @@
 
     **参数：**
 
-    - **device_num** (int)：表示可用设备的编号，必须在[1,4096]范围中。默认值：1。
-    - **global_rank** (int)：表示全局RANK的ID，必须在[0,4095]范围中。默认值：0。
-    - **gradients_mean** (bool)：表示是否在梯度的 AllReduce后执行平均算子。stand_alone不支持gradients_mean。默认值：False。
+    - **device_num** (int) - 表示可用设备的编号，必须在[1,4096]范围中。默认值：1。
+    - **global_rank** (int) - 表示全局RANK的ID，必须在[0,4095]范围中。默认值：0。
+    - **gradients_mean** (bool) - 表示是否在梯度的 AllReduce后执行平均算子。stand_alone不支持gradients_mean。默认值：False。
     - **gradient_fp32_sync** (bool)：在FP32中运行梯度的 AllReduce。stand_alone、data_parallel和hybrid_parallel不支持gradient_fp32_sync。默认值：True。
-    - **parallel_mode** (str)：有五种并行模式，分别是stand_alone、data_parallel、hybrid_parallel、semi_auto_parallel和auto_parallel。默认值：stand_alone。
+    - **parallel_mode** (str) - 有五种并行模式，分别是stand_alone、data_parallel、hybrid_parallel、semi_auto_parallel和auto_parallel。默认值：stand_alone。
 
       - stand_alone：单卡模式。
       - data_parallel：数据并行模式。
@@ -226,20 +226,20 @@
       - semi_auto_parallel：半自动并行模式。
       - auto_parallel：自动并行模式。
 
-    - **auto_parallel_search_mode** (str)：表示有两种策略搜索模式，分别是recursive_programming和dynamic_programming。默认值：dynamic_programming。
+    - **auto_parallel_search_mode** (str) - 表示有两种策略搜索模式，分别是recursive_programming和dynamic_programming。默认值：dynamic_programming。
 
       - recursive_programming：表示双递归搜索模式。
       - dynamic_programming：表示动态规划搜索模式。
 
-    - **parameter_broadcast** (bool)：表示在训练前是否广播参数。在训练之前，为了使所有设备的网络初始化参数值相同，请将设备0上的参数广播到其他设备。不同并行模式下的参数广播不同。在data_parallel模式下，除layerwise_parallel属性为True的参数外，所有参数都会被广播。在hybrid_parallel、semi_auto_parallel和auto_parallel模式下，分段参数不参与广播。默认值：False。
-    - **strategy_ckpt_load_file** (str)：表示用于加载并行策略checkpoint的路径。默认值：''。
-    - **strategy_ckpt_save_file** (str)：表示用于保存并行策略checkpoint的路径。默认值：''。
-    - **full_batch** (bool)：如果在auto_parallel模式下加载整个batch数据集，则此参数应设置为True。默认值：False。目前不建议使用该接口，建议使用dataset_strategy来替换它。
-    - **dataset_strategy** (Union[str, tuple])：表示数据集分片策略。默认值：data_parallel。dataset_strategy="data_parallel"等于full_batch=False，dataset_strategy="full_batch"等于full_batch=True。对于通过模型并列策略加载到网络的数据集，如ds_stra ((1, 8)、(1, 8))，需要使用set_auto_parallel_context(dataset_strategy=ds_stra)。
-    - **enable_parallel_optimizer** (bool)：这是一个开发中的特性，它可以为数据并行训练对权重更新计算进行分片，以节省时间和内存。目前，自动和半自动并行模式支持Ascend和GPU中的所有优化器。数据并行模式仅支持Ascend中的 `Lamb` 和 `AdamWeightDecay` 。默认值：False。
-    - **all_reduce_fusion_config** (list)：通过参数索引设置 AllReduce 融合策略。仅支持ReduceOp.SUM和HCCL_WORLD_GROUP/NCCL_WORLD_GROUP。没有默认值。如果不设置，则关闭算子融合。
-    - **pipeline_stages** (int)：设置pipeline并行的阶段信息。这表明了设备如何单独分布在pipeline上。所有的设备将被划分为pipeline_stags个阶段。目前，这只能在启动semi_auto_parallel模式的情况下使用。默认值：1。
-    - **grad_accumulation_step** (int)：在自动和半自动并行模式下设置梯度的累积step。其值应为正整数。默认值：1。
+    - **parameter_broadcast** (bool) - 表示在训练前是否广播参数。在训练之前，为了使所有设备的网络初始化参数值相同，请将设备0上的参数广播到其他设备。不同并行模式下的参数广播不同。在data_parallel模式下，除layerwise_parallel属性为True的参数外，所有参数都会被广播。在hybrid_parallel、semi_auto_parallel和auto_parallel模式下，分段参数不参与广播。默认值：False。
+    - **strategy_ckpt_load_file** (str) - 表示用于加载并行策略checkpoint的路径。默认值：''。
+    - **strategy_ckpt_save_file** (str) - 表示用于保存并行策略checkpoint的路径。默认值：''。
+    - **full_batch** (bool) - 如果在auto_parallel模式下加载整个batch数据集，则此参数应设置为True。默认值：False。目前不建议使用该接口，建议使用dataset_strategy来替换它。
+    - **dataset_strategy** (Union[str, tuple]) - 表示数据集分片策略。默认值：data_parallel。dataset_strategy="data_parallel"等于full_batch=False，dataset_strategy="full_batch"等于full_batch=True。对于通过模型并列策略加载到网络的数据集，如ds_stra ((1, 8)、(1, 8))，需要使用set_auto_parallel_context(dataset_strategy=ds_stra)。
+    - **enable_parallel_optimizer** (bool) - 这是一个开发中的特性，它可以为数据并行训练对权重更新计算进行分片，以节省时间和内存。目前，自动和半自动并行模式支持Ascend和GPU中的所有优化器。数据并行模式仅支持Ascend中的 `Lamb` 和 `AdamWeightDecay` 。默认值：False。
+    - **all_reduce_fusion_config** (list) - 通过参数索引设置 AllReduce 融合策略。仅支持ReduceOp.SUM和HCCL_WORLD_GROUP/NCCL_WORLD_GROUP。没有默认值。如果不设置，则关闭算子融合。
+    - **pipeline_stages** (int) - 设置pipeline并行的阶段信息。这表明了设备如何单独分布在pipeline上。所有的设备将被划分为pipeline_stags个阶段。目前，这只能在启动semi_auto_parallel模式的情况下使用。默认值：1。
+    - **grad_accumulation_step** (int) - 在自动和半自动并行模式下设置梯度的累积step。其值应为正整数。默认值：1。
 
     **异常：**
 
@@ -267,7 +267,7 @@
 
     **参数：**
 
-    **attr_key** (str)：配置的key。
+    - **attr_key** (str) - 配置的key。
 
     **返回：**
 
@@ -312,7 +312,7 @@
 
     设置参数服务器训练模式的上下文。
 
-    .. note:: 
+    .. note::
         需要给参数服务器训练模式设置其他的环境变量。些环境变量如下所示：
 
         - MS_SERVER_NUM：表示参数服务器数量。
@@ -327,12 +327,12 @@
 
     **参数：**
 
-    - **enable_ps** (bool)：表示是否启用参数服务器训练模式。只有在enable_ps设置为True后，环境变量才会生效。默认值：False。
-    - **config_file_path** (string)：配置文件路径，用于容灾恢复等。默认值：''。
-    - **scheduler_manage_port** (int)：调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。默认值：11202。
-    - **enable_ssl** (bool)：设置是否打开SSL认证。默认值：True。
-    - **client_password** (str)：用于解密客户端证书密钥的密码。默认值：''。
-    - **server_password** (str)：用于解密服务端证书密钥的密码。默认值：''。
+    - **enable_ps** (bool) - 表示是否启用参数服务器训练模式。只有在enable_ps设置为True后，环境变量才会生效。默认值：False。
+    - **config_file_path** (string) - 配置文件路径，用于容灾恢复等。默认值：''。
+    - **scheduler_manage_port** (int) - 调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。默认值：11202。
+    - **enable_ssl** (bool) - 设置是否打开SSL认证。默认值：True。
+    - **client_password** (str) - 用于解密客户端证书密钥的密码。默认值：''。
+    - **server_password** (str) - 用于解密服务端证书密钥的密码。默认值：''。
 
 
     **异常：**
@@ -349,7 +349,7 @@
 
     **参数：**
 
-    **attr_key** (str)：属性的key。
+    - **attr_key** (str) - 属性的key。
 
     - enable_ps (bool)：表示是否启用参数服务器训练模式。
     - config_file_path (string)：配置文件路径，用于容灾恢复等。
@@ -369,7 +369,7 @@
     **样例：**
 
     >>> context.get_ps_context(enable_ps)
-    
+
 
 .. py:function:: reset_ps_context()
 

docs/api/api_python/mindspore.nn.probability.rst

@@ -24,7 +24,7 @@ Distributions
 
 .. cnmsplatformautosummary::
     :toctree: nn_probability
-    
+
     mindspore.nn.probability.distribution.Bernoulli
     mindspore.nn.probability.distribution.Beta
     mindspore.nn.probability.distribution.Categorical

docs/api/api_python/mindspore.nn.rst

@@ -9,33 +9,6 @@ Cell
 
     mindspore.nn.Cell
 
-Dynamic Learning Rate
----------------------
-
-.. cnmsplatformautosummary::
-    :toctree: nn
-
-    mindspore.nn.cosine_decay_lr
-    mindspore.nn.exponential_decay_lr
-    mindspore.nn.inverse_decay_lr
-    mindspore.nn.natural_exp_decay_lr
-    mindspore.nn.piecewise_constant_lr
-    mindspore.nn.polynomial_decay_lr
-    mindspore.nn.warmup_lr
-
-Dynamic Learning Rate
----------------------
-
-.. cnmsplatformautosummary::
-    :toctree: nn
-
-    mindspore.nn.CosineDecayLR
-    mindspore.nn.ExponentialDecayLR
-    mindspore.nn.InverseDecayLR
-    mindspore.nn.NaturalExpDecayLR
-    mindspore.nn.PolynomialDecayLR
-    mindspore.nn.WarmUpLR
-
 Gradient
 ---------
 
@@ -45,28 +18,6 @@ Gradient
     mindspore.nn.Jvp
     mindspore.nn.Vjp
 
-Metrics
---------
-
-.. cnmsplatformautosummary::
-    :toctree: nn
-
-    mindspore.nn.Accuracy
-    mindspore.nn.F1
-    mindspore.nn.Fbeta
-    mindspore.nn.Loss
-    mindspore.nn.MAE
-    mindspore.nn.MSE
-    mindspore.nn.Metric
-    mindspore.nn.Precision
-    mindspore.nn.Recall
-    mindspore.nn.Top1CategoricalAccuracy
-    mindspore.nn.Top5CategoricalAccuracy
-    mindspore.nn.TopKCategoricalAccuracy
-    mindspore.nn.get_metric_fn
-    mindspore.nn.names
-    mindspore.nn.rearrange_inputs
-
 Non-linear Activations
 ----------------------
 
@@ -76,8 +27,8 @@ Non-linear Activations
     mindspore.nn.FastGelu
     mindspore.nn.HSwish
     mindspore.nn.ReLU
-    mindspore.nn.elu
-    mindspore.nn.gelu
+    mindspore.nn.ELU
+    mindspore.nn.GELU
 
 Optimizer Functions
 -------------------
@@ -113,4 +64,56 @@ Wrapper Functions
     mindspore.nn.TrainOneStepCell
     mindspore.nn.TrainOneStepWithLossScaleCell
     mindspore.nn.WithEvalCell
-    mindspore.nn.WithLossCell
+    mindspore.nn.WithLossCell
+
+Metrics
+--------
+
+.. cnmsautosummary::
+    :toctree: nn
+
+    mindspore.nn.Accuracy
+    mindspore.nn.F1
+    mindspore.nn.Fbeta
+    mindspore.nn.Loss
+    mindspore.nn.MAE
+    mindspore.nn.MSE
+    mindspore.nn.Metric
+    mindspore.nn.Precision
+    mindspore.nn.Recall
+    mindspore.nn.Top1CategoricalAccuracy
+    mindspore.nn.Top5CategoricalAccuracy
+    mindspore.nn.TopKCategoricalAccuracy
+    mindspore.nn.get_metric_fn
+    mindspore.nn.names
+    mindspore.nn.rearrange_inputs
+
+Dynamic Learning Rate
+---------------------
+
+LearningRateSchedule
+^^^^^^^^^^^^^^^^^^^^^
+
+.. cnmsplatformautosummary::
+    :toctree: nn
+
+    mindspore.nn.CosineDecayLR
+    mindspore.nn.ExponentialDecayLR
+    mindspore.nn.InverseDecayLR
+    mindspore.nn.NaturalExpDecayLR
+    mindspore.nn.PolynomialDecayLR
+    mindspore.nn.WarmUpLR
+
+Dynamic LR
+^^^^^^^^^^
+
+.. cnmsautosummary::
+    :toctree: nn
+
+    mindspore.nn.cosine_decay_lr
+    mindspore.nn.exponential_decay_lr
+    mindspore.nn.inverse_decay_lr
+    mindspore.nn.natural_exp_decay_lr
+    mindspore.nn.piecewise_constant_lr
+    mindspore.nn.polynomial_decay_lr
+    mindspore.nn.warmup_lr

docs/api/api_python/mindspore.ops.rst

@@ -17,18 +17,6 @@ Neural Network Operators
     mindspore.ops.SeLU
     mindspore.ops.Sigmoid
 
-Array Operators
-----------------
-
-.. cnmsplatformautosummary::
-    :toctree: ops
-
-    mindspore.ops.OnesLike
-    mindspore.ops.Reshape
-    mindspore.ops.Size
-    mindspore.ops.Tile
-    mindspore.ops.ZerosLike
-
 Math Operators
 --------------
 
@@ -47,12 +35,24 @@ Math Operators
     mindspore.ops.Pow
     mindspore.ops.Sub
 
+Array Operators
+----------------
+
+.. cnmsplatformautosummary::
+    :toctree: ops
+
+    mindspore.ops.OnesLike
+    mindspore.ops.Reshape
+    mindspore.ops.Size
+    mindspore.ops.Tile
+    mindspore.ops.ZerosLike
+
 
 Random Operators
 ----------------
 
 .. cnmsplatformautosummary::
     :toctree: ops
-    
+
     mindspore.ops.Gamma
     mindspore.ops.UniformReal

docs/api/api_python/mindspore.rst

@@ -7,9 +7,18 @@ Tensor
 .. cnmsautosummary::
     :toctree: mindspore
 
+    mindspore.Tensor
     mindspore.RowTensor
     mindspore.SparseTensor
-    mindspore.Tensor
+
+Parameter
+---------
+
+.. cnmsautosummary::
+    :toctree: mindspore
+
+    mindspore.Parameter
+    mindspore.ParameterTuple
 
 DataType
 --------
@@ -17,54 +26,48 @@ DataType
 .. cnmsautosummary::
     :toctree: mindspore
 
+    mindspore.dtype
     mindspore.dtype_to_nptype
     mindspore.dtype_to_pytype
     mindspore.get_py_obj_dtype
-    mindspore.issubclass\_
+    mindspore.issubclass_
     mindspore.pytype_to_dtype
 
-Installation Verification
---------------------------
-
-.. cnmsautosummary::
-    :toctree: mindspore
-    
-    mindspore.run_check
-
-Parameter
----------
+Seed
+----
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.Parameter
-    mindspore.ParameterTuple
+    mindspore.get_seed
+    mindspore.set_seed
 
-Log
----
+Model
+-----
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.get_level
-    mindspore.get_log_config
+    mindspore.Model
 
-Model
------
+Dataset Helper
+---------------
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.Model
+    mindspore.DatasetHelper
+    mindspore.connect_network_with_dataset
 
-Seed
-----
+Loss Scale Manager
+------------------
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.get_seed
-    mindspore.set_seed
+    mindspore.DynamicLossScaleManager
+    mindspore.FixedLossScaleManager
+    mindspore.LossScaleManager
 
 Serialization
 --------------
@@ -88,21 +91,19 @@ JIT
 
     mindspore.ms_function
 
-Dataset Helper
----------------
+Log
+---
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.DatasetHelper
-    mindspore.connect_network_with_dataset
+    mindspore.get_level
+    mindspore.get_log_config
 
-Loss Scale Manager
-------------------
+Installation Verification
+--------------------------
 
 .. cnmsautosummary::
     :toctree: mindspore
 
-    mindspore.DynamicLossScaleManager
-    mindspore.FixedLossScaleManager
-    mindspore.LossScaleManager
+    mindspore.run_check

docs/api/api_python/mindspore.train/mindspore.train.callback.Callback.rst

@@ -31,45 +31,44 @@
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: end(run_context)
 
         网络执行后被调用一次。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: epoch_begin(run_context)
 
         在每个epoch开始之前被调用。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: epoch_end(run_context)
 
         在每个epoch结束后被调用。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: step_begin(run_context)
 
         在每个step开始之前被调用。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: step_end(run_context)
 
         在每个step完成后被调用。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。

docs/api/api_python/mindspore.train/mindspore.train.callback.CheckpointConfig.rst

@@ -2,7 +2,7 @@
 
     保存checkpoint时的配置策略。
 
-    .. note:: 
+    .. note::
         在训练过程中，如果数据集是通过数据通道传输的，建议将 `save_checkpoint_steps` 设为循环下沉step数量的整数倍数，否则，保存checkpoint的时机可能会有偏差。建议同时只设置一种触发保存checkpoint策略和一种保留checkpoint文件总数策略。如果同时设置了 `save_checkpoint_steps` 和 `save_checkpoint_seconds` ，则 `save_checkpoint_seconds` 无效。如果同时设置了 `keep_checkpoint_max` 和 `keep_checkpoint_per_n_minutes` ，则 `keep_checkpoint_per_n_minutes` 无效。
 
     **参数：**
@@ -20,7 +20,7 @@
 
     **异常：**
 
-    **ValueError** - 输入参数的类型不正确。
+    - **ValueError** - 输入参数的类型不正确。
 
     **样例：**
 
@@ -57,7 +57,7 @@
     >>> config = CheckpointConfig(saved_network=net)
     >>> ckpoint_cb = ModelCheckpoint(prefix='LeNet5', directory='./checkpoint', config=config)
     >>> model.train(10, dataset, callbacks=ckpoint_cb)
-    
+
 
     .. py:method:: append_dict
         :property:
@@ -100,7 +100,7 @@
 
     .. py:method:: saved_network
         :property:
-        
+
         获取_保存的网络。
 
     .. py:method:: save_checkpoint_seconds

docs/api/api_python/mindspore.train/mindspore.train.callback.LearningRateScheduler.rst

@@ -4,7 +4,7 @@
 
     **参数：**
 
-    **learning_rate_function** (Function) - 在训练期间更改学习率的函数。
+    - **learning_rate_function** (Function) - 在训练期间更改学习率的函数。
 
     **样例：**
 
@@ -27,12 +27,11 @@
     >>> dataset = create_custom_dataset("custom_dataset_path")
     >>> model.train(1, dataset, callbacks=[LearningRateScheduler(learning_rate_function)],
     ...             dataset_sink_mode=False)
-    
+
     .. py:method:: step_end(run_context)
 
         在step结束时更改学习率。
 
         **参数：**
-        
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+
+        - **run_context** (RunContext) - 包含模型的一些基本信息。

docs/api/api_python/mindspore.train/mindspore.train.callback.LossMonitor.rst

@@ -4,22 +4,21 @@
 
     如果loss是NAN或INF，则终止训练。
 
-    .. note:: 
+    .. note::
         如果 `per_print_times` 为0，则不打印loss。
 
     **参数：**
 
-    **per_print_times** (int) - 表示每隔多少个step打印一次loss。默认值：1。
+    - **per_print_times** (int) - 表示每隔多少个step打印一次loss。默认值：1。
 
     **异常：**
 
-    **ValueError** - 当 `per_print_times` 不是整数或小于零。
-    
+    - **ValueError** - 当 `per_print_times` 不是整数或小于零。
+
     .. py:method:: step_end(run_context)
 
         step结束时打印训练loss。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。

docs/api/api_python/mindspore.train/mindspore.train.callback.ModelCheckpoint.rst

@@ -4,7 +4,7 @@
 
     在训练过程中调用该方法可以保存训练后的网络参数。
 
-    .. note:: 
+    .. note::
         在分布式训练场景下，请为每个训练进程指定不同的目录来保存checkpoint文件。否则，可能会训练失败。
 
     **参数：**
@@ -17,14 +17,14 @@
 
     - **ValueError** - 如果前缀无效。
     - **TypeError** - config不是CheckpointConfig类型。
-    
+
     .. py:method:: end(run_context)
 
         在训练结束后，会保存最后一个step的checkpoint。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
 
     .. py:method:: latest_ckpt_file_name
         :property:
@@ -36,6 +36,5 @@
         在step结束时保存checkpoint。
 
         **参数：**
-        
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+
+        - **run_context** (RunContext) - 包含模型的一些基本信息。

docs/api/api_python/mindspore.train/mindspore.train.callback.RunContext.rst

@@ -7,27 +7,26 @@
 
     **参数：**
 
-    **original_args** (dict) - 模型的相关信息。
-    
+    - **original_args** (dict) - 模型的相关信息。
+
     .. py:method:: get_stop_requested()
 
         获取是否停止训练标志。
 
         **返回：**
-        
+
         bool，如果为True，则 `Model.train()` 停止迭代。
-        
+
     .. py:method:: original_args()
 
         获取模型的相关信息。
 
         **返回：**
-        
+
         dict，模型的相关信息。
-        
+
     .. py:method:: request_stop()
 
         在训练期间设置停止请求。
 
         可以使用此函数请求停止训练。 `Model.train()` 会检查是否调用此函数。
-        

docs/api/api_python/mindspore.train/mindspore.train.callback.TimeMonitor.rst

@@ -3,26 +3,25 @@
     监控训练时间。
 
     **参数：**
-    
-    **data_size** (int) - 表示每隔多少个step打印一次信息。如果程序在训练期间获取到Model的 `batch_num` ，则将把 `data_size` 设为 `batch_num` ，否则将使用 `data_size` 。默认值：None。
+
+    - **data_size** (int) - 表示每隔多少个step打印一次信息。如果程序在训练期间获取到Model的 `batch_num` ，则将把 `data_size` 设为 `batch_num` ，否则将使用 `data_size` 。默认值：None。
 
     **异常：**
 
-    **ValueError** - `data_size` 不是正整数。
-    
+    - **ValueError** - `data_size` 不是正整数。
+
     .. py:method:: epoch_begin(run_context)
 
         在epoch开始时记录时间。
 
         **参数：**
-        
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+
+        - **run_context** (RunContext) - 包含模型的一些基本信息。
+
     .. py:method:: epoch_end(run_context)
 
         在epoch结束时打印epoch的耗时。
 
         **参数：**
 
-        **run_context** (RunContext) - 包含模型的一些基本信息。
-        
+        - **run_context** (RunContext) - 包含模型的一些基本信息。

docs/api/api_python/mindspore.train/mindspore.train.summary.SummaryRecord.rst

@@ -13,15 +13,15 @@
 
     **参数：**
 
-    - **log_dir** (str)：`log_dir` 是用来保存summary的目录。
-    - **file_prefix** (str)：文件的前缀。默认值：events。
-    - **file_suffix** (str)：文件的后缀。默认值：_MS。
-    - **network** (Cell)：通过网络获取用于保存图形summary的管道。默认值：None。
-    - **max_file_size** (int, optional)：可写入磁盘的每个文件的最大大小（以字节为单位）。例如，如果不大于4GB，则设置 `max_file_size=4*1024**3` 。默认值：None，表示无限制。
-    - **raise_exception** (bool, 可选)：设置在记录数据中发生RuntimeError或OSError异常时是否抛出异常。默认值：False，表示打印错误日志，不抛出异常。
-    - **export_options** (Union[None, dict])：可以将保存在summary中的数据导出，并使用字典自定义所需的数据和文件格式。注：导出的文件大小不受 `max_file_size` 的限制。例如，您可以设置{'tensor_format':'npy'}将Tensor导出为NPY文件。支持控制的数据如下所示。默认值：None，表示不导出数据。
+    - **log_dir** (str) - `log_dir` 是用来保存summary的目录。
+    - **file_prefix** (str) - 文件的前缀。默认值：events。
+    - **file_suffix** (str) - 文件的后缀。默认值：_MS。
+    - **network** (Cell) - 通过网络获取用于保存图形summary的管道。默认值：None。
+    - **max_file_size** (int, optional) - 可写入磁盘的每个文件的最大大小（以字节为单位）。例如，如果不大于4GB，则设置 `max_file_size=4*1024**3` 。默认值：None，表示无限制。
+    - **raise_exception** (bool, 可选) - 设置在记录数据中发生RuntimeError或OSError异常时是否抛出异常。默认值：False，表示打印错误日志，不抛出异常。
+    - **export_options** (Union[None, dict]) - 可以将保存在summary中的数据导出，并使用字典自定义所需的数据和文件格式。注：导出的文件大小不受 `max_file_size` 的限制。例如，您可以设置{'tensor_format':'npy'}将Tensor导出为NPY文件。支持控制的数据如下所示。默认值：None，表示不导出数据。
 
-        - **tensor_format** (Union[str, None])：自定义导出的Tensor的格式。支持["npy", None]。默认值：None，表示不导出Tensor。
+        - **tensor_format** (Union[str, None]) - 自定义导出的Tensor的格式。支持["npy", None]。默认值：None，表示不导出Tensor。
 
           - **npy**：将Tensor导出为NPY文件。
 
@@ -44,15 +44,15 @@
     ...         summary_record = SummaryRecord(log_dir="./summary_dir")
     ...     finally:
     ...         summary_record.close()
-    
+
     .. py:method:: add_value(plugin, name, value)
 
         添加稍后记录的值。
 
         **参数：**
 
-        - **plugin** (str)：数据类型标签。
-        - **name** (str)：数据名称。
+        - **plugin** (str) - 数据类型标签。
+        - **name** (str) - 数据名称。
         - **value** (Union[Tensor, GraphProto, TrainLineage, EvaluationLineage, DatasetGraph, UserDefinedInfo])： 待存储的值。
 
           - 当plugin为"graph"时，参数值的数据类型应为"GraphProto"对象。具体详情，请参见 mindspore/ccsrc/anf_ir.proto。
@@ -62,7 +62,7 @@
           - 当plugin为"dataset_graph"时，参数值的数据类型应为"DatasetGraph"对象。具体详情，请参见 mindspore/ccsrc/lineage.proto。
           - 当plugin为"custom_lineage_data"时，参数值的数据类型应为"UserDefinedInfo"对象。具体详情，请参见 mindspore/ccsrc/lineage.proto。
           - 当plugin为"explainer"时，参数值的数据类型应为"Explain"对象。具体详情，请参见 mindspore/ccsrc/summary.proto。
-        
+
         **异常：**
 
         - **ValueError：** 参数值无效。
@@ -75,7 +75,7 @@
         >>> if __name__ == '__main__':
         ...     with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
         ...         summary_record.add_value('scalar', 'loss', Tensor(0.1))
-        
+
     .. py:method:: close()
 
         将所有事件持久化并关闭SummaryRecord。请使用with语句或try…finally语句进行自动关闭。
@@ -88,7 +88,7 @@
         ...         summary_record = SummaryRecord(log_dir="./summary_dir")
         ...     finally:
         ...         summary_record.close()
-            
+
     .. py:method:: flush()
 
         将事件文件持久化到磁盘。
@@ -101,7 +101,7 @@
         >>> if __name__ == '__main__':
         ...     with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
         ...         summary_record.flush()
-        
+
     .. py:method:: log_dir
         :property:
 
@@ -117,16 +117,16 @@
         >>> if __name__ == '__main__':
         ...     with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
         ...         log_dir = summary_record.log_dir
-        
+
     .. py:method:: record(step, train_network=None, plugin_filter=None)
 
         记录summary。
 
         **参数：**
 
-        - **step** (int)：表示训练step的编号。
-        - **train_network** (Cell)：表示用于保存图形的备用网络。默认值：None，表示当原始网络图为None时，不保存图形summary。
-        - **plugin_filter** (Optional[Callable[[str], bool]])：过滤器函数，用于通过返回False来过滤正在写入的插件。默认值：None。
+        - **step** (int) - 表示训练step的编号。
+        - **train_network** (Cell) - 表示用于保存图形的备用网络。默认值：None，表示当原始网络图为None时，不保存图形summary。
+        - **plugin_filter** (Optional[Callable[[str], bool]]) - 过滤器函数，用于通过返回False来过滤正在写入的插件。默认值：None。
 
         **返回：**
 
@@ -145,14 +145,14 @@
         ...         summary_record.record(step=2)
         ...
         True
-        
+
     .. py:method:: set_mode(mode)
 
         设置训练阶段。不同的训练阶段会影响数据记录。
 
         **参数：**
 
-        **mode** (str)：待设置的模式，为"train"或"eval"。当模式为"eval"时，`summary_record` 不记录summary算子的数据。
+        - **mode** (str) - 待设置的模式，为"train"或"eval"。当模式为"eval"时，`summary_record` 不记录summary算子的数据。
 
         **异常：**
 

docs/api/api_python/mindspore/mindspore.DynamicLossScaleManager.rst

@@ -19,15 +19,15 @@ mindspore.DynamicLossScaleManager
     >>> loss_scale_manager = DynamicLossScaleManager()
     >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
     >>> model = Model(net, loss_scale_manager=loss_scale_manager, optimizer=optim)
-    
+
     .. py:method:: get_drop_overflow_update()
 
         该值表示是否在发生溢出时放弃本轮参数更新。
 
         **返回：**
-        
+
         bool，始终为True。
-        
+
     .. py:method:: get_loss_scale()
 
         返回当前梯度放大系数。
@@ -35,7 +35,7 @@ mindspore.DynamicLossScaleManager
         **返回：**
 
         float，梯度放大系数。
-        
+
     .. py:method:: get_update_cell()
 
         返回用于更新梯度放大系数的 `Cell` 实例，:class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该实例。
@@ -43,12 +43,11 @@ mindspore.DynamicLossScaleManager
         **返回：**
 
         :class:`mindspore.DynamicLossScaleUpdateCell` 实例，用于更新梯度放大系数。
-        
+
     .. py:method:: update_loss_scale(overflow)
 
         根据溢出状态更新梯度放大系数。如果发生溢出，减小梯度放大系数，否则增大梯度放大系数。
 
         **参数：**
-        
-        **overflow** (bool) - 表示是否溢出。
-        
+
+        - **overflow** (bool) - 表示是否溢出。

docs/api/api_python/mindspore/mindspore.FixedLossScaleManager.rst

@@ -6,7 +6,7 @@ mindspore.FixedLossScaleManager
     梯度放大系数不变的管理器，继承自 :class:`mindspore.LossScaleManager` 。
 
     **参数：**
-    
+
     - **loss_scale** (float) - 梯度放大系数。注：如果将 `drop_overflow_update` 设为False，则定义优化器时需要将优化器的 `loss_scale` 设为相同的值。默认值：128.0。
     - **drop_overflow_update** (bool) - 出现溢出时，是否执行优化器。如果值为True，则出现溢出时不会执行优化器。默认值：True。
 
@@ -25,7 +25,7 @@ mindspore.FixedLossScaleManager
     >>> loss_scale_manager = FixedLossScaleManager(loss_scale, False)
     >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9, loss_scale=loss_scale)
     >>> model = Model(net, loss_scale_manager=loss_scale_manager, optimizer=optim)
-    
+
     .. py:method:: get_drop_overflow_update()
 
         返回 `drop_overflow_update` ，该值表示是否在发生溢出时放弃本轮参数更新。
@@ -33,7 +33,7 @@ mindspore.FixedLossScaleManager
         **返回：**
 
         bool, `drop_overflow_update` 的值。
-        
+
     .. py:method:: get_loss_scale()
 
         获取loss scale值。
@@ -41,20 +41,19 @@ mindspore.FixedLossScaleManager
         **返回：**
 
         bool，`loss_scale` 的值。
-        
+
     .. py:method:: get_update_cell()
 
-        返回用于更新 `loss_scale` 值的 `Cell` 实例，:class:`mindspore.TrainOneStepWithLossScaleCell`会调用该实例。该类使用固定的梯度放大系数，因此该实例不执行任何操作。
+        返回用于更新 `loss_scale` 值的 `Cell` 实例， :class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该实例。该类使用固定的梯度放大系数，因此该实例不执行任何操作。
 
         **返回：**
 
         None或 `Cell` 。当 `drop_overflow_update` 为True时，返回 :class:`mindspore.FixedLossScaleUpdateCell` 实例，当 `drop_overflow_update` 为False时，返回None。
-        
+
     .. py:method:: update_loss_scale(overflow)
 
         更新loss scale值。类 :class:`mindspore.FixedLossScaleManager` 中，该方法不执行任何操作。
 
         **参数：**
 
-        **overflow** (bool) - 表示是否溢出。
-        
+        - **overflow** (bool) - 表示是否溢出。

docs/api/api_python/mindspore/mindspore.LossScaleManager.rst

@@ -8,13 +8,13 @@ mindspore.LossScaleManager
    派生类需要实现该类的所有方法。 `get_loss_scale` 用于获取当前的梯度放大系数。 `update_loss_scale` 用于更新梯度放大系数，该方法将在训练过程中被调用。 `get_update_cell` 用于获取更新梯度放大系数的 `Cell` 实例，该实例将在训练过程中被调用。当前多使用 `get_update_cell` 方式。
 
    例如：:class:`mindspore.FixedLossScaleManager` 和 :class:`mindspore.DynamicLossScaleManager` 。
-    
+
     .. py:method:: get_loss_scale()
 
         获取梯度放大系数（loss scale）的值。
 
     .. py:method:: get_update_cell()
-      
+
         获取用于更新梯度放大系数的Cell实例。
 
     .. py:method:: update_loss_scale(overflow)
@@ -23,4 +23,4 @@ mindspore.LossScaleManager
 
         **参数：**
 
-        **overflow** (bool) - 表示训练过程是否溢出。
+        - **overflow** (bool) - 表示训练过程是否溢出。

docs/api/api_python/mindspore/mindspore.Parameter.rst

@@ -40,9 +40,9 @@
     >>> net.weight.set_data(Tensor(np.zeros((1, 2)), mindspore.float32))
     >>> print(net(x))
     [[0.]]
-    
+
     .. py:method:: cache_enable
-        :property: 
+        :property:
 
         表示该参数是否开启缓存功能。
 
@@ -56,20 +56,20 @@
         克隆参数。
 
         **参数：**
-                
-        **init** (Union[Tensor, str, numbers.Number]) - 初始化参数的形状和数据类型。如果 `init` 是 `Tensor` 或 `numbers.Number` ，则克隆一个具有相同数值、形状和数据类型的新参数。 如果 `init` 是 `str` ，则 `init` 将继承 `Initializer` 模块中对应的同名的类。例如，如果 `init` 是'same'，则克隆一个具有相同数据、形状和数据类型的新参数。默认值：'same'。
+
+        - **init** (Union[Tensor, str, numbers.Number]) - 初始化参数的形状和数据类型。如果 `init` 是 `Tensor` 或 `numbers.Number` ，则克隆一个具有相同数值、形状和数据类型的新参数。 如果 `init` 是 `str` ，则 `init` 将继承 `Initializer` 模块中对应的同名的类。例如，如果 `init` 是'same'，则克隆一个具有相同数据、形状和数据类型的新参数。默认值：'same'。
 
         **返回：**
 
         Parameter，返回克隆的新参数。
-        
+
     .. py:method:: comm_fusion
         :property:
 
         获取此参数的通信算子的融合类型（int）。
 
         在 `AUTO_PARALLEL` 和 `SEMI_AUTO_PARALLEL` 模式下，一些用于参数或梯度聚合的通信算子将自动插入。fusion的值必须大于等于0。当fusion的值为0时，算子不会融合在一起。
-        
+
     .. py:method:: data
         :property:
 
@@ -101,21 +101,21 @@
         **返回：**
 
         初始化数据后的 `Parameter` 。如果当前 `Parameter` 已初始化，则更新 `Parameter` 数据。
-        
+
     .. py:method:: is_init
         :property:
 
         获取参数的初始化状态。
 
         此属性仅在GE（Graph Engine）中有效，在其他后端将设为False。
-        
+
     .. py:method:: layerwise_parallel
         :property:
 
         获取此参数的逐层并行状态（bool）。
 
         在 `DATA_PARALLEL` 和 `HYBRID_PARALLEL` 模式下，如果 `layerwise_parallel` 为True，则广播和gradients通信将不会应用到参数。
-        
+
     .. py:method:: name
         :property:
 
@@ -127,7 +127,7 @@
         获取此参数的优化器并行状态（bool）。
 
         用于在 `AUTO_PARALLEL` 和 `SEMI_AUTO_PARALLEL` 模式下过滤权重切分操作。当在 `mindspore.context.set_auto_parallel_context()` 中启用优化器并行时，它才有效。
-        
+
     .. py:method:: parallel_optimizer_comm_recompute
         :property:
 
@@ -138,7 +138,7 @@
         .. note::
             - 仅支持 `Graph` 模式。
             - 建议使用(cell.recompute(parallel_optimizer_comm_recompute=True/False)去配置由优化器并行生成的 :class:`mindspore.ops.AllGather` 算子，而不是直接使用该接口。
-        
+
     .. py:method:: requires_grad
         :property:
 
@@ -154,9 +154,9 @@
         - **slice_shape** (bool) - 如果 `slice_shape` 设为True，则不检查 `data` 和当前参数shape的一致性。默认值：False。
 
         **返回：**
-    
+
         完成数据设置的新参数。
-        
+
     .. py:method:: set_param_fl(push_to_server=False, pull_from_server=False, requires_aggr=True)
 
         设置参数和服务器的互动方式。
@@ -166,7 +166,7 @@
         - **push_to_server** (bool) - 表示是否将参数推送到服务器。默认值：False。
         - **pull_from_server** (bool) - 表示是否应从服务器中拉取参数。默认值：False。
         - **requires_aggr** (bool) - 表示是否应在服务器中聚合参数。默认值：True。
-        
+
     .. py:method:: set_param_ps(init_in_server=False)
 
         表示可训练参数是否由参数服务器更新，以及可训练参数是否在服务器上初始化。
@@ -175,7 +175,7 @@
 
         **参数：**
 
-        **init_in_server** (bool) - 表示参数服务器更新的可训练参数是否在服务器上初始化。默认值：False。
+        - **init_in_server** (bool) - 表示参数服务器更新的可训练参数是否在服务器上初始化。默认值：False。
 
     .. py:method:: sliced
         :property:
@@ -184,5 +184,5 @@
 
     .. py:method:: unique
         :property:
-        
+
         表示参数是否唯一。

docs/api/api_python/mindspore/mindspore.Tensor.rst

@@ -129,20 +129,20 @@ mindspore.Tensor
 
         **参数：**
 
-        **x** (Tensor) - 输入的张量。该张量的形状必须遵守广播规则。
+        - **x** (Tensor) - 输入的张量。该张量的形状必须遵守广播规则。
 
         **返回：**
 
         Tensor，维度与输入张量的相同。
 
     .. py:method:: from_numpy(array)
-        :static:
+        :staticmethod:
 
         将NumPy数组转换为张量，且不需要复制数据。
 
         **参数：**
 
-        **array** (numpy.array) - 输入数组。
+        - **array** (numpy.array) - 输入数组。
 
         **返回：**
 
@@ -180,7 +180,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **axis** (int, optional) - 默认情况下，返回扁平化Tensor的最大值序号，否则返回指定轴方向上。
+        - **axis** (int, optional) - 默认情况下，返回扁平化Tensor的最大值序号，否则返回指定轴方向上。
 
         **返回：**
 
@@ -188,7 +188,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 轴超出了范围。
+        - **ValueError** - 轴超出了范围。
 
         **支持平台：**
 
@@ -201,14 +201,14 @@ mindspore.Tensor
         >>> a = Tensor(np.arange(10, 16).reshape(2, 3).astype("float32"))
         >>> print(a.argmax())
         5
-        
+
     .. py:method:: argmin(axis=None)
 
         返回指定轴上最小值的索引。
 
         **参数：**
 
-        **axis** (int, optional) - 返回扁平化Tensor的最小值序号，否则返回指定轴方向上的最小值序号。默认值: None。
+        - **axis** (int, optional) - 返回扁平化Tensor的最小值序号，否则返回指定轴方向上的最小值序号。默认值: None。
 
         **返回：**
 
@@ -216,7 +216,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 轴超出了范围。
+        - **ValueError** - 轴超出了范围。
 
         **支持平台：**
 
@@ -245,7 +245,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **TypeError** - 指定了无法解析的类型。
+        - **TypeError** - 指定了无法解析的类型。
 
         **支持平台：**
 
@@ -283,7 +283,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 输入Tensor和任一 `choices` 无法广播。
+        - **ValueError** - 输入Tensor和任一 `choices` 无法广播。
 
         **样例：**
 
@@ -301,7 +301,7 @@ mindspore.Tensor
         给定一个区间，区间外的值将被裁剪到区间边缘。
         例如，如果指定的间隔为 :math:`[0, 1]` ，则小于0的值将变为0，大于1的值将变为1。
 
-        .. note:: 
+        .. note::
             目前不支持裁剪 `xmin=nan` 或 `xmax=nan` 。
 
         **参数：**
@@ -335,7 +335,7 @@ mindspore.Tensor
 
         返回复制的Tensor。
 
-        .. note:: 
+        .. note::
             当前实现不支持类似NumPy的 `order` 参数。
 
         **返回：**
@@ -361,7 +361,7 @@ mindspore.Tensor
 
         返回指定轴方向上元素的累加值。
 
-        .. note:: 
+        .. note::
             如果 `dtype` 为 `int8` , `int16` 或 `bool` ，则结果 `dtype` 将提升为 `int32` ，不支持 `int64` 。
 
         **参数：**
@@ -371,7 +371,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 轴超出范围。
+        - **ValueError** - 轴超出范围。
 
         **返回：**
 
@@ -408,7 +408,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 输入Tensor的维度少于2。
+        - **ValueError** - 输入Tensor的维度少于2。
 
         **支持平台：**
 
@@ -430,12 +430,12 @@ mindspore.Tensor
 
         用标量值填充数组。
 
-        .. note:: 
+        .. note::
             与NumPy不同，Tensor.fill()将始终返回一个新的Tensor，而不是填充原来的Tensor。
 
         **参数：**
 
-        **value** (Union[None, int, float, bool]) - 所有元素都被赋予这个值。
+        - **value** (Union[None, int, float, bool]) - 所有元素都被赋予这个值。
 
         **返回：**
 
@@ -443,7 +443,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **TypeError** - 输入参数具有前面未指定的类型。
+        - **TypeError** - 输入参数具有前面未指定的类型。
 
         **支持平台：**
 
@@ -464,7 +464,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **order** (str, optional) - 可以在'C'和'F'之间进行选择。'C'表示按行优先（C风格）顺序展开。'F'表示按列优先顺序（Fortran风格）进行扁平化。仅支持'C'和'F'。默认值：C。
+        - **order** (str, optional) - 可以在'C'和'F'之间进行选择。'C'表示按行优先（C风格）顺序展开。'F'表示按列优先顺序（Fortran风格）进行扁平化。仅支持'C'和'F'。默认值：C。
 
         **返回：**
 
@@ -530,12 +530,12 @@ mindspore.Tensor
 
         使用索引从Tensor中获取值。
 
-        .. note:: 
+        .. note::
             Tensor.item返回的是Tensor标量，而不是Python标量。
 
         **参数：**
 
-        **index** (Union[None, int, tuple(int)]) - Tensor的索引。默认值：None。
+        - **index** (Union[None, int, tuple(int)]) - Tensor的索引。默认值：None。
 
         **返回：**
 
@@ -543,7 +543,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - `index` 的长度不等于Tensor的ndim。
+        - **ValueError** - `index` 的长度不等于Tensor的ndim。
 
         **支持平台：**
 
@@ -567,7 +567,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **args** (Union[(numbers.Number), (int/tuple(int), numbers.Number)]) - 指定索引和值的参数。如果 `args` 包含一个参数（标量），则其仅在Tensor大小为1的情况下使用。如果 `args` 包含两个参数，则最后一个参数是要设置的值且必须是标量，而第一个参数指定单个Tensor元素的位置。参数值是整数或者元组。
+        - **args** (Union[(numbers.Number), (int/tuple(int), numbers.Number)]) - 指定索引和值的参数。如果 `args` 包含一个参数（标量），则其仅在Tensor大小为1的情况下使用。如果 `args` 包含两个参数，则最后一个参数是要设置的值且必须是标量，而第一个参数指定单个Tensor元素的位置。参数值是整数或者元组。
 
         **返回：**
 
@@ -614,7 +614,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **TypeError** - 参数具有前面未指定的类型。
+        - **TypeError** - 参数具有前面未指定的类型。
 
         **支持平台：**
 
@@ -646,7 +646,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **TypeError** - 参数具有前面未指定的类型。
+        - **TypeError** - 参数具有前面未指定的类型。
 
         **支持平台：**
 
@@ -676,7 +676,7 @@ mindspore.Tensor
 
         该函数名称是"peak to peak"的缩写。
 
-        .. note:: 
+        .. note::
             不支持NumPy参数 `dtype` 和 `out` 。
 
         **参数：**
@@ -690,7 +690,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **TypeError** - `self` 不是Tensor，或者 `axis` 和 `keepdims` 具有前面未指定的类型。
+        - **TypeError** - `self` 不是Tensor，或者 `axis` 和 `keepdims` 具有前面未指定的类型。
 
         **支持平台：**
 
@@ -772,7 +772,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **shape** (Union[int, tuple(int), list(int)]) - 新的shape应与原来的shape兼容。如果参数值为整数，则结果是该长度的一维数组。shape的维度可以为-1。在这种情况下，将根据数组的长度和剩下的维度计算出该值。
+        - **shape** (Union[int, tuple(int), list(int)]) - 新的shape应与原来的shape兼容。如果参数值为整数，则结果是该长度的一维数组。shape的维度可以为-1。在这种情况下，将根据数组的长度和剩下的维度计算出该值。
 
         **返回：**
 
@@ -802,12 +802,12 @@ mindspore.Tensor
 
         更改Tensor的shape。
 
-        .. note:: 
+        .. note::
             此方法不更改输入数组的大小，也不返回NumPy中的任何内容，而是返回一个具有输入大小的新Tensor。不支持Numpy参数 `refcheck` 。
 
         **参数：**
 
-        **new_shape** (Union[ints, tuple of ints]) - 指定Tensor的新shape。
+        - **new_shape** (Union[ints, tuple of ints]) - 指定Tensor的新shape。
 
         **返回：**
 
@@ -843,7 +843,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - `side` 或 `sorter` 的参数无效。
+        - **ValueError** - `side` 或 `sorter` 的参数无效。
 
         **支持平台：**
 
@@ -873,7 +873,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **axis** (Union[None, int, list(int), tuple(int)], optional) - 选择shape中长度为1的条目的子集。如果选择shape条目长度大于1的轴，则报错。默认值为None。
+        - **axis** (Union[None, int, list(int), tuple(int)], optional) - 选择shape中长度为1的条目的子集。如果选择shape条目长度大于1的轴，则报错。默认值为None。
 
         **返回：**
 
@@ -904,7 +904,7 @@ mindspore.Tensor
 
         返回标准差。默认情况下计算展开数组的标准差，否则在指定维度上计算。
 
-        .. note:: 
+        .. note::
             不支持NumPy参数 `dtype` 、 `out` 和 `where` 。
 
         **参数：**
@@ -939,7 +939,7 @@ mindspore.Tensor
 
         返回指定维度上数组元素的总和。
 
-        .. note:: 
+        .. note::
             不支持NumPy参数 `out` 、 `where` 、 `casting` 、 `order` 、 `subok` 、 `signature` 和 `extobj` 。
 
         **参数：**
@@ -1029,7 +1029,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - `axis` 超出范围，或 `mode` 被设置为'raise'、'wrap'和'clip'以外的值。
+        - **ValueError** - `axis` 超出范围，或 `mode` 被设置为'raise'、'wrap'和'clip'以外的值。
 
         **支持平台：**
 
@@ -1049,7 +1049,7 @@ mindspore.Tensor
 
         返回init_data()的结果，并获取此Tensor的数据。
 
-        .. note:: 
+        .. note::
             不建议使用 `to_tensor`。请使用 `init_data` 。
 
         **参数：**
@@ -1093,7 +1093,7 @@ mindspore.Tensor
 
         **异常：**
 
-        **ValueError** - 输入Tensor的维度少于2。
+        - **ValueError** - 输入Tensor的维度少于2。
 
         **支持平台：**
 
@@ -1119,7 +1119,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **axes** (Union[None, tuple(int), list(int), int], optional) - 如果 `axes` 为None或未设置，则该方法将反转维度。如果 `axes` 为tuple(int)或list(int)，则Tensor.transpose()把Tensor转置为新的维度。如果 `axes` 为整数，则此表单仅作为元组/列表表单的备选。
+        - **axes** (Union[None, tuple(int), list(int), int], optional) - 如果 `axes` 为None或未设置，则该方法将反转维度。如果 `axes` 为tuple(int)或list(int)，则Tensor.transpose()把Tensor转置为新的维度。如果 `axes` 为整数，则此表单仅作为元组/列表表单的备选。
 
         **返回：**
 
@@ -1151,7 +1151,7 @@ mindspore.Tensor
 
         返回方差值。默认情况下计算展开Tensor的方差，否则在指定维度上计算。
 
-        .. note:: 
+        .. note::
             不支持NumPy参数 `dtype` 、 `out` 和 `where` 。
 
         **参数：**
@@ -1183,7 +1183,7 @@ mindspore.Tensor
 
         **参数：**
 
-        **shape** (Union[tuple(int), int]) - 输出Tensor的维度。
+        - **shape** (Union[tuple(int), int]) - 输出Tensor的维度。
 
         **返回：**
 

docs/api/api_python/mindspore/mindspore.build_searched_strategy.rst

@@ -7,7 +7,7 @@ mindspore.build_searched_strategy
 
     **参数：**
 
-    **strategy_filename** (str) - 策略文件的名称。
+    - **strategy_filename** (str) - 策略文件的名称。
 
     **返回：**
 
@@ -17,4 +17,3 @@ mindspore.build_searched_strategy
 
     - **ValueError** - 策略文件不正确。
     - **TypeError** - `strategy_filename` 不是str。
-    

docs/api/api_python/mindspore/mindspore.connect_network_with_dataset.rst

@@ -11,7 +11,7 @@ mindspore.connect_network_with_dataset
         如果以图模式在Ascend/GPU上运行网络，此函数将使用 :class:`mindspore.ops.GetNext` 包装输入网络。在其他情况下，输入网络将在没有改动的情况下返回。仅在下沉模式下获取数据需要使用 :class:`mindspore.ops.GetNext` ，因此此函数不适用于非下沉模式。
 
     **参数：**
-      
+
     - **network** (Cell) - 数据集的训练网络。
     - **dataset_helper** (DatasetHelper) - 一个处理MindData数据集的类，提供了数据集的类型、形状（shape）和队列名称，以包装 :class:`mindspore.ops.GetNext` 。
 
@@ -20,11 +20,11 @@ mindspore.connect_network_with_dataset
     Cell，在Ascend上以图模式运行任务的情况下，一个由 :class:`mindspore.ops.GetNext` 包装的新网络。在其他情况下是输入网络。
 
     **异常：**
-    
-    **RuntimeError** - 如果该接口在非数据下沉模式调用。
+
+    - **RuntimeError** - 如果该接口在非数据下沉模式调用。
 
     **支持平台：**
-      
+
     ``Ascend``  ``GPU``
 
     **样例：**
@@ -34,6 +34,5 @@ mindspore.connect_network_with_dataset
     >>> # 调用create_dataset函数创建一个通用的数据集，参考mindpore.dataset
     >>> train_dataset = create_custom_dataset()
     >>> dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True)
-    >>> net = Net()                                                                                                                                                                       
+    >>> net = Net()
     >>> net_with_get_next = connect_network_with_dataset(net, dataset_helper)
-    

docs/api/api_python/mindspore/mindspore.dtype.rst

@@ -2,24 +2,24 @@ mindspore.dtype
 ===============
 
 .. py:class:: mindspore.dtype
-  
+
     创建一个MindSpore数据类型的对象。
 
     `dtype` 的实际路径为 `/mindspore/common/dtype.py` ，运行以下命令导入环境：
-  
+
     .. code-block::
-  
+
         from mindspore import dtype as mstype
-  
+
     - **数值型**
 
       目前，MindSpore支持 ``Int``，``Uint`` 和 ``Float`` 数据类型，详情请参照以下表格。
-  
+
       ==============================================   =============================
       定义                                              描述
       ==============================================   =============================
       ``mindspore.int8`` ,  ``mindspore.byte``         8位整型数
-      ``mindspore.int16`` ,  ``mindspore.short``       16位整型数 
+      ``mindspore.int16`` ,  ``mindspore.short``       16位整型数
       ``mindspore.int32`` ,  ``mindspore.intc``        32位整型数
       ``mindspore.int64`` ,  ``mindspore.intp``        64位整型数
       ``mindspore.uint8`` ,  ``mindspore.ubyte``       无符号8位整型数
@@ -32,11 +32,11 @@ mindspore.dtype
       ``mindspore.complex64``                          64位复数
       ``mindspore.complex128``                         128位复数
       ==============================================   =============================
-  
+
     - **其他类型**
-  
+
       除数值型以外的其他数据类型，请参照以下表格。
-    
+
       ============================   =================
       类型                            描述
       ============================   =================
@@ -55,13 +55,13 @@ mindspore.dtype
       ``symbolic_key``                在 ``env_type`` 中用作变量的键的变量的值。
       ``env_type``                    用于存储函数的自由变量的梯度，其中键是自由变量节点的 `symbolic_key` ，值是梯度。
       ============================   =================
-  
+
     - **树形拓扑**
-  
+
       以上定义的数据类型遵从如下的树形拓扑结构：
-    
+
       .. code-block::
-      
+
           └─────── number
               │   ├─── bool_
               │   ├─── int_

docs/api/api_python/mindspore/mindspore.dtype_to_nptype.rst

@@ -7,7 +7,7 @@ mindspore.dtype_to_nptype
 
     **参数：**
 
-    **type_** (mindspore.dtype) – MindSpore中的dtype。
+    - **type_** (mindspore.dtype) – MindSpore中的dtype。
 
     **返回：**
 

docs/api/api_python/mindspore/mindspore.dtype_to_pytype.rst

@@ -7,7 +7,7 @@ mindspore.dtype_to_pytype
 
     **参数：**
 
-    **type_** (mindspore.dtype) – MindSpore中的dtype。
+    - **type_** (mindspore.dtype) – MindSpore中的dtype。
 
     **返回：**
 

docs/api/api_python/mindspore/mindspore.get_py_obj_dtype.rst

@@ -7,7 +7,7 @@ mindspore.get_py_obj_dtype
 
     **参数：**
 
-    **obj** (type) – Python数据对象，或在Python环境中定义的变量。
+    - **obj** (type) – Python数据对象，或在Python环境中定义的变量。
 
     **返回：**
 

docs/api/api_python/mindspore/mindspore.load_checkpoint.rst

@@ -20,7 +20,7 @@ mindspore.load_checkpoint
 
     **异常：**
 
-    **ValueError** – checkpoint文件格式正确。
+    - **ValueError** – checkpoint文件格式正确。
 
     **样例：**
 

docs/api/api_python/mindspore/mindspore.load_distributed_checkpoint.rst

@@ -3,20 +3,19 @@ mindspore.load_distributed_checkpoint
 
 .. py:method:: mindspore.load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=None, train_strategy_filename=None, strict_load=False, dec_key=None, dec_mode='AES-GCM')
 
-    给分布式预测加载checkpoint文件到网络，用于分布式推理。关于分布式推理的细节，请参考：'<https://www.mindspore.cn/docs/programming_guide/zh-CN/master/distributed_inference.html>' 。
+    给分布式预测加载checkpoint文件到网络，用于分布式推理。关于分布式推理的细节，请参考： https://www.mindspore.cn/docs/programming_guide/zh-CN/master/distributed_inference.html 。
 
     **参数：**
 
-    - **network** (Cell)：分布式预测网络。
-    - **checkpoint_filenames** (list[str])：checkpoint文件的名称，按rank id 顺序排列。
-    - **predict_strategy** (dict)：预测时参数的切分策略。
-    - **train_strategy_filename** (str)：训练策略proto文件名。默认值：None。
-    - **strict_load** (bool)：表示是否严格加载参数到网络。如果值为False，则当checkpoint文件中参数名称的后缀与网络中的参数相同时，加载参数到网络。当类型不一致时，对相同类型的参数进行类型转换，如从float32到float16。默认值：False。
-    - **dec_key** (Union[None, bytes])：用于解密的字节类型key。如果value为None，则不需要解密。默认值：None。
-    - **dec_mode** (str)：仅当dec_key不设为None时，该参数有效。指定了解密模式，目前支持AES-GCM和AES-CBC。默认值：AES-GCM。
+    - **network** (Cell) - 分布式预测网络。
+    - **checkpoint_filenames** (list[str]) - checkpoint文件的名称，按rank id 顺序排列。
+    - **predict_strategy** (dict) - 预测时参数的切分策略。
+    - **train_strategy_filename** (str) - 训练策略proto文件名。默认值：None。
+    - **strict_load** (bool) - 表示是否严格加载参数到网络。如果值为False，则当checkpoint文件中参数名称的后缀与网络中的参数相同时，加载参数到网络。当类型不一致时，对相同类型的参数进行类型转换，如从float32到float16。默认值：False。
+    - **dec_key** (Union[None, bytes]) - 用于解密的字节类型key。如果value为None，则不需要解密。默认值：None。
+    - **dec_mode** (str) - 仅当dec_key不设为None时，该参数有效。指定了解密模式，目前支持AES-GCM和AES-CBC。默认值：AES-GCM。
 
     **异常：**
 
     - **TypeError：** 输入类型不符合要求。
     - **ValueError：** 无法加载checkpoint文件到网络。
-    

docs/api/api_python/mindspore/mindspore.load_param_into_net.rst

@@ -17,7 +17,7 @@ mindspore.load_param_into_net
 
     **异常：**
 
-    **TypeError** – 如果参数不是Cell或者 `parameter_dict` 不是Parameter类型的字典。
+    - **TypeError** – 如果参数不是Cell或者 `parameter_dict` 不是Parameter类型的字典。
 
     **样例：**
 

docs/api/api_python/mindspore/mindspore.model.rst

@@ -90,7 +90,7 @@
 
         使用PyNative模式或CPU处理器时，模型评估流程将以非下沉模式执行。
 
-        .. note::    
+        .. note::
             如果 `dataset_sink_mode` 配置为True，数据将被送到处理器中。如果处理器是Ascend，数据特征将被逐一传输，每次数据传输的限制是256M。如果 `dataset_sink_mode` 配置为True，数据集仅能在当前模型中使用，而不能被其他模型使用。该接口会构建并执行计算图，如果使用前先执行了 `Model.build` ，那么它会直接执行计算图而不构建。
 
         **参数：**
@@ -98,7 +98,7 @@
         - **valid_dataset** (Dataset) – 评估模型的数据集。
         - **callbacks** (Optional[list(Callback), Callback]) - 评估过程中需要执行的回调对象或回调对象列表。默认值：None。
         - **dataset_sink_mode** (bool) - 是否通过数据通道获取数据。默认值：True。
-   
+
         **返回：**
 
         Dict，键是用户定义的评价指标名称，值是以推理模式运行的评估结果。
@@ -124,25 +124,25 @@
         评估网络实例。
 
     .. py:method:: infer_predict_layout(*predict_data)
- 
+
         在 `AUTO_PARALLEL` 或 `SEMI_AUTO_PARALLEL` 模式下为预测网络生成参数layout，数据可以是单个或多个张量。
- 
+
         .. note:: 同一批次数据应放在一个张量中。
- 
+
         **参数：**
- 
-        **predict_data** (Tensor) – 单个或多个张量的预测数据。
- 
+
+        - **predict_data** (Tensor) – 单个或多个张量的预测数据。
+
         **返回：**
- 
+
         Dict，用于加载分布式checkpoint的参数layout字典。它总是作为 `load_distributed_checkpoint()` 函数的一个入参。
- 
+
         **异常：**
- 
-        **RuntimeError** – 如果不是图模式（GRAPH_MODE）。
- 
+
+        - **RuntimeError** – 如果不是图模式（GRAPH_MODE）。
+
         **样例：**
- 
+
         >>> # 该例子需要在多设备上运行。请参考mindpore.cn上的教程 > 分布式训练。
         >>> import numpy as np
         >>> import mindspore as ms
@@ -156,27 +156,27 @@
         >>> input_data = Tensor(np.random.randint(0, 255, [1, 1, 32, 32]), ms.float32)
         >>> model = Model(Net())
         >>> model.infer_predict_layout(input_data)
- 
+
     .. py:method:: infer_train_layout(train_dataset, dataset_sink_mode=True, sink_size=-1)
 
         在 `AUTO_PARALLEL` 或 `SEMI_AUTO_PARALLEL` 模式下为训练网络生成参数layout，当前只有数据下沉模式可支持使用。
- 
+
         .. warning:: 这是一个实验性的原型，可能会被改变和/或删除。
- 
+
         .. note:: 这是一个预编译函数。参数必须与Model.train()函数相同。
- 
+
         **参数：**
- 
+
         - **train_dataset** (Dataset) – 一个训练数据集迭代器。如果没有损失函数（loss_fn），返回一个包含多个数据的元组（data1, data2, data3, ...）并传递给网络。否则，返回一个元组（data, label），数据和标签将被分别传递给网络和损失函数。
         - **dataset_sink_mode** (bool) – 决定是否以数据集下沉模式进行训练。默认值：True。配置项是PyNative模式或CPU时，训练模型流程使用的是数据不下沉（non-sink）模式。默认值：True。
         - **sink_size** (int) – 控制每次数据下沉的数据量，如果 `sink_size` =-1，则每一次epoch下沉完整数据集。如果 `sink_size` >0，则每一次epoch下沉数据量为 `sink_size` 的数据集。如果 `dataset_sink_mode` 为False，则设置 `sink_size` 为无效。默认值：-1。
- 
+
         **返回：**
- 
+
         Dict，用于加载分布式checkpoint的参数layout字典。
- 
+
         **样例：**
- 
+
         >>> # 该例子需要在多设备上运行。请参考mindpore.cn上的教程 > 分布式训练。
         >>> import numpy as np
         >>> import mindspore as ms
@@ -203,12 +203,12 @@
 
         **参数：**
 
-        **predict_data** (Tensor) – 预测样本，数据可以是单个张量、张量列表或张量元组。
-        
+        - **predict_data** (Tensor) – 预测样本，数据可以是单个张量、张量列表或张量元组。
+
         **返回：**
 
         返回预测结果，类型是张量或数组。
-         
+
         **样例:**
 
         >>> import mindspore as ms
@@ -233,7 +233,7 @@
 
         使用PYNATIVE_MODE模式或CPU处理器时，模型训练流程将以非下沉模式执行。
 
-        .. note::    
+        .. note::
             如果 `dataset_sink_mode` 配置为True，数据将被送到处理器中。如果处理器是Ascend，数据特征将被逐一传输，每次数据传输的限制是256M。如果 `dataset_sink_mode` 配置为True，仅在每个epoch结束时调用Callback实例的step_end方法。如果 `dataset_sink_mode` 配置为True，数据集仅能在当前模型中使用，而不能被其他模型使用。如果 `sink_size` 大于零，每次epoch可以无限次遍历数据集，直到遍历数据量等于 `sink_size` 为止。然后下次epoch是从上一次遍历的最后位置继续开始遍历。该接口会构建并执行计算图，如果使用前先执行了 `Model.build` ，那么它会直接执行计算图而不构建。
 
         **参数：**
@@ -263,5 +263,5 @@
         获得该模型的训练网络。
 
         **返回：**
-       
+
         预测网络实例。

docs/api/api_python/mindspore/mindspore.pytype_to_dtype.rst

@@ -7,7 +7,7 @@ mindspore.pytype_to_dtype
 
     **参数：**
 
-    **obj** (type) – Python数据对象。
+    - **obj** (type) – Python数据对象。
 
     **返回:**
 

docs/api/api_python/mindspore/mindspore.save_checkpoint.rst

@@ -17,7 +17,7 @@ mindspore.save_checkpoint
 
     **异常：**
 
-    **TypeError** – 如果参数 `save_obj` 类型不为nn.Cell或者list，且如果参数 `integrated_save` 及 `async_save` 非bool类型。
+    - **TypeError** – 如果参数 `save_obj` 类型不为nn.Cell或者list，且如果参数 `integrated_save` 及 `async_save` 非bool类型。
 
     **样例：**
 

docs/api/api_python/mindspore/mindspore.set_seed.rst

@@ -5,14 +5,14 @@ mindspore.set_seed
 
     设置全局种子。
 
-    .. note:: 
+    .. note::
         - 全局种子可用于numpy.random,mindspore.common.Initializer,mindspore.ops.composite.random_ops以及mindspore.nn.probability.distribution。
         - 如果没有设置全局种子，这些包将会各自使用自己的种子，numpy.random和mindspore.common.Initializer将会随机选择种子值，mindspore.ops.composite.random_ops和mindspore.nn.probability.distribution将会使用零作为种子值。
         - numpy.random.seed()设置的种子仅能被numpy.random使用，而这个API设置的种子也可被numpy.random使用，因此推荐使用这个API设置所有的种子。
 
     **参数：**
 
-    **seed** (int) – 设置的全局种子。
+    - **seed** (int) – 设置的全局种子。
 
     **异常:**
 

docs/api/api_python/nn/mindspore.nn.Accuracy.rst

@@ -1,7 +1,7 @@
 mindspore.nn.Accuracy
 =====================
 
-.. py:class:: Class mindspore.nn.Accuracy(eval_type='classification')
+.. py:class:: mindspore.nn.Accuracy(eval_type='classification')
 
     计算'classification'单标签数据分类和'multilabel'多标签数据分类的正确率。
 
@@ -13,7 +13,7 @@ mindspore.nn.Accuracy
         {\text{true_positive} + \text{true_negative} + \text{false_positive} + \text{false_negative}}
 
     **参数：**
-    
+
     - **eval_type** (str) - 评估的数据集的类型，支持'classification'和'multilabel'。'classification'为单标签分类场景，'multilabel'为多标签分类场景。
       默认值：'classification'。
 
@@ -59,8 +59,8 @@ mindspore.nn.Accuracy
           对于'classification'情况，`y_pred` 在大多数情况下由范围 :math:`[0, 1]` 中的浮点数组成，shape为 :math:`(N, C)` ，其中 :math:`N` 是样本数， :math:`C` 是类别数。
           `y` 由整数值组成，如果是one_hot编码格式，shape是 :math:`(N,C)` ；如果是类别索引，shape是 :math:`(N,)` 。
 
-          对于'multilabel'情况，`y_pred 和 `y` 只能是值为0或1的one-hot编码格式，其中值为1的索引表示正类别。 `y_pred` 和 `y` 的shape都是 :math:`(N,C)` 。
+          对于'multilabel'情况，`y_pred` 和 `y` 只能是值为0或1的one-hot编码格式，其中值为1的索引表示正类别。 `y_pred` 和 `y` 的shape都是 :math:`(N,C)` 。
 
         **异常：**
-        
+
         - **ValueError** - inputs的数量不等于2。

docs/api/api_python/nn/mindspore.nn.Adagrad.rst

@@ -7,7 +7,7 @@ mindspore.nn.Adagrad
 
     Adagrad用于在线学习和随机优化。
     请参阅论文 `Efficient Learning using Forward-Backward Splitting <https://proceedings.neurips.cc/paper/2009/file/621bf66ddb7c962aa0d22ac97d69b793-Paper.pdf>`_。
-    
+
     公式如下：
 
     .. math::
@@ -34,7 +34,7 @@ mindspore.nn.Adagrad
 
     - **accum** (float) - 累加器 :math:`h` 的初始值，必须大于等于零。默认值：0.1。
     - **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]) - 默认值：0.001。
-    
+
       .. include:: mindspore.nn.optim_arg_dynamic_lr.rst
 
     - **update_slots** (bool) - 如果为True，则更新累加器 :math:`h` 。默认值：True。
@@ -45,7 +45,7 @@ mindspore.nn.Adagrad
 
     **输入：**
 
-    **grads** (tuple[Tensor]) - 优化器中 `params` 的梯度，形状（shape）与 `params` 相同。
+    - **grads** (tuple[Tensor]) - 优化器中 `params` 的梯度，形状（shape）与 `params` 相同。
 
     **输出：**
 

docs/api/api_python/nn/mindspore.nn.Adam.rst

@@ -49,7 +49,7 @@ mindspore.nn.Adam
 
     **输入：**
 
-    **gradients** (tuple[Tensor]) - `params` 的梯度，形状（shape）与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，形状（shape）与 `params` 相同。
 
     **输出：**
 

docs/api/api_python/nn/mindspore.nn.AdamOffload.rst

@@ -4,7 +4,7 @@ mindspore.nn.AdamOffload
 .. py:class:: mindspore.nn.AdamOffload(params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-08, use_locking=False, use_nesterov=False, weight_decay=0.0, loss_scale=1.0)
 
     此优化器在主机CPU上运行Adam优化算法，设备上仅执行网络参数的更新，最大限度地降低内存成本。虽然会增加性能开销，但优化器可以运行更大的模型。
-    
+
     Adam算法参见 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_。
 
     更新公式如下：
@@ -17,7 +17,7 @@ mindspore.nn.AdamOffload
             w_{t+1} = w_{t} - l * \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
         \end{array}
 
-    :math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2`，:math:`g` 代表 `gradients`，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2`，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power`，:math:`\alpha` 代表 `learning_rate`，:math:`w` 代表 `params`，:math:`\epsilon` 代表 `eps` 。
+    :math:`m` 代表第一个矩向量 `moment1` ， :math:`v` 代表第二个矩向量 `moment2`，:math:`g` 代表 `gradients`，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2`，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power`，:math:`\alpha` 代表 `learning_rate`，:math:`w` 代表 `params`，:math:`\epsilon` 代表 `eps` 。
 
     .. note::此优化器目前仅支持图模式。
 
@@ -34,7 +34,7 @@ mindspore.nn.AdamOffload
       .. include:: mindspore.nn.optim_group_weight_decay.rst
 
       .. include:: mindspore.nn.optim_group_order.rst
-              
+
 
     - **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
 
@@ -51,7 +51,7 @@ mindspore.nn.AdamOffload
 
     **输入：**
 
-    **gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
 
     **输出：**
 
@@ -59,14 +59,14 @@ mindspore.nn.AdamOffload
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
-    - **TypeError**：`parameters` 的元素不是Parameter或字典。
-    - **TypeError**：`beta1` 、 `beta2` 、 `eps `或 `loss_scale` 不是float。
-    - **TypeError**：`weight_decay` 不是float或int。
-    - **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
-    - **ValueError**：`loss_scale` 或 `eps` 不大于0。
-    - **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
-    - **ValueError**：`weight_decay` 小于0。
+    - **TypeError** - `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+    - **TypeError** - `parameters` 的元素不是Parameter或字典。
+    - **TypeError** - `beta1` 、 `beta2` 、 `eps` 或 `loss_scale` 不是float。
+    - **TypeError** - `weight_decay` 不是float或int。
+    - **TypeError** - `use_locking` 或 `use_nesterov` 不是bool。
+    - **ValueError** - `loss_scale` 或 `eps` 不大于0。
+    - **ValueError** - `beta1` 、 `beta2` 不在（0.0,1.0）范围内。
+    - **ValueError** - `weight_decay` 小于0。
 
     **支持平台：**
 
@@ -91,4 +91,3 @@ mindspore.nn.AdamOffload
     >>>
     >>> loss = nn.SoftmaxCrossEntropyWithLogits()
     >>> model = Model(net, loss_fn=loss, optimizer=optim)
-    

docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.rst

@@ -20,7 +20,7 @@ mindspore.nn.AdamWeightDecay
             w_{t+1}  = w_{t} - lr * update
         \end{array}
 
-    :math:`m` 表示第1矩向量 `moment1` , :math:`v` 表示第2矩向量 `moment2`， :math:`g` 表示 `gradients` ，:math:`lr` 表示 `learning_rate` ，:math:`\beta_1, \beta_2` 表示 `beta1` 和 `beta2` ,:math:`t` 表示当前step，:math:`w` 表示 `params`。
+    :math:`m` 表示第1矩向量 `moment1` , :math:`v` 表示第2矩向量 `moment2`， :math:`g` 表示 `gradients` ，:math:`lr` 表示 `learning_rate` ，:math:`\beta_1, \beta_2` 表示 `beta1` 和 `beta2` , :math:`t` 表示当前step，:math:`w` 表示 `params`。
 
     .. note::
         .. include:: mindspore.nn.optim_note_loss_scale.rst
@@ -31,11 +31,11 @@ mindspore.nn.AdamWeightDecay
     - **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、和"order_params"：
 
       .. include:: mindspore.nn.optim_group_param.rst
-  
+
       .. include:: mindspore.nn.optim_group_lr.rst
-  
+
       .. include:: mindspore.nn.optim_group_weight_decay.rst
-  
+
       .. include:: mindspore.nn.optim_group_order.rst
 
 
@@ -45,26 +45,26 @@ mindspore.nn.AdamWeightDecay
 
     - **beta1** (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
     - **beta2** (float)：`moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
-    - **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
-    - **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
+    - **eps** (float) - 将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
+    - **weight_decay** (float) - 权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
 
     **输入：**
 
-    **gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
 
     **输出：**
 
-    **tuple** [bool]，所有元素都为True。
+    - **tuple** [bool]，所有元素都为True。
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
-    - **TypeError**：`parameters` 的元素不是Parameter或字典。
-    - **TypeError**：`beta1` 、 `beta2` 或 `eps` 不是float。
-    - **TypeError**：`weight_decay` 不是float或int。
-    - **ValueError**：`eps` 小于等于0。
-    - **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
-    - **ValueError**：`weight_decay` 小于0。
+    - **TypeError** - `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+    - **TypeError** - `parameters` 的元素不是Parameter或字典。
+    - **TypeError** - `beta1` 、 `beta2` 或 `eps` 不是float。
+    - **TypeError** - `weight_decay` 不是float或int。
+    - **ValueError** - `eps` 小于等于0。
+    - **ValueError** - `beta1` 、 `beta2` 不在（0.0,1.0）范围内。
+    - **ValueError** - `weight_decay` 小于0。
 
     **支持平台：**
 
@@ -89,4 +89,3 @@ mindspore.nn.AdamWeightDecay
     >>>
     >>> loss = nn.SoftmaxCrossEntropyWithLogits()
     >>> model = Model(net, loss_fn=loss, optimizer=optim)
-   

docs/api/api_python/nn/mindspore.nn.cell.rst → docs/api/api_python/nn/mindspore.nn.Cell.rst

@@ -7,7 +7,7 @@
 
     一个 `Cell` 可以是单一的神经网络单元，如 :class:`mindspore.nn.Conv2d`, :class:`mindspore.nn.ReLU`,  :class:`mindspore.nn.BatchNorm` 等，也可以是组成网络的 `Cell` 的结合体。
 
-    .. note:: 
+    .. note::
        一般情况下，自动微分 (AutoDiff) 算法会自动调用梯度函数，但是如果使用反向传播方法 (bprop method)，梯度函数将会被反向传播方法代替。反向传播函数会接收一个包含损失对输出的梯度张量 `dout` 和一个包含前向传播结果的张量 `out` 。反向传播过程需要计算损失对输入的梯度，损失对参数变量的梯度目前暂不支持。反向传播函数必须包含自身参数。
 
     **参数：**
@@ -36,10 +36,10 @@
         为Cell添加自定义属性。
 
         在实例化Cell类时，如果入参flags不为空，会调用此方法。
- 
+
         **参数：**
- 
-        **flags** (dict) - Cell的配置信息，目前用于绑定Cell和数据集。用户也通过该参数自定义Cell属性。默认值：None。
+
+        - **flags** (dict) - Cell的配置信息，目前用于绑定Cell和数据集。用户也通过该参数自定义Cell属性。默认值：None。
 
     .. py:method:: add_flags_recursive(**flags)
 
@@ -47,7 +47,7 @@
 
         **参数：**
 
-        **flags** (dict) - Cell的配置信息，目前用于绑定Cell和数据集。用户也通过该参数自定义Cell属性。默认值：None。
+        - **flags** (dict) - Cell的配置信息，目前用于绑定Cell和数据集。用户也通过该参数自定义Cell属性。默认值：None。
 
     .. py:method:: auto_parallel_compile_and_run()
 
@@ -83,7 +83,7 @@
 
         **参数：**
 
-        **param** (Parameter) – Parameter类型，需要被转换类型的输入参数。
+        - **param** (Parameter) – Parameter类型，需要被转换类型的输入参数。
 
         **返回：**
 
@@ -117,7 +117,7 @@
         >>> for m in n.cells_and_names():
         ...    if m[0]:
         ...       names.append(m[0])
- 
+
     .. py:method:: check_names()
 
         检查Cell中的网络参数名称是否重复。
@@ -128,7 +128,7 @@
 
         **参数：**
 
-        **inputs** (tuple) – Cell的输入。
+        - **inputs** (tuple) – Cell的输入。
 
     .. py:method:: compile_and_run(*inputs)
 
@@ -136,7 +136,7 @@
 
         **参数：**
 
-        **inputs** (tuple) – Cell的输入。
+        - **inputs** (tuple) – Cell的输入。
 
         **返回：**
 
@@ -155,7 +155,7 @@
         保存checkpoint图。
 
     .. py:method:: extend_repr()
- 
+
         设置Cell的扩展表示形式。
 
         若需要在print时输出个性化的扩展信息，请在您的网络中重新实现此方法。
@@ -178,7 +178,7 @@
 
         **参数：**
 
-        **expand** (bool) – 如果为True，则递归地获取当前Cell和所有子Cell的parameter。否则，只生成当前Cell的子Cell的parameter。默认值：True。
+        - **expand** (bool) – 如果为True，则递归地获取当前Cell和所有子Cell的parameter。否则，只生成当前Cell的子Cell的parameter。默认值：True。
 
         **返回：**
 
@@ -199,21 +199,21 @@
 
         String类型，网络的作用域。
 
-.. py:method:: infer_param_pipeline_stage()
+    .. py:method:: infer_param_pipeline_stage()
 
-    推导Cell中当前 `pipeline_stage` 的参数。
+        推导Cell中当前 `pipeline_stage` 的参数。
 
-    .. note:: 
-        - 如果某参数不属于任何已被设置 `pipeline_stage` 的Cell，此参数应使用 `add_pipeline_stage` 方法来添加它的 `pipeline_stage` 信息。
-        - 如果某参数P被stageA和stageB两个不同stage的算子使用，那么参数P在使用 `infer_param_pipeline_stage` 之前，应使用 `P.add_pipeline_stage(stageA)` 和 `P.add_pipeline_stage(stageB)` 添加它的stage信息。
+        .. note::
+            - 如果某参数不属于任何已被设置 `pipeline_stage` 的Cell，此参数应使用 `add_pipeline_stage` 方法来添加它的 `pipeline_stage` 信息。
+            - 如果某参数P被stageA和stageB两个不同stage的算子使用，那么参数P在使用 `infer_param_pipeline_stage` 之前，应使用 `P.add_pipeline_stage(stageA)` 和 `P.add_pipeline_stage(stageB)` 添加它的stage信息。
 
-    **返回：**
+        **返回：**
 
-    属于当前 `pipeline_stage` 的参数。
-      
-    **异常：**
+        属于当前 `pipeline_stage` 的参数。
 
-    **RuntimeError** – 如果参数不属于任何stage。
+        **异常：**
+
+        - **RuntimeError** – 如果参数不属于任何stage。
 
 
     .. py:method:: insert_child_to_cell(child_name, child_cell)
@@ -255,7 +255,7 @@
 
         **参数：**
 
-        **params** (dict) – 用于初始化数据图的参数字典。
+        - **params** (dict) – 用于初始化数据图的参数字典。
 
 
     .. py:method:: name_cells()
@@ -307,7 +307,7 @@
 
         **参数：**
 
-        **recurse** (bool): 是否包含子Cell的参数。 默认: True。
+        - **recurse** (bool): 是否包含子Cell的参数。 默认: True。
 
         **返回：**
 
@@ -319,7 +319,7 @@
 
         **参数：**
 
-        **recurse** (bool) – 是否递归得包含所有子Cell的parameter。默认值：True。
+        - **recurse** (bool) – 是否递归得包含所有子Cell的parameter。默认值：True。
 
         **返回：**
 
@@ -329,7 +329,7 @@
 
         设置Cell重计算。Cell中的所有算子将被设置为重计算。如果一个算子的计算结果被输出到一些反向节点来进行梯度计算，且被设置成重计算，那么我们会在反向传播中重新计算它，而不去存储在前向传播中的中间激活层的计算结果。
 
-        .. note:: 
+        .. note::
             - 如果计算涉及到诸如随机化或全局变量之类的操作，那么目前还不能保证等价。
             - 如果该Cell中算子的重计算API也被调用，则该算子的重计算模式以算子的重计算API的设置为准。
             - 该接口仅配置一次，即当父Cell配置了，子Cell不需再配置。
@@ -349,7 +349,7 @@
 
         **参数：**
 
-        **fn** (function) – 以梯度作为输入的hook函数。
+        - **fn** (function) – 以梯度作为输入的hook函数。
 
     .. py:method:: remove_redundant_parameters()
 
@@ -380,7 +380,7 @@
 
         **参数：**
 
-        **requires_grad** (bool) – 指定网络是否需要梯度，如果为True，PyNative模式下Cell将构建反向网络。默认值：True。
+        - **requires_grad** (bool) – 指定网络是否需要梯度，如果为True，PyNative模式下Cell将构建反向网络。默认值：True。
 
         **返回：**
 
@@ -389,15 +389,15 @@
     .. py:method:: set_parallel_input_with_inputs(*inputs)
 
         通过并行策略对输入张量进行切分。
-      
+
         **参数**：
 
-        **inputs** (tuple) – construct方法的输入。
+        - **inputs** (tuple) – construct方法的输入。
 
     .. py:method:: set_param_fl(push_to_server=False, pull_from_server=False, requires_aggr=True)
 
         设置参数与服务器交互的方式。
-      
+
         **参数**：
 
         - **push_to_server** (bool) – 是否将参数推送到服务器。默认值：False。
@@ -423,7 +423,7 @@
 
         **参数：**
 
-        **mode** (bool) – 指定模型是否为训练模式。默认值：True。
+        - **mode** (bool) – 指定模型是否为训练模式。默认值：True。
 
         **返回：**
 
@@ -439,7 +439,7 @@
 
         **参数：**
 
-        **dst_type** (mindspore.dtype) – Cell转换为 `dst_type` 类型运行。 `dst_type` 可以是 `mindspore.dtype.float16` 或者  `mindspore.dtype.float32` 。
+        - **dst_type** (mindspore.dtype) – Cell转换为 `dst_type` 类型运行。 `dst_type` 可以是 `mindspore.dtype.float16` 或者  `mindspore.dtype.float32` 。
 
         **返回：**
 
@@ -447,7 +447,7 @@
 
         **异常：**
 
-        **ValueError** – 如果 `dst_type` 不是 `mindspore.dtype.float32` ，也不是 `mindspore.dtype.float16`。
+        - **ValueError** – 如果 `dst_type` 不是 `mindspore.dtype.float32` ，也不是 `mindspore.dtype.float16`。
 
     .. py:method:: trainable_params(recurse=True)
 
@@ -457,7 +457,7 @@
 
         **参数：**
 
-        **recurse** (bool) – 是否递归地包含当前Cell的所有子Cell的可训练参数。默认值：True。
+        - **recurse** (bool) – 是否递归地包含当前Cell的所有子Cell的可训练参数。默认值：True。
 
         **返回：**
 
@@ -471,7 +471,7 @@
 
         **参数：**
 
-        **recurse** (bool) – 是否递归地包含当前Cell的所有子Cell的不可训练参数。默认值：True。
+        - **recurse** (bool) – 是否递归地包含当前Cell的所有子Cell的不可训练参数。默认值：True。
 
         **返回：**
 
@@ -491,7 +491,7 @@
 
         **参数：**
 
-        **cell_type** (str) – 被更新的类型，`cell_type` 可以是"quant"或"second-order"。
+        - **cell_type** (str) – 被更新的类型，`cell_type` 可以是"quant"或"second-order"。
 
     .. py:method:: update_parameters_name(prefix="", recurse=True)
 

docs/api/api_python/nn/mindspore.nn.CosineDecayLR.rst

@@ -20,7 +20,7 @@ mindspore.nn.CosineDecayLR
 
     **输入：**
 
-    **global_step** (Tensor) - 当前step数。
+    - **global_step** (Tensor) - 当前step数。
 
     **输出：**
 
@@ -38,7 +38,7 @@ mindspore.nn.CosineDecayLR
     ``Ascend`` ``GPU``
 
     **样例：**
-    
+
     >>> min_lr = 0.01
     >>> max_lr = 0.1
     >>> decay_steps = 4
@@ -47,4 +47,3 @@ mindspore.nn.CosineDecayLR
     >>> result = cosine_decay_lr(global_steps)
     >>> print(result)
     0.055
-    

docs/api/api_python/nn/mindspore.nn.DistributedGradReducer.rst

@@ -9,10 +9,10 @@ mindspore.nn.DistributedGradReducer
 
     **参数：**
 
-        - **parameters** (list)：需要更新的参数。
-        - **mean** (bool)：当mean为True时，对AllReduce之后的梯度求均值。默认值：False。
-        - **degree** (int)：平均系数，通常等于设备编号。默认值：None。
-        - **fusion_type** (int)：AllReduce算子的融合类型。默认值：1。
+        - **parameters** (list) - 需要更新的参数。
+        - **mean** (bool) - 当mean为True时，对AllReduce之后的梯度求均值。默认值：False。
+        - **degree** (int) - 平均系数，通常等于设备编号。默认值：None。
+        - **fusion_type** (int) - AllReduce算子的融合类型。默认值：1。
 
     **异常：**
 
@@ -97,9 +97,8 @@ mindspore.nn.DistributedGradReducer
 
     **参数：**
 
-    **grads** (Union[Tensor, tuple[Tensor]])：操作前的梯度Tensor或tuple。
+    - **grads** (Union[Tensor, tuple[Tensor]]) - 操作前的梯度Tensor或tuple。
 
     **返回：**
 
-    **new_grads** (Union[Tensor, tuple[Tensor]])，操作后的梯度Tensor或tuple。
-        
+    - **new_grads** (Union[Tensor, tuple[Tensor]])，操作后的梯度Tensor或tuple。

docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.rst

@@ -11,14 +11,14 @@ mindspore.nn.DynamicLossScaleUpdateCell
 
    **参数：**
 
-    - **loss_scale_value** (float)：初始的梯度放大系数。
-    - **scale_factor** (int)：增减系数。
-    - **scale_window** (int)：未溢出时，增大梯度放大系数的最大连续训练步数。
+    - **loss_scale_value** (float) - 初始的梯度放大系数。
+    - **scale_factor** (int) - 增减系数。
+    - **scale_window** (int) - 未溢出时，增大梯度放大系数的最大连续训练步数。
 
     **输入：**
 
-    - **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`。
-    - **overflow** (bool)：是否发生溢出。
+    - **loss_scale** (Tensor) - 训练期间的梯度放大系数，shape为 :math:`()`。
+    - **overflow** (bool) - 是否发生溢出。
 
     **输出：**
 
@@ -55,9 +55,8 @@ mindspore.nn.DynamicLossScaleUpdateCell
     >>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
     >>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
     >>> output = train_network(input, labels)
-    
+
 
     .. py:method:: get_loss_scale()
 
         获取当前梯度放大系数。
-        

docs/api/api_python/nn/mindspore.nn.elu.rst → docs/api/api_python/nn/mindspore.nn.ELU.rst

@@ -6,7 +6,7 @@ mindspore.nn.ELU
     指数线性单元激活函数（Exponential Linear Uint activation function）。
 
     对输入的每个元素计算ELU。该激活函数定义如下：
-    
+
     .. math::
             E_{i} =
             \begin{cases}

docs/api/api_python/nn/mindspore.nn.ExponentialDecayLR.rst

@@ -29,7 +29,7 @@ mindspore.nn.ExponentialDecayLR
 
     **输入：**
 
-    **global_step** (Tensor) - 当前step数。
+    - **global_step** (Tensor) - 当前step数。
 
     **输出：**
 
@@ -56,4 +56,3 @@ mindspore.nn.ExponentialDecayLR
     >>> result = exponential_decay_lr(global_step)
     >>> print(result)
     0.09486833
-    

docs/api/api_python/nn/mindspore.nn.FTRL.rst

@@ -5,7 +5,7 @@ mindspore.nn.FTRL
     使用ApplyFtrl算子实现FTRL算法。
 
     FTRL是一种在线凸优化算法，根据损失函数自适应地选择正则化函数。详见论文 `Adaptive Bound Optimization for Online Convex Optimization <https://arxiv.org/abs/1002.4908>`_。工程文档参阅 `Ad Click Prediction: a View from the Trenches <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_。
-    
+
 
     更新公式如下：
 
@@ -31,7 +31,7 @@ mindspore.nn.FTRL
         .. include:: mindspore.nn.optim_note_weight_decay.rst
 
    **参数：**
-   
+
     - **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
 
       .. include:: mindspore.nn.optim_group_param.rst
@@ -44,35 +44,35 @@ mindspore.nn.FTRL
 
       .. include:: mindspore.nn.optim_group_order.rst
 
-    - **initial_accum** (float)：累加器 `m` 的初始值，必须大于等于零。默认值：0.1。
-    - **learning_rate** (float)：学习速率值必须为零或正数，当前不支持动态学习率。默认值：0.001。
-    - **lr_power** (float)：学习率的幂值，控制训练期间学习率的下降方式，必须小于或等于零。如果lr_power为零，则使用固定的学习率。默认值：-0.5。
+    - **initial_accum** (float) - 累加器 `m` 的初始值，必须大于等于零。默认值：0.1。
+    - **learning_rate** (float) - 学习速率值必须为零或正数，当前不支持动态学习率。默认值：0.001。
+    - **lr_power** (float) - 学习率的幂值，控制训练期间学习率的下降方式，必须小于或等于零。如果lr_power为零，则使用固定的学习率。默认值：-0.5。
     - **l1** (float)：l1正则化强度，必须大于等于零。默认值：0.0。
     - **l2** (float)：l2正则化强度，必须大于等于零。默认值：0.0。
-    - **use_locking** (bool)：如果为True，则更新操作使用锁保护。默认值：False。
+    - **use_locking** (bool) - 如果为True，则更新操作使用锁保护。默认值：False。
 
       .. include:: mindspore.nn.optim_arg_loss_scale.rst
 
-    - **weight_decay** (Union[float, int])：要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
+    - **weight_decay** (Union[float, int]) - 要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
 
     **输入：**
 
-    **grads** (tuple[Tensor])：优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
-          
+    - **grads** (tuple[Tensor]) - 优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
+
 
    **输出：**
 
-    tuple[Parameter]，更新的参数，shape与`params`相同。
+    tuple[Parameter]，更新的参数，shape与 `params` 相同。
 
    **异常：**
 
-    - **TypeError**：`initial_accum`、`learning_rate`、`lr_power`、`l1`、`l2` 或 `loss_scale` 不是float。
-    - **TypeError**：`parameters` 的元素不是Parameter或dict。
-    - **TypeError**：`weight_decay` 不是float或int。
-    - **TypeError**：`use_nesterov` 不是bool。
-    - **ValueError**：`lr_power` 大于0。
-    - **ValueError**：`loss_scale` 小于等于0。
-    - **ValueError**：`initial_accum`、`l1` 或 `l2` 小于0。
+    - **TypeError** - `initial_accum`、`learning_rate`、`lr_power`、`l1`、`l2` 或 `loss_scale` 不是float。
+    - **TypeError** - `parameters` 的元素不是Parameter或dict。
+    - **TypeError** - `weight_decay` 不是float或int。
+    - **TypeError** - `use_nesterov` 不是bool。
+    - **ValueError** - `lr_power` 大于0。
+    - **ValueError** - `loss_scale` 小于等于0。
+    - **ValueError** - `initial_accum`、`l1` 或 `l2` 小于0。
 
    **支持平台：**
 
@@ -98,6 +98,6 @@ mindspore.nn.FTRL
     >>>
     >>> loss = nn.SoftmaxCrossEntropyWithLogits()
     >>> model = Model(net, loss_fn=loss, optimizer=optim)
-    
+
 
 .. include::mindspore.nn.optim_target_unique_for_sparse.rst

docs/api/api_python/nn/mindspore.nn.FastGelu.rst

@@ -17,7 +17,7 @@ mindspore.nn.FastGelu
 
     **输入：**
 
-    - **x** (Tensor)：用于计算FastGelu的Tensor。数据类型为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
+    - **x** (Tensor) - 用于计算FastGelu的Tensor。数据类型为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
 
     **输出：**
 
@@ -39,4 +39,3 @@ mindspore.nn.FastGelu
     >>> print(output)
     [[-1.5418735e-01  3.9921875e+00 -9.7473649e-06]
      [ 1.9375000e+00 -1.0052517e-03  8.9824219e+00]]
-    

docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.rst

@@ -9,12 +9,12 @@ mindspore.nn.FixedLossScaleUpdateCell
 
    **参数：**
 
-    **loss_scale_value** (float)：初始梯度放大系数。
+    - **loss_scale_value** (float) - 初始梯度放大系数。
 
     **输入：**
 
-    - **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`，在当前类中，该值被忽略。
-    - **overflow** (bool)：是否发生溢出。
+    - **loss_scale** (Tensor) - 训练期间的梯度放大系数，shape为 :math:`()`，在当前类中，该值被忽略。
+    - **overflow** (bool) - 是否发生溢出。
 
     **输出：**
 
@@ -50,9 +50,8 @@ mindspore.nn.FixedLossScaleUpdateCell
     >>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
     >>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
     >>> output = train_network(input, labels)
-    
+
 
     .. py:method:: get_loss_scale()
 
         获取当前梯度放大系数。
-        

docs/api/api_python/nn/mindspore.nn.gelu.rst → docs/api/api_python/nn/mindspore.nn.GELU.rst

@@ -8,7 +8,7 @@ mindspore.nn.GELU
     对输入的每个元素计算GELU。
 
     GELU的定义如下：
-    
+
     .. math::
         GELU(x_i) = x_i*P(X < x_i),
 

docs/api/api_python/nn/mindspore.nn.InverseDecayLR.rst

@@ -22,14 +22,14 @@ mindspore.nn.InverseDecayLR
 
     **参数：**
 
-    - **learning_rate** (float)：学习率的初始值。
-    - **decay_rate** (float)：衰减率。
-    - **decay_steps** (int)：用于计算衰减学习率的值。
-    - **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
+    - **learning_rate** (float) - 学习率的初始值。
+    - **decay_rate** (float) - 衰减率。
+    - **decay_steps** (int) - 用于计算衰减学习率的值。
+    - **is_stair** (bool) - 如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
 
     **输入：**
 
-    **global_step** (Tensor)：当前step数。
+    - **global_step** (Tensor) - 当前step数。
 
     **输出：**
 
@@ -37,10 +37,10 @@ mindspore.nn.InverseDecayLR
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
-    - **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
-    - **ValueError**：`decay_steps` 小于1。
-    - **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
+    - **TypeError** - `learning_rate` 或 `decay_rate` 不是float。
+    - **TypeError** - `decay_steps` 不是int或 `is_stair` 不是bool。
+    - **ValueError** - `decay_steps` 小于1。
+    - **ValueError** - `learning_rate` 或 `decay_rate` 小于或等于0。
 
     **支持平台：**
 
@@ -56,4 +56,3 @@ mindspore.nn.InverseDecayLR
     >>> result = inverse_decay_lr(global_step)
     >>> print(result)
     0.1
-    

docs/api/api_python/nn/mindspore.nn.Jvp.rst

@@ -7,7 +7,7 @@ mindspore.nn.Jvp
 
     **参数：**
 
-    **fn** (Cell) - 基于Cell的网络，用于接收张量输入并返回张量或者张量元组。
+    - **fn** (Cell) - 基于Cell的网络，用于接收张量输入并返回张量或者张量元组。
 
     **输入：**
 
@@ -21,6 +21,10 @@ mindspore.nn.Jvp
     - **net_output** (Tensor or Tuple of Tensor) - 输入网络的正向计算结果。
     - **jvp** (Tensor or Tuple of Tensor) - 雅可比向量积的结果。
 
+    **支持平台：**
+
+    ``Ascend`` ``GPU`` ``CPU``
+
     **样例：**
 
     >>> from mindspore.nn import Jvp

docs/api/api_python/nn/mindspore.nn.LARS.rst

@@ -1,4 +1,4 @@
-mindspore.nn.Lamb
+mindspore.nn.LARS
 ==================
 
 .. py:class:: mindspore.nn.LARS(*args, **kwargs)
@@ -29,16 +29,16 @@ mindspore.nn.Lamb
 
     **参数：**
 
-    - **optimizer** (Optimizer)：待封装和修改梯度的MindSpore优化器。
-    - **epsilon** (float)：将添加到分母中，提高数值稳定性。默认值：1e-05。
-    - **coefficient** (float)：计算局部学习速率的信任系数。默认值：0.001。
-    - **use_clip** (bool)：计算局部学习速率时是否裁剪。默认值：False。
-    - **lars_filter** (Function)：用于指定使用LARS算法的网络参数。默认值：lambda x: 'LayerNorm' not in x.name and 'bias' not in x.name。
+    - **optimizer** (Optimizer) - 待封装和修改梯度的MindSpore优化器。
+    - **epsilon** (float) - 将添加到分母中，提高数值稳定性。默认值：1e-05。
+    - **coefficient** (float) - 计算局部学习速率的信任系数。默认值：0.001。
+    - **use_clip** (bool) - 计算局部学习速率时是否裁剪。默认值：False。
+    - **lars_filter** (Function) - 用于指定使用LARS算法的网络参数。默认值：lambda x: 'LayerNorm' not in x.name and 'bias' not in x.name。
 
     **输入：**
 
-    **gradients** (tuple[Tensor])：优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
-          
+    - **gradients** (tuple[Tensor]) - 优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
+
 
     **输出：**
 
@@ -55,4 +55,3 @@ mindspore.nn.Lamb
     >>> opt = nn.Momentum(net.trainable_params(), 0.1, 0.9)
     >>> opt_lars = nn.LARS(opt, epsilon=1e-08, coefficient=0.02)
     >>> model = Model(net, loss_fn=loss, optimizer=opt_lars, metrics=None)
-    

docs/api/api_python/nn/mindspore.nn.Lamb.rst

@@ -8,7 +8,7 @@ mindspore.nn.Lamb
     LAMB是一种采用分层自适应批优化技术的优化算法。详见论文 `LARGE BATCH OPTIMIZATION FOR DEEP LEARNING: TRAINING BERT IN 76 MINUTES <https://arxiv.org/abs/1904.00962>`_。
 
     LAMB优化器旨在不降低精度的情况下增加训练batch size，支持自适应逐元素更新和精确的分层校正。
-    
+
 
     参数更新如下：
 
@@ -45,12 +45,12 @@ mindspore.nn.Lamb
 
     - **beta1** (float)：第一矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
     - **beta2** (float)：第二矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
-    - **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
-    - **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
+    - **eps** (float) - 将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
+    - **weight_decay** (float) - 权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
 
     **输入：**
 
-    **gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
 
     **输出：**
 
@@ -58,13 +58,13 @@ mindspore.nn.Lamb
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
-    - **TypeError**：`parameters` 的元素不是Parameter或dict。
-    - **TypeError**：`beta1`、`beta2` 或 `eps` 不是float。
-    - **TypeError**：`weight_decay` 不是float或int。
-    - **ValueError**：`eps` 小于等于0。
-    - **ValueError**：`beta1`、`beta2` 不在（0.0,1.0）范围内。
-    - **ValueError**：`weight_decay` 小于0。
+    - **TypeError** - `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+    - **TypeError** - `parameters` 的元素不是Parameter或dict。
+    - **TypeError** - `beta1`、`beta2` 或 `eps` 不是float。
+    - **TypeError** - `weight_decay` 不是float或int。
+    - **ValueError** - `eps` 小于等于0。
+    - **ValueError** - `beta1`、`beta2` 不在（0.0,1.0）范围内。
+    - **ValueError** - `weight_decay` 小于0。
 
     **支持平台：**
 
@@ -91,4 +91,3 @@ mindspore.nn.Lamb
     >>>
     >>> loss = nn.SoftmaxCrossEntropyWithLogits()
     >>> model = Model(net, loss_fn=loss, optimizer=optim)
-    

docs/api/api_python/nn/mindspore.nn.LazyAdam.rst

@@ -18,7 +18,7 @@ mindspore.nn.LazyAdam
         \end{array}
 
     :math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2` ，:math:`g` 代表 `gradients` ，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2` ，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power` ， :math:`\alpha` 代表 `learning_rate` ， :math:`w` 代表 `params` ， :math:`\epsilon` 代表 `eps`。
-    
+
 
     .. note::
        .. include:: mindspore.nn.optim_note_sparse.rst
@@ -43,16 +43,16 @@ mindspore.nn.LazyAdam
 
     - **beta1** (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
     - **beta2** (float)：`moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
-    - **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
-    - **use_locking** (bool)：是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的Tensor更新将受到锁的保护。如果为False，则结果不可预测。默认值：False。
-    - **use_nesterov** (bool)：是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
-    - **weight_decay** (Union[float, int])：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
+    - **eps** (float) - 将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
+    - **use_locking** (bool) - 是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的Tensor更新将受到锁的保护。如果为False，则结果不可预测。默认值：False。
+    - **use_nesterov** (bool) - 是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
+    - **weight_decay** (Union[float, int]) - 权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
 
       .. include:: mindspore.nn.optim_arg_loss_scale.rst
 
     **输入：**
 
-    **gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
 
     **输出：**
 
@@ -60,14 +60,14 @@ mindspore.nn.LazyAdam
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
-    - **TypeError**：`parameters` 的元素不是Parameter或字典。
-    - **TypeError**：`beta1`、`beta2`、`eps` 或 `loss_scale` 不是float。
-    - **TypeError**：`weight_decay` 不是float或int。
-    - **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
-    - **ValueError**：`loss_scale` 或 `eps` 小于或等于0。
-    - **ValueError**：`beta1`、`beta2` 不在（0.0,1.0）范围内。
-    - **ValueError**：`weight_decay` 小于0。
+    - **TypeError** - `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+    - **TypeError** - `parameters` 的元素不是Parameter或字典。
+    - **TypeError** - `beta1`、`beta2`、`eps` 或 `loss_scale` 不是float。
+    - **TypeError** - `weight_decay` 不是float或int。
+    - **TypeError** - `use_locking` 或 `use_nesterov` 不是bool。
+    - **ValueError** - `loss_scale` 或 `eps` 小于或等于0。
+    - **ValueError** - `beta1`、`beta2` 不在（0.0,1.0）范围内。
+    - **ValueError** - `weight_decay` 小于0。
 
     **支持平台：**
 
@@ -94,4 +94,3 @@ mindspore.nn.LazyAdam
     >>> model = Model(net, loss_fn=loss, optimizer=optim)
 
 .. include:: mindspore.nn.optim_target_unique_for_sparse.rst
-            

docs/api/api_python/nn/mindspore.nn.Loss.rst

@@ -28,7 +28,7 @@ mindspore.nn.Loss
         计算loss的平均值。
 
         **返回：**
-        
+
         Float，loss的平均值。
 
         **异常：**
@@ -41,9 +41,9 @@ mindspore.nn.Loss
 
         **参数：**
 
-        inputs：输入只包含一个元素，且该元素为loss。loss的维度必须为0或1。
+        - **inputs** - 输入只包含一个元素，且该元素为loss。loss的维度必须为0或1。
 
         **异常：**
 
-        **ValueError**：`inputs` 的长度不为1。
-        **ValueError**：`inputs` 的维度不为0或1。
+        - **ValueError** - `inputs` 的长度不为1。
+        - **ValueError** - `inputs` 的维度不为0或1。

docs/api/api_python/nn/mindspore.nn.MSE.rst

@@ -12,19 +12,20 @@ mindspore.nn.MSE
 
     其中， :math:`n` 为batch size。
 
-   **样例：**
-        >>> import numpy as np
-        >>> from mindspore import nn, Tensor
-        >>>
-        >>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
-        >>> y = Tensor(np.array([0.1, 0.25, 0.5, 0.9]), mindspore.float32)
-        >>> error = nn.MSE()
-        >>> error.clear()
-        >>> error.update(x, y)
-        >>> result = error.eval()
+    **样例：**
+
+    >>> import numpy as np
+    >>> from mindspore import nn, Tensor
+    >>>
+    >>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
+    >>> y = Tensor(np.array([0.1, 0.25, 0.5, 0.9]), mindspore.float32)
+    >>> error = nn.MSE()
+    >>> error.clear()
+    >>> error.update(x, y)
+    >>> result = error.eval()
 
     .. py:method:: clear()
-        
+
         清除内部评估结果。
 
     .. py:method:: eval()
@@ -32,11 +33,11 @@ mindspore.nn.MSE
         计算均方差（MSE）。
 
         **返回：**
-        
+
         numpy.float64，计算结果。
 
         **异常：**
-        
+
         - **RuntimeError** - 样本数为0。
 
     .. py:method:: update(*inputs)

docs/api/api_python/nn/mindspore.nn.Metric.rst

@@ -9,7 +9,7 @@ mindspore.nn.Metric
     请勿直接使用该类，需使用子类如 :class:`mindspore.nn.MAE` 、 :class:`mindspore.nn.Recall` 等。
 
     .. py:method:: clear()
-        :abstract:
+        :abstractmethod:
 
         描述了清除内部评估结果的行为。
 
@@ -17,13 +17,13 @@ mindspore.nn.Metric
             所有子类都必须重写此接口。
 
     .. py:method:: eval()
-        :abstract:
+        :abstractmethod:
 
         描述了计算最终评估结果的行为。
 
         .. note::
             所有子类都必须重写此接口。
-        
+
     .. py:method:: indexes
         :property:
 
@@ -37,11 +37,11 @@ mindspore.nn.Metric
 
         .. note::
             在继承该类自定义评估函数时，需要用装饰器 `mindspore.nn.rearrange_inputs` 修饰 `update` 方法，否则配置的 `indexes` 值不生效。
-            
+
 
         **参数：**
 
-        **indexes** (List(int)) - logits和标签的目标顺序。
+        - **indexes** (List(int)) - logits和标签的目标顺序。
 
         **输出：**
 
@@ -62,9 +62,9 @@ mindspore.nn.Metric
         >>> accuracy = metric.eval()
         >>> print(accuracy)
         0.3333333333333333
-        
+
     .. py:method:: update(*inputs)
-        :abstract:
+        :abstractmethod:
 
         描述了更新内部评估结果的行为。
 
@@ -73,4 +73,4 @@ mindspore.nn.Metric
 
         **参数：**
 
-        **inputs** - 可变长度输入参数列表。通常是预测值和对应的真实标签。
+        - **inputs** - 可变长度输入参数列表。通常是预测值和对应的真实标签。

docs/api/api_python/nn/mindspore.nn.Momentum.rst

@@ -48,7 +48,7 @@ mindspore.nn.Momentum
 
     **输入：**
 
-    **gradients** (tuple[Tensor]) - `params` 的梯度，形状（shape）与 `params` 相同。
+    - **gradients** (tuple[Tensor]) - `params` 的梯度，形状（shape）与 `params` 相同。
 
     **输出：**
 

docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.rst

@@ -22,14 +22,14 @@ mindspore.nn.NaturalExpDecayLR
 
     **参数：**
 
-    - **learning_rate** (float)：学习率的初始值。
-    - **decay_rate** (float)：衰减率。
-    - **decay_steps** (int)：用于计算衰减学习率的值。
-    - **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
+    - **learning_rate** (float) - 学习率的初始值。
+    - **decay_rate** (float) - 衰减率。
+    - **decay_steps** (int) - 用于计算衰减学习率的值。
+    - **is_stair** (bool) - 如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
 
     **输入：**
 
-    **global_step** （Tensor）：当前step数。
+    - **global_step** （Tensor）：当前step数。
 
     **输出：**
 
@@ -37,10 +37,10 @@ mindspore.nn.NaturalExpDecayLR
 
     **异常：**
 
-    - **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
-    - **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
-    - **ValueError**：`decay_steps` 小于1。
-    - **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
+    - **TypeError** - `learning_rate` 或 `decay_rate` 不是float。
+    - **TypeError** - `decay_steps` 不是int或 `is_stair` 不是bool。
+    - **ValueError** - `decay_steps` 小于1。
+    - **ValueError** - `learning_rate` 或 `decay_rate` 小于或等于0。
 
     **支持平台：**
 
@@ -56,4 +56,3 @@ mindspore.nn.NaturalExpDecayLR
     >>> result = natural_exp_decay_lr(global_step)
     >>> print(result)
     0.1
-    

docs/api/api_python/nn/mindspore.nn.Optimizer.rst

@@ -25,7 +25,7 @@ mindspore.nn.Optimizer
       .. include:: mindspore.nn.optim_group_order.rst
 
     - **weight_decay** (Union[float, int]) - 权重衰减的整数或浮点值。必须等于或大于0。如果 `weight_decay` 是整数，它将被转换为浮点数。默认值：0.0。
- 
+
       .. include:: mindspore.nn.optim_arg_loss_scale.rst
 
     **异常：**
@@ -48,7 +48,7 @@ mindspore.nn.Optimizer
 
         **参数：**
 
-        **optim_result** (bool) - 参数更新结果。该输入用来保证参数更新完成后才执行参数广播。
+        - **optim_result** (bool) - 参数更新结果。该输入用来保证参数更新完成后才执行参数广播。
 
         **返回：**
 
@@ -62,7 +62,7 @@ mindspore.nn.Optimizer
 
         **参数：**
 
-        **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
+        - **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
 
         **返回：**
 
@@ -82,7 +82,7 @@ mindspore.nn.Optimizer
 
         **参数：**
 
-        **param** (Union[Parameter, list[Parameter]]) - `Parameter` 或 `Parameter` 列表。
+        - **param** (Union[Parameter, list[Parameter]]) - `Parameter` 或 `Parameter` 列表。
 
         **返回：**
 
@@ -109,7 +109,7 @@ mindspore.nn.Optimizer
 
         **参数：**
 
-        **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
+        - **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
 
         **返回：**
 
@@ -123,7 +123,7 @@ mindspore.nn.Optimizer
 
         **参数：**
 
-        **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
+        - **gradients** (tuple[Tensor]) - 网络参数的梯度，形状（shape）与网络参数相同。
 
         **返回：**