mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/_inner_ops.py

@@ -20,22 +20,25 @@ import numpy as np
 
 from mindspore.common import Tensor
 from mindspore.ops import composite as C
-from mindspore.communication.management import GlobalComm
 from mindspore.ops.operations.array_ops import Cast
+from mindspore.ops.operations._scalar_ops import bit_or, bit_and
 from mindspore.ops import signature as sig
 from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, _run_op
 from mindspore import context
-from mindspore._checkparam import Rel
-from mindspore._checkparam import Validator as validator
+from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import typing
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
-from mindspore._c_expression import call_constant_folding
+from mindspore.communication.management import GlobalComm
+from mindspore.common.api import _pynative_executor
+from mindspore.common._register_for_adapter import ms_adapter_registry
 
 
 # Bit operation
-bit_and = Primitive("bit_and")
-bit_or = Primitive("bit_or")
+bit_and = bit_and()
+bit_or = bit_or()
 bit_xor = Primitive("bit_xor")
 bit_left_shift = Primitive("bit_left_shift")
 bit_right_shift = Primitive("bit_right_shift")
@@ -50,54 +53,10 @@ string_mul = Primitive("string_mul")
 string_getitem = Primitive("string_getitem")
 
 
-class FillV2(Primitive):
-    """
-    Creates a tensor filled with a scalar value.
-
-    Creates a tensor with shape described by the first argument and fills it with values in the second argument.
-
-    Inputs:
-        - **shape** (tensor) - The specified shape of output tensor. The shape of the input1 must be 1D and
-          the data type of the input1 must be int32 or int64.
-        - **value** (tensor) - Value to fill the returned tensor. The shape of the input2 must be 0D and
-          the data type of the input2 must be one of the following types:
-          bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64.
-
-    Outputs:
-        A tensor, has the same type and shape as input value.
-
-    Raises:
-        ValueError: If `shape` is not a 1D tensor.
-        TypeError: If the data type of `shape` is not int32 or int64.
-        ValueError: If `value` is not a 0D tensor.
-        ValueError: If the number of output elements is greater than 1000000.
-
-    Supported Platforms:
-        ``CPU``
-
-    Examples:
-        >>> fillV2 = ops.FillV2()
-        >>> output = fillV2(Tensor([2, 3], mindspore.int32), Tensor(1, mindspore.float32))
-        >>> print(output)
-        [[1. 1. 1.]
-         [1. 1. 1.]]
-        >>> output = fillV2(Tensor([3, 3], mindspore.int64), Tensor(0, mindspore.int32))
-        >>> print(output)
-        [[0 0 0]
-         [0 0 0]
-         [0 0 0]]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize FillV2"""
-        self.add_prim_attr("max_length", 1000000)
-
-
 class ExtractImagePatches(Primitive):
-    """
+    r"""
     Extracts patches from images.
-    The input tensor must be a 4-D tensor and the data format is NHWC.
+    The input tensor must be a 4-D tensor and the data format is NCHW.
 
     Args:
         ksizes (Union[tuple[int], list[int]]): The size of sliding window, must be a tuple or a list of integers,
@@ -114,12 +73,32 @@ class ExtractImagePatches(Primitive):
             - valid: Means that the taken patch area must be completely covered in the original image.
 
     Inputs:
-        - **input_x** (Tensor) - A 4-D tensor whose shape is [in_batch, in_row, in_col, in_depth] and
+        - **input_x** (Tensor) - A 4-D tensor whose shape is [in_batch, in_depth, in_row, in_col] and
           data type is number.
 
     Outputs:
         Tensor, a 4-D tensor whose data type is same as 'input_x',
-        and the shape is [out_batch, out_row, out_col, out_depth], the out_batch is the same as the in_batch.
+        and the shape is [out_batch, out_depth, out_row, out_col], Where the out_batch is the same as the in_batch
+        and
+
+        .. math::
+            out_depth=ksize\_row * ksize\_col * in\_depth
+
+        and
+        if 'padding' is "valid":
+
+        .. math::
+            out\_row=floor((in\_row - (ksize\_row + (ksize\_row - 1) * (rate\_row - 1))) / stride\_row) + 1
+            out\_col=floor((in\_col - (ksize\_col + (ksize\_col - 1) * (rate\_col - 1))) / stride\_col) + 1
+
+        if 'padding' is "same":
+
+        .. math::
+            out\_row=floor((in\_row - 1) / stride\_row) + 1
+            out\_col=floor((in\_col - 1) / stride\_col) + 1
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
     """
 
     @prim_attr_register
@@ -223,12 +202,14 @@ class Lamb(PrimitiveWithInfer):
           Default: 0.0.
         - **global_step** (Tensor) - Tensor to record current global step.
         - **gradient** (Tensor) - Gradient, has the same shape and data type as `var`.
+
     Outputs:
         Tensor, the updated parameters.
+
         - **var** (Tensor) - The same shape and data type as `var`.
 
     Supported Platforms:
-        ``GPU`` ``Ascend``
+        ``Ascend````GPU``
     """
 
     @prim_attr_register
@@ -238,9 +219,9 @@ class Lamb(PrimitiveWithInfer):
 
     def infer_shape(self, var_shape, m_shape, v_shape, lr_shape, beta1_shape, beta2_shape,
                     epsilon_shape, decay_shape, global_step_shape, gradient_shape):
-        validator.check("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
-        validator.check("var_shape", var_shape, "gradient_shape", gradient_shape, Rel.EQ, self.name)
+        validator.check("var_shape", var_shape, "m_shape", m_shape, validator.EQ, self.name)
+        validator.check("var_shape", var_shape, "v_shape", v_shape, validator.EQ, self.name)
+        validator.check("var_shape", var_shape, "gradient_shape", gradient_shape, validator.EQ, self.name)
         return var_shape
 
     def infer_dtype(self, var_dtype, m_dtype, v_dtype, lr_dtype, beta1_dtype, beta2_dtype,
@@ -344,18 +325,18 @@ class MatrixDiag(PrimitiveWithInfer):
         return x_dtype
 
     def infer_shape(self, x_shape, assist_shape):
-        validator.check_int(len(assist_shape), 2, Rel.GE, "assist rank", self.name)
+        validator.check_int(len(assist_shape), 2, validator.GE, "assist rank", self.name)
         validator.check('rank of x', len(x_shape) + 1,
-                        'rank of assist', len(assist_shape), Rel.LE, self.name)
+                        'rank of assist', len(assist_shape), validator.LE, self.name)
         validator.check('assist\'s penultimate dimension', assist_shape[-2], 'assist\'s last dimension',
-                        assist_shape[-1], Rel.EQ, self.name)
+                        assist_shape[-1], validator.EQ, self.name)
 
         r_end_dim = -len(x_shape)
         r_idx = -1
         while r_idx >= r_end_dim:
             if x_shape[r_idx] != 1:
                 validator.check("reverse x dim %d" % r_idx, x_shape[r_idx], "reverse assist dim %d" %
-                                assist_shape[r_idx - 1], assist_shape[r_idx - 1], Rel.EQ, self.name)
+                                assist_shape[r_idx - 1], assist_shape[r_idx - 1], validator.EQ, self.name)
             r_idx = r_idx - 1
 
         return assist_shape
@@ -393,8 +374,8 @@ class MatrixDiagPart(PrimitiveWithInfer):
         return x_dtype
 
     def infer_shape(self, x_shape, assist_shape):
-        validator.check_int(len(x_shape), 2, Rel.GE, "x rank", self.name)
-        validator.check("x shape", x_shape, "assist shape", assist_shape, Rel.EQ, self.name)
+        validator.check_int(len(x_shape), 2, validator.GE, "x rank", self.name)
+        validator.check("x shape", x_shape, "assist shape", assist_shape, validator.EQ, self.name)
 
         if assist_shape[-2] < assist_shape[-1]:
             out_shape = assist_shape[:-1]
@@ -448,6 +429,7 @@ class Send(PrimitiveWithInfer):
         self.rank = dest_rank
         self.sr_tag = sr_tag
         self.group = group
+        self.add_prim_attr("no_eliminate", True)
 
     def infer_shape(self, x_shape):
         self.add_prim_attr("shape", x_shape)
@@ -459,7 +441,7 @@ class Send(PrimitiveWithInfer):
 
 class Receive(PrimitiveWithInfer):
     """
-    receive tensors from src_rank.
+    Receive tensors from src_rank.
 
     Note:
         Send and Receive must be used in combination and have same sr_tag.
@@ -472,7 +454,8 @@ class Receive(PrimitiveWithInfer):
         shape (list[int]): A required list identifying the shape of the tensor to be received.
         dtype (Type): A required Type identifying the type of the tensor to be received. The supported types:
                        int8, int16, int32, float16, float32.
-        group (str): The communication group to work on. Default: "hccl_world_group/nccl_world_group".
+        group (str, optional): The communication group to work on.
+            Default: "hccl_world_group" on Ascend, "nccl_world_group" on GPU.
 
     Inputs:
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
@@ -507,6 +490,7 @@ class Receive(PrimitiveWithInfer):
         self.shape = shape
         self.dtype = dtype
         self.group = group
+        self.add_prim_attr("no_eliminate", True)
         valid_type = [mstype.float16, mstype.float32, mstype.int32, mstype.int8, mstype.uint8]
         args = {"dtype": dtype}
         validator.check_scalar_or_tensor_types_same(args, valid_type, self.name)
@@ -552,15 +536,15 @@ class MatrixSetDiag(PrimitiveWithInfer):
         return x_dtype
 
     def infer_shape(self, x_shape, diagonal_shape, assist_shape):
-        validator.check_int(len(x_shape), 2, Rel.GE, "x rank", self.name)
-        validator.check("x shape", x_shape, "assist shape", assist_shape, Rel.EQ, self.name)
+        validator.check_int(len(x_shape), 2, validator.GE, "x rank", self.name)
+        validator.check("x shape", x_shape, "assist shape", assist_shape, validator.EQ, self.name)
 
         if x_shape[-2] < x_shape[-1]:
-            validator.check("diagnoal shape", diagonal_shape, "x shape excluding the last dimension",
-                            x_shape[:-1], Rel.EQ, self.name)
+            validator.check("diagonal shape", diagonal_shape, "x shape excluding the last dimension",
+                            x_shape[:-1], validator.EQ, self.name)
         else:
             validator.check("diagonal shape", diagonal_shape, "x shape excluding the second last dimension",
-                            x_shape[:-2] + x_shape[-1:], Rel.EQ, self.name)
+                            x_shape[:-2] + x_shape[-1:], validator.EQ, self.name)
 
         return assist_shape
 
@@ -677,7 +661,7 @@ class ConvertToDynamic(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=["input"], outputs=["output"])
 
     def check_shape(self, input_shape):
-        validator.check("input_shape rank", len(input_shape), "", 0, Rel.GT, self.name)
+        validator.check("input_shape rank", len(input_shape), "", 0, validator.GT, self.name)
 
     def check_dtype(self, input_dtype):
         validator.check_subclass("input_dtype", input_dtype, mstype.tensor, self.name)
@@ -727,7 +711,7 @@ class GpuConvertToDynamicShape(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=["input"], outputs=["output"])
 
     def check_shape(self, input_shape):
-        validator.check("input_shape rank", len(input_shape), "", 0, Rel.GT, self.name)
+        validator.check("input_shape rank", len(input_shape), "", 0, validator.GT, self.name)
 
     def check_dtype(self, input_dtype):
         validator.check_subclass("input_dtype", input_dtype, mstype.tensor, self.name)
@@ -808,7 +792,7 @@ class SequenceMask(PrimitiveWithCheck):
         One mask tensor of shape lengths.shape + (maxlen,).
 
     Supported Platforms:
-        ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore import ops
@@ -828,8 +812,8 @@ class SequenceMask(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=["lengths", "maxlen"], outputs=["mask"])
 
     def check_shape(self, lengths_shape, maxlen_shape):
-        validator.check("lengths_shape", len(lengths_shape), "", 0, Rel.GT, self.name)
-        validator.check("maxlen_shape", len(maxlen_shape), "", 0, Rel.EQ, self.name)
+        validator.check("lengths_shape", len(lengths_shape), "", 0, validator.GT, self.name)
+        validator.check("maxlen_shape", len(maxlen_shape), "", 0, validator.EQ, self.name)
 
     def check_dtype(self, lengths_dtype, maxlen_dtype):
         validator.check_subclass("lengths_dtype", lengths_dtype, mstype.tensor, self.name)
@@ -901,10 +885,10 @@ class SyncBatchNorm(Primitive):
 
     @prim_attr_register
     def __init__(self, epsilon=1e-5, momentum=0.1, group="sync_bn_group0", device_num=2):
-        validator.check_float_range(epsilon, 0, 1, Rel.INC_RIGHT, 'epsilon', self.name)
-        validator.check_float_range(momentum, 0, 1, Rel.INC_BOTH, 'momentum', self.name)
+        validator.check_float_range(epsilon, 0, 1, validator.INC_RIGHT, 'epsilon', self.name)
+        validator.check_float_range(momentum, 0, 1, validator.INC_BOTH, 'momentum', self.name)
         validator.check_isinstance("group", group, str)
-        validator.check_int(device_num, 2, Rel.GE, "device_num", self.name)
+        validator.check_int(device_num, 2, validator.GE, "device_num", self.name)
         self.init_prim_io_names(inputs=['x', 'scale', 'offset', 'mean', 'variance'],
                                 outputs=['y', 'batch_mean', 'batch_variance', 'reserve_space_1', 'reserve_space_2'])
         self.add_prim_attr('side_effect_mem', True)
@@ -967,7 +951,7 @@ class Centralization(PrimitiveWithInfer):
         validator.check_value_type('axis', axis_v, [int, list, tuple], self.name)
 
         if isinstance(axis_v, int):
-            validator.check_int_range(axis_v, -rank, rank, Rel.INC_LEFT, 'axis', self.name)
+            validator.check_int_range(axis_v, -rank, rank, validator.INC_LEFT, 'axis', self.name)
         elif axis:
             for index, one_axis in enumerate(axis_v):
                 validator.check_value_type('axis[%d]' % index, one_axis, [int], self.name)
@@ -1068,9 +1052,9 @@ class StackPop(PrimitiveWithInfer):
         validator.check_value_type("index", index, [int], self.name)
 
         validator.check_value_type('shape type', shape, [list, tuple], self.name)
-        validator.check_int(len(np.array(shape).shape), 1, Rel.EQ, "dim of shape", self.name)
+        validator.check_int(len(np.array(shape).shape), 1, validator.EQ, "dim of shape", self.name)
         for elem in shape:
-            validator.check_int(elem, 1, Rel.GE, 'shape element', self.name)
+            validator.check_int(elem, 1, validator.GE, 'shape element', self.name)
             validator.check_value_type('type of shape element', elem, [int], self.name)
 
         validator.check_type_name("dtype", dtype, (mstype.bool_,) + mstype.number_type, self.name)
@@ -1151,22 +1135,22 @@ class DynamicStitch(PrimitiveWithCheck):
 
     def check_shape(self, indices_shape, data_shape):
         validator.check_value_type("shape of indices", indices_shape, [tuple, list], self.name)
-        validator.check_int(len(indices_shape), 1, Rel.GE, "len of indices_shape", self.name)
+        validator.check_int(len(indices_shape), 1, validator.GE, "len of indices_shape", self.name)
         indices_dim0 = len(indices_shape[0])
         indices_num = len(indices_shape)
 
         validator.check_value_type("shape of data", data_shape, [tuple, list], self.name)
-        validator.check_int(len(data_shape), 1, Rel.GE, "len of data_shape", self.name)
+        validator.check_int(len(data_shape), 1, validator.GE, "len of data_shape", self.name)
         data_dim0 = len(data_shape[0])
         data_num = len(indices_shape)
 
-        validator.check("size of indices", indices_num, 'size of data', data_num, Rel.EQ, self.name)
+        validator.check("size of indices", indices_num, 'size of data', data_num, validator.EQ, self.name)
 
         # shape of `data` must start with shape of `indices`
         for i in range(0, indices_num):
             indices_dim = len(indices_shape[i])
             data_dim = len(data_shape[i])
-            validator.check(f"dim of indices[{i}]", indices_dim, f"dim of data[{i}]", data_dim, Rel.LE, self.name)
+            validator.check(f"dim of indices[{i}]", indices_dim, f"dim of data[{i}]", data_dim, validator.LE, self.name)
             if data_shape[i][:indices_dim] != data_shape[i][:indices_dim]:
                 raise ValueError(f"data[{i}].shape: {data_shape} does not start with indices[{i}].shape: {data_shape}")
 
@@ -1177,10 +1161,10 @@ class DynamicStitch(PrimitiveWithCheck):
             data_dim = len(data_shape[i])
             extra = data_dim - indices_dim
             validator.check(f"extra dim of data[{i}]", extra,
-                            f"extra dim of data[0]", base_extra, Rel.EQ, self.name)
+                            f"extra dim of data[0]", base_extra, validator.EQ, self.name)
             validator.check(f"data[0].shape[{indices_dim0}:]", data_shape[0][indices_dim0:],
                             f"data[{i}].shape[{len(indices_shape[i])}:]",
-                            data_shape[i][indices_dim:], Rel.EQ, self.name)
+                            data_shape[i][indices_dim:], validator.EQ, self.name)
 
         out_shape = [-1] + data_shape[0][indices_dim0:]
         return out_shape
@@ -1193,7 +1177,8 @@ class DynamicStitch(PrimitiveWithCheck):
             validator.check_tensor_dtype_valid(f'indices[{i}]', indices_type[i], mstype.int32, self.name)
             validator.check_tensor_dtype_valid(f'data[{i}]', data_type[i],
                                                mstype.number_type + (mstype.bool_,), self.name)
-            validator.check(f"type of data[{i}]", data_type[i], f"type of data[0]", data_type[0], Rel.EQ, self.name)
+            validator.check(f"type of data[{i}]", data_type[i], f"type of data[0]",
+                            data_type[0], validator.EQ, self.name)
         return data_type[0]
 
 
@@ -1278,69 +1263,6 @@ class TensorCopySlices(Primitive):
         self.init_prim_io_names(inputs=['x', 'value', 'begin', 'end', 'strides'], outputs=['y'])
 
 
-class Roll(Primitive):
-    """
-    Rolls the elements of a tensor along an axis.
-
-    The elements are shifted positively (towards larger indices) by the offset of `shift` along the dimension of `axis`.
-    Negative `shift` values will shift elements in the opposite direction. Elements that roll passed the last position
-    will wrap around to the first and vice versa. Multiple shifts along multiple axes may be specified.
-
-    Note:
-        This inner operation is valid only if the axis is equal to 0. If the shift and the axis are tuples or lists,
-        this inner operation is valid only for the first pair of elements.
-
-    Args:
-        shift (Union[list(int), tuple(int), int]): Specifies the number of places by which elements are shifted
-            positively (towards larger indices) along the specified dimension. Negative shifts will roll the elements
-            in the opposite direction.
-        axis (Union[list(int), tuple(int), int]): Specifies the dimension indexes of shape to be rolled. The value is
-            forced to be zero in this operation.
-
-    Inputs:
-        - **input_x** (Tensor) - Input tensor.
-
-    Outputs:
-        Tensor, has the same shape and type as `input_x`.
-
-    Raises:
-        TypeError: If `shift` is not an int, a tuple or a list.
-        TypeError: If `axis` is not an int, a tuple or a list.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-
-    Examples:
-        >>> from mindspore.ops.operations import _inner_ops as inner
-        >>> input_x = Tensor(np.array([0, 1, 2, 3, 4]).astype(np.float32))
-        >>> op = inner.Roll(shift=2, axis=0)
-        >>> output = op(input_x)
-        >>> print(output)
-        [3. 4. 0. 1. 2.]
-        >>> input_x = Tensor(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]).astype(np.float32))
-        >>> op = inner.Roll(shift=-1, axis=0)
-        >>> output = op(input_x)
-        >>> print(output)
-        [[5. 6. 7. 8. 9.]
-         [0. 1. 2. 3. 4.]]
-    """
-
-    @prim_attr_register
-    def __init__(self, shift, axis):
-        """Initialize Roll"""
-        if context.get_context("device_target") == "GPU":
-            validator.check_value_type("shift", shift, [int, tuple, list], self.name)
-            validator.check_value_type("axis", axis, [int, tuple, list], self.name)
-        else:
-            if isinstance(shift, (tuple, list)) and isinstance(axis, (tuple, list)):
-                validator.check_equal_int(len(shift), 1, "shift size", self.name)
-                validator.check_equal_int(len(axis), 1, "shift size", self.name)
-                validator.check_equal_int(axis[0], 0, "axis", self.name)
-            elif isinstance(shift, int) and isinstance(axis, int):
-                validator.check_equal_int(axis, 0, "axis", self.name)
-        self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
-
-
 class DSDMatmul(PrimitiveWithInfer):
     """
     The definition of the CusSquare primitive.
@@ -1524,10 +1446,16 @@ class SliceGetItem(Primitive):
             raise TypeError(
                 "Primitive[SliceGetItem] only support to get a slice type element but got {}".format(slice_value))
         if value == "start":
+            if hasattr(slice_value.start, "ndim") and slice_value.start.ndim == 1:
+                return slice_value.start.item()
             return slice_value.start
         if value == "stop":
+            if hasattr(slice_value.stop, "ndim") and slice_value.stop.ndim == 1:
+                return slice_value.stop.item()
             return slice_value.stop
         if value == "step":
+            if hasattr(slice_value.step, "ndim") and slice_value.step.ndim == 1:
+                return slice_value.step.item()
             return slice_value.step
         raise AttributeError("\'slice\' object has no attribute {}".format(value))
 
@@ -1549,7 +1477,7 @@ class DynamicBroadcastTo(Primitive):
         ValueError: if the target and input shapes are incompatible.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1562,12 +1490,25 @@ class Cummin(Primitive):
     r"""
     Returns the cumulative minimum of elements and the index.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Refer to :func:`mindspore.ops.cummin` for more detail.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
-    """
 
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import mindspore
+        >>> a = Tensor([-0.2284, -0.6628,  0.0975,  0.2680, -1.3298, -0.4220], mindspore.float32)
+        >>> func = ops.Cummin(axis=0)
+        >>> output = func(a)
+        >>> print(output[0])
+        [-0.2284 -0.6628 -0.6628 -0.6628 -1.3298 -1.3298]
+        >>> print(output[1])
+        [0 1 1 1 4 4]
+    """
     @prim_attr_register
     def __init__(self, axis):
         """Initialize Cummin"""
@@ -1684,7 +1625,7 @@ class ParallelResizeBilinear(PrimitiveWithInfer):
         """Initialize ParallelResizeBilinear."""
         validator.check_value_type("ori_image_size", ori_image_size, [list, tuple], self.name)
         validator.check_value_type("split_size", split_size, [list, tuple], self.name)
-        validator.check_int(len(split_size), 2, Rel.EQ, "len of split_size", self.name)
+        validator.check_int(len(split_size), 2, validator.EQ, "len of split_size", self.name)
         validator.check_value_type("src_start_w", src_start_w, [int], self.name)
         validator.check_value_type("dst_start_w", dst_start_w, [int], self.name)
         validator.check_value_type("align_corners", align_corners, [bool], self.name)
@@ -2002,21 +1943,23 @@ class KMeansCentroids(PrimitiveWithInfer):
     def infer_shape(self, x_shape, y_shape, sum_square_y_shape, sum_square_x_shape):
         """infer shape of primitive"""
         expected_shape_size = 2
-        validator.check_int(len(x_shape), expected_shape_size, Rel.EQ, "dims of x", self.name)
-        validator.check_int(len(y_shape), expected_shape_size, Rel.EQ, "dims of y", self.name)
-        validator.check_int(len(sum_square_y_shape), expected_shape_size, Rel.EQ, "dims of sum_square_y", self.name)
-        validator.check_int(len(sum_square_x_shape), expected_shape_size, Rel.EQ, "dims of sum_square_x", self.name)
-
-        validator.check_int(x_shape[1], y_shape[1], Rel.EQ,
+        validator.check_int(len(x_shape), expected_shape_size, validator.EQ, "dims of x", self.name)
+        validator.check_int(len(y_shape), expected_shape_size, validator.EQ, "dims of y", self.name)
+        validator.check_int(len(sum_square_y_shape), expected_shape_size, validator.EQ,
+                            "dims of sum_square_y", self.name)
+        validator.check_int(len(sum_square_x_shape), expected_shape_size, validator.EQ,
+                            "dims of sum_square_x", self.name)
+
+        validator.check_int(x_shape[1], y_shape[1], validator.EQ,
                             "the second dim of x and the second dim of y", self.name)
-        validator.check_int(y_shape[0], sum_square_y_shape[1], Rel.EQ,
+        validator.check_int(y_shape[0], sum_square_y_shape[1], validator.EQ,
                             "the first dim of y and the second dim of sum_square_y", self.name)
-        validator.check_int(x_shape[0], sum_square_x_shape[0], Rel.EQ,
+        validator.check_int(x_shape[0], sum_square_x_shape[0], validator.EQ,
                             "the first dim of x and the first dim of sum_square_x", self.name)
-        validator.check_int(sum_square_y_shape[0], sum_square_x_shape[1], Rel.EQ,
+        validator.check_int(sum_square_y_shape[0], sum_square_x_shape[1], validator.EQ,
                             "the first dim of sum_square_y and the first dim of sum_square_x",
                             self.name)
-        validator.check_int(sum_square_y_shape[0], 1, Rel.EQ,
+        validator.check_int(sum_square_y_shape[0], 1, validator.EQ,
                             "the first dim of sum_square_y", self.name)
 
         k = y_shape[0]
@@ -2087,7 +2030,7 @@ class ClipByNorm(PrimitiveWithInfer):
         x_dim = len(x_shape)
         axis = self.axis if isinstance(self.axis, Iterable) else (self.axis,)
         for _, value in enumerate(axis):
-            validator.check_int_range(value, -x_dim, x_dim, Rel.INC_LEFT, 'axis', self.name)
+            validator.check_int_range(value, -x_dim, x_dim, validator.INC_LEFT, 'axis', self.name)
         return x_shape
 
     def infer_dtype(self, x_type, clip_norm_type):
@@ -2114,23 +2057,24 @@ class TopTypeof(Primitive):
     def __init__(self):
         self.prim = Primitive('TopTypeof')
         self.typeof_cache = {
-            'slice': call_constant_folding(self.prim, slice(None, None, None)),
-            'list': call_constant_folding(self.prim, []),
-            'tuple': call_constant_folding(self.prim, ()),
-            'Tensor': call_constant_folding(self.prim, Tensor(np.ones([1], dtype=np.float32))),
-            'NoneType': call_constant_folding(self.prim, None),
-            'int': call_constant_folding(self.prim, 0),
-            'bool': call_constant_folding(self.prim, False),
-            'ellipsis': call_constant_folding(self.prim, ...)
+            'slice': mstype.Slice(),
+            'list': mstype.List(),
+            'tuple': mstype.Tuple(),
+            'Tensor': mstype.tensor,
+            'NoneType': mstype.none_type(),
+            'int': mstype.Int(),
+            'bool': mstype.Bool(),
+            'ellipsis': mstype.Ellipsis_(),
+            'dict': mstype.Dict()
         }
 
     def __call__(self, x):
         index_type = type(x).__name__
         if 'Tensor' in index_type:
             index_type = 'Tensor'
-        if index_type in ('slice', 'list', 'tuple', 'Tensor', 'NoneType', 'int', 'bool', 'ellipsis'):
+        if index_type in self.typeof_cache:
             return self.typeof_cache.get(index_type)
-        return call_constant_folding(self.prim, x)
+        return _pynative_executor.constant_folding(self.prim, x)
 
 
 class MixedPrecisionCast(Primitive):
@@ -2176,3 +2120,430 @@ class MixedPrecisionCast(Primitive):
             return data
 
         return self.hyper_map(cast_inner, x)
+
+
+class CheckBprop(PrimitiveWithInfer):
+    """
+    Checks whether the data type and the shape of corresponding elements from tuples x and y are the same.
+
+    Args:
+        prim_to_check (str): The name of the primitive being checked. Default: ''.
+
+    Inputs:
+        - **input_x** (tuple[Tensor]) - The `input_x` contains the outputs of bprop to be checked.
+        - **input_y** (tuple[Tensor]) - The `input_y` contains the inputs of bprop to check against.
+
+    Outputs:
+        Tuple[Tensor], the `input_x`,
+        if data type and shape of corresponding elements from `input_x` and `input_y` are the same.
+
+    Raises:
+        TypeError: If `input_x` or `input_y` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.op = ops.CheckBprop()
+        ...     def construct(self, x, y):
+        ...         return self.op(x, y)
+        ...
+        >>> net = Net()
+        >>> input_x = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
+        >>> input_y = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
+        >>> output = net(input_x, input_y)
+        >>> print(output)
+        (Tensor(shape=[2, 2], dtype=Float32, value=
+        [[ 2.00000000e+00,  2.00000000e+00],
+         [ 2.00000000e+00,  2.00000000e+00]]),)
+    """
+
+    @prim_attr_register
+    def __init__(self, prim_to_check=""):
+        """Initialize CheckBprop"""
+        self.prim_to_check = prim_to_check
+
+    def infer_shape(self, xshapes, yshapes):
+        """infer shape"""
+        tips = f"user defined method 'bprop'"
+        validator.check_value_type('grads', xshapes, (tuple,), tips)
+        validator.check_value_type('params', yshapes, (tuple,), tips)
+        if not len(xshapes) == len(yshapes):
+            raise ValueError(f"For {tips} the number of return values(gradients) must be equal to "
+                             f"the number of input arguments except 'out' and 'dout', "
+                             f"which is:{len(yshapes)} but got {len(xshapes)}.")
+        checking_range = len(yshapes)
+        for i in range(checking_range):
+            xshape = xshapes[i]
+            yshape = yshapes[i]
+            if not xshape or not yshape:
+                continue
+            if xshape != yshape:
+                raise ValueError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) "
+                                 f"should have the same shape as the {i}th argument, "
+                                 f"which is:{yshape}, but got: {xshape}.")
+        return xshapes
+
+    def infer_dtype(self, xdtypes, ydtypes):
+        """infer dtype"""
+        tips = f"user defined method 'bprop'"
+        validator.check_value_type('grads', xdtypes, (tuple,), tips)
+        validator.check_value_type('params', ydtypes, (tuple,), tips)
+        if not len(xdtypes) == len(ydtypes):
+            raise ValueError(f"For {tips}, the number of return values(gradients) must be equal to "
+                             f"the number of input arguments except 'out' and 'dout', "
+                             f"which is:{len(ydtypes)} but got {len(xdtypes)}.")
+        checking_range = len(ydtypes)
+        for i in range(checking_range):
+            xdtype = xdtypes[i]
+            ydtype = ydtypes[i]
+            if isinstance(xdtype, mstype.anything_type) or isinstance(ydtype, mstype.anything_type):
+                continue
+            if isinstance(ydtype, mstype.function_type):
+                if not isinstance(xdtype, mstype.env_type_type):
+                    raise TypeError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) type "
+                                    f"should be {mstype.env_type_type}, but got {xdtype}.")
+            if xdtype != ydtype:
+                raise TypeError(f"For {tips}, the {i}th return value(gradient of the {i}th argument) "
+                                f"should have the same dtype as the {i}th argument, "
+                                f"which is:{ydtype}, but got: {xdtype}.")
+        return xdtypes
+
+check_bprop = CheckBprop()
+
+
+class SameTypeShape(PrimitiveWithInfer):
+    """
+    Checks whether the data type and shape of two tensors are the same.
+
+    Refer to :func:`mindspore.ops.same_type_shape` for more detail.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
+        >>> input_y = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
+        >>> output = ops.SameTypeShape()(input_x, input_y)
+        >>> print(output)
+        [[2. 2.]
+         [2. 2.]]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Same"""
+
+    def __call__(self, x, y):
+        """run in PyNative mode"""
+        validator.check_value_type('x', x, Tensor, self.name)
+        validator.check_value_type('y', y, Tensor, self.name)
+        validator.check('x dtype', x.dtype, 'y dtype', y.dtype, validator.EQ, self.name, TypeError)
+        validator.check('x shape', x.shape, 'y shape', y.shape, validator.EQ, self.name)
+        return x
+
+    def __infer__(self, x, y):
+        validator.check_subclass('x', x['dtype'], mstype.tensor, self.name)
+        validator.check_subclass('y', y['dtype'], mstype.tensor, self.name)
+        validator.check('x dtype', x['dtype'], 'y dtype', y['dtype'], validator.EQ, self.name, TypeError)
+        validator.check('x shape', x['shape'], 'y shape', y['shape'], validator.EQ, self.name)
+        return x
+
+
+same_type_shape_ = SameTypeShape()
+
+
+def _is_subclass_(type_, dtype):
+    if not isinstance(type_, typing.Type):
+        return False
+    return typing.is_subclass(type_, dtype)
+
+
+class IsSubClass(PrimitiveWithInfer):
+    """
+    Checks whether this type is a sub-class of another type.
+
+    Inputs:
+        - **sub_type** (mindspore.dtype) - The type to be checked. Only constant value is allowed.
+        - **type_** (mindspore.dtype) - The target type. Only constant value is allowed.
+
+    Outputs:
+        bool, the check result.
+
+    Raises:
+        TypeError: If `sub_type` or `type_` is not a Type.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> output = ops.IsSubClass()(mindspore.int32,  mindspore.intc)
+        >>> print(output)
+        True
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        pass
+
+    def __infer__(self, sub_type, type_):
+        sub_type_t = sub_type['value']
+        type_v = type_['value']
+
+        validator.check_value_type("sub_type", sub_type_t, [mstype.Type], self.name)
+        validator.check_value_type("type_", type_v, [mstype.Type], self.name)
+
+        value = _is_subclass_(sub_type_t, type_v)
+
+        out = {'shape': (),
+               'dtype': mstype.type_type,
+               'value': value}
+        return out
+
+
+issubclass_ = IsSubClass()
+
+
+class IsInstance(PrimitiveWithInfer):
+    """
+    Checks whether an object is an instance of a target type.
+
+    Inputs:
+        - **inst** (Any Object) - The instance to be checked. Only constant value is allowed.
+        - **type_** (mindspore.dtype) - The target type. Only constant value is allowed.
+
+    Outputs:
+        bool, the check result.
+
+    Raises:
+        TypeError: If `type_` is not a Type.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> inst = 1
+        >>> output = ops.IsInstance()(inst, mindspore.int32)
+        >>> print(output)
+        False
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        pass
+
+    def __infer__(self, inst, type_):
+        sub_type_t = inst['dtype']
+        type_v = type_['value']
+
+        validator.check_value_type("type_", type_v, [mstype.Type], self.name)
+
+        if type_v == mstype.list_:
+            value = isinstance(sub_type_t, list)
+        elif type_v == mstype.tuple_:
+            value = isinstance(sub_type_t, tuple)
+        else:
+            value = _is_subclass_(sub_type_t, type_v)
+
+        out = {'shape': (),
+               'dtype': mstype.type_type,
+               'value': value}
+        return out
+
+
+class ConvertToAdapterTensor(Primitive):
+    """
+    Convert a tensor from MindSpore's Tensor type to MSAdapter's Tensor type,
+    where MSAdapter's Tensor is a subclass of MindSpore's Tensor.
+
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        A tensor, whose type is MSAdapter's Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([1, 2 ,3])
+        >>> x = ops.ConvertToAdapterTensor()(x)
+        >>> print(x)
+        [1 2 3]
+    """
+    @prim_attr_register
+    def __init__(self):
+        """Initialize"""
+
+    def __call__(self, x):
+        """run in PyNative mode"""
+        return ms_adapter_registry.tensor(x, inner=True)
+
+convert_to_adapter_tensor = ConvertToAdapterTensor()
+
+
+class ConvertToMsTensor(Primitive):
+    """
+    Convert a tensor from MSAdapter's Tensor type to MindSpore's Tensor type,
+    where MSAdapter's Tensor is a subclass of MindSpore's Tensor.
+
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        A tensor, whose type is MindSpore's Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([1, 2 ,3])
+        >>> x = ops.ConvertToMsTensor()(x)
+        >>> print(x)
+        [1 2 3]
+    """
+    @prim_attr_register
+    def __init__(self):
+        """Initialize"""
+
+    def __call__(self, x):
+        """run in PyNative mode"""
+        return Tensor(x)
+
+convert_to_ms_tensor = ConvertToMsTensor()
+
+
+class GetGrad(Primitive):
+    """
+        Use the position id or Parameter object to get the gradient from the output
+        which returned by the :func:`mindspore.ops.grad`.
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize ScatterElements"""
+        self.init_prim_io_names(
+            inputs=['gradients', 'x'], outputs=['gradient'])
+
+    def __call__(self, gradients, x):
+        if not isinstance(x, int) and not isinstance(x, Parameter):
+            raise TypeError(
+                f"For `get_grad`, the `x` should be an integer or a Parameter, but got {x}")
+        hash_id = x
+        if isinstance(x, Parameter):
+            hash_id = x.name
+        output = None
+
+        def _get_grad(grads, identifier):
+            if isinstance(grads, tuple):
+                if len(grads) != 2 or identifier != grads[0]:
+                    for gradient in grads:
+                        _get_grad(gradient, identifier)
+                else:
+                    nonlocal output
+                    output = grads[1]
+                    return
+
+        _get_grad(gradients, hash_id)
+        if output is None:
+            raise RuntimeError(
+                f"Can not find the gradient for position or Parameter {x}")
+        return output
+
+
+class IsParameter(PrimitiveWithInfer):
+    """
+        Check if input is `Parameter`
+    """
+    @prim_attr_register
+    def __init__(self):
+        """Initialize IsParameter"""
+
+    def __call__(self, x):
+        return isinstance(x, Parameter)
+
+    def __infer__(self, x):
+        return {'shape': [],
+                'dtype': mstype.bool_,
+                'value': isinstance(x['dtype'], mstype.ref_type)}
+
+
+class SiLU(Primitive):
+    r"""
+    Computes SiLU (Sigmoid Linear Unit activation function) of input tensors element-wise.
+
+    Refer to :func:`mindspore.ops.silu` for more details.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> output = ops.SiLU(x)
+        >>> print(output)
+        [-0.269  1.762  -0.1423  1.762  -0.269]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize SiLU"""
+        self.init_prim_io_names(inputs=['x'], outputs=['output'])
+
+
+class TileSize(Primitive):
+    r"""
+        Tile size for matmul
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize TileSize"""
+        self.init_prim_io_names(inputs=['shape', 'out_shape', 'ndim'], outputs=['output'])
+
+    def __call__(self, shape, out_shape, ndim):
+        size = [1] * ndim
+        for idx, (i, j) in enumerate(zip(shape, out_shape)):
+            if i != j:
+                size[idx] = j
+        return tuple(size)
+
+
+class GetitemTensorIndexInfo(Primitive):
+    r"""
+        Get getitem tensor index info
+    """
+
+    @prim_attr_register
+    def __init__(self, is_ascend):
+        """Initialize GetitemTensorIndexInfo"""
+        self.init_prim_io_names(inputs=['data', 'index'],
+                                outputs=["new_index", "tensor_update_types", "tensor_update_args"])
+        validator.check_value_type('is_ascend', is_ascend, [bool], self.name)
+        self.is_ascend = is_ascend
+
+    def __call__(self, data, index):
+        return Tensor_.getitem_index_info(data, index, self.is_ascend)
+
+
+class SetitemTensorIndexInfo(Primitive):
+    r"""
+        Get setitem tensor index info
+    """
+
+    @prim_attr_register
+    def __init__(self, is_ascend):
+        """Initialize GetitemTensorIndexInfo"""
+        self.init_prim_io_names(
+            inputs=['data', 'index', 'value'], outputs=['new_index',
+                                                        'v_transfer_types',
+                                                        'v_transfer_args',
+                                                        'tensor_update_types',
+                                                        'tensor_update_args'])
+        validator.check_value_type('is_ascend', is_ascend, [bool], self.name)
+        self.is_ascend = is_ascend
+
+    def __call__(self, data, index, value):
+        return Tensor_.setitem_index_info(data, index, value, self.is_ascend)