mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/_grad/grad_nn_ops.py

@@ -14,50 +14,41 @@
 # ============================================================================
 
 """Define the grad rules of neural network related operations."""
-import numpy as np
-from mindspore.ops.primitive import constexpr
-from mindspore.ops.operations import nn_ops as nps
+from mindspore import context
 from mindspore.common import dtype as mstype
-from .grad_base import bprop_getters, dyn_size, create_tensor_by_element
-from .. import functional as F
-from .. import operations as P
-from ..composite.multitype_ops.zeros_like_impl import zeros_like
-from ..operations import _grad_ops as G
-from ..operations import _inner_ops as inner
-from ..operations import _rl_inner_ops as rl_ops
-from ... import context
-from .._utils.utils import range_op, get_1d_shape, is_shape_unknown
-
-
-@bprop_getters.register(P.BiasAdd)
-def get_bprop_bias_add(self):
-    """Grad definition for `BiasAdd` operation."""
-    bias_grad = G.BiasAddGrad(self.data_format)
-
-    def bprop(x, w, out, dout):
-        return dout, bias_grad(dout)
-
-    return bprop
+from mindspore.common.tensor import Tensor
+from mindspore.ops.primitive import _primexpr
+from mindspore.ops.operations import nn_ops as nps
+from mindspore.ops._grad.grad_base import bprop_getters, dyn_size, create_tensor_by_element, dyn_rank
+from mindspore.ops import functional as F
+from mindspore.ops import operations as P
+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 import _inner_ops as inner
+from mindspore.ops.operations import _rl_inner_ops as rl_ops
+from mindspore.ops._utils.utils import range_op, get_1d_shape
 
 
-@constexpr
+@_primexpr
 def bias_add_gradgrad_helper(shape, bias_shape, data_format):
     """Helper function of BiasGradGrad to calculate expanded shape."""
-    shape = np.array(shape).astype(np.int)
-    bias_shape = np.array(bias_shape).astype(np.int)
+    new_shape = list(shape)
+    new_bias_shape = list(bias_shape)
+
+    ones_1 = []
+    ones_2 = []
+    for _ in new_shape[2:]:
+        ones_1.append(1)
+
+    for _ in new_shape[:-1]:
+        ones_2.append(1)
+
     if data_format == "NCHW":
-        expanded_shape = np.concatenate([
-            np.ones_like(shape[:1]),
-            bias_shape,
-            np.ones_like(shape[2:])
-        ], axis=0)
-        tile_mults = np.concatenate([shape[:1], [1], shape[2:]], axis=0)
+        expanded_shape = [1] + new_bias_shape + ones_1
+        tile_mults = [new_shape[0]] + [1] + new_shape[2:]
     else:
-        expanded_shape = np.concatenate([
-            np.ones_like(shape[:-1]),
-            bias_shape
-        ], axis=0)
-        tile_mults = np.concatenate([shape[:-1], [1]], axis=0)
+        expanded_shape = ones_2 + new_bias_shape
+        tile_mults = new_shape[:-1] + [1]
     return tuple(expanded_shape), tuple(tile_mults)
 
 
@@ -65,11 +56,11 @@ def bias_add_gradgrad_helper_dynamic(shape, bias_shape, data_format):
     """Helper function of BiasGradGrad to calculate expanded shape(dynamic version)."""
     if data_format == "NCHW":
         expanded_shape = P.Concat(0)((P.OnesLike()(shape[:1]), bias_shape, P.OnesLike()(shape[2:])))
-        tile_mults = P.Concat(0)((shape[:1], [1], shape[2:]))
+        tile_mults = P.Concat(0)((shape[:1], Tensor([1], dtype=mstype.int64), shape[2:]))
     else:
         expanded_shape = P.Concat(0)((P.OnesLike()(shape[:-1]), bias_shape))
-        tile_mults = P.Concat(0)((shape[:-1], [1]))
-    return tuple(expanded_shape), tuple(tile_mults)
+        tile_mults = P.Concat(0)((shape[:-1], Tensor([1], dtype=mstype.int64)))
+    return expanded_shape, tile_mults
 
 
 @bprop_getters.register(G.BiasAddGrad)
@@ -84,12 +75,12 @@ def get_bprop_bias_add_grad(self):
         dyn_shape = P.TensorShape()
         dy_shape = dy.shape
         dout_shape = dout.shape
-        if is_shape_unknown(dy_shape) or is_shape_unknown(dout_shape):
+        if F.is_sequence_value_unknown(dy_shape) or F.is_sequence_value_unknown(dout_shape):
             dy_shape = dyn_shape(dy)
             dout_shape = dyn_shape(dout)
             expanded_shape, tile_mults = bias_add_gradgrad_helper_dynamic(dy_shape, dout_shape, data_format)
-            expanded_grad = reshape(dout, create_tensor_by_element(expanded_shape))
-            tiled_grad = tile(expanded_grad, create_tensor_by_element(tile_mults))
+            expanded_grad = reshape(dout, expanded_shape)
+            tiled_grad = tile(expanded_grad, tile_mults)
         else:
             expanded_shape, tile_mults = bias_add_gradgrad_helper(dy_shape, dout_shape, data_format)
             expanded_grad = reshape(dout, expanded_shape)
@@ -99,37 +90,6 @@ def get_bprop_bias_add_grad(self):
     return bprop
 
 
-@bprop_getters.register(P.Conv2D)
-def get_bprop_conv2d(self):
-    """Grad definition for `Conv2D` operation."""
-    self.out_channel = self.get_attr_dict()["out_channel"]
-    self.pad_list = self.get_attr_dict()["pad_list"]
-    input_grad = P.Conv2DBackpropInput(
-        self.out_channel, self.kernel_size, self.pad_mode, self.pad, self.pad_list, mode=self.mode,
-        dilation=self.dilation, stride=self.stride, group=self.group, data_format=self.format
-    )
-    filter_grad = G.Conv2DBackpropFilter(
-        self.out_channel, self.kernel_size, self.pad_mode, self.pad, self.pad_list, mode=self.mode,
-        dilation=self.dilation, stride=self.stride, group=self.group, data_format=self.format
-    )
-    get_shape = P.Shape()
-    get_dyn_shape = P.TensorShape()
-    cast_type = P.Cast()
-
-    def bprop(x, w, out, dout):
-        x_shape = get_shape(x)
-        w_shape = get_shape(w)
-        if is_shape_unknown(x_shape):
-            x_shape = get_dyn_shape(x)
-            w_shape = get_dyn_shape(w)
-            w_shape = cast_type(w_shape, mstype.int32)
-        dx = input_grad(dout, w, x_shape)
-        dw = filter_grad(dout, x, w_shape)
-        return dx, dw
-
-    return bprop
-
-
 @bprop_getters.register(nps.Conv3D)
 def get_bprop_conv3d(self):
     """Grad definition for `Conv3D` operation."""
@@ -143,15 +103,17 @@ def get_bprop_conv3d(self):
     )
     get_shape = P.Shape()
     get_dyn_shape = P.TensorShape()
+    cast = P.Cast()
+    get_dtype = P.DType()
 
     def bprop(x, w, out, dout):
-        if is_shape_unknown(get_shape(x)) or is_shape_unknown(get_shape(w)):
+        if F.is_sequence_value_unknown(get_shape(x)) or F.is_sequence_value_unknown(get_shape(w)):
             dx = input_grad(w, dout, get_dyn_shape(x))
-            dw = filter_grad(x, dout, get_dyn_shape(w))
+            dw = cast(filter_grad(x, dout, get_dyn_shape(w)), get_dtype(x))
             return dx, dw
 
         dx = input_grad(w, dout, get_shape(x))
-        dw = filter_grad(x, dout, get_shape(w))
+        dw = cast(filter_grad(x, dout, get_shape(w)), get_dtype(x))
         return dx, dw
 
     return bprop
@@ -174,7 +136,7 @@ def get_bprop_conv3d_transpose(self):
     get_dyn_shape = P.TensorShape()
 
     def bprop(x, w, out, dout):
-        if is_shape_unknown(F.shape(w)):
+        if F.is_sequence_value_unknown(F.shape(w)):
             dx = input_grad(dout, w)
             dw = filter_grad(dout, x, get_dyn_shape(w))
             return dx, dw
@@ -204,11 +166,51 @@ def get_bprop_extract_image_patches(self):
     transpose = P.Transpose()
     cast = P.Cast()
     matmul = P.MatMul()
+    range_ = P.Range()
+    dyn_shape_op = P.TensorShape()
+    ones_like = P.OnesLike()
 
     _, _, ksizes_row, ksizes_col = self.ksizes
 
+    def _dyn_extract_image_patched(x, out, dout):
+        x_shape = dyn_shape_op(x)
+        out_shape = dyn_shape_op(out)
+        x_batch, x_depth, x_row, x_col = x_shape[0], x_shape[1], x_shape[2], x_shape[3]
+        x_indices_num = x_row * x_col + 1
+        x_idx = range_(cast(1, mstype.float32), cast(x_indices_num, mstype.float32), cast(1, mstype.float32))
+        x_idx = reshape(x_idx, create_tensor_by_element((1, 1, x_row, x_col)))
+        x_idx_patch = cast(extract_image_patches(x_idx), mstype.int32)
+        x_idx_patch = transpose(x_idx_patch, (0, 2, 3, 1))
+
+        out_row, out_col = out_shape[2], out_shape[3]
+        out_indices_num = out_row * out_col * ksizes_row * ksizes_col
+        out_idx_ori = range_(cast(0, mstype.int32), cast(out_indices_num, mstype.int32), cast(1, mstype.int32))
+        out_idx = reshape(out_idx_ori, create_tensor_by_element((1, out_row, out_col, ksizes_row * ksizes_col)))
+
+        idx_tensor = concat((expand_dims(x_idx_patch, -1), expand_dims(out_idx, -1)))
+        idx_tensor = reshape(idx_tensor, (-1, 2))
+        sp_shape = create_tensor_by_element((x_indices_num, out_indices_num))
+        update = cast(ones_like(out_idx_ori), dtype(dout))
+        sp_tensor = scatter_nd(idx_tensor, update, sp_shape)
+        begin = create_tensor_by_element((1, 0))
+        size = create_tensor_by_element((x_indices_num - 1, out_indices_num))
+        sp_tensor = slice_op(sp_tensor, begin, size)
+
+        grad = transpose(dout, (0, 2, 3, 1))
+        grad = reshape(grad, create_tensor_by_element((x_batch, out_row, out_col, ksizes_row, ksizes_col, x_depth)))
+        grad = transpose(grad, (1, 2, 3, 4, 0, 5))
+        grad = reshape(grad, create_tensor_by_element((out_row * out_col * ksizes_row * ksizes_col, x_batch * x_depth)))
+
+        jac = matmul(sp_tensor, grad)
+        dx = reshape(jac, create_tensor_by_element((x_row, x_col, x_batch, x_depth)))
+        dx = transpose(dx, (2, 3, 0, 1))
+        return (dx,)
+
     def bprop(x, out, dout):
         x_shape = get_shape(x)
+        out_shape = get_shape(out)
+        if F.is_sequence_value_unknown(x_shape) or F.is_sequence_value_unknown(out_shape):
+            return _dyn_extract_image_patched(x, out, dout)
         x_batch, x_depth, x_row, x_col = x_shape
         x_indices_num = x_row * x_col + 1
         x_idx = cast(F.tuple_to_array(range(1, x_indices_num)), mstype.float32)
@@ -216,7 +218,6 @@ def get_bprop_extract_image_patches(self):
         x_idx_patch = cast(extract_image_patches(x_idx), mstype.int32)
         x_idx_patch = transpose(x_idx_patch, (0, 2, 3, 1))
 
-        out_shape = get_shape(out)
         _, _, out_row, out_col = out_shape
         out_indices_num = out_row * out_col * ksizes_row * ksizes_col
         out_idx = F.tuple_to_array(range(out_indices_num))
@@ -302,6 +303,11 @@ def get_bprop_max_pool_grad_grad(self):
         reshape = P.Reshape()
     else:
         raise RuntimeError("MaxPoolGradGrad does not support on CPU!")
+    shape_op = P.Shape()
+    dyn_shape_op = P.TensorShape()
+    op_range = P.Range()
+    dyn_broadcast_op = inner.DynamicBroadcastTo()
+
 
     def bprop(x1, x2, grad, out, dout):
         dx1 = zeros_like(x1)
@@ -309,12 +315,24 @@ def get_bprop_max_pool_grad_grad(self):
         if is_ascend:
             dgrad = maxpool_grad_grad(x1, x2, dout)
         else:
-            b, c, h, w = P.Shape()(x2)
-            _, ind = maxpool_with_argmax(x1)
-            batch = F.cast(F.tuple_to_array(range(b)), mstype.int32)
-            batch = P.Tile()(reshape(batch, (-1, 1)), (1, c * h * w))
-            gather_ind = P.Stack(-1)((batch, reshape(ind, (b, -1))))
-            dgrad = reshape(gather(reshape(dout, (b, -1)), gather_ind), (b, c, h, w))
+            shape_x2 = shape_op(x2)
+            if F.is_sequence_value_unknown(shape_x2):
+                shape_x2 = dyn_shape_op(x2)
+                b, c, h, w = shape_x2
+                _, ind = maxpool_with_argmax(x1)
+                batch = op_range(F.cast(0, mstype.int32), F.cast(b, mstype.int32), F.cast(1, mstype.int32))
+                batch = dyn_broadcast_op(reshape(batch, (-1, 1)),
+                                         create_tensor_by_element((dyn_size(batch), c * h * w)))
+                gather_ind = P.Stack(-1)((batch, reshape(ind, create_tensor_by_element((b, -1)))))
+                dgrad = reshape(gather(reshape(dout, create_tensor_by_element((b, -1))), gather_ind),
+                                create_tensor_by_element((b, c, h, w)))
+            else:
+                b, c, h, w = shape_x2
+                _, ind = maxpool_with_argmax(x1)
+                batch = F.cast(F.tuple_to_array(range(b)), mstype.int32)
+                batch = P.Tile()(reshape(batch, (-1, 1)), (1, c * h * w))
+                gather_ind = P.Stack(-1)((batch, reshape(ind, (b, -1))))
+                dgrad = reshape(gather(reshape(dout, (b, -1)), gather_ind), (b, c, h, w))
         return (dx1, dx2, dgrad)
 
     return bprop
@@ -337,22 +355,6 @@ def get_bprop_max_pool_grad_grad_grad(self):
     return bprop
 
 
-@bprop_getters.register(P.MaxPool)
-def get_bprop_max_pool_grad(self):
-    """Grad definition for `MaxPool` operation."""
-    maxpool_grad = G.MaxPoolGrad(
-        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(x, out, dout)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(P.MaxPool3D)
 def get_bprop_max_pool3d_grad(self):
     """Grad definition for `MaxPool3D` operation."""
@@ -437,9 +439,10 @@ def get_bprop_avg_pool_grad(self):
 def get_bprop_adaptive_avg_pool2d_grad(self):
     """Grad definition for `AdaptiveAvgPool2D` operation."""
     adaptive_avgpool_grad = G.AdaptiveAvgPool2DGrad()
+    shape = P.TensorShape()
 
     def bprop(x, out, dout):
-        dx = adaptive_avgpool_grad(x, dout)
+        dx = adaptive_avgpool_grad(dout, shape(x))
         return (dx,)
 
     return bprop
@@ -461,6 +464,8 @@ def get_bprop_avg_pool_3d_grad(self):
 
     def bprop(x, out, dout):
         x_shape = F.shape(x)
+        if F.is_sequence_value_unknown(x_shape):
+            x_shape = P.TensorShape()(x)
         dx = avgpool3d_grad(x_shape, dout)
         return (dx,)
 
@@ -540,18 +545,6 @@ def get_bprop_mul_no_nan(self):
     return bprop
 
 
-@bprop_getters.register(P.ReLU)
-def get_bprop_relu(self):
-    """Grad definition for `ReLU` operation."""
-    input_grad = G.ReluGrad()
-
-    def bprop(x, out, dout):
-        dx = input_grad(dout, out)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(G.ReluGrad)
 def get_bprop_relu_grad(self):
     """Grad definition for `ReLUGrad` operation."""
@@ -650,7 +643,7 @@ def get_bprop_sigmoid_grad(self):
     return bprop
 
 
-@constexpr
+@_primexpr
 def _get_transpose_axis(x_shp, axis):
     rank = len(x_shp)
     if axis < 0:
@@ -661,6 +654,34 @@ def _get_transpose_axis(x_shp, axis):
     return tuple(reverse_axis)
 
 
+def _get_dyn_transpose_axis(x, axis, is_ascend):
+    """Get transpose axis"""
+    if F.is_sequence_shape_unknown(P.Shape()(x)):
+        rank = dyn_rank(x)
+        start = Tensor(0, dtype=mstype.int64)
+        delta = Tensor(1, dtype=mstype.int64)
+    else:
+        rank = P.Cast()(len(P.Shape()(x)), mstype.int64)
+        start = P.Cast()(0, mstype.int64)
+        delta = P.Cast()(1, mstype.int64)
+
+    if axis < 0:
+        axis += rank
+    range_ops = P.Range()
+
+    reverse_axis = range_ops(start, rank, delta)
+    if is_ascend:
+        reverse_axis = P.Cast()(reverse_axis, mstype.int8)
+        axis = P.Cast()(axis, mstype.int32)
+        reverse_axis[axis] = rank - 1
+        rank = P.Cast()(rank, mstype.int32)
+    else:
+        reverse_axis[axis] = rank - 1
+
+    reverse_axis[rank - 1] = axis
+    return reverse_axis
+
+
 @bprop_getters.register(P.Softmax)
 def get_bprop_softmax(self):
     """Grad definition for `Softmax` operation."""
@@ -673,13 +694,22 @@ def get_bprop_softmax(self):
     if not isinstance(axis, int):
         axis = axis[0]
 
+    device_target = context.get_context("device_target")
+    is_ascend = (device_target == "Ascend")
+
     def bprop(x, out, dout):
-        # dx = (dout - sum(dout * out)) * out
+        # dx can be expressed as (dout - sum(dout * out)) * out
         # This formula is correct only when the `axis` is the last dimension.
         # In order to support the scenario where the `axis` is other values,
         # we transpose the data of the `axis` dimension to the last dimension for calculation,
         # and then transpose it back after the calculation.
-        reverse_axis = _get_transpose_axis(get_shape(x), axis)
+        shp = get_shape(x)
+        if F.is_sequence_value_unknown(shp):
+            reverse_axis = _get_dyn_transpose_axis(x, axis, is_ascend)
+            if is_ascend:
+                reverse_axis = P.Cast()(reverse_axis, mstype.int32)
+        else:
+            reverse_axis = _get_transpose_axis(get_shape(x), axis)
         out = transpose(out, reverse_axis)
         dout = transpose(dout, reverse_axis)
         dx = mul(out, sub(dout, sum_func(mul(out, dout), -1)))
@@ -759,19 +789,6 @@ def get_bprop_tanh_grad(self):
     return bprop
 
 
-@bprop_getters.register(P.Gelu)
-@bprop_getters.register(P.GeLU)
-def get_bprop_gelu(self):
-    """Grad definition for `GeLU` operation."""
-    input_grad = G.GeLUGrad()
-
-    def bprop(x, out, dout):
-        dx = input_grad(dout, x, out)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(P.FastGeLU)
 def get_bprop_fast_gelu(self):
     """Grad definition for `FastGeLU` operation."""
@@ -813,30 +830,6 @@ def get_bprop_instance_norm(self):
     return bprop
 
 
-@bprop_getters.register(P.BatchNorm)
-def get_bprop_batch_norm(self):
-    """Grad definition for `BatchNorm` operation."""
-    is_training = self.is_training
-    input_grad = G.BatchNormGrad(is_training, self.epsilon, self.data_format)
-
-    def bprop(x, scale, b, mean, variance, out, dout):
-        if is_training:
-            saved_mean = out[3]
-            saved_variance = out[4]
-            reserve = out[2]
-        else:
-            saved_mean = mean
-            saved_variance = variance
-            reserve = out[2]
-        out = input_grad(dout[0], x, scale, saved_mean, saved_variance, reserve)
-        dx = out[0]
-        dscale = out[1]
-        dbias = out[2]
-        return dx, dscale, dbias, zeros_like(mean), zeros_like(variance)
-
-    return bprop
-
-
 @bprop_getters.register(G.BatchNormGrad)
 def get_bprop_batch_norm_grad(self):
     """Grad definition for `BatchNorm` operation."""
@@ -849,19 +842,6 @@ def get_bprop_batch_norm_grad(self):
     return bprop
 
 
-@bprop_getters.register(P.LayerNorm)
-def get_bprop_layer_norm(self):
-    """Grad definition for `LayerNorm` operation."""
-    layer_norm_grad = G.LayerNormGrad(self.begin_norm_axis, self.begin_params_axis)
-
-    def bprop(x, gamma, beta, out, dout):
-        dx, d_gamma, d_beta = layer_norm_grad(
-            x, dout[0], out[2], out[1], gamma)
-        return dx, d_gamma, d_beta
-
-    return bprop
-
-
 @bprop_getters.register(G.LayerNormGrad)
 def get_bprop_layer_norm_grad(self):
     """Grad definition for `LayerNormGrad` operation."""
@@ -976,7 +956,7 @@ def get_bprop_top_kv2(self):
         ind_2d = reshape_op(indices, (-1, ind_lastdim))
         outerdim = shape_op(ind_2d)[0]
 
-        # [0, outterdim, 2*outerdim, ..., (k-1)*outerdim]
+        # range_flatten_index can be expressed as: [0, outterdim, 2*outerdim, ..., (k-1)*outerdim]
         indices_dtype = dtype(indices)
         range_flatten_index = range_op(0, outerdim * in_lastdim, in_lastdim, indices_dtype)
 
@@ -1003,7 +983,7 @@ def get_bprop_top_kv2(self):
         ind_2d = reshape_op(indices, create_tensor_by_element((-1, ind_lastdim)))
         outerdim = dyn_shape(ind_2d)[0]
 
-        # [0, outterdim, 2*outerdim, ..., (k-1)*outerdim]
+        # range_flatten_index can be expressed as: [0, outterdim, 2*outerdim, ..., (k-1)*outerdim]
         range_flatten_index = P.Range()(cast(0, mstype.int64), outerdim * in_lastdim, in_lastdim)
 
         # expand_dims to (k, 1), then broadcast
@@ -1019,7 +999,7 @@ def get_bprop_top_kv2(self):
         return out_grad, zeros_like(k)
 
     def bprop(input_x, k, out, dout):
-        if is_shape_unknown(shape_op(input_x)):
+        if F.is_sequence_value_unknown(shape_op(input_x)):
             return _bprop_dynshape(input_x, k, out, dout)
         return _bprop_static(input_x, k, out, dout)
 
@@ -1117,11 +1097,33 @@ def get_bprop_lstm(self):
         return dx, dhx, dcx, dw
 
     if context.get_context('device_target') == "CPU":
+        self.add_prim_attr("is_training", True)
         return bprop_cpu
 
     return bprop
 
 
+@bprop_getters.register(rl_ops.GRUV2)
+def get_bppro_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 bpro(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 dx, dhx, dw, (0)
+
+    return bpro
+
+
 @bprop_getters.register(rl_ops.CudnnGRU)
 def get_bprop_gru(self):
     """Grad definition for `GRU` operation."""
@@ -1216,6 +1218,7 @@ def get_bprop_sigmoid_crossentropy_with_logits(self):
 def get_bprop_pad(self):
     """Grad definition for `Pad` operation."""
     shape_op = P.Shape()
+    dyn_shape_op = P.TensorShape()
     paddings = self.paddings
 
     def bprop(x, out, dout):
@@ -1223,6 +1226,8 @@ def get_bprop_pad(self):
         for item in paddings:
             begin += (item[0],)
         shp = shape_op(x)
+        if F.is_sequence_value_unknown(shp):
+            shp = dyn_shape_op(x)
         dx = P.Slice()(dout, begin, shp)
         return (dx,)
 
@@ -1253,7 +1258,7 @@ def get_bprop_roi_align(self):
 
     def bprop(inputs, rois, out, dout):
         inputs_shape = shape_op(inputs)
-        if is_shape_unknown(inputs_shape):
+        if F.is_sequence_value_unknown(inputs_shape):
             inputs_shape = dyn_shape(inputs)
         dx = G.ROIAlignGrad(pooled_height, pooled_width, spatial_scale, sample_num)(dout, rois, inputs_shape)
         return dx, zeros_like(rois)
@@ -1280,7 +1285,7 @@ def get_bprop_conv2d_backprop_input(self):
 
     def bprop(x, w, f_sizes, out, dout):
         w_shape = get_shape(w)
-        if is_shape_unknown(w_shape):
+        if F.is_sequence_value_unknown(w_shape):
             w_shape = get_dyn_shape(w)
         dx = input_grad(dout, w)
         dw = filter_grad(x, dout, w_shape)
@@ -1327,8 +1332,8 @@ def get_bprop_bce_with_logits_loss(self):
             dx = mul(dx, weight)
             grad_target = mul(grad_target, weight)
         if reduction == 'mean':
-            dx_size = dyn_size(dx) if is_shape_unknown(shape(dx)) else size(dx)
-            target_size = dyn_size(target) if is_shape_unknown(shape(target)) else size(target)
+            dx_size = dyn_size(dx) if F.is_sequence_value_unknown(shape(dx)) else size(dx)
+            target_size = dyn_size(target) if F.is_sequence_value_unknown(shape(target)) else size(target)
             dx = dx / dx_size
             grad_target = grad_target / target_size
         return dx, grad_target, zeros_like(weight), zeros_like(pos_weight)
@@ -1339,17 +1344,20 @@ def get_bprop_bce_with_logits_loss(self):
 @bprop_getters.register(P.KLDivLoss)
 def get_bprop_kl_div_loss(self):
     """Grad definition for `KLDivLoss` operation."""
-    if self.reduction == "mean":
-        grad = G.KLDivLossGrad("sum")
-    else:
-        grad = G.KLDivLossGrad(self.reduction)
-    size = P.Size()
     reduce_type = self.reduction
 
+    size = P.Size()
+    shape = P.Shape()
+
     def bprop(x, y, out, dout):
+        if reduce_type == "mean":
+            grad = G.KLDivLossGrad("sum")
+        else:
+            grad = G.KLDivLossGrad(self.reduction)
         dx = grad(dout, x, y)
         if reduce_type == "mean":
-            return dx / size(x), zeros_like(y)
+            x_size = dyn_size(x) if F.is_sequence_value_unknown(shape(x)) else size(x)
+            return dx / x_size, zeros_like(y)
         return dx, zeros_like(y)
 
     return bprop
@@ -1449,6 +1457,7 @@ def get_bprop_deformable_offsets(self):
     def bprop(x, offsets, out, dout):
         out_grad = grad(dout, x, offsets)
         return out_grad
+
     return bprop
 
 
@@ -1480,7 +1489,7 @@ def get_bprop_conv2d_backprop_filter(self):
 
     def bprop(dy, x, filter_size, out, dout):
         x_shape = get_shape(x)
-        if is_shape_unknown(x_shape):
+        if F.is_sequence_value_unknown(x_shape):
             x_shape = get_dyn_shape(x)
         dw_dx = input_grad(dy, dout, x_shape)
         dw_dy = filter_grad(x, dout)
@@ -1500,6 +1509,7 @@ def get_bprop_upsample_nearest_3d_grad(self):
         input_grad = G.UpsampleNearest3DGrad(get_shape(input_x), output_size, scales)
         dx = input_grad(dout)
         return (dx,)
+
     return bprop
 
 
@@ -1515,4 +1525,5 @@ def get_bprop_upsample_trilinear_3d_grad(self):
         input_grad = G.UpsampleTrilinear3DGrad(get_shape(input_x), output_size, scales, align_corners)
         dx = input_grad(dout)
         return (dx,)
+
     return bprop

mindspore/ops/_grad/grad_other_ops.py

@@ -19,7 +19,7 @@ from mindspore.ops import operations as P
 from mindspore.ops.operations import _grad_ops as G
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from .grad_base import bprop_getters
+from mindspore.ops._grad.grad_base import bprop_getters
 
 # Unused parameters are placeholders.
 

mindspore/ops/_grad/grad_quant_ops.py

@@ -15,11 +15,11 @@
 
 """Generate bprop for quantization aware ops"""
 
-from .. import operations as P
-from ..operations import _quant_ops as Q
-from .grad_base import bprop_getters
-from ..composite.multitype_ops.zeros_like_impl import zeros_like
-from ... import context
+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.composite.multitype_ops.zeros_like_impl import zeros_like
+from mindspore import context
 
 
 @bprop_getters.register(Q.FakeQuantPerLayer)