mindspore 2.4.1__cp39-none-any.whl → 2.5.0__cp39-none-any.whl

mindspore/ops/operations/math_ops.py

@@ -31,16 +31,17 @@ from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWith
 from mindspore._c_expression import Tensor as Tensor_
 from ..auto_generate import (Add, Addcdiv, Addcmul, 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.
@@ -1907,41 +1812,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 +1848,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,7 +1914,7 @@ 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.
 
 
@@ -2608,6 +2442,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 +3263,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 +3275,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.
@@ -4595,47 +4431,6 @@ 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