mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/operations/_grad_ops.py

@@ -14,19 +14,29 @@
 # ============================================================================
 
 """Operators for gradients."""
-from  __future__ import division
 from __future__ import absolute_import
 
+from __future__ import division
 from mindspore._checkparam import _check_3d_int_or_tuple
 from mindspore.ops.operations.nn_ops import _check_positive_int_or_tuple
 from mindspore.ops import signature as sig
 from mindspore.ops._utils import get_concat_offset
 from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, prim_attr_register
 import mindspore.context as context
-from mindspore._checkparam import Validator as validator, Rel
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.communication.management import GlobalComm
-from mindspore.ops._utils import is_shape_unknown
+from mindspore.common._utils import is_shape_unknown, is_dim_unknown
+
+
+class SparseFillEmptyRowsGrad(Primitive):
+    """Performs grad of SparseFillEmptyRows operation."""
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize SparseFillEmptyRowsGrad."""
+        self.init_prim_io_names(inputs=['reverse_index_map', 'grad_values'],
+                                outputs=['y_values', 'y_default_value'])
 
 
 class AbsGrad(PrimitiveWithInfer):
@@ -104,6 +114,7 @@ class ReciprocalGrad(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize ReciprocalGrad"""
+        self.init_prim_io_names(inputs=['y', 'dy'], outputs=['z'])
 
 
 class RsqrtGrad(Primitive):
@@ -145,7 +156,7 @@ class BatchNormGrad(Primitive):
     @prim_attr_register
     def __init__(self, is_training=False, epsilon=1e-5, data_format='NCHW'):
         self.is_training = validator.check_value_type('is_training', is_training, (bool,), self.name)
-        self.epsilon = validator.check_float_range(epsilon, 0, 1, Rel.INC_RIGHT, 'epsilon', self.name)
+        self.epsilon = validator.check_float_range(epsilon, 0, 1, validator.INC_RIGHT, 'epsilon', self.name)
         self.data_format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.name)
 
 
@@ -155,7 +166,7 @@ class BatchNormGradGrad(Primitive):
     @prim_attr_register
     def __init__(self, is_training=False, epsilon=1e-5, data_format='NCHW'):
         self.is_training = validator.check_value_type('is_training', is_training, (bool,), self.name)
-        self.epsilon = validator.check_float_range(epsilon, 0, 1, Rel.INC_RIGHT, 'epsilon', self.name)
+        self.epsilon = validator.check_float_range(epsilon, 0, 1, validator.INC_RIGHT, 'epsilon', self.name)
         self.data_format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.name)
 
 
@@ -164,10 +175,10 @@ class SyncBatchNormGrad(Primitive):
 
     @prim_attr_register
     def __init__(self, epsilon=1e-5, group="group0", device_num=2):
-        validator.check_float_range(epsilon, 0, 1, Rel.INC_RIGHT, 'epsilon', self.name)
+        validator.check_float_range(epsilon, 0, 1, validator.INC_RIGHT, 'epsilon', self.name)
         if not isinstance(group, str):
             raise TypeError("The group attr of SyncBatchNormGrad must be 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)
 
 
 class BiasAddGrad(Primitive):
@@ -177,8 +188,6 @@ class BiasAddGrad(Primitive):
     def __init__(self, data_format="NCHW"):
         self.init_prim_io_names(inputs=['dout'], outputs=['output'])
         self.format = validator.check_string(data_format, ['NCHW', 'NHWC', 'NCDHW'], 'format', self.name)
-        if context.get_context("device_target") != "GPU" and self.format == "NHWC":
-            raise ValueError("NHWC format only support in GPU target.")
         if self.format == "NCDHW":
             self.format = "NCHW"
         self.add_prim_attr('data_format', self.format)
@@ -232,10 +241,27 @@ class ConcatOffset(PrimitiveWithInfer):
         x_type = input_x['dtype']
         self.add_prim_attr('T', x_type[0].element_type())
 
+        # input_x is dynamic rank
+        rank = -1
+        is_dyn_rank = False
+        for _, sh in enumerate(x_shp):
+            if is_dim_unknown(sh):
+                is_dyn_rank = True
+            else:
+                rank = len(sh)
+        if is_dyn_rank:
+            return {
+                'shape': [len(x_shp), rank],
+                'dtype': mstype.int64,
+                'value': None
+            }
+
         # if the dimension of input_x on the axis is dynamic
-        rank_base = len(x_shp[0])
+        if axis < -rank or axis >= rank:
+            raise ValueError("For 'ConcatOffset', 'axis' must be in range [{}, {}), but got {}"
+                             .format(-rank, rank, axis))
         if axis < 0:
-            axis = axis + rank_base
+            axis = axis + rank
         for each in x_shp:
             if each[axis] == -1:
                 return {
@@ -466,9 +492,6 @@ class DepthwiseConv2dNativeBackpropFilter(PrimitiveWithInfer):
         self.group = group
         self.add_prim_attr('data_format', "NCHW")
 
-    def __call__(self, x, w_size, dout):
-        raise NotImplementedError
-
     def __infer__(self, x, w_size, dout):
         w_size_v = w_size['value']
         args = {'x': x['dtype'], 'dout': dout['dtype']}
@@ -533,9 +556,6 @@ class DepthwiseConv2dNativeBackpropInput(PrimitiveWithInfer):
         self.group = group
         self.add_prim_attr('data_format', "NCHW")
 
-    def __call__(self, x_size, w, dout):
-        raise NotImplementedError
-
     def __infer__(self, x_size, w, dout):
         args = {'w': w['dtype'], 'dout': dout['dtype']}
         validator.check_tensors_dtypes_same_and_valid(args, mstype.number_type, self.name)
@@ -571,7 +591,7 @@ class DropoutGrad(Primitive):
 
     @prim_attr_register
     def __init__(self, keep_prob=0.5):
-        self.keep_prob = validator.check_float_range(keep_prob, 0, 1, Rel.INC_RIGHT, "keep_prob", self.name)
+        self.keep_prob = validator.check_float_range(keep_prob, 0, 1, validator.INC_RIGHT, "keep_prob", self.name)
 
 
 class FlattenGrad(PrimitiveWithInfer):
@@ -599,6 +619,18 @@ class InstanceNormGrad(PrimitiveWithInfer):
                                 outputs=['dx', 'bn_gamma', 'bn_beta'])
 
 
+class InstanceNormV2Grad(Primitive):
+    """Gradients of InstanceNormV2 operation."""
+
+    @prim_attr_register
+    def __init__(self, is_training=True, epsilon=1e-5):
+        self.init_prim_io_names(inputs=['dy', 'x', 'gamma', 'mean', 'variance', 'save_mean', 'save_variance'],
+                                outputs=['pd_x', 'pd_gamma', 'pd_beta'])
+        validator.check_is_float(epsilon, 'epsilon', self.name)
+        validator.check_float_range(epsilon, 0, 1, validator.INC_RIGHT, 'epsilon', self.name)
+        validator.check_bool(is_training, "is_training", self.name)
+
+
 class EinsumGrad(PrimitiveWithInfer):
     """Gradients of Einsum."""
 
@@ -626,9 +658,6 @@ class UniqueGrad(Primitive):
     def __init__(self):
         self.init_prim_io_names(inputs=['dy', 'y'], outputs=['dx'])
 
-    def __call__(self, dy, x, scale, save_mean, save_inv_variance):
-        raise NotImplementedError
-
 
 class BNTrainingReduceGrad(Primitive):
     """Gradients of FusedBatchNorm operation."""
@@ -666,7 +695,7 @@ class NeighborExchangeV2Grad(PrimitiveWithInfer):
 
     def __infer__(self, dy):
         dy_shape = dy['shape']
-        validator.check(f'dy_shape.size()', len(dy_shape), f'4', 4, Rel.EQ, self.name)
+        validator.check(f'dy_shape.size()', len(dy_shape), f'4', 4, validator.EQ, self.name)
         if self.send_rank_ids[5] != -1 or self.send_rank_ids[6] != -1 or self.send_rank_ids[7] != -1:
             dy_shape[3] -= self.send_lens[2]
 
@@ -683,9 +712,6 @@ class NeighborExchangeV2Grad(PrimitiveWithInfer):
                 'dtype': dy['dtype'],
                 'value': None}
 
-    def __call__(self, tensor):
-        raise NotImplementedError
-
 
 class GeLUGrad(Primitive):
     """Gradients of GeLU operation."""
@@ -853,18 +879,13 @@ class AvgPoolGradV1(Primitive):
         self.add_prim_attr("strides", self.strides_adapt)
 
 
-class AdaptiveAvgPool2DGrad(PrimitiveWithInfer):
+class AdaptiveAvgPool2DGrad(Primitive):
     """Gradients of the adaptive avg pool 2D operation."""
 
     @prim_attr_register
     def __init__(self):
         """Initialize AdaptiveAvgPool2DGrad"""
-
-    def infer_shape(self, x1_shape, grad_shape):
-        return x1_shape
-
-    def infer_dtype(self, x1_dtype, grad_dtype):
-        return x1_dtype
+        self.init_prim_io_names(inputs=['input_grad', 'orig_input_shape'], outputs=['output_grad'])
 
 
 class AdaptiveAvgPool3DGrad(Primitive):
@@ -872,7 +893,6 @@ class AdaptiveAvgPool3DGrad(Primitive):
     @prim_attr_register
     def __init__(self):
         self.init_prim_io_names(inputs=['y_grad', 'orig_input_shape'], outputs=['x_grad'])
-        self.set_const_input_indexes([1])
 
 
 class AvgPool3DGrad(Primitive):
@@ -1180,9 +1200,6 @@ class MaximumGrad(Primitive):
         """Initialize MaximumGrad"""
         self.init_prim_io_names(inputs=['x1', 'x2', 'grads'], outputs=['y1', 'y2'])
 
-    def __call__(self, x, y, dout):
-        raise NotImplementedError
-
 
 class MaximumGradGrad(Primitive):
     """Grad for maximum grad."""
@@ -1194,13 +1211,71 @@ class MaximumGradGrad(Primitive):
         self.init_prim_io_names(inputs=['x1', 'x2', 'dy1', 'dy2'], outputs=['sopd_x1', 'sopd_x2', 'sopd_grad'])
 
 
-class MaxPoolGradWithArgmax(_PoolGrad):
+class MaxPoolGradWithArgmax(Primitive):
     """Computes the gradients of MaxPoolWithArgmax."""
+    @prim_attr_register
+    def __init__(self, kernel_size=1, strides=1, pad_mode="VALID", data_format="NCHW"):
+        self.init_prim_io_names(inputs=['x_origin', 'out_origin', 'grad'], outputs=['output'])
+        validator.check_value_type('kernel_size', kernel_size, [int, tuple], self.name)
+        validator.check_value_type('strides', strides, [int, tuple], self.name)
+        validator.check_value_type('pad_mode', pad_mode, [str], self.name)
+        self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.name)
+        self.add_prim_attr("pad_mode", self.pad_mode)
+        self.format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.name)
+        if context.get_context("device_target") != "GPU" and self.format == "NHWC":
+            raise ValueError("NHWC format only support in GPU target.")
+        self.is_maxpoolgradwithargmax = (self.name == "MaxPoolGradWithArgmax")
+        if not self.is_maxpoolgradwithargmax:
+            self.add_prim_attr('data_format', self.format)
+
+        def _grad_check_int_or_tuple(arg_name, arg_val):
+            validator.check_value_type(arg_name, arg_val, (int, tuple), self.name)
+            error_msg = ValueError(f"For '{self.name}' the '{arg_name}' must be an positive int number "
+                                   f"or a tuple of two or four positive int numbers, but got {arg_val}")
+            if isinstance(arg_val, int):
+                ret = (1, arg_val, arg_val, 1)
+            elif len(arg_val) == 2:
+                ret = (1, arg_val[0], arg_val[1], 1)
+            elif len(arg_val) == 4:
+                ret = arg_val
+            else:
+                raise error_msg
+            # whether all elements of tuple are positive integers
+            for item in ret:
+                if not isinstance(item, int) or item <= 0:
+                    raise error_msg
+            return ret
+
+        kernel_size = _grad_check_int_or_tuple("kernel_size", kernel_size)
+        self.kernel_size = kernel_size
+        self.add_prim_attr("kernel_size", self.kernel_size)
+
+        strides = _grad_check_int_or_tuple("strides", strides)
+        self.strides = strides
+        self.add_prim_attr("strides", self.strides)
+
+
+class MaxPoolGradWithArgmaxV2(Primitive):
+    """Gradients of the MaxPoolWithArgmaxV2 operation."""
 
     @prim_attr_register
-    def __init__(self, kernel_size=1, strides=1, pad_mode="VALID"):
-        self.init_prim_io_names(inputs=['x', 'grad', 'argmax'], outputs=['output'])
-        super(MaxPoolGradWithArgmax, self).__init__(kernel_size, strides, pad_mode)
+    def __init__(self, kernel_size, strides=None, pads=0, dilation=(1, 1), ceil_mode=False, argmax_type=mstype.int64):
+        self.init_prim_io_names(inputs=['x', 'grad', 'argmax'], outputs=['y'])
+        self.kernel_size = _check_positive_int_or_tuple("kernel_size", kernel_size, self.name, allow_four=True,
+                                                        ret_four=True)
+        self.add_prim_attr('kernel_size', self.kernel_size)
+        if strides is None:
+            strides = kernel_size
+        self.strides = _check_positive_int_or_tuple("strides", strides, self.name, allow_four=True, ret_four=True)
+        self.add_prim_attr('strides', self.strides)
+        self.pads = _check_positive_int_or_tuple("pads", pads, self.name, allow_four=True, ret_four=True,
+                                                 strict_positive=False)
+        self.add_prim_attr('pads', self.pads)
+        validator.check_value_type('ceil_mode', ceil_mode, bool, self.name)
+        self.add_prim_attr('ceil_mode', self.ceil_mode)
+        self.dilation = _check_positive_int_or_tuple("dilation", dilation, self.name, allow_four=True, ret_four=True)
+        self.add_prim_attr('dilation', self.dilation)
+        self.add_prim_attr('argmax_type', self.argmax_type)
 
 
 class MaxPool3DGradWithArgmax(Primitive):
@@ -1292,9 +1367,6 @@ class MinimumGrad(Primitive):
         """Initialize MinimumGrad"""
         self.init_prim_io_names(inputs=['x1', 'x2', 'grads'], outputs=['y1', 'y2'])
 
-    def __call__(self, x, y, dout):
-        raise NotImplementedError
-
 
 class MinimumGradGrad(Primitive):
     """Grad for minimum_grad."""
@@ -1354,9 +1426,6 @@ class LayerNormGrad(Primitive):
         self.begin_norm_axis = validator.check_value_type('begin_norm_axis', begin_norm_axis, [int], self.name)
         self.begin_params_axis = validator.check_value_type('begin_params_axis', begin_params_axis, [int], self.name)
 
-    def __call__(self, x, dy, variance, mean, gamma):
-        raise NotImplementedError
-
 
 class LayerNormGradGrad(Primitive):
     """
@@ -1389,7 +1458,7 @@ class LayerNormGradGrad(Primitive):
         ValueError: If gamma, d_dg, d_db don't have the same shape.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1397,6 +1466,8 @@ class LayerNormGradGrad(Primitive):
         """init"""
         self.begin_norm_axis = validator.check_value_type('begin_norm_axis', begin_norm_axis, [int], self.name)
         self.begin_params_axis = validator.check_value_type('begin_params_axis', begin_params_axis, [int], self.name)
+        self.init_prim_io_names(inputs=['x', 'dy', 'variance', 'mean', 'gamma', 'd_dx', 'd_dg', 'd_db'],
+                                outputs=['sopd_x', 'sopd_dy', 'sopd_gamma'])
 
 
 class LogSoftmaxGrad(Primitive):
@@ -1408,7 +1479,7 @@ class LogSoftmaxGrad(Primitive):
         validator.check_value_type("axis", axis, [int], self.name)
 
 
-class LSTMGradData(PrimitiveWithInfer):
+class LSTMGradData(Primitive):
     """Computes the data gradients of LSTM."""
 
     @prim_attr_register
@@ -1419,43 +1490,15 @@ class LSTMGradData(PrimitiveWithInfer):
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
         self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
-        self.dropout = validator.check_float_range(dropout, 0, 1, Rel.INC_BOTH, 'dropout', self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
 
         if bidirectional:
             self.num_directions = 2
         else:
             self.num_directions = 1
 
-    def infer_shape(self, y_shape, dy_shape, dhy_shape, dcy_shape, w_shape,
-                    hx_shape, cx_shape, reserve_shape, state_shape):
-        # dhy and dcy should be same shape
-        validator.check_equal_int(len(dhy_shape), 3, "h_shape", self.name)
-        validator.check_equal_int(len(dhy_shape), len(dcy_shape), "h_shape", self.name)
-        validator.check_equal_int(dhy_shape[0], dcy_shape[0], "h_shape[0]", self.name)
-        validator.check_equal_int(dhy_shape[1], dcy_shape[1], "h_shape[1]", self.name)
-        validator.check_equal_int(dhy_shape[2], dcy_shape[2], "h_shape[2]", self.name)
-
-        validator.check_int(dhy_shape[0], self.num_layers * self.num_directions, Rel.EQ, "h_shape[0]", self.name)
-        validator.check_equal_int(dhy_shape[2], self.hidden_size, "h_shape[2]", self.name)
-
-        validator.check_equal_int(len(dy_shape), 3, "dy_shape", self.name)
-        validator.check_equal_int(dy_shape[1], dhy_shape[1], "dy[1]", self.name)
-        validator.check_int(dy_shape[2], self.hidden_size * self.num_directions, Rel.EQ, "dy[2]", self.name)
-
-        dx_shape = (y_shape[0], y_shape[1], self.input_size)
-        dhx_shape = dhy_shape
-        dcx_shape = dcy_shape
 
-        return (dx_shape, dhx_shape, dcx_shape)
-
-    def infer_dtype(self, y_dtype, dy_dtype, dhy_dtype, dcy_dtype, w_dtype,
-                    hx_dtype, cx_dtype, reserve_dtype, state_dtype):
-        args = {"dy": dy_dtype, "dhy": dhy_dtype, "dcy": dcy_dtype}
-        validator.check_tensors_dtypes_same_and_valid(args, (mstype.float32, mstype.float16), self.name)
-        return (dy_dtype, dy_dtype, dy_dtype)
-
-
-class LSTMGradWeight(PrimitiveWithInfer):
+class LSTMGradWeight(Primitive):
     """Computes the weight gradients of LSTM."""
 
     @prim_attr_register
@@ -1466,31 +1509,15 @@ class LSTMGradWeight(PrimitiveWithInfer):
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
         self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
-        self.dropout = validator.check_float_range(dropout, 0, 1, Rel.INC_BOTH, 'dropout', self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
 
         if bidirectional:
             self.num_directions = 2
         else:
             self.num_directions = 1
 
-    def infer_shape(self, x_shape, hx_shape, y_shape, reserve_shape, state_shape):
-        weight_size = 0
-        gate_size = 4 * self.hidden_size
-        for layer in range(self.num_layers):
-            for _ in range(self.num_directions):
-                input_layer_size = self.input_size if layer == 0 else self.hidden_size * self.num_directions
-                weight_size += gate_size * input_layer_size
-                weight_size += gate_size * self.hidden_size
-                if self.has_bias:
-                    weight_size += 2 * gate_size
-
-        return (weight_size, 1, 1)
 
-    def infer_dtype(self, x_dtype, hx_dtype, y_dtype, reserve_dtype, state_dtype):
-        return hx_dtype
-
-
-class LSTMGrad(PrimitiveWithInfer):
+class LSTMGrad(Primitive):
     """Computes the data and weight gradients of LSTM."""
 
     @prim_attr_register
@@ -1501,50 +1528,15 @@ class LSTMGrad(PrimitiveWithInfer):
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
         self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
-        self.dropout = validator.check_float_range(dropout, 0, 1, Rel.INC_BOTH, 'dropout', self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
 
         if bidirectional:
             self.num_directions = 2
         else:
             self.num_directions = 1
 
-    def infer_shape(self, x_shape, hx_shape, cx_shape, w_shape, y_shape, hy_shape, cy_shape, dy_shape, dhy_shape,
-                    dcy_shape, reserve_shape):
-        # dhy and dcy should be same shape
-        validator.check_equal_int(len(dhy_shape), 3, "h_shape", self.name)
-        validator.check_equal_int(len(dhy_shape), len(dcy_shape), "h_shape", self.name)
-        validator.check_equal_int(dhy_shape[0], dcy_shape[0], "h_shape[0]", self.name)
-        validator.check_equal_int(dhy_shape[1], dcy_shape[1], "h_shape[1]", self.name)
-        validator.check_equal_int(dhy_shape[2], dcy_shape[2], "h_shape[2]", self.name)
-
-        validator.check_int(dhy_shape[0], self.num_layers * self.num_directions, Rel.EQ, "h_shape[0]", self.name)
-        validator.check_equal_int(dhy_shape[2], self.hidden_size, "h_shape[2]", self.name)
 
-        validator.check_equal_int(len(dy_shape), 3, "dy_shape", self.name)
-        validator.check_equal_int(dy_shape[1], dhy_shape[1], "dy[1]", self.name)
-        validator.check_int(dy_shape[2], self.hidden_size * self.num_directions, Rel.EQ, "dy[2]", self.name)
-
-        dx_shape = (y_shape[0], y_shape[1], self.input_size)
-        dhx_shape = dhy_shape
-        dcx_shape = dcy_shape
-        weight_size = 0
-        gate_size = 4 * self.hidden_size
-        for layer in range(self.num_layers):
-            for _ in range(self.num_directions):
-                input_layer_size = self.input_size if layer == 0 else self.hidden_size * self.num_directions
-                weight_size += gate_size * input_layer_size
-                weight_size += gate_size * self.hidden_size
-                if self.has_bias:
-                    weight_size += gate_size
-
-        return (dx_shape, dhx_shape, dcx_shape, (weight_size, 1, 1))
-
-    def infer_dtype(self, x_dtype, hx_dtype, cx_dtype, w_dtype, y_dtype, hy_dtype, cy_dtype, dy_dtype, dhy_dtype,
-                    dcy_dtype, reserve_dtype):
-        return (dy_dtype, dy_dtype, dy_dtype, hx_dtype)
-
-
-class DynamicRNNGrad(PrimitiveWithInfer):
+class DynamicRNNGrad(Primitive):
     """Computes the input gradients of DynamicRNN."""
 
     @prim_attr_register
@@ -1560,35 +1552,6 @@ class DynamicRNNGrad(PrimitiveWithInfer):
                  forget_bias=0.0):
         self.forget_bias = validator.check_value_type("forget_bias", forget_bias, [float], self.name)
 
-    def infer_shape(self, x_shape, w_shape, b_shape, y_shape, init_h_shape, init_c_shape, h_shape,
-                    c_shape, dy_shape, dh_shape, dc_shape, i_shape, j_shape, f_shape, o_shape, tanhc_shape):
-        validator.check_equal_int(len(x_shape), 3, "x_shape", self.name)
-        num_step, batch_size, input_size = x_shape
-        hidden_size = w_shape[-1] // 4
-        if w_shape[-1] % 4 != 0:
-            raise ValueError(f"For {self.name}, w_shape[-1] should multiple of 4.")
-        validator.check("w_shape[0]", w_shape[0], "input_size + hidden_size",
-                        input_size + hidden_size, Rel.EQ, self.name)
-        valid_shape = [num_step, batch_size, hidden_size]
-        validator.check("b_shape[0]", b_shape[0], "w_shape[1]", w_shape[1], Rel.EQ, self.name)
-        validator.check("y_shape", y_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("h_shape", h_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("c_shape", c_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("i_shape", i_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("j_shape", j_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("f_shape", f_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("o_shape", o_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("tanhc_shape", tanhc_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("dy_shape", dy_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("dh_shape", dh_shape, "excepted shape", [batch_size, hidden_size], Rel.EQ, self.name)
-        validator.check("dc_shape", dc_shape, "excepted shape", [batch_size, hidden_size], Rel.EQ, self.name)
-
-        return w_shape, (w_shape[1],), x_shape, dh_shape, dc_shape
-
-    def infer_dtype(self, x_dtype, w_dtype, b_dtype, y_dtype, init_h_dtype, init_c_dtype, h_dtype,
-                    c_dtype, dy_dtype, dh_dtype, dc_dtype, i_dtype, j_dtype, f_dtype, o_dtype, tanhc_dtype):
-        return x_dtype, x_dtype, x_dtype, x_dtype, x_dtype
-
 
 class GruGradData(PrimitiveWithInfer):
     """Computes the data gradients of GRU."""
@@ -1601,7 +1564,7 @@ class GruGradData(PrimitiveWithInfer):
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
         self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
-        self.dropout = validator.check_float_range(dropout, 0, 1, Rel.INC_BOTH, 'dropout', self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
 
         if bidirectional:
             self.num_directions = 2
@@ -1613,12 +1576,12 @@ class GruGradData(PrimitiveWithInfer):
         # dhy and dcy should be same shape
         validator.check_equal_int(len(dhy_shape), 3, "h_shape", self.name)
 
-        validator.check_int(dhy_shape[0], self.num_layers * self.num_directions, Rel.EQ, "h_shape[0]", self.name)
+        validator.check_int(dhy_shape[0], self.num_layers * self.num_directions, validator.EQ, "h_shape[0]", self.name)
         validator.check_equal_int(dhy_shape[2], self.hidden_size, "h_shape[2]", self.name)
 
         validator.check_equal_int(len(dy_shape), 3, "dy_shape", self.name)
         validator.check_equal_int(dy_shape[1], dhy_shape[1], "dy[1]", self.name)
-        validator.check_int(dy_shape[2], self.hidden_size * self.num_directions, Rel.EQ, "dy[2]", self.name)
+        validator.check_int(dy_shape[2], self.hidden_size * self.num_directions, validator.EQ, "dy[2]", self.name)
 
         dx_shape = (y_shape[0], y_shape[1], self.input_size)
         dhx_shape = dhy_shape
@@ -1643,7 +1606,7 @@ class GruGradWeight(PrimitiveWithInfer):
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
         self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
-        self.dropout = validator.check_float_range(dropout, 0, 1, Rel.INC_BOTH, 'dropout', self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
 
         if bidirectional:
             self.num_directions = 2
@@ -1667,7 +1630,26 @@ class GruGradWeight(PrimitiveWithInfer):
         return hx_dtype
 
 
-class DynamicGRUV2Grad(PrimitiveWithInfer):
+class GRUV2Grad(Primitive):
+    """Computes the grad gradients of GRU."""
+
+    @prim_attr_register
+    def __init__(self, input_size, hidden_size, num_layers, has_bias, bidirectional, dropout):
+        self.input_size = validator.check_positive_int(input_size, 'input_size', self.name)
+        self.hidden_size = validator.check_positive_int(hidden_size, 'hidden_size', self.name)
+        self.num_layers = validator.check_positive_int(num_layers, 'num_layers', self.name)
+        self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
+        self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
+        self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
+        self.dropout = validator.check_float_range(dropout, 0, 1, validator.INC_BOTH, 'dropout', self.name)
+
+        if bidirectional:
+            self.num_directions = 2
+        else:
+            self.num_directions = 1
+
+
+class DynamicGRUV2Grad(Primitive):
     r"""
     Computes the input gradients of DynamicGRUV2.
 
@@ -1719,13 +1701,13 @@ class DynamicGRUV2Grad(PrimitiveWithInfer):
         - **dw_hidden** (Tensor) - A Tensor has the same shape as `weight_hidden`.
           Has the same type with input `x`.
         - **db_input** (Tensor) - A Tensor of shape :math:`(3 x hidden\_size)`.
-          Has the same type with input `x`.
+          Has the same type with input `init\_h`.
         - **db_hidden** (Tensor) - A Tensor of shape :math:`(3 x hidden\_size)`.
-          Has the same type with input `x`.
+          Has the same type with input `init\_h`.
         - **dx** (Tensor) - A Tensor of shape :math:`(num\_step, batch\_size, hidden\_size)`.
           Has the same type with input `x`.
         - **dh_prev** (Tensor) - A Tensor of shape :math:`(batch\_size, hidden\_size)`.
-          Has the same type with input `x`.
+          Has the same type with input `init\_h`.
     """
 
     @prim_attr_register
@@ -1746,62 +1728,14 @@ class DynamicGRUV2Grad(PrimitiveWithInfer):
         self.direction = validator.check_string(direction, ['UNIDIRECTIONAL'], "direction", self.name)
         self.gate_order = validator.check_string(gate_order, ['zrh', 'rzh'], "gate_order", self.name)
         self.reset_after = validator.check_value_type("reset_after", reset_after, [bool], self.name)
-
-    def infer_shape(self, x_shape, winput_shape, whidden_shape, y_shape, init_h_shape, h_shape,
-                    dy_shape, dh_shape, update_shape, reset_shape, new_shape, hnew_shape, seq_shape, mask_shape):
-        validator.check_int(len(x_shape), 3, Rel.EQ, "x shape", self.name)
-        validator.check_int(len(winput_shape), 2, Rel.EQ, "weight input shape rank", self.name)
-        validator.check_int(len(whidden_shape), 2, Rel.EQ, "weight hidden shape rank", self.name)
-        validator.check_int(len(y_shape), 3, Rel.EQ, "y shape rank", self.name)
-        num_step, batch_size, input_size = x_shape
-        hidden_size = whidden_shape[0]
-        validator.check("weight_hidden_shape[-1]", whidden_shape[-1], "3 * hidden_size",
-                        3 * hidden_size, Rel.EQ, self.name)
-        validator.check("weight_input_shape", winput_shape, "excepted shape",
-                        [input_size, 3 * hidden_size], Rel.EQ, self.name)
-        if self.num_proj > 0:
-            valid_y_shape = [num_step, batch_size, min(hidden_size, self.num_proj)]
-        else:
-            valid_y_shape = [num_step, batch_size, hidden_size]
-        validator.check("y_shape", y_shape, "excepted shape", valid_y_shape, Rel.EQ, self.name)
-
-        validator.check("init_h_shape", init_h_shape, "excepted shape",
-                        [batch_size, hidden_size], Rel.EQ, self.name)
-        valid_shape = [num_step, batch_size, hidden_size]
-        validator.check("h_shape", h_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("dy_shape", dy_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("dh_shape", dh_shape, "excepted shape",
-                        [batch_size, hidden_size], Rel.EQ, self.name)
-        validator.check("update_shape", update_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("reset_shape", reset_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("new_shape", new_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        validator.check("hnew_shape", hnew_shape, "excepted shape", valid_shape, Rel.EQ, self.name)
-        if seq_shape is not None:
-            validator.check("seq_shape", seq_shape, "batch_size", batch_size, Rel.EQ, self.name)
-
-        dx_shape = (num_step, batch_size, input_size)
-        dh_shape = (batch_size, hidden_size)
-        dwinput_shape = (input_size, 3 * hidden_size)
-        dwhidden_shape = (hidden_size, 3 * hidden_size)
-        db_shape = (3 * hidden_size,)
-        return dwinput_shape, dwhidden_shape, db_shape, db_shape, dx_shape, dh_shape
-
-    def infer_dtype(self, x_dtype, winput_dtype, whidden_dtype, y_dtype, init_h_dtype, h_dtype,
-                    dy_dtype, dh_dtype, update_dtype, reset_dtype, new_dtype, hnew_dtype, seq_dtype, mask_dtype):
-        valid_types = (mstype.float16, mstype.float32)
-        args = {"y_dtype": y_dtype, "h_dtype": h_dtype, "dy_dtype": dy_dtype,
-                "dh_dtype": dh_dtype, "update_dtype": update_dtype, "reset_dtype": reset_dtype,
-                "new_dtype": new_dtype, "hnew_dtype": hnew_dtype}
-        validator.check_tensor_dtype_valid("x_dtype", x_dtype, valid_types, self.name)
-        validator.check_tensor_dtype_valid("winput_dtype", winput_dtype, valid_types, self.name)
-        validator.check_tensor_dtype_valid("whidden_dtype", whidden_dtype, valid_types, self.name)
-        validator.check_tensor_dtype_valid("init_h_dtype", init_h_dtype, valid_types, self.name)
-        validator.check_tensors_dtypes_same_and_valid(args, valid_types, self.name)
-        if seq_dtype is not None:
-            validator.check_tensor_dtype_valid("seq_dtype", seq_dtype, valid_types, self.name)
-        if mask_dtype is not None:
-            validator.check_tensor_dtype_valid("mask_dtype", mask_dtype, valid_types, self.name)
-        return x_dtype, x_dtype, x_dtype, x_dtype, x_dtype, x_dtype
+        self.init_prim_io_names(inputs=[
+            "x", "weight_input", "weight_hidden", "y", "init_h", "h", "dy",
+            "dh", "update", "reset", "new", "hidden_new", "seq_length", "mask"
+        ],
+                                outputs=[
+                                    "dw_input", "dw_hidden", "db_input",
+                                    "db_hidden", "dx", "dh_prev"
+                                ])
 
 
 class PReLUGrad(Primitive):
@@ -1825,6 +1759,44 @@ class PReLUGrad(Primitive):
         pass
 
 
+class RandomGammaGrad(Primitive):
+    r"""
+    Computes the derivative of a random sample of Gamma with respect to alpha.:
+
+    Inputs:
+        - **alpha** (Tensor) - α is the shape parameter of RandomGamma distribution.
+        It must be greater than 0. Must be one of the following types: float32, float64.
+        - **sample** (Tensor) - The sample of random gamma tensor. Must be one of the
+        following types: float32, float64.
+
+    Outputs:
+        The dtype is the same type as alpha.
+        The output shape is derived from the input through broadcasting.
+
+    Raises:
+        TypeError: If data type of `alpha` and `sample` is not float32 or float64.
+        TypeError: If data type of `alpha` and `sample` is not same.
+        ValueError: If the shape last dim of `sample` and `alpha` is not equal.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> alpha = Tensor(np.array([1., 0.6, 3., 26.]), mstype.float32)
+        >>> sample = Tensor(np.array([6., 7, 11., 0.5]), mstype.float32)
+        >>> randomgammagrad = ops.RandomGammaGrad()
+        >>> output = randomgammagrad(alpha, sample)
+        >>> print(output)
+        [2.5142431 3.4334087 1.8847835 0.07780622]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize RandomGammaGrad"""
+        self.init_prim_io_names(inputs=['alpha', 'sample'], outputs=['output'])
+        self.add_prim_attr("side_effect_hidden", True)
+
+
 class ReluGrad(Primitive):
     """Performs grad of Relu operation."""
 
@@ -1833,8 +1805,14 @@ class ReluGrad(Primitive):
         """Initialize ReluGrad"""
         self.init_prim_io_names(inputs=['y_backprop', 'x'], outputs=['output'])
 
-    def __call__(self, y_backprop, x):
-        raise NotImplementedError
+
+class SiLUGrad(Primitive):
+    """Performs grad of SiLU operation."""
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize SiLUGrad"""
+        self.init_prim_io_names(inputs=['dout', 'out'], outputs=['output'])
 
 
 class ReLU6Grad(Primitive):
@@ -1844,9 +1822,6 @@ class ReLU6Grad(Primitive):
     def __init__(self):
         self.init_prim_io_names(inputs=['y_grad', 'x'], outputs=['output'])
 
-    def __call__(self, y_grad, x):
-        raise NotImplementedError
-
 
 class ReluGradV2(Primitive):
     """Performs grad of ReLUV2 operation."""
@@ -1855,9 +1830,6 @@ class ReluGradV2(Primitive):
     def __init__(self):
         self.init_prim_io_names(inputs=['gradients', 'mask'], outputs=['output'])
 
-    def __call__(self, gradients, mask):
-        raise NotImplementedError
-
 
 class EluGrad(Primitive):
     """Performs grad of Elu operation."""
@@ -1885,12 +1857,9 @@ class GatherDGradV2(Primitive):
     """Performs grad of GatherD operation."""
 
     @prim_attr_register
-    def __init__(self, dim=0):
+    def __init__(self):
         """Initialize GatherDGradV2"""
-        validator.check_is_int(dim, int)
-        self.add_prim_attr("dim", dim)
-        self.dim = dim
-        self.init_prim_io_names(inputs=['x', 'index', 'grad'], outputs=['output'])
+        self.init_prim_io_names(inputs=['x', 'dim', 'index', 'grad'], outputs=['output'])
 
 
 class ResizeBilinearGrad(Primitive):
@@ -1907,9 +1876,6 @@ class ResizeBilinearGrad(Primitive):
         self.init_prim_io_names(inputs=['grads', 'original_image'], outputs=['y'])
         if half_pixel_centers and align_corners:
             raise ValueError(f"If half_pixel_centers is True, align_corners must be False, but got {align_corners}")
-        target = context.get_context("device_target")
-        if half_pixel_centers and target.lower() == "cpu":
-            raise ValueError(f"Currently `half_pixel_centers`=True not support in cpu device_target")
 
 
 class ResizeNearestNeighborGrad(Primitive):
@@ -1934,12 +1900,12 @@ class ResizeLinear1DGrad(Primitive):
     """
     Compute gradient of `ResizeLinear1D` operator.
 
-    Note:
-        This is an experimental feature and is subjected to change.
+    .. warning::
+        This is an experimental API that is subject to change.
 
     Args:
         coordinate_transformation_mode (string): Default is 'align_corners'. Describes how to transform the coordinate
-            in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel', 'asymmetric'.
+            in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel'.
     """
 
     @prim_attr_register
@@ -1949,7 +1915,7 @@ class ResizeLinear1DGrad(Primitive):
             inputs=['grads', 'input_x'], outputs=['y'])
         validator.check_value_type(
             "coordinate_transformation_mode", coordinate_transformation_mode, [str], self.name)
-        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel", "asymmetric"],
+        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel"],
                                "coordinate_transformation_mode", self.name)
 
 
@@ -1960,7 +1926,7 @@ class ResizeNearestNeighborV2Grad(Primitive):
     Args:
         align_corners (bool): Whether the centers of the 4 corner pixels of the input
             and output tensors are aligned. Default: False.
-        half_pixel_centers (bool): Default :False.
+        half_pixel_centers (bool): Default: False.
         data_format: An optional `string` that describes the format of the input `x` Defaults to `NHWC`.
     """
 
@@ -2012,7 +1978,7 @@ class UpsampleNearest3DGrad(Primitive):
         ValueError: If shape of `x` is not 5D.
 
     Supported Platforms:
-        ``GPU`` ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
     @prim_attr_register
     def __init__(self, input_size, output_size=None, scales=None):
@@ -2146,13 +2112,14 @@ class SliceGrad(PrimitiveWithInfer):
     def __infer__(self, dy, x, begin, size):
         dy_shape, x_shape, size_value, begin_v = dy['shape'], x['shape'], size['value'], begin['value']
         dy_shape_len = len(dy_shape)
-        if (size_value is not None) and not is_shape_unknown(x_shape):
+        if size_value is not None and not is_shape_unknown(x_shape) and not is_shape_unknown(dy_shape):
             size_value = list(size_value)
             for i in range(dy_shape_len):
                 if size_value[i] == -1:
                     size_value[i] = x_shape[i] - begin_v[i]
-                validator.check(f'dy_shape[{i}]', dy_shape[i], f'x_shape[{i}]', x_shape[i], Rel.LE, self.name)
-                validator.check(f'dy_shape[{i}]', dy_shape[i], f'size_shape[{i}]', size_value[i], Rel.EQ, self.name)
+                validator.check(f'dy_shape[{i}]', dy_shape[i], f'x_shape[{i}]', x_shape[i], validator.LE, self.name)
+                validator.check(f'dy_shape[{i}]', dy_shape[i], f'size_shape[{i}]',
+                                size_value[i], validator.EQ, self.name)
 
         return {'shape': x_shape,
                 'dtype': x['dtype'],
@@ -2175,6 +2142,7 @@ class SmoothL1LossGrad(Primitive):
 
     @prim_attr_register
     def __init__(self, beta=1.0, reduction='none'):
+        self.add_prim_attr('sigma', self.beta)
         self.reduction = validator.check_string(
             reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
 
@@ -2188,6 +2156,36 @@ class SoftMarginLossGrad(Primitive):
         self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
 
 
+class StridedSliceV2Grad(Primitive):
+    """
+    Performs grad of StridedSliceV2 operation.
+
+    Inputs:
+        - **shapex** (Tensor) - StridedSliceV2 shape of input
+        - **begin** (tuple[int]) - A tuple which represents the location where to start. Only
+          constant value is allowed.
+        - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
+          Only constant value is allowed.
+        - **strides** (tuple[int]) - A tuple which represents the stride is continuously added
+          before reaching the maximum location. Only constant value is allowed.
+        - **dy** (Tensor) - The output of StridedSliceV2
+
+    Outputs:
+        Tensor, the shape same as the input of StridedSliceV2
+    """
+
+    @prim_attr_register
+    def __init__(self,
+                 begin_mask=0,
+                 end_mask=0,
+                 ellipsis_mask=0,
+                 new_axis_mask=0,
+                 shrink_axis_mask=0):
+        """Initialize StridedSliceV2Grad"""
+        self.set_const_input_indexes([0])
+        self.init_prim_io_names(inputs=['shapex', 'begin', 'end', 'strides', 'dy'], outputs=['output'])
+
+
 class StridedSliceGrad(Primitive):
     """
     Performs grad of StridedSlice operation.
@@ -2256,7 +2254,7 @@ class PadV3Grad(Primitive):
         """Initialize Padv3Grad"""
         self.add_prim_attr("cust_aicpu", self.name)
         self.init_prim_io_names(inputs=['x', 'paddings'], outputs=['y'])
-        validator.check_string(mode, ['reflect', 'edge'], 'mode', self.name)
+        validator.check_string(mode, ['reflect', 'edge', 'circular'], 'mode', self.name)
         validator.check_bool(paddings_contiguous, "paddings_contiguous", self.name)
         self.set_const_input_indexes([1])
         self.mode = mode
@@ -2274,7 +2272,7 @@ class EmbeddingLookupCommGrad(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         self.init_prim_io_names(inputs=['dy', 'split_num'], outputs=['output'])
-        self.add_prim_attr('primitive_target', 'CPU')
+        self.set_device('CPU')
         self.tuple_setitem = Primitive('tuple_setitem')
 
     def __infer__(self, dy, split_num):
@@ -2352,20 +2350,20 @@ class BasicLSTMCellCStateGrad(PrimitiveWithInfer):
     def infer_shape(self, c_shape, dht_shape, dct_shape, it_shape, jt_shape, ft_shape, ot_shape, tanhct_shape):
         # dhy and dcy should be same shape
         validator.check_equal_int(len(c_shape), 2, "c rank", self.name)
-        validator.check("dht rank", len(dht_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("dct rank", len(dct_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("it rank", len(it_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("jt rank", len(jt_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("ft rank", len(ft_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("ot rank", len(ot_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("tanhct rank", len(tanhct_shape), "c rank", len(c_shape), Rel.EQ, self.name)
-        validator.check("dht shape", dht_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("dct shape", dct_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("it shape", it_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("jt shape", jt_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("ft shape", ft_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("ot shape", ot_shape, "c shape", c_shape, Rel.EQ, self.name)
-        validator.check("tanhct shape", tanhct_shape, "c shape", c_shape, Rel.EQ, self.name)
+        validator.check("dht rank", len(dht_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("dct rank", len(dct_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("it rank", len(it_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("jt rank", len(jt_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("ft rank", len(ft_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("ot rank", len(ot_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("tanhct rank", len(tanhct_shape), "c rank", len(c_shape), validator.EQ, self.name)
+        validator.check("dht shape", dht_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("dct shape", dct_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("it shape", it_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("jt shape", jt_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("ft shape", ft_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("ot shape", ot_shape, "c shape", c_shape, validator.EQ, self.name)
+        validator.check("tanhct shape", tanhct_shape, "c shape", c_shape, validator.EQ, self.name)
 
         dgate_shape = (c_shape[0], 4 * c_shape[1])
         dct_1_shape = c_shape
@@ -2401,11 +2399,11 @@ class BasicLSTMCellWeightGrad(PrimitiveWithInfer):
 
     def infer_shape(self, x_shape, h_shape, dgate_shape):
         validator.check_equal_int(len(x_shape), 2, "x rank", self.name)
-        validator.check("h rank", len(h_shape), " x rank", len(x_shape), Rel.EQ, self.name)
-        validator.check("dgate rank", len(dgate_shape), "x rank", len(x_shape), Rel.EQ, self.name)
-        validator.check("h_shape[0]", h_shape[0], "x_shape[0]", x_shape[0], Rel.EQ, self.name)
-        validator.check("dgate_shape[0]", dgate_shape[0], "h_shape[0]", h_shape[0], Rel.EQ, self.name)
-        validator.check("dgate_shape[1]", dgate_shape[1], "4*h_shape[1]", 4 * h_shape[1], Rel.EQ, self.name)
+        validator.check("h rank", len(h_shape), " x rank", len(x_shape), validator.EQ, self.name)
+        validator.check("dgate rank", len(dgate_shape), "x rank", len(x_shape), validator.EQ, self.name)
+        validator.check("h_shape[0]", h_shape[0], "x_shape[0]", x_shape[0], validator.EQ, self.name)
+        validator.check("dgate_shape[0]", dgate_shape[0], "h_shape[0]", h_shape[0], validator.EQ, self.name)
+        validator.check("dgate_shape[1]", dgate_shape[1], "4*h_shape[1]", 4 * h_shape[1], validator.EQ, self.name)
         input_size = x_shape[1]
         hidden_size = h_shape[1]
         dw_shape = (input_size + hidden_size, 4 * hidden_size)
@@ -2428,12 +2426,12 @@ class BasicLSTMCellInputGrad(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, keep_prob):
         self.keep_prob = validator.check_value_type("keep_prob", keep_prob, [float], self.name)
-        self.keep_prob = validator.check_float_range(keep_prob, 0.0, 1.0, Rel.INC_BOTH, "keep_prob", self.name)
+        self.keep_prob = validator.check_float_range(keep_prob, 0.0, 1.0, validator.INC_BOTH, "keep_prob", self.name)
 
     def infer_shape(self, dgate_shape, w_shape):
         validator.check_equal_int(len(dgate_shape), 2, "dgate rank", self.name)
         validator.check_equal_int(len(w_shape), 2, "w rank", self.name)
-        validator.check("dgate_shape[1]", dgate_shape[1], "w_shape[1]", w_shape[1], Rel.EQ, self.name)
+        validator.check("dgate_shape[1]", dgate_shape[1], "w_shape[1]", w_shape[1], validator.EQ, self.name)
         batch_size = dgate_shape[0]
         hidden_size = dgate_shape[1] // 4
         input_size = w_shape[0] - hidden_size
@@ -2457,7 +2455,7 @@ class InvGrad(Primitive):
         self.init_prim_io_names(inputs=['x', 'grad'], outputs=['y'])
 
 
-class LRNGrad(PrimitiveWithInfer):
+class LRNGrad(Primitive):
     """Computes gradients for LRN operation."""
 
     @prim_attr_register
@@ -2468,14 +2466,6 @@ class LRNGrad(PrimitiveWithInfer):
         validator.check_value_type("alpha", alpha, [float], self.name)
         validator.check_value_type("beta", beta, [float], self.name)
 
-    def infer_dtype(self, grads, x, y):
-        args = {"grads": grads, "x": x, "y": y}
-        validator.check_tensors_dtypes_same_and_valid(args, (mstype.float16, mstype.float32,), self.name)
-        return x
-
-    def infer_shape(self, grads, x, y):
-        return x
-
 
 class MvlgammaGrad(Primitive):
     r"""
@@ -2557,7 +2547,7 @@ class SoftShrinkGrad(Primitive):
     def __init__(self, lambd=0.5):
         self.init_prim_io_names(inputs=['input_grad', 'input_x'], outputs=['output'])
         validator.check_value_type("lambd", lambd, [float], self.name)
-        validator.check_number("lambd", lambd, 0, Rel.GE, self.name)
+        validator.check_number("lambd", lambd, 0, validator.GE, self.name)
 
 
 class CdistGrad(Primitive):
@@ -2594,7 +2584,7 @@ class PdistGrad(Primitive):
         ValueError: If dimension of `x` is not 2.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -2669,7 +2659,7 @@ class HShrinkGrad(Primitive):
         TypeError: If dtype of `gradients` or `features` is neither float16 nor float32.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -2726,7 +2716,7 @@ class Dilation2DBackpropInput(Primitive):
         ValueError: If `data_format` is not the str of 'NCHW'.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         (pad_mode="SAME", data_format="NCHW")
@@ -2843,7 +2833,7 @@ class Dilation2DBackpropFilter(Primitive):
 
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         (pad_mode="SAME", data_format="NCHW")
@@ -2990,7 +2980,7 @@ class MultiMarginLossGrad(Primitive):
     def __init__(self, p=1, margin=1.0, reduction="mean"):
         """Initialize MultiMarginLossGrad"""
         self.p = validator.check_value_type('p', p, [int], self.name)
-        validator.check_int(p, {1, 2}, Rel.IN, 'p', self.name)
+        validator.check_int(p, {1, 2}, validator.IN, 'p', self.name)
         self.margin = validator.check_value_type('margin', margin, [float], self.name)
         self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
         self.init_prim_io_names(inputs=['y_grad', 'x', 'target', 'weight'], outputs=['x_grad'])
@@ -3043,7 +3033,7 @@ class UpsampleTrilinear3DGrad(Primitive):
         ValueError: If elements number of `input_size` is not 5.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
     @prim_attr_register
     def __init__(self, input_size, output_size=None, scales=None, align_corners=False):
@@ -3111,7 +3101,7 @@ class GridSampler3DGrad(Primitive):
         ValueError: If the shape of `grad` is inconsistent with the shape of the output result of forward calculation.
 
     Supported Platforms:
-        ``CPU````GPU``
+        ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3156,7 +3146,7 @@ class SparseSegmentMeanGrad(Primitive):
         ValueError: If `indices` is out of range of `output_dim0`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3199,9 +3189,9 @@ class MaxUnpool2DGrad(Primitive):
         validator.check_value_type("pads", pads, [int, tuple], self.name)
         validator.check_value_type("output_shape", output_shape, [tuple], self.name)
         validator.check_string(data_format, ['NCHW', 'NHWC'], 'data_format', self.name)
-        validator.check_int(len(ksize), 4, Rel.EQ, "ksize rank", self.name)
-        validator.check_int(len(strides), 4, Rel.EQ, "strides rank", self.name)
-        validator.check_int(len(pads), 4, Rel.EQ, "pads rank", self.name)
+        validator.check_int(len(ksize), 4, validator.EQ, "ksize rank", self.name)
+        validator.check_int(len(strides), 4, validator.EQ, "strides rank", self.name)
+        validator.check_int(len(pads), 4, validator.EQ, "pads rank", self.name)
 
 
 class MaxUnpool3DGrad(Primitive):
@@ -3218,9 +3208,9 @@ class MaxUnpool3DGrad(Primitive):
         validator.check_value_type("pads", pads, [int, tuple], self.name)
         validator.check_value_type("output_shape", output_shape, [tuple], self.name)
         validator.check_string(data_format, ['NCDHW', 'NDHWC'], 'data_format', self.name)
-        validator.check_int(len(ksize), 5, Rel.EQ, "ksize rank", self.name)
-        validator.check_int(len(strides), 5, Rel.EQ, "strides rank", self.name)
-        validator.check_int(len(pads), 5, Rel.EQ, "pads rank", self.name)
+        validator.check_int(len(ksize), 5, validator.EQ, "ksize rank", self.name)
+        validator.check_int(len(strides), 5, validator.EQ, "strides rank", self.name)
+        validator.check_int(len(pads), 5, validator.EQ, "pads rank", self.name)
 
 
 class FractionalAvgPoolGrad(Primitive):
@@ -3269,6 +3259,7 @@ class AdaptiveMaxPool3DGrad(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize AdaptiveMaxPool3DGrad"""
+        self.init_prim_io_names(inputs=['input_grad', 'x', 'argmax'], outputs=['output_grad'])
 
 
 class TraceGrad(Primitive):
@@ -3292,7 +3283,7 @@ class TraceGrad(Primitive):
         ValueError: If length of shape of `x_shape` is not equal to 2.
 
     Support Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3564,7 +3555,7 @@ class GridSampler2DGrad(Primitive):
         ValueError: If the shape of `grad` is inconsistent with the shape of the output result of forward calculation.
 
     Supported Platforms:
-        ``CPU````GPU``
+        ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3605,7 +3596,7 @@ class ResizeBicubicGrad(Primitive):
         ValueError: If `size` dim is not 4.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
     @prim_attr_register
     def __init__(self, align_corners=False, half_pixel_centers=False):
@@ -3634,15 +3625,16 @@ class ResizeBicubicGrad(Primitive):
         validator.check_tensor_dtype_valid("original_image", original_image_dtype,
                                            [mstype.float32, mstype.float64], self.name)
         # check input shape rank
-        validator.check("grads rank", len(grads_shape), "expected", 4, Rel.EQ, self.name)
-        validator.check("original_image rank", len(original_image_shape), "expected", 4, Rel.EQ, self.name)
-        validator.check("batch_size equal", grads_shape[0], "expected", original_image_shape[0], Rel.EQ, self.name)
-        validator.check("channel equal", grads_shape[3], "expected", original_image_shape[3], Rel.EQ, self.name)
+        validator.check("grads rank", len(grads_shape), "expected", 4, validator.EQ, self.name)
+        validator.check("original_image rank", len(original_image_shape), "expected", 4, validator.EQ, self.name)
+        validator.check("batch_size equal", grads_shape[0], "expected",
+                        original_image_shape[0], validator.EQ, self.name)
+        validator.check("channel equal", grads_shape[3], "expected", original_image_shape[3], validator.EQ, self.name)
         # check original_image_shape and grads_shape
         validator.check("original_image[0] and grads[0]", original_image_shape[0],
-                        "expected", grads_shape[0], Rel.EQ, self.name)
+                        "expected", grads_shape[0], validator.EQ, self.name)
         validator.check("original_image[3] and grads[3]", original_image_shape[3],
-                        "expected", grads_shape[3], Rel.EQ, self.name)
+                        "expected", grads_shape[3], validator.EQ, self.name)
 
         batch_size = grads_shape[0]
         height = original_image_shape[1]
@@ -3660,38 +3652,41 @@ class SparseSliceGrad(Primitive):
 
     Inputs:
         - **backprop_val_grad** (Tensor) - A 1D Tensor.
-          The shape should be :math:`(n,)`.
-        - **indices** (Tensor) - A 2D Tensor of type int64. The indices of the SparseTensor.
+          The shape should be :math:`(N,)`.
+        - **indices** (Tensor) - A 2D Tensor (N x R matrix) of type int64. The indices of the SparseTensor.
           Support int64, each element value should be a non-negative int number. This tensor should be sorted.
-          The shape is :math:`(n, 2)`.
+          The shape is :math:`(N, R)`.
         - **start** (Tensor) - A 1D Tensor of type int64, represents the start of the indices.
-        - **new_indices** (Tensor) - A 2D Tensor of type int64. The indices of the SparseTensor.
+          The shape should be :math:`(R,)`.
+        - **new_indices** (Tensor) - A 2D Tensor (N x C matrix) of type int64. The indices of the SparseTensor.
           Support int64, each element value should be a non-negative int number. This tensor should be sorted.
-          The shape is :math:`(n, 2)`.
+          The shape is :math:`(N, C)`.
 
     Outputs:
-        - *y_grad_val: A Tensor. Has the same type as "backprop_val_grad".
+        - *y_grad_val: A Tensor. Has the same type as `backprop_val_grad`.
+          Has the same number as `indices`.
 
     Raises:
         TypeError: If the dtype of `indices`, `start`, `new_indices` are not int64.
         ValueError: If `indices`, `new_indices` are not 2-D tensor.
         ValueError: If `backprop_val_grad`, `start` is not a 1-D tensor.
         ValueError: If the number of `backprop_val_grad` is not corresponding to the number of `new_indices`.
-        RunTimeError: If the `backprop_val_grad` is not all backpropagated, because `indices` or `new_indices`
+        ValueError: If the shape of `indices[1]` is not corresponding to `start[1]`.
+        ValueError: If the shape of `indices[1]` is not corresponding to `new_indices[1]`.
+        RuntimeError: If the `backprop_val_grad` is not all backpropagated, because `indices` or `new_indices`
         is not sorted.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
     Examples:
-        >>> backprop_val_grad = Tensor([4, 2, 3])
-        >>> indices = Tensor([[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 4]], dtype=ms.int64)
-        >>> values = Tensor([1, 2, 3, 4])
-        >>> start = Tensor([0, 0], dtype=ms.int64)
-        >>> new_indices = Tensor([0, 2], [1, 2], [1, 3], dtype=ms.int64)
+        >>> backprop_val_grad = Tensor(np.array([1, 2, 3, 4]).astype(np.int64))
+        >>> indices = Tensor(np.array([[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 4]]).astype(np.int64))
+        >>> start = Tensor(np.array([0, 0]).astype(np.int64))
+        >>> new_indices = Tensor(np.array([[0, 2], [1, 2], [1, 3], [2, 4]]).astype(np.int64))
         >>> grad = SparseSliceGrad()
         >>> output = grad(backprop_val_grad, indices, start, new_indices)
         >>> print(output)
-        [0, 4, 2, 3, 0, 0]
+        [0 1 2 3 0 4]
     """
 
     @prim_attr_register
@@ -3726,7 +3721,7 @@ class FractionalMaxPoolGradWithFixedKsize(Primitive):
         ValueError: If the second dimension size of `origin_input` and `out_backprop` is not equal.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3736,9 +3731,139 @@ class FractionalMaxPoolGradWithFixedKsize(Primitive):
         self.init_prim_io_names(inputs=['origin_input', 'out_backprop', 'argmax'], outputs=['y'])
 
 
+class AffineGridGrad(Primitive):
+    r"""
+    Computes gradients for AffineGrid operation.
+
+    Args:
+        align_corners (bool): if True, consider -1 and 1 to refer to the centers
+            of the corner pixels rather than the image corners. Default: False.
+
+    Inputs:
+        - **y_grad** (Tensor) - Data type must be float16 or float32.
+        - **x_size** (tuple) - Data type must be int32 or int64.
+
+    Outputs:
+        Tensor, with data type same as `y_grad`.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import mindspore.ops.operations._grad_ops as _grad_ops
+        >>> affinegridgrad = _grad_ops.AffineGridGrad()
+        >>> y_grad = Tensor(np.ones([1, 2, 2, 2]), mindspore.float32)
+        >>> x_size = (1, 2, 2, 2)
+        >>> x_grad = affinegridgrad(y_grad, x_size)
+        >>> print(x_grad)
+        [[[0. 0. 4.]
+          [0. 0. 4.]]]
+    """
+
+    @prim_attr_register
+    def __init__(self, align_corners=False):
+        """Initialize AffineGridGrad."""
+        validator.check_value_type("align_corners", align_corners, [bool], self.name)
+        self.init_prim_io_names(inputs=['y_grad', 'x_size'], outputs=['x_grad'])
+
+
 class HSigmoidGrad(Primitive):
     """Gets the gradient of HSigmoid operation."""
     @prim_attr_register
     def __init__(self):
         """Initialize HSigmoidGrad"""
         self.init_prim_io_names(inputs=['grads', 'input_x'], outputs=['output'])
+
+
+class GluGrad(Primitive):
+    """
+    Computes grad for Glu operation.
+    """
+
+    @prim_attr_register
+    def __init__(self, axis):
+        self.add_prim_attr("cust_aicpu", self.name)
+        self.init_prim_io_names(inputs=["grads", "x"], outputs=["y"])
+        validator.check_value_type("axis", axis, [int], self.name)
+
+
+class CholeskyGrad(Primitive):
+    r"""
+    Computes the reverse mode backpropgated gradient of the Cholesky algorithm.
+
+    Inputs:
+        - **x** (Tensor) - A tensor with float32 or float64 data type.
+        - **grad** (Tensor) - A tensor with float32 or float64 data type. `x` should have
+          the same dtype with `a`.
+
+    Outputs:
+        Tensor, has the same dtype as `a` and `x`.
+
+    Raises:
+        TypeError: If x is not Tensor.
+        TypeError: If grad is not Tensor.
+        TypeError: If dtype of input x and grad is not float64 nor float32,
+        TypeError: If x has different dtype with grad.
+        ValueError: If input tensor's last two dims are not equal,
+        ValueError: If the shape of x and grad mismatch.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> x = Tensor(np.array([[4, 2],[2, 3]]), mstype.float64)
+        >>> grad = Tensor(np.array([[4, 2],[2, 3]]), mstype.float64)
+        >>> choleskygrad = G.CholeskyGrad()
+        >>> output = choleskygrad(x, grad)
+        >>> print (output)
+        [[0.5 0. ]
+         [0.  0.5]]
+
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize CholeskyGrad"""
+        self.init_prim_io_names(inputs=['x', 'grad'], outputs=['y'])
+
+
+class MapTensorGetGrad(Primitive):
+    """
+    Computes gradients for MapTensorGet operation.
+
+    Inputs:
+        - **map_tensor** (MapTensor) - The input `map_tensor` of the forward operator MapTensorGet.
+        - **key_tensor** (Tensor) - The input `key_tensor` of the forward operator MapTensorGet.
+        - **default_value** (Scalar) - The input `default_value` of the forward operator MapTensorGet.
+        - **grad** (Tensor) - The grad value according the forward operator MapTensorGet.
+
+    Outputs:
+        - **output** (MapTensor) -  MapTensor with grad values.
+    """
+    @prim_attr_register
+    def __init__(self):
+        """Initialize MapTensorGetGrad"""
+        self.init_prim_io_names(inputs=['map_tensor', 'key_tensor', 'default_value', 'grad'], outputs=['output'])
+        self.add_prim_attr('side_effect_mem', True)
+
+
+class ResizeV2Grad(Primitive):
+    r"""
+    Calculates the gradient of ResizeV2 operation.
+
+    Supported Platforms:
+        ``CPU``
+    """
+
+    @prim_attr_register
+    def __init__(self, coordinate_transformation_mode="half_pixel", mode="nearest"):
+        """Initialize ResizeV2Grad."""
+        self.init_prim_io_names(inputs=["grads", "roi", "scales", "original_size"], outputs=["y"])
+        self.add_prim_attr("nearest_mode", "floor")
+        self.add_prim_attr("cubic_coeff_a", -0.75)
+        validator.check_value_type(
+            "coordinate_transformation_mode", coordinate_transformation_mode, [str], self.name)
+        validator.check_string(coordinate_transformation_mode,
+                               ["align_corners", "half_pixel"], "coordinate_transformation_mode", self.name)
+        validator.check_value_type("mode", mode, [str], self.name)
+        validator.check_string(mode, ["nearest", "linear", "cubic"], "mode", self.name)