diff --git a/docs/api/api_python/mindspore.ops.rst b/docs/api/api_python/mindspore.ops.rst
index 88cd4046d04..6749b6e9df4 100644
--- a/docs/api/api_python/mindspore.ops.rst
+++ b/docs/api/api_python/mindspore.ops.rst
@@ -59,7 +59,9 @@ MindSpore中 `mindspore.ops` 接口与上一版本相比，新增、删除和支
     mindspore.ops.Dropout3D
     mindspore.ops.DynamicGRUV2
     mindspore.ops.DynamicRNN
+    mindspore.ops.EmbeddingLookup
     mindspore.ops.Flatten
+    mindspore.ops.GridSampler3D
     mindspore.ops.LayerNorm
     mindspore.ops.LRN
     mindspore.ops.LSTM
@@ -70,7 +72,6 @@ MindSpore中 `mindspore.ops` 接口与上一版本相比，新增、删除和支
     mindspore.ops.MaxUnpool2D
     mindspore.ops.MirrorPad
     mindspore.ops.Pad
-    mindspore.ops.EmbeddingLookup
     mindspore.ops.Padding
     mindspore.ops.ResizeNearestNeighbor
     mindspore.ops.ResizeBilinear
@@ -204,6 +205,7 @@ MindSpore中 `mindspore.ops` 接口与上一版本相比，新增、删除和支
     mindspore.ops.CombinedNonMaxSuppression
     mindspore.ops.CropAndResize
     mindspore.ops.ExtractVolumePatches
+    mindspore.ops.HSVToRGB
     mindspore.ops.IOU
     mindspore.ops.L2Normalize
     mindspore.ops.NMSWithMask
@@ -346,6 +348,7 @@ Reduction算子
     mindspore.ops.ReduceMean
     mindspore.ops.ReduceMin
     mindspore.ops.ReduceProd
+    mindspore.ops.ReduceStd
     mindspore.ops.ReduceSum
 
 比较算子
@@ -418,6 +421,7 @@ Tensor创建
     :template: classtemplate.rst
 
     mindspore.ops.Gamma
+    mindspore.ops.LogNormalReverse
     mindspore.ops.Multinomial
     mindspore.ops.RandomCategorical
     mindspore.ops.RandomChoiceWithMask
@@ -454,18 +458,30 @@ Array操作
     mindspore.ops.DiagPart
     mindspore.ops.DType
     mindspore.ops.ExpandDims
+    mindspore.ops.FFTWithSize
     mindspore.ops.FloatStatus
     mindspore.ops.Gather
     mindspore.ops.GatherD
     mindspore.ops.GatherNd
+    mindspore.ops.HammingWindow
+    mindspore.ops.Heaviside
+    mindspore.ops.Histogram
     mindspore.ops.HistogramFixedWidth
+    mindspore.ops.Hypot
     mindspore.ops.Identity
+    mindspore.ops.IdentityN
     mindspore.ops.Im2Col
     mindspore.ops.IndexAdd
+    mindspore.ops.IndexFill
     mindspore.ops.InplaceAdd
     mindspore.ops.InplaceSub
     mindspore.ops.InplaceUpdate
     mindspore.ops.InvertPermutation
+    mindspore.ops.IsClose
+    mindspore.ops.Lcm
+    mindspore.ops.LeftShift
+    mindspore.ops.ListDiff
+    mindspore.ops.LogMatrixDeterminant
     mindspore.ops.LogSpace
     mindspore.ops.LowerBound
     mindspore.ops.Lstsq
diff --git a/docs/api/api_python/ops/mindspore.ops.FFTWithSize.rst b/docs/api/api_python/ops/mindspore.ops.FFTWithSize.rst
new file mode 100644
index 00000000000..8501f2687a2
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.FFTWithSize.rst
@@ -0,0 +1,64 @@
+mindspore.ops.FFTWithSize
+=========================
+
+.. py:class:: mindspore.ops.FFTWithSize(signal_ndim, inverse, real, norm="backward", onesided=True, signal_sizes=())
+
+    傅里叶变换，可以对参数进行调整，以实现FFT/IFFT/RFFT/IRFFT。
+
+    对于FFT，它计算以下表达式：
+
+    .. math::
+        X[\omega_1, \dots, \omega_d] =
+            \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
+             e^{-j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
+
+    其中， :math:`d` = `signal_ndim` 是信号的维度，:math:`N_i` 则是信号第i个维度的大小。
+    
+    对于IFFT，它计算以下表达式：
+
+    .. math::
+        X[\omega_1, \dots, \omega_d] =
+            \frac{1}{\prod_{i=1}^d N_i} \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
+             e^{\ j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
+
+    其中， :math:`d` = `signal_ndim` 是信号的维度，:math:`N_i` 则是信号第i维的大小。
+
+    .. note::
+        - FFT/IFFT要求complex64或complex128类型的输入，返回complex64或complex128类型的输出。
+        - RFFT要求float32或float64类型的输入，返回complex64或complex128类型的输出。
+        - IRFFT要求complex64或complex128类型的输入，返回float32或float64类型的输出。
+
+    参数：
+        - **signal_ndim** (int) - 表示每个信号中的维数，控制着傅里叶变换的维数，其值只能为1、2或3。
+        - **inverse** (bool) - 表示该操作是否为逆变换，用以选择FFT、IFFT、RFFT和IRFFT。
+
+          - 如果为True，则为RFFT或IRFFT。
+          - 如果为False，则为FFT或IFFT。
+
+        - **real** (bool) - 表示该操作是否为实变换，用以选择FFT、IFFT、RFFT和IRFFT。
+
+          - 如果为True，则为RFFT或IRFFT。
+          - 如果为False，则为FFT或IFFT。
+  
+        - **norm** (str，可选) - 表示该操作的规范化方式，可选值：["backward", "forward", "ortho"]。默认值："backward"。
+  
+          - "backward"，正向变换不缩放，逆变换按 :math:`1/sqrt(n)` 缩放，其中 `n` 表示输入 `x` 的元素数量。。
+          - "ortho"，正向变换与逆变换均按 :math:`1/sqrt(n)` 缩放。
+          - "forward"，正向变换按 :math:`1/sqrt(n)` 缩放，逆变换不缩放。
+  
+        - **onesided** (bool，可选) - 控制输入是否减半以避免冗余。默认值：True。
+        - **signal_sizes** (list，可选) - 原始信号的大小（RFFT变换之前的信号，不包含batch这一维），只有在IRFFT模式下和设置 `onesided=True` 时需要该参数。默认值： :math:`[]` 。
+
+    输入：
+        - **x** (Tensor) - 输入Tensor的维数必须大于或等于 `signal_ndim` 。
+
+    输出：
+        Tensor，表示复数到复数、实数到复数或复数到实数傅里叶变换的结果。
+
+    异常：
+        - **TypeError** - 如果FFT/IFFT/IRFF的输入类型不是以下类型之一：complex64、complex128。
+        - **TypeError** - 如果RFFT的输入类型不是以下类型之一：float3、float64。
+        - **TypeError** - 如果输入的类型不是Tensor。
+        - **ValueError** - 如果输入 `x` 的维度小于 `signal_ndim` 。
+        - **ValueError** - 如果 `signal_ndim` 大于3或小于1。
+        - **ValueError** - 如果 `norm` 取值不是"backward"、"forward"或"ortho"。
\ No newline at end of file
diff --git a/docs/api/api_python/ops/mindspore.ops.GridSampler3D.rst b/docs/api/api_python/ops/mindspore.ops.GridSampler3D.rst
new file mode 100644
index 00000000000..eec09d0bda9
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.GridSampler3D.rst
@@ -0,0 +1,8 @@
+mindspore.ops.GridSampler3D
+===========================
+
+.. py:class:: mindspore.ops.GridSampler3D
+
+    给定一个输入和一个网格，使用网格中的输入值和像素位置计算输出。
+
+    更多参考详见 :func:`mindspore.ops.grid_sample`。
diff --git a/docs/api/api_python/ops/mindspore.ops.HSVToRGB.rst b/docs/api/api_python/ops/mindspore.ops.HSVToRGB.rst
new file mode 100644
index 00000000000..c04ae90735a
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HSVToRGB.rst
@@ -0,0 +1,20 @@
+mindspore.ops.HSVToRGB
+======================
+
+.. py:class:: mindspore.ops.HSVToRGB
+
+    将一个或多个图像从HSV转换为RGB。图像的格式应为：NHWC。
+
+    输入：
+        - **x** (Tensor) - 输入的图像必须是shape为 :math:`[batch, image_height, image_width, channel]` 的4维Tensor。
+          channel 值必须为3。
+          支持的类型：float16、float32、float64。
+
+    输出：
+        一个4-D Tensor，shape为 :math:`[batch, image_height, image_width, channel]` ，且数据类型同输入一致。
+
+    异常：
+        - **TypeError** - 如果 `x` 不是一个Tensor。
+        - **TypeError** - 如果 `x` 的数据类型不是float16、float32或float64。
+        - **ValueError** - 如果 `x` 的维度不等于4。
+        - **ValueError** - 如果 `x` 的最后一维不等于3。
diff --git a/docs/api/api_python/ops/mindspore.ops.HammingWindow.rst b/docs/api/api_python/ops/mindspore.ops.HammingWindow.rst
new file mode 100644
index 00000000000..fa562dc056d
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.HammingWindow.rst
@@ -0,0 +1,37 @@
+mindspore.ops.HammingWindow
+===========================
+
+.. py:class:: mindspore.ops.HammingWindow(periodic=True, alpha=0.54, beta=0.46, dtype=mstype.float32)
+
+    使用输入窗口长度计算汉明窗口函数。
+
+    .. math::
+         w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),
+
+    其中， :math:`N` 是全窗口尺寸。
+
+    参数：
+        - **periodic** (bool，可选) - 一个标志，表示返回的窗口是否修剪掉来自对称窗口的最后一个重复值。默认值：True。
+  
+          - 如果为True，则返回的窗口作为周期函数，在上式中， :math:`N = text{length} + 1` 。
+          - 如果为False，则返回一个对称窗口， :math:`N = text{length}` 。
+
+        - **alpha** (float，可选) - 加权系数，上式中的 :math:`\alpha` ，默认值：0.54。
+        - **beta** (float，可选) - 加权系数，上式中的 :math:`\beta` ，默认值：0.46。
+        - **dtype** (:class:`mindspore.dtype`，可选) - 数据类型，可选值为 `mindspore.dtype.float16` 、 `mindspore.dtype.float32` 或 `mindspore.dtype.float64` 。默认值： `mindspore.dtype.float32` 。
+
+    输入：
+        - **length** (Tensor) - 一个1D的正整数Tensor，控制返回窗口的大小。
+
+    输出：
+        Tensor，一个包含窗口的1-D Tensor，其shape为 :math:`\text{length}` 。
+
+    异常：
+        - **TypeError** - 如果 `length` 不是一个Tensor。
+        - **TypeError** - 如果 `length` 的数据类型不是整型。
+        - **TypeError** - 如果 `periodic` 的数据类型不是bool类型。
+        - **TypeError** - 如果 `alpha` 的数据类型不是float类型。
+        - **TypeError** - 如果 `beta` 的数据类型不是float类型。
+        - **TypeError** - 如果 `dtype` 的取值不是 `mindspore.float16` 、 `mindspore.float32` 或 `mindspore.float64` 。
+        - **ValueError** - 如果 `length` 的维度不是1。
+        - **ValueError** - 如果 `length` 的值是负数。
diff --git a/docs/api/api_python/ops/mindspore.ops.Heaviside.rst b/docs/api/api_python/ops/mindspore.ops.Heaviside.rst
new file mode 100644
index 00000000000..2d13f287a33
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Heaviside.rst
@@ -0,0 +1,25 @@
+mindspore.ops.Heaviside
+=======================
+
+.. py:class:: mindspore.ops.Heaviside
+
+    计算输入中每个元素的Heaviside步长函数。
+
+    .. math::
+            \text { heaviside }(\text { x, values })=\left\{\begin{array}{ll}
+            0, & \text { if x }<0 \\
+            \text { values, } & \text { if x }==0 \\
+            1, & \text { if x }>0
+            \end{array}\right.
+
+    输入：
+        - **x** (Tensor) - 输入Tensor，实数类型。
+        - **values** (Tensor) - 在 `x` 中为0的位置应用其值。 `values` 可以同 `x` 进行广播。 `x` 与 `values` 的数据类型应该相同。
+
+    输出：
+        Tensor，与 `x` 和 `values` 的数据类型相同。
+
+    异常：
+        - **TypeError** - 如果 `x` 或 `values` 不是Tensor。
+        - **TypeError** - 如果 `x` 与 `values` 的数据类型不一致。
+        - **ValueError** - 如果两个输入的shape之间无法进行广播。
diff --git a/docs/api/api_python/ops/mindspore.ops.Histogram.rst b/docs/api/api_python/ops/mindspore.ops.Histogram.rst
new file mode 100644
index 00000000000..774eb5da486
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Histogram.rst
@@ -0,0 +1,30 @@
+mindspore.ops.Histogram
+=======================
+
+.. py:class:: mindspore.ops.Histogram(bins=100, min=0.0, max=0.0)
+
+    计算Tensor的直方图。
+    
+    元素被分类到 `min` 和 `max` 之间的等宽箱中。
+    如果 `min` 和 `max` 均为0，则使用数据的最小值和最大值。
+
+    低于最小值和高于最大值的元素将被忽略。
+
+    参数：
+        - **bins** (int， 可选) - 直方图箱的数量，可选。默认值：100。若指定，则必须为正数。
+        - **min** (float，可选) - 范围下端（含）的可选浮点数。默认值：0.0。
+        - **max** (float，可选) - 范围上限（含）的可选浮点数。默认值：0.0。
+
+    输入：
+        - **x** (Tensor) - 输入Tensor，类型支持： :math:`[float16, float32, int32]` 。
+
+    输出：
+        Tensor，类型为int32的1-D Tensor。
+
+    异常：
+        - **TypeError** - 如果 `x` 不是Tensor。
+        - **TypeError** - 如果 `x` 的数据类型不支持。
+        - **TypeError** - 如果属性 `min` 或 `max` 不是float类型。
+        - **TypeError** - 如果属性 `bins` 不是整数。
+        - **ValueError** - 如果属性 `min` > `max` 。
+        - **ValueError** - 如果属性 `bins` <= 0。
diff --git a/docs/api/api_python/ops/mindspore.ops.Hypot.rst b/docs/api/api_python/ops/mindspore.ops.Hypot.rst
new file mode 100644
index 00000000000..f086b61527e
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Hypot.rst
@@ -0,0 +1,18 @@
+mindspore.ops.Hypot
+===================
+
+.. py:class:: mindspore.ops.Hypot
+
+    将输入Tensor的逐个元素作为直角三角形的直角边，并计算其斜边的值。
+    两个输入的shape应该是可广播的，且它们的数据类型应该是其中之一：float32、float64。
+
+    输入：
+        - **x1** (Tensor) - 第一个输入Tensor。
+        - **x2** (Tensor) - 第二个输入Tensor。
+
+    输出：
+        Tensor，shape与广播后的shape相同，数据类型为两个输入中具有更高的精度的那一个。
+
+    异常：
+        - **TypeError** - 如果 `x1` 或 `x2` 的数据类型不是float32或float64。
+        - **ValueError** - 如果两个输入的shape无法广播。
diff --git a/docs/api/api_python/ops/mindspore.ops.IdentityN.rst b/docs/api/api_python/ops/mindspore.ops.IdentityN.rst
new file mode 100644
index 00000000000..32c63409934
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.IdentityN.rst
@@ -0,0 +1,19 @@
+mindspore.ops.IdentityN
+=======================
+
+.. py:class:: mindspore.ops.IdentityN
+
+    返回与输入具有相同shape和值的tuple(Tensor)。
+
+    此操作可用于覆盖复杂函数的梯度。例如，假设 :math: `y = f(x)` ，
+    我们希望为反向传播应用自定义函数g，则 :math:`dx=g(dy)` 。
+
+    输入：
+        - **x** (Tensors) - tuple(Tensor)或List(Tensor)，数据类型为实数。
+
+    输出：
+        与输入 `x` 具有相同shape和数据类型的tuple(Tensor)。
+
+    异常：
+        - **TypeError** - 如果 `x` 不是tuple(Tensor)或List(Tensor)。
+        - **TypeError** - 如果 `x` 的数据类型不是实数。
diff --git a/docs/api/api_python/ops/mindspore.ops.IndexFill.rst b/docs/api/api_python/ops/mindspore.ops.IndexFill.rst
new file mode 100644
index 00000000000..9091bb98ba5
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.IndexFill.rst
@@ -0,0 +1,8 @@
+mindspore.ops.IndexFill
+=======================
+
+.. py:class:: mindspore.ops.IndexFill
+
+    按 `index` 中给定的顺序选择索引，将输入 `value` 的值填充到输入Tensor `x` 的所有 `dim` 维元素。
+
+    更多参考详见 :func:`mindspore.ops.index_fill`。
diff --git a/docs/api/api_python/ops/mindspore.ops.IsClose.rst b/docs/api/api_python/ops/mindspore.ops.IsClose.rst
new file mode 100644
index 00000000000..35066d34400
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.IsClose.rst
@@ -0,0 +1,8 @@
+mindspore.ops.IsClose
+=====================
+
+.. py:class:: mindspore.ops.IsClose
+
+    返回一个bool型Tensor，表示 `x1` 的每个元素与 `x2` 的每个元素在给定容忍度内是否“接近”。
+
+    更多参考详见 :func:`mindspore.ops.isclose`。
diff --git a/docs/api/api_python/ops/mindspore.ops.Lcm.rst b/docs/api/api_python/ops/mindspore.ops.Lcm.rst
new file mode 100644
index 00000000000..7ce49cd91eb
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.Lcm.rst
@@ -0,0 +1,18 @@
+mindspore.ops.Lcm
+=================
+
+.. py:class:: mindspore.ops.Lcm
+
+    逐个元素计算输入Tensor的最小公倍数。
+    两个输入的shape应该是可广播的，它们的数据类型应该是其中之一：int32、int64。
+
+    输入：
+        - **x1** (Tensor) - 第一个输入Tensor。
+        - **x2** (Tensor) - 第二个输入Tensor。
+
+    输出：
+        Tensor，shape与广播后的shape相同，数据类型为两个输入中具有更高的精度的那一个。
+
+    异常：
+        - **TypeError** - 如果 `x1` 或 `x2` 的数据类型不是int32或int64。
+        - **ValueError** - 如果两个输入的shape无法广播。
diff --git a/docs/api/api_python/ops/mindspore.ops.LeftShift.rst b/docs/api/api_python/ops/mindspore.ops.LeftShift.rst
new file mode 100644
index 00000000000..21cebdc67e2
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.LeftShift.rst
@@ -0,0 +1,26 @@
+mindspore.ops.LeftShift
+=======================
+
+.. py:class:: mindspore.ops.LeftShift
+
+    将Tensor每个位置的值向左移动几个比特位。
+    输入是两个Tensor，它们的数据类型必须一致，并且它们的shape可以广播。
+    输出不支持隐式类型转换。
+
+    .. math::
+
+        \begin{aligned}
+        &out_{i} =x_{i} << y_{i}
+        \end{aligned}
+
+    输入：
+        - **x1** (Tensor) - 目标Tensor，将根据 `x2` 对应位置的值向左移动相应的比特位，类型支持int8、int16、int32、int64、uint8、uint16、uint32、uint64。
+        - **x2** (Tensor) - Tensor必须具有与 `x1` 相同的数据类型，且其shape必须与 `x1` 相同或者可以与 `x1` 进行广播。
+
+    输出：
+        - **output** (Tensor) - 输出Tensor，数据类型与 `x1` 相同。并且输出Tensor的shape与 `x1` 相同，或者与广播后的 `x1` 和 `x2` 的shape相同。
+
+    异常：
+        - **TypeError** - 如果 `x1` 或 `x2` 的数据类型错误。
+        - **TypeError** - 如果 `x1` 或 `x2` 不是Tensor。
+        - **ValueError** - 如果 `x1` 与 `x2` 无法广播。
diff --git a/docs/api/api_python/ops/mindspore.ops.ListDiff.rst b/docs/api/api_python/ops/mindspore.ops.ListDiff.rst
new file mode 100644
index 00000000000..10960165e95
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.ListDiff.rst
@@ -0,0 +1,28 @@
+mindspore.ops.ListDiff
+======================
+
+.. py:class:: mindspore.ops.ListDiff(out_idx=mstype.int32)
+
+    比较两个数字列表之间的不同。
+
+    给定一个列表 `x` 和一个列表 `y`，此操作返回一个列表 `out`，表示在 `x` 中但不在 `y` 中的所有值。
+    返回列表 `out` 的排序顺序与数字出现在 `x` 中的顺序相同（保留重复项）。此操作还会返回一个列表 `idx` ，
+    表示每个 `out` 元素在 `x` 中的位置。即： :math:`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]` 。
+
+    参数：
+        - **out_idx** ( :class:`mindspore.dtype` ，可选) - `idx` 的数据类型，可选值： `mindspore.dtype.int32` 和 `mindspore.dtype.int64` 。默认值： `mindspore.dtype.int32` 。
+
+    输入：
+        - **x** (Tensor) - 一个1-D Tensor。保留的值。类型支持：[float16, float32, float64, uint8, uint16, int8, int16, int32, int64]。
+        - **y** (Tensor) - 一个1-D Tensor，与 `x` 类型一致。移除的值。
+
+    输出：
+        **out** (Tensor) - 一个1-D Tensor，与 `x` 类型一致。
+        **idx** (Tensor) - 一个1-D Tensor， `out_idx` 类型。
+
+    异常：
+        - **ValueError** - 如果 `x` 或 `y` 的shape不是1D。
+        - **TypeError** - 如果 `x` 或 `y` 不是Tensor。
+        - **TypeError** - 如果 `x` 或 `y` 的数据类型不在支持列表里。
+        - **TypeError** - 如果 `x` 与 `y` 的数据类型不同。
+        - **TypeError** - 如果属性 `out_idx` 的取值不在[mindspore.dtype.int32, mindspore.dtype.int64]中。
diff --git a/docs/api/api_python/ops/mindspore.ops.LogMatrixDeterminant.rst b/docs/api/api_python/ops/mindspore.ops.LogMatrixDeterminant.rst
new file mode 100644
index 00000000000..81b0a082c6b
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.LogMatrixDeterminant.rst
@@ -0,0 +1,8 @@
+mindspore.ops.LogMatrixDeterminant
+==================================
+
+.. py:class:: mindspore.ops.LogMatrixDeterminant
+
+    计算一个或多个方块矩阵行列式绝对值的符号和对数。
+
+    更多参考详见 :func:`mindspore.ops.log_matrix_determinant`。
diff --git a/docs/api/api_python/ops/mindspore.ops.LogNormalReverse.rst b/docs/api/api_python/ops/mindspore.ops.LogNormalReverse.rst
new file mode 100644
index 00000000000..c93b1ef3037
--- /dev/null
+++ b/docs/api/api_python/ops/mindspore.ops.LogNormalReverse.rst
@@ -0,0 +1,23 @@
+mindspore.ops.LogNormalReverse
+==============================
+
+.. py:class:: mindspore.ops.LogNormalReverse(mean=2.0, std=1.0)
+
+    用给定均值和标准差初始化对数正态分布，并以此填充输入Tensor的元素。
+
+    .. math::
+        \text{f}(x;1.0,2.0)=\frac{1}{x\delta \sqrt[]{2\pi} }e^{-\frac{(\ln x-\mu )^2}{2\delta ^2} }
+
+    参数：
+        - **mean** (float，可选) - 正态分布的均值，float类型。默认值：2.0。
+        - **std** (float，可选) - 正态分布的标准差，float类型。默认值：1.0。
+
+    输入：
+        - **input** (Tensor) - 要用对数正态分布生成的Tensor。必须是以下类型之一：float16、float32。
+
+    输出：
+        Tensor，与 `input` 的shape及数据类型相同。
+
+    异常：
+        - **TypeError** - 如果 `input` 不是Tensor。
+        - **ValueError** - 如果 `input` 是NULL。
diff --git a/docs/api/api_python/ops/mindspore.ops.ReduceStd.rst b/docs/api/api_python/ops/mindspore.ops.ReduceStd.rst
index c70b11b1c83..2fbc2783f5e 100644
--- a/docs/api/api_python/ops/mindspore.ops.ReduceStd.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ReduceStd.rst
@@ -3,8 +3,7 @@ mindspore.ops.ReduceStd
 
 .. py:class:: mindspore.ops.ReduceStd(axis=(), unbiased=True, keep_dims=False)
 
-    默认情况下，输出Tensor各维度上的标准差与均值，也可以对指定维度求标准差与均值。如果 `axis` 是维度列表，则减少对应的维度。
-
-    通过指定 `keep_dims` 参数，来控制输出和输入的维度是否相同。
+    返回输入Tensor在 `axis` 维上每一行的标准差和均值。
+    如果 `axis` 是维度列表，则减少列表内的所有维度。
 
     更多参考详见 :func:`mindspore.ops.std`。
\ No newline at end of file
diff --git a/docs/api/api_python_en/mindspore.ops.rst b/docs/api/api_python_en/mindspore.ops.rst
index 05f8b6d3933..67121e82abd 100644
--- a/docs/api/api_python_en/mindspore.ops.rst
+++ b/docs/api/api_python_en/mindspore.ops.rst
@@ -60,6 +60,7 @@ Neural Network
     mindspore.ops.DynamicGRUV2
     mindspore.ops.DynamicRNN
     mindspore.ops.Flatten
+    mindspore.ops.GridSampler3D
     mindspore.ops.LayerNorm
     mindspore.ops.LRN
     mindspore.ops.LSTM
@@ -203,6 +204,7 @@ Image Processing
     mindspore.ops.CombinedNonMaxSuppression
     mindspore.ops.CropAndResize
     mindspore.ops.ExtractVolumePatches
+    mindspore.ops.HSVToRGB
     mindspore.ops.IOU
     mindspore.ops.L2Normalize
     mindspore.ops.NMSWithMask
@@ -345,6 +347,7 @@ Reduction Operator
     mindspore.ops.ReduceMean
     mindspore.ops.ReduceMin
     mindspore.ops.ReduceProd
+    mindspore.ops.ReduceStd
     mindspore.ops.ReduceSum
 
 Comparison Operator
@@ -417,6 +420,7 @@ Random Generation Operator
     :template: classtemplate.rst
 
     mindspore.ops.Gamma
+    mindspore.ops.LogNormalReverse
     mindspore.ops.Multinomial
     mindspore.ops.RandomCategorical
     mindspore.ops.RandomChoiceWithMask
@@ -453,18 +457,30 @@ Array Operation
     mindspore.ops.DiagPart
     mindspore.ops.DType
     mindspore.ops.ExpandDims
+    mindspore.ops.FFTWithSize
     mindspore.ops.FloatStatus
     mindspore.ops.Gather
     mindspore.ops.GatherD
     mindspore.ops.GatherNd
+    mindspore.ops.HammingWindow
+    mindspore.ops.Heaviside
+    mindspore.ops.Histogram
     mindspore.ops.HistogramFixedWidth
+    mindspore.ops.Hypot
     mindspore.ops.Identity
+    mindspore.ops.IdentityN
     mindspore.ops.Im2Col
     mindspore.ops.IndexAdd
+    mindspore.ops.IndexFill
     mindspore.ops.InplaceAdd
     mindspore.ops.InplaceSub
     mindspore.ops.InplaceUpdate
     mindspore.ops.InvertPermutation
+    mindspore.ops.IsClose
+    mindspore.ops.Lcm
+    mindspore.ops.LeftShift
+    mindspore.ops.ListDiff
+    mindspore.ops.LogMatrixDeterminant
     mindspore.ops.LogSpace
     mindspore.ops.LowerBound
     mindspore.ops.Lstsq
diff --git a/mindspore/python/mindspore/ops/operations/array_ops.py b/mindspore/python/mindspore/ops/operations/array_ops.py
index 131fabce87b..2e61768a94e 100755
--- a/mindspore/python/mindspore/ops/operations/array_ops.py
+++ b/mindspore/python/mindspore/ops/operations/array_ops.py
@@ -6489,8 +6489,12 @@ class ListDiff(Primitive):
     is sorted in the same order that the numbers appear in `x` (duplicates are
     preserved). This operation also returns a list `idx` that represents the
     position of each `out` element in `x`. In other words:
+    :math:`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]` .
 
-    `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+    Args:
+        out_idx (:class:`mindspore.dtype`, optional): The dtype of `idx`,
+        an optioanal datatype of `mindspore.dtype.int32` and `mindspore.dtype.int64`.
+        Default: `mindspore.dtype.int32`.
 
     Inputs:
         - **x**: A 1-D `Tensor`. Values to keep. type support list [float16, float32,
@@ -6506,15 +6510,15 @@ class ListDiff(Primitive):
         TypeError: If `x` or `y` is not a Tensor.
         TypeError: If `x` or `y` datetype not in support list.
         TypeError: If `x` has different data type with `y`.
-        TypeError: If attr `out_idx` not in [mstype.int32, mstype.int64].
+        TypeError: If attr `out_idx` not in [mindspore.dtype.int32, mindspore.dtype.int64].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.arange(1, 7, 1), dtype=mstype.int32) # [1, 2, 3, 4, 5, 6]
-        >>> y = Tensor([1, 3, 5], dtype=mstype.int32)
-        >>> op = ops.ListDiff() # out_idx default is mstype.int32
+        >>> x = Tensor(np.arange(1, 7, 1), dtype=mindspore.dtype.int32) # [1, 2, 3, 4, 5, 6]
+        >>> y = Tensor([1, 3, 5], dtype=mindspore.dtype.int32)
+        >>> op = ops.ListDiff() # out_idx default is mindspore.dtype.int32
         >>> out, idx = op(x, y)
         >>> print(out)
         [2 4 6]
@@ -7092,7 +7096,8 @@ class LogSpace(Primitive):
         TypeError: If `input` is not a Tensor.
         TypeError: If `steps` is not an int.
         TypeError: If `base` is not an int.
-        TypeError: If `dtype` is not mindspore.float16, mindspore.float32 or mindspore.float64(for GPU).
+        TypeError: If `dtype` is not mindspore.float16, mindspore.float32 or
+            mindspore.float64(for GPU).
         ValueError: If `steps` is not a non-negative integer.
         ValueError: If `base` is not a non-negative integer.
 
@@ -7221,7 +7226,7 @@ class IndexFill(Primitive):
     Fills the elements under the dim dimension of the input Tensor with the input value
     by selecting the indices in the order given in index.
 
-    Refer to :func:`mindspore.ops.index_fill` for more detail.
+    Refer to :func:`mindspore.ops.index_fill` for more details.
     Inputs:
         - **x** (Tensor) - Input tensor.
           The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
@@ -7545,13 +7550,16 @@ class HammingWindow(Primitive):
     where :math:`N` is the full window size.
 
     Args:
-        periodic (bool): a flag determines whether the returned window trims off the last
-            duplicate value from the symmetric window. If True, returns a window to be used
-            as periodic function, in above formula, :math:`N = \text{length} + 1`.
-            If False, return a symmetric window, :math:`N = \text{length}`. Default: True.
-        alpha (float): The coefficient :math:`\alpha` in the equation above, default to 0.54.
-        beta (float): The coefficient :math:`\beta` in the equation above, default to 0.46.
-        dtype (:class:`mindspore.dtype`): An optional data type of `mindspore.dtype.float16`,
+        periodic (bool, optional): a flag determines whether the returned window trims off
+            the last duplicate value from the symmetric window. Default: True.
+
+            - If True, returns a window to be used as periodic function, in above formula,
+              :math:`N = \text{length} + 1`.
+            - If False, return a symmetric window, :math:`N = \text{length}`.
+
+        alpha (float, optional): The coefficient :math:`\alpha` in the equation above. Default: 0.54.
+        beta (float, optional): The coefficient :math:`\beta` in the equation above. Default: 0.46.
+        dtype (:class:`mindspore.dtype`, optional): An optional data type of `mindspore.dtype.float16`,
             `mindspore.dtype.float32` and `mindspore.dtype.float64`. Default: `mindspore.dtype.float32`.
 
     Inputs:
diff --git a/mindspore/python/mindspore/ops/operations/image_ops.py b/mindspore/python/mindspore/ops/operations/image_ops.py
index 145bdcf4a1f..57d10d3a1ce 100644
--- a/mindspore/python/mindspore/ops/operations/image_ops.py
+++ b/mindspore/python/mindspore/ops/operations/image_ops.py
@@ -488,15 +488,18 @@ class NonMaxSuppressionWithOverlaps(Primitive):
 class HSVToRGB(Primitive):
     """
     Convert one or more images from HSV to RGB.
-    Outputs a tensor of the same shape as the images tensor, containing the HSV value of the pixels.
-    The output is only well defined if the value in images are in [0,1].
+    Outputs a tensor of the same shape as the images tensor,
+    containing the HSV value of the pixels. The output is only
+    well defined if the value in images are in [0,1].
 
     Inputs:
-        **x** (Tensor) - The input image must be a 4-D tensor of shape [batch, image_height, image_width, channel].
-        Number of channel must be 3.
-        Types allowed: float16, float32, float64.
+        - **x** (Tensor) - The input image must be a 4-D tensor of shape
+          :math:`[batch, image_height, image_width, channel]`.
+          Number of channel must be 3. Types allowed: float16, float32, float64.
+
     Outputs:
-        A 4-D tensor of shape [batch, image_height, image_width, channel] with same type of input.
+        A 4-D tensor of shape :math:`[batch, image_height, image_width, channel]`
+        with same type of input.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -755,6 +758,7 @@ class ResizeBicubic(Primitive):
           Types allowed: int8, int16, int32, int64, float16, float32, float64, uint8, uint16.
         - **size** (Tensor) - A 1-D tensor of shape [2], with 2 elements: new_height, new_width.
           Types allowed: int32.
+
     Outputs:
         A 4-D tensor of shape [batch, new_height, new_width, channels] with type: float32.
 
diff --git a/mindspore/python/mindspore/ops/operations/math_ops.py b/mindspore/python/mindspore/ops/operations/math_ops.py
index c9a9622c512..b7945f37e35 100644
--- a/mindspore/python/mindspore/ops/operations/math_ops.py
+++ b/mindspore/python/mindspore/ops/operations/math_ops.py
@@ -2466,7 +2466,7 @@ class ReduceStd(Primitive):
     Returns the standard-deviation and mean of each row of the input tensor in the dimension `axis`.
     If `axis` is a list of dimensions, reduce over all of them.
 
-    Refer to :func:`mindspore.ops.std` for more detail.
+    Refer to :func:`mindspore.ops.std` for more details.
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -2878,8 +2878,9 @@ class Heaviside(Primitive):
 
     Inputs:
         - **x** (Tensor) - The input tensor. With real number data type.
-        - **values** (Tensor) - The values to use where x is zero. Values can be broadcast with x.
-          'x' should have the same dtype with 'values'.
+        - **values** (Tensor) - The values to use where `x` is zero.
+          Values can be broadcast with `x` . 'x' should have the same
+          dtype with 'values'.
 
     Outputs:
         Tensor, has the same type as 'x' and 'values'.
@@ -5589,7 +5590,7 @@ class LogMatrixDeterminant(Primitive):
     """
     Computes the sign and the log of the absolute value of the determinant of one or more square matrices.
 
-    Refer to :func:`mindspore.ops.log_matrix_determinant` for more detail.
+    Refer to :func:`mindspore.ops.log_matrix_determinant` for more details.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -6143,7 +6144,7 @@ class IsClose(Primitive):
     r"""
     Returns a boolean Tensor where two tensors are element-wise equal within a tolerance.
 
-    Refer to :func:`mindspore.ops.isclose` for more detail.
+    Refer to :func:`mindspore.ops.isclose` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -7093,7 +7094,7 @@ class FFTWithSize(Primitive):
             \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
              e^{-j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
 
-    where :math:`d` = :attr:`signal_ndim` is number of dimensions for the
+    where :math:`d` = `signal_ndim` is number of dimensions for the
     signal, and :math:`N_i` is the size of signal dimension :math:`i`.
 
     For ifft, it computes the following expression:
@@ -7103,26 +7104,29 @@ class FFTWithSize(Primitive):
             \frac{1}{\prod_{i=1}^d N_i} \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
              e^{\ j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
 
-    where :math:`d` = :attr:`signal_ndim` is number of dimensions for the
+    where :math:`d` = `signal_ndim` is number of dimensions for the
     signal, and :math:`N_i` is the size of signal dimension :math:`i`.
 
     Note:
-        FFT/IFFT requires complex64 or complex128 inputs, return complex64 or complex128 outputs.
-        RFFT requires float32 or float64 inputs, return complex64 or complex128 outputs.
-        IRFFT requires complex64 or complex128 inputs, return float32 or float64 outputs.
+        - FFT/IFFT requires complex64 or complex128 inputs, return complex64 or complex128 outputs.
+        - RFFT requires float32 or float64 inputs, return complex64 or complex128 outputs.
+        - IRFFT requires complex64 or complex128 inputs, return float32 or float64 outputs.
 
     Args:
-        signal_ndim (int): The number of dimensions in each signal, this controls how many dimensions of the fourier
-            transform are realized, can only be 1, 2 or 3.
-        inverse (bool): Whether it is the inverse transformation, used to select FFT or IFFT and RFFT or IRFFT.
-            inverse=False means FFT or RFFT, inverse=True means IFFT or IRFFT.
+        signal_ndim (int): The number of dimensions in each signal, this controls how many dimensions
+            of the fourier transform are realized, can only be 1, 2 or 3.
+        inverse (bool): Whether it is the inverse transformation, used to select FFT or IFFT and RFFT or
+            IRFFT. inverse=False means FFT or RFFT, inverse=True means IFFT or IRFFT.
         real (bool): Whether it is the real transformation, used to select FFT/IFFT or RFFT/IRFFT.
             real=False means FFT or IFFT, real=True means RFFT or IRFFT.
-        norm (str): The default normalization ("backward") has the direct (forward) transforms unscaled
-            and the inverse (backward) transforms scaled by 1/n.
-            "ortho" has both direct and inverse transforms are scaled by 1/sqrt(n).
-            "forward" has the direct transforms scaled by 1/n and the inverse transforms unscaled.
-            n is the input x's element numbers.
+        norm (str, optional): The normalization, optional values: ["backward", "forward", "ortho"].
+            Default value: "backward".
+
+            - "backward" has the direct (forward) transforms unscaled and the inverse (backward) transforms
+              scaled by 1/n, where n is the input x's element numbers.
+            - "ortho" has both direct and inverse transforms are scaled by 1/sqrt(n).
+            - "forward" has the direct transforms scaled by 1/n and the inverse transforms unscaled.
+
         onesided (bool): Controls whether the input is halved to avoid redundancy. Default: True.
         signal_sizes (list): Size of the original signal (the signal before rfft, no batch dimension),
             only in irfft mode and set onesided=true requires the parameter. Default: [].
diff --git a/mindspore/python/mindspore/ops/operations/random_ops.py b/mindspore/python/mindspore/ops/operations/random_ops.py
index 24fd0a3e026..1fb82d90f25 100755
--- a/mindspore/python/mindspore/ops/operations/random_ops.py
+++ b/mindspore/python/mindspore/ops/operations/random_ops.py
@@ -268,18 +268,21 @@ class RandomGamma(Primitive):
 
 class LogNormalReverse(Primitive):
     r"""
-    Fills the elements of the input tensor with log normal values initialized by given mean and std:
+    Fills the elements of the input tensor with log normal values initialized by
+    given mean and std:
 
     .. math::
         \text{f}(x;1.0,2.0)=\frac{1}{x\delta \sqrt[]{2\pi} }e^{-\frac{(\ln x-\mu )^2}{2\delta ^2} }
 
     Args:
-        mean (float): the mean of normal distribution. With float data type. Default: 2.0.
-        std (float): the std of normal distribution. With float data type. Default: 1.0.
+        mean (float, optional): the mean of normal distribution. With float data type.
+            Default: 2.0.
+        std (float, optional): the std of normal distribution. With float data type.
+            Default: 1.0.
 
     Inputs:
         - **input** (Tensor) - The tensor to be generated with log-normal distribution.
-        Must be one of the following types: float16, float32.
+          Must be one of the following types: float16, float32.
 
     Outputs:
         Tensor. A Tensor with the same type and shape of input.