p60975123
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

amend ops

This commit is contained in:
chenweitao_295 2021-12-22 11:46:09 +08:00
parent 35ffa628eb
commit 3c9aa15c15
24 changed files with 157 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
docs/api/api_python/ops/mindspore.ops.Add.rst
View File

@ -1,31 +1,32 @@
mindspore.ops.Add
=================
.. py:class:: mindspore.ops.Add(*args, **kwargs)
.. py:class:: mindspore.ops.Add()
两个输入Tensor按元素相加。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
输入必须是两个Tensor，或一个Tensor和一个Scalar。
当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
两个输入Tensor逐元素相加。
.. math::
out_{i} = x_{i} + y_{i}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**
Tensor，shape与广播后的shape相同，数据类型为两个输入中精度较高的类型。
Tensor，shape与输入 `x`，`y` 广播后的shape相同，数据类型为两个输入中精度较高的类型。
**异常：**
- **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
- **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
**支持平台：**

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

@ -1,15 +1,15 @@
mindspore.ops.AddN
===================
.. py:class:: mindspore.ops.AddN(*args, **kwargs)
.. py:class:: mindspore.ops.AddN()
按元素将所有输入的Tensor相加。
逐元素将所有输入的Tensor相加。
所有输入Tensor必须具有相同的shape。
**输入：**
- **x** (Union(tuple[Tensor], list[Tensor])) - 输入tuple或list由多个Tensor组成，其数据类型为Number或bool，用于相加。
- **x** (Union(tuple[Tensor], list[Tensor])) - Tensor组成的tuble或list，类型为 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 。
**输出：**
@ -18,6 +18,7 @@ mindspore.ops.AddN
**异常：**
- **TypeError** - `x` 既不是tuple，也不是list。
- **ValueError** - `x` 中存在shape不同的Tensor。
**支持平台：**

23
docs/api/api_python/ops/mindspore.ops.Div.rst
View File

@ -1,28 +1,33 @@
mindspore.ops.Div
=================
.. py:class:: mindspore.ops.Div(*args, **kwargs)
.. py:class:: mindspore.ops.Div()
按元素计算第一输入Tensor除以第二输入Tensor的商。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。输入必须是两个Tensor，或一个Tensor和一个Scalar。当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
逐元素计算第一输入Tensor除以第二输入Tensor的商。
.. math::
out_{i} = \frac{x_i}{y_i}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**
Tensor，shape与广播后的shape相同，数据类型为两个输入中精度较高的类型。
Tensor，shape与输入 `x`，`y` 广播后的shape相同，数据类型为两个输入中精度较高的类型。
**异常：**
- **TypeError** - `x` 和 `y` 都不是Tensor。
- **TypeError** - `x` 和 `y` 数据类型都是bool_的Tensor。
**支持平台：**
@ -38,8 +43,8 @@ mindspore.ops.Div
>>> print(output)
[-1.3333334 2.5 2. ]
>>> # 用例2：两个输入的数据类型和shape不同
>>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.int32)
>>> y = Tensor(2, mindspore.float32)
>>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
>>> y = Tensor(2, mindspore.int32)
>>> output = div(x, y)
>>> print(output)
[-2. 2.5 3.]

11
docs/api/api_python/ops/mindspore.ops.Eps.rst
View File

@ -1,18 +1,23 @@
mindspore.ops.Eps
=================
.. py:class:: mindspore.ops.Eps(*args, **kwargs)
.. py:class:: mindspore.ops.Eps()
创建一个填充 `x` 数据类型最小值的Tensor。
创建一个与输入数据类型和shape都相同的Tensor，元素值为对应数据类型能表达的最小值。
**输入：**
- **x** (Tensor) - 用于获取其数据类型最小值的Tensor。数据类型必须为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
- **x** (Tensor) - 用于获取其数据类型能表达的最小值的任意维度的Tensor。数据类型必须为float16或float32。
**输出：**
Tensor，具有与 `x` 相同的数据类型和shape，填充了 `x` 数据类型的最小值。
**异常：**
- **TypeError** - `x` 不是Tensor。
- **TypeError** - `x` 的数据类型不是float16或者float32。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``

6
docs/api/api_python/ops/mindspore.ops.Erf.rst
View File

@ -1,9 +1,9 @@
mindspore.ops.Erf
=================
.. py:class:: mindspore.ops.Erf(*args, **kwargs)
.. py:class:: mindspore.ops.Erf()
按元素计算 `x` 的高斯误差函数。
逐元素计算 `x` 的高斯误差函数。
.. math::
@ -11,7 +11,7 @@ mindspore.ops.Erf
**输入：**
- **x** (Tensor) - 用于计算高斯误差函数的Tensor。数据类型必须为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数，其秩应小于8。
- **x** (Tensor) - 高斯误差函数的输入Tensor。数据类型必须为float16或float32。任意维度小于8的Tensor。
**输出：**

16
docs/api/api_python/ops/mindspore.ops.Gamma.rst
View File

@ -3,7 +3,7 @@ mindspore.ops.Gamma
.. py:class:: mindspore.ops.Gamma(seed=0, seed2=0)
根据概率密度函数分布生成随机正浮点数x。
根据概率密度函数分布生成随机正值浮点数x。
.. math::
@ -14,6 +14,13 @@ mindspore.ops.Gamma
- **seed** (int) - 算子层的随机种子，用于生成随机数。必须是非负的。默认值：0。
- **seed2** (int)：全局的随机种子，和算子层的随机种子共同决定最终生成的随机数。必须是非负的。默认值：0。
.. note::
- 随机种子：通过一些复杂的数学算法，可以得到一组有规律的随机数，而随机种子就是这个随机数的初始值。随机种子相同，得到的随机数就不会改变。
- 全局的随机种子和算子层的随机种子都没设置：使用默认值当做随机种子。
- 全局的随机种子设置了，算子层的随机种子未设置：随机生成一个种子和全局的随机种子拼接。
- 全局的随机种子未设置，算子层的随机种子设置了：使用默认的全局的随机种子，和算子层的随机种子拼接。
- 全局的随机种子和算子层的随机种子都设置了：全局的随机种子和算子层的随机种子拼接。
**输入：**
- **shape** (tuple) - 待生成的随机Tensor的shape。只支持常量值。
@ -22,12 +29,13 @@ mindspore.ops.Gamma
**输出：**
Tensor。shape是输入 `shape` 以及alpha、beta广播后的shape。数据类型为float32。
Tensor。shape是输入 `shape`， `alpha`， `beta` 广播后的shape。数据类型为float32。
**异常：**
- **TypeError** - `seed` 和 `seed2` 都不是int。
- **TypeError** - `alpha` 和 `beta` 都不是Tensor。
- **TypeError** - `seed` 或 `seed2` 的数据类型不是int。
- **TypeError** - `alpha` 或 `beta` 不是Tensor。
- **TypeError** - `alpha` 或 `beta` 的数据类型不是float32。
- **ValueError** - `shape` 不是常量值。
**支持平台：**

8
docs/api/api_python/ops/mindspore.ops.GeLU.rst
View File

@ -1,7 +1,7 @@
mindspore.ops.GeLU
==================
.. py:class:: mindspore.ops.GeLU(*args, **kwargs)
.. py:class:: mindspore.ops.GeLU()
高斯误差线性单元激活函数（Gaussian Error Linear Units activation function）。
@ -11,13 +11,13 @@ mindspore.ops.GeLU
GeLU函数定义如下：
.. math::
\text{output} = 0.5 * x * (1 + tanh(x / \sqrt{2})),
GELU(x_i) = x_i*P(X < x_i)
其中 :math:`tanh` 是双曲正切函数。
其中 :math:`P` 是标准高斯分布的累积分布函数， :math:`x_i` 是输入的元素。
**输入：**
- **x** (Tensor) - 用于计算GeLU函数的Tensor，数据类型为float16或float32。
- **x** (Tensor) - 激活函数GeLU的输入，数据类型为float16或float32。
**输出：**

10
docs/api/api_python/ops/mindspore.ops.L2Loss.rst
View File

@ -1,14 +1,14 @@
mindspore.ops.L2Loss
====================
.. py:class:: mindspore.ops.L2Loss(*args, **kwargs)
.. py:class:: mindspore.ops.L2Loss()
计算Tensor的L2范数的一半，不对结果进行开方。
用于计算L2范数，但不对结果进行开方操作。
把 `input_x` 设为x，输出设为loss。
把输入设为x，输出设为loss。
.. math::
loss = sum(x ** 2) / 2
loss = \frac{\sum x ^ 2}{2}
**输入：**
@ -16,7 +16,7 @@ mindspore.ops.L2Loss
**输出：**
Tensor，具有与 `input_x` 相同的数据类型。输出Tensor是loss的值，是一个scalar Tensor。
Tensor，具有与 `input_x` 相同的数据类型的Scalar Tensor。
**异常：**

19
docs/api/api_python/ops/mindspore.ops.LessEqual.rst
View File

@ -1,14 +1,9 @@
mindspore.ops.LessEqual
========================
.. py:class:: mindspore.ops.LessEqual(*args, **kwargs)
.. py:class:: mindspore.ops.LessEqual()
按元素计算 :math:`x <= y` 的bool值。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
输入必须是两个Tensor，或一个Tensor和一个Scalar。
当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
逐元素计算 :math:`x <= y` 的bool值。
.. math::
@ -17,10 +12,16 @@ mindspore.ops.LessEqual
& \text{False, if } x_{i}>y_{i}
\end{cases}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**

11
docs/api/api_python/ops/mindspore.ops.Log.rst
View File

@ -1,20 +1,23 @@
mindspore.ops.Log
=================
.. py:class:: mindspore.ops.Log(*args, **kwargs)
.. py:class:: mindspore.ops.Log()
按元素返回Tensor的自然对数。
逐元素返回Tensor的自然对数。
.. math::
y_i = log_e(x_i)
.. warning::
如果算子Log的输入值在(0，0.01]或[0.95，1.05]范围内，则输出精度可能会发生变化。
如果算子Log的输入值在(0，0.01]或[0.95，1.05]范围内，则输出精度可能会存在误差。
.. note::
Ascend上输入Tensor的维度要小于等于8，CPU上输入Tensor的维度要小于8。
**输入：**
- **x** (Tensor) - 输入Tensor。该值必须大于0。shape为 :math:`(N,*)`，其中 :math:`*` 表示任意的附加维度数，它的秩应小于8。
- **x** (Tensor) - 任意维度的输入Tensor。该值必须大于0。
**输出：**

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

@ -28,7 +28,7 @@ mindspore.ops.matmul
**异常：**
- **TypeError** - `transpose_a` 或 `transpose_b` 不是bool。
- **ValueError** - 矩阵 `a` 的维度的列不等于矩阵 `b` 的维度的行。
- **ValueError** - 矩阵 `a` 的列不等于矩阵 `b` 的行。
- **ValueError** - `a` 或 `b` 的维度不等于2。
**支持平台：**

21
docs/api/api_python/ops/mindspore.ops.Mul.rst
View File

@ -1,23 +1,24 @@
mindspore.ops.Mul
=================
.. py:class:: mindspore.ops.Mul(*args, **kwargs)
.. py:class:: mindspore.ops.Mul()
两个Tensor按元素相乘。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
输入必须是两个Tensor，或一个Tensor和一个Scalar。
当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
两个Tensor逐元素相乘。
.. math::
out_{i} = x_{i} * y_{i}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**
@ -25,7 +26,7 @@ mindspore.ops.Mul
**异常：**
- **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
- **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
- **ValueError** - `x` 和 `y` 的shape不相同。
**支持平台：**

8
docs/api/api_python/ops/mindspore.ops.OnesLike.rst
View File

@ -1,15 +1,13 @@
mindspore.ops.OnesLike
======================
.. py:class:: mindspore.ops.OnesLike(*args, **kwargs)
.. py:class:: mindspore.ops.OnesLike()
创建新Tensor。所有元素的值都为1。
返回填充了Scalar值为1的具有与输入相同shape和数据类型的Tensor。
返回值为1的Tensor，shape和数据类型与输入相同。
**输入：**
- **input_x** (Tensor) - 输入Tensor。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
- **input_x** (Tensor) - 任意维度的Tensor。
**输出：**

10
docs/api/api_python/ops/mindspore.ops.PReLU.rst
View File

@ -1,7 +1,7 @@
mindspore.ops.PReLU
===================
.. py:class:: mindspore.ops.PReLU(*args, **kwargs)
.. py:class:: mindspore.ops.PReLU()
带参数的线性修正单元激活函数（Parametric Rectified Linear Unit activation function）。
@ -14,18 +14,18 @@ mindspore.ops.PReLU
.. note::
Ascend不支持0-D或1-D的x。
Ascend不支持标量和1维向量的输入x。
**输入：**
- **x** (Tensor) - 用于计算激活函数的Tensor。数据类型为float16或float32。shape为 :math:`(N, C, *)` ，其中 :math:`*` 表示任意的附加维度数。
- **weight** (Tensor) - 权重Tensor。数据类型为float16或float32。只有两种shape是合法的，1或 `input_x` 的通道数。通道维度是输入的第二维。当输入为0-D或1-D Tensor时，通道数为1。
- **x** (Tensor) - 激活函数的输入Tensor。数据类型为float16或float32。shape为 :math:`(N, C, *)` ，其中 :math:`*` 表示任意的附加维度。
- **weight** (Tensor) - 权重Tensor。数据类型为float16或float32。weight只可以是向量，长度与输入x的通道数C相同。在GPU设备上，当输入为标量时，shape为1。
**输出：**
Tensor，数据类型与 `x` 的相同。
有关详细信息，请参考:class:`nn.PReLU`。
有关详细信息，请参考 :class:`mindspore.nn.PReLU` 。
**异常：**

23
docs/api/api_python/ops/mindspore.ops.Pow.rst
View File

@ -1,23 +1,24 @@
mindspore.ops.Pow
==================
.. py:class:: mindspore.ops.Pow(*args, **kwargs)
.. py:class:: mindspore.ops.Pow()
计算 `x` 中每个元素的 `y` 的幂次。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
输入必须是两个Tensor，或一个Tensor和一个Scalar。
当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
计算 `x` 中每个元素的 `y` 次幂。
.. math::
out_{i} = x_{i} ^{ y_{i}}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**
@ -25,8 +26,8 @@ mindspore.ops.Pow
**异常：**
- **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
- **ValueError** - `x` 和 `y` 的shape不相同。
- **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
- **ValueError** - 当`x` 和 `y` 都为Tensor时，它们的shape不相同。
**支持平台：**

17
docs/api/api_python/ops/mindspore.ops.ReLUV2.rst
View File

@ -1,7 +1,7 @@
mindspore.ops.ReLUV2
====================
.. py:class:: mindspore.ops.ReLUV2(*args, **kwargs)
.. py:class:: mindspore.ops.ReLUV2()
线性修正单元激活函数（Rectified Linear Unit activation function）。
@ -11,10 +11,6 @@ mindspore.ops.ReLUV2
\text{ReLU}(x) = (x)^+ = \max(0, x)，
.. note::
与 `ReLu` 的区别在于该算子多输出一个mask，且算子的kernel与 `ReLu` 的不同。
**输入：**
- **input_x** (Tensor) - 输入Tensor必须是4-D Tensor。
@ -22,7 +18,7 @@ mindspore.ops.ReLUV2
**输出：**
- **output** (Tensor) - 数据类型和shape与 `input_x` 的相同。
- **mask** (Tensor) - 数据类型必须为uint8的Tensor。
- **mask** (Tensor) - 保留输出，无实际意义。
**异常：**
@ -37,14 +33,9 @@ mindspore.ops.ReLUV2
>>> input_x = Tensor(np.array([[[[1, -2], [-3, 4]], [[-5, 6], [7, -8]]]]), mindspore.float32)
>>> relu_v2 = ops.ReLUV2()
>>> output, mask= relu_v2(input_x)
>>> output, _= relu_v2(input_x)
>>> print(output)
[[[[1. 0.]
[0. 4.]]
[[0. 6.]
[7. 0.]]]]
>>> print(mask)
[[[[[1 0]
[2 0]]
[[2 0]
[1 0]]]]]
[7. 0.]]]]

6
docs/api/api_python/ops/mindspore.ops.Reshape.rst
View File

@ -1,9 +1,9 @@
mindspore.ops.Reshape
======================
.. py:class:: mindspore.ops.Reshape(*args, **kwargs)
.. py:class:: mindspore.ops.Reshape()
基于给定的shape，使用相同的值对输入Tensor进行reshape操作。
基于给定的shape，对输入Tensor进行重新排列。
`input_shape` 最多只能有一个-1，在这种情况下，它可以从剩余的维度和输入的元素个数中推断出来。
@ -18,7 +18,7 @@ mindspore.ops.Reshape
**异常：**
- **ValueError** - 给定的 `input_shape`，如果它有几个-1，或者除-1（若存在）之外的元素的乘积小于或等于0，或者无法被输入Tensor的shape的乘积相除，或者与输入的数组大小不匹配。
- **ValueError** - 给定的 `input_shape`，如果它有多个-1，或者除-1（若存在）之外的元素的乘积小于或等于0，或者无法被输入Tensor的shape的乘积整除，或者与输入的数组大小不匹配。
**支持平台：**

6
docs/api/api_python/ops/mindspore.ops.SeLU.rst
View File

@ -1,9 +1,9 @@
mindspore.ops.SeLU
==================
.. py:class:: mindspore.ops.SeLU(*args, **kwargs)
.. py:class:: mindspore.ops.SeLU()
按元素计算输入Tensor的SeLU（scaled exponential Linear Unit）函数。
激活函数SeLU（Scaled exponential Linear Unit）。
该激活函数定义为：
@ -21,7 +21,7 @@ mindspore.ops.SeLU
**输入：**
- **input_x** (Tensor) - shape为 :math:`(N, *)` 的Tensor，其中， :math:`*` 表示任意的附加维度数，数据类型为float16或float32。
- **input_x** (Tensor) - 任意维度的Tensor，数据类型为float16或float32。
**输出：**

6
docs/api/api_python/ops/mindspore.ops.Sigmoid.rst
View File

@ -1,11 +1,11 @@
mindspore.ops.Sigmoid
=====================
.. py:class:: mindspore.ops.Sigmoid(*args, **kwargs)
.. py:class:: mindspore.ops.Sigmoid()
Sigmoid激活函数。
按元素计算输入的Sigmoid函数。Sigmoid函数定义为：
逐元素计算Sgmoid激活函数。Sigmoid函数定义为：
.. math::
@ -15,7 +15,7 @@ mindspore.ops.Sigmoid
**输入：**
- **input_x** (Tensor) - shape为 :math:`(N, *)` 的tensor，其中， :math:`*` 表示任意的附加维度数，数据类型为float16或float32。
- **input_x** (Tensor) - 任意维度的Tensor，数据类型为float16或float32。
**输出：**

8
docs/api/api_python/ops/mindspore.ops.Size.rst
View File

@ -1,15 +1,13 @@
mindspore.ops.Size
==================
.. py:class:: mindspore.ops.Size(*args, **kwargs)
.. py:class:: mindspore.ops.Size()
返回Tensor的大小。
返回一个整数Scalar，表示输入的元素大小，即Tensor中元素的总数。
返回一个Scalar，类型为整数，表示输入Tensor的大小，即Tensor中元素的总数。
**输入：**
- **input_x** (Tensor) - Tensor的shape为 :math:`(x_1, x_2, ..., x_R)` 。数据类型为Number。
- **input_x** (Tensor) - 输入参数，shape为 :math:`(x_1, x_2, ..., x_R)` 。数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 。
**输出：**

21
docs/api/api_python/ops/mindspore.ops.Sub.rst
View File

@ -1,23 +1,24 @@
mindspore.ops.Sub
=================
.. py:class:: mindspore.ops.Sub(*args, **kwargs)
.. py:class:: mindspore.ops.Sub()
按元素用第一个输入Tensor减去第二个输入Tensor。
输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
输入必须是两个Tensor，或一个Tensor和一个Scalar。
当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
逐元素用第一个输入Tensor减去第二个输入Tensor。
.. math::
out_{i} = x_{i} - y_{i}
.. note::
- 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
- 输入必须是两个Tensor，或一个Tensor和一个Scalar。
- 当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
- 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
**输入：**
- **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
- **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
- **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
- **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
**输出：**
@ -25,7 +26,7 @@ mindspore.ops.Sub
**异常：**
- **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
- **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
**支持平台：**

10
docs/api/api_python/ops/mindspore.ops.Tile.rst
View File

@ -1,9 +1,9 @@
mindspore.ops.Tile
===================
.. py:class:: mindspore.ops.Tile(*args, **kwargs)
.. py:class:: mindspore.ops.Tile()
按照给定的次数复制Tensor。
按照给定的次数复制输入Tensor。
通过复制 `multiples` 次 `input_x` 来创建新的Tensor。输出Tensor的第i维度有 `input_x.shape[i] * multiples[i]` 个元素，并且 `input_x` 的值沿第i维度被复制 `multiples[i]` 次。
@ -13,12 +13,12 @@ mindspore.ops.Tile
**输入：**
- **input_x** (Tensor) - 1-D或更高的Tensor。将输入Tensor的shape设置为 :math:`(x_1, x_2, ..., x_S)` 。
- **multiples** (tuple[int]) - 输入tuple由多个整数构成，如 :math:`(y_1, y_2, ..., y_S)` 。`multiples` 的长度不能小于 `input_x` 的维度。只支持常量值。
- **input_x** (Tensor) - 1-D或更高维的Tensor。
- **multiples** (tuple[int]) - 指定复制次数的参数，参数类型为tuple，数据类型为整数。如 :math:`(y_1, y_2, ..., y_S)` 。`multiples` 的长度不能小于 `input_x` 的维度。只支持常量值。
**输出：**
Tensor，具有与 `input_x` 相同的数据类型。假设 `multiples` 的长度为 `d` ，`input_x` 的维度为 `input_x.dim`。
Tensor，具有与 `input_x` 相同的数据类型。假设 `multiples` 的长度为 `d` ，`input_x` 的维度为 `input_x.dim`，`input_x`的shape为 :math:`(x_1, x_2, ..., x_S)` 。
- 如果 `input_x.dim = d`， 将其相应位置的shape相乘，输出的shape为 :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_S)` 。
- 如果 `input_x.dim < d`， 在 `input_x` 的shape的前面填充1，直到它们的长度一致。例如将 `input_x` 的shape设置为 :math:`(1, ..., x_1, ..., x_R, x_S)` ，然后可以将其相应位置的shape相乘，输出的shape为 :math:`(1*y_1, ..., x_R*y_R, x_S*y_S)` 。

15
docs/api/api_python/ops/mindspore.ops.UniformReal.rst
View File

@ -3,24 +3,31 @@ mindspore.ops.UniformReal
.. py:class:: mindspore.ops.UniformReal(seed=0, seed2=0)
产生随机的浮点数i，均匀分布在[0，1)范围内。
产生随机的浮点数，均匀分布在[0，1)范围内。
**参数：**
- **seed** (int) - 算子层的随机种子，用于生成随机数。必须是非负的。默认值：0。
- **seed2** (int)：全局的随机种子，和算子层的随机种子共同决定最终生成的随机数。必须是非负的。默认值：0。
.. note::
- 随机种子：通过一些复杂的数学算法，可以得到一组有规律的随机数，而随机种子就是这个随机数的初始值。随机种子相同，得到的随机数就不会改变。
- 全局的随机种子和算子层的随机种子都没设置：使用默认值当做随机种子。
- 全局的随机种子设置了，算子层的随机种子未设置：随机生成一个种子和全局的随机种子拼接。
- 全局的随机种子未设置，算子层的随机种子设置了：使用默认的全局的随机种子，和算子层的随机种子拼接。
- 全局的随机种子和算子层的随机种子都设置了：全局的随机种子和算子层的随机种子拼接。
**输入：**
- **shape** (tuple) - 待生成的随机Tensor的shape。只支持常量值。
- **shape** (tuple) - 待生成的Tensor的shape。只支持常量值。
**输出：**
Tensor。它的shape为输入 `shape` 表示的值。数据类型为float32。
Tensor。它的shape为输入 `shape`。数据类型为float32。
**异常：**
- **TypeError** - `seed` 和 `seed2` 都不是int。
- **TypeError** - `seed` 或 `seed2` 不是int。
- **TypeError** - `shape` 不是tuple。
- **ValueError** - `shape` 不是常量值。

8
docs/api/api_python/ops/mindspore.ops.ZerosLike.rst
View File

@ -1,15 +1,13 @@
mindspore.ops.ZerosLike
=======================
.. py:class:: mindspore.ops.ZerosLike(*args, **kwargs)
.. py:class:: mindspore.ops.ZerosLike()
创建新的Tensor。它的所有元素的值都为0。
返回具有与输入Tensor相同shape和数据类型的值为0的Tensor。
返回值为0的Tensor，其shape和数据类型与输入Tensor相同。
**输入：**
- **input_x** (Tensor) - 输入Tensor。数据类型为int32、int64、float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
- **input_x** (Tensor) - 任意维度的输入Tensor。数据类型为int32、int64、float16或float32。
**输出：**