diff --git a/docs/api/api_python/nn/mindspore.nn.ASGD.rst b/docs/api/api_python/nn/mindspore.nn.ASGD.rst
new file mode 100644
index 00000000000..a1c940f49cd
--- /dev/null
+++ b/docs/api/api_python/nn/mindspore.nn.ASGD.rst
@@ -0,0 +1,56 @@
+mindspore.nn.ASGD
+==================
+
+.. py:class:: mindspore.nn.ASGD(params, learning_rate=0.1, lambd=1e-4, alpha=0.75, t0=1e6, weight_decay=0.0)
+
+    随机平均梯度下降（ASGD）算法的实现。
+    
+    请参阅论文 `Acceleration of stochastic approximation by average <http://dl.acm.org/citation.cfm?id=131098>`_ 。
+    
+    更新公式如下：
+    
+    .. math::
+        \begin{gather*}
+            w_{t} = w_{t-1} * (1 - \lambda * \eta_{t-1}) - \eta_{t-1} * g_{t} \\
+            ax_{t} = (w_t - ax_{t-1}) * \mu_{t-1} \\
+            \eta_{t} = \frac{1.}{(1 + \lambda * lr * t)^\alpha} \\
+            \mu_{t} = \frac{1}{\max(1, t - t0)}
+        \end{gather*}
+    
+    :math:`\lambda` 代表衰减项， :math:`\mu` 和 :math:`\eta` 被跟踪以更新 :math:`ax` 和 :math:`w` ， :math:`t0` 代表开始平均的点， :math:`\α` 代表 :math:`\eta` 更新的系数， :math:`ax` 表示平均参数值， :math:`t` 表示当前步数（step），:math:`g` 表示 `gradients` ， :math:`w` 表示`params` 。
+
+    .. note::
+        如果参数未分组，则优化器中的 `weight_decay` 将应用于名称中没有"beta"或"gamma"的参数。用户可以对参数进行分组，以更改权重衰减策略。当参数分组时，每个组都可以设置 `weight_decay` ，如果没有，将应用优化器中的 `weight_decay` 。
+        
+    参数：
+        - **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
+
+          .. include:: mindspore.nn.optim_group_param.rst
+          .. include:: mindspore.nn.optim_group_lr.rst
+          .. include:: mindspore.nn.optim_group_dynamic_weight_decay.rst
+          .. include:: mindspore.nn.optim_group_gc.rst
+          .. include:: mindspore.nn.optim_group_order.rst
+
+        - **learning_rate** (Union[float, int, Tensor, Iterable, LearningRateSchedule]) -
+
+          .. include:: mindspore.nn.optim_arg_dynamic_lr.rst
+
+        - **lambd** (float) - 衰减项。默认值：1e-4。
+        - **alpha** (float) -  :math:`\eta` 更新的系数。默认值：0.75。
+        - **t0** (float) - 开始平均的点。默认值：1e6。
+        - **weight_decay** (Union[float, int, Cell]) - 权重衰减（L2 penalty）。默认值：0.0。
+
+        .. include:: mindspore.nn.optim_arg_dynamic_wd.rst
+
+    输入：
+        - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
+
+    输出：
+        Tensor[bool]，值为True。
+
+    异常：
+        - **TypeError** - 如果 `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+        - **TypeError** - 如果 `parameters` 的元素不是Parameter或字典。
+        - **TypeError** - 如果 `lambd` 、 `alpha` 或 `t0` 不是float。
+        - **TypeError** - 如果 `weight_decay` 既不是float也不是int。
+        - **ValueError** - 如果 `weight_decay` 小于0。
diff --git a/docs/api/api_python/nn/mindspore.nn.CELU.rst b/docs/api/api_python/nn/mindspore.nn.CELU.rst
new file mode 100644
index 00000000000..6a1d761b6ac
--- /dev/null
+++ b/docs/api/api_python/nn/mindspore.nn.CELU.rst
@@ -0,0 +1,30 @@
+mindspore.nn.CELU
+==================
+
+.. py:class:: mindspore.nn.CELU(alpha=1.0)
+
+    CELU激活层（CELU Activation Operator）。
+
+    根据Continuously Differentiable Exponential Linear Units对输入Tensor逐元素计算。
+
+    .. math::
+        \text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))
+
+    其返回值为 :math:`\max(0,x)+\min(0,\Alpha*(\exp(x/\Alpha)-1)` 。
+
+    更多详情，请查看： `CELU <https://arxiv.org/abs/1704.07483>`_ 。
+
+    参数：
+        - **alpha** (float) - CELU公式中的 :math:`\alpha` 值。默认值：1.0。
+
+    输入：
+        - **x** (Tensor) - CELU的输入。其数据类型为float16或float32，shape为 :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。
+
+    输出：
+        Tensor，数据类型和shape与 `x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `α` 不是float。
+        - **ValueError** - 如果 `α` 的值为0。
+        - **TypeError** - 如果 输入 `x` 不是Tensor。
+        - **TypeError** - 如果输入 `x` 的数据类型既不是float16也不是float32。
diff --git a/docs/api/api_python/nn/mindspore.nn.Rprop.rst b/docs/api/api_python/nn/mindspore.nn.Rprop.rst
new file mode 100644
index 00000000000..8aa59523a9c
--- /dev/null
+++ b/docs/api/api_python/nn/mindspore.nn.Rprop.rst
@@ -0,0 +1,62 @@
+mindspore.nn.Rprop
+===================
+
+.. py:class:: mindspore.nn.Rprop(params, learning_rate=0.1, etas=(0.5, 1.2), step_sizes=(1e-6, 50.), weight_decay=0.)
+
+    弹性反向传播（Rprop）算法的实现。
+
+    请参阅论文 `A Direct Adaptive Method for Faster Backpropagation Learning <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.21.1417>`_ 。
+
+    更新公式如下：
+
+    .. math::
+        \begin{gather*}
+        &\hspace{-10mm}  \textbf{if} \:   g_{t-1} g_t  > 0                                     \\
+        &\hspace{25mm}  \Delta_t \leftarrow \mathrm{min}(\Delta_{t-1} \eta_{+}, \Delta_{max})  \\
+        &\hspace{0mm}  \textbf{else if}  \:  g_{t-1} g_t < 0                                   \\
+        &\hspace{25mm}  \Delta_t \leftarrow \mathrm{max}(\Delta_{t-1} \eta_{-}, \Delta_{min})  \\
+        &\hspace{-25mm}  \textbf{else}  \:                                                     \\
+        &\hspace{-5mm}  \Delta_t \leftarrow \Delta_{t-1}                                       \\
+        &\hspace{15mm} w_{t} \leftarrow w_{t-1}- \Delta_{t} \mathrm{sign}(g_t)                 \\
+        \end{gather*}
+
+    :math:`\Delta_{min/max}` 表示最小或者最大步长， :math:`\eta_{+/-}` 表示加速和减速因子， :math:`g` 表示 `gradients` ， :math:`w` 表示 `params` 。
+
+    .. note::
+        .. 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
+          .. include:: mindspore.nn.optim_group_lr.rst
+          .. include:: mindspore.nn.optim_group_dynamic_weight_decay.rst
+          .. include:: mindspore.nn.optim_group_gc.rst
+          .. include:: mindspore.nn.optim_group_order.rst
+
+        - **learning_rate** (Union[float, int, Tensor, Iterable, LearningRateSchedule]) -
+
+          .. include:: mindspore.nn.optim_arg_dynamic_lr.rst
+
+        - **etas** (tuple[float, float]) - 乘法的增加或减少的因子（etaminus, etaplus）。
+        - **step_sizes** (tuple[float, float]) - 允许的最小和最大步长（min_step_sizes, max_step_size）。
+        - **weight_decay** (Union[float, int, Cell]) - 权重衰减（L2 penalty）。默认值：0.0。
+
+          .. include:: mindspore.nn.optim_arg_dynamic_wd.rst
+
+    输入：
+        - **gradients** (tuple[Tensor]) - `params` 的梯度，shape与 `params` 相同。
+
+    输出：
+        Tensor[bool]，值为True。
+        
+    异常：
+        - **TypeError** - 如果 `learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
+        - **TypeError** - 如果 `parameters` 的元素不是Parameter或字典。
+        - **TypeError** - 如果 `step_sizes` 或 `etas` 不是tuple。
+        - **ValueError** - 如果最大步长小于最小步长。
+        - **ValueError** - 如果 `step_sizes` 或 `etas` 的长度不等于2。
+        - **TypeError** - 如果 `etas` 或 `step_sizes` 中的元素不是float。
+        - **ValueError** - 如果 `etaminus` 不在（0,1）的范围内，或者 `etaplus` 不大于1。
+        - **TypeError** - 如果 `weight_decay` 既不是float也不是int。
+        - **ValueError** - 如果 `weight_decay` 小于0。
diff --git a/docs/api/api_python/ops/mindspore.ops.AccumulateNV2.rst b/docs/api/api_python/ops/mindspore.ops.AccumulateNV2.rst
new file mode 100644
index 00000000000..b7b00608114
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.AccumulateNV2.rst
@@ -0,0 +1,18 @@
+mindspore.ops.AccumulateNV2
+===========================
+
+.. py:class:: mindspore.ops.AccumulateNV2
+
+    逐元素计算输入Tensor的累积。
+
+    AccumulateNV2与AddN类似，但它们之间有一个显著的区别：AccumulateNV2不会等待其所有输入就绪后再求和。也就是说，不同时刻的输入会存储在内存中，AccumulateNV2能够节省内存，因为最小临时存储与输出大小成正比，而不是输入大小。
+
+    输入：
+        - **x** (Union(tuple[Tensor], list[Tensor])) - AccumulateNV2的输入，由多个Tensor组成的tuple或list，其数据类型为数值型，且每个元素的shape必须相等。
+
+    输出：
+        Tensor，数据类型和shape与输入 `x` 的每个条目相同。
+
+    异常：
+        - **TypeError** - 如果 `x` 既不是tuple也不是list。
+        - **ValueError** - 如果 `x` 的元素的shape不相同。
diff --git a/docs/api/api_python/ops/mindspore.ops.AiCPURegOp.rst b/docs/api/api_python/ops/mindspore.ops.AiCPURegOp.rst
new file mode 100644
index 00000000000..4bd3fa0a4be
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.AiCPURegOp.rst
@@ -0,0 +1,9 @@
+mindspore.ops.AiCPURegOp
+=========================
+
+.. py:class:: mindspore.ops.AiCPURegOp(op_name)
+
+    AiCPU算子信息注册类。
+
+    参数：
+        - **op_name** (str) - 算子名称。
diff --git a/docs/api/api_python/ops/mindspore.ops.AlltoAll.rst b/docs/api/api_python/ops/mindspore.ops.AlltoAll.rst
new file mode 100644
index 00000000000..c200273ad18
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.AlltoAll.rst
@@ -0,0 +1,25 @@
+mindspore.ops.AlltoAll
+======================
+
+.. py:class:: mindspore.ops.AlltoAll(split_count, split_dim, concat_dim, group='hccl_world_group')
+
+    AlltoAll是一个集合通信函数。
+
+    AlltoAll将输入数据在特定的维度切分成特定的块数（blocks），并按顺序发送给其他rank。一般有两个阶段：
+
+    - 分发阶段：在每个进程上， 操作数沿着 `split_dim` 拆分为 `split_count` 个块（blocks），且分发到指定的rank上，例如，第i块被发送到第i个rank上。
+    - 聚合阶段：每个rank沿着 `concat_dimension` 拼接接收到的数据。
+
+    .. note::
+        聚合阶段，所有进程中的Tensor必须具有相同的shape和格式。用户在运行以下示例之前需要预置环境变量，请在 `MindSpore <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.ops.html#通信算子>`_ 官网查看详细信息。
+
+        要求全连接配网方式，每台设备具有相同的vlan id，ip和mask在同一子网，请查看 `详细信息 <https://www.mindspore.cn/tutorials/experts/zh-CN/master/parallel/communicate_ops.html#注意事项>`_ 。
+
+    参数：
+        - **split_count** (int) - 在每个进程上，将块（blocks）拆分为 `split_count` 个。
+        - **split_dim** (int) - 在每个进程上，沿着 `split_dim` 维度进行拆分。
+        - **concat_dim** (int) - 在每个进程上，沿着 `concat_dimension` 拼接接收到的块（blocks）。
+        - **group** (str) - AlltoAll的通信域。默认值："GlobalComm.WORLD_COMM_GROUP"。
+
+    异常：
+        - **TypeError** - 如果 `group` 不是字符串。
diff --git a/docs/api/api_python/ops/mindspore.ops.BatchToSpace.rst b/docs/api/api_python/ops/mindspore.ops.BatchToSpace.rst
new file mode 100644
index 00000000000..0b0327770a1
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.BatchToSpace.rst
@@ -0,0 +1,31 @@
+mindspore.ops.BatchToSpace
+===========================
+
+.. py:class:: mindspore.ops.BatchToSpace(block_size, crops)
+
+    将批处理数据重新排列到空间数据中。
+
+    此操作将批处理维度N拆分为 `block_size` 大小的块（blocks），输出Tensor的维度N，即为拆分后对应的块数。输出Tensor的H、W维分别是原H、W维和 `block_size` 在给定裁剪量情况下的乘积。
+
+    参数：
+        - **block_size** (int) - 指定拆分的块大小，其值不能小于2。
+        - **crops** (Union[list(int), tuple(int)]) - 指定H和W维度上的裁剪值，包含2个列表。每个列表包含2个整数。所有值都必须不小于0。crops[i]表示指定空间维度i的裁剪值，该维度对应于输入维度i+2。要求 :math:`input\_shape[i+2]*block\_size >= crops[i][0]+crops[i][1]` 。
+
+    输入：
+        - **input_x** (Tensor) - 输入Tensor。必须是四维，第0维度（维度n）的大小必须可被 `block_size` 的乘积整除。数据类型为float16或float32。
+
+    输出：
+        Tensor，数据类型与输入Tensor相同。假设输入shape为 :math:`(n,c,h,w)` ，经过 `block_size` 和 `crops` 计算后。输出shape将为 :math:`(n'，c'，h'，w')` ，其中
+
+        :math:`n' = n//(block\_size*block\_size)`
+
+        :math:`c' = c`
+
+        :math:`h' = h*block\_size-crops[0][0]-crops[0][1]`
+
+        :math:`w' = w*block\_size-crops[1][0]-crops[1][1]`
+
+    异常：
+        - **TypeError** - 如果 `block_size` 或 `crops` 的元素不是int。
+        - **TypeError** - 如果 `ccrops` 既不是list也不是tuple。
+        - **ValueError** - 如果 `block_size` 的值小于2。
diff --git a/docs/api/api_python/ops/mindspore.ops.BoundingBoxDecode.rst b/docs/api/api_python/ops/mindspore.ops.BoundingBoxDecode.rst
new file mode 100644
index 00000000000..1b95b046b12
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.BoundingBoxDecode.rst
@@ -0,0 +1,26 @@
+mindspore.ops.BoundingBoxDecode
+===============================
+
+.. py:class:: mindspore.ops.BoundingBoxDecode(max_shape, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0), wh_ratio_clip=0.016)
+
+    解码边界框位置信息。
+
+    算子的功能是计算偏移量，此算子将偏移量转换为Bbox，用于在后续图像中标记目标等。
+
+    参数：
+        - **means** (tuple) - 计算 `deltas` 的均值。默认值：（0.0, 0.0, 0.0, 0.0, 0.0）。
+        - **stds** (tuple) - 计算 `deltas` 的标准差。默认值：（1.0, 1.0, 1.0, 1.0）。
+        - **max_shape** (tuple) - 解码框计算的上限值。
+        - **wh_ratio_clip** (float) - 解码框计算的宽高比限制。默认值：0.016。
+
+    输入：
+        - **anchor_box** (Tensor) - 锚框。锚框的shape必须为 :math:`(n,4)` 。
+        - **deltas** (Tensor) - 框的增量。它的shape与 `anchor_box` 相同。
+
+    输出：
+        Tensor，解码框。它的数据类型和shape与 `anchor_box` 相同。
+
+    异常：
+        - **TypeError** - 如果 `means` 、 `stds` 或 `max_shape` 不是tuple。
+        - **TypeError** - 如果 `wh_ratio_clip` 不是float。
+        - **TypeError** - 如果 `anchor_box` 或 `deltas` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.BoundingBoxEncode.rst b/docs/api/api_python/ops/mindspore.ops.BoundingBoxEncode.rst
new file mode 100644
index 00000000000..c404ae9f3d3
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.BoundingBoxEncode.rst
@@ -0,0 +1,23 @@
+mindspore.ops.BoundingBoxEncode
+================================
+
+.. py:class:: mindspore.ops.BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
+
+    编码边界框位置信息。
+
+    算子的功能是计算预测边界框和真实边界框之间的偏移，并将此偏移作为损失变量。
+
+    参数：
+        - **means** (tuple) - 计算编码边界框的均值。默认值：（0.0, 0.0, 0.0, 0.0, 0.0）。
+        - **stds** (tuple) - 计算增量的标准偏差。默认值：（1.0、1.0、1.0、1.0）。
+
+    输入：
+        - **anchor_box** (Tensor) - 锚框。锚框的shape必须为 :math:`(n,4)` 。
+        - **groundtruth_box** (Tensor) - 真实边界框。它的shape与锚框相同。
+
+    输出：
+        Tensor，编码边界框。数据类型和shape与输入 `anchor_box` 相同。
+
+    异常：
+        - **TypeError** - 如果 `means` 或 `stds` 不是tuple。
+        - **TypeError** - 如果 `anchor_box` 或 `groundtruth_box` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.Conv2DTranspose.rst b/docs/api/api_python/ops/mindspore.ops.Conv2DTranspose.rst
new file mode 100644
index 00000000000..60c015d39ae
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Conv2DTranspose.rst
@@ -0,0 +1,35 @@
+mindspore.ops.Conv2DTranspose
+==============================
+
+.. py:class:: mindspore.ops.Conv2DTranspose(out_channel, kernel_size, pad_mode='valid', pad=0, pad_list=None, mode=1, stride=1, dilation=1, group=1, data_format='NCHW')
+
+    计算二维转置卷积，也称为反卷积（实际不是真正的反卷积）。
+
+    参数：
+        - **out_channel** (t) - 输出的通道数。
+        - **kernel_size** (Union[int, tuple[int]]) - 卷积核的大小。
+        - **pad_mode** (str) - 填充的模式。它可以是"valid"、"same"或"pad"。默认值："valid"。
+        - **pad** (Union[int, tuple[int]]) - 指定要填充的填充值。默认值：0。如果 `pad` 是整数，则顶部、底部、左侧和右侧的填充都等于 `pad` 。如果 `pad` 是四个整数的tuple，则顶部、底部、左侧和右侧的填充分别等于pad[0]、pad[1]、pad[2]和pad[3]。
+        - **pad_list** (Union[str, None]) - 卷积填充方式，如（顶部、底部、左、右）。默认值：None，表示不使用此参数。
+        - **mode** (int) - 指定不同的卷积模式。当前未使用该值。默认值：1。
+        - **stride** (Union[int. tuple[int]]) - 卷积核移动的步长。默认值：1。
+        - **dilation** (Union[int. tuple[int]]) - 卷积核膨胀尺寸。默认值：1。
+        - **group** (int) - 将过滤器拆分为组。默认值：1。
+        - **data_format** (str) - 输入和输出的数据格式。它应该是'NHWC'或'NCHW'，默认值是'NCHW'。
+
+    输入：
+        - **dout** (Tensor) - 卷积操作的输出的梯度Tensor。shape： :math:`(N,C_{out},H_{out},W_{out})` 。
+        - **weight** (Tensor) - 设置卷积核大小为 :math:`(K_1,K_2)` ，然后shape为 :math:`(C_{out},C_{in},K_1,K_2)` 。
+        - **input_size** (Tensor) - 输入的shape，shape的格式为 :math:`(N,C_{in},H_{in},W_{in})` 。
+
+    输出：
+        Tensor，卷积操作的输入的梯度Tensor。它的shape与输入相同。
+
+    异常：
+        - **TypeError** - 如果 `kernel_size` 、 `stride` 、 `pad` 或 `diation` 既不是int也不是tuple。
+        - **TypeError** - 如果 `out_channel` 或 `group` 不是int。
+        - **ValueError** - 如果 `kernel_size` 、 `stride` 或 `dlation` 小于1。
+        - **ValueError** - 如果 `pad_mode` 不是'same'、'valid'或'pad'。
+        - **ValueError** - 如果 `padding` 是长度不等于4的tuple。
+        - **ValueError** - 如果 `pad_mode` 不等于'pad'，`pad` 不等于（0,0,0,0）。
+        - **ValueError** - 如果 `data_format` 既不是'NCHW'也不是'NHWC'。
diff --git a/docs/api/api_python/ops/mindspore.ops.CropAndResize.rst b/docs/api/api_python/ops/mindspore.ops.CropAndResize.rst
new file mode 100644
index 00000000000..406d6237012
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.CropAndResize.rst
@@ -0,0 +1,26 @@
+mindspore.ops.CropAndResize
+============================
+
+.. py:class:: mindspore.ops.CropAndResize(method="bilinear", extrapolation_value=0.0)
+
+    从输入图像Tensor中提取切片并调整其大小。
+
+    .. note::
+        如果输出shape依赖于 `crop_size` 的值，则 `crop_size` 必须为常量。
+
+    参数：
+        - **method** (str, optional) - 指定调整大小的采样方法，为可选字符串。提供的方法有："bilinear"、"nearest"或"bilinear_v2"。"bilinear"代表标准双线性插值算法，而"bilinear_v2"在某些情况下可能会产生更好的结果。默认值："bilinear"。
+        - **extrapolation_value** (float, optional) - 外插值，数据类型为float。默认值：0.0。
+
+    输入：
+        - **x** (Tensor) - 输入为四维的Tensor，其shape必须是 :math:`(batch, image\_height, image\_width, depth)` 。支持的数据类型：int8、int16、int32、int64、float16、float32、float64、uint8、uint16。
+        - **boxes** (Tensor) - 二维Tensor，其shape为 :math:`(num\_boxes, 4)` 。第i行表示 `box_index[i]` 图像区域的坐标，并且坐标[y1, x1, y2, x2]是归一化后的值。归一化后的坐标值y，映射到图像y * (image_height - 1)处，因此归一化后的图像高度范围为[0, 1]，映射到实际图像高度范围为[0, image_height - 1]。我们允许y1 > y2，在这种情况下，视为原始图像的上下翻转变换。宽度尺寸的处理类似。坐标取值允许在[0, 1]范围之外，在这种情况下，我们使用 `extrapolation_value` 外插值进行补齐。支持的数据类型：float32。
+        - **box_index** (Tensor) - `boxes` 的索引，其shape为 :math:`(num\_boxes)` 的一维Tensor，数据类型为int32，取值范围为[0, batch)。box_index[i]的值表示第i个框的图像的值。
+        - **crop_size** (Tuple[int]) - 两个int32元素元素组成的tuple：（裁剪高度，裁剪宽度）。只能是常量。所有裁剪后的图像大小都将调整为此大小，且不保留图像内容的宽高比，裁剪高度和裁剪宽度都需要为正。
+
+    输出：
+        四维Tensor，其shape为 :math:`(num\_boxes, crop\_height, crop\_width, depth)` ，数据类型类型为float32。
+
+    异常：
+        - **TypeError** - 如果 `method` 不是str。
+        - **TypeError** - 如果 `extrapolation_value` 不是float，且取值不是"bilinear"、"nearest"或"bilinear_v2"。
diff --git a/docs/api/api_python/ops/mindspore.ops.DepthToSpace.rst b/docs/api/api_python/ops/mindspore.ops.DepthToSpace.rst
new file mode 100644
index 00000000000..e4613a8b9ba
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.DepthToSpace.rst
@@ -0,0 +1,30 @@
+mindspore.ops.DepthToSpace
+===========================
+
+.. py:class:: mindspore.ops.DepthToSpace(block_size)
+
+    将深度数据重新排列到空间维度中。
+
+    这是SpaceToDepth的反向操作。
+
+    输出Tensor的深度为 :math:`input\_depth / (block\_size * block\_size)` 。
+
+    输出Tensor的 `height` 维度为 :math:`height * block\_size` 。
+
+    输出Tensor的 `weight` 维度为 :math:`weight * block\_size` 。
+
+    输入Tensor的深度必须可被 `block_size * block_size` 整除。数据格式为"NCHW"。
+
+    参数：
+        - **block_size** (int) - 用于划分深度数据的块大小。其值必须>=2。
+
+    输入：
+        - **x** (Tensor) - 输入Tensor。它必须为四维，其shape为 :math:`(N,C_{in},H_{in},W_{in})` ，数据类型为数值型。
+
+    输出：
+        Tensor，shape为 :math:`(N, C_{in} / \text{block_size} ^ 2, H_{in} * \text{block_size}, W_{in} * \text{block_size})` 。
+
+    异常：
+        - **TypeError** - 如果 `block_size` 不是int。
+        - **ValueError** - 如果 `block_size` 小于2。
+        - **ValueError** - 如果 `x` 的shape长度不等于4。
diff --git a/docs/api/api_python/ops/mindspore.ops.EditDistance.rst b/docs/api/api_python/ops/mindspore.ops.EditDistance.rst
new file mode 100644
index 00000000000..a5c2e63b2b1
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.EditDistance.rst
@@ -0,0 +1,35 @@
+mindspore.ops.EditDistance
+===========================
+
+.. py:class:: mindspore.ops.EditDistance(normalize=True)
+
+    计算Levenshtein编辑距离。它用于测量两个序列的相似性。输入是可变长度的序列，由SpaseTensors（hypothesis_indices, hypothesis_values, hypothesis_shape）和（truth_indices, truth_values, truth_shape）提供。
+
+    .. math::
+        \operatorname{lev}_{a, b}(i, j)=\left\{\begin{array}{ll}
+        \max (i, j)  \qquad \qquad \qquad \qquad \qquad \quad \  \text { if } \min (i, j)=0 \\
+        \min \left\{\begin{array}{ll}
+        \operatorname{lev}_{a, b}(i-1, j)+1 & \\
+        \operatorname{lev}_{a, b}(i, j-1)+1 & \text { otherwise. } \\
+        \operatorname{lev}_{a, b}(i-1, j-1)+1_{\left(a_{i} \neq b_{j}\right)}
+        \end{array}\right. &
+        \end{array}\right.
+
+    其中 :math:`a` 表示预测值， :math:`b` 表示真实值。为了便于理解，这里的i和j可以被视为a和b的长度。
+
+    参数：
+        - **normalize** (bool) - 如果为True，则编辑距离将按真实值长度标准化。默认值：True。
+
+    输入：
+        - **hypothesis_indices** (Tensor) - 预测列表的索引。类型为Tensor，数据类型为int64，其shape为 :math:`(N,R)` 。
+        - **hypothesis_values** (Tensor) - 预测列表的值。类型为Tensor，必须是长度为N的一维向量。
+        - **hypothesis_shape** (Tensor) - 预测列表的shape。类型为Tensor，必须是长度为R的向量，数据类型为int64。只能是常量。
+        - **truth_indices** (Tensor) - 真实列表的索引。类型为Tensor，数据类型为int64，其shape为 :math:`(M,R)` 。
+        - **truth_values** (Tensor) - 真实列表的值。类型为Tensor，必须是长度为M的一维向量。
+        - **truth_shape** (Tensor) - 真实列表的shape。类型为Tensor，必须是长度为R的向量，数据类型为int64。只能是常量。
+
+    输出：
+        Tensor，其秩为 `R-1` ，数据类型为float32。
+
+    异常：
+        - **TypeError** - 如果 `normalize` 不是bool。
diff --git a/docs/api/api_python/ops/mindspore.ops.Einsum.rst b/docs/api/api_python/ops/mindspore.ops.Einsum.rst
new file mode 100644
index 00000000000..087dc129703
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Einsum.rst
@@ -0,0 +1,20 @@
+mindspore.ops.Einsum
+=====================
+
+.. py:class:: mindspore.ops.Einsum(equation)
+
+    此算子使用爱因斯坦求和约定（Einsum）进行Tensor计算，支持对角线、约和、转置、矩阵乘、乘积、内积运算等。
+
+    输入必须是Tensor的tuple。当输入只有一个Tensor时，可以输入(Tensor, )，支持数据类型float16、float32、float64。
+
+    参数：
+        - **equation** (str) - 属性，表示要执行的计算。该值只能使用letter([a-z][A-Z])、commas(,)、ellipsis(...)和arrow(->)。letter([a-z][A-Z])表示输入的Tensor的维度，commas(,)表示Tensor维度之间的分隔符，ellipsis(...)表示不关心的Tensor维度，arrow(->)的左侧表示输入Tensor，右侧表示所需的输出维度。
+
+    输入：
+        - **x** (Tuple) - 用于计算的输入Tensor，Tensor的数据类型必须相同。
+
+    输出：
+        Tensor，shape可以从方程中获得，数据类型与输入Tensor相同。
+
+    异常：
+        - **TypeError** - 如果 `equation` 本身无效，或者 `equation` 与输入Tensor不匹配。
diff --git a/docs/api/api_python/ops/mindspore.ops.EqualCount.rst b/docs/api/api_python/ops/mindspore.ops.EqualCount.rst
new file mode 100644
index 00000000000..04411bcd9d1
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.EqualCount.rst
@@ -0,0 +1,19 @@
+mindspore.ops.EqualCount
+=========================
+
+.. py:class:: mindspore.ops.EqualCount
+
+    计算两个Tensor的相同元素的数量。
+    
+    两个输入Tensor必须具有相同的数据类型和shape。
+
+    输入：
+        - **x** (Tensor) - 第一个输入Tensor。如果确定了 `y` 的数据类型和shape，则 `x` 必须与 `y` 相同，反之亦然。 :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度。
+        - **y** (Tensor) - 第二个输入Tensor。如果确定了 `x` 的数据类型和shape，则 `y` 必须与 `x` 相同，反之亦然。
+
+    输出：
+        Tensor，数据类型与输入Tensor相同，shape为 :math:`(1,)` 。
+
+    异常：
+        - **TypeError** - 如果 `x` 或 `y` 不是Tensor。
+        - **ValueError** - 如果 `x` 与`y` 的shape不相等。
diff --git a/docs/api/api_python/ops/mindspore.ops.Erfinv.rst b/docs/api/api_python/ops/mindspore.ops.Erfinv.rst
new file mode 100644
index 00000000000..05acdfc9cda
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Erfinv.rst
@@ -0,0 +1,20 @@
+mindspore.ops.Erfinv
+=====================
+
+.. py:class:: mindspore.ops.Erfinv
+
+    计算输入Tensor的逆误差函数。逆误差函数在范围(-1,1)。
+    
+    公式定义为：
+
+    .. math::
+        erfinv(erf(x)) = x
+
+    输入：
+        - **input_x** (Tensor) - 待计算的输入Tensor，数据类型为float32或float16。
+
+    输出：
+        Tensor，数据类型和shape与 `input_x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `input_x` 的数据类型既不是float32也不是float16。
diff --git a/docs/api/api_python/ops/mindspore.ops.ExtractVolumePatches.rst b/docs/api/api_python/ops/mindspore.ops.ExtractVolumePatches.rst
new file mode 100644
index 00000000000..dee62fc08f1
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.ExtractVolumePatches.rst
@@ -0,0 +1,34 @@
+mindspore.ops.ExtractVolumePatches
+===================================
+
+.. py:class:: mindspore.ops.ExtractVolumePatches(kernel_size, strides, padding)
+
+    提取立体中的一块数据，是 :class:`mindspore.ops.ExtractImagePatches` 的3D格式扩展。
+
+    参数：
+        - **kernel_size** (Union[int, tuple[int], list[int]]) - 长度为3或5的int列表。输入每个维度表示滑动窗口大小。必须是：[1, 1, k_d, k_h, k_w]或[k_d, k_h, k_w]。如果k_d = k_h = k_w，则可以输入整数。
+        - **strides** (Union[int, tuple[int], list[int]]) - 长度为3或5的int列表。
+          两个连续色块的中心在输入中的距离。必须是：[1, 1, s_d, s_h, s_w]或[s_d, s_h, s_w]。如果s_d = s_h = s_w，则可以输入整数。
+        - **padding** (str) - 要使用的填充算法的类型。可选值有"SAME"和"VALID"。
+
+    输入：
+        - **input_x** (Tensor) - 一个五维的输入Tensor。数据类型必须为float16、float32，shape为 :math:`(x_n、x_c、x_d、x_h、x_w)` 。
+
+    输出：
+        Tensor，与输入的类型相同。如果填充为"VALID"，则shape为 :math:`(x_n,k_d*k_h*k_w*x_c,1+(x_d-k_d)/s_d,1+(x_h-k_h)/s_h,1+(x_w-k_w)/s_w)` ；如果填充"SAME"，则shape为 :math:`(x_n,k_d*k_h*k_w*x_c,(x_d+s_d-1)/s_d,(x_h+s_h-1)/s_h,(x_w+s_w-1)/s_w)` 。
+
+    异常：
+        - **TypeError** - 如果 `kernel_size` 或 `strides` 不是一个list，tuple或int。
+        - **TypeError** - 如果 `input_x` 不是Tensor。
+        - **TypeError** - 如果 `padding` 不是str。
+        - **ValueError** - 如果 `kernel_size` 的长度不是3或5，并且 `kernel_size` 不是int。
+        - **ValueError** - 如果 `strides` 的长度不是3或5，并且 `strides` 不是int。
+        - **ValueError** - 如果 `padding` 既不是"VALID"也不是"SAME"。
+        - **ValueError** - 如果 `kernel_size` 或 `strides` 的元素不是正整数。
+        - **ValueError** - 如果 `input_x` 不是五维的Tensor。
+        - **ValueError** - 如果 `input_x` 的shape含有0。
+        - **ValueError** - 如果 `kernel_size` 或 `strides` 的前两个数不等于1。
+        - **ValueError** - 如果 `padding` 为"VALID"，并且 :math:`input\_x - kernel\_size` 在d、h或w维上小于0。
+        - **ValueError** - 如果 `padding` 为"SAME"，并且 :math:`padding\_needed = ((input\_x + strides - 1) / strides - 1) * strides + kernel\_size - input\_x` 在d、h或w维中小于0。
+        - **ValueError** - 如果x_h不等于1或x_w不等于1，并且 :math:`x_w + padding\_needed - k_w - s_w` 小于0。
+        - **ValueError** - 如果 :math:`x_d * x_h * x_w` 大于2048。
diff --git a/docs/api/api_python/ops/mindspore.ops.FloatStatus.rst b/docs/api/api_python/ops/mindspore.ops.FloatStatus.rst
new file mode 100644
index 00000000000..4d988840843
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.FloatStatus.rst
@@ -0,0 +1,15 @@
+mindspore.ops.FloatStatus
+==========================
+
+.. py:class:: mindspore.ops.FloatStatus
+
+    确定元素是否包含非数字（NaN）、正无穷还是负无穷。0表示正常，1表示溢出。
+
+    输入：
+        - **x** (Tensor) - 输入Tensor。数据类型必须为float16或float32。 :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度。
+
+    输出：
+        Tensor，shape为 :math:`(1,)` ，数据类型为 `mindspore.dtype.float32` 。
+
+    异常：
+        - **TypeError** - 如果 `x` 的数据类型不是float16，float32或float64。
diff --git a/docs/api/api_python/ops/mindspore.ops.HSigmoid.rst b/docs/api/api_python/ops/mindspore.ops.HSigmoid.rst
new file mode 100644
index 00000000000..4be237a4ec0
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HSigmoid.rst
@@ -0,0 +1,24 @@
+mindspore.ops.HSigmoid
+=======================
+
+.. py:class:: mindspore.ops.HSigmoid
+
+    分段性逼近激活函数。
+
+    逐元素计算。输入为任意维度的Tensor。
+
+    HSigmoid定义为：
+
+    .. math::
+        \text{hsigmoid}(x_{i}) = max(0, min(1, \frac{x_{i} + 3}{6})),
+
+    其中 :math:`x_i` 是输入Tensor的元素。
+
+    输入：
+        - **input_x** (Tensor) - 输入Tensor ，其shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度。
+
+    输出：
+        Tensor，数据类型和shape与 `input_x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `input_x` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.HistogramFixedWidth.rst b/docs/api/api_python/ops/mindspore.ops.HistogramFixedWidth.rst
new file mode 100644
index 00000000000..cebeb153e6a
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HistogramFixedWidth.rst
@@ -0,0 +1,22 @@
+mindspore.ops.HistogramFixedWidth
+=================================
+
+.. py:class:: mindspore.ops.HistogramFixedWidth(nbins, dtype='int32')
+
+    返回一个rank为1的直方图，该直方图中的每个组的值表示数量。每个组的宽度应该相等，且宽度由输入 `range` 和参数 `nbins` 决定。
+
+    参数：
+        - **nbins** (int) - 直方图的组数，类型为正整数。
+        - **dtype** (str, optional) - 可选属性。数据类型必须为int32。默认值："int32"。
+
+    输入：
+        - **x** (Tensor) - HistogramFixedWidth的输入，为一个Tensor。数据类型必须为int32、float32或float16。
+        - **range** (Tensor) - 数据类型与 `x` 相同，shape为 :math:`(2,)` 。x <= range[0] 将映射到histogram[0]，x >= range[1]将映射到histogram[-1]。
+
+    输出：
+        Tensor，数据类型为int32。
+
+    异常：
+        - **TypeError** - 如果 `dtype` 不是str或 `nbins` 不是int。
+        - **ValueError** - 如果 `nbins` 小于1。
+        - **ValueError** - 如果 `dtype` 既不是 `int32` 也不是 `int64` 。
diff --git a/docs/api/api_python/ops/mindspore.ops.HistogramSummary.rst b/docs/api/api_python/ops/mindspore.ops.HistogramSummary.rst
new file mode 100644
index 00000000000..9ac173ee9e8
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HistogramSummary.rst
@@ -0,0 +1,14 @@
+mindspore.ops.HistogramSummary
+===============================
+
+.. py:class:: mindspore.ops.HistogramSummary
+
+    将Tensor数据转换为直方图数据记录。
+
+    输入：
+        - **name** (str) - 输入变量的名称。
+        - **value** (Tensor) - Tensor的值，Tensor的rank必须大于0。
+
+    异常：
+        - **TypeError** - 如果 `name` 不是str。
+        - **TypeError** - 如果 `value` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.HookBackward.rst b/docs/api/api_python/ops/mindspore.ops.HookBackward.rst
new file mode 100644
index 00000000000..e118412ffe3
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HookBackward.rst
@@ -0,0 +1,23 @@
+mindspore.ops.HookBackward
+===========================
+
+.. py:class:: mindspore.ops.HookBackward(hook_fn, cell_id="")
+
+    用来导出中间变量中的梯度。请注意，此函数仅在PyNative模式下支持。
+
+    .. note::
+        钩子函数必须定义为 `hook_fn(grad) -> new gradient or None` ，其中'grad'是传递给Primitive的梯度。可以通过返回新的梯度并传递到下一个Primitive来修改'grad'。钩子函数和InsertGradientOf的回调的区别在于，钩子函数是在python环境中执行的，而回调将被解析并添加到图中。
+
+    参数：
+        - **hook_fn** (Function) - Python函数。钩子函数。
+        - **cell_id** (str) - 用于标识钩子注册的函数是否实际注册在指定的cell对象上。例如，'nn.Conv2d'是一个cell对象。cell_id的默认值为空字符串("")，在这种情况下，系统将自动注册cell_id的值。cell_id的值目前不支持自定义值。
+
+    输入：
+        - **input** (Tensor) - 需要导出的变量的梯度。
+
+    输出：
+        - **output** (Tensor) - 直接返回 `input` 。 `HookBackward` 不影响前向结果。
+
+    异常：
+        - **TypeError** - 如果 `input` 不是Tensor。
+        - **TypeError** - 如果 `hook_fn` 不是Python的函数。
diff --git a/docs/api/api_python/ops/mindspore.ops.Imag.rst b/docs/api/api_python/ops/mindspore.ops.Imag.rst
new file mode 100644
index 00000000000..5f1741bb70e
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Imag.rst
@@ -0,0 +1,15 @@
+mindspore.ops.Imag
+===================
+
+.. py:class:: mindspore.ops.Imag
+
+    返回包含输入Tensor的虚部。如果输入为实数，则返回零。
+
+    输入：
+        - **input** (Tensor) - 要计算的输入Tensor。
+
+    输出：
+        Tensor，shape与 `input` 相同。
+
+    异常：
+        - **TypeError** - 如果 `input` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.ImageSummary.rst b/docs/api/api_python/ops/mindspore.ops.ImageSummary.rst
new file mode 100644
index 00000000000..a401212cf72
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.ImageSummary.rst
@@ -0,0 +1,14 @@
+mindspore.ops.ImageSummary
+==========================
+
+.. py:class:: mindspore.ops.ImageSummary
+
+    将图片数据放到缓冲区。
+
+    输入：
+        - **name** (str) - 输入变量的名称，不能是空字符串。
+        - **value** (Tensor) - 图像数据的值，Tensor的rank必须为4。
+
+    异常：
+        - **TypeError** - 如果 `name` 不是str。
+        - **TypeError** - 如果 `value` 不是Tensor。
diff --git a/docs/api/api_python/ops/mindspore.ops.InvertPermutation.rst b/docs/api/api_python/ops/mindspore.ops.InvertPermutation.rst
new file mode 100644
index 00000000000..509fae3d261
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.InvertPermutation.rst
@@ -0,0 +1,21 @@
+mindspore.ops.InvertPermutation
+================================
+
+.. py:class:: mindspore.ops.InvertPermutation
+
+    计算索引的逆置换。
+
+    该算子主要用于计算索引的逆置换。 `input_x` 是一个一维的整数Tensor，一个以0开始的索引数组，并将每个值与其索引位置交换。换句话说，对于输出Tensor和输入 `input_x` ，依赖此计算方法 :math:`y[x[i]] = i, \quad i \in [0, 1, \ldots, \text{len}(x)-1]` 。
+
+    .. note::
+        这些值必须包括0。不能有重复的值，并且值不能为负值。
+        
+    输入：
+        - **input_x** (Union(tuple[int], list[int])) - 输入由多个整数构造，即 :math:`(y_1,y_2,...,y_S)` 代表索引。值必须包括0。不能有重复值或负值。只允许常量。最大值必须等于 `input_x` 的长度。
+        
+    输出：
+        tuple[int]。输出的长度与 `input_x` 相同。
+        
+    异常：
+        - **TypeError** - 如果 `input_x` 既不是tuple也不是list。
+        - **TypeError** - 如果 `input_x` 的元素不是整数。