mindspore 2.2.11__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/numpy/math_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2021 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.
@@ -295,7 +295,7 @@ def add(x1, x2, dtype=None):
     # broadcast is not fully supported in tensor_add on CPU,
     # so we use tensor_sub as a substitute solution
     if _get_device() == 'CPU':
-        return subtract(x1, F.neg_tensor(_to_tensor(x2)), dtype=dtype)
+        return subtract(x1, F.neg(_to_tensor(x2)), dtype=dtype)
     return _apply_tensor_op(F.tensor_add, x1, x2, dtype=dtype)
 
 
@@ -1552,7 +1552,7 @@ def hypot(x1, x2, dtype=None):
         if _get_device() == 'CPU':
             # broadcast is not fully supported in tensor_add on CPU,
             # so we use tensor_sub as a substitute solution
-            return F.sqrt(F.tensor_sub(F.square(x1), F.neg_tensor(F.square(x2))))
+            return F.sqrt(F.tensor_sub(F.square(x1), F.neg(F.square(x2))))
         return F.sqrt(F.tensor_add(F.square(x1), F.square(x2)))
 
     return _apply_tensor_op(_hypot, x1, x2, dtype=dtype)
@@ -1716,7 +1716,7 @@ def fix(x):
         x = F.cast(x, mstype.float32)
     floored = F.floor(x)
     # change to F.ceil once supported on CPU.
-    ceiled = F.neg_tensor(F.floor(F.neg_tensor(x)))
+    ceiled = F.neg(F.floor(F.neg(x)))
     is_neg = F.tensor_lt(x, zeros(F.shape(x), F.dtype(x)))
     return F.select(is_neg, ceiled, floored)
 
@@ -2997,11 +2997,11 @@ def cross(a, b, axisa=- 1, axisb=- 1, axisc=- 1, axis=None):
         cx = F.tensor_sub(_get_slice_product(1, 2), _get_slice_product(2, 1)) # ay*bz - az*by
         cy = F.tensor_sub(_get_slice_product(2, 0), _get_slice_product(0, 2)) # az*bx - ax*bz
     elif a_has_z:
-        cx = F.neg_tensor(_get_slice_product(2, 1)) # -az*by
+        cx = F.neg(_get_slice_product(2, 1)) # -az*by
         cy = _get_slice_product(2, 0)               # az*bx
     else: # b_has_z
         cx = _get_slice_product(1, 2)               # ay*bz
-        cy = F.neg_tensor(_get_slice_product(0, 2)) # -ax*bz
+        cy = F.neg(_get_slice_product(0, 2)) # -ax*bz
     res = _concat((cx, cy, cz)).reshape(shape_out)
     return moveaxis(res, -1, axisc).astype(dtype)
 
@@ -3035,7 +3035,7 @@ def ceil(x, dtype=None):
         >>> print(output)
         [-1. -1. -0.  1.  2.  2.  2.]
     """
-    return _apply_tensor_op(lambda x: F.neg_tensor(F.floor(F.neg_tensor(x.astype(mstype.float32)))),
+    return _apply_tensor_op(lambda x: F.neg(F.floor(F.neg(x.astype(mstype.float32)))),
                             x, dtype=dtype)
 
 
@@ -3080,8 +3080,8 @@ def positive(a, dtype=None):
         [1. -1.]
     """
     _check_input_tensor(a)
-    neg_tensor = F.neg_tensor(a)
-    return _apply_tensor_op(F.neg_tensor, neg_tensor, dtype=dtype)
+    neg_tensor = F.neg(a)
+    return _apply_tensor_op(F.neg, neg_tensor, dtype=dtype)
 
 
 def negative(a, dtype=None):
@@ -3110,7 +3110,7 @@ def negative(a, dtype=None):
         >>> print(output)
         [-1. 1.]
     """
-    return _apply_tensor_op(F.neg_tensor, a, dtype=dtype)
+    return _apply_tensor_op(F.neg, a, dtype=dtype)
 
 
 def cumsum(a, axis=None, dtype=None):
@@ -3271,12 +3271,7 @@ def log1p(x, dtype=None):
 
 def logaddexp(x1, x2, dtype=None):
     """
-    Logarithm of the sum of exponentiations of the inputs.
-
-    Calculates ``log(exp(x1) + exp(x2))``. This function is useful in statistics where the
-    calculated probabilities of events may be so small as to exceed the range of normal
-    floating point numbers. In such cases the logarithm of the calculated probability is
-    stored. This function allows adding probabilities stored in such a fashion.
+    Logarithm of the sum of exponentiations of the inputs. Calculates ``log(exp(x1) + exp(x2))``.
 
     Note:
         Numpy arguments `out`, `where`, `casting`, `order`, `subok`, `signature`, and `extobj` are
@@ -4171,18 +4166,18 @@ def multi_dot(arrays):
     Examples:
         >>> import mindspore.numpy as np
         >>> A = np.ones((10000, 100))
-        >>> B = np.ones((100, 1000))
-        >>> C = np.ones((1000, 5))
+        >>> B = np.ones((100, 100))
+        >>> C = np.ones((100, 5))
         >>> D = np.ones((5, 333))
         >>> output = np.multi_dot([A, B, C, D])
         >>> print(output)
-        [[500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
+        [[50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
         ...
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]]
     """
     if len(arrays) < 2:
         _raise_value_error('Expecting at least 2 arrays')
@@ -4554,7 +4549,7 @@ def copysign(x1, x2, dtype=None):
     else:
         pos_tensor = F.absolute(x1)
 
-    neg_tensor = F.neg_tensor(pos_tensor)
+    neg_tensor = F.neg(pos_tensor)
     less_zero = F.less(x2, 0)
     res = F.select(less_zero, neg_tensor, pos_tensor)
 
@@ -5118,7 +5113,7 @@ def polysub(a1, a2):
         >>> print(np.polysub([2, 10, -2], [3, 10, -4]))
         [-1  0  2]
     """
-    return polyadd(a1, F.neg_tensor(_to_tensor(a2)))
+    return polyadd(a1, F.neg(_to_tensor(a2)))
 
 
 def polyval(p, x):
@@ -5370,9 +5365,9 @@ def unwrap(p, discont=3.141592653589793, axis=-1):
     axis = _check_axis_in_range(axis, ndim)
     dd = diff(p, axis=axis)
     ddmod = remainder(add(dd, pi), 2*pi) - pi
-    ddmod = F.masked_fill(ddmod, F.logical_and(ddmod == -pi, dd > 0), pi)
+    ddmod = F.masked_fill(ddmod, F.logical_and(ddmod == -pi, dd > 0), F.cast(pi, ddmod.dtype))
     ph_correct = ddmod - dd
-    ph_correct = F.masked_fill(ph_correct, absolute(dd) < discont, 0)
+    ph_correct = F.masked_fill(ph_correct, absolute(dd) < discont, F.cast(0, ph_correct.dtype))
     slice_all = _list_comprehensions(F.rank(p), F.make_slice(None, None, None), True)
     slice0 = _tuple_setitem(slice_all, axis, F.make_slice(0, 1, None))
     slice1 = _tuple_setitem(slice_all, axis, F.make_slice(1, None, None))
@@ -5800,72 +5795,71 @@ def rint(x, dtype=None):
 
 
 def correlate(a, v, mode='valid'):
-    """
+    r"""
     Cross-correlation of two 1-dimensional sequences.
 
     This function computes the correlation as generally defined in signal processing texts:
 
-    :math:`c_{av}[k] = sum_n a[n+k] * conj(v[n])`
+    :math:`c_{av}[k] = \sum_{n}{a[n+k] * conj(v[n])}`
 
     with `a` and `v` sequences being zero-padded where necessary and conj being the conjugate.
 
     Note:
-        Currently, complex numbers are not supported.
+        - `correlate` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `correlate` is not supported on Windows platform yet.
 
     Args:
         a (Union[list, tuple, Tensor]): First input sequence.
         v (Union[list, tuple, Tensor]): Second input sequence.
-        mode (str, optional): By default, mode is `\'valid\'`.
-            If `mode` is `\'valid\'`, it returns output of length :math:`max(M, N) - min(M, N) + 1`.
-            The convolution product is only given for points where the signals overlap
-            completely. Values outside the signal boundary have no effect.
-            If `mode` is `\'full\'`, it returns the convolution at each point of overlap, with
-            an output shape of :math:`(N + M - 1,)`.
-            At the end-points of the convolution, the signals do not overlap completely,
-            and boundary effects may be seen.
-            If `mode` is `\'same\'`, it returns output of length :math:`max(M, N)`. Boundary
-            effects are still visible.
+        mode (str, optional): Specifies padding mode. The optional values are
+            ``"same"`` , ``"valid"`` and ``"full"`` . Default: ``"valid"`` .
+
+            - ``"same"``: it returns output of length :math:`max(M, N)`. Boundary
+              effects are still visible.
+
+            - ``"valid"``: it returns output of length :math:`max(M, N) - min(M, N) + 1`.
+              The convolution product is only given for points where the signals overlap
+              completely. Values outside the signal boundary have no effect.
+
+            - ``"full"``: it returns the convolution at each point of overlap, with
+              an output shape of :math:`(N + M - 1,)`.At the end-points of the convolution,
+              the signals do not overlap completely, and boundary effects may be seen.
 
     Returns:
-        Tensor. Discrete cross-correlation of `a` and `v`.
+        Tensor, Discrete cross-correlation of `a` and `v`.
 
     Raises:
-        TypeError: If the inputs can not be converted to tensor.
+        TypeError: If `a` or `v` is not a tensor.
+        TypeError: If `a` and `v` is of different dtype.
         ValueError: If `a` and `v` are empty or have wrong dimensions
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.numpy as np
-        >>> output = np.correlate([1, 2, 3], [0, 1, 0.5])
+        >>> import mindspore.numpy as mnp
+        >>> from mindspore import Tensor
+        >>> output = mnp.correlate(Tensor([1., 2., 3.]), Tensor([0., 1., 0.5]))
         >>> print(output)
         [3.5]
-        >>> output = np.correlate([1, 2, 3], [0, 1, 0.5], mode="same")
+        >>> output = mnp.correlate(Tensor([1., 2., 3.]), Tensor([0., 1., 0.5]), mode="same")
         >>> print(output)
         [2.  3.5 3. ]
-        >>> output = np.correlate([1, 2, 3, 4, 5], [1, 2], mode="same")
+        >>> output = mnp.correlate(Tensor([1., 2., 3., 4., 5.]), Tensor([1., 2.]), mode="full")
         >>> print(output)
-        [ 2.  5.  8. 11. 14.]
-    """
-    a, v = _to_tensor(a, v)
-    if a.ndim != 1 or v.ndim != 1:
-        _raise_value_error("only support 1-dimensional inputs.")
-    if a.size == 0 or v.size == 0:
-        _raise_value_error("Inputs cannot be empty.")
+        [ 2.  5.  8. 11. 14.  5.]
+    """
+    if isinstance(a, list):
+        a = ops.auto_generate.list_to_tuple(a)
+    if isinstance(a, tuple):
+        a = ops.auto_generate.tuple_to_tensor(a)
+    if isinstance(v, list):
+        v = ops.auto_generate.list_to_tuple(v)
+    if isinstance(v, tuple):
+        v = ops.auto_generate.tuple_to_tensor(v)
+    return ops.auto_generate.correlate(a, v, mode)
 
-    promote_dtype = _promote(a.dtype, v.dtype)
-    # P.Conv2D requires that the two tensors have the same data type.
-    # If the promote data type is not supported, it will be converted to float32.
-    # The supported dtype list may vary in the future.
-    if promote_dtype not in [mstype.float32, mstype.float16]:
-        promote_dtype = mstype.float32
-    a = a.astype(promote_dtype)
-    v = v.astype(promote_dtype)
-    if a.size < v.size:
-        a, v = v, a
-        return _compute_1d_conv(a, v, mode)[::-1]
-    return _compute_1d_conv(a, v, mode)
 
 
 def _compute_1d_conv(a, v, mode):

mindspore/numpy/utils.py

@@ -18,6 +18,7 @@ from __future__ import absolute_import
 import types
 
 from mindspore.common import Tensor
+from mindspore._c_expression import Tensor as Tensor_
 from mindspore.ops import functional as F
 from mindspore.common import dtype as mstype
 
@@ -127,6 +128,8 @@ def _to_tensor(*args):
     res = ()
     for arg in args:
         if isinstance(arg, (int, float, bool, list, tuple)):
+            if isinstance(arg, (list, tuple)) and not arg:
+                arg = Tensor_(arg)
             arg = _convert_64_to_32(_type_convert(Tensor, arg))
         elif not isinstance(arg, Tensor):
             _raise_type_error("Expect input to be array like.")

mindspore/ops/__init__.py

@@ -23,28 +23,32 @@ Examples:
 from __future__ import absolute_import
 
 from mindspore.common import Tensor
-from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register
+from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register, \
+    prim_arg_register
 from mindspore.ops.vm_impl_registry import get_vm_impl_fn, vm_impl_registry
 from mindspore.ops.op_info_register import op_info_register, custom_info_register, AkgGpuRegOp, AkgAscendRegOp, \
     AiCPURegOp, TBERegOp, CpuRegOp, CustomRegOp, DataType
 from mindspore.ops.primitive import constexpr
-from mindspore.ops import composite, operations, functional, function
+from mindspore.ops import composite, operations, functional, function, auto_generate, extend
 from mindspore.ops import signature
 from mindspore.ops.composite import *
 from mindspore.ops.operations import *
 from mindspore.ops.function import *
 from mindspore.ops.functional import *
+from mindspore.ops.silent_check import _silent_check
 
 __primitive__ = [
-    "prim_attr_register", "Primitive", "PrimitiveWithInfer", "PrimitiveWithCheck", "signature"
+    "prim_attr_register", "prim_arg_register", "Primitive", "PrimitiveWithInfer", "PrimitiveWithCheck", "signature"
 ]
 
 __all__ = ["get_vm_impl_fn", "vm_impl_registry",
            "op_info_register", "custom_info_register", "AkgGpuRegOp", "AkgAscendRegOp", "AiCPURegOp", "TBERegOp",
            "CpuRegOp", "CustomRegOp", "DataType",
-           "constexpr"]
+           "constexpr", "reshard"]
 __all__.extend(__primitive__)
 __all__.extend(composite.__all__)
 __all__.extend(operations.__all__)
 __all__.extend(functional.__all__)
 __all__.extend(function.__all__)
+__all__.extend(auto_generate.__all__)
+_silent_check()

mindspore/ops/_grad_experimental/grad_array_ops.py

@@ -36,8 +36,6 @@ from mindspore.ops.operations.array_ops import ScatterAddWithAxis
 from mindspore.ops.operations.array_ops import Expand
 from mindspore.ops.operations.array_ops import SegmentMean
 from mindspore.ops.operations.array_ops import AffineGrid
-from mindspore.ops.operations.array_ops import Im2Col
-from mindspore.ops.operations.array_ops import Col2Im
 from mindspore.ops.operations.array_ops import MaskedScatter
 from mindspore.ops.operations.array_ops import MaskedSelect
 from mindspore.ops.operations.array_ops import CountNonZero
@@ -203,7 +201,7 @@ def get_bprop_index_put(self):
         if is_ascend:
             indices_ms = [convert_idx_positive(indices_ms[i], x1.shape[i]) for i in range(len(indices_ms))]
         indices_me = stack(indices_ms)
-        indices_grad = F.transpose(indices_me, F.make_range(F.rank(indices_me) - 1, -1, -1))
+        indices_grad = F.transpose(indices_me, F.make_range(F.rank(indices_me)-1, -1, -1))
         values_grad = gather_nd(dout, indices_grad)
         if equal(cast(x2.shape[0], mstype.int32), Tensor(1)):
             values_grad = values_grad.sum().reshape(1)
@@ -360,128 +358,6 @@ def get_bprop_resize_nearest_neighbor_v2(self):
     return bprop
 
 
-@bprop_getters.register(Im2Col)
-def get_bprop_im2col(self):
-    """
-    Generate bprop for Im2Col
-
-    Im2Col, corresponding to torch's UnFold operator.
-    The Unfold operator has no `padding_mode` attribute,
-    and it's implementation corresponds to the mindspore
-    implementation with `padding_mode=CALCULATED` .
-    So, currently the bprop function of Im2Col only supports
-    the CALCULATED mode.
-    """
-    kernel_size = self.ksizes
-    dilation = self.dilations
-    stride = self.strides
-    padding = (self.pads[0], self.pads[-1])
-    col2im = Col2Im(kernel_size=kernel_size,
-                    dilation=dilation,
-                    stride=stride,
-                    padding=padding)
-
-    def bprop(x, out, dout):
-        x_shape = P.TensorShape()(x)[2:]
-        dx = col2im(dout, x_shape)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register(P.ExtractVolumePatches)
-def get_bprop_extract_volume_patches(self):
-    """Generate bprop for ExtractVolumePatches"""
-    extract_volume_patches = P.ExtractVolumePatches(kernel_size=self.kernel_size,
-                                                    strides=self.strides, padding=self.padding)
-    concat = P.Concat(axis=-1)
-    expend_dims = P.ExpandDims()
-    scatter_nd = P.ScatterNd()
-    slice_op = P.Slice()
-    dtype = P.DType()
-    cast = P.Cast()
-    matmul = P.MatMul()
-    _, _, ksize_d, ksize_h, ksize_w = self.kernel_size
-    range_ = P.Range()
-    ones_like = P.OnesLike()
-
-    def _dyn_extract_volume_patches(x, out, dout):
-        x_shape = shape_op(x)
-        out_shape = shape_op(out)
-        x_n, x_c, x_d, x_h, x_w = x_shape[0], x_shape[1], x_shape[2], x_shape[3], x_shape[4]
-        x_indices_num = 1 + x_d * x_h * x_w
-        x_idx = range_(cast(1, mstype.float32), cast(x_indices_num, mstype.float32), cast(1, mstype.float32))
-        x_idx = cast(x_idx, mstype.float16)
-        x_idx = P.Reshape()(x_idx, create_tensor_by_element((1, 1, x_d, x_h, x_w)))
-        x_idx_patched = extract_volume_patches(x_idx)
-        x_idx_patched = P.Transpose()(x_idx_patched, (0, 2, 3, 4, 1))
-        x_idx_patched = cast(x_idx_patched, mstype.int32)
-
-        out_d, out_h, out_w = out_shape[2], out_shape[3], out_shape[4]
-        out_indices_num = out_d * out_h * out_w * ksize_d * ksize_h * ksize_w
-        out_idx_ori = range_(cast(0, mstype.int32), cast(out_indices_num, mstype.int32), cast(1, mstype.int32))
-        out_idx = P.Reshape()(out_idx_ori,
-                              create_tensor_by_element((1, out_d, out_h, out_w, ksize_d * ksize_h * ksize_w)))
-
-        idx_tensor = concat((expend_dims(x_idx_patched, -1), expend_dims(out_idx, -1)))
-        idx_map = P.Reshape()(idx_tensor, (-1, 2))
-        sp_shape = create_tensor_by_element((x_indices_num, out_indices_num))
-        update = cast(ones_like(out_idx_ori), dtype(dout))
-        sp_mat_full = scatter_nd(idx_map, update, sp_shape)
-        begin = create_tensor_by_element((1, 0))
-        size = create_tensor_by_element((x_indices_num - 1, out_indices_num))
-        sp_tensor = slice_op(sp_mat_full, begin, size)
-
-        grad = P.Transpose()(dout, (0, 2, 3, 4, 1))
-        grad = P.Reshape()(grad, create_tensor_by_element((x_n, out_d, out_h, out_w, ksize_d,
-                                                           ksize_h, ksize_w, x_c)))
-        grad_expended = P.Transpose()(grad, (1, 2, 3, 4, 5, 6, 0, 7))
-        grad_flat = P.Reshape()(grad_expended,
-                                create_tensor_by_element((out_d * out_h * out_w * ksize_d * ksize_h * ksize_w,
-                                                          x_n * x_c)))
-        jac = matmul(sp_tensor, grad_flat)
-        dx = P.Reshape()(jac, create_tensor_by_element((x_d, x_h, x_w, x_n, x_c)))
-        dx = P.Transpose()(dx, (3, 4, 0, 1, 2))
-        return (dx,)
-
-    def bprop(x, out, dout):
-        x_shape = P.Shape()(x)
-        out_shape = P.Shape()(out)
-        if F.is_sequence_value_unknown(x_shape) or F.is_sequence_value_unknown(out_shape):
-            return _dyn_extract_volume_patches(x, out, dout)
-        x_n, x_c, x_d, x_h, x_w = x_shape
-        x_indices_num = 1 + x_d * x_h * x_w
-        x_idx = cast(F.tuple_to_array(range(1, x_indices_num)), mstype.float16)
-        x_idx = P.Reshape()(x_idx, (1, 1, x_d, x_h, x_w))
-        x_idx_patched = extract_volume_patches(x_idx)
-        x_idx_patched = P.Transpose()(x_idx_patched, (0, 2, 3, 4, 1))
-        x_idx_patched = cast(x_idx_patched, mstype.int32)
-
-        _, _, out_d, out_h, out_w = out_shape
-        out_indices_num = out_d * out_h * out_w * ksize_d * ksize_h * ksize_w
-        out_idx = F.tuple_to_array(range(0, out_indices_num))
-        out_idx = P.Reshape()(out_idx, (1, out_d, out_h, out_w, ksize_d * ksize_h * ksize_w))
-
-        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, 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))
-        grad = P.Reshape()(grad, (x_n, out_d, out_h, out_w, ksize_d,
-                                  ksize_h, ksize_w, x_c))
-        grad_expended = P.Transpose()(grad, (1, 2, 3, 4, 5, 6, 0, 7))
-        grad_flat = P.Reshape()(grad_expended, (-1, x_n * x_c))
-
-        jac = matmul(sp_tensor, grad_flat)
-        dx = P.Reshape()(jac, (x_d, x_h, x_w, x_n, x_c))
-        dx = P.Transpose()(dx, (3, 4, 0, 1, 2))
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(SegmentSum)
 def get_bprop_segment_sum(self):
     """Generate bprop for SegmentSum"""
@@ -815,26 +691,6 @@ def get_bprop_segment_mean(self):
     return bprop
 
 
-@bprop_getters.register(P.Ones)
-def get_bprop_ones(self):
-    """Generate bprop for Ones"""
-
-    def bprop(dims, dtype, out, dout):
-        return zeros_like(dims)
-
-    return bprop
-
-
-@bprop_getters.register(P.Zeros)
-def get_bprop_zeros(self):
-    """Generate bprop for Zeros"""
-
-    def bprop(dims, dtype, out, dout):
-        return zeros_like(dims)
-
-    return bprop
-
-
 @bprop_getters.register(P.EmbeddingLookup)
 def get_bprop_embedding_lookup(self):
     """Generate bprop for EmbeddingLookup"""
@@ -847,14 +703,14 @@ def get_bprop_embedding_lookup(self):
             raise RuntimeError("Now, EmbeddingLookup op's grad don't support Dynamic Sense!")
         new_indices = sub_op(indices, offset)
         indices_size = size_op(new_indices)
+        x_shp_tail = x_shp[1:]
         if indices_size > 0:
             # Reshape the 'new_indices'
             new_indices_shape_changed = (indices_size,)
             new_indices = reshape_op(new_indices, new_indices_shape_changed)
+            actual_dout_shape_changed = new_indices_shape_changed + x_shp_tail
         else:
-            new_indices_shape_changed = ()
-        x_shp_tail = x_shp[1:]
-        actual_dout_shape_changed = new_indices_shape_changed + x_shp_tail
+            actual_dout_shape_changed = x_shp_tail
         # Reshape the 'actual_dout' on device
         actual_dout = reshape_op(dout, actual_dout_shape_changed)
         return RowTensorInner(new_indices, actual_dout, x_shp), zeros_like(indices), zeros_like(offset)
@@ -962,18 +818,6 @@ def get_bprop_scatter_update(self):
     return bprop
 
 
-@bprop_getters.register(P.TransShape)
-def get_bprop_trans_shape(self):
-    """Generate bprop for TransShape"""
-    op = P.TransShape()
-
-    def bprop(x, shape, out, dout):
-        dx = op(dout, shape_op(x))
-        return (dx, zeros_like(shape))
-
-    return bprop
-
-
 @bprop_getters.register(P.Unique)
 def get_bprop_unique(self):
     """Generate bprop for Unique"""