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

mindspore/ops/_grad/grad_math_ops.py

@@ -15,23 +15,24 @@
 
 """Define the grad rules of math related operations."""
 
-from functools import reduce
 import numpy as np
 import mindspore as ms
 from mindspore import nn
-from .. import functional as F
-from .. import operations as P
-from ..operations import _grad_ops as G
-from ..composite.multitype_ops.zeros_like_impl import zeros_like
-from ..functional import broadcast_gradient_args, reduced_shape, tuple_div
-from .grad_base import bprop_getters
-from .grad_base import convert_to_tensor
-from ..primitive import constexpr
-from ..composite.multitype_ops import _constexpr_utils as const_utils
-from ..operations._inner_ops import DynamicStitch, DynamicBroadcastGradientArgs, DynamicBroadcastTo
-from ...common import Tensor
-from .._utils.utils import is_shape_unknown
-from ...common import dtype as mstype
+from mindspore.common import Tensor
+from mindspore.common import dtype as mstype
+from mindspore.ops import functional as F
+from mindspore.ops import operations as P
+from mindspore.ops.operations import _grad_ops as G
+from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
+from mindspore.ops.functional import broadcast_gradient_args, reduced_shape, tuple_div
+from mindspore.ops._grad.grad_base import bprop_getters, create_tensor_by_element, dyn_invert_permutation
+from mindspore.ops._grad.grad_base import convert_to_tensor
+from mindspore.ops._grad.grad_base import sum_grad_reduce_axis, dyn_fill, dyn_rank
+from mindspore.ops._grad.grad_base import dyn_ones, dyn_rank_1d
+from mindspore.ops.primitive import _primexpr
+from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
+from mindspore.ops.operations._inner_ops import DynamicBroadcastGradientArgs, IsSubClass, DynamicBroadcastTo
+from mindspore.ops.operations import array_ops as A
 
 shape_op = P.Shape()
 dyn_shape_op = P.TensorShape()
@@ -39,7 +40,7 @@ reduce_prod = P.ReduceProd()
 reduce_sum = P.ReduceSum()
 reshape = P.Reshape()
 tile = P.Tile()
-is_sub_class = P.IsSubClass()
+is_sub_class = IsSubClass()
 to_array = P.TupleToArray()
 real_div = P.RealDiv()
 
@@ -56,17 +57,17 @@ def dyn_binop_grad_common(x, y, dx, dy):
     dx_origin_dtype = dx.dtype
     if dx_origin_dtype in (mstype.int16, mstype.int32, mstype.int64):
         dx = F.cast(dx, mstype.float32)
-        dx = reduce_sum(dx, rx)
+        dx = sum_grad_reduce_axis(dx, rx)
         dx = F.cast(dx, dx_origin_dtype)
     else:
-        dx = reduce_sum(dx, rx)
+        dx = sum_grad_reduce_axis(dx, rx)
     dy_origin_dtype = dy.dtype
     if dy_origin_dtype in (mstype.int16, mstype.int32, mstype.int64):
         dy = F.cast(dy, mstype.float32)
-        dy = reduce_sum(dy, ry)
+        dy = sum_grad_reduce_axis(dy, ry)
         dy = F.cast(dy, dy_origin_dtype)
     else:
-        dy = reduce_sum(dy, ry)
+        dy = sum_grad_reduce_axis(dy, ry)
     reduce_dx = reshape(dx, shape_of_x)
     reduce_dy = reshape(dy, shape_of_y)
     return reduce_dx, reduce_dy
@@ -83,8 +84,8 @@ def dyn_binop_grad_common_with_shift(x, y, dx, dy, shift):
     broadcast_shape_of_x = shape_of_x[:-shift]
     broadcast_shape_of_y = shape_of_y[:-shift]
     rx, ry = DynamicBroadcastGradientArgs()(broadcast_shape_of_x, broadcast_shape_of_y)
-    dx = reduce_sum(dx, rx)
-    dy = reduce_sum(dy, ry)
+    dx = sum_grad_reduce_axis(dx, rx)
+    dy = sum_grad_reduce_axis(dy, ry)
     reduce_dx = reshape(dx, shape_of_x)
     reduce_dy = reshape(dy, shape_of_y)
     return reduce_dx, reduce_dy
@@ -111,7 +112,7 @@ def binop_grad_common(x, y, dx, dy):
     # if input shape is the same as dout shape, do not need to reduce
     reduce_dx = dx
     reduce_dy = dy
-    if not (is_shape_unknown(shape_of_x) or is_shape_unknown(shape_of_y)):
+    if not (F.is_sequence_value_unknown(shape_of_x) or F.is_sequence_value_unknown(shape_of_y)):
         rx = broadcast_gradient_args(shape_of_x, shape_of_y)
         if rx[0]:
             # if dx is scalar whose shape is (), do not need reduce
@@ -124,11 +125,12 @@ def binop_grad_common(x, y, dx, dy):
                 dy = _reduce_sum_with_cast(dy, rx[1])
             reduce_dy = reshape(dy, shape_of_y)
         return reduce_dx, reduce_dy
-    if not shape_of_x or not shape_of_y:
+
+    if not isinstance(shape_of_x, tuple) or not isinstance(shape_of_y, tuple):
         # x or y is scalar
-        if not shape_of_x:
+        if not isinstance(shape_of_x, tuple):
             reduce_dx = _reduce_sum_with_cast(dx, ())
-        if not shape_of_y:
+        if not isinstance(shape_of_y, tuple):
             reduce_dy = _reduce_sum_with_cast(dy, ())
         return reduce_dx, reduce_dy
 
@@ -148,7 +150,7 @@ def binop_grad_common_with_shift(x, y, dx, dy, shift):
     # if input shape is the same as dout shape, do not need to reduce
     reduce_dx = dx
     reduce_dy = dy
-    if not (is_shape_unknown(broadcast_shape_of_x) or is_shape_unknown(broadcast_shape_of_y)):
+    if not (F.is_sequence_value_unknown(broadcast_shape_of_x) or F.is_sequence_value_unknown(broadcast_shape_of_y)):
         rx = broadcast_gradient_args(broadcast_shape_of_x, broadcast_shape_of_y)
         if rx[0]:
             # if dx is scalar whose shape is (), do not need reduce
@@ -161,49 +163,56 @@ def binop_grad_common_with_shift(x, y, dx, dy, shift):
                 dy = _reduce_sum_with_cast(dy, rx[1])
             reduce_dy = reshape(dy, shape_of_y)
         return reduce_dx, reduce_dy
-    if not shape_of_x or not shape_of_y:
+
+    if not isinstance(shape_of_x, tuple) or not isinstance(shape_of_y, tuple):
         # x or y is scalar
-        if not shape_of_x:
+        if not isinstance(shape_of_x, tuple):
             reduce_dx = _reduce_sum_with_cast(dx, ())
-        if not shape_of_y:
+        if not isinstance(shape_of_y, tuple):
             reduce_dy = _reduce_sum_with_cast(dy, ())
         return reduce_dx, reduce_dy
 
     return dyn_binop_grad_common_with_shift(x, y, dx, dy, shift)
 
 
-def _dyn_reduced_shape(input_shape, axis):
+def _dyn_reduced_shape(input_shape, axis, x):
     """Dynamic reduce shape"""
     input_shape = P.Cast()(input_shape, ms.int32)
-    if isinstance(axis, Tensor):
-        if is_shape_unknown(shape_op(axis)):
-            expanded_axis = P.ExpandDims()(axis, 1)
-            update = P.Cast()(P.OnesLike()(axis), ms.int32)
-            return P.TensorScatterUpdate()(input_shape, expanded_axis, update)
-        input_rank = P.Rank()(input_shape)
-        real_axis = (axis + input_rank) % input_rank
-        axis_shape = shape_op(real_axis)
+    if x is not None and not F.is_sequence_shape_unknown(shape_op(x)):
+        input_rank = len(shape_op(x))
     else:
-        real_axis = ()
-        input_rank = len(input_shape)
-        if isinstance(axis, int):
-            axis = (axis,)
-        elif not axis:
-            axis = range(input_rank)
-        for i in axis:
-            real_axis += ((i + input_rank) % input_rank,)
-        axis_shape = (len(real_axis),)
-    return DynamicStitch()([to_array(range(input_rank)), to_array(real_axis)],
-                           [input_shape, P.Fill()(ms.int32, axis_shape, 1)])
+        input_rank = dyn_rank(x)
+    input_rank = P.Cast()(input_rank, ms.int32)
+
+    if (isinstance(axis, tuple) and axis == ()) or (isinstance(axis, list) and axis == []):
+        res_shape = P.ExpandDims()(input_rank, 0)
+        return dyn_ones(res_shape, res_shape.dtype)
+
+    if isinstance(axis, int):
+        axis = (axis,)
+
+    real_axis = axis
+    if not isinstance(axis, Tensor):
+        real_axis = Tensor(axis, ms.int32)
+
+    real_axis = (real_axis + input_rank) % input_rank
+    if real_axis.ndim == 0:
+        real_axis = P.ExpandDims()(real_axis, 0)
+    expanded_axis = P.ExpandDims()(real_axis, 1)
+    expanded_axis = P.Cast()(expanded_axis, ms.int32)
+    update = P.Cast()(P.OnesLike()(real_axis), ms.float32)
+    input_shape = P.Cast()(input_shape, ms.float32)
+    return P.TensorScatterUpdate()(input_shape, expanded_axis, update)
 
 
 def _sum_grad(x, axis, dout):
     """Grad definition for `Sum` operation."""
     input_shape = shape_op(x)
     is_mutable, axis = convert_to_tensor(axis)
-    if is_shape_unknown(input_shape) or is_mutable:
+    if F.is_sequence_value_unknown(input_shape) or is_mutable:
         input_shape = dyn_shape_op(x)
-        output_shape_kept_dims = _dyn_reduced_shape(input_shape, axis)
+        output_shape_kept_dims = _dyn_reduced_shape(input_shape, axis, x)
+        output_shape_kept_dims = P.Cast()(output_shape_kept_dims, ms.int32)
         grad = reshape(dout, output_shape_kept_dims)
         return DynamicBroadcastTo()(grad, input_shape)
 
@@ -216,15 +225,40 @@ def _sum_grad(x, axis, dout):
 def _min_or_max_grad(x, axis, out, dout):
     """Grad definition for `Min` and `Max` operations."""
     input_shape = shape_op(x)
-    output_shape_kept_dims = reduced_shape(input_shape, axis)
+    output_shape_kept_dims = ()
+    if F.is_sequence_value_unknown(input_shape):
+        input_shape = dyn_shape_op(x)
+        output_shape_kept_dims = _dyn_reduced_shape(input_shape, axis, x)
+        output_shape_kept_dims = P.Cast()(output_shape_kept_dims, ms.int32)
+    else:
+        output_shape_kept_dims = reduced_shape(input_shape, axis)
+
     y = reshape(out, output_shape_kept_dims)
     grad = reshape(dout, output_shape_kept_dims)
     indicators = F.cast(F.equal(y, x), F.dtype(grad))
-    min_num = F.cast(F.scalar_to_array(1e-24), F.dtype(grad))
+    min_num = F.cast(F.scalar_to_tensor(1e-24), F.dtype(grad))
     num_selected = reshape(reduce_sum(indicators, axis), output_shape_kept_dims) + min_num
     return indicators / num_selected * grad
 
 
+def _onehot_with_neg_axis(axis, indices, depth, on_value_dtype):
+    """onehot support tensor axis"""
+    depth_range = P.Range()(F.cast(0, depth.dtype), depth, F.cast(1, depth.dtype))
+    indices_expand = P.ExpandDims()(indices, axis)
+    indices_expand_rank = dyn_rank_1d(indices_expand)
+    broad_shape = dyn_ones(indices_expand_rank, mstype.int64)
+    # It should use int64 dtype, but the TensorScatterUpdate op does not support the int64
+    # dtype on Ascend device, so the float32 dtype is used here.
+    update_dtype = mstype.float32
+    broad_shape = dyn_ones(indices_expand_rank, update_dtype)
+    broad_shape[axis] = F.cast(depth, update_dtype)
+    broad_shape = F.cast(broad_shape, mstype.int64)
+    depth_broad = P.Reshape()(depth_range, broad_shape)
+    one_hot_bool = P.Equal()(indices_expand, depth_broad)
+    one_hot_res = F.cast(one_hot_bool, on_value_dtype)
+    return one_hot_res
+
+
 def _argmin_or_argmax_grad(x, axis, keep_dims, op, out, dout):
     """ArgMinWiwhValue and ArgMaxWithValue grad."""
     expand = P.ExpandDims()
@@ -232,53 +266,48 @@ def _argmin_or_argmax_grad(x, axis, keep_dims, op, out, dout):
     x_shape = F.shape(x)
     x_dim = len(x_shape)
     x_axis = axis
+    onehot_axis_is_neg = False
     if x_axis < 0:
-        x_axis = axis + x_dim
+        if not F.is_sequence_shape_unknown(x_shape):
+            x_axis = axis + x_dim
+        else:
+            onehot_axis_is_neg = True
     onehot_axis = x_axis
-    depth = 1
-    if x_shape:
-        depth = x_shape[axis]
     if keep_dims:
         dout_expand = dout[1]
         out = op(x)
     else:
         dout_expand = expand(dout[1], onehot_axis)
-    if onehot_axis >= len(shape_op(out[0])):
-        onehot_axis = -1
-    onehot = P.OneHot(onehot_axis)
+    out_shape = shape_op(out[0])
+    if not F.is_sequence_shape_unknown(out_shape):
+        if onehot_axis >= len(out_shape):
+            onehot_axis = -1
     type_x = F.dtype(x)
-    on_value = F.cast(F.scalar_to_array(1.0), type_x)
-    off_value = F.cast(F.scalar_to_array(0.0), type_x)
-    dx = dout_expand * onehot(out[0], depth, on_value, off_value)
-    if not x_shape:
-        dx = squeeze(dx)
+    on_value = F.cast(F.scalar_to_tensor(1.0), type_x)
+    off_value = F.cast(F.scalar_to_tensor(0.0), type_x)
+    if not F.is_sequence_value_unknown(x_shape):
+        depth = 1
+        if x_shape:
+            depth = x_shape[axis]
+        onehot = P.OneHot(onehot_axis)
+        dx = dout_expand * onehot(out[0], depth, on_value, off_value)
+        if not x_shape:
+            dx = squeeze(dx)
+        return dx
+    x_tensor_shape = P.TensorShape()(x)
+    depth = x_tensor_shape[axis]
+    if not onehot_axis_is_neg:
+        onehot = P.OneHot(onehot_axis)
+        dx = dout_expand * onehot(out[0], depth, on_value, off_value)
+    else:
+        if out[0].value is not None:
+        # It is a temporary method: In the pynative mode, out may be a constant tensor. Constant
+        # folding occurs in ExpandDims op, but such scenarios are not supported currently.
+            out = op(x)
+        dx = dout_expand * _onehot_with_neg_axis(onehot_axis, out[0], depth, on_value.dtype)
     return dx
 
 
-@bprop_getters.register(P.MatMul)
-def bprop_matmul(self):
-    """Grad definition for `MatMul` operation."""
-    ta = self.transpose_a
-    tb = self.transpose_b
-    mul1 = P.MatMul(transpose_a=(ta and tb),
-                    transpose_b=(ta or (not tb)))
-    mul2 = P.MatMul(transpose_a=((not ta) or tb),
-                    transpose_b=(ta and tb))
-
-    def bprop(x, w, out, dout):
-        if ta:
-            dx = mul1(w, dout)
-        else:
-            dx = mul1(dout, w)
-        if tb:
-            dw = mul2(dout, x)
-        else:
-            dw = mul2(x, dout)
-        return dx, dw
-
-    return bprop
-
-
 @bprop_getters.register(P.BatchMatMul)
 def bprop_batchmatmul(self):
     """Grad definition for `BatchMatMul` operation."""
@@ -303,16 +332,6 @@ def bprop_batchmatmul(self):
     return bprop
 
 
-@bprop_getters.register(P.Add)
-def get_bprop_add(self):
-    """Grad definition for `Add` operation."""
-
-    def bprop(x, y, out, dout):
-        return binop_grad_common(x, y, dout, dout)
-
-    return bprop
-
-
 @bprop_getters.register(P.TensorAdd)
 def get_bprop_tensor_add(self):
     """Grad definition for `Add` operation."""
@@ -339,35 +358,14 @@ def get_bprop_matrix_inverse(self):
     return bprop
 
 
-@bprop_getters.register(P.Neg)
-def get_bprop_neg(self):
-    """Grad definition for `Neg` operation."""
-    neg_grad = P.Neg()
-
-    def bprop(x, out, dout):
-        dx = neg_grad(dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(P.Sub)
-def get_bprop_sub(self):
-    """Grad definition for `Sub` operation."""
-    neg_func = P.Neg()
-
-    def bprop(x, y, out, dout):
-        return binop_grad_common(x, y, dout, neg_func(dout))
-
-    return bprop
-
-
 @bprop_getters.register(P.Mul)
 def get_bprop_mul(self):
     """Grad definition for `Mul` operation."""
     mul_func = P.Mul()
 
     def bprop(x, y, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("For 'Mul', gradient not support for complex type currently.")
         bc_dx = mul_func(y, dout)
         bc_dy = mul_func(x, dout)
         return binop_grad_common(x, y, bc_dx, bc_dy)
@@ -383,6 +381,8 @@ def get_bprop_real_div(self):
     mul_op = P.Mul()
 
     def bprop(x, y, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("For 'RealDiv', gradient not support for complex type currently.")
         bc_x = div_op(dout, y)
         bc_y = neg(mul_op(bc_x, out))
         return binop_grad_common(x, y, bc_x, bc_y)
@@ -443,7 +443,10 @@ def get_bprop_floor(self):
     dtype_ = P.DType()
 
     def bprop(x, out, dout):
-        bc_x = fill_(dtype_(x), shape_(x), 0.)
+        if F.is_sequence_value_unknown(shape_(x)):
+            bc_x = zeros_like(x)
+        else:
+            bc_x = fill_(dtype_(x), shape_(x), 0.)
         return (bc_x,)
 
     return bprop
@@ -457,7 +460,10 @@ def get_bprop_ceil(self):
     dtype_ = P.DType()
 
     def bprop(x, out, dout):
-        bc_x = fill_(dtype_(x), shape_(x), 0.)
+        if F.is_sequence_value_unknown(shape_(x)):
+            bc_x = zeros_like(x)
+        else:
+            bc_x = fill_(dtype_(x), shape_(x), 0.)
         return (bc_x,)
 
     return bprop
@@ -473,6 +479,36 @@ def get_bprop_floordiv(self):
     return bprop
 
 
+@bprop_getters.register(P.BitwiseAnd)
+def get_bprop_bitwiseand(self):
+    """Grad definition for `BitwiseAnd` operation."""
+
+    def bprop(x, y, out, dout):
+        return zeros_like(x), zeros_like(y)
+
+    return bprop
+
+
+@bprop_getters.register(P.BitwiseOr)
+def get_bprop_bitwiseor(self):
+    """Grad definition for `BitwiseOr` operation."""
+
+    def bprop(x, y, out, dout):
+        return zeros_like(x), zeros_like(y)
+
+    return bprop
+
+
+@bprop_getters.register(P.BitwiseXor)
+def get_bprop_bitwisexor(self):
+    """Grad definition for `BitwiseXor` operation."""
+
+    def bprop(x, y, out, dout):
+        return zeros_like(x), zeros_like(y)
+
+    return bprop
+
+
 @bprop_getters.register(P.FloorMod)
 def get_bprop_floormod(self):
     """Grad definition for `FloorMod` operation."""
@@ -529,7 +565,12 @@ def get_bprop_square(self):
 
     def bprop(x, out, dout):
         temp = mul_func(dout, x)
-        dx = mul_func(fill_func(dtype(temp), shape_op(x), 2.0), temp)
+        shape_x = shape_op(x)
+        if F.is_sequence_value_unknown(shape_x):
+            fill_value = dyn_fill(dtype(temp), dyn_shape_op(x), 2.0)
+        else:
+            fill_value = fill_func(dtype(temp), shape_x, 2.0)
+        dx = mul_func(fill_value, temp)
         return (dx,)
 
     return bprop
@@ -575,8 +616,15 @@ def get_bprop_square_sum_all(self):
     def bprop(x, y, out, dout):
         temp_x = mul_func(dout[0], x)
         temp_y = mul_func(dout[1], y)
-        dx = mul_func(fill_func(dtype(temp_x), shape_op(x), 2.0), temp_x)
-        dy = mul_func(fill_func(dtype(temp_y), shape_op(y), 2.0), temp_y)
+        if F.is_sequence_value_unknown(shape_op(x)):
+            dx = mul_func(dyn_fill(dtype(temp_x), dyn_shape_op(x), 2.0), temp_x)
+        else:
+            dx = mul_func(fill_func(dtype(temp_x), shape_op(x), 2.0), temp_x)
+
+        if F.is_sequence_value_unknown(shape_op(y)):
+            dy = mul_func(dyn_fill(dtype(temp_y), dyn_shape_op(y), 2.0), temp_y)
+        else:
+            dy = mul_func(fill_func(dtype(temp_y), shape_op(y), 2.0), temp_y)
         return (dx, dy)
 
     return bprop
@@ -716,8 +764,14 @@ def get_bprop_pow(self):
     ln = P.Log()
 
     def bprop(x, power, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("For 'Pow', gradient not support for complex type currently.")
         bc_dx = power * pow_op(x, power - 1.0) * dout
-        x = F.select(x < 0, F.fill(F.dtype(x), F.shape(x), 1), x)
+        shape_x = shape_op(x)
+        if F.is_sequence_value_unknown(shape_x):
+            x = F.select(x < 0, dyn_fill(F.dtype(x), dyn_shape_op(x), 1), x)
+        else:
+            x = F.select(x < 0, F.fill(F.dtype(x), F.shape(x), 1), x)
         bc_dpower = out * ln(x) * dout
         return binop_grad_common(x, power, bc_dx, bc_dpower)
 
@@ -808,21 +862,31 @@ def get_bprop_cumsum(self):
     return bprop
 
 
-@constexpr
+@_primexpr
 def _split_shape_index(input_shape, axis):
     """Calculate reduce_prod grad transpose indices and perm shape."""
     rank = len(input_shape)
     if isinstance(axis, int):
         axis = tuple([axis])
     reduction_indices = tuple([(i + rank) % rank for i in axis])
-    other_indices = tuple(set(range(rank)) - set(reduction_indices))
-    reduced_num = reduce(lambda x, y: x * y, [1] + [input_shape[i] for i in reduction_indices])
-    other_num = reduce(lambda x, y: x * y, [1] + [input_shape[i] for i in other_indices])
+    other_indices_list = []
+    for i in range(rank):
+        if i not in reduction_indices and i not in other_indices_list:
+            other_indices_list.append(i)
+    other_indices = tuple(other_indices_list)
+    reduced_list = [1] + [input_shape[i] for i in reduction_indices]
+    other_list = [1] + [input_shape[i] for i in other_indices]
+    reduced_num = 1
+    for i in reduced_list:
+        reduced_num = reduced_num * i
+    other_num = 1
+    for i in other_list:
+        other_num = other_num * i
     perm = reduction_indices + other_indices
     return tuple([reduced_num, other_num]), perm
 
 
-@constexpr
+@_primexpr
 def _invert_permutation(perm):
     """Calculate invert permutation."""
     out = [0] * len(perm)
@@ -831,6 +895,26 @@ def _invert_permutation(perm):
     return tuple(out)
 
 
+def _split_dyn_shape_index(x, axis):
+    """Calculate reduce prod grad invert permutation."""
+    input_shape = dyn_shape_op(x)
+    rank = dyn_rank(x)
+    if not isinstance(axis, Tensor):
+        axis = Tensor(axis, dtype=mstype.int64)
+    reduction_indices = reshape(axis, (-1,))
+    reduction_indices = (reduction_indices + rank) % rank
+    reduced = P.Cast()(reduction_indices, mstype.int64)
+
+    start = Tensor(0, dtype=mstype.int64)
+    delta = Tensor(1, dtype=mstype.int64)
+    idx = P.Range()(start, rank, delta)
+    other, _ = A.ListDiff()(idx, reduced)
+    perm = P.Concat()((reduced, other))
+    reduced_num = reduce_prod(P.Cast()(P.Gather()(input_shape, reduced, 0), mstype.int64), ())
+    other_num = reduce_prod(P.Cast()(P.Gather()(input_shape, other, 0), mstype.int64), ())
+    return (reduced_num, other_num), perm
+
+
 @bprop_getters.register(P.ReduceProd)
 def get_bprop_reduceprod(self):
     """Grad definition for `ReduceProd` operation."""
@@ -840,17 +924,35 @@ def get_bprop_reduceprod(self):
 
     def bprop(x, axis, out, dout):
         """Grad definition for `Product` operation."""
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("The 'ReduceProd', gradient not support for complex type currently.")
         # Expand dout to full input shape
         input_shape = shape_op(x)
-        output_shape_kept_dims = reduced_shape(input_shape, axis)
+        if input_shape == ():
+            dx = _sum_grad(x, axis, dout)
+            return dx, zeros_like(axis)
+
+        if F.is_sequence_value_unknown(input_shape):
+            input_shape = dyn_shape_op(x)
+            input_shape = P.Cast()(input_shape, ms.int64)
+            output_shape_kept_dims = _dyn_reduced_shape(input_shape, axis, x)
+            output_shape_kept_dims = P.Cast()(output_shape_kept_dims, ms.int64)
+        else:
+            output_shape_kept_dims = reduced_shape(input_shape, axis)
+
         dout = reshape(dout, output_shape_kept_dims)
-        tile_scaling = tuple_div(input_shape, output_shape_kept_dims)
-        grad = tile(dout, tile_scaling)
 
         # Pack all reduced dimensions into a single one, so we can perform the cumprod ops.
-        pack_shape, perm = _split_shape_index(input_shape, axis)
+        if F.is_sequence_value_unknown(shape_op(x)):
+            pack_shape, perm = _split_dyn_shape_index(x, axis)
+        else:
+            pack_shape, perm = _split_shape_index(shape_op(x), axis)
+
         permuted = transpose(x, perm)
         permuted_shape = shape_op(permuted)
+        if F.is_sequence_value_unknown(permuted_shape):
+            permuted_shape = dyn_shape_op(permuted)
+            pack_shape = create_tensor_by_element(pack_shape)
         reshaped = reshape(permuted, pack_shape)
 
         # Calculate product, leaving out the current entry
@@ -860,7 +962,14 @@ def get_bprop_reduceprod(self):
 
         # Invert the transpose and reshape operations.
         # Make sure to set the statically known shape information through a reshape.
-        out = transpose(y, _invert_permutation(perm)) * grad
+        if F.is_sequence_value_unknown(shape_op(permuted)):
+            dout = DynamicBroadcastTo()(dout, input_shape)
+            out = transpose(y, dyn_invert_permutation(perm)) * dout
+        else:
+            tile_scaling = tuple_div(input_shape, output_shape_kept_dims)
+            grad = tile(dout, tile_scaling)
+            out = transpose(y, _invert_permutation(perm)) * grad
+
         dx = reshape(out, input_shape)
         return dx, zeros_like(axis)
 
@@ -908,6 +1017,8 @@ def get_bprop_reducemax(self):
     """Grad definition for `Max` operation."""
 
     def bprop(x, axis, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("The 'ReduceMax', gradient not support for complex type currently.")
         dx = _min_or_max_grad(x, axis, out, dout)
         return (dx, zeros_like(axis))
 
@@ -933,6 +1044,8 @@ def get_bprop_reducemin(self):
     """Grad definition for `ReduceMin` operation."""
 
     def bprop(x, axis, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("The 'ReduceMin', gradient not support for complex type currently.")
         dx = _min_or_max_grad(x, axis, out, dout)
         return (dx, zeros_like(axis))
 
@@ -961,17 +1074,20 @@ def get_bprop_reduce_mean(self):
     dtype = P.DType()
 
     def bprop(x, axis, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("The 'ReduceMean', gradient not support for complex type currently.")
         grad = _sum_grad(x, axis, dout)
         shape_x = shape_op(x)
         shape_out = shape_op(out)
-        if is_shape_unknown(shape_x):
+        if F.is_sequence_value_unknown(shape_x) or F.is_sequence_value_unknown(shape_out):
             shape_x = dyn_shape_op(x)
             shape_out = dyn_shape_op(out)
-            div_shape = reduce_prod(shape_x) / reduce_prod(shape_out)
+            div_shape = reduce_prod(cast(shape_x, mstype.float32), ()) /\
+                        reduce_prod(cast(shape_out, mstype.float32), ())
             dx = div_op(grad, cast(div_shape, dtype(grad)))
         else:
             div_shape = F.shape_mul(shape_x) / F.shape_mul(shape_out)
-            dx = div_op(grad, cast(F.scalar_to_array(div_shape), dtype(grad)))
+            dx = div_op(grad, cast(F.scalar_to_tensor(div_shape), dtype(grad)))
         return dx, zeros_like(axis)
 
     return bprop
@@ -1097,16 +1213,6 @@ def get_bprop_logical_and(self):
     return bprop
 
 
-@bprop_getters.register(P.LogicalOr)
-def get_bprop_logical_or(self):
-    """Grad definition for `LogicalOr` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
 @bprop_getters.register(P.NPUAllocFloatStatus)
 def get_bprop_npu_alloc_float_status(self):
     """Grad definition for `NPUAllocFloatStatus` operation."""
@@ -1304,6 +1410,9 @@ def get_bprop_cosh(self):
     sinh = P.Sinh()
 
     def bprop(x, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("The 'Cosh', gradient not support for complex type currently.")
+
         dx = sinh(x) * dout
         return (dx,)
 
@@ -1334,16 +1443,6 @@ def get_bprop_conj(self):
     return bprop
 
 
-@bprop_getters.register(P.ScalarCast)
-def get_bprop_scalar_cast(self):
-    """Generate bprop for ScalarCast"""
-
-    def bprop(x, t, out, dout):
-        return F.scalar_cast(dout, F.typeof(x)), zeros_like(t)
-
-    return bprop
-
-
 @bprop_getters.register(P.AccumulateNV2)
 def get_bprop_scalar_accumulatenv2(self):
     """Generate bprop for AccumulateNV2"""
@@ -1457,6 +1556,9 @@ def get_bprop_tan(self):
     cos = P.Cos()
 
     def bprop(x, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("For 'Tan', gradient not support for complex type currently.")
+
         cosx = cos(x)
         secx2 = square(reciprocal(cosx))
         dx = secx2 * dout
@@ -1498,6 +1600,9 @@ def get_bprop_atanh(self):
     div = P.Div()
 
     def bprop(x, out, dout):
+        if x.dtype in (mstype.complex64, mstype.complex128):
+            raise TypeError("For 'Atanh', gradient not support for complex type currently.")
+
         tmp = 1 - power(x, 2)
         dx = div(1, tmp) * dout
         return (dx,)
@@ -1537,3 +1642,43 @@ def get_bprop_index_add(self):
         return dout, zeros_like(indices), gather(dout, indices, _axis)
 
     return bprop
+
+
+@bprop_getters.register(P.InplaceUpdate)
+def get_bprop_inplace_update(self):
+    """Grad definition for `InplaceUpdate` operation."""
+
+    def bprop(x, v, out, dout):
+        return zeros_like(x), zeros_like(v)
+
+    return bprop
+
+
+@bprop_getters.register(P.InplaceUpdateV2)
+def get_bprop_inplace_update_v2(self):
+    """Grad definition for `InplaceUpdateV2` operation."""
+
+    def bprop(x, indices, v, out, dout):
+        return zeros_like(x), zeros_like(indices), zeros_like(v)
+
+    return bprop
+
+
+@bprop_getters.register(P.InplaceSub)
+def get_bprop_inplace_sub(self):
+    """Grad definition for `InplaceSub` operation."""
+
+    def bprop(x, input_v, out, dout):
+        return zeros_like(x), zeros_like(input_v)
+
+    return bprop
+
+
+@bprop_getters.register(P.InplaceAdd)
+def get_bprop_inplace_add(self):
+    """Grad definition for `InplaceAdd` operation."""
+
+    def bprop(x, input_v, out, dout):
+        return zeros_like(x), zeros_like(input_v)
+
+    return bprop