mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/operations/_quant_ops.py

@@ -140,7 +140,7 @@ class MinMaxUpdatePerLayer(PrimitiveWithInfer):
     Updates min and max per layer.
 
     Args:
-        ema (bool): Uses EMA algorithm update value min and max. Default: False.
+        ema (bool): Uses EMA algorithm update value min and max. Default: ``False``.
         ema_decay (int) : EMA algorithm decay parameter. Default: 0.999.
 
     Inputs:
@@ -193,7 +193,7 @@ class MinMaxUpdatePerChannel(PrimitiveWithInfer):
      Updates min and max per channel.
 
     Args:
-        ema (bool): Uses EMA algorithm update value min and max. Default: False.
+        ema (bool): Uses EMA algorithm update value min and max. Default: ``False``.
         ema_decay (int) : EMA algorithm decay parameter. Default: 0.999.
         channel_axis (int): Quantization by channel axis. Ascend backend only supports 0 or 1. Default: 1.
 
@@ -260,8 +260,8 @@ class FakeLearnedScaleQuantPerLayer(PrimitiveWithInfer):
         quant_delay (int): Quantilization delay parameter. Before delay step in training time not update
             simulate quantization aware function. After delay step in training time begin simulate the aware
             quantize function. Default: 0.
-        neg_trunc (bool): Whether the quantization algorithm uses negative truncation or not. Default: False.
-        training (bool): Training the network or not. Default: True.
+        neg_trunc (bool): Whether the quantization algorithm uses negative truncation or not. Default: ``False``.
+        training (bool): Training the network or not. Default: ``True``.
 
     Inputs:
         - **input_x** (Tensor) : Input tensor that needs to be quantified.
@@ -269,7 +269,7 @@ class FakeLearnedScaleQuantPerLayer(PrimitiveWithInfer):
         - **quant_max** (Tensor) : Value of the quantization range.
 
     Outputs:
-        - Tensor: Simulates quantize tensor of `input_x`，with the same type and shape as the `input_x`.
+        - Tensor: Simulates quantize tensor of `input_x`, with the same type and shape as the `input_x`.
 
     Examples:
         >>> input_tensor = Tensor(np.random.rand(3, 16, 5, 5), mstype.float32)
@@ -409,8 +409,8 @@ class FakeLearnedScaleQuantPerChannel(PrimitiveWithInfer):
         quant_delay (int): Quantilization delay parameter. Before delay step in training time not update
             simulate quantization aware function. After delay step in training time begin simulate the aware
             quantize function. Default: 0.
-        neg_trunc (bool): Whether the quantization algorithm uses negative truncation or not. Default: False.
-        training (bool): Training the network or not. Default: True.
+        neg_trunc (bool): Whether the quantization algorithm uses negative truncation or not. Default: ``False``.
+        training (bool): Training the network or not. Default: ``True``.
         channel_axis (int): Quantization by channel axis. Ascend backend only supports 0 or 1. Default: 1.
 
     Inputs:
@@ -419,7 +419,7 @@ class FakeLearnedScaleQuantPerChannel(PrimitiveWithInfer):
         - **quant_max** (Tensor) : Value of the quantization range.
 
     Outputs:
-        - Tensor: Simulates quantize tensor of `input_x`，with the same type and shape as the `input_x`.
+        - Tensor: Simulates quantize tensor of `input_x`, with the same type and shape as the `input_x`.
 
     Examples:
         >>> input_tensor = Tensor(np.random.rand(3, 16, 5, 5), mstype.float32)
@@ -576,7 +576,7 @@ class FakeQuantWithMinMaxVars(PrimitiveWithInfer):
         num_bits (int): Quantization bitwidth; between 2 and 16. Default: 8.
         narrow_range (bool): Whether the quantization algorithm uses narrow range or not.
             if True, the quantization range is [0, 2^num_bits-1]. Otherwise, the quantization
-            range is [1, 2^num_bits-1]. Default: False.
+            range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
         - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
@@ -634,7 +634,7 @@ class FakeQuantWithMinMaxVarsGradient(PrimitiveWithInfer):
         num_bits (int): Quantization bitwidth; between 2 and 16, inclusive. Default: 8.
         narrow_range (bool): Whether the quantization algorithm uses narrow range or not.
             if True, the quantization range is [0, 2^num_bits-1]. Otherwise, the quantization
-            range is [1, 2^num_bits-1]. Default: False.
+            range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
         - **gradients** (Tensor) - The gradient above the FakeQuantWithMinMaxVars.
@@ -699,7 +699,7 @@ class FakeQuantWithMinMaxVarsPerChannel(PrimitiveWithInfer):
         num_bits (int): Quantization bitwidth; between 2 and 16, inclusive. Default: 8.
         narrow_range (bool): Whether the quantization algorithm uses narrow range or not.
             if True, the quantization range is [0, 2^num_bits-1]. Otherwise, the quantization
-            range is [1, 2^num_bits-1]. Default: False.
+            range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
         - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
@@ -750,7 +750,7 @@ class FakeQuantWithMinMaxVarsPerChannelGradient(PrimitiveWithInfer):
         num_bits (int): Quantization bitwidth; between 2 and 16, inclusive. Default: 8.
         narrow_range (bool): Whether the quantization algorithm uses narrow range or not.
             if True, the quantization range is [0, 2^num_bits-1]. Otherwise, the quantization
-            range is [1, 2^num_bits-1]. Default: False.
+            range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
         - **gradients** (Tensor) - The gradient above the FakeQuantWithMinMaxVars.
@@ -829,14 +829,14 @@ class FakeQuantPerLayer(PrimitiveWithInfer):
 
     Args:
         num_bits (int) : Number bits for quantization aware. Default: 8.
-        ema (bool): Uses EMA algorithm update value min and max. Default: False.
+        ema (bool): Uses EMA algorithm update value min and max. Default: ``False``.
         ema_decay (int) : EMA algorithm decay parameter. Default: 0.999.
         quant_delay (int): Quantilization delay parameter. Before delay step in training time not update
             simulate quantization aware function. After delay step in training time begin simulate the aware
             quantize function. Default: 0.
-        symmetric (bool): Whether the quantization algorithm is symmetric or not. Default: False.
-        narrow_range (bool): Whether the quantization algorithm uses narrow range or not. Default: False.
-        training (bool): Training the network or not. Default: True.
+        symmetric (bool): Whether the quantization algorithm is symmetric or not. Default: ``False``.
+        narrow_range (bool): Whether the quantization algorithm uses narrow range or not. Default: ``False``.
+        training (bool): Training the network or not. Default: ``True``.
 
     Inputs:
         - **x** (Tensor) : float32 Tensor representing the shape of the output tensor.
@@ -949,14 +949,14 @@ class FakeQuantPerChannel(PrimitiveWithInfer):
 
     Args:
         num_bits (int) : Number bits to quantilization. Default: 8.
-        ema (bool): Uses EMA algorithm update tensor min and tensor max. Default: False.
+        ema (bool): Uses EMA algorithm update tensor min and tensor max. Default: ``False``.
         ema_decay (int) : EMA algorithm decay parameter. Default: 0.999.
         quant_delay (int): Quantilization delay  parameter. Before delay step in training time not
             update the weight data to simulate quantize operation. After delay step in training time
             begin simulate the quantize operation. Default: 0.
-        symmetric (bool): Whether the quantization algorithm is symmetric or not. Default: False.
-        narrow_range (bool): Whether the quantization algorithm uses narrow range or not. Default: False.
-        training (bool): Training the network or not. Default: True.
+        symmetric (bool): Whether the quantization algorithm is symmetric or not. Default: ``False``.
+        narrow_range (bool): Whether the quantization algorithm uses narrow range or not. Default: ``False``.
+        training (bool): Training the network or not. Default: ``True``.
         channel_axis (int): Quantization by channel axis. Ascend backend only supports 0 or 1. Default: 1.
 
     Inputs:
@@ -975,7 +975,7 @@ class FakeQuantPerChannel(PrimitiveWithInfer):
         >>> result = fake_quant(input_x, _min, _max)
     """
     support_quant_bit = [4, 7, 8]
-    ascend_support_x_rank = [2, 4]
+    ascend_support_x_rank = [2, 3, 4]
 
     @prim_attr_register
     def __init__(self,
@@ -1008,11 +1008,7 @@ class FakeQuantPerChannel(PrimitiveWithInfer):
         self.ema_decay = validator.check_float_range(ema_decay, 0, 1, validator.INC_BOTH, 'ema_decay', self.name)
         self.num_bits = validator.check_positive_int(num_bits, 'num_bits', self.name)
         self.quant_delay = validator.check_non_negative_int(quant_delay, 'quant_delay', self.name)
-        if self.is_ascend:
-            self.channel_axis = validator.check_int_range(channel_axis, 0, 1, validator.INC_BOTH,
-                                                          'channel_axis', self.name)
-        else:
-            self.channel_axis = validator.check_non_negative_int(channel_axis, 'channel_axis', self.name)
+        self.channel_axis = validator.check_non_negative_int(channel_axis, 'channel_axis', self.name)
         self.init_prim_io_names(inputs=['x', 'min', 'max'], outputs=['out'])
 
     def infer_shape(self, x_shape, min_shape, max_shape):
@@ -1087,7 +1083,7 @@ class BatchNormFold(PrimitiveWithInfer):
         momentum (float): Momentum value must be [0, 1]. Default: 0.9.
         epsilon (float): A small float number to avoid dividing by 0. 1e-5 if dtype in
             float32 else 1e-3. Default: 1e-5.
-        is_training (bool): In training mode set True, else set False. Default: True.
+        is_training (bool): In training mode set True, else set False. Default: ``True``.
         freeze_bn (int): Delay in steps at which computation switches from regular batch
             norm to frozen mean and std. Default: 0.
 
@@ -1806,7 +1802,7 @@ class IFMR(Primitive):
         max_percentile (float): Max init percentile. Default: 0.999999.
         search_range Union[list(float), tuple(float)]: Range of searching. Default: [0.7, 1.3].
         search_step (float): Step size of searching. Default: 0.01.
-        with_offset (bool): Whether using offset. Default: True.
+        with_offset (bool): Whether using offset. Default: ``True``.
 
     Inputs:
         - **data** (Tensor) - A Tensor of feature map. With float16 or float32 data type.

mindspore/ops/operations/_rl_inner_ops.py

@@ -189,16 +189,18 @@ class DiscountedReturn(PrimitiveWithInfer):
 
     def infer_shape(self, reward_shape, done_shape, last_state_value_shape):
         if len(reward_shape) != len(done_shape):
-            raise ValueError(f'{self.name} len(reward) and len(done) must be same, ',
+            raise ValueError(f'For \'{self.name}\', len(reward) and len(done) must be the same, ',
                              f'but got {len(reward_shape)} and {len(done_shape)}.')
 
         if reward_shape[0] != done_shape[0]:
-            raise ValueError(f'{self.name} timestep of reward and done must be same, ',
-                             f'but got {reward_shape[0]} and {done_shape[0]}.')
+            raise ValueError(f'For \'{self.name}\', the first element of the shape of \'reward\' '
+                             f'and \'done\' must be the same, but got reward.shape[0]:'
+                             f' {reward_shape[0]} and done.shape[0]: {done_shape[0]}.')
 
         if reward_shape[1:] != last_state_value_shape:
-            raise ValueError(f'{self.name} state value shape must be match, ',
-                             f'but got {reward_shape[1:]} and {last_state_value_shape}.')
+            raise ValueError(f'For \'{self.name}\', reward.shape[1:] and last_state_value.shape must be the same, '
+                             f'but got reward.shape[1:]: {reward_shape[1:]} '
+                             f'and last_state_value.shape: {last_state_value_shape}.')
         return reward_shape
 
     def infer_dtype(self, reward_dtype, done_dtype, last_state_value_dtype):
@@ -804,7 +806,7 @@ class BatchAssign(PrimitiveWithInfer):
     Assign the parameters of the source to overwrite the target.
 
     Args:
-        lock (bool): Lock when the operator is Write, else shared the mutex. Default: True.
+        lock (bool): Lock when the operator is Write, else shared the mutex. Default: ``True``.
 
     Inputs:
         - **dst_model** (tuple) - A parameters tuple of the dst model.
@@ -939,7 +941,7 @@ class TensorsQueuePut(PrimitiveWithInfer):
         validator.check_equal_int(len(elements_shape), self.elements_num, "inputs elements", self.name)
         for i, shape in enumerate(elements_shape):
             if tuple(shape) != self.shapes[i]:
-                raise ValueError(f'{self.name} init shape and ipnut shape must be the same, ',
+                raise ValueError(f'{self.name} init shape and input shape must be the same, ',
                                  f'but got {self.shapes[i]} and input {shape} in position {i}.')
         return ()
 

mindspore/ops/operations/_scalar_ops.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """Operations for sequence"""
 
+from math import log
 from mindspore.ops.primitive import Primitive, prim_attr_register
 
 
@@ -119,6 +120,120 @@ class ScalarAdd(Primitive):
         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.

mindspore/ops/operations/_sequence_ops.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 # ============================================================================
 """Operations for sequence"""
-
 from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, prim_attr_register
+import mindspore._checkparam as validator
 from mindspore.common import Tensor
 from mindspore._c_expression import Tensor as Tensor_
 
@@ -196,6 +196,9 @@ class SequenceSlice(Primitive):
         """Initialize SequenceSlice"""
         self.init_prim_io_names(inputs=['seq', 'start', 'stop', 'step'], outputs=['output_data'])
 
+    def __call__(self, sequence, start, stop, step):
+        return sequence[start:stop:step]
+
 
 class InSequence(Primitive):
     r"""
@@ -223,6 +226,9 @@ class InSequence(Primitive):
         """Initialize ListAppend"""
         self.init_prim_io_names(inputs=['element', 'input_data'], outputs=['output_data'])
 
+    def __call__(self, target, sequence):
+        return target in sequence
+
 
 class SequenceSliceSetItem(Primitive):
     r"""
@@ -291,6 +297,9 @@ class SequenceAdd(Primitive):
         """Initialize SequenceAdd"""
         self.init_prim_io_names(inputs=['input_1', 'input_2'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x + y
+
 
 class SequenceAddOffset(Primitive):
     r"""
@@ -319,7 +328,7 @@ class SequenceAddOffset(Primitive):
         self.init_prim_io_names(inputs=['shape_0', 'shape_1'], outputs=['output'])
 
 
-class TupleToTensor(PrimitiveWithCheck):
+class TupleToTensor(Primitive):
     r"""
     Convert tuple to tensor
 
@@ -363,7 +372,7 @@ class TupleToTensor(PrimitiveWithCheck):
         return None
 
 
-class ListToTensor(PrimitiveWithCheck):
+class ListToTensor(Primitive):
     r"""
     Convert list to tensor
 
@@ -394,13 +403,9 @@ class ListToTensor(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=['input_list', 'dtype'], outputs=['output_data'])
 
     def __call__(self, x, dtype):
-        return self.infer_value(x, dtype)
-
-    def infer_value(self, x, dtype):
-        """Infer_value ListToTensor"""
         if x is not None and None not in x and isinstance(x, list):
             return Tensor(x, dtype)
-        return None
+        raise RuntimeError(f"input must be list, but got {x}")
 
 
 class TensorToTuple(PrimitiveWithCheck):
@@ -435,7 +440,7 @@ class TensorToTuple(PrimitiveWithCheck):
     def infer_value(self, x):
         """Infer_value TensorToTuple"""
         value = None
-        if x is not None and None not in x and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)):
             value = tuple(x.asnumpy().tolist())
         return value
 
@@ -472,7 +477,7 @@ class TensorToList(PrimitiveWithCheck):
     def infer_value(self, x):
         """infer_value TensorToList"""
         value = None
-        if x is not None and None not in x and isinstance(x, (Tensor, Tensor_)):
+        if x is not None and isinstance(x, (Tensor, Tensor_)):
             value = x.asnumpy().tolist()
         return value
 
@@ -540,6 +545,9 @@ class SequenceCount(Primitive):
         """Initialize SequenceCount"""
         self.init_prim_io_names(inputs=['sequence', 'target'], outputs=['output_data'])
 
+    def __call__(self, sequence, target):
+        return sequence.count(target)
+
 
 class SequenceIndex(Primitive):
     r"""
@@ -560,6 +568,7 @@ class SequenceIndex(Primitive):
 
     Raises:
         TypeError: The 'sequence' is not list or tuple.
+        ValueError: The 'target' is not in the 'sequence'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -569,6 +578,9 @@ class SequenceIndex(Primitive):
         """Initialize SequenceIndex"""
         self.init_prim_io_names(inputs=['sequence', 'target', 'start', 'end'], outputs=['output_data'])
 
+    def __call__(self, sequence, target, start=None, end=None):
+        return sequence.index(target, start, end)
+
 
 class SequenceMul(Primitive):
     r"""
@@ -597,6 +609,9 @@ class SequenceMul(Primitive):
         """Initialize SequenceMul"""
         self.init_prim_io_names(inputs=['sequence', 'scalar'], outputs=['output_data'])
 
+    def __call__(self, sequence, scalar):
+        return sequence * scalar
+
 
 class SequenceZerosLike(Primitive):
     r"""
@@ -823,6 +838,105 @@ class SequenceAddN(Primitive):
         self.init_prim_io_names(inputs=["inputs"], outputs=["sum"])
 
 
+class SequenceStack(Primitive):
+    r"""
+    Support sequence stack operation.
+
+    .. note::
+        This it is only for internal used.
+
+    Args:
+        axis (Int):  Dimension to stack. Default: ``0`` .
+            Negative values wrap around. The range is [-(R+1), R+1).
+
+    Inputs:
+        - **input_x** (Union[tuple, list]) - A Tuple or list of Tensor objects with the same shape and type.
+
+    Outputs:
+        Tensor. A stacked Tensor with the same type as `input_x`.
+
+    Raises:
+        TypeError: The 'sequence' is not list or tuple.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+
+    @prim_attr_register
+    def __init__(self, axis=0):
+        """Initialize Stack"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        validator.check_value_type("axis", axis, [int], self.name)
+        self.axis = axis
+
+
+class SequenceUnstack(Primitive):
+    r"""
+    Support sequence unstack operation.
+
+    .. note::
+        This it is only for internal used.
+
+    Args:
+        axis (Int): Dimension along which to unpack. Default: ``0`` .
+            Negative values wrap around. The range is [-R, R).
+        num (Union[None, int]): The number of output tensors.
+            Automatically inferred by input_x and axis if ``None`` . Default: ``None`` .
+
+    Inputs:
+        **input_x** (Tensor) - The shape is :math:`(x_1, x_2, ..., x_R)`.
+          A tensor to be unstacked and the rank of the tensor must be greater than 0.
+
+    Outputs:
+        A tuple of tensors, the shape of each objects is the same.
+
+    Raises:
+        TypeError: The 'sequence' is not list or tuple.
+
+    Supported Platforms:
+        ``CPU``
+    """
+
+    @prim_attr_register
+    def __init__(self, axis=0, num=None):
+        """Initialize SequenceUnstack"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        validator.check_value_type("axis", axis, [int], self.name)
+        self.axis = axis
+        if num is not None:
+            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)'.
@@ -850,6 +964,9 @@ class tuple_greater_than(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x > y
+
 
 class tuple_greater_equal(Primitive):
     r"""
@@ -878,6 +995,9 @@ class tuple_greater_equal(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x >= y
+
 
 class list_greater_than(Primitive):
     r"""
@@ -906,6 +1026,9 @@ class list_greater_than(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x > y
+
 
 class list_greater_equal(Primitive):
     r"""
@@ -934,6 +1057,9 @@ class list_greater_equal(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x >= y
+
 
 class tuple_lt(Primitive):
     r"""
@@ -962,6 +1088,9 @@ class tuple_lt(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x < y
+
 
 class list_lt(Primitive):
     r"""
@@ -990,6 +1119,9 @@ class list_lt(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x < y
+
 
 class tuple_le(Primitive):
     r"""
@@ -1018,6 +1150,9 @@ class tuple_le(Primitive):
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
 
+    def __call__(self, x, y):
+        return x <= y
+
 
 class list_le(Primitive):
     r"""
@@ -1045,3 +1180,6 @@ class list_le(Primitive):
         """Initialize list_le"""
         self.init_prim_io_names(
             inputs=['input_0', 'input_1'], outputs=['output_data'])
+
+    def __call__(self, x, y):
+        return x <= y

mindspore/ops/operations/_tensor_array.py

@@ -31,7 +31,7 @@ class TensorArray(PrimitiveWithInfer):
     Args:
         dtype (mindspore.dtype): the data type in the TensorArray.
         element_shape (tuple[int]): the shape of each tensor in a TensorArray.
-        dynamic_size (bool): If true the TensorArray can increase the size. Default: True.
+        dynamic_size (bool): If true the TensorArray can increase the size. Default: ``True``.
         size (int): The size of the TensorArray if dynamic_size = False.
         name (string): the name of this TensorArray. Default: "TA".
 

mindspore/ops/operations/_thor_ops.py

@@ -261,8 +261,8 @@ class CusMatMulCube(PrimitiveWithInfer):
     The rank of input tensors must be `2`.
 
     Args:
-        transpose_a (bool): If true, `a` is transposed before multiplication. Default: False.
-        transpose_b (bool): If true, `b` is transposed before multiplication. Default: False.
+        transpose_a (bool): If true, `a` is transposed before multiplication. Default: ``False``.
+        transpose_b (bool): If true, `b` is transposed before multiplication. Default: ``False``.
 
     Inputs:
         - **input_x** (Tensor) - The first tensor to be multiplied. The shape of the tensor is :math:`(N, C)`. If