mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/operations/_inner_ops.py

@@ -21,21 +21,24 @@ import numpy as np
 from mindspore.common import Tensor
 from mindspore.ops import composite as C
 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.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]
@@ -555,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("diagonal shape", diagonal_shape, "x shape excluding the last dimension",
-                            x_shape[:-1], Rel.EQ, self.name)
+                            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
 
@@ -680,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)
@@ -730,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)
@@ -811,7 +792,7 @@ class SequenceMask(PrimitiveWithCheck):
         One mask tensor of shape lengths.shape + (maxlen,).
 
     Supported Platforms:
-        ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore import ops
@@ -831,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)
@@ -904,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)
@@ -970,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)
@@ -1071,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)
@@ -1154,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}")
 
@@ -1180,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
@@ -1196,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]
 
 
@@ -1464,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))
 
@@ -1489,7 +1477,7 @@ class DynamicBroadcastTo(Primitive):
         ValueError: if the target and input shapes are incompatible.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1502,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"""
@@ -1624,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)
@@ -1942,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]
@@ -2027,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):
@@ -2054,21 +2057,22 @@ class TopTypeof(Primitive):
     def __init__(self):
         self.prim = Primitive('TopTypeof')
         self.typeof_cache = {
-            'slice': _pynative_executor.constant_folding(self.prim, slice(None, None, None)),
-            'list': _pynative_executor.constant_folding(self.prim, []),
-            'tuple': _pynative_executor.constant_folding(self.prim, ()),
-            'Tensor': _pynative_executor.constant_folding(self.prim, Tensor(np.ones([1], dtype=np.float32))),
-            'NoneType': _pynative_executor.constant_folding(self.prim, None),
-            'int': _pynative_executor.constant_folding(self.prim, 0),
-            'bool': _pynative_executor.constant_folding(self.prim, False),
-            'ellipsis': _pynative_executor.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 _pynative_executor.constant_folding(self.prim, x)
 
@@ -2237,20 +2241,27 @@ class SameTypeShape(PrimitiveWithInfer):
         """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, Rel.EQ, self.name, TypeError)
-        validator.check('x shape', x.shape, 'y shape', y.shape, Rel.EQ, 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'], Rel.EQ, self.name, TypeError)
-        validator.check('x shape', x['shape'], 'y shape', y['shape'], Rel.EQ, 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.
@@ -2285,7 +2296,7 @@ class IsSubClass(PrimitiveWithInfer):
         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 = mstype._issubclass_(sub_type_t, type_v)  # pylint: disable=W0212
+        value = _is_subclass_(sub_type_t, type_v)
 
         out = {'shape': (),
                'dtype': mstype.type_type,
@@ -2335,9 +2346,204 @@ class IsInstance(PrimitiveWithInfer):
         elif type_v == mstype.tuple_:
             value = isinstance(sub_type_t, tuple)
         else:
-            value = mstype._issubclass_(sub_type_t, type_v)  # pylint: disable=W0212
+            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)