mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/_grad_experimental/grad_nn_ops.py

@@ -17,335 +17,29 @@
 """Define the grad rules of neural network related operations."""
 from __future__ import absolute_import
 
-from mindspore import Tensor
-import mindspore.numpy as mnp
-from mindspore.ops import matmul
-from mindspore.ops.operations.nn_ops import GridSampler2D
-from mindspore.ops.operations.nn_ops import GridSampler3D
-from mindspore.ops.primitive import constexpr
 from mindspore.common import dtype as mstype
-from mindspore.ops._grad.grad_base import bprop_getters
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.operations import _grad_ops as G
-from mindspore.ops.operations.nn_ops import MaxUnpool2D
-from mindspore.ops.operations.nn_ops import MaxUnpool3D
-from mindspore.ops.operations.nn_ops import Dilation2D
+from mindspore.ops.operations.nn_ops import FractionalAvgPool
+from mindspore.ops.operations._grad_ops import FractionalAvgPoolGrad
 from mindspore.ops.operations.nn_ops import FractionalMaxPool
-from mindspore.ops.operations.nn_ops import SparseSoftmaxCrossEntropyWithLogitsV2
 from mindspore.ops.operations._grad_ops import FractionalMaxPoolGrad
 from mindspore.ops.operations.nn_ops import FractionalMaxPool3DWithFixedKsize
 from mindspore.ops.operations._grad_ops import FractionalMaxPool3DGradWithFixedKsize
-from mindspore.ops.operations.nn_ops import FractionalAvgPool
-from mindspore.ops.operations._grad_ops import FractionalAvgPoolGrad
-from mindspore.ops.operations.nn_ops import InstanceNormV2
-from mindspore.ops.operations._grad_ops import InstanceNormV2Grad
-from mindspore.ops.operations.nn_ops import MultiMarginLoss
-from mindspore.ops.operations.nn_ops import MultilabelMarginLoss
-from mindspore.ops.operations.nn_ops import NthElement
-from mindspore.ops.operations.nn_ops import UpsampleTrilinear3D
-from mindspore.ops.operations._grad_ops import UpsampleTrilinear3DGrad
-from mindspore.ops.operations.nn_ops import Pdist
-from mindspore.ops.operations._grad_ops import PdistGrad
-from mindspore.ops.operations.nn_ops import PSROIPooling
-from mindspore.ops.operations._grad_ops import PSROIPoolingGrad
-from mindspore.ops.operations.nn_ops import PadV3
-from mindspore.ops.operations._grad_ops import PadV3Grad
 from mindspore.ops.operations.nn_ops import AvgPoolV1
 from mindspore.ops.operations._grad_ops import AvgPoolGradV1
-from mindspore.ops.operations.nn_ops import UpsampleNearest3D
-from mindspore.ops.operations._grad_ops import UpsampleNearest3DGrad
-from mindspore.ops.operations.nn_ops import MaxPoolV1
-from mindspore.ops.operations._grad_ops import MaxPoolGradV1
-from mindspore.ops.operations.nn_ops import ReLUV3
-from mindspore.ops.operations._grad_ops import ReluGrad
-from mindspore.ops.operations.image_ops import ResizeLinear1D
-from mindspore.ops.operations.nn_ops import MaxPool3DWithArgmax
 from mindspore.ops.operations.nn_ops import MaxPoolWithArgmaxV2
 from mindspore.ops.operations.nn_ops import FractionalMaxPoolWithFixedKsize
 from mindspore.ops.operations._grad_ops import FractionalMaxPoolGradWithFixedKsize
-from mindspore.ops.operations.nn_ops import AdaptiveAvgPool3D
+from mindspore.ops.operations.nn_ops import WKV
+from mindspore.ops.operations._grad_ops import WKVGrad
 from mindspore.ops.operations.nn_ops import GLU
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool3D
-
-
-@bprop_getters.register(P.CTCLossV2)
-def get_bprop_ctc_loss_v2(self):
-    """Grad definition for `CTCLossV2` operation"""
-    ctc_loss_grad = P.CTCLossV2Grad(self.blank, self.reduction, self.zero_infinity)
-
-    def bprop(log_probs, targets, input_lengths, target_lengths, out, dout):
-        grad = ctc_loss_grad(dout[0], log_probs, targets, input_lengths, target_lengths, out[0], out[1])
-        return grad, zeros_like(targets), zeros_like(input_lengths), zeros_like(target_lengths)
-
-    return bprop
-
-
-@bprop_getters.register(InstanceNormV2)
-def get_bprop_instance_norm_v2(self):
-    """Grad definition for `InstanceNormV2` operation."""
-    grad_ops = InstanceNormV2Grad(self.is_training, self.epsilon)
-
-    def bprop(x, gamma, beta, mean, variance, out, dout):
-        saved_mean = out[1]
-        saved_variance = out[2]
-        grad_ops_out = grad_ops(dout[0], x, gamma, mean, variance, saved_mean, saved_variance)
-        dx = grad_ops_out[0]
-        dgamma = grad_ops_out[1]
-        dbeta = grad_ops_out[2]
-        pd_res = (dx, dgamma, dbeta, zeros_like(mean), zeros_like(variance))
-        return pd_res
-
-    return bprop
-
-
-@bprop_getters.register(P.SoftMarginLoss)
-def get_bprop_soft_margin_loss(self):
-    """Grad definition for `SoftMarginLoss` operation."""
-    grad = G.SoftMarginLossGrad(reduction=self.reduction)
-
-    def bprop(predict, label, out, dout):
-        dx = grad(predict, label, dout)
-        dy = grad(label, predict, dout)
-        return dx, dy
-
-    return bprop
-
-
-@bprop_getters.register(P.SoftShrink)
-def get_bprop_softshrink(self):
-    """Grad definition for `SoftShrink` operation."""
-    input_grad = G.SoftShrinkGrad(self.lambd)
-
-    def bprop(input_x, out, dout):
-        dx = input_grad(dout, input_x)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(P.HShrink)
-def get_bprop_hshrink(self):
-    """Grad definition for `HShrinkGrad` operation."""
-    grad = G.HShrinkGrad(self.lambd)
-
-    def bprop(features, out, gradients):
-        dx = grad(gradients, features)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(PadV3)
-def get_bprop_pad_v3(self):
-    """Grad definition for `PadV3` operation."""
-    mode = self.mode
-    if mode == 'constant':
-        pad_v3_grad = PadV3(mode, self.paddings_contiguous)
-    else:
-        pad_v3_grad = PadV3Grad(mode, self.paddings_contiguous)
-
-    def bprop(x, paddings, constant_values, out, dout):
-        if mode == 'constant':
-            if isinstance(paddings, (list, tuple)):
-                neg_paddings = tuple(-x for x in paddings)
-            else:
-                neg_paddings = -paddings
-            dx = pad_v3_grad(dout, neg_paddings, zeros_like(constant_values))
-        else:
-            dx = pad_v3_grad(dout, paddings)
-        return (dx, zeros_like(paddings), zeros_like(constant_values))
-
-    return bprop
-
-
-@bprop_getters.register(MultilabelMarginLoss)
-def get_bprop_multilabel_margin_loss(self):
-    """Grad definition for `MultilabelMarginLoss` operation."""
-    input_grad = G.MultilabelMarginLossGrad(reduction=self.reduction)
-
-    def bprop(x, target, out, dout):
-        dx = input_grad(dout[0], x, target, out[1])
-        return dx, zeros_like(target)
-
-    return bprop
-
-
-@bprop_getters.register(Dilation2D)
-def get_bprop_dilation2d(self):
-    """Grad definition for `Dilation2D` operation"""
-
-    input_grad = G.Dilation2DBackpropInput(stride=self.stride, dilation=self.dilation,
-                                           pad_mode=self.pad_mode, data_format=self.data_format)
-    filter_grad = G.Dilation2DBackpropFilter(stride=self.stride, dilation=self.dilation,
-                                             pad_mode=self.pad_mode, data_format=self.data_format)
-
-    def bprop(x, _filter, out, dout):
-        dx = input_grad(x, _filter, dout)
-        dfilter = filter_grad(x, _filter, dout)
-        return dx, dfilter
-
-    return bprop
-
-
-@bprop_getters.register(P.CeLU)
-def get_bprop_celu(self):
-    """Grad definition for `CeLU` operation."""
-    alpha = self.alpha
-    greater_equal = P.GreaterEqual()
-
-    def bprop(x, out, dout):
-        condition = greater_equal(x, 0.0)
-        dx = dout * mnp.where(condition, 1.0, out / alpha + 1.0)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(Pdist)
-def get_bprop_pdist(self):
-    """Generate bprop for Pdist"""
-    input_grad = PdistGrad(p=self.p)
-
-    def bprop(x, out, dout):
-        dx = input_grad(dout, x, out)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(MultiMarginLoss)
-def get_bprop_multi_margin_loss(self):
-    """Grad definition for `MultiMarginLoss` operation."""
-    input_grad = G.MultiMarginLossGrad(p=self.p, margin=self.margin, reduction=self.reduction)
-
-    def bprop(x, target, weight, out, dout):
-        dx = input_grad(dout, x, target, weight)
-        return dx, zeros_like(target), zeros_like(weight)
-
-    return bprop
-
-
-@bprop_getters.register(UpsampleNearest3D)
-def get_bprop_upsample_nearest_3d(self):
-    """Grad definition for `UpsampleNearest3D` operation."""
-    output_size = self.output_size
-    scales = self.scales
-
-    def bprop(x, out, dout):
-        x_shape = P.Shape()(x)
-        grad_op = UpsampleNearest3DGrad(x_shape, output_size, scales)
-        dx = grad_op(dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(UpsampleTrilinear3D)
-def get_bprop_upsample_trilinear_3d(self):
-    """Grad definition for `UpsampleTrilinear3D` operation."""
-    output_size = self.output_size
-    scales = self.scales
-    align_corners = self.align_corners
-
-    def bprop(x, out, dout):
-        input_size = P.Shape()(x)
-        grad_op = UpsampleTrilinear3DGrad(input_size, output_size, scales, align_corners)
-        dx = grad_op(dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(GridSampler3D)
-def get_bprop_grid_sampler_3d(self):
-    """Grad definition for `GridSampler3D` operation."""
-    grad = G.GridSampler3DGrad(self.interpolation_mode, self.padding_mode, self.align_corners)
-
-    def bprop(input_x, grid, out, dout):
-        dx, dgrid = grad(dout, input_x, grid)
-        return dx, dgrid
-    return bprop
-
-
-@bprop_getters.register(ReLUV3)
-def get_bprop_relu(self):
-    """Grad definition for `ReLUV3` operation."""
-    input_grad = ReluGrad()
-
-    def bprop(x, out, dout):
-        dx = input_grad(dout, out)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(MaxUnpool2D)
-def get_bprop_maxunpool2d(self):
-    """Grad definition for `MaxUnpool2D` operation."""
-    maxunpool2d_grad = G.MaxUnpool2DGrad(
-        ksize=self.ksize,
-        strides=self.strides,
-        pads=self.pads,
-        output_shape=self.output_shape,
-        data_format=self.data_format)
-
-    def bprop(x, argmax, out, dout):
-        dx = maxunpool2d_grad(x, dout, argmax)
-        dargmax = zeros_like(argmax)
-        return (dx, dargmax)
-
-    return bprop
-
-
-@bprop_getters.register(MaxUnpool3D)
-def get_bprop_maxunpool3d(self):
-    """Grad definition for `MaxUnpool3D` operation."""
-    maxunpool3d_grad = G.MaxUnpool3DGrad(
-        ksize=self.ksize,
-        strides=self.strides,
-        pads=self.pads,
-        output_shape=self.output_shape,
-        data_format=self.data_format)
-
-    def bprop(x, argmax, out, dout):
-        dx = maxunpool3d_grad(x, dout, argmax)
-        dargmax = zeros_like(argmax)
-        return (dx, dargmax)
-
-    return bprop
-
-
-@bprop_getters.register(NthElement)
-def get_bprop_nth_element(self):
-    """Grad definition for `NthElement` operation."""
-    expand_dims = P.ExpandDims()
-    cast = P.Cast()
-    equal = P.Equal()
-    reduce_sum = P.ReduceSum()
-    divide = P.Div()
-
-    def bprop(input_x, n, out, dout):
-        indicators = cast(equal(expand_dims(out, -1), input_x), mstype.float32)
-        dout = expand_dims(dout, -1)
-        num_select = expand_dims(reduce_sum(indicators, -1), -1)
-        return cast(divide(indicators, num_select) * dout, input_x.dtype), None
-
-    return bprop
-
-
-@bprop_getters.register(AdaptiveAvgPool3D)
-def get_bprop_adaptiveavgpool3d(self):
-    """Grad definition for `AdaptiveAvgPool3D` operation."""
-    grad = G.AdaptiveAvgPool3DGrad()
-
-    def bprop(x, out, dout):
-        get_x_shape = P.TensorShape()
-        x_shape = get_x_shape(x).astype(mstype.int32)
-        dx = grad(dout, x_shape)
-        return (dx,)
-
-    return bprop
+from mindspore.ops.operations._sequence_ops import TupleToTensor
+from mindspore.ops.operations import _rl_inner_ops as rl_ops
 
 
 @bprop_getters.register(FractionalMaxPool)
@@ -372,40 +66,20 @@ def get_bprop_fractional_max_pool3d_with_fixed_ksize(self):
     return bprop
 
 
-@constexpr
-def _create_tensor(x_shape):
-    return Tensor(x_shape, mstype.int64)
-
-
 @bprop_getters.register(FractionalAvgPool)
 def get_bprop_fractional_avg_pool(self):
     """Grad definition for `FractionalAvgPool` operation."""
     fractional_avg_pool_grad = FractionalAvgPoolGrad(overlapping=self.overlapping)
     shape_op = P.Shape()
+    tuple_to_tensor_op = TupleToTensor()
 
     def bprop(x, out, dout):
-        dx = fractional_avg_pool_grad(_create_tensor(shape_op(x)), dout[0], out[1], out[2])
+        dx = fractional_avg_pool_grad(tuple_to_tensor_op(shape_op(x), mstype.int64), dout[0], out[1], out[2])
         return (dx,)
 
     return bprop
 
 
-@bprop_getters.register(PSROIPooling)
-def get_bprop_p_s_r_o_i_pooling(self):
-    """Grad definition for `PSROIPooling` operation."""
-    spatial_scale = self.spatial_scale
-    group_size = self.group_size
-    output_dim = self.output_dim
-
-    def bprop(x, rois, out, dout):
-        shape = P.Shape()(x)
-        p_s_r_o_i_pooling_grad = PSROIPoolingGrad((shape[2:]), spatial_scale, group_size, output_dim)
-        dx = p_s_r_o_i_pooling_grad(dout, rois)
-        return (dx, zeros_like(rois))
-
-    return bprop
-
-
 @bprop_getters.register(AdaptiveMaxPool3D)
 def get_bprop_adaptive_max_pool_3d(self):
     """Grad definition for `AdaptiveMaxPool3D` operation."""
@@ -437,66 +111,6 @@ def get_bprop_avg_pool_v1_grad(self):
     return bprop
 
 
-@bprop_getters.register(MaxPoolV1)
-def get_bprop_max_pool_v1_grad(self):
-    """Grad definition for `MaxPoolV1` operation."""
-    maxpool_grad_v1 = MaxPoolGradV1(
-        kernel_size=self.kernel_size,
-        strides=self.strides,
-        pad_mode=self.pad_mode,
-        data_format=self.format)
-
-    def bprop(x, out, dout):
-        dx = maxpool_grad_v1(x, out, dout)
-        return (dx,)
-    return bprop
-
-
-@bprop_getters.register(SparseSoftmaxCrossEntropyWithLogitsV2)
-def get_bprop_sparse_softmax_cross_entropy_with_logits_v2(self):
-    """Grad definition for `SparseSoftmaxCrossEntropyWithLogitsV2` operation."""
-    mul = P.Mul()
-    squeeze = P.Squeeze(axis=1)
-    softmax_op = P.Softmax()
-    expand_dims = P.ExpandDims()
-
-    def bprop(logits, labels, out, dout):
-        grad_loss = dout[0]
-        softmax_grad = out[1]
-        grad_loss = expand_dims(grad_loss, -1)
-        grad = mul(grad_loss, softmax_grad)
-        if dout[1] is not None:
-            softmax = softmax_op(logits)
-            grad += ((dout[1] - squeeze(matmul(expand_dims(dout[1], 1), expand_dims(softmax, 2)))) * softmax)
-        return grad, zeros_like(labels)
-
-    return bprop
-
-
-@bprop_getters.register(GridSampler2D)
-def get_bprop_grid_sampler_2d(self):
-    """Grad definition for `GridSampler2D` operation."""
-    grad = G.GridSampler2DGrad(self.interpolation_mode, self.padding_mode, self.align_corners)
-
-    def bprop(input_x, grid, out, dout):
-        dx, dgrid = grad(dout, input_x, grid)
-        return dx, dgrid
-
-    return bprop
-
-
-@bprop_getters.register(ResizeLinear1D)
-def get_bprop_resize_bilinear(self):
-    """Grad definition for `ResizeLinear1D` operation."""
-    resize_grad = G.ResizeLinear1DGrad(self.coordinate_transformation_mode)
-
-    def bprop(input_x, size, out, dout):
-        dx = resize_grad(dout, input_x)
-        return (dx, zeros_like(size))
-
-    return bprop
-
-
 @bprop_getters.register(GLU)
 def get_bprop_glu(self):
     """Grad definition for `Glu` operation."""
@@ -509,24 +123,6 @@ def get_bprop_glu(self):
     return bprop
 
 
-@bprop_getters.register(MaxPool3DWithArgmax)
-def get_bprop_maxpool3dwithargmax(self):
-    """Grad definition for `MaxPool3DWithArgmax` operation."""
-    maxpool3dwithargmax_grad = G.MaxPool3DGradWithArgmax(
-        ksize=self.ksize,
-        strides=self.strides,
-        pads=self.pads,
-        dilation=self.dilation,
-        ceil_mode=self.ceil_mode,
-        data_format=self.data_format)
-
-    def bprop(x, out, dout):
-        dx = maxpool3dwithargmax_grad(x, dout[0], out[1])
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(MaxPoolWithArgmaxV2)
 def get_bprop_maxpoolwithargmaxv2(self):
     """Grad definition for `MaxPoolWithArgmaxV2` operation."""
@@ -555,3 +151,134 @@ def get_bprop_fractional_max_pool_with_fixed_ksize(self):
         return (dx, zeros_like(random_samples))
 
     return bprop
+
+
+@bprop_getters.register(P.DepthwiseConv2dNative)
+def get_bprop_depthwise_conv2d_native(self):
+    """Grad definition for `DepthwiseConv2dNative` operation."""
+    input_grad = G.DepthwiseConv2dNativeBackpropInput(
+        self.channel_multiplier, self.kernel_size, self.pad_mode, self.pad, self.pad_list, self.mode, self.stride,
+        self.dilation, self.group
+    )
+    filter_grad = G.DepthwiseConv2dNativeBackpropFilter(
+        self.channel_multiplier, self.kernel_size, self.pad_mode, self.pad, self.pad_list, self.mode, self.stride,
+        self.dilation, self.group
+    )
+    get_shape = P.Shape()
+
+    def bprop(x, w, out, dout):
+        dx = input_grad(get_shape(x), w, dout)
+
+        dw = filter_grad(x, get_shape(w), dout)
+        return dx, dw
+
+    return bprop
+
+
+@bprop_getters.register(P.SparseSoftmaxCrossEntropyWithLogits)
+def get_bprop_sparse_softmax_cross_entropy_with_logits(self):
+    """Grad definition for `SparseSoftmaxCrossEntropyWithLogits` operation."""
+    is_grad = self.is_grad
+    grad_op = P.SparseSoftmaxCrossEntropyWithLogits(is_grad=True)
+
+    def bprop(logits, labels, out, dout):
+        grad = out[0]
+        if not is_grad:
+            # if construct use loss
+            grad = grad_op(logits, labels)
+            grad = F.depend(grad, out)
+            grad = grad * dout
+        return grad, zeros_like(labels)
+
+    return bprop
+
+
+@bprop_getters.register(rl_ops.GRUV2)
+def get_bprop_gru_v2(self):
+    """Grad definition for `GRUV2` operation."""
+    gru_grad_v2 = G.GRUV2Grad(
+        self.input_size,
+        self.hidden_size,
+        self.num_layers,
+        self.has_bias,
+        self.bidirectional,
+        self.dropout
+    )
+
+    def bprop(x, hx, w, seq_length, out, dout):
+        y, hy, reverse, _ = out
+        dy, dhy, _, _ = dout
+        dx, dhx, dw = gru_grad_v2(x, hx, w, seq_length, y, hy, dy, dhy, reverse)
+        return tuple((dx, dhx, dw, (0)))
+
+    return bprop
+
+
+@bprop_getters.register(rl_ops.CudnnGRU)
+def get_bprop_gru(self):
+    """Grad definition for `GRU` operation."""
+    gru_grad_data = G.GruGradData(
+        input_size=self.input_size,
+        hidden_size=self.hidden_size,
+        num_layers=self.num_layers,
+        has_bias=self.has_bias,
+        bidirectional=self.bidirectional,
+        dropout=self.dropout
+    )
+
+    gru_grad_weight = G.GruGradWeight(
+        input_size=self.input_size,
+        hidden_size=self.hidden_size,
+        num_layers=self.num_layers,
+        has_bias=self.has_bias,
+        bidirectional=self.bidirectional,
+        dropout=self.dropout
+    )
+
+    def bprop(x, hx, w, out, dout):
+        y, _, reserve, state = out
+        dy, dhy, _, _ = dout
+        dx, dhx = gru_grad_data(y, dy, dhy, w, hx, reserve, state)
+        dw = gru_grad_weight(F.depend(x, dx), hx, y, reserve, state)
+        return dx, dhx, dw
+
+    return bprop
+
+
+@bprop_getters.register(P.BasicLSTMCell)
+def get_bprop_basic_lstm_cell(self):
+    """Grad definition for `BasicLSTMCell` operation."""
+    basic_lstm_cell_cstate_grad = G.BasicLSTMCellCStateGrad(
+        forget_bias=self.forget_bias,
+        activation=self.activation
+    )
+
+    basic_lstm_cell_weight_grad = G.BasicLSTMCellWeightGrad()
+
+    basic_lstm_cell_input_grad = G.BasicLSTMCellInputGrad(keep_prob=self.keep_prob)
+
+    def bprop(x, h, c, w, b, out, dout):
+        _, _, it, jt, ft, ot, tanhct = out
+        dct, dht, _, _, _, _, _ = dout
+        dgate, dct_1 = basic_lstm_cell_cstate_grad(c, dht, dct, it, jt, ft, ot, tanhct)
+        dxt, dht = basic_lstm_cell_input_grad(dgate, w)
+        dw, db = basic_lstm_cell_weight_grad(F.depend(x, dxt), h, dgate)
+        res = (dxt, dht, dct_1, dw, db)
+        return res
+
+    return bprop
+
+
+@bprop_getters.register(WKV)
+def get_bprop_wkv(self):
+    """Grad definition for `wkv` operation."""
+    wkv_backward = WKVGrad()
+
+    def bpro(w, u, k, v, sp, sq, sm, out, dout):
+        gw, gu, gk, gv = wkv_backward(w, u, k, v, dout[0])
+        gw = F.sum(gw, 0)
+        gu = F.sum(gu, 0)
+        res = (gw, gu, gk, gv, zeros_like(sp), zeros_like(sq), zeros_like(sm))
+        return res
+
+    return bpro

mindspore/ops/{_grad → _grad_experimental}/grad_quant_ops.py

@@ -17,7 +17,7 @@
 
 from mindspore.ops import operations as P
 from mindspore.ops.operations import _quant_ops as Q
-from mindspore.ops._grad.grad_base import bprop_getters
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore import context
 
@@ -84,7 +84,8 @@ def get_bprop_batchnorm_fold(self):
 
     def bprop(x, mean, variance, global_step, out, dout):
         dx = op(dout[0], dout[1], x, out[0], out[1], global_step)
-        return dx, zeros_like(mean), zeros_like(variance), zeros_like(global_step)
+        res = (dx, zeros_like(mean), zeros_like(variance), zeros_like(global_step))
+        return res
 
     return bprop
 
@@ -118,8 +119,9 @@ def get_bprop_batchnorm_fold2(self):
     def bprop(x, beta, gamma, batch_std, batch_mean, running_std, running_mean, global_step, out, dout):
         d_batch_std, d_batch_mean, d_beta, d_gamma, d_x = op_f(dout, x, gamma, batch_std, batch_mean, running_std,
                                                                running_mean, global_step)
-        return d_x, d_beta, d_gamma, d_batch_std, d_batch_mean, zeros_like(running_std), zeros_like(running_mean), \
-            zeros_like(global_step)
+        res = (d_x, d_beta, d_gamma, d_batch_std, d_batch_mean, zeros_like(running_std), zeros_like(running_mean), \
+            zeros_like(global_step))
+        return res
 
     return bprop
 
@@ -131,7 +133,8 @@ def get_bprop_batchnormfold(self):
 
     def bprop(x, x_sum, x_square_sum, mean, variance, out, dout):
         dx = op(dout[1], dout[2], x, out[1], out[2])
-        return dx, zeros_like(x_sum), zeros_like(x_square_sum), zeros_like(mean), zeros_like(variance)
+        res = (dx, zeros_like(x_sum), zeros_like(x_square_sum), zeros_like(mean), zeros_like(variance))
+        return res
 
     return bprop
 
@@ -156,7 +159,8 @@ def get_bprop_batchnorm_fold2_(self):
         dout_reduce, dout_x_reduce = op_reduce(dout, x)
         d_batch_std, d_batch_mean, d_gamma, d_x = op_f(dout, dout_reduce, dout_x_reduce, gamma, batch_std,
                                                        batch_mean, running_std)
-        return d_x, dout_reduce, d_gamma, d_batch_std, d_batch_mean, zeros_like(running_std)
+        res = (d_x, dout_reduce, d_gamma, d_batch_std, d_batch_mean, zeros_like(running_std))
+        return res
 
     return bprop