modify apiformat

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

@@ -375,11 +375,11 @@
 
         - **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是原始数据集的大小。
 
-            如果round四舍五入计算后：
+          如果round四舍五入计算后：
 
-                - 任何子数据集的的大小等于0，都将发生错误。
-                - 如果子数据集大小的总和小于K，K - sigma(round(fi * k))的值将添加到第一个子数据集，sigma为求和操作。
-                - 如果子数据集大小的总和大于K，sigma(round(fi * K)) - K的值将从第一个足够大的子数据集中删除，且删除后的子数据集大小至少大于1。
+          - 任何子数据集的的大小等于0，都将发生错误。
+          - 如果子数据集大小的总和小于K，K - sigma(round(fi * k))的值将添加到第一个子数据集，sigma为求和操作。
+          - 如果子数据集大小的总和大于K，sigma(round(fi * K)) - K的值将从第一个足够大的子数据集中删除，且删除后的子数据集大小至少大于1。
 
         - **randomize** (bool, 可选) - 确定是否随机拆分数据，默认值：True，数据集将被随机拆分。否则将按顺序拆分为多个不重叠的子数据集。
 

docs/api/api_python/dataset/mindspore.dataset.utils.imshow_det_bbox.rst

@@ -27,6 +27,6 @@
 
     numpy.ndarray，带边界框和类别置信度的图像。
 
-    ** `imshow_det_bbox` 在VOC2012数据集的使用图示:**
+    **imshow_det_bbox在VOC2012数据集的使用图示：**
 
-    .. image:: api_img/browse_dataset.png
+    .. image:: browse_dataset.png

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

@@ -14,7 +14,7 @@ mindspore.dataset.audio.transforms.FrequencyMasking
     - **mask_start** (int, 可选) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, freq_length - frequency_mask_param]，其中 `freq_length` 为音频波形在频域的长度，默认值：0。
     - **mask_value** (float, 可选) - 掩码填充值，默认值：0.0。
 
-    .. image:: api_img/frequency_masking_original.png
+    .. image:: frequency_masking_original.png
 
-    .. image:: api_img/frequency_masking.png
+    .. image:: frequency_masking.png
 

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

@@ -14,6 +14,6 @@ mindspore.dataset.audio.transforms.TimeMasking
     - **mask_start** (int, 可选) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, time_length - time_mask_param]，其中 `time_length` 为音频波形在时域的长度，默认值：0。
     - **mask_value** (float, 可选) - 掩码填充值，默认值：0.0。
 
-    .. image:: api_img/time_masking_original.png
+    .. image:: time_masking_original.png
 
-    .. image:: api_img/time_masking.png
+    .. image:: time_masking.png

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

@@ -13,8 +13,8 @@ mindspore.dataset.audio.transforms.TimeStretch
     - **n_freq** (int, 可选) - STFT中的滤波器组数，默认值：201。
     - **fixed_rate** (float, 可选) - 频谱在时域加快或减缓的比例，默认值：None，表示保持原始速率。
 
-    .. image:: api_img/time_stretch_rate1.5.png
+    .. image:: time_stretch_rate1.5.png
 
-    .. image:: api_img/time_stretch_original.png
+    .. image:: time_stretch_original.png
 
-    .. image:: api_img/time_stretch_rate0.8.png
+    .. image:: time_stretch_rate0.8.png

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

@@ -44,7 +44,7 @@ mindspore.common.initializer
     生成一个服从HeKaiming均匀分布U(-boundary, boundary)的随机数组用于初始化Tensor，其中：
     
     .. math::
-        boundary = \text{gain} \times \sqrt{\frac{3}{fan_mode}}
+        boundary = \text{gain} \times \sqrt{\frac{3}{fan\_mode}}
 
     其中，gain是一个可选的缩放因子。fan_mode是权重Tensor中输入或输出单元的数量，取决于mode是"fan_in"或是"fan_out"。
 
@@ -59,7 +59,7 @@ mindspore.common.initializer
     生成一个服从HeKaiming正态分布N(0, sigma^2)的随机数组用于初始化Tensor，其中：
 
     .. math::
-        sigma = \frac{gain} {\sqrt{fan_mode}}
+        sigma = \frac{gain} {\sqrt{fan\_mode}}
 
     其中，gain是一个可选的缩放因子。如果mode是"fan_in"，则fan_mode是权重Tensor中输入单元的数量，如果mode是"fan_out"，
     fan_mode是权重Tensor中输出单元的数量。

docs/api/api_python/mindspore.communication.rst

@@ -2,10 +2,10 @@ mindspore.communication
 ========================
 集合通信接口。
 
-注意，集合通信接口需要预先设置环境变量。对于Ascend，用户需要配置rank_table，设置rank_id和device_id，相关教程可参考：
-<https://www.mindspore.cn/tutorials/zh-CN/master/intermediate/distributed_training/distributed_training_ascend.html>`_。
-对于GPU，用户需要预先配置host_file以及mpi，相关教程参考：
-<https://www.mindspore.cn/tutorials/zh-CN/master/intermediate/distributed_training/distributed_training_gpu.html>`_。
+注意，集合通信接口需要预先设置环境变量。对于Ascend，用户需要配置rank_table，设置rank_id和device_id，相关教程可参考： 
+`<https://www.mindspore.cn/tutorials/zh-CN/master/intermediate/distributed_training/distributed_training_ascend.html>`_。
+对于GPU，用户需要预先配置host_file以及mpi，相关教程参考： 
+`<https://www.mindspore.cn/tutorials/zh-CN/master/intermediate/distributed_training/distributed_training_gpu.html>`_。
 
 目前尚不支持CPU。
 

docs/api/api_python/mindspore/mindspore.DatasetHelper.rst

@@ -17,16 +17,6 @@ mindspore.DatasetHelper
     - **sink_size** (int) - 控制每个下沉中的数据量。如果 `sink_size` 为-1，则下沉每个epoch的完整数据集。如果 `sink_size` 大于0，则下沉每个epoch的 `sink_size` 数据。默认值：-1。
     - **epoch_num** (int) - 控制待发送的epoch数据量。默认值：1。
 
-    **样例：**
-
-    >>> from mindspore import DatasetHelper
-    >>>
-    >>> train_dataset = create_custom_dataset()
-    >>> set_helper = DatasetHelper(train_dataset, dataset_sink_mode=False)
-    >>> # DatasetHelper对象是可迭代的
-    >>> for next_element in set_helper:
-    ...     next_element
-    
     .. py:method:: continue_send()
         
         在epoch开始时继续向设备发送数据。
@@ -35,30 +25,9 @@ mindspore.DatasetHelper
         
         返回动态数据的形状(shape)范围（最小形状(shape)，最大形状(shape)）。
 
-        **样例：**
-
-        >>>from mindspore import DatasetHelper
-        >>>
-        >>>train_dataset = create_custom_dataset()
-        >>># config dynamic shape
-        >>>dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": [None]})
-        >>>dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True)
-        >>>
-        >>>min_shapes, max_shapes = dataset_helper.dynamic_min_max_shapes()
-
-
     .. py:method:: get_data_info()
         
         下沉模式下，获取当前批次数据的类型和形状(shape)。通常在数据形状(shape)动态变化的场景使用。
-    
-        **样例：**
-
-        >>> from mindspore import DatasetHelper
-        >>>
-        >>> train_dataset = create_custom_dataset()
-        >>> dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True)
-        >>>
-        >>> types, shapes = dataset_helper.get_data_info()
 
     .. py:method:: release()
         
@@ -68,16 +37,6 @@ mindspore.DatasetHelper
         
         获取每次迭代的 `sink_size` 。
 
-        **样例：**
-
-        >>>from mindspore import DatasetHelper
-        >>>
-        >>>train_dataset = create_custom_dataset()
-        >>>dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True, sink_size=-1)
-        >>>
-        >>># if sink_size==-1, then will return the full size of source dataset.
-        >>>sink_size = dataset_helper.sink_size()
-
     .. py:method:: stop_send()
         
         停止发送数据下沉数据。
@@ -85,12 +44,3 @@ mindspore.DatasetHelper
     .. py:method:: types_shapes()
         
         从当前配置中的数据集获取类型和形状(shape)。
-
-        **样例：**
-
-        >>>from mindspore import DatasetHelper
-        >>>
-        >>>train_dataset = create_custom_dataset()
-        >>>dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True)
-        >>>
-        >>>types, shapes = dataset_helper.types_shapes()

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

@@ -10,22 +10,6 @@ mindspore.FixedLossScaleManager
     - **loss_scale** (float) - 梯度放大系数。注：如果将 `drop_overflow_update` 设为False，则定义优化器时需要将优化器的 `loss_scale` 设为相同的值。默认值：128.0。
     - **drop_overflow_update** (bool) - 出现溢出时，是否执行优化器。如果值为True，则出现溢出时不会执行优化器。默认值：True。
 
-    **样例：**
-
-    >>> from mindspore import Model, nn, FixedLossScaleManager
-    >>>
-    >>> net = Net()
-    >>> # 1) 如果存在溢出，则不执行参数更新
-    >>> loss_scale_manager = FixedLossScaleManager()
-    >>> 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)
-    >>>
-    >>> # 2) 即使发生溢出，也执行参数更新
-    >>> loss_scale = 1024.0
-    >>> 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` ，该值表示是否在发生溢出时放弃本轮参数更新。

docs/api/api_python/mindspore/mindspore.Model.rst

@@ -101,7 +101,7 @@
 
         在 `AUTO_PARALLEL` 或 `SEMI_AUTO_PARALLEL` 模式下为训练网络生成参数layout，当前仅支持在数据下沉模式下使用。
 
-        .. warning:: 这是一个实验性的原型，可能会被改变和/或删除。
+        .. warning:: 这是一个实验性的原型，可能会被改变或删除。
 
         .. note:: 这是一个预编译函数。参数必须与Model.train()函数相同。
 
@@ -143,7 +143,11 @@
         使用PYNATIVE_MODE模式或CPU处理器时，模型训练流程将以非下沉模式执行。
 
         .. 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` ，那么它会直接执行计算图而不构建。
+            - 如果 `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` ，那么它会直接执行计算图而不构建。
 
         **参数：**
 

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

@@ -6,7 +6,10 @@
     `Parameter` 是 `Tensor` 的子类，当它们被绑定为Cell的属性时，会自动添加到其参数列表中，并且可以通过Cell的某些方法获取，例如 `cell.get_parameters()` 。
 
     .. note::
-        在"semi_auto_parallel"和"auto_parallel"的并行模式下，如果使用 `Initializer` 模块初始化参数，参数的类型将为 `Tensor` ，:class:`mindspore.ops.AllGather` ，`Tensor` 仅保存张量的形状和类型信息，而不占用内存来保存实际数据。并行场景下存在参数的形状发生变化的情况，用户可以调用 `Parameter` 的 `init_data` 方法得到原始数据。如果网络中存在需要部分输入为 `Parameter` 的算子，则不允许这部分输入的 `Parameter` 进行转换。如果在 `Cell` 里初始化一个 `Parameter` 作为 `Cell` 的属性时，建议使用默认值None，否则 `Parameter` 的 `name` 可能与预期不一致。
+        - 在"semi_auto_parallel"和"auto_parallel"的并行模式下，如果使用 `Initializer` 模块初始化参数，参数的类型将为 `Tensor` ，:class:`mindspore.ops.AllGather` 。`Tensor` 仅保存张量的形状和类型信息，而不占用内存来保存实际数据。
+        - 并行场景下存在参数的形状发生变化的情况，用户可以调用 `Parameter` 的 `init_data` 方法得到原始数据。
+        - 如果网络中存在需要部分输入为 `Parameter` 的算子，则不允许这部分输入的 `Parameter` 进行转换。
+        - 如果在 `Cell` 里初始化一个 `Parameter` 作为 `Cell` 的属性时，建议使用默认值None，否则 `Parameter` 的 `name` 可能与预期不一致。
 
     **参数：**
 

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

@@ -22,17 +22,3 @@ mindspore.connect_network_with_dataset
     **异常：**
 
     - **RuntimeError** - 如果该接口在非数据下沉模式调用。
-
-    **支持平台：**
-
-    ``Ascend``  ``GPU``
-
-    **样例：**
-
-    >>> from mindspore import DatasetHelper
-    >>>
-    >>> # 调用create_dataset函数创建一个通用的数据集，参考mindpore.dataset
-    >>> train_dataset = create_custom_dataset()
-    >>> dataset_helper = DatasetHelper(train_dataset, dataset_sink_mode=True)
-    >>> net = Net()
-    >>> net_with_get_next = connect_network_with_dataset(net, dataset_helper)

docs/api/api_python/mindspore/mindspore.load.rst

@@ -11,6 +11,7 @@ mindspore.load
 
     - **file_name** (str) – MindIR文件的全路径名。
     - **kwargs** (dict) – 配置项字典。
+
       - **dec_key** (bytes) - 用于解密的字节类型密钥。 有效长度为 16、24 或 32。
       - **dec_mode** (str) - 指定解密模式，设置dec_key时生效。可选项：'AES-GCM' | 'AES-CBC'。 默认值："AES-GCM"。
 

docs/api/api_python/mindspore/mindspore.parse_print.rst

@@ -15,17 +15,5 @@ mindspore.parse_print
 
     **异常：**
 
-    **ValueError** – 指定的文件不存在或为空。
-    **RuntimeError** - 解析文件失败。
-
-    >>> x = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]).astype(np.float32)
-    >>> input_pra = Tensor(x)
-    >>> net = PrintInputTensor()
-    >>> net(input_pra)
-
-    >>> import mindspore
-    >>> data = mindspore.parse_print('./log.data')
-    >>> print(data)
-    ['print:', Tensor(shape=[2, 4], dtype=Float32, value=
-    [[ 1.00000000e+00,  2.00000000e+00,  3.00000000e+00,  4.00000000e+00],
-    [ 5.00000000e+00,  6.00000000e+00,  7.00000000e+00,  8.00000000e+00]])]
+    - **ValueError** – 指定的文件不存在或为空。
+    - **RuntimeError** - 解析文件失败。

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

@@ -18,88 +18,3 @@ mindspore.set_seed
 
     - **ValueError** – 种子值非法 (小于0)。
     - **TypeError** – 种子值非整型数。
-
-    **样例:**
-
-    >>> import numpy as np
-    >>> import mindspore as ms
-    >>> import mindspore.ops as ops
-    >>> from mindspore import Tensor, set_seed, Parameter
-    >>> from mindspore.common.initializer import initializer
-    ...
-    >>> # 注意：（1）请确保代码在动态图模式下运行；
-    >>> # （2）由于复合级别的算子需要参数为张量类型，如以下样例，
-    >>> # 当使用ops.uniform这个算子，minval和maxval用以下方法初始化:
-    >>> minval = Tensor(1.0, ms.float32)
-    >>> maxval = Tensor(2.0, ms.float32)
-    ...
-    >>> # 1. 如果没有设置全局种子，numpy.random以及initializer将会选择随机种子：
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A1
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A2
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W1
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W2
-    >>> # 重新运行程序将得到不同的结果：
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A3
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A4
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W3
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W4
-    ...
-    >>> # 2. 如果设置了全局种子，numpy.random以及initializer将会使用这个种子：
-    >>> set_seed(1234)
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A1
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A2
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W1
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W2
-    >>> # 重新运行程序将得到相同的结果：
-    >>> set_seed(1234)
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A1
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A2
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W1
-    >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W2
-    ...
-    >>> # 3. 如果全局种子或者算子种子均未设置，mindspore.ops.composite.random_ops以及
-    >>> # mindspore.nn.probability.distribution将会选择一个随机种子：
-    >>> c1 = ops.uniform((1, 4), minval, maxval) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval) # C2
-    >>> # 重新运行程序将得到不同的结果：
-    >>> c1 = ops.uniform((1, 4), minval, maxval) # C3
-    >>> c2 = ops.uniform((1, 4), minval, maxval) # C4
-    ...
-    >>> # 4. 如果设置了全局种子，但未设置算子种子，mindspore.ops.composite.random_ops以及
-    >>> # mindspore.nn.probability.distribution将会根据全局种子及默认算子种子计算出一个种子。
-    >>> # 每次调用默认算子种子都会改变，因此每次调用会得到不同的结果。
-    >>> set_seed(1234)
-    >>> c1 = ops.uniform((1, 4), minval, maxval) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval) # C2
-    >>> # 重新运行程序将得到相同的结果：
-    >>> set_seed(1234)
-    >>> c1 = ops.uniform((1, 4), minval, maxval) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval) # C2
-    ...
-    >>> # 5. 如果设置了全局种子以及算子种子，mindspore.ops.composite.random_ops以及
-    >>> # mindspore.nn.probability.distribution将根据全局种子及算子种子计数器计算出一个种子。
-    >>> # 每次调用将会更改算子种子计数器, 因此每次调用会得到不同的结果。
-    >>> set_seed(1234)
-    >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
-    >>> # 重新运行程序将得到相同的结果：
-    >>> set_seed(1234)
-    >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
-    ...
-    >>> # 6. 如果算子种子设置了但是全局种子没有设置，0将作为全局种子，那么
-    >>> # mindspore.ops.composite.random_ops以及mindspore.nn.probability.distribution运行方式同5。
-    >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
-    >>> # 重新运行程序将得到相同的结果：
-    >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
-    >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
-    ...
-    >>> # 7. 在程序中重新调用set_seed()将会重置mindspore.ops.composite.random_ops
-    >>> # 和mindspore.nn.probability.distribution的numpy种子以及算子种子计数器。
-    >>> set_seed(1234)
-    >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A1
-    >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
-    >>> set_seed(1234)
-    >>> np_2 = np.random.normal(0, 1, [1]).astype(np.float32) # still get A1
-    >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # still get C1

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

@@ -35,5 +35,5 @@ mindspore.nn.MSELoss
         
     **异常：**
 
-    **ValueError** - `reduction` 不为"mean"，"sum"，或"none"。
-    **ValueError** - `logits` 和 `labels` 的shape不同，且不能广播。
+    - **ValueError** - `reduction` 不为"mean"，"sum"，或"none"。
+    - **ValueError** - `logits` 和 `labels` 的shape不同，且不能广播。

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

@@ -112,4 +112,6 @@ mindspore.nn.Optimizer
 
         tuple[Tensor]，还原后的梯度。
 
-.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
+.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
+
+.. include:: mindspore.nn.optim_target_unique_for_sparse.b.rst

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

@@ -17,7 +17,9 @@ mindspore.nn.SmoothL1Loss
     其中，:math:`{\beta}` 代表阈值 `beta` 。
 
     .. note::
-        SmoothL1Loss可以看成 :class:`mindspore.nn.L1Loss` 的修改版本，也可以看成 :class:`mindspore.nn.L1Loss` 和 :class:`mindspore.ops.L2Loss` 的组合。 :class:`mindspore.nn.L1Loss` 计算两个输入Tensor之间的绝对误差，而 :class:`mindspore.ops.L2Loss` 计算两个输入Tensor之间的平方误差。 :class:`mindspore.ops.L2Loss` 通常更快收敛，但对离群值的鲁棒性较差。该损失函数具有较好的鲁棒性。
+        - SmoothL1Loss可以看成 :class:`mindspore.nn.L1Loss` 的修改版本，也可以看成 :class:`mindspore.nn.L1Loss` 和 :class:`mindspore.ops.L2Loss` 的组合。 
+        - :class:`mindspore.nn.L1Loss` 计算两个输入Tensor之间的绝对误差，而 :class:`mindspore.ops.L2Loss` 计算两个输入Tensor之间的平方误差。 
+        - :class:`mindspore.ops.L2Loss` 通常更快收敛，但对离群值的鲁棒性较差。该损失函数具有较好的鲁棒性。
 
     **参数：**
 

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

@@ -20,18 +20,3 @@ mindspore.nn.Vjp
 
     - **net_output** (Tensor or Tuple of Tensor) - 输入网络的正向计算结果。
     - **vjp** (Tensor or Tuple of Tensor) - 向量雅可比积的结果。
-
-    **支持平台：**
-
-    ``Ascend`` ``GPU`` ``CPU``
-
-    **样例：**
-
-    >>> from mindspore.nn import Vjp
-    >>> class Net(nn.Cell):
-    ...     def construct(self, x, y):
-    ...         return x**3 + y
-    >>> x = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
-    >>> y = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
-    >>> v = Tensor(np.array([[1, 1], [1, 1]]).astype(np.float32))
-    >>> output = Vjp(Net())(x, y, v)

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

@@ -26,11 +26,11 @@ mindspore.nn.WithLossCell
     **TypeError**：`data` 或 `label` 的数据类型既不是float16也不是float32。
 
 
-.. py:method:: backbone_network
-    :property:
-
-    获取骨干网络。
-
-    **返回：**
-
-    Cell，骨干网络。
+    .. py:method:: backbone_network
+        :property:
+    
+        获取骨干网络。
+    
+        **返回：**
+    
+        Cell，骨干网络。

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

@@ -13,7 +13,7 @@ mindspore.nn.cosine_decay_lr
 
     其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
 
-   **参数：**
+    **参数：**
 
     - **min_lr** (float) - 学习率的最小值。
     - **max_lr** (float) - 学习率的最大值。
@@ -21,7 +21,7 @@ mindspore.nn.cosine_decay_lr
     - **step_per_epoch** (int) - 每个epoch的step数。
     - **decay_epoch** (int) - 进行衰减的epoch数。
 
-   **返回：**
+    **返回：**
 
     list[float]。列表大小为 `total_step`。
 

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

@@ -1 +1,5 @@
-优化器和混合精度之间通常没有联系。但是，当使用 `FixedLossScaleManager` 且 `FixedLossScaleManager` 中的 `drop_overflow_update` 设置为False时，优化器需要设置'loss_scale'。由于此优化器没有 `loss_scale` 的参数，因此需要通过其他方式处理 `loss_scale` ，如何正确处理 `loss_scale` 详见 `LossScale <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/lossscale.html>`_。
+优化器和混合精度之间通常没有联系。但是，当使用 `FixedLossScaleManager` 且 `FixedLossScaleManager` 中的 `drop_overflow_update` 设置为False时，优化器需要设置'loss_scale'。
+
+由于此优化器没有 `loss_scale` 的参数，因此需要通过其他方式处理 `loss_scale` 。
+
+如何正确处理 `loss_scale` 详见 `LossScale <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/lossscale.html>`_。

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

@@ -1 +1,5 @@
-在参数未分组时，优化器配置的 `weight_decay` 应用于名称不含"beta"或"gamma"的网络参数，参数分组情况下，可以分组调整权重衰减策略。分组时，每组网络参数均可配置 `weight_decay` ，若未配置，则该组网络参数使用优化器中配置的 `weight_decay` 。
+在参数未分组时，优化器配置的 `weight_decay` 应用于名称不含"beta"或"gamma"的网络参数。
+
+参数分组情况下，可以分组调整权重衰减策略。
+
+分组时，每组网络参数均可配置 `weight_decay` ，若未配置，则该组网络参数使用优化器中配置的 `weight_decay` 。

docs/api/api_python/nn/mindspore.nn.optim_target_unique_for_sparse.b.rst

@@ -0,0 +1,4 @@
+    .. py:method:: unique
+            :property:
+    
+            该属性表示是否在优化器中进行梯度去重，通常用于稀疏网络。如果梯度是稀疏的则设置为True。如果前向稀疏网络已对权重去重，即梯度是稠密的，则设置为False。未进行任何配置时默认为True。

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

@@ -2,8 +2,3 @@
         :property:
 
         该属性用于指定在主机（host）上还是设备（device）上更新参数。输入类型为str，只能是'CPU'，'Ascend'或'GPU'。
-
-    .. py:method:: unique
-        :property:
-
-        该属性表示是否在优化器中进行梯度去重，通常用于稀疏网络。如果梯度是稀疏的则设置为True。如果前向稀疏网络已对权重去重，即梯度是稠密的，则设置为False。未进行任何配置时默认为True。

docs/api/api_python/nn_probability/mindspore.nn.probability.bijector.Bijector.rst

@@ -14,7 +14,17 @@ mindspore.nn.probability.bijector.Bijector
     - **param** (dict) - 用于初始化Bijector的参数。默认值：None。
 
     .. note::
-        Bijector的 `dtype` 为None时，输入值必须是float类型，除此之外没有其他强制要求。在初始化过程中，当 `dtype` 为None时，对参数的数据类型没有强制要求。但所有参数都应具有相同的float类型，否则将引发TypeError。具体来说，参数类型跟随输入值的数据类型，即当 `dtype` 为None时，Bijector的参数将被强制转换为与输入值相同的类型。当指定了 `dtype` 时，参数和输入值的 `dtype` 必须相同。当参数类型或输入值类型与 `dtype` 不相同时，将引发TypeError。只能使用mindspore的float数据类型来指定Bijector的 `dtype` 。
+        Bijector的 `dtype` 为None时，输入值必须是float类型，除此之外没有其他强制要求。
+
+        在初始化过程中，当 `dtype` 为None时，对参数的数据类型没有强制要求。
+
+        但所有参数都应具有相同的float类型，否则将引发TypeError。
+
+        具体来说，参数类型跟随输入值的数据类型，即当 `dtype` 为None时，Bijector的参数将被强制转换为与输入值相同的类型。
+
+        当指定了 `dtype` 时，参数和输入值的 `dtype` 必须相同。
+
+        当参数类型或输入值类型与 `dtype` 不相同时，将引发TypeError。只能使用mindspore的float数据类型来指定Bijector的 `dtype` 。
 
     .. py:method:: cast_param_by_value(value, para)
 

docs/api/api_python/nn_probability/mindspore.nn.probability.bijector.GumbelCDF.rst

@@ -16,7 +16,10 @@ mindspore.nn.probability.bijector.GumbelCDF
     - **name** (str) - Bijector名称。默认值：'GumbelCDF'。
 
     .. note::
-        `scale` 中元素必须大于零。对于 `inverse` 和 `inverse_log_jacobian` ，输入应在(0, 1)范围内。`loc` 和 `scale` 中元素的数据类型必须为float。如果 `loc` 、 `scale` 作为numpy.ndarray或Tensor传入，则它们必须具有相同的数据类型，否则将引发错误。
+        - `scale` 中元素必须大于零。
+        - 对于 `inverse` 和 `inverse_log_jacobian` ，输入应在(0, 1)范围内。
+        - `loc` 和 `scale` 中元素的数据类型必须为float。
+        - 如果 `loc` 、 `scale` 作为numpy.ndarray或Tensor传入，则它们必须具有相同的数据类型，否则将引发错误。
 
     **异常：**