mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/operations/math_ops.py

@@ -28,19 +28,20 @@ from mindspore.common import dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore.ops._utils import get_broadcast_shape
 from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register, _run_op
-from mindspore._c_expression import Tensor as Tensor_
-from ..auto_generate import (Add, Addcdiv, Addcmul, ReduceMean, ReduceSum, ReduceAll, ReduceAny,
+from mindspore._c_expression import TensorPy as Tensor_
+from ..auto_generate import (Add, Addcdiv, AddcdivExt, Addcmul, AddcmulExt, ReduceMean, ReduceSum, ReduceAll, ReduceAny,
                              ReduceMax, ReduceMin, ReduceProd, Betainc, Neg, MatMul, BatchMatMul,
-                             Mul, Square, Rsqrt, Sqrt, Reciprocal, Pow, Exp,
+                             Mul, Square, Rsqrt, Sqrt, Reciprocal, Pow, Exp, Cdist,
                              Logit, ReduceStd, Expm1, Log, Log1p, Erf, Erfc,
                              Minimum, RealDiv, FloorDiv, Floor, FloorMod, Ceil,
                              Acosh, Cosh, Asinh, Sinc, Sinh, Equal, NotEqual,
                              Greater, GreaterEqual, Gcd, LogicalNot, LogicalAnd, LogicalOr,
-                             LogicalXor, Cos, ACos, Sin, Asin, Abs, Round, Atan, Atanh, Atan2,
+                             LogicalXor, Cos, ACos, Sin, Asin, Abs, Round, Atan, Atanh, Atan2, AssignSub,
                              LinSpace, MatrixDeterminant, LogMatrixDeterminant, Erfinv, Conj,
                              Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky, Cross,
                              FFTWithSize, NextAfter, NanToNum, Eig, Qr, Roll, Maximum, Div, DivMod, CumProd,
-                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad, Xlogy, Trunc, Sign)
+                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad, Xlogy, Trunc, Sign, Polar,
+                             IsInf, Lerp, LerpScalar)
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
@@ -250,58 +251,6 @@ class AddV2(Primitive):
         self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
 
 
-class AssignSub(Primitive):
-    """
-    Updates a `Parameter` by subtracting a value from it.
-
-    Refer to :func:`mindspore.ops.assign_sub` for more details.
-
-    Inputs:
-        - **variable** (Parameter) - The `Parameter`.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank be should be less than 8.
-        - **value** (Union[numbers.Number, Tensor]) - The value to be subtracted from the `variable`.
-          It must have the same shape as `variable` if it is a Tensor.
-
-    Outputs:
-        Tensor, has the same data type and shape as original `variable`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops, nn
-        >>> from mindspore.common.initializer import initializer
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.AssignSub = ops.AssignSub()
-        ...         self.variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
-        ...
-        ...     def construct(self, x):
-        ...         self.AssignSub(self.variable, x)
-        ...         return self.variable
-        ...
-        >>> net = Net()
-        >>> value = Tensor(np.ones([1]).astype(np.int32)*100)
-        >>> output = net(value)
-        >>> print(net.variable.asnumpy())
-        [-99]
-    """
-
-    __mindspore_signature__ = (
-        sig.make_sig('val', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
-        sig.make_sig('value', dtype=sig.sig_dtype.T)
-    )
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize AssignSub"""
-        self.init_prim_io_names(inputs=['val', 'value'], outputs=['val'])
-        self.add_prim_attr('side_effect_mem', True)
-
-
 class _Reduce(PrimitiveWithCheck):
     """
     Definition of base class of reduction class operators.
@@ -551,50 +500,6 @@ class Lcm(Primitive):
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
 
 
-class Cdist(Primitive):
-    """
-    Computes batched the p-norm distance between each pair of the two collections of row vectors.
-
-    Refer to :func:`mindspore.ops.cdist` for more details.
-
-    Args:
-        p (float, optional): P value for the p-norm distance to calculate between each vector pair, P ∈ [0,∞].
-            Default: ``2.0`` .
-
-    Inputs:
-        - **input_x** (Tensor) - Input tensor of shape :math:`(B, P, M)`.
-          When :math:`B` is equal to 0, it means this dimension can be ignored,
-          i.e. shape of the tensor is :math:`(P, M)`.
-        - **input_y** (Tensor) - Input tensor of shape :math:`(B, R, M)` with the same dtype as `input_x`.
-
-    Outputs:
-        Tensor, has the same dtype as `input_x`, which shape is :math:`(B, P, R)`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[[1.0, 1.0], [2.0, 2.0]]]).astype(np.float32))
-        >>> input_y = Tensor(np.array([[[3.0, 3.0], [3.0, 3.0]]]).astype(np.float32))
-        >>> op = ops.Cdist(p=2.0)
-        >>> output = op(input_x, input_y)
-        >>> print(output)
-        [[[2.8284273 2.8284273]
-          [1.4142137 1.4142137]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, p=2.0):
-        """Initialize Cdist"""
-        validator.check_value_type("p", p, [float], self.name)
-        if (p < 0 or np.isnan(p)):
-            raise ValueError('Cdist p must be a non-negative value, but got `{p}`.')
-        self.init_prim_io_names(inputs=['input_x', 'input_y'], outputs=['output'])
-
-
 class LpNorm(Primitive):
     r"""
     Return the p-norm of a matrix or vector.
@@ -874,8 +779,8 @@ class InplaceIndexAdd(Primitive):
         axis (int): The dimension along which to index. It should be in range :math:`[0, len(var.dim))`.
 
     Inputs:
-        - **var** (Parameter) - The input Parameter to add to, with data type uint8, int8, int16, int32,
-          float16, float32, float64.
+        - **var** (Union[Parameter, Tensor]) - The input Parameter or Tensor to add to, with data type uint8, int8,
+          int16, int32, float16, float32, float64.
         - **indices** (Tensor) - The indies along `axis` to perform the addition. A 1D Tensor
           of shape :math:`(updates.shape[axis],)`, every value of it
           should be in range :math:`[0, var.shape[axis])` with data type int32.
@@ -914,6 +819,7 @@ class InplaceIndexAdd(Primitive):
         """Initialize InplaceIndexAdd"""
         self.init_prim_io_names(inputs=['var', 'indices', 'updates'], outputs=['var'])
         self.axis = axis
+        self.add_prim_attr('side_effect_mem', True)
         validator.check_value_type('axis', axis, [int], self.name)
 
 
@@ -1223,7 +1129,7 @@ class Histogram(Primitive):
 class HistogramFixedWidth(PrimitiveWithInfer):
     """
     Returns a rank 1 histogram counting the number of entries in values that fall into every bin. The bins are equal
-    width and determined by the inputs `range` and the arguments `nbins`.
+    width and determined by the input `range` and the argument `nbins`.
 
     Args:
         nbins (int): The number of histogram bins, the type is a positive integer.
@@ -1444,7 +1350,7 @@ class MulNoNan(_MathBinaryOp):
           int32, int64, float16, float32, float64, complex64, complex128 currently or scalar.
 
     Outputs:
-        Tensor, the shape is the same as the shape after broadcasting,
+        Tensor, the shape is the same as the shape of input Tensor after broadcasting,
         and the data type is the one with higher precision among the two inputs.
 
     Raises:
@@ -1830,7 +1736,8 @@ class ApproximateEqual(_LogicBinaryOp):
     the relatively highest precision data type.
 
     Args:
-        tolerance (float): The maximum deviation that two elements can be considered equal. Default: ``1e-05`` .
+        tolerance (float, optional): The maximum deviation that two elements can be considered equal.
+            Default: ``1e-05`` .
 
     Inputs:
         - **x** (Tensor) - A tensor. Must be one of the following types: float32, float16.
@@ -1907,41 +1814,6 @@ class EqualCount(PrimitiveWithInfer):
         self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
 
 
-class Lerp(Primitive):
-    """
-    Does a linear interpolation of two tensors start and end based on a float or tensor weight.
-
-    Refer to :func:`mindspore.ops.lerp` for more details.
-
-    Inputs:
-        - **start** (Tensor) - The tensor with the starting points. Data type must be float16, float32 or float64.
-        - **end** (Tensor) - The tensor with the ending points. Data type must be the same as `start`.
-        - **weight** (Union[float, Tensor]) - The weight for the interpolation formula. Must be a float
-          or a scalar tensor with float16 or float32 data type.
-
-    Outputs:
-        Tensor, has the same type and shape as input `start`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> start = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
-        >>> end = Tensor(np.array([10., 10., 10., 10.]), mindspore.float32)
-        >>> lerp = ops.Lerp()
-        >>> output = lerp(start, end, 0.5)
-        >>> print(output)
-        [5.5 6. 6.5 7. ]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        self.init_prim_io_names(inputs=['start', 'end', 'weight'], outputs=['output'])
-
-
 class IsNan(Primitive):
     r"""
     Determines which elements are NaN for each position.
@@ -1978,42 +1850,6 @@ class IsNan(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
-class IsInf(Primitive):
-    r"""
-    Determines which elements are inf or -inf for each position.
-
-    Refer to :func:`mindspore.ops.isinf` for more details.
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-
-    Outputs:
-        Tensor, has the same shape of input, and the dtype is bool.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> is_inf = ops.IsInf()
-        >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
-        >>> output = is_inf(x)
-        >>> print(output)
-        [False False True]
-        >>> x = Tensor(2.1, mindspore.float64)
-        >>> output = is_inf(x)
-        >>> print(output)
-        False
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize IsInf"""
-        self.init_prim_io_names(inputs=['x'], outputs=['output'])
-
-
 class FloatStatus(Primitive):
     """
     Determines if the elements contain Not a Number(NaN), infinite or negative infinite. 0 for normal, 1 for overflow.
@@ -2080,17 +1916,17 @@ class NPUAllocFloatStatus(Primitive):
 
 class NPUGetFloatStatus(Primitive):
     """
-    `mindspore.ops.NPUGetFloatStatus` updates the flag which is
+    :class:`mindspore.ops.NPUGetFloatStatus` updates the flag which is
     the output tensor of :class:`mindspore.ops.NPUAllocFloatStatus` with the latest overflow status.
 
-
     Note:
         The flag is a tensor whose shape is :math:`(8,)` and data type is `mindspore.dtype.float32`.
         If the sum of the flag equals to 0, there is no overflow happened. If the sum of the
         flag is bigger than 0, there is overflow happened.
         In addition, there are strict sequencing requirements for use, i.e., before
         using the NPUGetFloatStatus operator, need to ensure that the NPUClearFlotStatus
-        and your compute has been executed. We use :class:`mindspore.ops.Depend` to ensure the execution order.
+        and your compute has been executed. We use :class:`mindspore.ops.Depend`
+        to ensure the correct execution order.
 
     Inputs:
         - **x** (Tensor) - The output tensor of `NPUAllocFloatStatus`.
@@ -2098,7 +1934,7 @@ class NPUGetFloatStatus(Primitive):
           :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
 
     Outputs:
-        Tensor, has the same shape as `x`. All the elements in the tensor will be zero.
+        Tensor, has the same shape as `x`.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -2608,6 +2444,9 @@ class BitwiseXor(_BitwiseBinaryOp):
     r"""
     Returns bitwise `xor` of two tensors element-wise.
 
+    .. warning::
+        This API has poor performance on CPU and it is recommended to run it on the Ascend/GPU.
+
     Refer to :func:`mindspore.ops.bitwise_xor` for more details.
 
     Inputs:
@@ -3426,7 +3265,7 @@ class IndexAdd(Primitive):
             don't check index boundary. Default: ``True`` .
 
     Inputs:
-        - **x** (Parameter) - The input Parameter to add to.
+        - **x** (Union[Parameter, Tensor]) - The input Parameter or Tensor to add to.
         - **indices** (Tensor) - Add the value of `x` and `y` along the dimension of the `axis` according to the
           specified index value, with data type int32.
           The `indices` must be 1D with the same size as the size of `y` in the `axis` dimension. The values
@@ -3438,7 +3277,6 @@ class IndexAdd(Primitive):
         Tensor, has the same shape and dtype as `x`.
 
     Raises:
-        TypeError: If `x` is not a Parameter.
         TypeError: If neither `indices` nor `y` is a Tensor.
         ValueError: If axis is out of `x` rank's range.
         ValueError: If `x` rank is not the same as `y` rank.
@@ -3550,9 +3388,8 @@ class Imag(Primitive):
 
     Examples:
         >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
+        >>> from mindspore import ops
+        >>> x = mindspore.tensor(1.3+0.4j, mindspore.complex64)
         >>> imag = ops.Imag()
         >>> output = imag(x)
         >>> print(output)
@@ -4053,8 +3890,8 @@ class Digamma(Primitive):
         Tensor, has the same dtype as `x`.
 
     Raises:
-        TypeError: If x is not a Tensor.
-        TypeError: If dtype of input x is not float16 or float32 or float64.
+        TypeError: If `x` is not a Tensor.
+        TypeError: If dtype of input `x` is not float16 or float32 or float64.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -4206,7 +4043,10 @@ class Median(Primitive):
         axis (int, optional): The specified dimension to compute median. Default: ``0`` .
         keep_dims (bool, optional): Whether the output tensor need to retain `axis` dimension or not.
             Default: ``False`` .
-        ignore_nan (bool, optional): Whether to ignore the NaN values in input Tensor. Default: ``False`` .
+        ignore_nan (bool, optional): Whether to ignore the ``NaN`` values in input Tensor. When ``False``, if the
+            input range (determined by `global_median`) contains a ``NaN`` value, the corresponding element of
+            `values` is ``NaN``. When ``True``, calculates the median of the remaining elements after excluding
+            ``NaN``. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - A Tensor to calculate median with.
@@ -4595,51 +4435,9 @@ class CholeskySolve(Primitive):
         validator.check_value_type('upper', upper, [bool], self.name)
 
 
-class Polar(Primitive):
-    r"""
-    Converts polar coordinates to Cartesian coordinates.
-
-    Refer to :func:`mindspore.ops.polar` for more details.
-
-    Inputs:
-        - **abs** (Tensor) - Radial distance. Tensor of any dimension,
-          must be one of the following types: float32, float64.
-
-        - **angle** (Tensor) - Polar angle. It has the same shape and dtype as `abs`.
-
-    Outputs:
-        Tensor, has the same shape and data type as `abs`.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> polar = ops.Polar()
-        >>> x1 = Tensor(np.array([1, 2]), mindspore.float64)
-        >>> x2 = Tensor(np.array([3, 4]), mindspore.float64)
-        >>> output = polar(x1, x2)
-        >>> print(output)
-        [-0.9899925 +0.14112001j -1.30728724-1.51360499j]
-        >>> x1 = Tensor(2.1, mindspore.float32)
-        >>> x2 = Tensor(2.1, mindspore.float32)
-        >>> output = polar(x1, x2)
-        >>> print(output)
-        (-1.0601766+1.8127397j)
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Polar"""
-        self.init_prim_io_names(inputs=['abs', 'angle'], outputs=['y'])
-
-
 class TrilIndices(Primitive):
     r"""
-    Calculates the indices of the lower triangular elements in a `row` * `col` matrix
-    and returns them as a 2-by-N Tensor.
+    Computes the indices of the lower triangular elements of a 2D matrix and returns them as a Tensor.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -4840,9 +4638,9 @@ class TriuIndices(Primitive):
             An optional data type of ``mstype.int32`` and ``mstype.int64`` . Default: ``mstype.int32`` .
 
     Outputs:
-        - **y** (Tensor) - indices of the elements in lower triangular part of matrix. The type specified by `dtype`.
+        - **y** (Tensor) - indices of the elements in upper triangular part of matrix. The type specified by `dtype`.
           The shape of output is :math:`(2, tril\_size)`, where :math:`tril\_size` is the number of elements in the
-          lower triangular matrix.
+          upper triangular matrix.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``