mindspore-Ecosystem
/
mindspore
21
0
Fork 27
Code Issues Pull Requests 6 Projects Releases Wiki Activity

Add translated CN API documents

This commit is contained in:
panzhihui 2022-05-29 11:14:01 +08:00
parent 5661e0edfd
commit 2d61667b09
29 changed files with 689 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
docs/api/api_python/ops/mindspore.nn.DynamicGRUV2.rst Normal file
View File

@ -0,0 +1,78 @@
mindspore.ops.DynamicGRUV2
==========================
.. py:class:: mindspore.ops.DynamicGRUV2(direction="UNIDIRECTIONAL", cell_depth=1, keep_prob=1.0, cell_clip=-1.0, num_proj=0, time_major=True, activation='tahn', gate_order='rzh', reset_after=True, is_training=True)
为输入序列应用一个单层GRU(gated recurrent unit)。
.. math::
\begin{array}{ll}
r_{t+1} = \sigma(W_{ir} x_{t+1} + b_{ir} + W_{hr} h_{(t)} + b_{hr}) \\
z_{t+1} = \sigma(W_{iz} x_{t+1} + b_{iz} + W_{hz} h_{(t)} + b_{hz}) \\
n_{t+1} = \tanh(W_{in} x_{t+1} + b_{in} + r_{t+1} * (W_{hn} h_{(t)}+ b_{hn})) \\
h_{t+1} = (1 - z_{t+1}) * n_{t+1} + z_{t+1} * h_{(t)}
\end{array}
其中 :math:`h_{t+1}` 是在时刻t+1的隐藏状态， :math:`x_{t+1}` 是时刻t+1的输入， :math:`h_{t}` 为时刻t的隐藏状态或时刻0的初始隐藏状态。 :math:`r_{t+1}` 、 :math:`z_{t+1}` 、 :math:`n_{t+1}` 分别为重置门、更新门和当前候选集。
:math:`W` ， :math:`b` 为可学习权重和偏置。
:math:`\sigma` 是sigmoid激活函数， :math:`*` 为Hadamard乘积。
**参数：**
- **direction** (str) - 指定GRU方向，str类型。默认值："UNIDIRECTIONAL"。目前仅支持"UNIDIRECTIONAL"。
- **cell_depth** (int) - GRU单元深度。默认值：1。
- **keep_prob** (float) - keep rate。默认值：1.0。
- **cell_clip** (float) - 输出裁剪率。默认值：-1.0。
- **num_proj** (int) - 投影维度。默认值：0。
- **time_major** (bool) - 如为True，则指定输入的第一维度为序列长度 `num_step` ，如为False则第一维度为 `batch_size` 。默认值：True。
- **activation** (str) - 字符串，指定activation类型。默认值："tanh"。目前仅支持取值"tanh"。
- **gate_order** (str) - 字符串，指定weight和bias中门的排列顺序，可选则为"rzh"或"zrh"。默认值："rzh"。"rzh"代表顺序为：重置门、更新门、隐藏门。"zrh"代表顺序为：更新门，重置门，隐藏门。
- **reset_after** (bool) - 是否在矩阵乘法后使用重置门。默认值：True。
- **is_training** (bool) - 是否为训练模式。默认值：True。
**输入：**
- **x** (Tensor) - 输入词序列。shape: :math:`(\text{num_step}, \text{batch_size}, \text{input_size})` 。数据类型支持float16。
- **weight_input** (Tensor) - 权重 :math:`W_{\{ir,iz,in\}}` 。
shape： :math:`(\text{input_size}, 3 \times \text{hidden_size})` 。
数据类型支持float16。
- **weight_hidden** (Tensor) - 权重 :math:`W_{\{hr,hz,hn\}}` 。
shape： :math:`(\text{hidden_size}, 3 \times \text{hidden_size})` 。
数据类型支持float16。
- **bias_input** (Tensor) - 偏差 :math:`b_{\{ir,iz,in\}}` 。shape： :math:`(3 \times \text{hidden_size})` ，或 `None` 。与输入 `init_h` 的数据类型相同。
- **bias_hidden** (Tensor) - 偏差 :math:`b_{\{hr,hz,hn\}}` 。Tensor of shape :math:`(3 \times \text{hidden_size})` ，或 `None` 。与输入 `init_h` 的数据类型相同。
- **seq_length** (Tensor) - 每个batch中序列的长度。shape： :math:`(\text{batch_size})` 。
目前仅支持 `None` 。
- **init_h** (Tensor) - 初始隐藏状态。shape： :math:`(\text{batch_size}, \text{hidden_size})` 。
数据类型支持float16和float32。
**输出：**
- **y** (Tensor) - Tensor，shape：
- :math:`(num\_step, batch\_size, min(hidden\_size, num\_proj))` ，如果 `num_proj` 大于0,
- :math:`(num\_step, batch\_size, hidden\_size)` ，如果 `num_proj` 等于0。
数据类型为 `bias_type` 。
- **output_h** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
- **update** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
- **reset** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
- **new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
- **hidden_new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
关于 `bias_type` :
- 如果 `bias_input` 和 `bias_hidden` 均为 `None` ，则 `bias_type` 为 `init_h` 的数据类型。
- 如果 `bias_input` 不为 `None` ，则 `bias_input` 为 `bias_type` 的数据类型。
- 如果 `bias_input` 为 `None` 而 `bias_hidden` 不为 `None` ，则 `bias_type` 为 `bias_hidden` 的数据类型。
**异常：**
- **TypeError** - `direction` 、 `activation` 或 `gate_order` 不是str。
- **TypeError** - `cell_depth` 或 `num_proj` 不是int类型。
- **TypeError** - `keep_prob` 或 `cell_clip` float类型。
- **TypeError** - `time_major` 、 `reset_after` 或 `is_training` 不是bool类型。
- **TypeError** - `x` 、 `weight_input` 、 `weight_hidden` 、 `bias_input` 、 `bias_hidden` 、 `seq_length` 或 `ini_h` 不是Tensor。
- **TypeError** - `x` 、 `weight_input` 或 `weight_hidden` 的数据类型非float16。
- **TypeError** - `init_h` 数据类型非float16或float32。

3
docs/api/api_python/ops/mindspore.ops.Asinh.rst
View File

@ -5,8 +5,7 @@ mindspore.ops.Asinh
逐元素计算输入Tensor的反双曲正弦值。
.. math::
out_i = \sinh^{-1}(x_i)
更多细节请参考 :func:`mindspore.ops.asinh` 。
**输入：**

23
docs/api/api_python/ops/mindspore.ops.InsertGradientOf.rst Normal file
View File

@ -0,0 +1,23 @@
mindspore.ops.InsertGradientOf
==============================
.. py:class:: mindspore.ops.InsertGradientOf(f)
为图节点附加回调函数，将在梯度计算时被调用。
**参数：**
- **f** (Function) - MindSpore Function。回调函数。
**输入：**
- **input_x** (Any) - 需要附加回调函数的图节点。
**输出：**
Tensor，直接返回输入 `input_x` 。该算子不影响前向计算的结果。
**异常：**
**TypeError** - `f` 不是MindSpore Function。

7
docs/api/api_python/ops/mindspore.ops.KLDivLoss.rst
View File

@ -25,6 +25,13 @@ mindspore.ops.KLDivLoss
:math:`target` 代表 `labels` ；
:math:`\ell(x, target)` 为 `output` 。
.. note::
目前Ascend平台不支持设置 `reduction` 为 "mean"。
目前Ascend平台不支持数据类型float64。
目前GPU平台不支持设置 `reduction` 为 "batchmean"。
仅当 `reduction` 设置为"batchmean"时输出才符合该数学公式。
**参数：**
- **reduction** (str) - 指定输出结果的计算方式。可选值为："none"、"mean"、"batchmean"或"sum"。 默认值: "mean"。

38
docs/api/api_python/ops/mindspore.ops.ROIAlign.rst Normal file
View File

@ -0,0 +1,38 @@
mindspore.ops.ROIAlign
======================
.. py:class:: mindspore.ops.ROIAlign(pooled_height, pooled_width, spatial_scale, sample_num=2, roi_end_mode=1)
感兴趣区域对齐(RoI Align)运算。
RoI Align通过在特征图上对附近网格点进行双线性插值计算每个采样点。RoI Align不对RoI、其子区域或采样点的中任何坐标执行量化。参阅论文 `Mask R-CNN <https://arxiv.org/abs/1703.06870>`_ 。
**参数：**
- **pooled_height** (int) - 输出特征高度。
- **pooled_width** (int) - 输出特征宽度。
- **spatial_scale** (float) - 缩放系数，将原始图像坐标映射到输入特征图坐标。
设RoI的高度在原始图像中为 `ori_h` ，在输入特征图中为 `fea_h` ，则 `spatial_scale` 应为 `fea_h / ori_h` 。
- **sample_num** (int) - 采样数。默认值：2。
- **roi_end_mode** (int) - 值必须为0或1。
如果值为0，则使用该算子的历史实现。
如果值为1，则对RoI末尾的像素进行偏移，偏移量为 `+1*spatial_scale` 。
默认值：1。
**输入：**
- **features** (Tensor) - 输入特征，shape: :math:`(N, C, H, W)` 。
- **rois** (Tensor) - shape: :math:`(rois\_n, 5)` 。数据类型支持float16和float32。
`rois_n` 为RoI的数量。第二个维度的大小必须为 `5` ，分别代表 :math:`(image\_index, top\_left\_x, top\_left\_y, bottom\_right\_x, bottom\_right\_y)` 。
`image_index` 表示图像的索引； `top_left_x` 和 `top_left_y` 分别对应RoI左上角坐标的 `x` 和 `y` 值；
`bottom_right_x` 和 `bottom_right_y` 分别对应RoI右下角坐标的 `x` 和 `y` 值。
**输出：**
Tensor，shape: :math:`(rois\_n, C, pooled\_height, pooled\_width)` 。
**异常：**
- **TypeError** - `pooled_height` 、`pooled_width` 、`sample_num` 或 `roi_end_mode` 不是int类型。
- **TypeError** - `spatial_scale` 不是float类型。
- **TypeError** - `features` 或 `rois` 不是Tensor。

2
docs/api/api_python/ops/mindspore.ops.ReduceAll.rst
View File

@ -3,7 +3,7 @@
.. py:class:: mindspore.ops.ReduceAll(keep_dims=False)
默认情况下，通过对指定维度所有元素进行逻辑与运算以移除该维度。也可仅缩小该维度大小至1。通过控制 `keep_dims` 确定输出和输入的维度是否相同。
默认情况下，通过对指定维度所有元素进行逻辑与运算以移除该维度。也可仅缩小该维度大小至1。 `keep_dims` 控制输出和输入的维度是否相同。
**参数：**

33
docs/api/api_python/ops/mindspore.ops.ReduceAny.rst Normal file
View File

@ -0,0 +1,33 @@
mindspore.ops.ReduceAny
=======================
.. py:class:: mindspore.ops.ReduceAny(keep_dims=False)
默认情况下，通过对指定维度所有元素进行逻辑或运算来移除该维度。也可仅缩小该维度大小至1。 `keep_dims` 控制输出和输入的维度是否相同。
**参数：**
- **keep_dims** (bool) - 如果为True，则保留缩小的维度，大小为1。否则移除维度。默认值：False。
**输入：**
- **x** (Tensor[bool]) - bool类型的输入Tensor。
shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
- **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank(`x`), rank(`x`))范围内。
**输出：**
bool类型的Tensor。
- 如果 `axis` 为()，且 `keep_dims` 为False，
则输出一个0维Tensor，表示输入Tensor中所有元素的逻辑或运算结果。
- 如果 `axis` 为int，值为2，并且 `keep_dims` 为False，
则输出Tensor的shape为： :math:`(x_1, x_3, ..., x_R)` 。
- 如果 `axis` 为Tuple，值为(2, 3)，并且 `keep_dims` 为False，
则输出Tensor的shape为： :math:`(x_1, x_4, ..., x_R)` 。
**异常：**
- **TypeError** - `keep_dims` 不是bool类型。
- **TypeError** - `x` 不是Tensor。
- **TypeError** - `axis` 不是以下数据类型之一：int、Tuple或List。

33
docs/api/api_python/ops/mindspore.ops.ReduceMin.rst Normal file
View File

@ -0,0 +1,33 @@
mindspore.ops.ReduceMin
=======================
.. py:class:: mindspore.ops.ReduceMin(keep_dims=False)
默认情况下，使用指定维度的最小值代替该维度的其他元素，以移除该维度。也可仅缩小该维度大小至1。 `keep_dims` 控制输出和输入的维度是否相同。
**参数：**
- **keep_dims** (bool) - 如果为True，则保留缩小的维度，大小为1。否则移除维度。默认值：False。
**输入：**
- **x** (Tensor[bool]) - bool类型的输入Tensor。
shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
- **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank( `x` ), rank( `x` ))范围内。
**输出：**
bool类型的Tensor。样例：
- 如果 `axis` 为()，且 `keep_dims` 为False，
则输出一个0维Tensor，表示输入Tensor中所有元素的最小值。
- 如果 `axis` 为int，值为2，并且 `keep_dims` 为False，
则输出Tensor的shape为： :math:`(x_1, x_3, ..., x_R)` 。
- 如果 `axis` 为Tuple，值为(2, 3)，并且 `keep_dims` 为False，
则输出Tensor的shape为 :math:`(x_1, x_4, ..., x_R)` 。
**异常：**
- **TypeError** - `keep_dims` 不是bool类型。
- **TypeError** - `x` 不是Tensor。
- **TypeError** - `axis` 不是以下数据类型之一：int、Tuple或List。

33
docs/api/api_python/ops/mindspore.ops.ReduceProd.rst Normal file
View File

@ -0,0 +1,33 @@
mindspore.ops.ReduceProd
========================
.. py:class:: mindspore.ops.ReduceProd(keep_dims=False)
默认情况下，通过计算指定维度中所有元素的乘积来移除该维度。也可仅缩小该维度大小至1。 `keep_dims` 控制输出和输入的维度是否相同。
**参数：**
- **keep_dims** (bool) - 如果为True，则保留缩小的维度，大小为1。否则移除维度。默认值：False。
**输入：**
- **x** (Tensor[bool]) - bool类型的输入Tensor。
shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
- **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank( `x` ), rank( `x` ))范围内。
**输出：**
bool类型的Tensor。样例：
- 如果 `axis` 为()，且 `keep_dims` 为False，
则输出一个0维Tensor，表示输入Tensor中所有元素的乘积。
- 如果 `axis` 为int，值为2，并且 `keep_dims` 为False，
则输出Tensor的shape为： :math:`(x_1, x_3, ..., x_R)` 。
- 如果 `axis` 为Tuple，值为(2, 3)，并且 `keep_dims` 为False，
则输出Tensor的shape为 :math:`(x_1, x_4, ..., x_R)` 。
**异常：**
- **TypeError** - `keep_dims` 不是bool类型。
- **TypeError** - `x` 不是Tensor。
- **TypeError** - `axis` 不是以下数据类型之一：int、Tuple或List。

43
docs/api/api_python/ops/mindspore.ops.SmoothL1Loss.rst Normal file
View File

@ -0,0 +1,43 @@
mindspore.ops.SmoothL1Loss
==========================
.. py:class:: mindspore.ops.SmoothL1Loss(beta=1.0)
计算平滑L1损失，该L1损失函数有稳健性。
平滑L1损失是一种类似于MSELoss的损失函数，但对异常值相对不敏感。参阅论文 `Fast R-CNN <https://arxiv.org/abs/1504.08083>`_ 。
给定长度为 :math:`N` 的两个输入 `x` 和 `y` ，平滑L1损失的计算如下：
.. math::
L_{i} =
\begin{cases}
\frac{0.5 (x_i - y_i)^{2}}{\beta}, & \text{if } |x_i - y_i| < \beta \\
|x_i - y_i| - 0.5 * \beta, & \text{otherwise. }
\end{cases}
其中， :math:`\beta` 代表阈值 `beta` 。 :math:`N` 为batch size。
.. warning::
此运算符不对损失值执行"reduce"操作。
如果需要，请调用其他reduce运算符对损失执行"reduce"操作。
**参数：**
- **beta** (float) - 控制损失函数在L1Loss和L2Loss间变换的阈值。默认值：1.0。
**输入：**
- **logits** (Tensor) - shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度。数据类型支持float16或float32。
- **labels** (Tensor) - shape： :math:`(N, *)` ，与 `logits` 的shape和数据类型相同。
**输出：**
Tensor，损失值，与 `logits` 的shape和数据类型相同。
**异常：**
- **TypeError** - `beta` 不是float类型。
- **TypeError** - `logits` 或 `labels` 的数据类型非float16或float32。
- **ValueError** - `beta` 小于或等于0。
- **ValueError** - `logits` 与 `labels` 的shape不同。

25
docs/api/api_python/ops/mindspore.ops.Softplus.rst Normal file
View File

@ -0,0 +1,25 @@
mindspore.ops.Softplus
======================
.. py:class:: mindspore.ops.Softplus
Softplus激活函数。
Softplus为ReLU函数的平滑近似。可对一组数值使用来确保转换后输出结果均为正值。函数计算如下：
.. math::
\text{output} = \log(1 + \exp(\text{x}))
**输入：**
- **input_x** (Tensor) - shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度，数据类型支持float16或float32。
**输出：**
Tensor，与 `input_x` 的shape和数据类型相同。
**异常：**
- **TypeError** - `input_x` 不是Tensor。
- **TypeError** - `input_x` 的数据类型非float16或float32。

25
docs/api/api_python/ops/mindspore.ops.Softsign.rst Normal file
View File

@ -0,0 +1,25 @@
mindspore.ops.Softsign
======================
.. py:class:: mindspore.ops.Softsign
Softsign激活函数。
函数计算如下：
.. math::
\text{SoftSign}(x) = \frac{x}{ 1 + |x|}
**输入：**
- **input_x** (Tensor) - shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度，数据类型支持float16或float32。
**输出：**
Tensor，与 `input_x` 的shape和数据类型相同。
**异常：**
- **TypeError** - `input_x` 不是Tensor。
- **TypeError** - `input_x` 的数据类型非float16或float32。

5
docs/api/api_python/ops/mindspore.ops.SpaceToBatchND.rst
View File

@ -1,5 +1,5 @@
mindspore.ops.SpaceToBatchND
=============================
============================
.. py:class:: mindspore.ops.SpaceToBatchND(block_shape, paddings)
@ -14,7 +14,8 @@ mindspore.ops.SpaceToBatchND
**参数：**
- **block_shape** (list[int], tuple[int], int) - 块形状描述空间维度为分割的个数。如果 `block_shape` 为list或者tuple，其长度 `M` 为空间维度的长度。如果 `block_shape` 为整数，那么所有空间维度分割的个数均为 `block_shape` 。在Ascend后端 `M` 必须为2。
- **paddings** (tuple, list) - 空间维度的填充大小。
- **paddings** (tuple, list) - 空间维度的填充大小。包含M个List，每一个List包含2个整形值，且各值须大于0。 `paddings[i]` 为对空间维度 `i` 的填充，对应输入Tensor的维度 `i+offset` ， `offset` 为空间维度在输入Tensor维度中的偏移量。
对空间维度i， `input_shape[i+offset]+paddings[i][0]+paddings[i][1]` 必须能被 `block_shape[i]` 整除。
**输入：**

32
docs/api/api_python/ops/mindspore.ops.SpaceToDepth.rst Normal file
View File

@ -0,0 +1,32 @@
mindspore.ops.SpaceToDepth
==========================
.. py:class:: mindspore.ops.SpaceToDepth(block_size)
将空间维度分块，增加Tensor深度。
输出Tensor的高度为（输入高度 / `block_size`）；
输出Tensor的宽度为（输入宽度 / `block_size`）；
输出Tensor的深度为（输入深度 * `block_size` * `block_size`）。
输入Tensor的高度和宽度必须可被 `block_size` 整除，格式为"NCHW"（batch_size，深度，高度，宽度）。
**参数：**
- **block_size** (int)：用于划分空间维度的子块的大小。必须>=2。
**输入：**
- **x** (Tensor) - 4维Tensor。数据类型为Number。
**输出：**
4维Tensor，数据类型与 `x` 相同。
**异常：**
- **TypeError** - `block_size` 不是int类型。
- **ValueError** - `block_size` 小于2。
- **ValueError** - `x` 的维度不为4。

21
docs/api/api_python/ops/mindspore.ops.SparseGatherV2.rst Normal file
View File

@ -0,0 +1,21 @@
mindspore.ops.SparseGatherV2
============================
.. py:class:: mindspore.ops.SparseGatherV2
基于指定的索引和axis返回输入Tensor的切片。
**输入：**
- **input_params** (Tensor) - 被切片的Tensor。shape： :math:`(x_1, x_2, ..., x_R)` 。
- **input_indices** (Tensor)- shape： :math:`(y_1, y_2, ..., y_S)` 。
指定切片的索引，取值须在 `[0, input_params.shape[axis])` 范围内。
- **axis** (int)- 进行索引的axis。
**输出：**
Tensor，shape： :math:`(z_1, z_2, ..., z_N)` 。
**异常：**
- **TypeError** - `axis` 不是int类型。

30
docs/api/api_python/ops/mindspore.ops.StandardNormal.rst Normal file
View File

@ -0,0 +1,30 @@
mindspore.ops.StandardNormal
============================
.. py:class:: mindspore.ops.StandardNormal(seed=0, seed2=0)
根据标准正态（高斯）随机数分布生成随机数。
返回具有给定shape的Tensor，其中的随机数从平均值为0、标准差为1的标准正态分布中取样。
.. math::
f(x)=\frac{1}{\sqrt{2 \pi}} e^{\left(-\frac{x^{2}}{2}\right)}
**参数：**
- **seed** (int) - 随机种子，非负值。默认值：0。
- **seed2** (int) - 随机种子2，用来防止随机种子冲突，非负值。默认值：0。
**输入：**
- **shape** (tuple) - 目标随机数Tensor的shape。只允许常量值。
**输出：**
Tensor。shape为输入 `shape` 。数据类型支持float32。
**异常：**
- **TypeError** - `seed` 或 `seed2` 不是int类型。
- **TypeError** - `shape` 不是Tuple。
- **ValueError** - `shape` 不是常量值。

27
docs/api/api_python/ops/mindspore.ops.TruncateDiv.rst Normal file
View File

@ -0,0 +1,27 @@
mindspore.ops.TruncateDiv
=========================
.. py:class:: mindspore.ops.TruncateDiv
对于整数类型，将第一个输入Tensor与第二个输入Tensor逐元素相除。结果将向0取整。
输入 `x` 和 `y` 应能遵循隐式类型转换规则使数据类型一致。
输入必须为两个Tensor或一个Tensor和一个标量。
当输入为两个Tensor时，数据类型不能同时为bool类型。
当输入是一个Tensor和一个标量时，标量只能是一个常数。
.. note::
支持shape广播。
**输入：**
- **x** (Union[Tensor, Number, bool]) - Number或bool类型，或这两个类型的Tensor。
- **y** (Union[Tensor, Number, bool]) - Number或bool类型，或这两个类型的Tensor。
**输出：**
Tensor，shape为输入广播后的shape，数据类型为两个输入中精度较高的输入的类型。
**异常：**
- **TypeError** - `x` 和 `y` 数据类型不是以下之一：Tensor、Number或bool。

32
docs/api/api_python/ops/mindspore.ops.TruncateMod.rst Normal file
View File

@ -0,0 +1,32 @@
mindspore.ops.TruncateMod
=========================
.. py:class:: mindspore.ops.TruncateMod
逐元素取模。
输入 `x` 和 `y` 应能遵循隐式类型转换规则使数据类型一致。
输入必须为两个Tensor或一个Tensor和一个标量。
当输入为两个Tensor时，数据类型不能同时为bool类型。支持shape广播。
当输入是一个Tensor和一个标量时，标量只能是一个常数。
.. warning::
- 输入数值不能为0。
- 当输入含有超过2048个元素，该操作不能保证千分之二的精度要求。
- 由于架构不同，该算子在NPU和CPU上的计算结果可能不一致。
- 若shape为（D1、D2...、Dn），则D1*D2...*DN<=1000000，n<=8。
**输入：**
- **x** (Union[Tensor, Number, bool]) - Number或bool类型，或这两个类型的Tensor。
- **y** (Union[Tensor, Number, bool]) - Number或bool类型，或这两个类型的Tensor。
**输出：**
Tensor，shape为输入进行广播后的shape，数据类型为两个输入中精度较高的输入的类型。
**异常：**
- **TypeError** - `x` 和 `y` 数据类型不是以下之一：Tensor、Number、bool。
- **TypeError** - `x` 和 `y` 均不是Tensor。
- **ValueError** - `x` 和 `y` 的shape无法进行广播转换。

38
docs/api/api_python/ops/mindspore.ops.UniformInt.rst Normal file
View File

@ -0,0 +1,38 @@
mindspore.ops.UniformInt
========================
.. py:class:: mindspore.ops.UniformInt(seed=0, seed2=0)
根据均匀分布在区间 `[minval, maxval)` 中生成随机数。即根据离散概率函数分布：
.. math::
\text{P}(i|a,b) = \frac{1}{b-a+1},
其中 :math:`a` 为 `minval` ， :math:`b` 为 `maxval` 。
.. note::
`minval` 中的数值在广播后必须严格小于 `maxval` 。
**参数：**
- **seed** (int) - 随机种子，非负值。默认值：0。
- **seed2** (int) - 随机种子2，用来防止随机种子冲突，非负值。默认值：0。
**输入：**
- **shape** (tuple) - 目标Tensor的shape。只允许常量值。
- **minval** (Tensor) - 分布参数， :math:`a` 。
决定可能生成的最小值，数据类型为int32。需为标量。
- **maxval** (Tensor) - 分布参数， :math:`b` 。
决定生成随机数的上限，数据类型为int32。需为标量。
**异常：**
- **TypeError** - `seed` 或 `seed2` 不是int类型。
- **TypeError** - `shape` 不是Tuple。
- **TypeError** - `minval` 或 `maxval` 不是Tensor。
- **ValueError** - `shape` 不是常量值。
**输出：**
Tensor。shape为输入 `shape` ，数据类型支持int32。

35
docs/api/api_python/ops/mindspore.ops.UnsortedSegmentMax.rst Normal file
View File

@ -0,0 +1,35 @@
mindspore.ops.UnsortedSegmentMax
================================
.. py:class:: mindspore.ops.UnsortedSegmentMax
沿分段计算输入Tensor的最大值。
UnsortedSegmentMax的计算过程如下图所示：
.. image:: UnsortedSegmentMax.png
.. math::
\text { output }_i=\text{max}_{j \ldots} \text { data }[j \ldots]
:math:`max` 返回元素 :math:`j...` 中的最大值，其中 :math:`segment\_ids[j...] == i` 。
.. note::
如果 `segment_ids` 中不存在segment_id `i` ，则将使用 `input_x` 的数据类型的最小值填充输出 `output[i]` 。
**输入：**
- **input_x** (Tensor) - shape： :math:`(x_1, x_2, ..., x_R)` 。
数据类型支持float16、float32或int32。
- **segment_ids** (Tensor) - shape为 :math:`(x_1)` 的1维张量，值必须是非负数。
数据类型支持int32。
- **num_segments** (int) - 分段的数量。
**输出：**
Tensor，若 `num_segments` 值为 `N` ，则shape为 :math:`(N, x_2, ..., x_R)` 。
**异常：**
- **TypeError** - `num_segments` 不是int类型。
- **ValueError** - `segment_ids` 的维度不等于1。

35
docs/api/api_python/ops/mindspore.ops.UnsortedSegmentMin.rst Normal file
View File

@ -0,0 +1,35 @@
mindspore.ops.UnsortedSegmentMin
================================
.. py:class:: mindspore.ops.UnsortedSegmentMin
沿分段计算输入Tensor的最小值。
UnsortedSegmentMin的计算过程如下图所示：
.. image:: UnsortedSegmentMin.png
.. math::
\text { output }_i=\text{min}_{j \ldots} \text { data }[j \ldots]
:math:`min` 返回元素 :math:`j...` 中的最小值，其中 :math:`segment\_ids[j...] == i` 。
.. note::
如果 `segment_ids` 中不存在segment_id `i` ，则将使用 `input_x` 的数据类型的最大值填充输出 `output[i]` 。
**输入：**
- **input_x** (Tensor) - shape： :math:`(x_1, x_2, ..., x_R)` 。
数据类型支持float16、float32或int32。
- **segment_ids** (Tensor) - shape为 :math:`(x_1)` 的1维张量，值必须是非负数。
数据类型支持int32。
- **num_segments** (int) - 分段的数量。
**输出：**
Tensor，若 `num_segments` 值为 `N` ，则shape为 :math:`(N, x_2, ..., x_R)` 。
**异常：**
- **TypeError** - `num_segments` 不是int类型。
- **ValueError** - `segment_ids` 的维度不等于1。

27
docs/api/api_python/ops/mindspore.ops.UnsortedSegmentProd.rst Normal file
View File

@ -0,0 +1,27 @@
mindspore.ops.UnsortedSegmentProd
=================================
.. py:class:: mindspore.ops.UnsortedSegmentProd
沿分段计算输入Tensor元素的乘积。
UnsortedSegmentProd的计算过程如下图所示：
.. image:: UnsortedSegmentProd.png
**输入：**
- **input_x** (Tensor) - shape： :math:`(x_1, x_2, ..., x_R)` 。
数据类型支持float16、float32或int32。
- **segment_ids** (Tensor) - shape为 :math:`(x_1)` 的1维张量，值必须是非负数。
数据类型支持int32。
- **num_segments** (int) - 分段的数量。必须大于0。
**输出：**
Tensor，若 `num_segments` 值为 `N` ，则shape为 :math:`(N, x_2, ..., x_R)` 。
**异常：**
- **TypeError** - `num_segments` 不是int类型。
- **ValueError** - `segment_ids` 的维度不等于1。

33
docs/api/api_python/ops/mindspore.ops.UnsortedSegmentSum.rst Normal file
View File

@ -0,0 +1,33 @@
mindspore.ops.UnsortedSegmentSum
================================
.. py:class:: mindspore.ops.UnsortedSegmentSum
沿分段计算输入Tensor元素的和。
计算输出Tensor :math:`\text{output}[i] = \sum_{segment\_ids[j] == i} \text{data}[j, \ldots]` ，其中 :math:`j,...` 是代表元素索引的Tuple。 `segment_ids` 确定输入Tensor元素的分段。 `segment_ids` 不需要排序，也不需要覆盖 `num_segments` 范围内的所有值。
UnsortedSegmentSum的计算过程如下图所示：
.. image:: UnsortedSegmentSum.png
.. note::
- 如果 `segment_ids` 中不存在segment_id `i` ，则对输出 `output[i]` 填充0。
- 在Ascend平台上，如果segment_id的值小于0或大于输入Tensor的shape的长度，将触发执行错误。
如果 `segment_ids` 元素为负数，将忽略该值。 `num_segments` 必须等于不同segment_id的数量。
**输入：**
- **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** (int) - 分段数量 :math:`z` 。
**输出：**
Tensor，shape： :math:`(z, x_{N+1}, ..., x_R)` 。
**异常：**
- **TypeError** - `num_segments` 不是int类型。
- **ValueError** - `segment_ids` 的维度小于1。

24
docs/api/api_python/ops/mindspore.ops.unique.rst Normal file
View File

@ -0,0 +1,24 @@
mindspore.ops.unique
====================
.. py:class:: mindspore.ops.unique(x)
对输入Tensor中元素去重，并返回一个索引Tensor，包含输入Tensor中的元素在输出Tensor中的索引。
`y` 与 `idx` 的shape通常会有差别，因为 `y` 会将元素去重，而 `idx` 的shape与 `x` 一致。
若需要 `idx` 与 `y` 的shape相同，请参考 :class:`mindspore.ops.UniqueWithPad` 算子。
.. warning::
此算子为实验性算子，将来可能面临更改或删除。
**参数：**
- **x** (Tensor) - 需要被去重的Tensor。shape： :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度。
**返回：**
Tuple， `(y, idx)` 。 `y` 是与 `x` 数据类型相同的Tensor，包含 `x` 中去重后的元素。 `idx` 为索引Tensor，包含 `x` 中的元素在 `y` 中的索引，与 `x` 的shape相同。
**异常：**
- **TypeError** - `x` 不是Tensor。

2
mindspore/python/mindspore/ops/operations/array_ops.py
View File

@ -925,7 +925,7 @@ class SparseGatherV2(PrimitiveWithCheck):
- **input_params** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
- **input_indices** (Tensor) - The shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
Specifies the indices of elements of the original Tensor, must be in the range
`[0, input_param.shape[axis])`.
`[0, input_params.shape[axis])`.
- **axis** (int) - Specifies the dimension index to gather indices.
Outputs:

2
mindspore/python/mindspore/ops/operations/debug_ops.py
View File

@ -263,7 +263,7 @@ class InsertGradientOf(PrimitiveWithInfer):
Tensor, returns `input_x` directly. `InsertGradientOf` does not affect the forward result.
Raises:
TypeError: If `f` is not a function of mindspore.
TypeError: If `f` is not a function of MindSpore.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``

4
mindspore/python/mindspore/ops/operations/math_ops.py
View File

@ -907,7 +907,7 @@ class ReduceMin(_Reduce):
- **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
:math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
- **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
Only constant value is allowed. Must be in the range [-rank( `x`), rank( `x` )).
Outputs:
Tensor, has the same dtype as the `x`.
@ -1029,7 +1029,7 @@ class ReduceProd(_Reduce):
- **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
:math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
- **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
Only constant value is allowed. Must be in the range [-rank( `x` ), rank( `x` )).
Outputs:
Tensor, has the same dtype as the `x`.

10
mindspore/python/mindspore/ops/operations/nn_ops.py
View File

@ -7383,15 +7383,17 @@ class DynamicGRUV2(PrimitiveWithInfer):
- **x** (Tensor) - Current words.
Tensor of shape :math:`(\text{num_step}, \text{batch_size}, \text{input_size})`.
The data type must be float16.
- **weight_input** (Tensor) - Input-hidden weight.
- **weight_input** (Tensor) - Input-hidden weight :math:`W_{\{ir,iz,in\}}`.
Tensor of shape :math:`(\text{input_size}, 3 \times \text{hidden_size})`.
The data type must be float16.
- **weight_hidden** (Tensor) - Hidden-hidden weight.
- **weight_hidden** (Tensor) - Hidden-hidden weight :math:`W_{\{hr,hz,hn\}}`.
Tensor of shape :math:`(\text{hidden_size}, 3 \times \text{hidden_size})`.
The data type must be float16.
- **bias_input** (Tensor) - Input-hidden bias. Tensor of shape :math:`(3 \times \text{hidden_size})`, or None.
- **bias_input** (Tensor) - Input-hidden bias :math:`b_{\{ir,iz,in\}}`.
Tensor of shape :math:`(3 \times \text{hidden_size})`, or None.
Has the same data type with input `init_h`.
- **bias_hidden** (Tensor) - Hidden-hidden bias. Tensor of shape :math:`(3 \times \text{hidden_size})`,
- **bias_hidden** (Tensor) - Hidden-hidden bias :math:`b_{\{hr,hz,hn\}}`.
Tensor of shape :math:`(3 \times \text{hidden_size})`,
or None. Has the same data type with input `init_h`.
- **seq_length** (Tensor) - The length of each batch. Tensor of shape :math:`(\text{batch_size})`.
Only `None` is currently supported.

4
mindspore/python/mindspore/ops/operations/random_ops.py
View File

@ -141,7 +141,7 @@ class StandardNormal(PrimitiveWithInfer):
Args:
seed (int): Random seed, must be non-negative. Default: 0.
seed2 (int): Random seed2, must be non-negative. Default: 0.
seed2 (int): Random seed2, must be non-negative. A second seed to avoid seed collision. Default: 0.
Inputs:
- **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
@ -464,7 +464,7 @@ class UniformInt(PrimitiveWithInfer):
Args:
seed (int): Random seed, must be non-negative. Default: 0.
seed2 (int): Random seed2, must be non-negative. Default: 0.
seed2 (int): Random seed2, must be non-negative. A second seed to avoid seed collision. Default: 0.
Inputs:
- **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.