mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -18,15 +18,12 @@
 import numpy as np
 import mindspore.numpy as mnp
 from mindspore.common import dtype as mstype
+import mindspore.ops as ops
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore import Tensor
-from mindspore.ops.operations.math_ops import Real, Imag, Complex, Angle
-from mindspore.ops.operations.math_ops import Polar
-from mindspore.ops.operations import _grad_ops as G
-from mindspore.ops.operations.math_ops import Lgamma
-from mindspore.ops.operations.math_ops import Digamma
-from mindspore.ops.operations.math_ops import Polygamma
+from mindspore.ops.operations.math_ops import SilentCheck
+from mindspore.ops.operations._inner_ops import _MirrorSilentCheck
 from mindspore.ops.operations.math_ops import CumulativeLogsumexp
 from mindspore.ops.operations.math_ops import MatrixSolve
 from mindspore.ops.operations.math_ops import MatrixSolveLs
@@ -35,11 +32,8 @@ 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 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.array_ops import Transpose
 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
@@ -135,7 +129,7 @@ def get_bprop_matrix_triangular_solve(self):
 
     def bprop(matrix, rhs, out, dout):
         grad_rhs = matrix_triangular_solve_op(matrix, dout)
-        if matrix.dtype in (mstype.complex64, mstype.complex128):
+        if matrix.dtype == mstype.complex64 or matrix.dtype == mstype.complex128:
             grad_rhs_temp = _adjoint(grad_rhs)
             out_temp = _adjoint(out)
         else:
@@ -156,14 +150,14 @@ def get_bprop_matrix_triangular_solve(self):
                 grad_matrix = mat_mul_op(grad_rhs, out_temp)
                 grad_matrix = neg_op(grad_matrix)
         if lower_a:
-            if grad_matrix.dtype in (mstype.complex64, mstype.complex128):
+            if grad_matrix.dtype == mstype.complex64 or grad_matrix.dtype == mstype.complex128:
                 grad_matrix_real = matrix_band_part_op(real_op(grad_matrix), -1, 0)
                 grad_matrix_imag = matrix_band_part_op(imag_op(grad_matrix), -1, 0)
                 grad_matrix = complex_op(grad_matrix_real, grad_matrix_imag)
             else:
                 grad_matrix = matrix_band_part_op(grad_matrix, -1, 0)
         else:
-            if grad_matrix.dtype in (mstype.complex64, mstype.complex128):
+            if grad_matrix.dtype == mstype.complex64 or grad_matrix.dtype == mstype.complex128:
                 grad_matrix_real = matrix_band_part_op(real_op(grad_matrix), 0, -1)
                 grad_matrix_imag = matrix_band_part_op(imag_op(grad_matrix), 0, -1)
                 grad_matrix = complex_op(grad_matrix_real, grad_matrix_imag)
@@ -219,7 +213,7 @@ def get_bprop_matrix_solve(self):
 @_primexpr
 def _generate_perm_matrix_solve_ls(x_dim):
     perm = tuple(range(x_dim - 2))
-    perm = perm + (x_dim - 1, x_dim - 2)
+    perm = perm + (x_dim-1, x_dim-2)
     return perm
 
 
@@ -283,7 +277,7 @@ def get_bprop_matrix_solve_ls(self):
             else:
                 l2_regularizer = cast(l2, matrix.dtype)
             chol = cast(regularized_gramian_cholesky(matrix, l2_regularizer, first_kind=True), matrix.dtype)
-            #CholeskySolve not support complex dtype and just support 2D or 3D matrices for now
+            # CholeskySolve not support complex dtype and just support 2D or 3D matrices for now
             z = cholesky_solve(dout, chol)
 
             matrix_dim = rank(matrix)
@@ -378,131 +372,6 @@ def get_bprop_nan_to_num(self):
     return bprop
 
 
-@bprop_getters.register(Angle)
-def get_bprop_angle(self):
-    """Grad definition for `Angle` operation."""
-    real_op = Real()
-    imag_op = Imag()
-    reciprocal_op = P.Reciprocal()
-    complex_op = Complex()
-    neg_op = P.Neg()
-
-    def bprop(x, out, dout):
-        re = real_op(x)
-        im = imag_op(x)
-        re = complex_op(im, re)
-        z = reciprocal_op(re)
-        zero = zeros_like(dout)
-        complex_dout = complex_op(dout, zero)
-        return (neg_op(complex_dout * z),)
-
-    return bprop
-
-
-@bprop_getters.register(Polar)
-def get_bprop_polar(self):
-    """Grad definition for `Polar` operation."""
-    complex_op = Complex()
-    conj = P.Conj()
-    real = P.Real()
-    sig = P.Sign()
-    ones = P.Ones()
-    zeros = P.Zeros()
-
-    def bprop(input1, angle, out, dout):
-        grad_conj = conj(dout)
-        zero = zeros(dout.shape, input1.dtype)
-        one = ones(dout.shape, input1.dtype)
-        i = complex_op(zero, one)
-        grad_abs = real(grad_conj * sig(out))
-        result_mul_1_j = out * i
-        grad_angle = real(grad_conj * result_mul_1_j)
-        return (grad_abs, grad_angle)
-
-    return bprop
-
-
-@bprop_getters.register(TridiagonalSolve)
-def get_bprop_tridiagonalsolve(self):
-    """Grad definition for 'TridiagonalSolve' operation"""
-    tridiagonalsolve = TridiagonalSolve()
-
-    def bprop(diagonals, rhs, out, dout):
-        diags = diagonals
-        diag1 = diags[..., 1, :]
-        zeros1 = P.Zeros()(diags.shape[:-2] + (1,), diags.dtype)
-        superdiag1 = P.Concat(-1)((diags[..., 2, 1:], zeros1))
-        subdiag1 = P.Concat(-1)((zeros1, diags[..., 0, :-1]))
-        diags_transposed = P.Stack(-2)([superdiag1, diag1, subdiag1])
-        grad_rhs = tridiagonalsolve(diags_transposed, dout)
-        diag2 = P.ReduceSum()(grad_rhs * out, -1)
-        zeros2 = P.Zeros()(grad_rhs.shape[:-2] + (1, grad_rhs.shape[-1]), grad_rhs.dtype)
-        superdiag2 = P.ReduceSum()(grad_rhs * P.Concat(-2)((out[..., 1:, :], zeros2)), -1)
-        subdiag2 = P.ReduceSum()(grad_rhs * P.Concat(-2)((zeros2, out[..., :-1, :])), -1)
-        a = (P.Stack(-2)([superdiag2, diag2, subdiag2]))
-        grad_diags = 0 - a
-        return grad_diags, grad_rhs
-
-    return bprop
-
-
-@bprop_getters.register(Lgamma)
-def get_bprop_lgamma(self):
-    """Grad definition for `Lgamma` operation."""
-    digamma = Digamma()
-
-    def bprop(x, out, dout):
-        if x.dtype in (mstype.float16,):
-            x = F.cast(x, mstype.float32)
-            dx = dout * digamma(x)
-            dx = F.cast(dx, mstype.float16)
-        elif x.dtype in (mstype.int32,):
-            x = F.cast(x, mstype.float32)
-            dx = dout * digamma(x)
-        else:
-            dx = dout * digamma(x)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(Digamma)
-def get_bprop_digamma(self):
-    """Grad definition for `Digamma` operation."""
-    polygamma = Polygamma()
-    a = Tensor(1)
-
-    def bprop(x, out, dout):
-        if x.dtype in (mstype.float16,):
-            x = F.cast(x, mstype.float32)
-            dx = dout * polygamma(a, x)
-            dx = F.cast(dx, mstype.float16)
-        else:
-            dx = dout * polygamma(a, x)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(Polygamma)
-def get_bprop_polygamma(self):
-    """Grad definition for `Polygamma` operation."""
-    polygamma = Polygamma()
-
-    def bprop(a, x, out, dout):
-        one = Tensor(1)
-        a = a + one
-        if x.dtype in (mstype.float16,):
-            x = F.cast(x, mstype.float64)
-            dx = dout * polygamma(a, x)
-            dx = F.cast(dx, mstype.float16)
-        else:
-            dx = dout * polygamma(a, x)
-        return zeros_like(a), dx
-
-    return bprop
-
-
 @bprop_getters.register(CholeskySolve)
 def get_bprop_cholesky_solve(self):
     """Grad definition for 'CholeskySolve' operation"""
@@ -547,94 +416,6 @@ def get_bprop_cholesky_solve(self):
     return bprop
 
 
-@bprop_getters.register(Diagonal)
-def get_bprop_diagonal(self):
-    """Grad definition for 'Diagonal' operation"""
-    offset = self.offset
-    dim1 = self.dim1
-    dim2 = self.dim2
-    zeros_op = P.FillV2()
-    size_op = P.Size()
-    transpose_op = Transpose()
-    matrix_set_diag_op = MatrixSetDiagV3(align="LEFT_RIGHT")
-
-    def bprop(x, out, dout):
-        x_shape = x.shape
-        x_dtype = x.dtype
-        x_dim = len(x_shape)
-        if dim1 < 0:
-            dim1_ = dim1 + x_dim
-        else:
-            dim1_ = dim1
-        if dim2 < 0:
-            dim2_ = dim2 + x_dim
-        else:
-            dim2_ = dim2
-        if size_op(out):
-            batch_dim = out.shape[:-1]
-            diag_plane = (x_shape[dim1_], x_shape[dim2_])
-            dx_trans_shape = batch_dim + diag_plane
-            value = Tensor(0, x_dtype)
-            dx = zeros_op(dx_trans_shape, value)
-            k = F.cast(offset, mstype.int32)
-            dx = matrix_set_diag_op(dx, dout, k)
-            dim = 0
-            perm = ()
-            for i in range(x_dim):
-                if i == dim1_:
-                    perm = perm + (x_dim - 2,)
-                elif i == dim2_:
-                    perm = perm + (x_dim - 1,)
-                else:
-                    perm = perm + (dim,)
-                    dim = dim + 1
-            dx = transpose_op(dx, perm)
-        else:
-            dx = zeros_like(x)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(Cholesky)
-def get_bprop_cholesky(self):
-    """Grad definition for `Cholesky` operation."""
-    upper = self.upper
-    choleskygrad = G.CholeskyGrad()
-
-    def bprop(x, out, dout):
-        out = cholesky_transpose(out) if upper else out
-        dout = cholesky_transpose(dout) if upper else dout
-        dx = choleskygrad(out, dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(InplaceIndexAdd)
-def get_bprop_inplace_index_add(self):
-    """Generate bprop for InplaceIndexAdd"""
-    gather = P.Gather()
-    _axis = self.axis
-
-    def bprop(var, indices, updates, out, dout):
-        return dout, zeros_like(indices), gather(dout, indices, _axis)
-
-    return bprop
-
-
-@bprop_getters.register(P.Zeta)
-def get_bprop_zeta(self):
-    """Generate bprop for Zeta"""
-    zeta = P.Zeta()
-
-    def bprop(x, q, out, dout):
-        dq = -x * zeta(x + 1, q) * dout
-        return zeros_like(x), dq
-
-    return bprop
-
-
 @_primexpr
 def _fft_rank_offset(norm_shape, rank):
     """generate offset for fft with rank"""
@@ -644,24 +425,37 @@ def _fft_rank_offset(norm_shape, rank):
     return norm_shape_product
 
 
+@_primexpr
+def _norm_enum_to_string(norm_mode):
+    """convert norm_mode enum to string ."""
+    norm_mode_str = ""
+    if norm_mode == 0:
+        norm_mode_str = "backward"
+    elif norm_mode == 1:
+        norm_mode_str = "forward"
+    elif norm_mode == 2:
+        norm_mode_str = "ortho"
+    return norm_mode_str
+
+
 @_primexpr
 def _fft_with_size_back_norm(norm_shape, norm, inverse, rank):
     """generate reverse term for fft_with_size"""
-    norm_ = None
+    norm_ = 1
     if inverse is False:
         if norm == "forward":
-            norm_ = 1.0 / _fft_rank_offset(norm_shape, rank)
-        elif norm == "backward":
-            norm_ = 1.0 * _fft_rank_offset(norm_shape, rank)
-        elif norm == "ortho":
-            norm_ = 1.0
-    else:
+            norm_ = 1 / _fft_rank_offset(norm_shape, rank)
+        if norm == "backward":
+            norm_ = 1 * _fft_rank_offset(norm_shape, rank)
+        if norm == "ortho":
+            norm_ = 1
+    if inverse is True:
         if norm == "forward":
-            norm_ = 1.0 * _fft_rank_offset(norm_shape, rank)
-        elif norm == "backward":
-            norm_ = 1.0 / _fft_rank_offset(norm_shape, rank)
-        elif norm == "ortho":
-            norm_ = 1.0
+            norm_ = 1 * _fft_rank_offset(norm_shape, rank)
+        if norm == "backward":
+            norm_ = 1 / _fft_rank_offset(norm_shape, rank)
+        if norm == "ortho":
+            norm_ = 1
     return norm_
 
 
@@ -671,9 +465,9 @@ def _rfft_norm(norm_shape, norm, rank):
     norm_ = 1.0
     if norm == "forward":
         norm_ = 1 / _fft_rank_offset(norm_shape, rank)
-    elif norm == "backward":
-        norm_ = 1.0
-    elif norm == "ortho":
+    if norm == "backward":
+        norm_ = 1
+    if norm == "ortho":
         norm_ = 1 / np.sqrt(_fft_rank_offset(norm_shape, rank))
     return norm_
 
@@ -735,34 +529,11 @@ def _batch_matmul_shape_decrease(matrix_shape):
 @bprop_getters.register(FFTWithSize)
 def get_bprop_fft_with_size(self):
     """Grad definition for `FFTWithSize` operation."""
-    signal_ndim = self.signal_ndim
-    inverse = self.inverse
-    real = self.real
-    norm = self.norm
-    onesided = self.onesided
-    fft_fn = FFTWithSize(signal_ndim=signal_ndim,
-                         inverse=False,
-                         real=False,
-                         norm=norm)
-    ifft_fn = FFTWithSize(signal_ndim=signal_ndim,
-                          inverse=True,
-                          real=False,
-                          norm=norm)
-    rfft_fn = FFTWithSize(signal_ndim=signal_ndim,
-                          inverse=False,
-                          real=True,
-                          norm=norm,
-                          onesided=onesided)
-    irfft_fn = FFTWithSize(signal_ndim=signal_ndim,
-                           inverse=True,
-                           real=True,
-                           norm=norm,
-                           onesided=onesided)
-
     complex_op = P.Complex()
     to_tensor_op = P.ScalarToTensor()
     type_op = P.DType()
     concat_op = P.Concat()
+    concat_op_last = P.Concat(axis=-1)
     ones_op = P.Ones()
     zeros_op = P.Zeros()
     real_op = P.Real()
@@ -776,7 +547,31 @@ def get_bprop_fft_with_size(self):
     conj_op = P.Conj()
     batch_matmul_op = P.BatchMatMul()
 
-    def bprop(x, out, dout):
+    def reverse_branch(dx, onesided, dout_shape, offset_shape,
+                       output_type, dout, norm, inverse, signal_ndim, offset_size):
+        if onesided is True:
+            is_odd = dout_shape[-1] % 2
+            last_shape = offset_shape[-1]
+            mask = concat_op((ones_op(1, output_type), 2.0 * ones_op(
+                (last_shape - 2 + is_odd,), output_type), ones_op((1 - is_odd,), output_type)))
+            dx = dx * \
+                complex_op(mask, zeros_op(shape_op(mask), output_type))
+            irfft_offset_size = to_tensor_op(
+                _fft_with_size_back_norm(
+                    shape_op(dout), norm, inverse, signal_ndim),
+                output_type)
+            dx = dx * complex_op(irfft_offset_size,
+                                 zeros_op(1, output_type))
+        else:
+            dx = dx * complex_op(offset_size, zeros_op(1, output_type))
+        return dx
+
+    def bprop(x, signal_ndim, inverse, real, norm_enum, onesided, signal_sizes, out, dout):
+        norm = _norm_enum_to_string(norm_enum)
+        fft_fn = FFTWithSize(signal_ndim=signal_ndim, inverse=False, real=False, norm=norm)
+        ifft_fn = FFTWithSize(signal_ndim=signal_ndim, inverse=True, real=False, norm=norm)
+        rfft_fn = FFTWithSize(signal_ndim=signal_ndim, inverse=False, real=True, norm=norm, onesided=onesided)
+        irfft_fn = FFTWithSize(signal_ndim=signal_ndim, inverse=True, real=True, norm=norm, onesided=onesided)
         dx = 0
         input_type = type_op(x)
         output_type = type_op(out)
@@ -794,8 +589,7 @@ def get_bprop_fft_with_size(self):
                                  signal_sizes=offset_shape[-1:])
             irfft2d_ = FFTWithSize(signal_ndim=2, inverse=True, real=True, norm="backward", onesided=onesided,
                                    signal_sizes=offset_shape[-2:])
-            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=True, norm="backward", onesided=onesided,
-                                   signal_sizes=offset_shape[-3:])
+            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=False, norm="backward", onesided=onesided)
             if inverse is False:
                 if onesided is True:
                     terms = 0
@@ -811,6 +605,7 @@ def get_bprop_fft_with_size(self):
                         vec_mask = complex_op(1 - 2 * (mnp.arange(0, input_shape[-1], 1, input_type) % 2),
                                               zeros_op(input_shape[-1], input_type))
                         terms = real_op(dout_first) + is_even * real_op(dout_last * vec_mask)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 2:
                         dx = irfft2d_(dout)
                         arange_inner = mnp.arange(0, input_shape[-2], 1, input_type)
@@ -852,28 +647,19 @@ def get_bprop_fft_with_size(self):
                                                         dout_shape, [input_shape[-1]])))
                         dout_last_term = dout_last_term * vec_mask
                         terms = real_op(dout_first_term) + is_even * real_op(dout_last_term)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 3:
-                        dx = irfft3d_(dout) * real_op(offset_size)
-                    dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
+                        zeros_shape = offset_shape[:-1] + (offset_shape[-1] - dout_shape[-1],)
+                        zeros_values = zeros_op(zeros_shape, input_type)
+                        zeros_padding = complex_op(zeros_values, zeros_values)
+                        dout = concat_op_last((dout, zeros_padding))
+                        dx = real_op(irfft3d_(dout)) * real_op(offset_size)
                 else:
                     dx = irfft_fn(dout) * real_op(offset_size)
             else:
                 dx = rfft_fn(dout)
-                if onesided is True:
-                    if signal_ndim != 3:
-                        is_odd = dout_shape[-1] % 2
-                        last_shape = offset_shape[-1]
-                        mask = concat_op((ones_op(1, output_type), 2.0 * ones_op(
-                            (last_shape - 2 + is_odd,), output_type), ones_op((1 - is_odd,), output_type)))
-                        dx = dx * complex_op(mask, zeros_op(shape_op(mask), output_type))
-                        irfft_offset_size = to_tensor_op(
-                            _fft_with_size_back_norm(shape_op(dout), norm, inverse, signal_ndim),
-                            output_type)
-                        dx = dx * complex_op(irfft_offset_size, zeros_op(1, output_type))
-                    else:
-                        dx = dx * complex_op(offset_size, zeros_op(1, output_type))
-                else:
-                    dx = dx * complex_op(offset_size, zeros_op(1, output_type))
+                dx = reverse_branch(dx, onesided, dout_shape, offset_shape,
+                                    output_type, dout, norm, inverse, signal_ndim, offset_size)
         return (dx,)
 
     return bprop
@@ -1017,3 +803,22 @@ def get_bprop_tensor_add(self):
         return binop_grad_common(x, y, dout, dout)
 
     return bprop
+
+
+@bprop_getters.register(_MirrorSilentCheck)
+def get_bprop_mirror_silent_check(self):
+    """Grad definition for '_MirrorSilentCheck' op"""
+    silent_check = SilentCheck(self.min_steps, self.thresh_l1, self.coeff_l1, self.thresh_l2, self.coeff_l2)
+    out_tensor = Tensor([0.0], mstype.float32)
+
+    def bporp(x, pre_val, min_val, max_val, n_step, loss_scale, out, dout):
+        if dout.dtype == mstype.float16:
+            return (dout, out_tensor, out_tensor, out_tensor, out_tensor, out_tensor)
+        if loss_scale is not None:
+            gnorm = ops.norm(dout / loss_scale)
+        else:
+            gnorm = ops.norm(dout)
+        dx, _, _, _, _ = silent_check(gnorm, dout, pre_val, min_val, max_val, n_step)
+        return (dx, out_tensor, out_tensor, out_tensor, out_tensor, out_tensor)
+
+    return bporp

mindspore/ops/_grad_experimental/grad_nn_ops.py

@@ -31,12 +31,10 @@ from mindspore.ops.operations.nn_ops import FractionalMaxPool3DWithFixedKsize
 from mindspore.ops.operations._grad_ops import FractionalMaxPool3DGradWithFixedKsize
 from mindspore.ops.operations.nn_ops import AvgPoolV1
 from mindspore.ops.operations._grad_ops import AvgPoolGradV1
-from mindspore.ops.operations.nn_ops import MaxPoolWithArgmaxV2
 from mindspore.ops.operations.nn_ops import FractionalMaxPoolWithFixedKsize
 from mindspore.ops.operations._grad_ops import FractionalMaxPoolGradWithFixedKsize
 from mindspore.ops.operations.nn_ops import WKV
 from mindspore.ops.operations._grad_ops import WKVGrad
-from mindspore.ops.operations.nn_ops import GLU
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool3D
 from mindspore.ops.operations._sequence_ops import TupleToTensor
 from mindspore.ops.operations import _rl_inner_ops as rl_ops
@@ -111,36 +109,6 @@ def get_bprop_avg_pool_v1_grad(self):
     return bprop
 
 
-@bprop_getters.register(GLU)
-def get_bprop_glu(self):
-    """Grad definition for `Glu` operation."""
-    input_grad = G.GluGrad(self.axis)
-
-    def bprop(x, out, dout):
-        dx = input_grad(dout, x)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(MaxPoolWithArgmaxV2)
-def get_bprop_maxpoolwithargmaxv2(self):
-    """Grad definition for `MaxPoolWithArgmaxV2` operation."""
-    maxpoolwithargmaxv2_grad = G.MaxPoolGradWithArgmaxV2(
-        kernel_size=self.kernel_size,
-        strides=self.strides,
-        pads=self.pads,
-        dilation=self.dilation,
-        ceil_mode=self.ceil_mode,
-        argmax_type=self.argmax_type)
-
-    def bprop(x, out, dout):
-        dx = maxpoolwithargmaxv2_grad(x, dout[0], out[1])
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(FractionalMaxPoolWithFixedKsize)
 def get_bprop_fractional_max_pool_with_fixed_ksize(self):
     """Grad definition for 'FractionalMaxPoolWithFixedKsize' operation."""
@@ -193,27 +161,6 @@ def get_bprop_sparse_softmax_cross_entropy_with_logits(self):
     return bprop
 
 
-@bprop_getters.register(rl_ops.GRUV2)
-def get_bprop_gru_v2(self):
-    """Grad definition for `GRUV2` operation."""
-    gru_grad_v2 = G.GRUV2Grad(
-        self.input_size,
-        self.hidden_size,
-        self.num_layers,
-        self.has_bias,
-        self.bidirectional,
-        self.dropout
-    )
-
-    def bprop(x, hx, w, seq_length, out, dout):
-        y, hy, reverse, _ = out
-        dy, dhy, _, _ = dout
-        dx, dhx, dw = gru_grad_v2(x, hx, w, seq_length, y, hy, dy, dhy, reverse)
-        return tuple((dx, dhx, dw, (0)))
-
-    return bprop
-
-
 @bprop_getters.register(rl_ops.CudnnGRU)
 def get_bprop_gru(self):
     """Grad definition for `GRU` operation."""

mindspore/ops/_grad_experimental/grad_quant_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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,7 +15,7 @@
 
 """Generate bprop for quantization aware ops"""
 
-from mindspore.ops import operations as P
+from mindspore.ops.deprecated import BNTrainingReduce
 from mindspore.ops.operations import _quant_ops as Q
 from mindspore.ops._grad_experimental.grad_base import bprop_getters
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
@@ -139,7 +139,7 @@ def get_bprop_batchnormfold(self):
     return bprop
 
 
-@bprop_getters.register(P.BNTrainingReduce)
+@bprop_getters.register(BNTrainingReduce)
 def get_bprop_bn_training_reduce(self):
     """Generate bprop for BNTrainingReduce for Ascend"""
 

mindspore/ops/_grad_experimental/grad_sparse.py

@@ -284,7 +284,7 @@ def get_bprop_csr_div(self):
             csr_tensor_grad_value = P.ReduceSum(True)(csr_tensor_grad.values, reduce_x)
         else:
             csr_tensor_grad_value = csr_tensor_grad.values
-        dense_grad_value = F.neg_tensor(F.mul(out, csr_tensor_grad_value))
+        dense_grad_value = F.neg(F.mul(out, csr_tensor_grad_value))
         dense_grad = F.make_csr_tensor(indptr, indices, dense_grad_value, shape)
         if len(dense.shape) == 1 or dense.shape[0] == 1:
             raise ValueError(

mindspore/ops/_grad_experimental/grad_sparse_ops.py

@@ -358,10 +358,10 @@ def get_bprop_ragged_tensor_to_sparse(self):
                 split.append(zeros_like(i))
             all_d = (split, ragged_values_grad)
             return all_d
-        split_ = ()
+        split = ()
         for i in enumerate(rt_nested_splits):
-            split_ = split_ + (zeros_like(i),)
-        all_d = (split_, ragged_values_grad)
+            split = split + (zeros_like(i),)
+        all_d = (split, ragged_values_grad)
         return all_d
 
     return bprop

mindspore/ops/_op_impl/__init__.py

@@ -19,6 +19,5 @@ from mindspore.ops._op_impl.aicpu import *
 from mindspore.ops._op_impl.cpu import *
 if "Windows" not in platform.system():
     from mindspore.ops._op_impl.akg import *
-    from mindspore.ops._op_impl.tbe import *
 
 __all__ = []

mindspore/ops/_op_impl/aicpu/__init__.py

@@ -60,6 +60,7 @@ from .init_data_set_queue import _init_data_set_queue_aicpu
 from .embedding_lookup import _embedding_lookup_aicpu
 from .padding import _padding_aicpu
 from .gather import _gather_aicpu
+from .generate_eod_mask import _generate_eod_mask_aicpu
 from .gather_grad import _gather_grad_aicpu
 from .gather_d_grad_v2 import _gather_d_grad_v2_aicpu
 from .gather_d import _gather_d_aicpu

mindspore/ops/_op_impl/aicpu/gamma.py

@@ -28,6 +28,8 @@ gamma_op_info = AiCPURegOp("Gamma") \
     .attr("seed2", "int") \
     .dtype_format(DataType.I32_Default, DataType.F32_Default, DataType.F32_Default, DataType.I64_Default,
                   DataType.I64_Default, DataType.F32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.F32_Default, DataType.F32_Default, DataType.I64_Default,
+                  DataType.I64_Default, DataType.F32_Default) \
     .get_op_info()
 
 @op_info_register(gamma_op_info)