!42192 replace the word in rst files

Merge pull request !42192 from 宦晓玲/code_docs_m0916
2022-09-16 09:33:40 +00:00 · 2022-09-16 09:33:40 +00:00 · abcc9585e4
parent 7752559826 4a175414b9
commit abcc9585e4
42 changed files with 81 additions and 81 deletions
--- a/docs/api/api_python/dataset/mindspore.dataset.DSCallback.rst
+++ b/docs/api/api_python/dataset/mindspore.dataset.DSCallback.rst
@ -8,7 +8,7 @@ mindspore.dataset.DSCallback
    用户可通过 `ds_run_context` 获取数据处理管道相关信息，包括 `cur_epoch_num` (当前epoch数)、 `cur_step_num_in_epoch` (当前epoch的step数)、 `cur_step_num` (当前step数)。

    参数：
-        - **step_size** (int, optional) - 定义相邻的 `ds_step_begin`/`ds_step_end` 调用之间相隔的step数，默认值：1，表示每个step都会调用。
+        - **step_size** (int, 可选) - 定义相邻的 `ds_step_begin`/`ds_step_end` 调用之间相隔的step数，默认值：1，表示每个step都会调用。

    .. py:method:: ds_begin(ds_run_context)

--- a/docs/api/api_python/dataset/mindspore.dataset.DatasetCache.rst
+++ b/docs/api/api_python/dataset/mindspore.dataset.DatasetCache.rst
@ -9,12 +9,12 @@ mindspore.dataset.DatasetCache

    参数：
        - **session_id** (int) - 当前数据缓存客户端的会话ID，用户在命令行开启缓存服务端后可通过 `cache_admin -g` 获取。
-        - **size** (int, optional) - 设置数据缓存服务可用的内存大小。默认值：0，表示内存使用没有限制。
-        - **spilling** (bool, optional) - 如果共享内存不足，是否将溢出部分缓存到磁盘。默认值：False。
-        - **hostname** (str, optional) - 数据缓存服务客户端的主机IP。默认值：None，表示使用默认主机IP 127.0.0.1。
-        - **port** (int, optional) - 指定连接到数据缓存服务端的端口号。默认值：None，表示端口为50052。
-        - **num_connections** (int, optional) - TCP/IP连接数量。默认值：None，表示连接数量为12。
-        - **prefetch_size** (int, optional) - 指定缓存队列大小，使用缓存功能算子时，将直接从缓存队列中获取数据。默认值：None，表示缓存队列大小为20。
+        - **size** (int, 可选) - 设置数据缓存服务可用的内存大小。默认值：0，表示内存使用没有限制。
+        - **spilling** (bool, 可选) - 如果共享内存不足，是否将溢出部分缓存到磁盘。默认值：False。
+        - **hostname** (str, 可选) - 数据缓存服务客户端的主机IP。默认值：None，表示使用默认主机IP 127.0.0.1。
+        - **port** (int, 可选) - 指定连接到数据缓存服务端的端口号。默认值：None，表示端口为50052。
+        - **num_connections** (int, 可选) - TCP/IP连接数量。默认值：None，表示连接数量为12。
+        - **prefetch_size** (int, 可选) - 指定缓存队列大小，使用缓存功能算子时，将直接从缓存队列中获取数据。默认值：None，表示缓存队列大小为20。

    .. py:method:: get_stat()

--- a/docs/api/api_python/dataset/mindspore.dataset.WaitedDSCallback.rst
+++ b/docs/api/api_python/dataset/mindspore.dataset.WaitedDSCallback.rst
@ -14,7 +14,7 @@ mindspore.dataset.WaitedDSCallback
    .. note:: 注意，第2个step或epoch开始时才会触发该调用。

    参数：
-        - **step_size** (int, optional) - 每个step包含的数据行数。通常step_size与batch_size一致，默认值：1。
+        - **step_size** (int, 可选) - 每个step包含的数据行数。通常step_size与batch_size一致，默认值：1。

    .. py:method:: sync_epoch_begin(train_run_context, ds_run_context)

--- a/docs/api/api_python/dataset/mindspore.dataset.show.rst
+++ b/docs/api/api_python/dataset/mindspore.dataset.show.rst
@ -7,4 +7,4 @@ mindspore.dataset.show

    参数：
        - **dataset** (Dataset) - 数据处理管道对象。
-        - **indentation** (int, optional) - 设置MindSpore的INFO级别日志文件打印时的缩进字符数。若为None，则不缩进。
+        - **indentation** (int, 可选) - 设置MindSpore的INFO级别日志文件打印时的缩进字符数。若为None，则不缩进。
--- a/docs/api/api_python/dataset/mindspore.dataset.utils.imshow_det_bbox.rst
+++ b/docs/api/api_python/dataset/mindspore.dataset.utils.imshow_det_bbox.rst
@ -20,7 +20,7 @@
        - **show** (bool) - 是否显示图像，默认值：True。
        - **win_name** (str) - 指定窗口名称，默认值："win"。
        - **wait_time** (int) - 指定cv2.waitKey的时延，单位为ms，即图像显示的自动切换间隔，默认值：2000，表示间隔为2000ms。
-        - **out_file** (str, optional) - 输出图像的文件路径，用于在绘制后将结果存储到本地，默认值：None，不保存。
+        - **out_file** (str, 可选) - 输出图像的文件路径，用于在绘制后将结果存储到本地，默认值：None，不保存。

    返回：
        numpy.ndarray，带边界框和类别置信度的图像。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.argmax.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.argmax.rst
@ -6,7 +6,7 @@ mindspore.Tensor.argmax
    返回指定轴上最大值的索引。

    参数：
-        - **axis** (int, optional) - 默认情况下，返回扁平化Tensor的最大值序号，否则返回指定轴方向上。
+        - **axis** (int, 可选) - 默认情况下，返回扁平化Tensor的最大值序号，否则返回指定轴方向上。

    返回：
        Tensor，最大值的索引。它与原始Tensor具有相同的shape，但移除了轴方向上的维度。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.argmin.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.argmin.rst
@ -6,7 +6,7 @@ mindspore.Tensor.argmin
    返回指定轴上最小值的索引。

    参数：
-        - **axis** (int, optional) - 返回扁平化Tensor的最小值序号，否则返回指定轴方向上的最小值序号。默认值: None。
+        - **axis** (int, 可选) - 返回扁平化Tensor的最小值序号，否则返回指定轴方向上的最小值序号。默认值: None。

    返回：
        Tensor，最小Tensor的索引。它与原始Tensor具有相同的shape，但移除了轴方向上的维度。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.astype.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.astype.rst
@ -7,7 +7,7 @@ mindspore.Tensor.astype

    参数：
        - **dtype** (Union[`mindspore.dtype` , `numpy.dtype` , str]) - 指定的Tensor数据类型，可以是: `mindspore.dtype.float32` , `numpy.float32` 或 `float32` 的格式。默认值：`mindspore.dtype.float32` 。
-        - **copy** (bool, optional) - 默认情况下，astype返回新拷贝的Tensor。如果该参数设为False，则返回输入Tensor而不是副本。默认值：True。
+        - **copy** (bool, 可选) - 默认情况下，astype返回新拷贝的Tensor。如果该参数设为False，则返回输入Tensor而不是副本。默认值：True。

    返回：
        Tensor，指定数据类型的Tensor。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.choose.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.choose.rst
@ -7,7 +7,7 @@ mindspore.Tensor.choose

    参数：
        - **choices** (Union[tuple, list, Tensor]) - 索引选择数组。原始输入Tensor和 `choices` 的广播维度必须相同。如果 `choices` 本身是一个Tensor，则其最外层的维度（即，对应于第0维的维度）被用来定义 `choices` 数组。
-        - **mode** ('raise', 'wrap', 'clip', optional) - 指定如何处理 `[0, n-1]` 外部的索引：
+        - **mode** ('raise', 'wrap', 'clip', 可选) - 指定如何处理 `[0, n-1]` 外部的索引：

          - **raise** - 引发异常（默认）；
          - **wrap** - 原值映射为对n取余后的值；
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.clip.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.clip.rst
@ -14,7 +14,7 @@ mindspore.Tensor.clip
    参数：
        - **xmin** (Tensor, scalar, None) - 最小值。如果值为None，则不在间隔的下边缘执行裁剪操作。`xmin` 或 `xmax` 只能有一个为None。
        - **xmax** (Tensor, scalar, None) - 最大值。如果值为None，则不在间隔的上边缘执行裁剪操作。`xmin` 或 `xmax` 只能有一个为None。如果 `xmin` 或 `xmax` 是Tensor，则三个Tensor将被广播进行shape匹配。
-        - **dtype** (`mindspore.dtype` , optional) - 覆盖输出Tensor的dtype。默认值为None。
+        - **dtype** (`mindspore.dtype` , 可选) - 覆盖输出Tensor的dtype。默认值为None。

    返回：
        Tensor，含有输入Tensor的元素，其中values < `xmin` 被替换为 `xmin` ，values > `xmax` 被替换为 `xmax` 。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cumsum.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cumsum.rst
@ -9,8 +9,8 @@ mindspore.Tensor.cumsum
        如果 `dtype` 为 `int8` , `int16` 或 `bool` ，则结果 `dtype` 将提升为 `int32` ，不支持 `int64` 。

    参数：
-        - **axis** (int, optional) - 轴，在该轴方向上的累积和。默认情况下，计算所有元素的累加和。
-        - **dtype** (`mindspore.dtype` , optional) - 如果未指定参数值，则保持与原始Tensor相同，除非参数值是一个精度小于 `float32` 的整数。在这种情况下，使用 `float32` 。默认值：None。
+        - **axis** (int, 可选) - 轴，在该轴方向上的累积和。默认情况下，计算所有元素的累加和。
+        - **dtype** (`mindspore.dtype` , 可选) - 如果未指定参数值，则保持与原始Tensor相同，除非参数值是一个精度小于 `float32` 的整数。在这种情况下，使用 `float32` 。默认值：None。

    返回：
        Tensor。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.diagonal.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.diagonal.rst
@ -6,9 +6,9 @@ mindspore.Tensor.diagonal
    返回指定的对角线。

    参数：
-        - **offset** (int, optional) - 对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
-        - **axis1** (int, optional) - 二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
-        - **axis2** (int, optional) - 二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
+        - **offset** (int, 可选) - 对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
+        - **axis1** (int, 可选) - 二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
+        - **axis2** (int, 可选) - 二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。

    返回：
        Tensor，如果Tensor是二维，则返回值是一维数组。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.flatten.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.flatten.rst
@ -6,7 +6,7 @@ mindspore.Tensor.flatten
    返回展开成一维的Tensor的副本。

    参数：
-        - **order** (str, optional) - 可以在'C'和'F'之间进行选择。'C'表示按行优先（C风格）顺序展开。'F'表示按列优先顺序（Fortran风格）进行扁平化。仅支持'C'和'F'。默认值：'C'。
+        - **order** (str, 可选) - 可以在'C'和'F'之间进行选择。'C'表示按行优先（C风格）顺序展开。'F'表示按列优先顺序（Fortran风格）进行扁平化。仅支持'C'和'F'。默认值：'C'。

    返回：
        Tensor，具有与输入相同的数据类型。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.isclose.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.isclose.rst
@ -7,9 +7,9 @@ mindspore.Tensor.isclose

    参数：
        - **x2** (Tensor) - 对比的第二个输入，支持的类型有float32，float16，int32。
-        - **rtol** (float, optional) - 相对容忍度。默认值：1e-05。
-        - **atol** (float, optional) - 绝对容忍度。默认值：1e-08。
-        - **equal_nan** (bool, optional) - IsNan的输入，任意维度的Tensor。默认值：False。
+        - **rtol** (float, 可选) - 相对容忍度。默认值：1e-05。
+        - **atol** (float, 可选) - 绝对容忍度。默认值：1e-08。
+        - **equal_nan** (bool, 可选) - IsNan的输入，任意维度的Tensor。默认值：False。

    返回：
        Tensor，shape与广播后的shape相同，数据类型是布尔型。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.max.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.max.rst
@ -6,10 +6,10 @@ mindspore.Tensor.max
    返回Tensor的最大值或轴方向上的最大值。

    参数：
-        - **axis** (Union[None, int, list, tuple of ints], optional) - 轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最大值，而不是在单个轴或所有轴上进行选择。默认值：None。
-        - **keepdims** (bool, optional) - 如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
-        - **initial** (scalar, optional) - 输出元素的最小值。如果对空切片进行计算，则该参数必须设置。默认值：None。
-        - **where** (bool Tensor, optional) - 一个bool数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。
+        - **axis** (Union[None, int, list, tuple of ints], 可选) - 轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最大值，而不是在单个轴或所有轴上进行选择。默认值：None。
+        - **keepdims** (bool, 可选) - 如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
+        - **initial** (scalar, 可选) - 输出元素的最小值。如果对空切片进行计算，则该参数必须设置。默认值：None。
+        - **where** (bool Tensor, 可选) - 一个bool数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。

    返回：
        Tensor或标量，输入Tensor的最大值。如果 `axis` 为None，则结果是一个标量值。如果提供了 `axis` ，则结果是Tensor ndim - 1维度的一个数组。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.min.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.min.rst
@ -6,10 +6,10 @@ mindspore.Tensor.min
    返回Tensor的最小值或轴方向上的最小值。

    参数：
-        - **axis** (Union[None, int, list, tuple of ints], optional) - 轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最小值，而不是在单个轴或所有轴上进行选择。默认值：None。
-        - **keepdims** (bool, optional) - 如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
-        - **initial** (scalar, optional) - 输出元素的最大值。如果对空切片进行计算，则该参数必须设置。默认值：None。
-        - **where** (bool Tensor, optional) - 一个布尔数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。
+        - **axis** (Union[None, int, list, tuple of ints], 可选) - 轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最小值，而不是在单个轴或所有轴上进行选择。默认值：None。
+        - **keepdims** (bool, 可选) - 如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
+        - **initial** (scalar, 可选) - 输出元素的最大值。如果对空切片进行计算，则该参数必须设置。默认值：None。
+        - **where** (bool Tensor, 可选) - 一个布尔数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。

    返回：
        Tensor或标量，输入Tensor的最小值。如果轴为None，则结果为一个标量值。如果提供了 `axis` ，则结果是Tensor.ndim - 1维度的一个数组。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.repeat.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.repeat.rst
@ -7,7 +7,7 @@ mindspore.Tensor.repeat

    参数：
        - **repeats** (Union[int, tuple, list]) - 每个元素的重复次数，`repeats` 被广播以适应指定轴的shape。
-        - **axis** (int, optional) - 轴方向上的重复值。默认情况下，使用展开的输入Tensor，并返回一个展开的输出Tensor。
+        - **axis** (int, 可选) - 轴方向上的重复值。默认情况下，使用展开的输入Tensor，并返回一个展开的输出Tensor。

    返回：
        Tensor，除了维度外，与输入Tensor具有相同的shape。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.searchsorted.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.searchsorted.rst
@ -7,7 +7,7 @@ mindspore.Tensor.searchsorted

    参数：
        - **v** (Union[int, float, bool, list, tuple, Tensor]) - 要插入元素的值。
-        - **side** ('left', 'right', optional) - 如果参数值为'left'，则给出找到的第一个合适位置的索引。如果参数值为'right'，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是Tensor的长度）。默认值：'left'。
+        - **side** ('left', 'right', 可选) - 如果参数值为'left'，则给出找到的第一个合适位置的索引。如果参数值为'right'，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是Tensor的长度）。默认值：'left'。
        - **sorter** (Union[int, float, bool, list, tuple, Tensor]) - 整数索引的可选一维数组，将Tensor按升序排序。它们通常是NumPy argsort方法的结果。默认值：None。

    返回：
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.squeeze.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.squeeze.rst
@ -6,7 +6,7 @@ mindspore.Tensor.squeeze
    从Tensor中删除shape为1的维度。

    参数：
-        - **axis** (Union[None, int, list(int), tuple(int)], optional) - 选择shape中长度为1的条目的子集。如果选择shape条目长度大于1的轴，则报错。默认值为None。
+        - **axis** (Union[None, int, list(int), tuple(int)], 可选) - 选择shape中长度为1的条目的子集。如果选择shape条目长度大于1的轴，则报错。默认值为None。

    返回：
        Tensor，删除了长度为1的维度的全部子集或一个子集。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.sum.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.sum.rst
@ -10,7 +10,7 @@ mindspore.Tensor.sum

    参数：
        - **axis** (Union[None, int, tuple(int)]) - 指定维度，在该维度方向上进行求和运算。默认值：None。如果参数值为None，会计算输入数组中所有元素的和。如果axis为负数，则从最后一维开始往第一维计算。如果axis为整数元组，会对该元组指定的所有轴方向上的元素进行求和。
-        - **dtype** (`mindspore.dtype`, optional) - 默认值为None。会覆盖输出Tensor的dtype。
+        - **dtype** (`mindspore.dtype`, 可选) - 默认值为None。会覆盖输出Tensor的dtype。
        - **keepdims** (bool) - 如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。如果设为默认值，那么 `keepdims` 不会被传递给ndarray子类的sum方法。但是任何非默认值都会被传递。如果子类的方法未实现 `keepdims` ，则引发异常。默认值：False。
        - **initial** (scalar) - 初始化的起始值。默认值：None。

--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.svd.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.svd.rst
@ -8,8 +8,8 @@ mindspore.Tensor.svd
    更多参考详见 :func:`mindspore.ops.svd`。

    参数：
-        - **full_matrices** (bool, optional) - 如果这个参数为True，则计算完整的 :math:`U` 和 :math:`V` 。否则 :math:`U` 和 :math:`V` 的shape和P有关。P是M和N的较小值。M和N是输入矩阵的行和列。默认值：False。
-        - **compute_uv** (bool, optional) - 如果这个参数为True，则计算 :math:`U` 和 :math:`V` 。如果为false，只计算 :math:`S` 。默认值：True。
+        - **full_matrices** (bool, 可选) - 如果这个参数为True，则计算完整的 :math:`U` 和 :math:`V` 。否则 :math:`U` 和 :math:`V` 的shape和P有关。P是M和N的较小值。M和N是输入矩阵的行和列。默认值：False。
+        - **compute_uv** (bool, 可选) - 如果这个参数为True，则计算 :math:`U` 和 :math:`V` 。如果为false，只计算 :math:`S` 。默认值：True。

    返回：
        - **s** (Tensor) - 奇异值。shape为 :math:`(*, P)`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.take.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.take.rst
@ -7,8 +7,8 @@ mindspore.Tensor.take

    参数：
        - **indices** (Tensor) - 待提取的值的shape为 `(Nj...)` 的索引。
-        - **axis** (int, optional) - 在指定维度上选择值。默认情况下，使用展开的输入数组。默认值：None。
-        - **mode** ('raise', 'wrap', 'clip', optional)
+        - **axis** (int, 可选) - 在指定维度上选择值。默认情况下，使用展开的输入数组。默认值：None。
+        - **mode** ('raise', 'wrap', 'clip', 可选)

          - raise：抛出错误。
          - wrap：绕接。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.top_k.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.top_k.rst
@ -21,7 +21,7 @@ mindspore.Tensor.top_k

    参数：
        - **k** (int) - 指定计算最大元素的数量，需要是常量。
-        - **sorted** (bool, optional) - 如果为True，则获取的元素将按值降序排序。默认值：True。
+        - **sorted** (bool, 可选) - 如果为True，则获取的元素将按值降序排序。默认值：True。

    返回：
        2个Tensor组成的tuple， `values` 和 `indices` 。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.trace.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.trace.rst
@ -6,10 +6,10 @@ mindspore.Tensor.trace
    在Tensor的对角线方向上的总和。

    参数：
-        - **offset** (int, optional) - 对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
-        - **axis1** (int, optional) - 二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
-        - **axis2** (int, optional) - 二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
-        - **dtype** (`mindspore.dtype` , optional) - 默认值为None。覆盖输出Tensor的dtype。
+        - **offset** (int, 可选) - 对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
+        - **axis1** (int, 可选) - 二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
+        - **axis2** (int, 可选) - 二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
+        - **dtype** (`mindspore.dtype` , 可选) - 默认值为None。覆盖输出Tensor的dtype。

    返回：
        Tensor，对角线方向上的总和。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.transpose.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.transpose.rst
@ -12,7 +12,7 @@ mindspore.Tensor.transpose
    如果未提供轴，且Tensor.shape等于(i[0], i[1],...i[n-2], i[n-1])，则Tensor.transpose().shape等于(i[n-1], i[n-2], ... i[1], i[0])。

    参数：
-        - **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], 可选) - 如果 `axes` 为None或未设置，则该方法将反转维度。如果 `axes` 为tuple(int)或list(int)，则Tensor.transpose()把Tensor转置为新的维度。如果 `axes` 为整数，则此表单仅作为元组/列表表单的备选。

    返回：
        Tensor，具有与输入Tensor相同的维度，其中维度被准确的排列。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.unique_consecutive.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.unique_consecutive.rst
@ -6,9 +6,9 @@ mindspore.Tensor.unique_consecutive
    返回输入张量中每个连续等效元素组中唯一的元素。

    参数：
-        - **return_idx** (bool, optional) - 是否返回原始输入中，各元素在返回的唯一列表中的结束位置的索引。默认值：False。
-        - **return_counts** (bool, optional) - 是否返回每个唯一元素的计数。默认值：False。
-        - **axis** (int, optional) - 维度。如果为None，对输入进行展平操作，返回其唯一性。如果指定，必须是int32或int64类型。默认值：None。
+        - **return_idx** (bool, 可选) - 是否返回原始输入中，各元素在返回的唯一列表中的结束位置的索引。默认值：False。
+        - **return_counts** (bool, 可选) - 是否返回每个唯一元素的计数。默认值：False。
+        - **axis** (int, 可选) - 维度。如果为None，对输入进行展平操作，返回其唯一性。如果指定，必须是int32或int64类型。默认值：None。

    返回：
        Tensor或包含Tensor对象的元组（ `output` 、 `idx` 、 `counts` ）。 `output` 与输入张量具有相同的类型，用于表示唯一标量元素的输出列表。
--- a/docs/api/api_python/nn/mindspore.nn.BCEWithLogitsLoss.rst
+++ b/docs/api/api_python/nn/mindspore.nn.BCEWithLogitsLoss.rst
@ -24,8 +24,8 @@ mindspore.nn.BCEWithLogitsLoss

    参数：
        - **reduction** (str) - 指定输出结果的计算方式。可选值有：'mean' ， 'sum' ，和 'none' 。如果为 'none' ，则不执行reduction。默认值：'mean' 。
-        - **weight** (Tensor, optional) - 指定每个批次二值交叉熵的权重。如果不是None，将进行广播，其shape与 `logits` 的shape保持一致，数据类型为float16或float32。默认值：None。
-        - **pos_weight** (Tensor, optional) - 指定正样本的权重。是一个长度等于分类数的向量。如果不是None，将进行广播，其shape与 `logits` 的shape保持一致，数据类型必须为float16或float32。默认值：None。
+        - **weight** (Tensor, 可选) - 指定每个批次二值交叉熵的权重。如果不是None，将进行广播，其shape与 `logits` 的shape保持一致，数据类型为float16或float32。默认值：None。
+        - **pos_weight** (Tensor, 可选) - 指定正样本的权重。是一个长度等于分类数的向量。如果不是None，将进行广播，其shape与 `logits` 的shape保持一致，数据类型必须为float16或float32。默认值：None。

    输入：
        - **logits** (Tensor) - 输入预测值Tensor，shape :math:`(N,*)` ，其中 `*` 代表任意数量的附加维度。数据类型必须为float16或float32。
--- a/docs/api/api_python/ops/mindspore.ops.BinaryCrossEntropy.rst
+++ b/docs/api/api_python/ops/mindspore.ops.BinaryCrossEntropy.rst
@ -30,7 +30,7 @@ mindspore.ops.BinaryCrossEntropy
    输入：
        - **logits** (Tensor) - 输入预测值。任意维度的Tensor，其数据类型必须为float16或float32。
        - **labels** (Tensor) - 输入目标值，其shape和数据类型与 `logits` 相同。
-        - **weight** (Tensor, optional) - 每个批次二值交叉熵的权重。且shape和数据类型必须与 `logits` 相同。默认值：None。
+        - **weight** (Tensor, 可选) - 每个批次二值交叉熵的权重。且shape和数据类型必须与 `logits` 相同。默认值：None。

    输出：
        Tensor，与 `logits` 有相同的数据类型。如果 `reduction` 为'none'，则shape与 `logits` 相同。否则，输出为Scalar Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.CropAndResize.rst
+++ b/docs/api/api_python/ops/mindspore.ops.CropAndResize.rst
@ -9,8 +9,8 @@ mindspore.ops.CropAndResize
        如果输出shape依赖于 `crop_size` 的值，则 `crop_size` 必须为常量。

    参数：
-        - **method** (str, optional) - 指定调整大小的采样方法，为可选字符串。提供的方法有："bilinear"、"nearest"或"bilinear_v2"。"bilinear"代表标准双线性插值算法，而"bilinear_v2"在某些情况下可能会产生更好的结果。默认值："bilinear"。
-        - **extrapolation_value** (float, optional) - 外插值，数据类型为float。默认值：0.0。
+        - **method** (str, 可选) - 指定调整大小的采样方法，为可选字符串。提供的方法有："bilinear"、"nearest"或"bilinear_v2"。"bilinear"代表标准双线性插值算法，而"bilinear_v2"在某些情况下可能会产生更好的结果。默认值："bilinear"。
+        - **extrapolation_value** (float, 可选) - 外插值，数据类型为float。默认值：0.0。

    输入：
        - **x** (Tensor) - 输入为四维的Tensor，其shape必须是 :math:`(batch, image\_height, image\_width, depth)` 。支持的数据类型：int8、int16、int32、int64、float16、float32、float64、uint8、uint16。
--- a/docs/api/api_python/ops/mindspore.ops.HistogramFixedWidth.rst
+++ b/docs/api/api_python/ops/mindspore.ops.HistogramFixedWidth.rst
@ -7,7 +7,7 @@ mindspore.ops.HistogramFixedWidth

    参数：
        - **nbins** (int) - 直方图的组数，类型为正整数。
-        - **dtype** (str, optional) - 可选属性。数据类型必须为int32。默认值："int32"。
+        - **dtype** (str, 可选) - 可选属性。数据类型必须为int32。默认值："int32"。

    输入：
        - **x** (Tensor) - HistogramFixedWidth的输入，为一个Tensor。数据类型必须为int32、float32或float16。
--- a/docs/api/api_python/ops/mindspore.ops.func_bernoulli.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_bernoulli.rst
@ -11,8 +11,8 @@ mindspore.ops.bernoulli

    参数：
        - **x** (Tensor) - 任意维度的Tensor，其数据类型为int8, uint8, int16, int32，int64，bool, float32或float64。
-        - **p** (Union[Tensor, float], optional) - shape需要可以被广播到当前Tensor。其数据类型为float32或float64。`p` 中每个值代表输出Tensor中对应广播位置为1的概率，数值范围在0到1之间。默认值：0.5。
-        - **seed** (int, optional) - 随机种子，用于生成随机数，数值范围是-1或正整数。默认值：-1，代表取当前时间戳。
+        - **p** (Union[Tensor, float], 可选) - shape需要可以被广播到当前Tensor。其数据类型为float32或float64。`p` 中每个值代表输出Tensor中对应广播位置为1的概率，数值范围在0到1之间。默认值：0.5。
+        - **seed** (int, 可选) - 随机种子，用于生成随机数，数值范围是-1或正整数。默认值：-1，代表取当前时间戳。

    返回：
        - **output** (Tensor) - shape和数据类型与 `x` 相同。
--- a/docs/api/api_python/ops/mindspore.ops.func_isclose.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_isclose.rst
@ -12,9 +12,9 @@ mindspore.ops.isclose
    参数：
        - **x1** (Tensor) - 对比的第一个输入，支持的类型有float32，float16，int32。
        - **x2** (Tensor) - 对比的第二个输入，支持的类型有float32，float16，int32。
-        - **rtol** (float, optional) - 相对容忍度。默认值：1e-05。
-        - **atol** (float, optional) - 绝对容忍度。默认值：1e-08。
-        - **equal_nan** (bool, optional) - 若为True，则两个NaN被视为相同。默认值：False。
+        - **rtol** (float, 可选) - 相对容忍度。默认值：1e-05。
+        - **atol** (float, 可选) - 绝对容忍度。默认值：1e-08。
+        - **equal_nan** (bool, 可选) - 若为True，则两个NaN被视为相同。默认值：False。

    返回：
        Tensor，shape与广播后的shape相同，数据类型是布尔型。
--- a/docs/api/api_python/ops/mindspore.ops.func_matrix_diag.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_matrix_diag.rst
@ -9,11 +9,11 @@ mindspore.ops.matrix_diag

    参数：
        - **x** (Tensor) - 对角线Tensor。
-        - **k** (Union[int, Tensor], optional) - int32类型的Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且k[0]不得大于k[1]。该值必须在必须在（-num_rows，num_cols）中。默认值：0。
-        - **num_rows** (Union[int, Tensor], optional) - int32类型的单值Tensor，表示输出Tensor的行数。若该值为-1，则表示输出Tensor的最内层矩阵是一个方阵，实际行数将由其他输入推导。默认值：-1。
-        - **num_cols** (Union[int, Tensor], optional) - int32类型的单值Tensor，表示输出Tensor的列数。若该值为-1，则表示输出Tensor的最内层矩阵是一个方阵，实际列数将由其他输入推导。默认值：-1。
-        - **padding_value** (Union[int, float, Tensor], optional) - 与 `x` 相同的数据类型的单值Tensor，表示填充对角线带外区域的数值，默认值：0。
-        - **align** (str, optional) - 一个字符串，指定超对角线和次对角线的对齐方式。可选字符串有：RIGHT_LEFT、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。
+        - **k** (Union[int, Tensor], 可选) - int32类型的Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且k[0]不得大于k[1]。该值必须在必须在（-num_rows，num_cols）中。默认值：0。
+        - **num_rows** (Union[int, Tensor], 可选) - int32类型的单值Tensor，表示输出Tensor的行数。若该值为-1，则表示输出Tensor的最内层矩阵是一个方阵，实际行数将由其他输入推导。默认值：-1。
+        - **num_cols** (Union[int, Tensor], 可选) - int32类型的单值Tensor，表示输出Tensor的列数。若该值为-1，则表示输出Tensor的最内层矩阵是一个方阵，实际列数将由其他输入推导。默认值：-1。
+        - **padding_value** (Union[int, float, Tensor], 可选) - 与 `x` 相同的数据类型的单值Tensor，表示填充对角线带外区域的数值，默认值：0。
+        - **align** (str, 可选) - 一个字符串，指定超对角线和次对角线的对齐方式。可选字符串有：RIGHT_LEFT、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。

    返回：
        Tensor，与 `x` 的类型相同。
--- a/docs/api/api_python/ops/mindspore.ops.func_matrix_diag_part.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_matrix_diag_part.rst
@ -8,9 +8,9 @@ mindspore.ops.matrix_diag_part

    参数：
        - **x** (Tensor) - 输入Tensor，维度r需要满足 r >= 2。
-        - **k** (Union[int, Tensor], optional) - int或int32类型的Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且k[0]不得大于k[1]。该值必须在必须在（-x.shape[-2], x.shape[-1]）中。默认值：0。
-        - **padding_value** (Union[int, float, Tensor], optional) - 与 `x` 相同的数据类型的单值Tensor，表示填充对角线带外区域的数值，默认值：0。
-        - **align** (str, optional) - 一个字符串，指定超对角线和次对角线的对齐方式。可选字符串有："RIGHT_LEFT"、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。
+        - **k** (Union[int, Tensor], 可选) - int或int32类型的Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且k[0]不得大于k[1]。该值必须在必须在（-x.shape[-2], x.shape[-1]）中。默认值：0。
+        - **padding_value** (Union[int, float, Tensor], 可选) - 与 `x` 相同的数据类型的单值Tensor，表示填充对角线带外区域的数值，默认值：0。
+        - **align** (str, 可选) - 一个字符串，指定超对角线和次对角线的对齐方式。可选字符串有："RIGHT_LEFT"、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。

    返回：
        Tensor，与 `x` 的类型相同。
--- a/docs/api/api_python/ops/mindspore.ops.func_matrix_set_diag.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_matrix_set_diag.rst
@ -14,8 +14,8 @@ mindspore.ops.matrix_set_diag
    参数：
        - **x** (Tensor) - 输入Tensor，其维度为 `r+1` 需要满足 `r >=1` 。
        - **diagonal** (Tensor) - 输入对角线Tensor，具有与 `x` 相同的数据类型。当 `k` 是整数或 :math:`k[0] == k[1]` 时，其为维度 `r` ，否则，其维度 `r + 1` 。
-        - **k** (Union[int, Tensor], optional) - int32常量或int32类型Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且 `k[0]` 不得大于 `k[1]` 。该值必须在必须在 :math:`(-x.shape[-2], x.shape[-1])` 中。默认值：0。
-        - **align** (str, optional) - 字符串，指定超对角线和次对角线的对齐方式。可选值："RIGHT_LEFT"、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。
+        - **k** (Union[int, Tensor], 可选) - int32常量或int32类型Tensor。对角线偏移。正值表示超对角线，0表示主对角线，负值表示次对角线。k可以是单个整数（对于单个对角线）或一对整数，指定矩阵带的上界和下界，且 `k[0]` 不得大于 `k[1]` 。该值必须在必须在 :math:`(-x.shape[-2], x.shape[-1])` 中。默认值：0。
+        - **align** (str, 可选) - 字符串，指定超对角线和次对角线的对齐方式。可选值："RIGHT_LEFT"、"LEFT_RIGHT"、"LEFT_LEFT"、"RIGHT_RIGHT"。例如，"RIGHT_LEFT"表示将超对角线与右侧对齐（左侧填充行），将次对角线与左侧对齐（右侧填充行）。默认值："RIGHT_LEFT"。

    返回：
        Tensor，与 `x` 的类型相同。
--- a/docs/api/api_python/ops/mindspore.ops.func_meshgrid.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_meshgrid.rst
@ -9,7 +9,7 @@ mindspore.ops.meshgrid

    参数：
        - **inputs** (Union[tuple]) - N个一维Tensor。输入的长度应大于1。数据类型为Number。
-        - **indexing** ('xy', 'ij', optional) - 'xy'或'ij'。影响输出的网格矩阵的size。对于长度为 `M` 和 `N` 的二维输入，取值为'xy'时，输出的shape为 :math:`(N, M)` ，取值为'ij'时，输出的shape为 :math:`(M, N)` 。以长度为 `M` ， `N` 和 `P` 的三维输入，取值为'xy'时，输出的shape为 :math:`(N, M, P)` ，取值为'ij'时，输出的shape为 :math:`(M, N, P)` 。默认值：'xy'。
+        - **indexing** ('xy', 'ij', 可选) - 'xy'或'ij'。影响输出的网格矩阵的size。对于长度为 `M` 和 `N` 的二维输入，取值为'xy'时，输出的shape为 :math:`(N, M)` ，取值为'ij'时，输出的shape为 :math:`(M, N)` 。以长度为 `M` ， `N` 和 `P` 的三维输入，取值为'xy'时，输出的shape为 :math:`(N, M, P)` ，取值为'ij'时，输出的shape为 :math:`(M, N, P)` 。默认值：'xy'。

    返回：
        Tensor，N个N维tensor对象的元组。数据类型与输入相同。
--- a/docs/api/api_python/ops/mindspore.ops.func_multinomial.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_multinomial.rst
@ -11,8 +11,8 @@ mindspore.ops.multinomial
    参数：
        - **inputs** (Tensor) - 输入的概率值Tensor，必须是1维或2维，数据类型为float32。
        - **num_sample** (int) - 采样的次数。
-        - **replacement** (bool, optional) - 是否是可放回的采样，默认：True。
-        - **seed** (int, optional) - 随机数种子，用于生成随机数(伪随机数)，必须是非负数。默认值：None。
+        - **replacement** (bool, 可选) - 是否是可放回的采样，默认：True。
+        - **seed** (int, 可选) - 随机数种子，用于生成随机数(伪随机数)，必须是非负数。默认值：None。

    返回：
        Tensor，与输入有相同的行数。每行的采样索引数为 `num_samples` 。数据类型为float32。
--- a/docs/api/api_python/ops/mindspore.ops.func_svd.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_svd.rst
@ -12,8 +12,8 @@ mindspore.ops.svd

    参数：
        - **a** (Tensor) - 待分解的矩阵。shape为 :math:`(*, M, N)` 。
-        - **full_matrices** (bool, optional) - 如果为True，则计算完整的 :math:`U` 和 :math:`V` 。否则仅计算前P个奇异向量，P为M和N中的较小值，M和N分别是输入矩阵的行和列。默认值：False。
-        - **compute_uv** (bool, optional) - 如果这个参数为True，则计算 :math:`U` 和 :math:`V` , 否则只计算 :math:`S` 。默认值：True。
+        - **full_matrices** (bool, 可选) - 如果为True，则计算完整的 :math:`U` 和 :math:`V` 。否则仅计算前P个奇异向量，P为M和N中的较小值，M和N分别是输入矩阵的行和列。默认值：False。
+        - **compute_uv** (bool, 可选) - 如果这个参数为True，则计算 :math:`U` 和 :math:`V` , 否则只计算 :math:`S` 。默认值：True。

    返回：
        - **s** (Tensor) - 奇异值。shape为 :math:`(*, P)` 。
--- a/docs/api/api_python/ops/mindspore.ops.func_top_k.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_top_k.rst
@ -20,7 +20,7 @@ mindspore.ops.top_k
    参数：
        - **input_x** (Tensor) - 需计算的输入，数据类型必须为float16、float32或int32。
        - **k** (int) - 指定计算最大元素的数量，需要是常量。
-        - **sorted** (bool, optional) - 如果为True，则获取的元素将按值降序排序。默认值：True。
+        - **sorted** (bool, 可选) - 如果为True，则获取的元素将按值降序排序。默认值：True。

    返回：
        2个Tensor组成的tuple， `values` 和 `indices` 。
--- a/docs/api/api_python/ops/mindspore.ops.func_unique_consecutive.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unique_consecutive.rst
@ -7,9 +7,9 @@ mindspore.ops.unique_consecutive

    参数：
        - **x** (Tensor) - 输入Tensor。
-        - **return_idx** (bool, optional) - 是否返回每个去重元素在输入中所在的连续序列的末尾位置的索引。默认值：False。
-        - **return_counts** (bool, optional) - 是否返回每个去重元素在输入所在的连续序列的计数。默认值：False。
-        - **axis** (int, optional) - 维度。如果为None，则对输入进行展平操作。如果指定，必须是int32或int64类型。默认值：None。
+        - **return_idx** (bool, 可选) - 是否返回每个去重元素在输入中所在的连续序列的末尾位置的索引。默认值：False。
+        - **return_counts** (bool, 可选) - 是否返回每个去重元素在输入所在的连续序列的计数。默认值：False。
+        - **axis** (int, 可选) - 维度。如果为None，则对输入进行展平操作。如果指定，必须是int32或int64类型。默认值：None。

    返回：
        Tensor或包含Tensor对象的元组（ `output` 、 `idx` 、 `counts` ）。 
--- a/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_sum.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_sum.rst
@ -20,7 +20,7 @@
    参数：
        - **input_x** (Tensor) - shape： :math:`(x_1, x_2, ..., x_R)` 。
        - **segment_ids** (Tensor) - 将形状设置为 :math:`(x_1, x_2, ..., x_N)` ，其中0<N<=R。
-        - **num_segments** (Union[int, Tensor], optional) - 分段数量 :math:`z` ，数据类型为int或0维的Tensor。
+        - **num_segments** (Union[int, Tensor], 可选) - 分段数量 :math:`z` ，数据类型为int或0维的Tensor。

    返回：
        Tensor，shape： :math:`(z, x_{N+1}, ..., x_R)` 。
--- a/docs/api/api_python/ops/mindspore.ops.func_vjp.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_vjp.rst
@ -13,7 +13,7 @@ mindspore.ops.vjp
    返回：
        - **net_output** (Union[Tensor, tuple[Tensor]]) - 输入网络的正向计算结果。
        - **vjp_fn** (Function) - 用于求解向量雅可比积的函数。接收shape和type与 `net_out` 一致的输入。
-        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - 若 `has_aux` 为True，才返回 `aux_value` 。`aux_value` 是 `fn(inputs)` 的第一个除外的其他输出，且不参与 `fn` 的求导。
+        - **aux_value** (Union[Tensor, tuple[Tensor]], 可选) - 若 `has_aux` 为True，才返回 `aux_value` 。`aux_value` 是 `fn(inputs)` 的第一个除外的其他输出，且不参与 `fn` 的求导。

    异常：
        - **TypeError** - `inputs` 或 `v` 类型不符合要求。