mindspore 2.1.0__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/_grad_experimental/__init__.py

@@ -17,20 +17,15 @@
 from __future__ import absolute_import
 from mindspore.ops._grad_experimental.grad_base import get_bprop_fn, get_taylor_fprop_fn
 from mindspore.ops._grad_experimental import grad_array_ops
-from mindspore.ops._grad_experimental import grad_image_ops
 from mindspore.ops._grad_experimental import grad_inner_ops
 from mindspore.ops._grad_experimental import grad_nn_ops
 from mindspore.ops._grad_experimental import grad_math_ops
-from mindspore.ops._grad_experimental import grad_linalg_ops
 from mindspore.ops._grad_experimental import grad_sparse
 from mindspore.ops._grad_experimental import grad_sparse_ops
-from mindspore.ops._grad_experimental import grad_scalar_ops
 from mindspore.ops._grad_experimental import grad_comm_ops
 from mindspore.ops._grad_experimental import grad_debug_ops
 from mindspore.ops._grad_experimental import grad_implementations
-from mindspore.ops._grad_experimental import grad_other_ops
 from mindspore.ops._grad_experimental import grad_quant_ops
-from mindspore.ops._grad_experimental import grad_sequence_ops
 from mindspore.ops._grad_experimental import taylor_rule
 
 __all__ = ['get_bprop_fn', 'get_taylor_fprop_fn']

mindspore/ops/_grad_experimental/grad_array_ops.py

@@ -398,7 +398,6 @@ def get_bprop_extract_volume_patches(self):
     expend_dims = P.ExpandDims()
     scatter_nd = P.ScatterNd()
     slice_op = P.Slice()
-    fill = P.Fill()
     dtype = P.DType()
     cast = P.Cast()
     matmul = P.MatMul()
@@ -466,7 +465,7 @@ def get_bprop_extract_volume_patches(self):
         idx_tensor = concat((expend_dims(x_idx_patched, -1), expend_dims(out_idx, -1)))
         idx_map = P.Reshape()(idx_tensor, (-1, 2))
         sp_shape = (x_indices_num, out_indices_num)
-        sp_mat_full = scatter_nd(idx_map, fill(dtype(dout), (out_indices_num,), 1), sp_shape)
+        sp_mat_full = scatter_nd(idx_map, F.fill(dtype(dout), (out_indices_num,), 1), sp_shape)
         sp_tensor = slice_op(sp_mat_full, (1, 0), (x_indices_num - 1, out_indices_num))
 
         grad = P.Transpose()(dout, (0, 2, 3, 4, 1))

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -98,6 +98,7 @@ def get_bprop_send(self):
     def bprop(x, out, dout):
         dx = send_grad(virtual_input)
         return (dx,)
+
     return bprop
 
 
@@ -117,14 +118,17 @@ def get_bprop_receive(self):
         else:
             dx = depend(cast(out_tensor, F.dtype(x)), send_out)
         return (dx,)
+
     return bprop
 
 
 @bprop_getters.register(_VirtualAdd)
 def get_bprop_virtual_add(self):
     """Generate bprop for _VirtualAdd"""
+
     def bprop(x, grad_accu, out, dout):
         return (dout + grad_accu, zeros_like(grad_accu))
+
     return bprop
 
 
@@ -181,7 +185,8 @@ def get_bprop_mirror_micro_step_operator(self):
     scale = 1 / dev_num
 
     all_reduce = AllReduce(group=group)
-
+    if "segment" in self.get_attr_dict():
+        all_reduce.add_prim_attr("segment", self.get_attr_dict()["segment"])
     fusion = self.get_attr_dict()["fusion"]
     all_reduce.add_prim_attr("fusion", fusion)
     if hasattr(self, 'parameter'):
@@ -218,6 +223,7 @@ def get_bprop_mirror_micro_step_operator(self):
                     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
 
 
@@ -227,6 +233,7 @@ def get_bprop_broad_cast(self):
 
     def bprop(x, out, dout):
         return (dout,)
+
     return bprop
 
 
@@ -306,6 +313,8 @@ def get_bprop_micro_step_all_gather(self):
     if do_mirror:
         scale = 1.0 / self.rank_size
         all_reduce = AllReduce(ReduceOp.SUM, self.group).add_prim_attr("fusion", fusion)
+        if "segment" in self.get_attr_dict():
+            all_reduce.add_prim_attr("segment", self.get_attr_dict()["segment"])
         rank = get_rank(self.group)
         dev_num = get_group_size(self.group)
         split = P.Split(output_num=dev_num)
@@ -502,6 +511,7 @@ def get_bprop_mirror_operator(self):
                 dx = RowTensorInner(indices, grad, dout.dense_shape)
 
         return (dx,)
+
     return bprop
 
 
@@ -555,6 +565,7 @@ def get_bprop_mirror_mini_step_operator(self):
                 dx = zeros_like(x)  # The grad accumulation do not support row tensor now
 
         return (dx, zeros_like(z))
+
     return bprop
 
 
@@ -569,7 +580,7 @@ def get_bprop_virtual_div_operator(self):
     def bprop(x, out, dout):
         if issubclass_(F.typeof(dout), mstype.tensor_type):
             if issubclass_(F.dtype(dout), mstype.bool_) or issubclass_(F.dtype(dout), mstype.int32) \
-                                     or issubclass_(F.dtype(dout), mstype.int16):
+                    or issubclass_(F.dtype(dout), mstype.int16):
                 return (dout,)
             dx = op(dout, cast(F.scalar_to_tensor(divisor), dtype(dout)))
             return (dx,)
@@ -588,6 +599,7 @@ def get_bprop_virtual_div_operator(self):
             ele_grad = op(dout[i], cast(F.scalar_to_tensor(divisor), dtype(dout[i])))
             dx.append(ele_grad)
         return (dx,)
+
     return bprop
 
 
@@ -597,4 +609,5 @@ def get_bprop_get_tensor_slice_operator(self):
 
     def bprop(x, dev_mat, tensor_map, out, dout):
         return (zeros_like(x),)
+
     return bprop

mindspore/ops/_grad_experimental/grad_debug_ops.py

@@ -16,48 +16,11 @@
 """Generate bprop for debug ops"""
 
 from mindspore.ops import operations as P
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops._grad_experimental.grad_base import bprop_getters
 
 # Unused parameters are placeholders.
 
 
-@bprop_getters.register(P.ScalarSummary)
-def get_bprop_scalar_summary(self):
-    """Generate bprop for ScalarSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.TensorSummary)
-def get_bprop_tensor_summary(self):
-    """Generate bprop for TensorSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.ImageSummary)
-def get_bprop_image_summary(self):
-    """Generate bprop for ImageSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
-@bprop_getters.register(P.HistogramSummary)
-def get_bprop_histogram_summary(self):
-    """Generate bprop for HistogramSummary"""
-
-    def bprop(tag, x, out, dout):
-        return tag, zeros_like(x)
-    return bprop
-
-
 @bprop_getters.register(P.InsertGradientOf)
 def get_bprop_insert_gradient_of(self):
     """Generate bprop for InsertGradientOf"""

mindspore/ops/_grad_experimental/grad_implementations.py

@@ -191,3 +191,13 @@ def bprop_scalar_not(x, out, dout):
 def bprop_tensor_move(x, out, dout):
     """Backpropagator for primitive `TensorMove`."""
     return (dout,)
+
+
+@bprops.register("DictInplaceSetItem")
+def get_bprop_dict_inplace_setitem(self):
+    """Generate bprop for dict inplace pop"""
+
+    def bprop(x, key, target, out, dout):
+        return (zeros_like(x), zeros_like(key), zeros_like(target))
+
+    return bprop

mindspore/ops/_grad_experimental/grad_inner_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -16,57 +16,11 @@
 """inner_ops"""
 from __future__ import absolute_import
 
-from mindspore.ops.operations.comm_ops import _VirtualPipelineEnd
 from mindspore.ops.operations import _inner_ops as inner
 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.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops.primitive import _primexpr
-from mindspore.ops._grad_experimental.grad_base import bprop_getters, sum_grad_reduce_axis
-import mindspore as ms
-
-reshape = P.Reshape()
-
-
-@bprop_getters.register(inner.TensorCopySlices)
-def get_bprop_tensor_copy_slices(self):
-    """Generate bprop for TensorCopySlices"""
-    tensor_copy_slices = inner.TensorCopySlices()
-
-    def bprop(x, update, begin, end, stride, out, dout):
-        x_grad = tensor_copy_slices(dout, zeros_like(update), begin, end, stride)
-        update_grad = F.strided_slice(dout, begin, end, stride)
-        res = (x_grad, update_grad, zeros_like(begin), zeros_like(end), zeros_like(stride))
-        return res
-
-    return bprop
-
-
-@bprop_getters.register(_VirtualPipelineEnd)
-def get_bprop_virtual_pipeline_end(self):
-    """Backpropagator for _VirtualPipelineEnd."""
-    grad = _VirtualPipelineEnd()
-
-    def bprop(x, out, dout):
-        dx = grad(dout)
-        return (dx,)
-    return bprop
-
-
-@bprop_getters.register(inner.DynamicResizeNearestNeighbor)
-def get_bprop_dynamic_resize_nearest_neighbor(self):
-    """Generate bprop for DynamicResizeNearestNeighbor"""
-    op = G.ResizeNearestNeighborGrad(self.align_corners)
-    shape_op = P.Shape()
-
-    def bprop(inputs, size, out, dout):
-        shp = shape_op(inputs)
-        # 2 and 3 represent the height and width
-        shp = (shp[2:])
-        return (op(dout, shp), zeros_like(size))
-
-    return bprop
+from mindspore.ops._grad_experimental.grad_base import bprop_getters
 
 
 @bprop_getters.register(inner.ParallelResizeBilinear)
@@ -82,115 +36,6 @@ def get_bprop_parallel_resize_bilinear(self):
     return bprop
 
 
-@bprop_getters.register(inner.ConvertToDynamic)
-def get_bprop_gpu_convert_to_dynamic_rank(self):
-    """Get backprop for ConvertToDynamic."""
-
-    def bprop(x, out, dout):
-        return (dout,)
-    return bprop
-
-
-def _get_matrix_diag_assist(x_shape, x_dtype):
-    base_eye = P.Eye()(x_shape[-1], x_shape[-1], x_dtype).flatten()
-    tile = P.Tile()(base_eye, x_shape[:-1])
-    assist = P.Reshape()(tile, x_shape + (x_shape[-1],))
-    return assist
-
-
-def _get_matrix_diag_part_assist(x_shape, x_dtype):
-    base_eye = P.Eye()(x_shape[-2], x_shape[-1], x_dtype).flatten()
-    tile = P.Tile()(base_eye, x_shape[:-2])
-    assist = P.Reshape()(tile, x_shape)
-    return assist
-
-
-@_primexpr
-def _get_min(x):
-    return min(x)
-
-
-@bprop_getters.register(inner.MatrixDiag)
-def get_bprop_matrix_diag(self):
-    """Generate bprop for MatrixDiag"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, out, dout):
-        shape = F.shape(dout)
-        dtype = get_dtype(dout)
-        assist = _get_matrix_diag_part_assist(shape, dtype)
-        dx = inner.MatrixDiagPart()(dout, assist)
-        return dx, zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatrixDiagPart)
-def get_bprop_matrix_diag_part(self):
-    """Generate bprop for MatrixDiagPart"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, out, dout):
-        x_shape = F.shape(x)[-2:]
-        if x_shape[0] == x_shape[1]:
-            shape = F.shape(dout)
-            dtype = get_dtype(dout)
-            assist = _get_matrix_diag_assist(shape, dtype)
-            return inner.MatrixDiag()(dout, assist), zeros_like(y)
-        shape = F.shape(x)
-        dtype = get_dtype(x)
-        assist = _get_matrix_diag_part_assist(shape, dtype)
-        return inner.MatrixSetDiag()(zeros_like(x), dout, assist), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatrixSetDiag)
-def get_bprop_matrix_set_diag(self):
-    """Generate bprop for MatrixSetDiag"""
-    get_dtype = P.DType()
-
-    def bprop(x, y, z, out, dout):
-        input_shape = F.shape(x)
-        batch_shape = input_shape[:-2]
-        matrix_shape = input_shape[-2:]
-        diag_shape = batch_shape + (_get_min(matrix_shape),)
-
-        grad_shape = F.shape(dout)
-        grad_dtype = get_dtype(dout)
-        assist = _get_matrix_diag_part_assist(grad_shape, grad_dtype)
-        dx = inner.MatrixSetDiag()(dout, P.Zeros()(diag_shape, grad_dtype), assist)
-        dy = inner.MatrixDiagPart()(dout, assist)
-        dz = zeros_like(z)
-        return dx, dy, dz
-
-    return bprop
-
-
-@bprop_getters.register(inner.DSDMatmul)
-def get_dsd_matmul_bprop(self):
-    def bprop(w1_gm, w2_gm, v_gm, out, dout):
-        d_w1_gm, d_w2_gm, d_v_gm = inner.DSDGrad()(w1_gm, w2_gm, v_gm, out, dout)
-        return d_w1_gm, d_w2_gm, d_v_gm
-
-    return bprop
-
-
-@bprop_getters.register(inner.MatmulDDS)
-def get_bprop(self):
-    """brop of the matmulDDS operator"""
-
-    def bprop(q, k, local_mask, global_mask, out, d_out):
-        lc, gc = out
-        d_lc, d_gc = d_out
-        dq, dk = inner.MatmulDDSGrad()(q, k, lc, gc, d_lc, d_gc)
-        dk = P.Transpose()(dk, (1, 0, 3, 2))
-        all_d = (dq, dk, zeros_like(local_mask), zeros_like(global_mask))
-        return all_d
-
-    return bprop
-
-
 @bprop_getters.register(inner.PsROIPooling)
 def get_bprop_ps_roi_pooling(self):
     """Grad definition for `PsROIPooling` operation."""
@@ -224,62 +69,3 @@ def get_bprop_ps_roi_pooling(self):
         return dx, zeros_like(rois)
 
     return bprop
-
-
-@bprop_getters.register(inner.DynamicBroadcastTo)
-def get_bprop_dynamic_broadcast_to(self):
-    """Generate bprop for DynamicBroadcastTo"""
-    shape_op = P.Shape()
-
-    def bprop(x, shp, out, dout):
-        x_shape = shape_op(x)
-        broadcast_shape = shape_op(out)
-
-        _, reduction_axes = inner.DynamicBroadcastGradientArgs()(broadcast_shape, x_shape)
-        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)
-
-    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

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -34,14 +34,12 @@ from mindspore.ops.operations.math_ops import MatrixTriangularSolve
 from mindspore.ops.operations.math_ops import NanToNum
 from mindspore.ops.operations.math_ops import FFTWithSize
 from mindspore.ops.operations.math_ops import Cholesky
-from mindspore.ops.operations.math_ops import Fmin
 from mindspore.ops.operations.math_ops import CholeskySolve
 from mindspore.ops.operations.math_ops import InplaceIndexAdd
 from mindspore.ops.operations.math_ops import TridiagonalSolve
 from mindspore.ops.operations.math_ops import Diagonal
 from mindspore.ops.operations.math_ops import EuclideanNorm
 from mindspore.ops.operations.array_ops import Transpose, MatrixSetDiagV3
-from mindspore.ops.operations.math_ops import Fmax
 from mindspore.ops.operations._inner_ops import DynamicBroadcastGradientArgs
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.primitive import _primexpr
@@ -424,115 +422,6 @@ def get_bprop_polar(self):
     return bprop
 
 
-@bprop_getters.register(Fmin)
-def get_bprop_fmin(self):
-    """Grad definition for 'Fmin' operation"""
-    shape_ = P.Shape()
-    masked_fill_op = P.MaskedFill()
-    logical_or_op = P.LogicalOr()
-    logical_not_op = P.LogicalNot()
-    logical_and_op = P.LogicalAnd()
-    mul_op = P.Mul()
-    is_nan_op = P.IsNan()
-    reshape_ = P.Reshape()
-
-    def bprop(x1, x2, out, dout):
-        x1_dtype = F.dtype(x1)
-        x2_dtype = F.dtype(x2)
-        x1 = F.cast(x1, mstype.float32)
-        x2 = F.cast(x2, mstype.float32)
-        dout = F.cast(dout, mstype.float32)
-        b1 = logical_or_op((x1 <= x2), is_nan_op(x2))
-        b2 = logical_or_op((x2 < x1), logical_and_op(is_nan_op(x1), logical_not_op(is_nan_op(x2))))
-        rx1 = masked_fill_op(x1, b1, 1.)
-        rx1 = masked_fill_op(rx1, logical_not_op(b1), 0.)
-        rx2 = masked_fill_op(x2, b2, 1.)
-        rx2 = masked_fill_op(rx2, logical_not_op(b2), 0.)
-        rrx1 = mul_op(rx1, dout)
-        rrx2 = mul_op(rx2, dout)
-        shape_of_x1 = shape_(x1)
-        shape_of_x2 = shape_(x2)
-        x1_dim = len(shape_of_x1)
-        x2_dim = len(shape_of_x2)
-        if x1_dim == 0 and x2_dim != 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2
-        elif x1_dim == 0 and x2_dim == 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2.sum()
-        elif x1_dim != 0 and x2_dim == 0:
-            sum_r2 = rrx2.sum()
-            sum_r1 = rrx1
-        else:
-            rx, ry = DynamicBroadcastGradientArgs()(shape_of_x1, shape_of_x2)
-            sum_r1 = sum_grad_reduce_axis(rrx1, rx)
-            sum_r2 = sum_grad_reduce_axis(rrx2, ry)
-        brrx1 = reshape_(sum_r1, shape_of_x1)
-        brrx2 = reshape_(sum_r2, shape_of_x2)
-        brrx1 = F.cast(brrx1, x1_dtype)
-        brrx2 = F.cast(brrx2, x2_dtype)
-        return brrx1, brrx2
-
-    return bprop
-
-
-@bprop_getters.register(Fmax)
-def get_bprop_fmax(self):
-    """Grad definition for 'Fmax' operation"""
-    shape_ = P.Shape()
-    masked_fill_op = P.MaskedFill()
-    logical_or_op = P.LogicalOr()
-    logical_not_op = P.LogicalNot()
-    logical_and_op = P.LogicalAnd()
-    mul_op = P.Mul()
-    is_nan_op = P.IsNan()
-    reshape_ = P.Reshape()
-
-    def bprop(x1, x2, out, dout):
-        x1_dtype = F.dtype(x1)
-        x2_dtype = F.dtype(x2)
-        if x1_dtype != mstype.float32:
-            x1 = F.cast(x1, mstype.float32)
-            dout = F.cast(dout, mstype.float32)
-        if x2_dtype != mstype.float32:
-            x2 = F.cast(x2, mstype.float32)
-            dout = F.cast(dout, mstype.float32)
-        b1 = logical_or_op(logical_and_op((x1 >= x2), logical_not_op(is_nan_op(x1))), is_nan_op(x2))
-        b2 = logical_or_op(logical_and_op(x2 > x1, logical_not_op(is_nan_op(x2))),
-                           logical_and_op(is_nan_op(x1), logical_not_op(is_nan_op(x2))))
-        rx1 = masked_fill_op(x1, b1, 1.)
-        rx1 = masked_fill_op(rx1, logical_not_op(b1), 0.)
-        rx2 = masked_fill_op(x2, b2, 1.)
-        rx2 = masked_fill_op(rx2, logical_not_op(b2), 0.)
-        rrx1 = mul_op(rx1, dout)
-        rrx2 = mul_op(rx2, dout)
-        shape_of_x1 = shape_(x1)
-        shape_of_x2 = shape_(x2)
-        x1_dim = len(shape_of_x1)
-        x2_dim = len(shape_of_x2)
-        if x1_dim == 0 and x2_dim != 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2
-        elif x1_dim == 0 and x2_dim == 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2.sum()
-        elif x1_dim != 0 and x2_dim == 0:
-            sum_r2 = rrx2.sum()
-            sum_r1 = rrx1
-        else:
-            rx, ry = DynamicBroadcastGradientArgs()(shape_of_x1, shape_of_x2)
-            sum_r1 = sum_grad_reduce_axis(rrx1, rx)
-            sum_r2 = sum_grad_reduce_axis(rrx2, ry)
-        brrx1 = reshape_(sum_r1, shape_of_x1)
-        brrx2 = reshape_(sum_r2, shape_of_x2)
-        brrx1 = F.cast(brrx1, x1_dtype)
-        brrx2 = F.cast(brrx2, x2_dtype)
-        return brrx1, brrx2
-
-
-    return bprop
-
-
 @bprop_getters.register(TridiagonalSolve)
 def get_bprop_tridiagonalsolve(self):
     """Grad definition for 'TridiagonalSolve' operation"""
@@ -1127,73 +1016,3 @@ def get_bprop_tensor_add(self):
         return binop_grad_common(x, y, dout, dout)
 
     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.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

mindspore/ops/_grad_experimental/grad_sparse.py

@@ -1,3 +1,18 @@
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
 """Define the grad rules of math related operations."""
 
 from mindspore.ops import functional as F

mindspore/ops/_op_impl/_custom_op/dsd_back_impl.py

@@ -299,7 +299,7 @@ def dsdbpropimpl(w1_gm, w2_gm, v_gm, a_gm, d_a_gm, d_w1_gm={}, d_w2_gm={}, d_v_g
                                                            global_size // 16, 16, 16),
                                                name='v_global_l0b', scope=tik.scope_cb)
 
-                # d_w_global，小z大n
+                # d_w_global, 小z大n
                 d_w_global_l0c = tik_inst.Tensor('float32', (global_size // 16, head_size // (16 * ub_time), 16, 16),
                                                  name='d_w_global_l0c', scope=tik.scope_cc)
                 d_w_global_ub = tik_inst.Tensor('float16', (global_size // 16,