mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/ops/operations/_rl_inner_ops.py

@@ -1132,7 +1132,7 @@ class MuxSend(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor
@@ -1190,7 +1190,7 @@ class MuxReceive(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor

mindspore/ops/operations/_scalar_ops.py

@@ -14,487 +14,9 @@
 # ============================================================================
 """Operations for sequence"""
 
-from math import log
 from mindspore.ops.primitive import Primitive, prim_attr_register
-
-
-class ScalarDiv(Primitive):
-    r"""
-    Computes the quotient of dividing the first input scalar by the second input scalar element-wise.
-
-    .. math::
-
-        out_{i} = \frac{x_i}{y_i}
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '/' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is float.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-        ValueError: If `y` is 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarDiv"""
-
-    def __call__(self, x, y):
-        if y == 0:
-            raise ValueError('The divisor could not be zero. But the divisor is zero now.')
-        return x / y
-
-
-class ScalarFloordiv(Primitive):
-    r"""
-    Computes the quotient of dividing the first input scalar by the second input scalar element-wise.
-
-    .. math::
-
-        out_{i} = \frac{x_i}{y_i}
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '//' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is float.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-        ValueError: If `y` is 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarFloordiv"""
-        self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
-
-    def __call__(self, x, y):
-        if y == 0:
-            raise ValueError('The divisor could not be zero. But the divisor is zero now.')
-        return x // y
-
-
-class ScalarAdd(Primitive):
-    r"""
-    Adds two input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarAdd"""
-
-    def __call__(self, x, y):
-        return x + y
-
-
-class ScalarPow(Primitive):
-    r"""
-    Pow two input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarPow"""
-
-    def __call__(self, x, y):
-        return pow(x, y)
-
-
-class ScalarLog(Primitive):
-    r"""
-    Log input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarAdd"""
-
-    def __call__(self, x):
-        return log(x)
-
-
-class ScalarUadd(Primitive):
-    r"""
-    UAdds input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarAdd"""
-
-    def __call__(self, x):
-        return x
-
-
-class ScalarUsub(Primitive):
-    r"""
-    usub input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarUsub"""
-
-    def __call__(self, x):
-        return -x
-
-
-class ScalarSub(Primitive):
-    r"""
-    Subtracts the second input Scalar from the first input Scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '-' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarSub"""
-
-    def __call__(self, x, y):
-        return x - y
-
-
-class ScalarMul(Primitive):
-    r"""
-    Muls two input scalar.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '+' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarMul"""
-
-    def __call__(self, x, y):
-        return x * y
-
-
-class scalar_eq(Primitive):
-    r"""
-    Computes the equivalence between two Scalars.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '==' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is bool.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarEq"""
-
-    def __call__(self, x, y):
-        return x == y
-
-
-class scalar_gt(Primitive):
-    r"""
-    Compare the value of the input scalars :math:`x,y`, and the output result is a bool value.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '>' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is bool.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize scalar_gt"""
-
-    def __call__(self, x, y):
-        return x > y
-
-
-class scalar_lt(Primitive):
-    r"""
-    Computes the boolean value of :math:`x < y`.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '<' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is bool.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize scalar_lt"""
-
-    def __call__(self, x, y):
-        return x < y
-
-
-class scalar_ge(Primitive):
-    r"""
-    Compare the value of the input scalars :math:`x,y`, and the output result is a bool value.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '>=' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is bool.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize scalar_ge"""
-
-    def __call__(self, x, y):
-        return x >= y
-
-
-class scalar_le(Primitive):
-    r"""
-    Compare the value of the input scalars :math:`x,y`, and the output result is a bool value.
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '<=' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type of scalar is bool.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize scalar_le"""
-
-    def __call__(self, x, y):
-        return x <= y
-
-
-class ScalarMod(Primitive):
-    r"""
-    Computes the remainder of dividing the first input scalar by the second input scalar element-wise.
-
-    .. math::
-
-        out_{i} = x_{i} \text{ % } y_{i}
-
-    .. note::
-        The inputs can be constant/variable value. Usage is the same as '%' in Python.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-        - **y** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type is the one with higher precision or higher digits among the two inputs.
-
-    Raises:
-        TypeError: If `x` and `y` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarMod"""
-
-    def __call__(self, x, y):
-        if y == 0:
-            raise ValueError('Cannot perform modulo operation on zero.')
-        return x % y
-
-
-class ScalarBool(Primitive):
-    r"""
-    Computes the input scalar true or false.
-
-    .. note::
-        The inputs can be constant/variable value.
-        This primitive only have 'CPU' implementation, for other platform, it runs using heterogeneous.
-
-    Inputs:
-        - **x** (Scalar) - A constant or variable scalar.
-
-    Outputs:
-        Scalar, the type is bool.
-
-    Raises:
-        TypeError: If `x` are not scalar.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScalarBool"""
+from .manually_defined import ScalarAdd, ScalarBool, ScalarDiv, ScalarMul, ScalarEq, ScalarFloorDiv, ScalarGe, \
+    ScalarGt, ScalarLe, ScalarLog, ScalarLt, ScalarMod, ScalarPow, ScalarSub, ScalarUadd, ScalarUsub
 
 
 class bool_not(Primitive):
@@ -517,6 +39,7 @@ class bool_not(Primitive):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize bool_not"""
@@ -550,6 +73,7 @@ class bit_and(Primitive):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize ScalarMod"""
@@ -576,6 +100,7 @@ class bit_or(Primitive):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize ScalarMod"""

mindspore/ops/operations/_sequence_ops.py

@@ -440,7 +440,7 @@ class TensorToTuple(PrimitiveWithCheck):
     def infer_value(self, x):
         """Infer_value TensorToTuple"""
         value = None
-        if x is not None and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)) and len(x.asnumpy().shape) <= 1:
             value = tuple(x.asnumpy().tolist())
         return value
 
@@ -477,7 +477,7 @@ class TensorToList(PrimitiveWithCheck):
     def infer_value(self, x):
         """infer_value TensorToList"""
         value = None
-        if x is not None and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)) and len(x.asnumpy().shape) <= 1:
             value = x.asnumpy().tolist()
         return value
 
@@ -513,10 +513,10 @@ class TensorToScalar(PrimitiveWithCheck):
 
     def infer_value(self, x):
         """infer_value TensorToScalar"""
-        value = None
-        if x is not None and None not in x and isinstance(x, (Tensor, Tensor_)):
-            value = x.asnumpy().tolist()
-        return value
+        if isinstance(x, (Tensor_, Tensor)):
+            if not x.shape or x.shape == (1,) or x.shape == [1,]:
+                return x.asnumpy().item()
+        return None
 
 
 class SequenceCount(Primitive):
@@ -907,36 +907,6 @@ class SequenceUnstack(Primitive):
             validator.check_value_type("num", num, [int], self.name)
 
 
-class SequenceConcat(Primitive):
-    r"""
-    Support sequence Concat operation.
-
-    .. note::
-        This is only for internal used.
-
-    Args:
-        axis (Int): The axis to be concat.
-
-    Inputs:
-        - **sequence** (Union[List, Tuple]) - A sequence of Tensor objects with same shape and type..
-
-    Outputs:
-        The concat of all input.
-
-    Raises:
-        TypeError: The 'sequence' is not list or tuple.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    @prim_attr_register
-    def __init__(self, axis=0):
-        """Initialize SequenceConcat"""
-        super(SequenceConcat, self).__init__("axis")
-        self.axis = axis
-        validator.check_value_type("axis", axis, [int], self.name)
-
-
 class tuple_greater_than(Primitive):
     r"""
     Support tuple_greater_than operation 'greater_than(target)'.

mindspore/ops/operations/_tensor_array.py

@@ -46,7 +46,7 @@ class TensorArray(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> print(handle)
@@ -90,7 +90,7 @@ class TensorArrayWrite(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -133,7 +133,7 @@ class TensorArrayRead(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -179,7 +179,7 @@ class TensorArrayClose(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> close_op = ops.TensorArrayClose()
@@ -215,7 +215,7 @@ class TensorArrayClear(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> clear_op = ops.TensorArrayClear()
@@ -255,7 +255,7 @@ class TensorArrayStack(Primitive):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> write_op = ops.TensorArrayWrite()
@@ -295,7 +295,7 @@ class TensorArraySize(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> create_op = ops.TensorArray(mindspore.int32, ())
         >>> handle = create_op()
         >>> size_op = ops.TensorArraySize()
@@ -333,7 +333,7 @@ class TensorArrayGather(PrimitiveWithInfer):
 
     Examples:
         >>> import mindspore
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import numpy as mnp
         >>> create_op = ops.TensorArray(mindspore.float32, dynamic_size=False, element_shape=(8,))
         >>> handle = create_op()