forked from mindspore-Ecosystem/mindspore
optimizes the documentation of chinese API of AVGPool,IOU,LayerNorm,etc.
This commit is contained in:
zhangfanghe
parent
5b360e39fb
commit
3168721749
|
|
@ -0,0 +1,44 @@
|
|||
mindspore.ops.AvgPool
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.ops.AvgPool(kernel_size=1, strides=1, pad_mode="valid", data_format="NCHW")
|
||||
|
||||
对输入的多维数据进行二维平均池化运算。
|
||||
|
||||
一般地，输入的形状为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，AvgPool输出 :math:`(H_{in}, W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`(kH, kW)` 和 `stride` ，运算如下：
|
||||
|
||||
.. math::
|
||||
\text{output}(N_i, C_j, h, w) = \frac{1}{kH * kW} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1}
|
||||
\text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)
|
||||
|
||||
.. warning::
|
||||
- 支持全局池化。
|
||||
- 在Ascend上，"kernel_size"的高度和权重取值为[1, 255]范围内的正整数。 :math: ksize_H * ksize_W < 256。
|
||||
- 由于指令限制，"strides_h"和"strides_w"的取值为[1, 63]范围内的正整数。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **kernel_size** (Union[int, tuple[int]]) - 指定池化核尺寸大小，表示内核高度和宽度的整数值，或者是两个分别表示高度和宽度的整数tuple。默认值：1。
|
||||
- **strides** (Union[int, tuple[int]]) - 池化操作的移动步长，表示移动高度和宽度的整数都是步长，或者两个分别表示移动高度和宽度的整数tuple。默认值：1。
|
||||
- **pad_mode** (str) - 指定池化填充模式，取值为"same"或"valid"，不区分大小写。默认值："valid"。
|
||||
|
||||
- **same** - 输出的高度和宽度分别与输入整除 `stride` 后的值相同。
|
||||
- **valid** - 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。
|
||||
|
||||
- **data_format** (str) - 指定输入和输出的数据格式。取值为'NHWC'或'NCHW'。默认值：'NCHW'。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor) - 输入shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，shape为 :math:`(N,C_{out},H_{out},W_{out})` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `kernel_size` 或 `strides` 既不是int也不是tuple。
|
||||
- **ValueError** - `pad_mode` 既不是'valid'，也不是'same'，不区分大小写。
|
||||
- **ValueError** - `data_format` 既不是'NCHW'也不是'NHWC'。
|
||||
- **ValueError** - `kernel_size` 或 `strides` 小于1。
|
||||
- **ValueError** - `x` 的shape长度不等于4。
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
mindspore.ops.BCEWithLogitsLoss
|
||||
===============================
|
||||
|
||||
.. py:class:: mindspore.ops.BCEWithLogitsLoss(reduction='mean')
|
||||
|
||||
使用sigmoid激活函数计算出预测值，BCEWithLogitsLoss计算预测值和目标值之间的二值交叉熵损失。
|
||||
|
||||
将输入 `logits` 设置为 :math:`X` ，输入 `labels` 设置为 :math:`Y` ，输入 `weight` 设置为 :math:`W` ，输出设置为 :math:`L` 。则，
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
L_{ij} = -W_{ij}[Y_{ij}log(X_{ij}) + (1 - Y_{ij})log(1 - X_{ij})]
|
||||
\end{array}
|
||||
|
||||
:math:`i` 表示 :math:`i^{th}` 样例， :math:`j` 表示类别。则，
|
||||
|
||||
.. math::
|
||||
\ell(x, y) = \begin{cases}
|
||||
L, & \text{if reduction} = \text{'none';}\\
|
||||
\operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
|
||||
\operatorname{sum}(L), & \text{if reduction} = \text{'sum'.}
|
||||
\end{cases}
|
||||
|
||||
:math:`\ell` 表示计算损失的方法。有三种方法：第一种方法是直接提供损失值，第二种方法是计算所有损失的平均值，第三种方法是计算所有损失的总和。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **reduction** (str) - 指定用于输出结果的计算方式。取值为'mean'、'sum'或'none'，不区分大小写。如果'none'，则不执行reduction。默认值：'mean'。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **logits** (Tensor)：输入预测值，任意维度的Tensor。其数据类型为float16或float32。
|
||||
- **label** (Tensor)： 输入目标值，shape与 `logits` 相同。数据类型为float16或float32。
|
||||
- **weight** (Tensor)：指定每个批次二值交叉熵的权重。可以广播到shape同 `logits` 的Tensor。数据类型必须为float16或float32。
|
||||
- **pos_weight** (Tensor)：指定正类的权重。为向量，其长度等于分类数。可以进行广播，其shape与 `logits` 的shape保持一致。数据类型必须为float16或float32。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor或Scalar，如果 `reduction` 为'none'，则为shape和数据类型与输入'logits'相的Tensor。否则，输出为Scalar。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - 任何输入的数据类型既不是float16也不是float32。
|
||||
- **ValueError** - `weight` 或 `pos_weight` 不能广播到shape为 `logits` 的Tensor。
|
||||
- **ValueError** - `reduction` 不为'none'、'mean'或'sum'。
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
mindspore.ops.BatchMatMul
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.ops.BatchMatMul(transpose_a=False, transpose_b=False)
|
||||
|
||||
两个批量Tensor之间的矩阵乘法。
|
||||
|
||||
.. math::
|
||||
\\text{output}[..., :, :]= \\text{matrix}(x[..., :, :])* \\text{matrix}(y[..., :, :])
|
||||
|
||||
两个输入Tensor必须具有相同的秩，并且秩必须不小于 `3`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **transpose_a** (bool) - 如果为True，则在乘法之前转置 `x` 的最后两个维度。默认值：False。
|
||||
- **transpose_b** (bool) - 如果为True，则在乘法之前转置 `y` 的最后两个维度。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor)：输入相乘的第一个Tensor。其shape为 :math:`(*B, N, C)` ，其中 :math:`*B` 表示批处理大小，可以是多维度， :math:`N` 和 :math:`C` 是最后两个维度的大小。如果 `transpose_a` 为True，则其shape必须为 :math:`(*B,C,N)` 。
|
||||
- **y** (Tensor)：输入相乘的第二个Tensor。Tensor的shape为 :math:`(*B, C, M)` 。如果 `transpose_b` 为True，则其shape必须为 :math:`(*B, M, C)` 。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，输出Tensor的shape为 :math:`(*B, N, M)` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `transpose_a` 或 `transpose_b` 不是bool。
|
||||
- **ValueError** - `x` 的shape长度不等于 `y` 的shape长度或 `x` 的shape长度小于3。
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
mindspore.ops.BatchNorm
|
||||
========================
|
||||
|
||||
.. py:class:: mindspore.ops.BatchNorm(is_training=False, epsilon=1e-5, momentum=0.1, data_format="NCHW")
|
||||
|
||||
对输入数据进行归一化(Batch Normalization Layer)和更新参数。
|
||||
|
||||
批量归一化广泛应用于卷积神经网络中。此运算对输入应用归一化，避免内部协变量偏移，详见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。使用mini-batch数据和学习参数进行训练，学习的参数见如下公式中，
|
||||
|
||||
.. math::
|
||||
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
|
||||
|
||||
其中， :math:`\gamma` 为 `scale`， :math:`\beta` 为 `bias`， :math:`\epsilon` 为 `epsilon`， :math:`mean` 为x的均值， :math:`variance` 为x的方差。
|
||||
|
||||
.. warning::
|
||||
- 如果该运算用于推理，并且输出"reserve_space_1"和"reserve_space_2"可用，则"reserve_space_1"的值与"mean"相同，"reserve_space_2"的值与"variance"相同。
|
||||
- 对于Ascend 310，由于平方根指令，结果精度未能达到1‰。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **is_training** (bool) - 如果 `is_training` 为True，则在训练期间计算 `mean` 和 `variance`。如果 `is_training` 为False，则在推理期间从checkpoint加载。默认值：False。
|
||||
- **epsilon** (float) - 添加的小值，以确保数值稳定性。默认值：1e-5。
|
||||
- **momentum** (float) - 动态均值和动态方差所使用的动量。（例如 :math:`new\_running\_mean = (1 - momentum) * running\_mean + momentum * current\_mean`)。动量值必须为[0, 1]。默认值：0.1。
|
||||
- **data_format** (str) - 输入数据格式，可选值有：'NHWC'或'NCHW'。默认值："NCHW"。
|
||||
|
||||
**输入：**
|
||||
|
||||
如果 `is_training` 为False，则输入为多个Tensor。
|
||||
|
||||
- **input_x** (Tensor) - 数据输入，shape为 :math:`(N, C)` 的Tensor，数据类型为float16或float32。
|
||||
- **scale** (Tensor) - 输入Scalar，shape为 :math:`(C,)` 的Tensor，数据类型为float16或float32。
|
||||
- **bias** (Tensor) - 输入偏置项，shape为 :math:`(C,)` 的Tensor，具有与 `scale` 相同的数据类型。
|
||||
- **mean** (Tensor) - 输入均值，shape为 :math:`(C,)` 的Tensor，具有与 `scale` 相同的数据类型。
|
||||
- **variance** (Tensor) - 输入方差，shape为 :math:`(C,)` 的Tensor，具有与 `scale` 相同的数据类型。
|
||||
|
||||
如果 `is_training` 为True，则 `bias`、`mean` 和 `variance` 是参数。
|
||||
|
||||
- **input_x** (Tensor) - 数据输入，shape为 :math:`(N, C)` 的Tensor，数据类型为float16或float32。
|
||||
- **scale** (Parameter) - 输入Scalar，shape为 :math:`(C,)` 的参数，数据类型为float16或float32。
|
||||
- **bias** (Parameter) - 输入偏置项，shape为 :math:`(C,)` 的参数，具有与 `scale` 相同的数据类型。
|
||||
- **mean** (Parameter) - 输入均值，shape为 :math:`(C,)` 的参数，具有与 `scale` 相同的数据类型。
|
||||
- **variance** (Parameter) - 输入方差，shape为 :math:`(C,)` 的参数，具有与 `scale` 相同的数据类型。
|
||||
|
||||
**输出：**
|
||||
|
||||
5个Tensor组成的tuple、归一化输入和更新的参数。
|
||||
|
||||
- **output_x** (Tensor) - 数据类型和shape与输入 `input_x` 相同。shape为 :math:`(N, C)` 。
|
||||
- **batch_mean** (Tensor) - 输入的均值，shape为 :math:`(C,)` 的一维Tensor。
|
||||
- **batch_variance** (Tensor) - 输入的方差，shape为 :math:`(C,)` 的一维Tensor。
|
||||
- **reserve_space_1** (Tensor) - 需要计算梯度时，被重新使用的均值，shape为 :math:`(C,)` 的一维Tensor。
|
||||
- **reserve_space_2** (Tensor) - 需要计算梯度时，被重新使用的方差，shape为 :math:`(C,)` 的一维Tensor。
|
||||
，
|
||||
**异常：**
|
||||
|
||||
- **TypeError：** `is_training` 不是bool。
|
||||
- **TypeError：** `epsilon` 或 `momentum` 的数据类型不是float。
|
||||
- **TypeError：** `data_format` 不是str。
|
||||
- **TypeError：** `input_x`、`scale`、`bias`、`mean` 或 `variance` 不是Tensor。
|
||||
- **TypeError：** `input_x` 和 `scale` 的数据类型既不是float16，也不是float32。
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
mindspore.ops.Dropout2D
|
||||
=======================
|
||||
|
||||
.. py:class:: mindspore.ops.Dropout2D(keep_prob=0.5)
|
||||
|
||||
在训练期间，根据概率 :math:`1 - keep\_prob` ，随机的将一些通道设置为0，且服从伯努利分布。（对于shape为 :math:`(N, C, H, W)` 的四维Tensor，通道特征图指的是shape为 :math:`(H, W)`的二维特征图。）
|
||||
|
||||
例如，对于批量输入的第 :math:`i_th` 样本的第:math:`j_th` 通道为二维Tensor，即input[i,j]。在前向传播过程中，输入样本的每个通道都有可能被置为0，置为0的概率为 :math:`1 - keep\_prob`，且服从伯努利分布。
|
||||
|
||||
论文 `Dropout: A Simple Way to Prevent Neural Networks from Overfitting <http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf>`_ 中提出了该技术，并证明其能有效地减少过度拟合，防止神经元共适应。更多详细信息，请参见 `Improving neural networks by preventing co-adaptation of feature detectors <https://arxiv.org/pdf/1207.0580.pdf>`_ 。
|
||||
|
||||
Dropout2D 可以提高通道特征图之间的独立性。
|
||||
|
||||
**参数：**
|
||||
|
||||
keep_prob (float) - 输入通道保留率，数值范围在0到1之间，例如 `keep_prob` = 0.8，意味着过滤20%的通道。默认值：0.5。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor) - shape为 :math:`(N, C, H, W)` 的四维张量，其中N是批量大小，C是通道数，H是特征高度，W是特征宽度。数据类型应为int8、int16、int32、int64、float16或float32。
|
||||
|
||||
**输出：**
|
||||
|
||||
- **output** (Tensor) - shape和数据类型与 `x` 相同。
|
||||
- **mask** (Tensor) - shape与 `x` 相同，数据类型为bool。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `keep_prob` 的数据类型不是float。
|
||||
- **ValueError** - `keep_prob` 超出[0.0, 1.0]范围，或者输入的维度不是四维。
|
||||
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
mindspore.ops.GradOperation
|
||||
============================
|
||||
|
||||
.. py:class:: mindspore.ops.GradOperation(get_all=False, get_by_list=False, sens_param=False)
|
||||
|
||||
一个高阶函数，为输入函数生成梯度函数。
|
||||
|
||||
由 `GradOperation` 高阶函数生成的梯度函数可以通过构造参数自定义。
|
||||
|
||||
构建一个以x和y为输入的函数 `net = Net()` ，并带有一个参数z，详见样例中的 `Net` 。
|
||||
|
||||
生成一个梯度函数，该函数返回关于第一个输入的梯度（见样例中的 `GradNetWrtX` ）。
|
||||
|
||||
1. 构建一个带有默认参数的 `GradOperation` 高阶函数： `grad_op = GradOperation()` 。
|
||||
|
||||
2. 将 `net` 作为参数调用 `grad_op` ，得到梯度函数： `gradient_function = grad_op(net)` 。
|
||||
|
||||
3. 用 `net` 的输入作为参数调用梯度函数，得到关于第一个输入的梯度：`grad_op(net)(x, y)` 。
|
||||
|
||||
生成一个梯度函数，该函数返回关于所有输入的梯度（见样例中的 `GradNetWrtXY` ）。
|
||||
|
||||
1. 构造一个带有 `get_all=True` 参数的 `GradOperation` 高阶函数，表示获得在样例中 `Net()` 中的x和y所有输入的梯度：`grad_op = GradOperation(get_all=True)` 。
|
||||
|
||||
2. 将 `net` 作为参数调用 `grad_op` ，得到梯度函数： `gradient_function = grad_op(net)` 。
|
||||
|
||||
3. 用 `net` 的输入作为参数调用梯度函数，得到所有输入的梯度：`gradient_function(x, y)` 。
|
||||
|
||||
生成一个梯度函数，该函数返回关于给定参数的梯度（见样例中的 `GradNetWithWrtParams` ）。
|
||||
|
||||
1. 构造一个带有 `get_by_list=True` 参数的GradOperation高阶函数： grad_op = GradOperation(get_by_list=True)。
|
||||
|
||||
2. 当构建 `GradOperation` 高阶函数时，创建一个 `ParameterTuple` 和 `net` 作为参数输入， `ParameterTuple` 作为参数过滤器决定返回哪个梯度：`params = ParameterTuple(net.trainingable_params())` 。
|
||||
|
||||
3. 将 `net` 和 `params` 作为参数输入 `grad_op` ，得到梯度函数： `gradient_function = grad_op(net, params)` 。
|
||||
|
||||
4. 用 `net` 的输入作为参数调用梯度函数，得到关于给定参数的梯度： `gradient_function(x, y)` 。
|
||||
|
||||
生成一个梯度函数，该函数以((dx, dy), (dz))的格式返回关于所有输入和给定参数的梯度（见样例中的 `GradNetWrtInputsAndParams` ）。
|
||||
|
||||
1. 构建一个带有 `get_all=True` 和 `get_by_list=True` 参数的 `GradOperation` 高阶函数：`grad_op = GradOperation(get_all=True, get_by_list=True)` 。
|
||||
|
||||
2. 当构建 `GradOperation` 高阶函数时，创建一个 `ParameterTuple` 和 `net` 作为参数输入：`params = ParameterTuple(net.trainingable_params())` 。
|
||||
|
||||
3. 将 `net` 和 `params` 作为参数输入 `grad_op` ，得到梯度函数： `gradient_function = grad_op(net, params)` 。
|
||||
|
||||
4. 用 `net` 的输入作为参数调用梯度函数，得到关于所有输入和给定参数的梯度：`gradient_function(x, y)` 。
|
||||
|
||||
我们可以设置 `sens_param` 等于True来配置灵敏度（关于输出的梯度），向梯度函数传递一个额外的灵敏度输入值。这个输入值必须与 `net` 的输出具有相同的形状和类型（见样例中的 `GradNetWrtXYWithSensParam` ）。
|
||||
|
||||
1. 构建一个带有 `get_all=True` 和 `sens_param=True` 参数的 `GradOperation` 高阶函数：`grad_op = GradOperation(get_all=True, sens_param=True)` 。
|
||||
|
||||
2. 当 `sens_param=True` ，定义 `grad_wrt_output` （关于输出的梯度）：`grad_wrt_output = Tensor(np.ones([2, 2]).astype(np.float32))` 。
|
||||
|
||||
3. 用 `net` 作为参数输入 `grad_op` ，得到梯度函数：`gradient_function = grad_op(net)` 。
|
||||
|
||||
4. 用 `net` 的输入和 `sens_param` 作为参数调用梯度函数，得到关于所有输入的梯度：`gradient_function(x, y, grad_wrt_output)` 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **get_all** (bool) - 计算梯度，如果等于False，获得第一个输入的梯度，如果等于True，获得所有输入的梯度。默认值：False。
|
||||
- **get_by_list** (bool) - 如果等于True，获得所有参数变量的梯度。如果 `get_all` 和 `get_by_list` 都等于False，则得到第一个输入的梯度。如果 `get_all` 和 `get_by_list` 都等于True，则同时得到关于输入和参数变量的梯度，输出形式为((关于输入的梯度)，(关于参数变量的梯度))。默认值：False。
|
||||
- **sens_param** (bool) - 是否在输入中配置灵敏度（关于输出的梯度）。如果sens_param等于False，自动添加一个 `ones_like(output)` 灵敏度。如果sensor_param等于True，灵敏度（关于输出的梯度），必须通过location参数或key-value pair参数来传递，如果是通过key-value pair参数传递value，那么key必须为sens。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
将一个函数作为参数，并返回梯度函数的高阶函数。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - 如果 `get_all` 、`get_by_list` 或者 `sens_params` 不是bool。
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
mindspore.ops.HyperMap
|
||||
=======================
|
||||
|
||||
.. py:class:: mindspore.ops.HyperMap(ops=None, reverse=False)
|
||||
|
||||
`HyperMap` 可以对输入序列做集合运算。
|
||||
|
||||
对序列的每个元素或嵌套序列进行运算。与 `Map` 不同，`HyperMap` 能够用于嵌套结构。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **ops** (Union[MultitypeFuncGraph, None]) – `ops` 是指定运算操作。如果 `ops` 为None，则运算应该作为 `HyperMap` 实例的第一个入参。默认值为None。
|
||||
- **reverse** (bool) - 在某些场景下，需要逆向以提高计算的并行性能，一般情况下，用户可以忽略。`reverse` 用于决定是否逆向执行运算，仅在图模式下支持。默认值为False。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **args** (Tuple[sequence]) - 如果 `ops` 不是None，则所有入参都应该是具有相同长度的序列，并且序列的每一行都是运算的输入。如果 `ops` 是None，则第一个入参是运算，其余都是输入。
|
||||
|
||||
**输出：**
|
||||
|
||||
序列或嵌套序列，执行函数如 `operation(args[0][i], args[1][i])` 之后输出的序列。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - 如果 `ops` 既不是 `MultitypeFuncGraph` 也不是None。
|
||||
- **TypeError** - 如果 `args` 不是一个tuple。
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
mindspore.ops.IOU
|
||||
=================
|
||||
|
||||
.. py:class:: mindspore.ops.IOU(mode='iou')
|
||||
|
||||
计算矩形的IOU，即真实区域和预测区域的交并比。
|
||||
|
||||
根据真实区域和预测区域计算IOU(intersection over union)或IOF(intersection over foreground)。
|
||||
|
||||
.. math::
|
||||
\text{IOU} = \frac{\text{Area of Overlap}}{\text{Area of Union}}
|
||||
|
||||
\text{IOF} = \frac{\text{Area of Overlap}}{\text{Area of Ground Truth}}
|
||||
|
||||
.. warning::
|
||||
在Ascend中，仅支持计算float16数据。为避免溢出，输入长度和宽度在内部按0.2缩放。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **mode** (string) - 该模式用于指定计算方法，现支持'iou'(intersection over union)或'iof'(intersection over foreground)模式。默认值：'iou'。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **anchor_boxes** (Tensor) - 预测区域，shape为(N, 4)的Tensor。"N"表示预测区域的数量，"4"表示"x0"、"y0"、"x1"和"y1"。数据类型为float16或float32。
|
||||
- **gt_boxes** (Tensor) - 真实区域，shape为(M, 4)的Tensor。"M"表示地面真实区域的数量，"4"表示"x0"、"y0"、"x1"和"y1"。数据类型为float16或float32。
|
||||
|
||||
**输出：**
|
||||
|
||||
IOU值的Tensor，shape为(M, N)的Tensor，数据类型与 `anchor_boxes` 的相同。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **KeyError** - `mode` 不是'iou'或'iof'。
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
mindspore.ops.LayerNorm
|
||||
=======================
|
||||
|
||||
.. py:class:: mindspore.ops.LayerNorm(begin_norm_axis=1, begin_params_axis=1, epsilon=1e-7)
|
||||
|
||||
在输入Tensor上应用层归一化（Layer Normalization）。
|
||||
|
||||
此算子将在给定的轴上对输入进行层归一化。`Layer Normalization <https://arxiv.org/abs/1607.06450>`_ 描述了LayerNorm。
|
||||
|
||||
.. math::
|
||||
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
|
||||
|
||||
其中 :math:`\gamma` 是Scalar， :math:`\beta` 是偏置项， :math:`\epsilon` 是精度值。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **begin_norm_axis** (int) - 指定 `input_x` 需进行层归一化的开始，其值必须在[-1, rank(input)范围内。默认值：1。
|
||||
- **begin_params_axis** (int) - 指定输入参数(`gamma`, `beta`) 需进行层归一化的开始轴，其值必须在[-1, rank(input))范围内。默认值：1。
|
||||
- **epsilon** (float) - 添加到分母中的值，以确保数据稳定性。默认值：1e-7。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **input_x** (Tensor) - LayerNorm的输入，shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
- **gamma** (Tensor) - 可学习参数 :math:`\gamma` ，shape为 :math:`(P_0, \ldots, P_\text{begin_params_axis})` 的Tensor。
|
||||
- **beta** (Tensor) - 可学习参数 :math:`\beta` 。shape为 :math:`(P_0, \ldots, P_\text{begin_params_axis})` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
tuple[Tensor]，3个Tensor组成的tuple，层归一化输入和更新后的参数。
|
||||
|
||||
- **output_x** (Tensor) - 层归一化输入，shape为是 :math:`(N, C)` 。数据类型和shape与 `input_x` 相同。
|
||||
- **mean** (Tensor) - 输入的均值，shape为 :math:`(C,)` 的Tensor。
|
||||
- **variance** (Tensor) - 输入的方差，shape为 :math:`(C,)` 的Tensor。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `begin_norm_axis` 或 `begin_params_axis` 不是int。
|
||||
- **TypeError** - `epsilon` 不是float。
|
||||
- **TypeError** - `input_x`、`gamma` 或 `beta` 不是Tensor。
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
mindspore.ops.MatrixInverse
|
||||
============================
|
||||
|
||||
.. py:class:: mindspore.ops.MatrixInverse(adjoint=False)
|
||||
|
||||
计算输入矩阵的逆矩阵，如果输入矩阵不可逆，将产生错误或者返回一个未知结果。
|
||||
|
||||
.. note::
|
||||
参数 `adjoint` 目前只支持False，因为目前该算子不支持复数。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **adjoint** (bool) - 指定是否支持复数，False表示为不支持复数。默认：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor) - 输入需计算的矩阵，至少为二维矩阵，且最后两个维度大小相同，数据类型为float32、float64。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，数据类型和shape与输入 `x` 相同。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `adjoint` 不是bool。
|
||||
- **TypeError** - `x` 的数据类型既不是float32，也不是float64。
|
||||
- **ValueError** - `x` 最后两个维度大小不同。
|
||||
- **ValueError** - `x` 低于二维。
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
mindspore.ops.MaxPool
|
||||
=====================
|
||||
|
||||
.. py:class:: mindspore.ops.MaxPool(kernel_size=1, strides=1, pad_mode="valid", data_format="NCHW")
|
||||
|
||||
对输入的多维数据进行二维的最大池化运算。
|
||||
|
||||
通常，输入的shape为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，MaxPool在 :math:`(H_{in}, W_{in})` 维度输出区域最大值。 给定 `kernel_size` 为 :math:`(kH,kW)` 和 `stride` ，运算如下：
|
||||
|
||||
.. math::
|
||||
\text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1}
|
||||
\text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **kernel_size** (Union[int, tuple[int]]) - 指定池化核尺寸大小。由一个整数或者是两个整数组成的tuple，表示高和宽。默认值：1。
|
||||
- **strides** (Union[int, tuple[int]]) - 池化操作的移动步长，由一个整数或者是两个整数组成的tuple，表示高和宽上的移动步长。默认值：1。
|
||||
- **pad_mode** (str) - 指定池化填充模式，可选值是'same'或'valid'，不区分大小写。默认值：'valid'。
|
||||
|
||||
- **same** - 输出的高度和宽度分别与输入整除 `stride` 后的值相同。
|
||||
- **valid** - 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。
|
||||
|
||||
- **data_format** (str)：输入和输出的数据格式。可选值为'NHWC'或'NCHW'。默认值：'NCHW'。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor) - shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `kernel_size` 或 `strides` 既不是int也不是tuple。
|
||||
- **ValueError** - `pad_mode` 既不是'valid'也不是'same'（不区分大小写）。
|
||||
- **ValueError** - `data_format` 既不是'NCHW'也不是'NHWC'。
|
||||
- **ValueError** - `kernel_size` 或 `strides` 小于1。
|
||||
- **ValueError** - `iput` 的shape长度不等于4。
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
mindspore.ops.MaxPoolWithArgmax
|
||||
===============================
|
||||
|
||||
.. py:class:: mindspore.ops.MaxPoolWithArgmax(kernel_size=1, strides=1, pad_mode="valid", data_format="NCHW")
|
||||
|
||||
对输入Tensor执行最大池化运算，并返回最大值和索引。
|
||||
|
||||
通常，输入的shape为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，MaxPool在 :math:`(H_{in}, W_{in})` 维度输出区域最大值。 给定 `kernel_size` 为 :math:`(kH, kW)` 和 `stride` ，运算如下：
|
||||
|
||||
.. math::
|
||||
\text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1}\\
|
||||
\text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **kernel_size** (Union[int, tuple[int]]) - 指定池化核尺寸大小。由一个整数或者是两个整数组成的tuple，表示高和宽。默认值：1。
|
||||
- **strides** (Union[int, tuple[int]]) - 池化操作的移动步长，由一个整数或者是两个整数组成的tuple，表示高和宽移动步长。默认值：1。
|
||||
- **pad_mode** (str) - 指定池化填充模式，可选值是'same'或'valid'，不区分大小写。默认值：'valid'。
|
||||
|
||||
- **same** - 输出的高度和宽度分别与输入整除 `stride` 后的值相同。
|
||||
- **valid** - 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。
|
||||
|
||||
- **data_format** (str)：输入和输出的数据格式。可选值为'NHWC'或'NCHW'。默认值：'NCHW'。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x** (Tensor) - shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。数据类型必须为float16或float32。
|
||||
|
||||
**输出：**
|
||||
|
||||
两个Tensor组成的tuple，表示最大池化结果和生成最大值的位置。
|
||||
|
||||
- **output** (Tensor) - 输出最大池结果，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 。其数据类型与 `x` 的相同。
|
||||
- **mask** (Tensor) - 输出最大值索引。数据类型为int32。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `x` 的数据类型既不是float16也不是float32。
|
||||
- **TypeError** - `kernel_size` 或 `strides` 既不是int也不是tuple。
|
||||
- **TypeError** - `x` 不是Tensor。
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
mindspore.ops.SoftmaxCrossEntropyWithLogits
|
||||
============================================
|
||||
|
||||
.. py:class:: mindspore.ops.SoftmaxCrossEntropyWithLogits
|
||||
|
||||
使用one-hot编码获取预测值和真实之间的softmax交叉熵。
|
||||
|
||||
SoftmaxCrossEntropyWithLogits算法的更新公式如下：
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
p_{ij} = softmax(X_{ij}) = \frac{\exp(x_i)}{\sum_{j = 0}^{N-1}\exp(x_j)} \\
|
||||
loss_{ij} = -\sum_j{Y_{ij} * ln(p_{ij})}
|
||||
\end{array}
|
||||
|
||||
其中 :math:`X` 代表 `logits` 。 :math:`Y` 代表 `label` 。 :math:`loss` 代表 `output` 。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **logits** (Tensor) - 输入预测值，其shape为 :math:`(N, C)` ，数据类型为float16或float32。
|
||||
- **labels** (Tensor) - 输入真实值，其shape为 :math:`(N, C)` ，数据类型与 `logits` 的相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
两个Tensor(loss, dlogits)组成的tuple， `loss` 的shape为 :math:`(N,)` ， `dlogits` 的shape与 `logits` 的相同。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `logits` 或 `labels` 的数据类型既不是float16也不是float32。
|
||||
- **TypeError** - `logits` 或 `labels` 不是Tensor。
|
||||
- **ValueError** - `logits` 的shape与 `labels` 的不同。
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
mindspore.ops.batch_dot
|
||||
=======================
|
||||
|
||||
.. py:function:: mindspore.ops.batch_dot(x1, x2, axes=None, prim_name=None)
|
||||
|
||||
当输入的两个Tensor是批量数据时，对其进行批量点积操作。
|
||||
|
||||
.. math::
|
||||
output = x1[batch, :]* x2[batch, :]
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x1** (Tensor) - 第一个输入Tensor，数据类型为float32且 `x1` 的秩必须大于或等于2。
|
||||
- **x2** (Tensor) - 第二个输入Tensor，数据类型为float32。 `x2` 的数据类型应与 `x1` 相同，`x2` 的秩必须大于或等于2。
|
||||
- **axes** (Union[int, tuple(int), list(int)]) - 指定为单值或长度为2的tuple和list，分别指定 `a` 和 `b` 的维度。如果传递了单个值 `N`，则自动从输入 `a` 的shape中获取最后N个维度，从输入 `b` 的shape中获取最后N个维度，分别作为每个维度的轴。默认值：None。
|
||||
- **prim_name** (Union[str,None]) - 指定算子名。默认值：None。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor， `x1` 和 `x2` 的批量点积。例如：输入 `x1` 的shape为(batch, d1, axes, d2)，`x2` shape为(batch, d3, axes, d4)，则输出shape为(batch, d1, d2, d3, d4)，其中d1和d2表示任意数字。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `x1` 和 `x2` 的类型不相同。
|
||||
- **TypeError** - `x1` 或 `x2` 的数据类型不是float32。
|
||||
- **ValueError** - `x1` 或 `x2` 的秩小于2。
|
||||
- **ValueError** - 在轴中使用了代表批量的维度。
|
||||
- **ValueError** - len(axes)小于2。
|
||||
- **ValueError** - 轴不是其一：None，int，或(int, int)。
|
||||
- **ValueError** - 如果 `axes` 为负值，低于输入数组的维度。
|
||||
- **ValueError** - 如果 `axes` 的值高于输入数组的维度。
|
||||
- **ValueError** - `x1` 和 `x2` 的批处理大小不相同。
|
||||
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
mindspore.ops.clip_by_global_norm
|
||||
==================================
|
||||
|
||||
.. py:function:: mindspore.ops.clip_by_global_norm(x, clip_norm=1.0, use_norm=None)
|
||||
|
||||
通过权重梯度总和的比率来裁剪多个Tensor的值。
|
||||
|
||||
.. note::
|
||||
输入'x'应为Tensor的tuple或list。否则，将引发错误。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **x** (Union(tuple[Tensor], list[Tensor])) - 由Tensor组成的tuple，其每个元素为任意维度的Tensor。
|
||||
- **clip_norm** (Union(float, int)) - 表示裁剪比率，应大于0。默认值：1.0。
|
||||
- **use_norm** (None) - 表示全局范数。目前只支持None，默认值：None。
|
||||
|
||||
**返回：**
|
||||
|
||||
tuple[Tensor]，表示裁剪后的Tensor。其数据类型与 `x` 相同，输出tuple中的每个Tensor与输入shape相同。
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
mindspore.ops.clip_by_value
|
||||
============================
|
||||
|
||||
.. py:function:: mindspore.ops.clip_by_value(x, clip_value_min, clip_value_max)
|
||||
|
||||
将输入Tensor值裁剪到指定的最小值和最大值之间。
|
||||
|
||||
限制 :math:`x` 的范围，其 :math:`x` 的最小值为'clip_value_min'，最大值为'clip_value_max'。
|
||||
|
||||
.. math::
|
||||
out_i= \left\{
|
||||
\begin{array}{align}
|
||||
clip\_value_{max} & \text{ if } x_i\ge clip\_value_{max} \\
|
||||
x_i & \text{ if } clip\_value_{min} \lt x_i \lt clip\_value_{max} \\
|
||||
clip\_value_{min} & \text{ if } x_i \le clip\_value_{min} \\
|
||||
\end{array}\right.
|
||||
|
||||
.. note::
|
||||
'clip_value_min'必须小于或等于'clip_value_max'。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **x** (Tensor) - clip_by_value的输入，任意维度的Tensor。
|
||||
- **clip_value_min** (Tensor) - 指定最小值。
|
||||
- **clip_value_max** (Tensor) - 指定最大值。
|
||||
|
||||
**返回：**
|
||||
|
||||
Tensor，表示裁剪后的Tensor。其shape和数据类型和 `x` 相同。
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
mindspore.ops.dot
|
||||
==================
|
||||
|
||||
.. py:function:: mindspore.ops.dot(x1, x2)
|
||||
|
||||
两个Tensor之间的点积。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **x1** (Tensor) - 第一个输入的Tensor，数据类型为float16或float32，秩必须大于或等于2。
|
||||
- **x2** (Tensor) - 第二个输入的Tensor，数据类型为float16或float32，秩必须大于或等于2。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor， `x1` 和 `x2` 的点积。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError** - `x1` 和 `x2` 的数据类型不相同。
|
||||
- **TypeError** - `x1` 或 `x2` 的数据类型不是float16或float32。
|
||||
- **ValueError** - `x1` 或 `x2` 的秩小于2。
|
||||
Loading…
Reference in New Issue