mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/_grad/grad_base.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-2022 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,13 +15,15 @@
 
 """grad base functions"""
 
-from .._register_for_op import Registry
-from ..primitive import Primitive
-from ...common import Tensor
-from .. import operations as P
-from ...common import dtype as mstype
-from ..operations._inner_ops import DynamicBroadcastTo
-
+from mindspore.ops._register_for_op import Registry
+from mindspore.ops.primitive import Primitive
+from mindspore.common import Tensor
+from mindspore.ops import operations as P
+from mindspore.common import dtype as mstype
+from mindspore.ops.operations._inner_ops import DynamicBroadcastTo
+from mindspore.ops import functional as F
+from mindspore.ops.operations import _sequence_ops as seq_op
+import mindspore as ms
 dyn_shape = P.TensorShape()
 cast = P.Cast()
 
@@ -68,12 +70,14 @@ taylor_fprop_getters = TaylorFpropRegistry()
 taylor_fprops = TaylorFpropRegistry()
 
 
-def get_bprop_fn(prim):
+def get_bprop_fn(prim, get_closure=False):
     """get bprop function by primitive obj or prim name for c++"""
     out = bprop_getters.get(prim, None)
-    if out:
-        return out(prim)
-    return bprops.get(prim, None)
+    if out is None:
+        return bprops.get(prim, None)
+    if get_closure:
+        return out
+    return out(prim)
 
 
 def get_taylor_fprop_fn(prim):
@@ -89,12 +93,39 @@ def convert_to_tensor(data):
     if isinstance(data, Tensor):
         return True, data
 
+    if isinstance(data, list):
+        if F.is_sequence_value_unknown(data):
+            data_tensor = seq_op.ListToTensor()(data, ms.int64)
+            return True, data_tensor
+        return False, data
+    if isinstance(data, tuple):
+        if F.is_sequence_value_unknown(data):
+            data_tensor = seq_op.TupleToTensor()(data, ms.int64)
+            return True, data_tensor
+        return False, data
+    if isinstance(data, int):
+        if not F.isconstant(data):
+            data_tensor = F.scalar_to_tensor(data, ms.int64)
+            return True, data_tensor
+        return False, data
+    if isinstance(data, float):
+        if not F.isconstant(data):
+            data_tensor = F.scalar_to_tensor(data, ms.float32)
+            return True, data_tensor
+        return False, data
     return False, data
 
 
 def dyn_rank(tensor):
     """get the rank of tensor"""
-    return dyn_shape(dyn_shape(tensor))[0]
+    out_rank = dyn_shape(dyn_shape(tensor))
+    return P.Reshape()(out_rank, ())
+
+
+def dyn_rank_1d(tensor):
+    """get the rank of tensor and return a 1D tensor"""
+    tensor_shape = dyn_shape(tensor)
+    return dyn_shape(tensor_shape)
 
 
 def dyn_size(tensor, dtype=mstype.int64):
@@ -117,13 +148,15 @@ def create_tensor_by_element(ori_tuple, data_type=mstype.int64):
     return ori_tuple
 
 
-def dyn_invert_permutation(prem):
+def dyn_invert_permutation(perm):
     """get the invert premutation of tensor"""
-    indices = P.ExpandDims()(prem, -1)
-    end = dyn_size(prem)
+    indices = P.ExpandDims()(perm, -1)
+    end = dyn_size(perm)
     updates = P.Range()(P.Cast()(0, end.dtype), end, P.Cast()(1, end.dtype))
     output = P.ZerosLike()(updates)
-    return P.TensorScatterUpdate()(output, indices, updates)
+    new_perm = P.TensorScatterUpdate()(P.Cast()(output, mstype.float32),
+                                       indices, P.Cast()(updates, mstype.float32))
+    return P.Cast()(new_perm, mstype.int32)
 
 
 def dyn_fill(value_type, shape, value):
@@ -135,3 +168,8 @@ def dyn_fill(value_type, shape, value):
 def dyn_ones(shape, value_type):
     """creates a tensor filled with value ones."""
     return dyn_fill(value_type, shape, 1)
+
+
+def sum_grad_reduce_axis(x, rx, keep_dims=False):
+    """sum the grad_reduce_axis. when rx is an empty tensor and skip_mode is True, we need skip this reduce"""
+    return P.ReduceSum(keep_dims=keep_dims, skip_mode=True)(x, rx)

mindspore/ops/_grad/grad_clip_ops.py

@@ -15,11 +15,13 @@
 
 
 """Define the grad rules of clip operations."""
-from mindspore.ops._grad.grad_base import bprop_getters
+from __future__ import absolute_import
+from mindspore.ops._grad.grad_base import bprop_getters, dyn_fill
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.operations import _grad_ops as G
-import mindspore.common.dtype as mstype
+from mindspore.common import dtype as mstype
 from mindspore.ops._grad.grad_math_ops import _sum_grad
 from mindspore.ops._grad.grad_math_ops import binop_grad_common
 
@@ -33,6 +35,7 @@ def get_bprop_clip_by_norm(self):
     fill_op = P.Fill()
     type_op = P.DType()
     shape_op = P.Shape()
+    dyn_shape_op = P.TensorShape()
     cast_op = P.Cast()
     sqrt_op = P.Sqrt()
     max_op = P.Maximum()
@@ -67,7 +70,12 @@ def get_bprop_clip_by_norm(self):
         # grad for square operation
         temp_num = 2.0
         temp_out = mul_op(reduce_sum_dout_x, cast_x)
-        square_dout_x = mul_op(fill_op(type_op(temp_out), shape_op(cast_x), temp_num), temp_out)
+        shape_cast_x = shape_op(cast_x)
+        if F.is_sequence_value_unknown(shape_cast_x):
+            fill_x = dyn_fill(type_op(temp_out), dyn_shape_op(cast_x), temp_num)
+        else:
+            fill_x = fill_op(type_op(temp_out), shape_cast_x, temp_num)
+        square_dout_x = mul_op(fill_x, temp_out)
         # grad for cast operation
         x_dout = cast_op((mul_dout_x + square_dout_x), type_op(x))
         clip_norm_dout = cast_op((mul_dout_y + max_dout_y), type_op(clip_norm))

mindspore/ops/_grad/grad_comm_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-2022 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,8 +22,8 @@ from mindspore.ops import functional as F
 from mindspore.communication import get_rank, get_group_size
 from mindspore.parallel._utils import _get_enable_parallel_optimizer, _get_grad_accumulation_shard
 from mindspore.ops import operations as P
-from mindspore.ops.operations._inner_ops import Send, Receive
-from mindspore.common.tensor import RowTensor
+from mindspore.ops.operations._inner_ops import Send, Receive, issubclass_
+from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.operations.comm_ops import (AllGather, _MiniStepAllGather, _HostAllGather, AllReduce,
                                                NeighborExchange, AlltoAll, NeighborExchangeV2, Broadcast,
@@ -61,17 +61,17 @@ def get_bprop_all_reduce(self):
     elif self.op == ReduceOp.SUM:
 
         def bprop(x, out, dout):
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 dx = all_reduce_grad(dout)
             else:
                 indices = all_gather(dout.indices)
                 grad = all_gather(dout.values)
-                dx = RowTensor(indices, grad, dout.dense_shape)
+                dx = RowTensorInner(indices, grad, dout.dense_shape)
             return (dx,)
     else:
 
         def bprop(x, out, dout):
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 dx = all_reduce_grad(dout)
                 z = equal(x, out)
                 z = cast(z, dtype(dx))
@@ -82,7 +82,7 @@ def get_bprop_all_reduce(self):
                 z = equal(x, out)
                 z = cast(z, dtype(grad))
                 grad = mul(grad, z)
-                dx = RowTensor(indices, grad, dout.dense_shape)
+                dx = RowTensorInner(indices, grad, dout.dense_shape)
             return (dx,)
     return bprop
 
@@ -151,8 +151,7 @@ def get_bprop_virtual_assign_add(self):
     def bprop(x, y, out, dout):
         if reduce_scatter:
             dout = reduce_scatter(dout)
-        temp = assign_add(y, dout)
-        return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(y))), temp)
+        return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(y))), assign_add(y, dout))
 
     return bprop
 
@@ -204,18 +203,20 @@ def get_bprop_mirror_micro_step_operator(self):
         real_grad = z
         assign_out = dout
         if mean_flag:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 z = F.depend(z, dout)
                 real_grad = all_reduce(z)
                 real_grad = F.tensor_mul(real_grad, scale)
-                assign_out = assign(z, real_grad)
+                if opt_shard:
+                    return (real_grad, cast(out_tensor, dtype(z)))
+                return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign(z, real_grad))
         else:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 z = F.depend(z, dout)
                 real_grad = all_reduce(z)
-                assign_out = assign(z, real_grad)
-        if opt_shard:
-            return (real_grad, cast(out_tensor, dtype(z)))
+                if opt_shard:
+                    return (real_grad, cast(out_tensor, dtype(z)))
+                return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign(z, real_grad))
         return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(z))), assign_out)
     return bprop
 
@@ -284,10 +285,11 @@ def get_bprop_mini_step_all_gather(self):
                 if mean_flag:
                     dx = F.tensor_mul(dx, scale)
                 if add_accu:
-                    z = assign_add(z, dx)
+                    assign_add(z, dx)
                 dx = F.depend(dx, z)
         else:
             dx = dout
+
         return (dx, zeros_like(z))
 
     return bprop
@@ -298,21 +300,33 @@ def get_bprop_micro_step_all_gather(self):
     """Generate bprop for _MicroStepAllGather"""
     fusion = self.get_attr_dict()["fusion"]
     mean_flag = self.get_attr_dict()["mean_flag"]
-    do_mirror = self.get_attr_dict()["do_mirror"]
-    scale = 1.0 / self.rank_size
-    all_reduce = AllReduce(ReduceOp.SUM, self.group).add_prim_attr("fusion", fusion)
-    rank = get_rank(self.group)
-    dev_num = get_group_size(self.group)
-    split = P.Split(output_num=dev_num)
-    if self.instance_name:
-        instance_name = "grad_" + self.instance_name
-        all_reduce.set_prim_instance_name(instance_name)
+    do_mirror = False
+    if self.group != "":
+        do_mirror = self.get_attr_dict()["do_mirror"]
+    if do_mirror:
+        scale = 1.0 / self.rank_size
+        all_reduce = AllReduce(ReduceOp.SUM, self.group).add_prim_attr("fusion", fusion)
+        rank = get_rank(self.group)
+        dev_num = get_group_size(self.group)
+        split = P.Split(output_num=dev_num)
+        if self.instance_name:
+            instance_name = "grad_" + self.instance_name
+            all_reduce.set_prim_instance_name(instance_name)
     cast = P.Cast()
     dtype = P.DType()
     out_tensor = Tensor(1.0, mstype.float16)
+    with_mirror_operator = self.get_attr_dict()["with_mirror_operator"]
 
     # z: accu_grad
     def bprop(x, z, out, dout):
+        if with_mirror_operator:
+            if not do_mirror:
+                return (dout, cast(out_tensor, dtype(z)))
+            real_grad = all_reduce(dout)
+            real_grad = split(real_grad)[rank]
+            if mean_flag:
+                real_grad = F.tensor_mul(real_grad, scale)
+            return (real_grad, cast(out_tensor, dtype(z)))
         z = F.depend(z, dout)
         if not do_mirror:
             return (z, cast(out_tensor, dtype(z)))
@@ -450,7 +464,9 @@ def get_bprop_mirror_operator(self):
     group = self.get_attr_dict()['group']
     dev_num = self.get_attr_dict()['dev_num']
     mean_flag = self.get_attr_dict()['mean_flag']
+    dev_num_r = 1.0
     if dev_num > 1:
+        dev_num_r = 1.0 / dev_num
         all_reduce = AllReduce(group=group)
         all_gather = AllGather(group=group)
         mul = P.Mul()
@@ -470,25 +486,21 @@ def get_bprop_mirror_operator(self):
         if dev_num == 1:
             return (dout,)
         if mean_flag:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 dx = all_reduce(dout)
-                float_one = F.scalar_cast(1.0, F.dtype(dx))
-                num = F.scalar_cast(dev_num, F.dtype(dx))
-                dx = mul(dx, cast(F.scalar_to_array(float_one/num), F.dtype(dx)))
+                dx = mul(dx, cast(F.scalar_to_tensor(dev_num_r), F.dtype(dx)))
             else:
                 indices = all_gather(dout.indices)
                 grad = all_gather(dout.values)
-                float_one = F.scalar_cast(1.0, F.dtype(grad))
-                num = F.scalar_cast(dev_num, F.dtype(grad))
-                grad = mul(grad, cast(F.scalar_to_array(float_one/num), F.dtype(grad)))
-                dx = RowTensor(indices, grad, dout.dense_shape)
+                grad = mul(grad, cast(F.scalar_to_tensor(dev_num_r), F.dtype(grad)))
+                dx = RowTensorInner(indices, grad, dout.dense_shape)
         else:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 dx = all_reduce(dout)
             else:
                 indices = all_gather(dout.indices)
                 grad = all_gather(dout.values)
-                dx = RowTensor(indices, grad, dout.dense_shape)
+                dx = RowTensorInner(indices, grad, dout.dense_shape)
 
         return (dx,)
     return bprop
@@ -503,6 +515,7 @@ def get_bprop_mirror_mini_step_operator(self):
     group = self.group
     dev_num = self.dev_num
     mean_flag = self.mean_flag
+    dev_num_r = 1.0 / dev_num
 
     all_reduce = AllReduce(group=group)
     mul = P.Mul()
@@ -521,20 +534,18 @@ def get_bprop_mirror_mini_step_operator(self):
 
     def bprop(x, z, out, dout):
         if mean_flag:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 if do_mirror:
                     z = F.depend(z, F.assign_add(z, dout))
                     real_grad = all_reduce(z)
                     dx = real_grad
                 else:
                     dx = dout
-                float_one = F.scalar_cast(1.0, F.dtype(dx))
-                num = F.scalar_cast(dev_num, F.dtype(dx))
-                dx = mul(dx, cast(F.scalar_to_array(float_one/num), F.dtype(dx)))
+                dx = mul(dx, cast(F.scalar_to_tensor(dev_num_r), F.dtype(dx)))
             else:
                 dx = zeros_like(x)  # The grad accumulation do not support row tensor now
         else:
-            if F.issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.typeof(dout), mstype.tensor):
                 if do_mirror:
                     z = F.depend(z, F.assign_add(z, dout))
                     real_grad = all_reduce(z)
@@ -557,25 +568,25 @@ def get_bprop_virtual_div_operator(self):
     dtype = P.DType()
 
     def bprop(x, out, dout):
-        if F.issubclass_(F.typeof(dout), mstype.tensor):
-            if F.issubclass_(F.dtype(dout), mstype.bool_) or F.issubclass_(F.dtype(dout), mstype.int32) \
-                                     or F.issubclass_(F.dtype(dout), mstype.int16):
+        if issubclass_(F.typeof(dout), mstype.tensor):
+            if issubclass_(F.dtype(dout), mstype.bool_) or issubclass_(F.dtype(dout), mstype.int32) \
+                                     or issubclass_(F.dtype(dout), mstype.int16):
                 return (dout,)
-            dx = op(dout, cast(F.scalar_to_array(divisor), dtype(dout)))
+            dx = op(dout, cast(F.scalar_to_tensor(divisor), dtype(dout)))
             return (dx,)
 
-        if F.issubclass_(F.typeof(dout), mstype.tuple_):
+        if issubclass_(F.typeof(dout), mstype.tuple_):
             dx = ()
             input_nums = F.tuple_len(dout)
             for i in range(input_nums):
-                ele_grad = op(dout[i], cast(F.scalar_to_array(divisor), dtype(dout[i])))
+                ele_grad = op(dout[i], cast(F.scalar_to_tensor(divisor), dtype(dout[i])))
                 dx = dx + (ele_grad,)
             return (dx,)
 
         dx = []
         input_nums = F.list_len(dout)
         for i in range(input_nums):
-            ele_grad = op(dout[i], cast(F.scalar_to_array(divisor), dtype(dout[i])))
+            ele_grad = op(dout[i], cast(F.scalar_to_tensor(divisor), dtype(dout[i])))
             dx.append(ele_grad)
         return (dx,)
     return bprop

mindspore/ops/_grad/grad_implementations.py

@@ -15,11 +15,12 @@
 
 """bprop primitives"""
 from mindspore.ops import _constants
-from mindspore.ops.operations import _grad_ops as G
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore.ops.composite import multitype_ops as C
+from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops._grad.grad_base import bprops
+from mindspore.common import dtype as mstype
 
 get_dtype = P.DType()
 # Unused parameters are placeholders.
@@ -35,38 +36,6 @@ def bprop_max_and_minimum_grad_grad(x, y, z, out, dout):
     return F.zeros_like(x), F.zeros_like(y), dz
 
 
-@bprops.register("ReluGrad")
-def bprop_relu_grad_grad(x, y, out, dout):
-    """Backpropagator for primitive `ReluGrad`."""
-    input_grad = G.ReluGrad()
-    dy = input_grad(dout, y)
-    return dy, F.zeros_like(y)
-
-
-@bprops.register(_constants.kScalarAdd)
-def bprop_scalar_add(x, y, out, dout):
-    """Backpropagator for primitive `scalar_add`."""
-    return dout, dout
-
-
-@bprops.register(_constants.kScalarMul)
-def bprop_scalar_mul(x, y, out, dout):
-    """Backpropagator for primitive `scalar_mul`."""
-    return dout * y, dout * x
-
-
-@bprops.register(_constants.kScalarSub)
-def bprop_scalar_sub(x, y, out, dout):
-    """Backpropagator for primitive `scalar_sub`."""
-    return dout, -dout
-
-
-@bprops.register(_constants.kScalarDiv)
-def bprop_scalar_div(x, y, out, dout):
-    """Backpropagator for primitive `scalar_div`."""
-    return dout / y, (-dout) * (out / y)
-
-
 @bprops.register(_constants.kScalarPow)
 def bprop_scalar_pow(x, y, out, dout):
     """Backpropagator for primitive `scalar_pow`."""
@@ -100,13 +69,19 @@ def bprop_scalar_cast(x, t, out, dout):
 @bprops.register(_constants.kTupleGetItem)
 def bprop_tuple_getitem(data, idx, out, dout):
     """Backpropagator for primitive `tuple_getitem`."""
-    return F.tuple_setitem(C.zeros_like(data), idx, dout), C.zeros_like(idx)
+    return F.tuple_setitem(zeros_like(data), idx, dout), zeros_like(idx)
 
 
 @bprops.register("list_getitem")
 def bprop_list_getitem(data, idx, out, dout):
     """Backpropagator for primitive `list_getitem`."""
-    return F.list_setitem(C.zeros_like(data), idx, dout), C.zeros_like(idx)
+    return F.list_setitem(zeros_like(data), idx, dout), zeros_like(idx)
+
+
+@bprops.register("dict_getitem")
+def bprop_dict_getitem(data, key, out, dout):
+    """Backpropagator for primitive `dict_getitem`."""
+    return F.dict_setitem(C.zeros_like(data), key, dout), key
 
 
 @bprops.register("identity")
@@ -115,16 +90,14 @@ def bprop_identity(x, out, dout):
     return (dout,)
 
 
-@bprops.register("scalar_to_array")
-def bprop_scalar_to_array(x, out, dout):
-    """Backpropagator for primitive `scalar_to_array`."""
-    return (F.array_to_scalar(dout),)
-
-
 @bprops.register("array_to_scalar")
 def bprop_array_to_scalar(x, out, dout):
     """Backpropagator for primitive `array_to_scalar`."""
-    return (F.scalar_to_array(dout),)
+    if isinstance(dout, int):
+        ret = F.scalar_to_tensor(dout, mstype.int32)
+    else:
+        ret = F.scalar_to_tensor(dout)
+    return (ret,)
 
 
 @bprops.register("reshape")
@@ -169,12 +142,6 @@ def bprop_embed(x, out, dout):
     return (C.zeros_like(x),)
 
 
-@bprops.register("stop_gradient")
-def bprop_stop_gradient(x, out, dout):
-    """Backpropagator for primitive `stop_gradient`."""
-    return (C.zeros_like(x),)
-
-
 @bprops.register("Switch")
 def bprop_switch(cond, tb, fb, out, dout):
     """Backpropagator for primitive `switch`."""
@@ -191,28 +158,15 @@ def _fprop_switch_layer(index, layers):
     return F.switch_layer(index, layers), _bprop_switch_layer
 
 
-@bprops.register("UpdateState")
-def bprop_update_state(u_monad, x, out, dout):
-    """Backpropagator for primitive `UpdateState`."""
-    return C.zeros_like(u_monad), C.zeros_like(x)
-
-
 @bprops.register("Load")
 def bprop_load(param, u_monad, out, dout):
     """Backpropagator for primitive `load`."""
     return dout, C.zeros_like(u_monad)
 
 
-@bprops.register("scalar_gt")
-@bprops.register("scalar_lt")
-@bprops.register("scalar_ge")
-@bprops.register("scalar_le")
-@bprops.register("scalar_eq")
 @bprops.register("scalar_ne")
 @bprops.register("bool_and")
 @bprops.register("bool_or")
-@bprops.register("bit_and")
-@bprops.register("bit_or")
 @bprops.register("bit_xor")
 @bprops.register("bit_left_shift")
 @bprops.register("bit_right_shift")
@@ -235,3 +189,9 @@ def bprop_scalar_calc(x, y, out, dout):
 def bprop_scalar_not(x, out, dout):
     """Backpropagator for primitive `bool_not` and `string_not`."""
     return (C.zeros_like(x),)
+
+
+@bprops.register("TensorMove")
+def bprop_tensor_move(x, out, dout):
+    """Backpropagator for primitive `TensorMove`."""
+    return (dout,)

mindspore/ops/_grad/grad_inner_ops.py

@@ -18,12 +18,13 @@
 from __future__ import absolute_import
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore.ops.primitive import constexpr
-from mindspore.ops._grad.grad_base import bprop_getters
+from mindspore.ops.primitive import _primexpr
+from mindspore.ops._grad.grad_base import bprop_getters, sum_grad_reduce_axis
 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 mindspore.ops.operations import image_ops as IMG
+from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
+import mindspore as ms
 
 dyn_shape_op = P.TensorShape()
 reshape = P.Reshape()
@@ -43,7 +44,7 @@ def _get_matrix_diag_part_assist(x_shape, x_dtype):
     return assist
 
 
-@constexpr
+@_primexpr
 def _get_min(x):
     return min(x)
 
@@ -167,14 +168,19 @@ def get_bprop_ps_roi_pooling(self):
 @bprop_getters.register(inner.DynamicBroadcastTo)
 def get_bprop_dynamic_broadcast_to(self):
     """Generate bprop for DynamicBroadcastTo"""
-    reduce_keep_dim = P.ReduceSum(keep_dims=True)
 
     def bprop(x, shp, out, dout):
         x_shape = dyn_shape_op(x)
         broadcast_shape = dyn_shape_op(out)
 
         _, reduction_axes = inner.DynamicBroadcastGradientArgs()(broadcast_shape, x_shape)
-        reduced_grad = reduce_keep_dim(dout, reduction_axes)
+        out_type = dout.dtype
+        if out_type in (ms.int16, ms.int32, ms.int64):
+            dout = P.Cast()(dout, ms.float32)
+            reduced_grad = sum_grad_reduce_axis(dout, reduction_axes, keep_dims=True)
+            reduced_grad = P.Cast()(reduced_grad, out_type)
+        else:
+            reduced_grad = sum_grad_reduce_axis(dout, reduction_axes, keep_dims=True)
         dx = reshape(reduced_grad, x_shape)
         return dx, zeros_like(shp)
 
@@ -191,3 +197,39 @@ def get_bprop_resize_bilinear(self):
         return dx, zeros_like(size)
 
     return bprop
+
+
+@bprop_getters.register(inner.ConvertToAdapterTensor)
+def get_bprop_convert_to_adapter_tensor(self):
+    """Generate bprop for ConvertToAdapterTensor"""
+
+    def bprop(x, out, dout):
+        return (dout,)
+
+    return bprop
+
+
+@bprop_getters.register(inner.ConvertToMsTensor)
+def get_bprop_convert_to_ms_tensor(self):
+    """Generate bprop for ConvertToMsTensor"""
+
+    def bprop(x, out, dout):
+        return (dout,)
+
+    return bprop
+
+
+@bprop_getters.register(inner.SiLU)
+def get_bprop_silu(self):
+    """Generate bprop for SiLU"""
+    sigmoid_grad = G.SigmoidGrad()
+    mul_func = P.Mul()
+
+    def bprop(x, out, dout):
+        sigmoid_input = P.Sigmoid()(x)
+        bc_dx = mul_func(x, dout)
+        bc_dy = mul_func(sigmoid_input, dout)
+        dx = sigmoid_grad(sigmoid_input, bc_dx)
+        return (dx+bc_dy,)
+
+    return bprop