mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/_grad_ops.py

@@ -23,10 +23,10 @@ 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, is_dim_unknown
+from mindspore.common._utils import is_shape_unknown, is_dim_unknown
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -156,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)
 
 
@@ -166,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)
 
 
@@ -175,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):
@@ -591,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):
@@ -627,7 +627,7 @@ class InstanceNormV2Grad(Primitive):
         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, Rel.INC_RIGHT, '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)
 
 
@@ -695,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]
 
@@ -885,16 +885,7 @@ class AdaptiveAvgPool2DGrad(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize AdaptiveAvgPool2DGrad"""
-
-
-class AdaptiveAvgPool2DGradV1(Primitive):
-    """Gradients of the adaptive avg pool 2D V1 operation."""
-
-    @prim_attr_register
-    def __init__(self, orig_input_shape):
-        """Initialize AdaptiveAvgPool2DGradV1"""
-        self.init_prim_io_names(inputs=['input_grad'], outputs=['output_grad'])
-        self.add_prim_attr('orig_input_shape', self.orig_input_shape)
+        self.init_prim_io_names(inputs=['input_grad', 'orig_input_shape'], outputs=['output_grad'])
 
 
 class AdaptiveAvgPool3DGrad(Primitive):
@@ -1048,7 +1039,7 @@ class MaxPoolGradGrad(_PoolGrad):
         ValueError: If the shapes of `origin_input` and `grad` are not equal.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1220,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):
@@ -1291,7 +1340,7 @@ class MaxPoolGradGradWithArgmax(_PoolGrad):
         ValueError: If the shapes of `x` and `grad` are not equal.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1409,7 +1458,7 @@ class LayerNormGradGrad(Primitive):
         ValueError: If gamma, d_dg, d_db don't have the same shape.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -1430,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
@@ -1441,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
@@ -1488,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
@@ -1523,48 +1528,13 @@ 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(Primitive):
     """Computes the input gradients of DynamicRNN."""
@@ -1594,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
@@ -1606,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
@@ -1636,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
@@ -1660,6 +1630,25 @@ class GruGradWeight(PrimitiveWithInfer):
         return hx_dtype
 
 
+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.
@@ -1690,7 +1679,7 @@ class DynamicGRUV2Grad(Primitive):
         - **init_h** (Tensor) - Hidden state of initial time.
           Tensor of shape :math:`(batch\_size, hidden\_size)`.
           The data type must be float16 or float32.
-        - **h** (Tensor) - A Tensor of shape :math:`(num\_step, batch\_size, hidden_size)`.
+        - **h** (Tensor) - A Tensor of shape :math:`(num\_step, batch\_size, hidden\_size)`.
           The data type must be float16 or float32.
         - **dy** (Tensor) - Gradient of `y`, has the same shape and data type as `y`.
         - **dh** (Tensor) - Gradient of `h`, has the same shape and data type as `init_h`.
@@ -1712,13 +1701,13 @@ class DynamicGRUV2Grad(Primitive):
         - **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
@@ -1770,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."""
 
@@ -1779,6 +1806,15 @@ class ReluGrad(Primitive):
         self.init_prim_io_names(inputs=['y_backprop', 'x'], outputs=['output'])
 
 
+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):
     """Performs grad of ReLU6 operation."""
 
@@ -1864,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
@@ -1879,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)
 
 
@@ -2081,8 +2117,9 @@ class SliceGrad(PrimitiveWithInfer):
             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'],
@@ -2105,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)
 
@@ -2216,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
@@ -2312,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
@@ -2361,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)
@@ -2388,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
@@ -2417,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
@@ -2428,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"""
@@ -2466,7 +2496,7 @@ class MvlgammaGrad(Primitive):
         ValueError: If all elements of `x` are not greater than (p-1)/2.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
     """
 
     @prim_attr_register
@@ -2517,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):
@@ -2554,7 +2584,7 @@ class PdistGrad(Primitive):
         ValueError: If dimension of `x` is not 2.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -2629,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
@@ -2686,7 +2716,7 @@ class Dilation2DBackpropInput(Primitive):
         ValueError: If `data_format` is not the str of 'NCHW'.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         (pad_mode="SAME", data_format="NCHW")
@@ -2803,7 +2833,7 @@ class Dilation2DBackpropFilter(Primitive):
 
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         (pad_mode="SAME", data_format="NCHW")
@@ -2943,14 +2973,14 @@ class MultiMarginLossGrad(Primitive):
         ValueError: If rank of `x` is not 2 or rank of 'target' is not 1.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend``  ``CPU``
     """
 
     @prim_attr_register
     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'])
@@ -3003,7 +3033,7 @@ class UpsampleTrilinear3DGrad(Primitive):
         ValueError: If elements number of `input_size` is not 5.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
     @prim_attr_register
     def __init__(self, input_size, output_size=None, scales=None, align_corners=False):
@@ -3071,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:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3116,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
@@ -3159,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):
@@ -3178,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):
@@ -3253,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
@@ -3280,7 +3310,7 @@ class IgammaGradA(Primitive):
         ValueError: If `a` could not be broadcast to a tensor with shape of `x`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
@@ -3390,7 +3420,7 @@ class MedianGrad(Primitive):
         ValueError: If shape of `y_grad` is not the same as `y`.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
     """
 
     @prim_attr_register
@@ -3479,7 +3509,7 @@ class SparseSegmentSqrtNGrad(Primitive):
         ValueError: If `indices` is bigger than or equal to `output_dim0`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3525,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:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3566,7 +3596,7 @@ class ResizeBicubicGrad(Primitive):
         ValueError: If `size` dim is not 4.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
     @prim_attr_register
     def __init__(self, align_corners=False, half_pixel_centers=False):
@@ -3595,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]
@@ -3642,7 +3673,7 @@ class SparseSliceGrad(Primitive):
         ValueError: If the number of `backprop_val_grad` is not corresponding to the number of `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`
+        RuntimeError: If the `backprop_val_grad` is not all backpropagated, because `indices` or `new_indices`
         is not sorted.
 
     Supported Platforms:
@@ -3690,7 +3721,7 @@ class FractionalMaxPoolGradWithFixedKsize(Primitive):
         ValueError: If the second dimension size of `origin_input` and `out_backprop` is not equal.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
     """
 
     @prim_attr_register
@@ -3700,6 +3731,42 @@ 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
@@ -3778,3 +3845,25 @@ class MapTensorGetGrad(Primitive):
         """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)