mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -18,17 +18,9 @@
 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, SilentCheck
-from mindspore.ops.operations._inner_ops import _MirrorSilentCheck
-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 CumulativeLogsumexp
 from mindspore.ops.operations.math_ops import MatrixSolve
 from mindspore.ops.operations.math_ops import MatrixSolveLs
@@ -37,11 +29,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
@@ -137,7 +126,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:
@@ -158,14 +147,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)
@@ -221,7 +210,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
 
 
@@ -285,7 +274,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)
@@ -380,131 +369,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"""
@@ -549,94 +413,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"""
@@ -646,24 +422,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_
 
 
@@ -673,9 +462,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_
 
@@ -737,30 +526,6 @@ 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()
@@ -779,7 +544,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)
@@ -866,18 +655,8 @@ def get_bprop_fft_with_size(self):
                     dx = irfft_fn(dout) * real_op(offset_size)
             else:
                 dx = rfft_fn(dout)
-                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))
+                dx = reverse_branch(dx, onesided, dout_shape, offset_shape,
+                                    output_type, dout, norm, inverse, signal_ndim, offset_size)
         return (dx,)
 
     return bprop
@@ -1021,19 +800,3 @@ 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 loss_scale is not None:
-            dout = dout / loss_scale
-        grad = ops.norm(dout)
-        dx, _, _, _, _ = silent_check(grad, 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/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)

mindspore/ops/_op_impl/aicpu/generate_eod_mask.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# Copyright 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.

mindspore/ops/_op_impl/aicpu/log_uniform_candidate_sampler.py

@@ -18,8 +18,6 @@ from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataTyp
 log_uniform_candidate_sampler_op_info = AiCPURegOp("LogUniformCandidateSampler") \
     .fusion_type("OPAQUE") \
     .input(0, "true_classes", "required") \
-    .input(1, "counts", "required") \
-    .input(2, "states", "required") \
     .output(0, "sampled_candidates", "required") \
     .output(1, "true_expected_count", "required") \
     .output(2, "sampled_expected_count", "required") \
@@ -28,7 +26,7 @@ log_uniform_candidate_sampler_op_info = AiCPURegOp("LogUniformCandidateSampler")
     .attr("unique", "bool") \
     .attr("range_max", "int") \
     .attr("seed", "int") \
-    .dtype_format(DataType.I64_Default, DataType.U64_Default, DataType.U64_Default, DataType.I64_Default,
+    .dtype_format(DataType.I64_Default, DataType.I64_Default,
                   DataType.F32_Default, DataType.F32_Default) \
     .get_op_info()
 

mindspore/ops/_op_impl/aicpu/poisson.py

@@ -27,6 +27,8 @@ poisson_op_info = AiCPURegOp("Poisson") \
     .attr("seed2", "int") \
     .dtype_format(DataType.I32_Default, DataType.F32_Default, DataType.I64_Default, DataType.I64_Default,
                   DataType.I32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.F32_Default, DataType.I64_Default, DataType.I64_Default,
+                  DataType.I32_Default) \
     .get_op_info()
 
 @op_info_register(poisson_op_info)

mindspore/ops/_op_impl/cpu/__init__.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.
@@ -19,7 +19,6 @@ from .sub import _sub_cpu
 from .pow import _pow_cpu
 from .real_div import _real_div_cpu
 from .div import _div_cpu
-from .concat import _concat_cpu
 from .concat_offset import _concat_offset_cpu
 from .dynamic_shape import _dynamic_shape_cpu
 from .dynamic_stitch import _dynamic_stitch_cpu
@@ -32,7 +31,6 @@ from .arg_max_with_value import _arg_max_with_value_cpu
 from .dropout import _dropout_cpu
 from .dropout_grad import _dropout_grad_cpu
 from .gather_d import _gather_cpu
-from .tensor_shape import _tensor_shape_cpu
 from .gather_d_grad import _gather_d_grad_cpu
 from .gather_d_grad_v2 import _gather_d_grad_v2_cpu
 from .gather_v2 import _gather_v2_cpu

mindspore/ops/_op_impl/cpu/adam.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-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.
@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 
-"""Concat op"""
+"""Adam op"""
 from mindspore.ops.op_info_register import op_info_register, CpuRegOp, DataType
 
 adam_op_info = CpuRegOp("Adam") \