optimizes the documentation of chinese API of Sort,Split,Stack,etc.

docs/api/api_python/ops/mindspore.ops.Sort.rst

@@ -0,0 +1,26 @@
+mindspore.ops.Sort
+===================
+
+.. py:class:: mindspore.ops.Sort(axis=-1, descending=False)
+
+    根据指定的维度对输入Tensor的元素进行排序。默认为升序排序。
+
+    **参数：**
+
+    - **axis** (int) - 指定排序的轴。默认值：-1。
+    - **descending** (bool) - 指定排序方式。如果descending为True，则根据value对元素进行升序排序。默认值：False。
+
+    **输入：**
+
+    - **x** (Tensor) - Sort的输入，任意维度的Tensor，数据类型为float16或float32。
+
+    **输出：**
+
+    - **y1** (Tensor) - Tensor，其值为排序后的值，shape和数据类型与输入相同。
+    - **y2** (Tensor) - 输入Tensor，其元素的索引。数据类型为int32。
+
+    **异常：**
+
+    - **TypeError** - `axis` 不是int。
+    - **TypeError** - `descending` 不是bool。
+    - **TypeError** - `x` 的数据类型既不是float16也不是float32。

docs/api/api_python/ops/mindspore.ops.Split.rst

@@ -0,0 +1,26 @@
+mindspore.ops.Split
+====================
+
+.. py:class:: mindspore.ops.Split(axis=0, output_num=1)
+
+    根据指定的轴和分割数量对输入Tensor进行分割。
+
+    `input_x` Tensor将被分割为相同shape的子Tensor，且要求 `input_x.shape(axis)` 可被 `output_num` 整除。
+
+    **参数：**
+
+    - **axis** (int) - 指定分割轴。默认值：0。
+    - **output_num** (int) - 指定分割数量。其值为正整数。默认值：1。
+
+    **输入：**
+
+    - **input_x** (Tensor) - Tensor的shape为 :math:`(x_1, x_2, ..., x_R)` 。
+
+    **输出：**
+
+    tuple[Tensor]，每个输出Tensor的shape相同，即 :math:`(y_1, y_2, ..., y_S)` 。数据类型与 `input_x` 的相同。
+
+    **异常：**
+
+    - **TypeError** - `axis` 或 `output_num` 不是int。
+    - **ValueError** - `axis` 超出[-len(`input_x.shape`), len(`input_x.shape`))范围。或 `output_num` 小于或等于0。

docs/api/api_python/ops/mindspore.ops.Sqrt.rst

@@ -0,0 +1,21 @@
+mindspore.ops.Sqrt
+===================
+
+.. py:class:: mindspore.ops.Sqrt
+
+    计算输入Tensor的平方根。
+
+    .. math::
+        out_{i} =  \sqrt{x_{i}}
+
+    **输入：**
+
+    - **x** (Tensor) - Sqrt的输入，任意维度的Tensor，其秩应小于8，数据类型为Number。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `x` 不是Tensor。

docs/api/api_python/ops/mindspore.ops.Stack.rst

@@ -0,0 +1,27 @@
+mindspore.ops.Stack
+====================
+
+.. py:class:: mindspore.ops.Stack(axis=0)
+
+    根据指定轴对输入Tensor序列进行堆叠运算。
+
+    输入秩为 `R` 的Tensor序列，且输出秩为 `(R+1)` 的Tensor。
+
+    给定输入Tensor的shape为 :math:`(x_1, x_2, ..., x_R)` 。将输入Tensor的数量设为 `N` 。如果存在 :math:`0 \le axis` ，则输出Tensor的shape为 :math:`(x_1, x_2, ..., x_{axis}, N, x_{axis+1}, ..., x_R)` 。
+
+    **参数：**
+
+    - **axis** (int) - 指定堆叠运算的轴。取值范围为[-(R+1), R+1)。默认值：0。
+
+    **输入：**
+
+    - **input_x** (Union[tuple, list]) - 输入多个Tensor对象组成的tuple或list，每个Tensor具有相同shape和数据类型。
+
+    **输出：**
+
+    堆叠运算后的Tensor，数据类型和 `input_x` 的相同。
+
+    **异常：**
+
+    - **TypeError** - `input_x` 中元素的数据类型不相同。
+    - **ValueError** - `input_x` 的长度不大于1，或axis不在[-(R+1),R+1)范围中，或 input_x` 中元素的shape不相同。

docs/api/api_python/ops/mindspore.ops.StridedSlice.rst

@@ -0,0 +1,64 @@
+mindspore.ops.StridedSlice
+===========================
+
+.. py:class:: mindspore.ops.StridedSlice(begin_mask=0, end_mask=0, ellipsis_mask=0, new_axis_mask=0, shrink_axis_mask=0)
+
+    输入Tensor根据步长和索引进行切片提取。
+
+    给定一个输入Tensor，此操作会插入长度为1的维度。从给定的'input_tensor'中提取大小为(end-begin)/stride的片段。从起始位置开始，根据步长和索引进行提取，直到所有维度都不小于结束位置为止。
+
+    给定一个 `input_x[m1, m2, ...、mn]` 。 `begin` 、 `end` 和 `strides` 是长度为n的向量。
+
+    在每个掩码字段中（`begin_mask`、`end_mask`、`ellipsis_mask`、`new_axis_mask`、`shrink_ax_mask`)，第i位将对应于第i个m。
+
+    如果设置了 `begin_mask` 的第i位，则忽略 `begin[i]` ，而使用该维度中最有可能的取值范围。除了结尾的取值范围， `end_mask` 是类似的。
+
+    对于5*6*7的Tensor， `x[2:,:3,:]` 等同于 `x[2:5,0:3,0:7]` 。
+
+    如果设置了 `elipsis_mask` 的第i位，则将在其他维度之间插入所需的任意数量的未指定维度。 `ellipsis_mask` 中只允许一个非零位。
+    
+    对于5*6*7*8的Tensor， `x[2:,...,:6]` 等同于 `x[2:5,:,:,0:6]` 。 `x[2:,...]` 等同于 `x[2:5,:,:,:]` 。
+
+    如果设置了 `new_ax_mask` 的第i位，则忽略 `begin` 、 `end` 和 `strides` ，并在输出Tensor的指定位置添加新的长度为1的维度。
+
+    对于5*6*7的Tensor， `x[:2, newaxis, :6]` 将产生一个shape为(2, 1, 7)的Tensor。
+
+    如果设置了 `shrink_ax_mask` 的第i位，则第i个大小将维度收缩1，并忽略 `begin[i]` 、 `end[i]` 和 `strides[i]` 索引处的值。
+
+    对于5*6*7的Tensor， `x[:, 5, :]` 将使得 `shrink_axis_mask` 等于4。
+
+    .. note::
+        步长可能为负值，这会导致反向切片。 `begin` 、 `end` 和 `strides` 的shape必须相同。 `begin` 和 `end` 是零索引。 `strides` 的元素必须非零。
+
+    **参数：**
+
+    - **begin_mask** (int) - 表示切片的起始索引。使用二进制flag对输入Tensor不同维度进行标志，第i位设置为1则begin[i]参数对应的第i维度设置无效，表示该维度的起始索引从0开始。默认值：0。
+    - **end_mask** (int) - 表示切片的结束索引。功能类似begin_mask。使用二进制flag对输入Tensor不同维度进行标志，第i位设置为1则end参数对应的该维度设置无效，表示该维度切分的结束索引到列表最后，即切分到尽可能大的维度。默认值：0。
+    - **ellipsis_mask** (int) - 不为0的维度不需要进行切片操作。为int型掩码。默认值：0。
+    - **new_axis_mask** (int) - 如果第i位出现1，则begin、end、stride对所有维度参数无效，并在第1位上增加一个大小为1的维度。为int型掩码。默认值：0。
+    - **shrink_axis_mask** (int) - 如果第i位设置为1，则意味着第i维度缩小为1。为int型掩码。默认值：0。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 需要切片处理的输入Tensor。
+    - **begin** (tuple[int]) - 指定开始切片的索引。输入为一个tuple，仅支持常量值。
+    - **end** (tuple[int]) - 指定结束切片的索引。输入为一个tuple，仅支持常量值。
+    - **strides** (tuple[int]) - tuple，指定各维度切片的步长。仅支持常量值。
+
+    **输出：**
+
+    Tensor。以下内容介绍了输出。
+
+    在第0个维度中，begin为1，end为2，stride为1，因为 :math:`1+1=2\geq2` ，且interval为 :math:`[1,2)` 。因此，在第0个维度中返回具有 :math:`index = 1` 的元素，例如[[3, 3, 3]，[4, 4, 4]]。
+
+    同样在第一个维度中，interval为 :math:`[0,1)` 。根据第0个维度的返回值，返回具有 :math:`index = 0` 的元素，例如[3, 3, 3]。
+
+    同样在第二个维度中，interval为 :math:`[0,3)` 。根据第1个维度的返回值，返回具有 :math:`index = 0,1,2` 的元素，例如[3, 3, 3]。
+
+    最后，输出为[3, 3, 3]。
+
+    **异常：**
+
+    - **TypeError** - `begin_mask` 、 `end_mask` 、 `ellipsis_mask` 、 `new_ax_mask` 或 `shrink_ax_mask` 不是int。
+    - **TypeError** - `begin` 、 `end` 或 `strides` 不是tuple。
+    - **ValueError** - `begin_mask` 、 `end_mask` 、 `ellipsis_mask` 、 `new_axis_mask` 或 `shrink_axis_mask` 小于0。

docs/api/api_python/ops/mindspore.ops.Tanh.rst

@@ -0,0 +1,26 @@
+mindspore.ops.Tanh
+===================
+
+.. py:class:: mindspore.ops.Tanh
+
+    Tanh激活函数。
+
+    按元素计算输入元素的双曲正切。Tanh函数定义为：
+
+    .. math::
+        tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
+
+    其中 :math:`x_i` 是输入Tensor的元素。
+
+    **输入：**
+
+    - **input_x** (Tensor) - Tanh的输入，任意维度的Tensor，其数据类型为float16或float32。
+
+    **输出：**
+
+    Tensor，数据类型和shape与 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `input_x` 的数据类型既不是float16也不是float32。
+    - **TypeError** - `input_x` 不是Tensor。

docs/api/api_python/ops/mindspore.ops.TensorScatterAdd.rst

@@ -0,0 +1,26 @@
+mindspore.ops.TensorScatterAdd
+===============================
+
+.. py:class:: mindspore.ops.TensorScatterAdd
+
+    根据指定的更新值和输入索引，通过相加运算更新输入Tensor的值。当同一索引有不同值时，更新的结果将是所有值的总和。此操作与ScatterNdAdd类似，只是更新后的结果是通过算子output返回，而不是直接原地更新input。
+
+    `indices` 的最后一个轴是每个索引向量的深度。对于每个索引向量， `updates` 中必须有相应的值。 `updates` 的shape应该等于 `input_x[indices]` 的shape。有关更多详细信息，请参见使用用例。
+
+    .. note::
+        如果 `indices` 的某些值超出范围，则相应的 `updates` 不会更新为 `input_x` ，而不是抛出索引错误。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor。input_x的维度必须不小于indices.shape[-1]。
+    - **indices** (Tensor) - 输入Tensor的索引，数据类型为int32或int64的。其rank必须至少为2。
+    - **updates** (Tensor) - 指定与 `input_x` 相加操作的Tensor，其数据类型与输入相同。updates.shape应等于indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `indices` 的数据类型既不是int32，也不是int64。
+    - **ValueError** - `input_x` 的shape长度小于 `indices` 的shape的最后一个维度。

docs/api/api_python/ops/mindspore.ops.TensorScatterMax.rst

@@ -0,0 +1,26 @@
+mindspore.ops.TensorScatterMax
+===============================
+
+.. py:class:: mindspore.ops.TensorScatterMax
+
+    根据指定的更新值和输入索引，通过最大值运算更新输入Tensor的值。
+
+    索引的最后一个轴是每个索引向量的深度。对于每个索引向量， `updates` 中必须有相应的值。 `updates` 的shape应该等于input_x[indices]的shape。有关更多详细信息，请参见使用用例。
+
+    .. note::
+        如果 `indices` 的某些值超出范围，则相应的 `updates` 不会更新为 `input_x` ，而不是抛出索引错误。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor。input_x的维度必须不小于indices.shape[-1]。
+    - **indices** (Tensor) - 输入Tensor的索引，数据类型为int32或int64的。其rank必须至少为2。
+    - **updates** (Tensor) - 指定与 `input_x` 取最大值操作的Tensor，其数据类型与输入相同。updates.shape应等于indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `indices` 的数据类型既不是int32，也不是int64。
+    - **ValueError** - `input_x` 的shape长度小于 `indices` 的shape的最后一个维度。

docs/api/api_python/ops/mindspore.ops.TensorScatterMin.rst

@@ -0,0 +1,27 @@
+mindspore.ops.TensorScatterMin
+===============================
+
+.. py:class:: mindspore.ops.TensorScatterMin
+
+    根据指定的更新值和输入索引，通过最小值运算更新输入Tensor的值。
+
+    索引的最后一个轴是每个索引向量的深度。对于每个索引向量， `updates` 中必须有相应的值。 `updates` 的shape应该等于input_x[indices]的shape。
+    有关更多详细信息，请参见使用用例。
+
+    .. note::
+        如果 `indices` 的某些值超出范围，则相应的 `updates` 不会更新为 `input_x` ，而不是抛出索引错误。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor。input_x的维度必须不小于indices.shape[-1]。
+    - **indices** (Tensor) - 输入Tensor的索引，数据类型为int32或int64。其rank必须至少为2。
+    - **updates** (Tensor) - 指定与 `input_x` 取最小值操作的Tensor，其数据类型与输入相同。updates.shape应该等于indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `indices` 的数据类型既不是int32，也不是int64。
+    - **ValueError** - `input_x` 的shape长度小于 `indices` 的shape的最后一个维度。

docs/api/api_python/ops/mindspore.ops.TensorScatterSub.rst

@@ -0,0 +1,27 @@
+mindspore.ops.TensorScatterSub
+===============================
+
+.. py:class:: mindspore.ops.TensorScatterSub
+
+    根据指定的更新值和输入索引，通过减法运算更新输入Tensor的值。当同一个索引有多个不同值时，更新的结果将分别减去这些值。此操作几乎等同于使用ScatterNdSub，只是更新后的结果是通过算子output返回，而不是直接原地更新input。
+
+    `indices` 的最后一个轴是每个索引向量的深度。对于每个索引向量， `updates` 中必须有相应的值。`updates` 的shape应该等于 `input_x[indices]` 的shape。有关更多详细信息，请参见使用用例。
+
+    .. note::
+        如果 `indices` 的某些值超出范围，则相应的 `updates` 不会更新为 `input_x` ，而不是抛出索引错误。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor。input_x的维度必须不小于indices.shape[-1]。
+    - **indices** (Tensor) - 输入Tensor的索引，数据类型为int32或int64的，其rank必须至少为2。
+    - **updates** (Tensor) - 指定与 `input_x` 相减操作的Tensor，其数据类型与输入相同。updates.shape应等于indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `indices` 的数据类型既不是int32，也不是int64。
+    - **ValueError** - `input_x` 的shape长度小于 `indices` 的shape的最后一个维度。
+    

docs/api/api_python/ops/mindspore.ops.TensorScatterUpdate.rst

@@ -0,0 +1,26 @@
+mindspore.ops.TensorScatterUpdate
+==================================
+
+.. py:class:: mindspore.ops.TensorScatterUpdate
+
+    根据指定的更新值和输入索引，通过更新操作更新输入Tensor的值。此操作几乎等同于使用ScatterNd，只是更新操作应用到 `input_x` Tensor而不是0。
+
+    `indices` 的rank至少要为2，最后一个轴表示每个索引向量的深度。对于每个索引向量， `update` 中必须有相应的值。如果每个索引Tensor的深度与 `input_x` 的rank匹配，则每个索引向量对应于 `input_x` 中的Scalar，并且每次更新都会更新一个Scalar。如果每个索引Tensor的深度小于 `input_x` 的rank，则每个索引向量对应于 `input_x` 中的切片，并且每次更新都会更新一个切片。
+
+    更新的顺序是不确定的，这意味着如果 `indices` 中有多个索引向量对应于同一位置，则输出中该位置值是不确定的。
+
+    **输入：**
+
+    - **input_x** (Tensor) - TensorScatterUpdate的输入，任意维度的Tensor。其数据类型为Number。input_x的维度必须不小于indices.shape[-1]。
+    - **indices** (Tensor) - 输入Tensor的索引，数据类型为int32或int64。其rank必须至少为2。
+    - **update** (Tensor) - 指定与 `input_x` 做更新操作的Tensor，其数据类型与输入相同。update.shape应等于indices.shape[:-1] + input_x.shape[indices.shape[-1]:]。
+
+    **输出：**
+
+    Tensor，shape和数据类型与输入 `input_x` 相同。
+
+    **异常：**
+
+    - **TypeError** - `indices` 的数据类型既不是int32，也不是int64。
+    - **ValueError** - `input_x` 的shape长度小于 `indices` 的shape的最后一个维度。
+    - **ValueError** - `input_x` 的值与输入 `indices` 不匹配。

docs/api/api_python/ops/mindspore.ops.Transpose.rst

@@ -0,0 +1,23 @@
+mindspore.ops.Transpose
+=======================
+
+.. py:class:: mindspore.ops.Transpose
+
+    根据指定的排列对输入的Tensor进行数据重排。
+
+    此函数对于一维数组转置后不产生变化。对于一维数组转为二维列向量，请参照： :class:`mindspore.ops.ExpandDims` 。对于二维数组可以看做是标准的矩阵转置。对于n维数组，根据指定的轴进行排列。如果没有指定轴并且a.shape为 :math:`(i[0], i[1], ... i[n-2], i[n-1])` ，那么a.transpose().shape为 :math:`(i[n-1], i[n-2], ... i[1], i[0])` 。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor，其shape是 :math:`(x_1, x_2, ..., x_R)` 。
+    - **input_perm** (tuple[int]) - 指定排列。 `input_perm` 中的元素由 `input_x` 的每个维度的索引组成。 `input_perm` 的长度和 `input_x` 的shape相同。只支持常量值。其范围在[0，rank(input_x))内。
+
+    **输出：**
+
+    Tensor，输出Tensor的数据类型与 `input_x` 相同，输出Tensor的shape由 `input_x` 的shape和 `input_perm` 的值决定。
+
+    **异常：**
+
+    - **TypeError** - `input_perm` 不是tuple。
+    - **ValueError** - `input_x` 的shape长度不等于 `input_perm` 的shape长度。
+    - **ValueError** - `input_perm` 中存在相同的元素。

docs/api/api_python/ops/mindspore.ops.TupleToArray.rst

@@ -0,0 +1,21 @@
+mindspore.ops.TupleToArray
+===========================
+
+.. py:class:: mindspore.ops.TupleToArray
+
+    将tuple转换为Tensor。
+
+    如果tuple中第一个Number的数据类型为整数，则输出Tensor的数据类型为int。否则，输出Tensor的数据类型为float。
+
+    **输入：**
+
+    - **input_x** (tuple) - Number组成的tuple。这些Number具有相同的类型。仅支持常量值。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度。
+
+    **输出：**
+
+    Tensor。如果输入tuple包含 `N` 个Number，则输出Tensor的shape为(N,)。
+
+    **异常：**
+
+    - **TypeError** - `input_x` 不是tuple。
+    - **ValueError** - `input_x` 的长度小于或等于0。

docs/api/api_python/ops/mindspore.ops.UniformCandidateSampler.rst

@@ -0,0 +1,35 @@
+mindspore.ops.UniformCandidateSampler
+======================================
+
+.. py:class:: mindspore.ops.UniformCandidateSampler(num_true, num_sampled, unique, range_max, seed=0, remove_accidental_hits=False)
+
+    使用均匀分布对一组类进行采样。
+    
+    此函数在均匀分布的基础上从[0, range_max-1]中采样一组类（sampled_candidates）。如果unique=True，则候选采样没有重复；如果unique=False，则有重复。
+
+    **参数：**
+
+    - **num_true** (int) - 每个训练样本的目标类数。
+    - **num_sampled** (int) - 随机采样的类数。sampled_candidates的shape将为num_sampled。如果unique=True，则num_sampled必须小于或等于range_max。
+    - **unique** (bool) - 表示一个batch中的所有采样类是否唯一。
+    - **range_max** (int) - 可能的类数，该值必须是非负的。
+    - **seed** (int) - 随机种子，该值必须是非负的。如果seed的值为0，则seed的值将被随机生成的值替换。默认值：0。
+    - **remove_accidental_hits** (bool) - 表示是否移除accidental hit。默认值：False。
+
+    **输入：**
+
+    - **true_classes** (Tensor) - 输入Tensor，目标类，其shape为(batch_size, num_true)。
+
+    **输出：**
+
+    - **sampled_candidates** (Tensor) -  候选采样与目标类之间不存在联系，其shape为(num_sampled, )。
+    - **true_expected_count** (Tensor) - 在每组目标类的采样分布下的预期计数。Shape为(batch_size, num_true)。
+    - **sampled_expected_count** (Tensor) - 每个候选采样分布下的预期计数。Shape为(num_sampled, )。
+
+    **异常：**
+
+    - **TypeError** - `num_true` 和 `num_sampled` 都不是int。
+    - **TypeError** - `uique` 和 `remo_acidental_hits` 都不是bool。
+    - **TypeError** - `range_max` 和 `seed` 都不是int。
+    - **TypeError** - `true_classes` 不是Tensor。
+    

docs/api/api_python/ops/mindspore.ops.Unstack.rst

@@ -0,0 +1,28 @@
+mindspore.ops.Unstack
+=======================
+
+.. py:class:: mindspore.ops.Unstack(axis=0)
+
+    根据指定轴对输入矩阵进行分解。
+
+    在指定轴上，矩阵分解的rank为 `R` 的Tensor，输出rank为 `(R-1)` 的Tensor。
+
+    给定一个shape为 :math:`(x_1, x_2, ..., x_R)` 的Tensor。如果存在 :math:`0 \le axis` ，则输出Tensor的shape为 :math:`(x_1, x_2, ..., x_{axis}, x_{axis+2}, ..., x_R)` 。
+
+    与Stack函数操作相反。
+
+    **参数：**
+
+    - **axis** (int) - 指定矩阵分解的轴。取值范围为[-R,R)，默认值：0。
+
+    **输入：**
+
+    - **input_x** (Tensor) - 输入Tensor，其shape为 :math:`(x_1, x_2, ..., x_R)` 。rank必须大于0。
+
+    **输出：**
+
+    Tensor对象组成的tuple。每个Tensor对象的shape相同。
+
+    **异常：**
+
+    - **ValueError** - axis超出[-len(input_x.shape), len(input_x.shape))范围。

docs/api/api_python/ops/mindspore.ops.Zeros.rst

@@ -0,0 +1,22 @@
+mindspore.ops.Zeros
+====================
+
+.. py:class:: mindspore.ops.Zeros
+
+    创建一个值全为0的Tensor。
+
+    第一个参数指定Tensor的shape，第二个参数指定填充值的数据类型。
+
+    **输入：**
+
+    - **shape** (Union[tuple[int], int]) - 指定输出Tensor的shape，只能是正整数常量。
+    - **type** (mindspore.dtype) - 指定输出Tensor的数据类型，只能是常量值。
+
+    **输出：**
+
+    Tensor，数据类型和shape与输入shape相同。
+
+    **异常：**
+
+    - **TypeError** - `shape` 既不是int也不是tuple。
+    - **TypeError** - `shape` 是tuple，其元素并非全部是int。

docs/api/api_python/ops/mindspore.ops.tensor_dot.rst

@@ -0,0 +1,27 @@
+mindspore.ops.tensor_dot
+=========================
+
+.. py:function:: mindspore.ops.tensor_dot(x1, x2, axes)
+
+    在任意轴上对Tensor `a` 和 `b` 进行点乘操作。
+
+    点乘操作可以在指定轴上计算 `a` 和`b` 元素的乘积和。轴数量必须由x1和x2指定，并且该值必须在 `a` 和 `b` 的维度数量的范围内。
+
+    在两个输入中的选定维度且相互匹配。
+
+    axes = 0为外积。axes = 1为普通矩阵乘法（输入是2维的）。axes = 1与axes = ((1,),(0,)相同，其中 `a` 和 `b` 都是2维的。axes = 2与axes = ((1,2),(0,1))相同，其中 `a` 和 `b` 都是3维的。
+
+    **输入：**
+
+    - **x1** (Tensor) - tensor_dot的第一个输入Tensor，其数据类型为float16或float32。
+    - **x2** (Tensor) - tensor_dot的第二个输入Tensor，其数据类型为float16或float32。
+    - **axes** (Union[int, tuple(int), tuple(tuple(int)), list(list(int))]) - 指定 `a` 和 `b` 计算轴，可为单个值，也可为长度为2的tuple或list。如果传递了单个值 `N` ，则自动从输入 `a` 的shape中获取最后N个维度，从输入 `b` 的shape中获取前N个维度，分别作为每个维度的轴。
+
+    **输出：**
+
+    Tensor，输出Tensor的shape为 :math:`(N + M)` 。其中 :math:`N` 和 :math:`M` 在两个输入中没有计算，是自由轴。
+
+    **异常：**
+
+    - **TypeError** - `x1` 或 `x2` 不是Tensor。
+    - **TypeError** - `axes` 不是int、tuple或list。

docs/api/api_python/ops/mindspore.ops.uniform.rst

@@ -0,0 +1,28 @@
+mindspore.ops.uniform
+=======================
+
+.. py:function:: mindspore.ops.uniform(shape, minval, maxval, seed=None, dtype=mstype.float32)
+
+    生成服从均匀分布的随机数。
+
+    .. note::
+        广播后，任意位置上Tensor的最小值都必须小于最大值。
+
+    **参数：**
+
+    - **shape** (tuple) - 指定输出shape，任意维度的Tensor。 其 :math:`(N,*)` 的长度应小于8。
+    - **minval** (Tensor) - 指定生成随机值的最小值，其数据类型为int32或float32。如果数据类型为int32，则只允许输入一个数字。
+    - **maxval** (Tensor) - 指定生成随机值的最大值，其数据类型为int32或float32。如果数据类型为int32，则只允许输入一个数字。
+    - **seed** (int) - 指定随机种子，用于随机数生成器生成伪随机数。随机数为非负数。默认值：None（将被视为0）。
+    - **dtype** (mindspore.dtype) - 指定输入的数据类型。如果数据类型为int32，则从离散型均匀分布中生成Number；如果数据类型是float32，则从连续型均匀分布中生成Number。仅支持这两种数据类型。默认值：mindspore.float32。
+
+    **返回：**
+
+    Tensor，shape等于输入 `shape` 与 `minval` 和 `maxval` 广播后的shape。数据类型由输入 `dtype` 决定。
+
+    **异常：**
+
+    - **TypeError** - `shape` 不是tuple。
+    - **TypeError** - `minval` 或 `maxval` 的数据类型既不是int32，也不是float32，并且 `minval` 的数据类型与 `maxval` 的不同。
+    - **TypeError** - `seed` 不是int。
+    - **TypeError** - `dtype` 既不是int32，也不是float32。