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

fix issue I60Q6L I5YQCT I5YQ9F I5YE52

This commit is contained in:
panfengfeng 2022-11-11 16:15:26 -05:00
parent 5fc1efc4aa
commit 5e91012009
36 changed files with 326 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/api/api_python/mindspore.ops.function.rst
View File

@ -154,6 +154,7 @@ mindspore.ops.function
mindspore.ops.addcdiv
mindspore.ops.addcmul
mindspore.ops.addn
mindspore.ops.addr
mindspore.ops.arccosh
mindspore.ops.arcsin
mindspore.ops.arctan

24
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.addr.rst
View File

@ -3,26 +3,4 @@ mindspore.Tensor.addr
.. py:method:: mindspore.Tensor.addr(vec1, vec2, beta=1, alpha=1)
计算 `vec1` 和 `vec2` 的外积，并将其添加到输入张量中。
如果 `vec1` 是一个大小为 :math:`N` 的向量， `vec2` 是一个大小为 :math:`M` 的向量，那么 `x` 必须是可广播的，且
带有一个大小为 :math:`(N, M)` 的矩阵，同时 `out` 是一个大小为 :math:`(N, M)` 的矩阵。
可选值 `bata` 和 `alpha` 分别是 `vec1` 和 `vec2` 外积的扩展因子以及附加矩阵 `x` 。如果 `beta` 为0，那么 `x` 将被忽略。
.. math::
output = β x + α (vec1 ⊗ vec2)
参数：
- **vec1** (Tensor) - 第一个需要相乘的Tensor，shape大小为 :math:`(N,)` 。
- **vec2** (Tensor) - 第二个需要相乘的Tensor，shape大小为 :math:`(M,)` 。
- **beta** (scalar[int, float, bool], 可选) - `x` (β)的乘法器。 `beta` 必须是int或float或bool类型，默认值：1。
- **alpha** (scalar[int, float, bool], 可选) - `mat` @ `vec` (α)的乘法器。 `alpha` 必须是int或float或bool类型，默认值：1。
返回：
Tensor，shape大小为 :math:`(N, M)` ，数据类型与 `x` 相同。
异常：
- **TypeError** - `x` 、 `vec1` 、 `vec2` 不是Tensor。
- **TypeError** - `x` 、 `vec1` 、 `vec2` 的数据类型不一致。
- **ValueError** - 如果 `x` 不是一个二维Tensor。如果 `vec1` ， `vec2` 不是一个一维Tensor。
详情请参考 :func:`mindspore.ops.addr`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.fold.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.fold
========================
.. py:method:: mindspore.Tensor.fold(output_size, kernel_size, dilation=1, padding=0, stride=1)
详情请参考 :func:`mindspore.ops.fold`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.greater.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.greater
========================
.. py:method:: mindspore.Tensor.greater(other)
详情请参考 :func:`mindspore.ops.greater`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.greater_equal.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.greater_equal
==============================
.. py:method:: mindspore.Tensor.greater_equal(other)
详情请参考 :func:`mindspore.ops.greater_equal`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.igamma.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.igamma
=======================
.. py:method:: mindspore.Tensor.igamma(other)
详情请参考 :func:`mindspore.ops.igamma`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.igammac.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.igammac
========================
.. py:method:: mindspore.Tensor.igammac(other)
详情请参考 :func:`mindspore.ops.igammac`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.index_add.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.index_add
==========================
.. py:method:: mindspore.Tensor.index_addindex_add(dim, index, source, *, alpha=1)
详情请参考 :func:`mindspore.ops.index_add`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.isinf.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.isinf
======================
.. py:method:: mindspore.Tensor.isinf()
详情请参考 :func:`mindspore.ops.isinf`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.isnan.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.isnan
======================
.. py:method:: mindspore.Tensor.isnan()
详情请参考 :func:`mindspore.ops.isnan`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.le.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.le
===================
.. py:method:: mindspore.Tensor.le(other)
详情请参考 :func:`mindspore.ops.le`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.less.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.less
=====================
.. py:method:: mindspore.Tensor.less(other)
详情请参考 :func:`mindspore.ops.less`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.logical_and.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.logical_and
============================
.. py:method:: mindspore.Tensor.logical_and(other)
详情请参考 :func:`mindspore.ops.logical_and`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.logical_not.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.logical_not
============================
.. py:method:: mindspore.Tensor.logical_not()
详情请参考 :func:`mindspore.ops.logical_not`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.logical_or.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.logical_or
===========================
.. py:method:: mindspore.Tensor.logical_or(other)
详情请参考 :func:`mindspore.ops.logical_or`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.logical_xor.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.logical_xor
============================
.. py:method:: mindspore.Tensor.logical_xor(other)
详情请参考 :func:`mindspore.ops.logical_xor`。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.searchsorted.rst
View File

@ -3,15 +3,15 @@ mindspore.Tensor.searchsorted
.. py:method:: mindspore.Tensor.searchsorted(v, side='left', sorter=None)
查找应插入元素以保存顺序的位置索引。
查找应插入元素在有序数列中的位置索引。
参数：
- **v** (Union[int, float, bool, list, tuple, Tensor]) - 要插入元素的值。
- **side** ('left', 'right', 可选) - 如果参数值为'left'，则给出找到的第一个合适位置的索引。如果参数值为'right'，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是Tensor的长度）。默认值：'left'。
- **side** (str, 可选) - 如果参数值为'left'，则给出找到的第一个合适位置的索引。如果参数值为'right'，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是Tensor的长度）。默认值：'left'。
- **sorter** (Union[int, float, bool, list, tuple, Tensor]) - 整数索引的可选一维数组，将Tensor按升序排序。它们通常是NumPy argsort方法的结果。默认值：None。
返回：
Tensor，shape与 `v` 相同的插入点数组。
异常：
- **ValueError** - `side` 或 `sorter` 的参数无效。
- **ValueError** - `side` 或 `sorter` 的参数无效。

4
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.sigmoid.rst
View File

@ -13,10 +13,8 @@ mindspore.Tensor.sigmoid
其中 :math:`x_i` 是原Tensor的元素。
关于Sigmoid的图例见 `Sigmoid <https://en.wikipedia.org/wiki/Sigmoid_function#/media/File:Logistic-curve.svg>`_ 。
返回：
Tensor，数据类型和shape与原Tensor的相同。
异常：
- **TypeError** - 原Tensor的数据类型不是float16、float32、float64、complex64或complex128。
- **TypeError** - 原Tensor的数据类型不是float16、float32、float64、complex64或complex128。

6
docs/api/api_python/mindspore/Tensor/mindspore.Tensor.unfold.rst Normal file
View File

@ -0,0 +1,6 @@
mindspore.Tensor.unfold
=======================
.. py:method:: mindspore.Tensor.unfold(kernel_size, dilation=1, padding=0, stride=1)
详情请参考 :func:`mindspore.ops.unfold`。

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

@ -5,19 +5,4 @@
确定输入Tensor每个位置上的元素是否为无穷大或无穷小。
.. math::
out_i = \begin{cases}
& \text{ if } x_{i} = \text{Inf},\ \ True \\
& \text{ if } x_{i} \ne \text{Inf},\ \ False
\end{cases}
其中 :math:`Inf` 表示不是一个数字。
输入：
- **x** (Tensor) - IsInf的输入，shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度。
输出：
Tensor，shape与相同的输入，数据的类型为bool。
异常：
- **TypeError** - 如果 `x` 不是Tensor。
更多参考详见 :func:`mindspore.ops.isinf`。

28
docs/api/api_python/ops/mindspore.ops.func_addr.rst Normal file
View File

@ -0,0 +1,28 @@
mindspore.ops.addr
==================
.. py:function:: mindspore.ops.addr(x, vec1, vec2, beta=1, alpha=1)
计算 `vec1` 和 `vec2` 的外积，并将其添加到 `x` 中。
如果 `vec1` 是一个大小为 :math:`N` 的向量， `vec2` 是一个大小为 :math:`M` 的向量，那么 `x` 必须是可广播的，且
带有一个大小为 :math:`(N, M)` 的矩阵，同时返回是一个大小为 :math:`(N, M)` 的矩阵。
可选值 `bata` 和 `alpha` 分别是 `vec1` 和 `vec2` 外积的扩展因子以及附加矩阵 `x` 。如果 `beta` 为0，那么 `x` 将被忽略。
.. math::
output = β x + α (vec1 ⊗ vec2)
参数：
- **vec1** (Tensor) - 第一个需要相乘的Tensor，shape大小为 :math:`(N,)` 。
- **vec2** (Tensor) - 第二个需要相乘的Tensor，shape大小为 :math:`(M,)` 。
- **beta** (scalar[int, float, bool], 可选) - `x` (β)的乘法器。 `beta` 必须是int或float或bool类型，默认值：1。
- **alpha** (scalar[int, float, bool], 可选) - `vec1` ⊗ `vec2` (α)的乘法器。 `alpha` 必须是int或float或bool类型，默认值：1。
返回：
Tensor，shape大小为 :math:`(N, M)` ，数据类型与 `x` 相同。
异常：
- **TypeError** - `x` 、 `vec1` 、 `vec2` 不是Tensor。
- **TypeError** - `x` 、 `vec1` 、 `vec2` 的数据类型不一致。
- **ValueError** - 如果 `x` 不是一个二维Tensor。如果 `vec1` ， `vec2` 不是一个一维Tensor。

12
docs/api/api_python/ops/mindspore.ops.func_bartlett_window.rst
View File

@ -1,7 +1,7 @@
mindspore.ops.bartlett_window
=============================
.. py:function:: mindspore.ops.bartlett_window(window_length, periodic=True, *, dtype=mstype.float32)
.. py:function:: mindspore.ops.bartlett_window(window_length, periodic=True, *, dtype=None)
巴特利特窗口函数。
@ -14,19 +14,17 @@ mindspore.ops.bartlett_window
2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
\end{cases},
\text{where : N is the full window size.}
其中，N是总的窗口长度 `window_length` ，n为小于N的自然数 [0, 1, ..., N-1]。
其中，N是总的窗口长度 `window_length` 。
参数：
- **window_length** (Tensor) - 返回窗口的大小，数据类型为int32，int64。输入数据的值为[0,1000000]的整数。
- **window_length** (Tensor) - 返回窗口的大小，数据类型为int32，int64。输入数据的值为[0, 1000000]的整数。
- **periodic** (bool，可选) - 如果为True，返回一个窗口作为周期函数使用。如果为False，返回一个对称窗口。默认值：True。
关键字参数：
- **dtype** (mindspore.dtype，可选) - 输出数据类型，目前只支持float16、float32和float64。默认值：mindspore.float32。
- **dtype** (mindspore.dtype，可选) - 输出数据类型，目前只支持float16、float32和float64。默认值：None。
返回：
1D Tensor，大小为 `window_length` ，数据类型与 `dtype` 一致。
1D Tensor，大小为 `window_length` ，数据类型与 `dtype` 一致。如果 `dtype` 为None，则数据类型为float32。
异常：
- **TypeError** - `window_length` 不是Tensor。

4
docs/api/api_python/ops/mindspore.ops.func_blackman_window.rst
View File

@ -13,14 +13,14 @@ mindspore.ops.blackman_window
其中，N是总的窗口长度 `window_length` ，n为小于N的自然数 [0, 1, ..., N-1]。
参数：
- **window_length** (Tensor) - 返回窗口的大小，数据类型为int32，int64。输入数据的值为[0,1000000]的整数。
- **window_length** (Tensor) - 返回窗口的大小，数据类型为int32，int64。输入数据的值为[0, 1000000]的整数。
- **periodic** (bool，可选) - 如果为True，返回一个窗口作为周期函数使用。如果为False，返回一个对称窗口。默认值：True。
关键字参数：
- **dtype** (mindspore.dtype，可选) - 输出数据类型，目前只支持float16、float32和float64。默认值：None。
返回：
1D Tensor，大小为 `window_length` ，数据类型与 `dtype` 一致。
1D Tensor，大小为 `window_length` ，数据类型与 `dtype` 一致。如果 `dtype` 为None，则数据类型为float32。
异常：
- **TypeError** - `window_length` 不是Tensor。

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

@ -8,18 +8,19 @@ mindspore.ops.elu
对输入的每个元素计算ELU。该激活函数定义如下：
.. math::
\text{ELU}(x)= \left\{
\begin{array}{align}
\alpha(e^{x} - 1) & \text{if } x \le 0\\
x & \text{if } x \gt 0\\
\end{array}\right.
其中，:math:`x` 表示输入的元素，:math:`\alpha` 表示 `alpha` 参数， `alpha` 决定ELU的平滑度。
其中，:math:`x` 表示输入Tensor `input_x` ，:math:`\alpha` 表示 `alpha` 参数， `alpha` 决定ELU的平滑度。
ELU相关图参见 `ELU <https://en.wikipedia.org/wiki/Activation_function#/media/File:Activation_elu.svg>`_ 。
参数：
- **input_x** (Tensor) - ELU的输入，为任意维度的Tensor，数据类型为float16或float32。
- **alpha** (float) - ELU的alpha值，数据类型为浮点数，目前仅支持1.0。默认值：1.0。
- **alpha** (float) - ELU的alpha值，数据类型为float，目前仅支持1.0。默认值：1.0。
返回：
Tensor，输出的shape、数据类型与 `input_x` 相同。

13
docs/api/api_python/ops/mindspore.ops.func_greater.rst Normal file
View File

@ -0,0 +1,13 @@
mindspore.ops.greater
=====================
.. py:function:: mindspore.ops.greater(input, other)
按元素比较输入参数 :math:`input > other` 的值，输出结果为bool值。
参数：
- **input** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 的Tensor。
- **other** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。
返回：
Tensor，shape与广播后的shape相同，数据类型为bool。

13
docs/api/api_python/ops/mindspore.ops.func_greater_equal.rst Normal file
View File

@ -0,0 +1,13 @@
mindspore.ops.greater_equal
===========================
.. py:function:: mindspore.ops.greater_equal(input, other)
按元素比较输入参数 :math:`input >= other` 的值，输出结果为bool值。
参数：
- **input** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 的Tensor。
- **other** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二>个输入必须是数据类型为number或bool_的Tensor。
返回：
Tensor，shape与广播后的shape相同，数据类型为bool。

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

@ -0,0 +1,35 @@
mindspore.ops.igamma
====================
.. py:function:: mindspore.ops.igamma(input, other)
计算正规化的下层不完全伽马函数。
如果我们将 `input` 比作 `a` ， `other` 比作 `x` ，则正规化的下层不完全伽马函数可以表示成：
.. math::
P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)
其中，
.. math::
gamma(a, x) = \int_0^x t^{a-1} \exp^{-t} dt
为下层不完全伽马函数。
:math:`Q(a, x)` 则为正规化的上层完全伽马函数。
.. warning::
这是一个实验原型，可以更改和/或删除。
参数：
- **input** (Tensor) - 输入Tensor，数据类型为float32或者float64。
- **other** (Tensor) - 输入Tensor，数据类型为float32或者float64，与 `input` 保持一致。
返回：
Tensor，数据类型与 `input` 和 `other` 相同。
异常：
- **TypeError** - 如果 `input` 或者 `other` 不是Tensor。
- **TypeError** - 如果 `other` 的数据类型不是float32或者float64。
- **TypeError** - 如果 `other` 的数据类型与 `input` 不相同。
- **ValueError** - 如果 `input` 不能广播成shape与 `other` 相同的Tensor。

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

@ -0,0 +1,35 @@
mindspore.ops.igammac
=====================
.. py:function:: mindspore.ops.igammac(input, other)
计算正规化的上层不完全伽马函数。
如果我们将 `input` 比作 `a` ， `other` 比作 `x` ，则正规化的下层不完全伽马函数可以表示成：
.. math::
\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\)
其中，
.. math::
\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\)
为上层不完全伽马函数。
:math:`P(a, x)` 则为正规化的下层完全伽马函数。
.. warning::
这是一个实验原型，可以更改和/或删除。
参数：
- **input** (Tensor) - 输入Tensor，数据类型为float32或者float64。
- **other** (Tensor) - 输入Tensor，数据类型为float32或者float64，与 `input` 保持一致。
返回：
Tensor，数据类型与 `input` 和 `other` 相同。
异常：
- **TypeError** - 如果 `input` 或者 `other` 不是Tensor。
- **TypeError** - 如果 `other` 的数据类型不是float32或者float64。
- **TypeError** - 如果 `other` 的数据类型与 `input` 不相同。
- **ValueError** - 如果 `input` 不能广播成shape与 `other` 相同的Tensor。

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

@ -0,0 +1,23 @@
mindspore.ops.isinf
===================
.. py:function:: mindspore.ops.isinf(input)
确定输入Tensor每个位置上的元素是否为无穷大或无穷小。
.. math::
out_i = \begin{cases}
& \text{ if } x_{i} = \text{Inf},\ \ True \\
& \text{ if } x_{i} \ne \text{Inf},\ \ False
\end{cases}
其中 :math:`Inf` 表示不是一个数字。
参数：
- **input** (Tensor) - IsInf的输入，shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度。
返回：
Tensor，shape与相同的输入，数据的类型为bool。
异常：
- **TypeError** - 如果 `input` 不是Tensor。

20
docs/api/api_python/ops/mindspore.ops.func_logical_xor.rst Normal file
View File

@ -0,0 +1,20 @@
mindspore.ops.logical_xor
=========================
.. py:function:: mindspore.ops.logical_xor(input, other)
逐元素计算两个Tensor的逻辑异或运算。
.. math::
out_{i} = x_{i} \oplus y_{i}
参数：
- **input** (Tensor) - 第一个输入是数据类型为bool的Tensor。
- **other** (Tensor) - 第二个输入是Tesor，与第一个输入进行异或计算，其中数据类型为bool。
返回：
Tensor，其shape与广播后的shape相同，数据类型为bool。
异常：
- **TypeError** - 如果 `input` 或 `other` 不是数据类型为bool的Tensor。
- **ValueError** - 如果两个输入的shape不能被广播。

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

@ -0,0 +1,21 @@
mindspore.ops.mse_loss
======================
.. py:function:: mindspore.ops.mse_loss(input_x, target, reduction='mean')
计算预测值和标签值之间的均方误差。
更多参考详见 :class:`mindspore.nn.MSELoss`。
参数：
- **input_x** (Tensor) - 任意维度的Tensor。
- **target** (Tensor) - 输入标签，任意维度的Tensor。大多数场景下与 `input_x` 具有相同的shape。
但是，也支持在两者shape不相同的情况下，通过广播保持一致。
- **reduction** (str，可选) - 对loss应用特定的缩减方法。可选"mean"、"none"、"sum"。默认值："mean"
返回：
Tensor，数据类型为float，如果 `reduction` 为 'mean'或'sum'时，shape为0；如果 `reduction` 为 'none'，输入的shape则是广播之后的shape。
异常：
- **ValueError** - 如果 `reduction` 的值不是以下其中之一时：'none'、 'mean'、 'sum'。
- **ValueError** - 如果 `input_x` 和 `target` 的shape不相同且无法广播。

1
docs/api/api_python_en/mindspore.ops.function.rst
View File

@ -154,6 +154,7 @@ Element-by-Element Operations
mindspore.ops.addcdiv
mindspore.ops.addcmul
mindspore.ops.addn
mindspore.ops.addr
mindspore.ops.arccos
mindspore.ops.arccosh
mindspore.ops.arcsin

69
mindspore/python/mindspore/common/tensor.py
View File

@ -919,33 +919,8 @@ class Tensor(Tensor_):
def addcdiv(self, x1, x2, value):
r"""
Performs the element-wise division of tensor x1 by tensor x2,
multiply the result by the scalar value and add it to input_data.
.. math::
y[i] = input\_data[i] + value[i] * (x1[i] / x2[i])
Args:
x1 (Tensor): The numerator tensor.
x2 (Tensor): The denominator tensor.
value (Tensor): The multiplier for tensor x1/x2.
Returns:
Tensor, has the same shape and dtype as x1/x2.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> x = Tensor(np.array([1, 1, 1, 1]), mindspore.float32)
>>> x1 = Tensor(np.array([1, 2, 3, 4]), mindspore.float32)
>>> x2 = Tensor(np.array([4, 3, 2, 1]), mindspore.float32)
>>> value = Tensor([1], mindspore.float32)
>>> y = x.addcdiv(x1, x2, value)
>>> print(y)
[1.25 1.6666667 2.5 5. ]
For details, please refer to :func:`mindspore.ops.addcdiv`.
"""
self._init_check()
return tensor_operator_registry.get('addcdiv')()(self, x1, x2, value)
@ -1044,48 +1019,8 @@ class Tensor(Tensor_):
def addr(self, vec1, vec2, beta=1, alpha=1):
r"""
Executes the outer-product of `vec1` and `vec2` and adds it to the input tensor.
If `vec1` is a vector of size :math:`N` and `vec2` is a vector of size :math:`M`, then `x` must be
broadcastable with a matrix of size :math:`(N, M)` and `out` will be a matrix of size :math:`(N, M)`.
The optional values `beta` and `alpha` are the scale factors on the outer product between `vec1` and `vec2`
and the added matrix `x` respectively. If `beta` is 0, then `x` will be ignored.
.. math::
output = β x + α (vec1 ⊗ vec2)
Args:
vec1 (Tensor): The first tensor to be multiplied. The shape of the tensor is :math:`(N,)`.
vec2 (Tensor): The second tensor to be multiplied. The shape of the tensor is :math:`(M,)`.
beta (scalar[int, float, bool], optional): Multiplier for `x` (β). The `beta` must be int or
float or bool, Default: 1.
alpha (scalar[int, float, bool], optional): Multiplier for `vec1` @ `vec2` (α). The `alpha` must
be int or float or bool, Default: 1.
Returns:
Tensor, the shape of the output tensor is :math:`(N, M)`, has the same dtype as `x`.
Raises:
TypeError: If `x`, `vec1`, `vec2` is not a Tensor.
TypeError: If inputs `x`, `vec1`, 'vec2' are not the same dtype.
ValueError: If `x` is not a 2-D Tensor.
If `vec1`, `vec2` is not a 1-D Tensor.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> x = Tensor(np.array([[2., 2.], [3., 2.], [3., 4.]], np.float32))
>>> vec1 = Tensor(np.array([2., 3., 2.], np.float32))
>>> vec2 = Tensor(np.array([3, 4], np.float32))
>>> output = x.addr(vec1, vec2)
>>> print(output)
[[ 8. 10.]
[12. 14.]
[ 9. 12.]]
For details, please refer to :func:`mindspore.ops.addr`.
"""
self._init_check()
return tensor_operator_registry.get('addr')(self, vec1, vec2, beta=beta, alpha=alpha)

31
mindspore/python/mindspore/ops/function/math_func.py
View File

@ -3961,13 +3961,13 @@ def adjoint(x):
def addr(x, vec1, vec2, beta=1, alpha=1):
"""
Executes the outer-product of `vec1` and `vec2` and adds it to the vec1rix `x`.
Executes the outer-product of `vec1` and `vec2` and adds it to the matrix `x`.
If `vec1` is a vector of size :vec1:`N` and `vec2` is a vector of size :vec1:`M`, then `x` must be broadcastable
with a vec1rix of size :vec1:`(N, M)` and `out` will be a vec1rix of size :vec1:`(N, M)`.
with a matrix of size :vec1:`(N, M)` and `out` will be a matrix of size :vec1:`(N, M)`.
The optional values `beta` and `alpha` are the scale factors on the outer product between `vec1` and `vec2`
and the added vec1rix `x` respectively. If `beta` is 0, then `x` will be ignored.
and the added matrix `x` respectively. If `beta` is 0, then `x` will be ignored.
.. vec1::
output = β x + α (vec1 ⊗ vec2)
@ -3978,7 +3978,7 @@ def addr(x, vec1, vec2, beta=1, alpha=1):
vec2 (Tensor): The second tensor to be multiplied. The shape of the tensor is :vec1:`(M,)`.
beta (scalar[int, float, bool], optional): Multiplier for `x` (β). The `beta` must be int or
float or bool, Default: 1.
alpha (scalar[int, float, bool], optional): Multiplier for `vec1` @ `vec2` (α). The `alpha` must
alpha (scalar[int, float, bool], optional): Multiplier for `vec1` ⊗ `vec2` (α). The `alpha` must
be int or float or bool, Default: 1.
Outputs:
@ -7029,15 +7029,16 @@ def greater_equal(input, other):
def igamma(input, other):
r"""
Calculates lower regularized incomplete Gamma function.
If we define `input` as `a` and `other` as `x`, the lower regularized incomplete Gamma function is defined as:
.. math::
P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)
\(P(a, x) = Gamma(a, x) / Gamma(a) = 1 - Q(a, x)\)
where
.. math::
gamma(a, x) = \int_0^x t^{a-1} \exp^{-t} dt
\(Gamma(a, x) = \int_0^x t^{a-1} \exp^{-t} dt\)
is the lower incomplete Gamma function.
@ -7051,7 +7052,7 @@ def igamma(input, other):
other (Tensor): The second input tensor. With float32 or float64 type. `other` should have
the same dtype with `input`.
Outputs:
Returns:
Tensor, has the same dtype as `input` and `other`.
Raises:
@ -7079,12 +7080,18 @@ def igammac(input, other):
Calculates upper regularized incomplete Gamma function.
If we define `input` as `a` and `other` as `x`, the upper regularized incomplete Gamma function is defined as:
\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\)
.. math::
\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\)
where
\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\)
.. math::
\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\)
is the upper incomplete Gama function.
Note, above P(a, x) (Igamma) is the lower regularized complete Gamma function.
Above :math:`P(a, x)` is the lower regularized complete Gamma function.
.. warning::
This is an experimental prototype that is subject to change and/or deletion.
@ -7094,7 +7101,7 @@ def igammac(input, other):
other (Tensor): The second input tensor. With float32 or float64 type. `other` should have
the same dtype with `input`.
Outputs:
Returns:
Tensor, has the same dtype as `input` and `other`.
Raises:
@ -7163,7 +7170,7 @@ def logical_xor(input, other):
Args:
input (Tensor): The first input is a tensor whose data type is bool.
other (Tensor): The second input is a the tensor to compute XOR with the first input.
other (Tensor): The second input is a tensor to compute XOR with the first input.
Datatype must be bool.
Returns:

10
mindspore/python/mindspore/ops/function/nn_func.py
View File

@ -4464,7 +4464,7 @@ def elu(input_x, alpha=1.0):
x & \text{if } x \gt 0\\
\end{array}\right.
Where :math:`x` is the element of input Tensor, :math:`\alpha` is param `alpha`,
Where :math:`x` is the element of input Tensor `input_x`, :math:`\alpha` is param `alpha`,
it determines the smoothness of ELU.
The picture about ELU looks like this `ELU <https://en.wikipedia.org/wiki/
Activation_function#/media/File:Activation_elu.svg>`_ .
@ -4733,10 +4733,10 @@ def mse_loss(input_x, target, reduction='mean'):
Args:
input_x (Tensor): Tensor of any dimension.
target (Tensor): The input label. Tensor of any dimension, same shape as the `input_x` in common cases.
However, it supports that the shape of `input_x` is different from the shape of `target`
and they should be broadcasted to each other.
reduction (str): Type of reduction to be applied to loss. The optional values are "mean", "none" and "sum".
Default: "mean".
However, it supports that the shape of `input_x` is different from the shape of `target`
and they should be broadcasted to each other.
reduction (str, optional): Type of reduction to be applied to loss.
The optional values are "mean", "none" and "sum". Default: "mean".
Returns:
Tensor, loss of type float, the shape is zero if `reduction` is 'mean' or 'sum',

8
mindspore/python/mindspore/ops/function/spectral_func.py
View File

@ -43,7 +43,7 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
periodic (bool, optional): If True, returns a window to be used as periodic function.
If False, return a symmetric window. Default: True.
Keyword args:
Keyword Args:
dtype (mindspore.dtype, optional): the desired data type of returned tensor.
Only float16, float32 and float64 is allowed. Default: None.
@ -56,7 +56,7 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
TypeError: If `periodic` is not a bool.
TypeError: If `dtype` is not one of: float16, float32, float64.
TypeError: If the type of `window_length` is not one of: int32, int64.
ValueError: If the value range of `window_length` is not [0,1000000].
ValueError: If the value range of `window_length` is not [0, 1000000].
ValueError: If the dimension of `window_length` is not 0.
Supported Platforms:
@ -103,7 +103,7 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
periodic (bool, optional): If True, returns a window to be used as periodic function.
If False, return a symmetric window. Default: True.
Keyword args:
Keyword Args:
dtype (mindspore.dtype, optional): The desired datatype of returned tensor.
Only float16, float32 and float64 are allowed. Default: None.
@ -116,7 +116,7 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
TypeError: If the type of `window_length` is not one of: int32, int64.
TypeError: If `periodic` is not a bool.
TypeError: If `dtype` is not one of: float16, float32, float64.
ValueError: If the value range of `window_length` is not [0,1000000].
ValueError: If the value range of `window_length` is not [0, 1000000].
ValueError: If the dimension of `window_length` is not 0.
Supported Platforms: