mindspore 2.7.0rc1__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/ops/function/debug_func.py

@@ -28,8 +28,7 @@ def print_(*input_x):
     Outputs the inputs to stdout.
     The outputs are printed to screen by default.
     It can also be saved in a file by setting the parameter  `print_file_path` in `context`.
-    :func:`mindspore.parse_print` can be employed to reload the data.
-    For more information, please refer to :func:`mindspore.set_context` and :func:`mindspore.parse_print`.
+    For more information, please refer to :func:`mindspore.set_context`.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
     can be set to solve operator execution failure when outputting big tensor or outputting tensor intensively.
 
@@ -124,6 +123,7 @@ def tensordump(file_name, tensor, mode='out'):
             --master_port=11450 --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
 
         >>> import os
+        >>> import time
         >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import nn, context
@@ -150,18 +150,19 @@ def tensordump(file_name, tensor, mode='out'):
         >>> strategy1 = ((1, 2), (2, 1))
         >>> strategy2 = ((1, 2), (2, 1))
         >>> with no_init_parameters():
-        >>>     net = Net(strategy1, strategy2)
+        ...     net = Net(strategy1, strategy2)
         >>> x = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> y = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
         >>> b = mindspore.tensor(0.1 * mindspore.ops.randn(64, 64), mindspore.float32)
-        >>> parallel_net = Autoparallel(net, parallel_mode="semi_auto")
+        >>> parallel_net = AutoParallel(net, parallel_mode="semi_auto")
         >>> parallel_net.dataset_strategy(config="full_batch")
         >>> out = parallel_net(x, y, b)
         >>> print(f"out shape is: {out.shape}")
-        >>> # out shape is (64, 64)
+        out shape is (64, 64)
+        >>> time.sleep(0.5) # npy file is generated asynchronously, spend an interval time then load it.
         >>> matmul1_output_slice = np.load(f'rank_{rank_id}_mul1_mul2_float32_0.npy')      # load matmul1's output slice
         >>> print(f"matmul1_output_slice is loaded, shape is: {matmul1_output_slice.shape}")
-        >>> # matmul1_output_slice is loaded, shape is: (64, 64)
+        matmul1_output_slice is loaded, shape is: (64, 64)
     """
 
     if not isinstance(file_name, str):

mindspore/ops/function/grad/grad_func.py

@@ -654,9 +654,7 @@ def _check_jvp_input_v_len(inputs_len, v_len):
 
 def jvp(fn, inputs, v, has_aux=False):
     """
-    Compute the jacobian-vector-product of the given network. The calculation procedure of JVP can be found in
-    `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
+    Compute the jacobian-vector-product of the given network.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -869,9 +867,7 @@ _vjp_grad_op_with_weight = _Grad(get_all=True, get_by_list=True, sens_param=True
 
 def vjp(fn, *inputs, weights=None, has_aux=False):
     """
-    Compute the vector-jacobian-product of the given network. `vjp` matches
-    `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
+    Compute the vector-jacobian-product of the given network.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -1070,9 +1066,7 @@ _vmap = _Vmap()
 
 def jacfwd(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via forward mode, corresponding to
-    `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
+    Compute Jacobian via forward mode.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
@@ -1241,9 +1235,7 @@ _grad = _Grad(get_by_position=True, has_aux=False, sens_param=True)
 
 def jacrev(fn, grad_position=0, has_aux=False):
     """
-    Compute Jacobian via reverse mode, corresponding to
-    `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
+    Compute Jacobian via reverse mode.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 

mindspore/ops/function/math_func.py

@@ -44,7 +44,7 @@ from mindspore.ops.auto_generate.pyboost_inner_prim import reduce_max_impl, redu
 from mindspore.ops.operations.math_ops import Ormqr
 from mindspore.ops.operations.math_ops import DivMod
 from mindspore.ops.auto_generate import multi_scale_deformable_attn_op
-from mindspore.ops.operations.array_ops import MatrixSetDiagV3, Transpose
+from mindspore.ops.operations.array_ops import MatrixSetDiagV3
 # 1
 from mindspore.ops.auto_generate import (minimum, maximum, mul, muls, sin, sinc, sinh, cummax, real, conj, add, sub,
                                          cos,
@@ -58,7 +58,7 @@ from mindspore.ops.auto_generate import (minimum, maximum, mul, muls, sin, sinc,
                                          xlogy_op, xlogy_scalar_other_op, xlogy_scalar_self_op, trunc, histc_ext, roll,
                                          bincount_ext, rotated_iou_op, cat, narrow, var_op, pow, inplace_erfinv_op,
                                          frac_ext, pow_tensor_scalar_op, not_equal_op, isinf, addmv_op, cdist,
-                                         addbmm_op, addmm_op, pow_scalar_tensor_op)
+                                         addbmm_op, addmm_op, pow_scalar_tensor_op, transpose_op)
 # 2
 from mindspore.ops.functional_overload import gmm
 # 3
@@ -183,7 +183,6 @@ tensor_muls = muls
 tensor_pow = P.Pow()
 pows = tensor_pow
 tensor_sub = P.Sub()
-transpose_ = P.Transpose()
 xdivy_ = P.Xdivy()
 tensor_div_ = P.Div()
 tensor_divmod_ = DivMod()
@@ -707,7 +706,7 @@ def permute(input, axis):
           [ 8. 11.]
           [ 9. 12.]]]
     """
-    return transpose_(input, axis)
+    return transpose_op(input, axis)
 
 
 def subtract(input, other, *, alpha=1):
@@ -1218,7 +1217,7 @@ def logical_not(input):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
         >>> output = mindspore.ops.logical_not(x)
         >>> print(output)
         [False  True False]
@@ -1250,23 +1249,23 @@ def logical_or(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         [ True  True  True]
-        >>> x = mindspore.tensor(1, mindspore.bool_)
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> x = mindspore.tensor(1, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool_)
+        >>> y = mindspore.tensor([True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_or(x, y)
         >>> print(output)
         [True True]
@@ -1298,23 +1297,23 @@ def logical_and(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         [ True False False]
-        >>> x = mindspore.tensor(1, mindspore.bool_)
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> x = mindspore.tensor(1, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         False
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         False
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool_)
+        >>> y = mindspore.tensor([True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_and(x, y)
         >>> print(output)
         [True False]
@@ -1595,7 +1594,7 @@ def t(input):
          [3, 4]])
     """
     if input.ndim == 2:
-        return transpose_(input, (1, 0))
+        return transpose_op(input, (1, 0))
     return input
 
 
@@ -1782,10 +1781,10 @@ def pow_ext(input, exponent):
     Args:
         input (Union[Tensor, Number]): The first input is a Number or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         exponent (Union[Tensor, Number]): The second input is a Number or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,
@@ -4215,33 +4214,33 @@ def var_mean(input, axis=None, ddof=0, keepdims=False):
          Tensor(shape=[], dtype=Float32, value= 3.16667))
         >>>
         >>> # case 2: Compute the variance and mean along axis 0.
-        >>> output = mindspore.ops.var_mean(input, axis=0)
+        >>> mindspore.ops.var_mean(input, axis=0)
         (Tensor(shape=[4], dtype=Float32, value= [ 2.88888884e+00,  6.66666687e-01,  1.55555570e+00,  2.22222194e-01]),
          Tensor(shape=[4], dtype=Float32, value= [ 3.33333325e+00,  3.00000000e+00,  3.66666675e+00,  2.66666675e+00]))
         >>>
         >>> # case 3: If keepdims=True, the output shape will be same of that of the input.
-        >>> output = mindspore.ops.var_mean(input, axis=0, keepdims=True)
+        >>> mindspore.ops.var_mean(input, axis=0, keepdims=True)
         (Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 2.88888884e+00,  6.66666687e-01,  1.55555570e+00,  2.22222194e-01]]),
          Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 3.33333325e+00,  3.00000000e+00,  3.66666675e+00,  2.66666675e+00]]))
         >>>
         >>> # case 4: If ddof=1:
-        >>> output = mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=1)
+        >>> mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=1)
         (Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 4.33333349e+00,  1.00000000e+00,  2.33333349e+00,  3.33333313e-01]]),
          Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 3.33333325e+00,  3.00000000e+00,  3.66666675e+00,  2.66666675e+00]]))
         >>>
         >>> # case 5: If ddof=True, same as ddof=1:
-        >>> output = mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=True)
+        >>> mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=True)
         (Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 4.33333349e+00,  1.00000000e+00,  2.33333349e+00,  3.33333313e-01]]),
          Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 3.33333325e+00,  3.00000000e+00,  3.66666675e+00,  2.66666675e+00]]))
         >>>
         >>> # case 6: If ddof=False, same as ddof=0:
-        >>> output = mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=False)
+        >>> mindspore.ops.var_mean(input, axis=0, keepdims=True, ddof=False)
         (Tensor(shape=[1, 4], dtype=Float32, value=
          [[ 2.88888884e+00,  6.66666687e-01,  1.55555570e+00,  2.22222194e-01]]),
          Tensor(shape=[1, 4], dtype=Float32, value=
@@ -5102,9 +5101,6 @@ def bernoulli_ext(input, *, generator=None):
     .. math::
         output_{i} \sim Bernoulli(p=input_{i})
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input tensor of Bernoulli distribution, where the i^{th} element 'input_{i}' represents the
             probability that the corresponding output element 'output_{i}' is set to '1', therefore each element in
@@ -5149,6 +5145,18 @@ def bernoulli_ext(input, *, generator=None):
     return bernoulli_ext_(input, seed, offset)
 
 
+def bernoulli_(input, p=0.5, *, generator=None):
+    r"""
+    bernoulli_(input, p=0.5, *, generator=None) -> Tensor
+
+    In-place version of :func:`mindspore.ops.bernoulli_ext`.
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_)  # pylint: disable=protected-access
+    return ops.functional_overload.bernoulli_(input, p, seed, offset)
+
+
 def bessel_i1(x):
     r"""
     Computes the first order modified Bessel function of the first kind for each element input.
@@ -5424,10 +5432,10 @@ def cummin(input, axis):
     else:
         x_shape = shape_(input)
         prem = _create_cummin_perm(axis, x_shape)
-        input = transpose_(input, prem)
+        input = transpose_op(input, prem)
         out1, out2 = cummin_op(input)
-        out1 = transpose_(out1, prem)
-        out2 = transpose_(out2, prem)
+        out1 = transpose_op(out1, prem)
+        out2 = transpose_op(out2, prem)
     return (out1, out2)
 
 
@@ -6625,7 +6633,7 @@ def amin(input, axis=None, keepdims=False, *, initial=None, where=None):
         >>> # case 4: Use "where" to include only specific elements in computing the minimum.
         >>> where = mindspore.tensor([[1, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
         >>> mindspore.ops.amin(input, axis=1, keepdims=True, initial=0, where=where)
         Tensor(shape=[3, 1], dtype=Int64, value=
          [[ 0],
@@ -6707,7 +6715,7 @@ def amax(input, axis=None, keepdims=False, *, initial=None, where=None):
         >>> # case 4: Use "where" to include only specific elements in computing the maximum.
         >>> where = mindspore.tensor([[0, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
         >>> mindspore.ops.amax(input, axis=1, keepdims=True, initial=0, where=where)
         Tensor(shape=[3, 1], dtype=Int64, value=
         [[4],
@@ -7693,9 +7701,6 @@ def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
     other `int` or `float`  -- not supported --              :math:`sum(abs(x)^{p})^{(1 / p)}`
     ====================== ================================ ==========================================
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The shape is :math:`(*)` or :math:`(*, m, n)`
             where :math:`*` means, any number of additional dimensions.
@@ -8206,6 +8211,10 @@ def kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None):
         [5.27734413e-05 2.15672745e-01 1.00000000e+00 2.15672745e-01
          5.27734413e-05]
     """
+    if not isinstance(periodic, bool):
+        raise TypeError(
+            f"For 'kaiser_window', 'periodic' must be a variable of Boolean type, but got {type(periodic)}"
+        )
     if not isinstance(window_length, int):
         raise TypeError(
             f"For 'kaiser_window', 'window_length' must be a non-negative integer, but got {type(window_length)}"
@@ -8216,10 +8225,6 @@ def kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None):
         )
     if window_length <= 1:
         return Tensor(np.ones(window_length))
-    if not isinstance(periodic, bool):
-        raise TypeError(
-            f"For 'kaiser_window', 'periodic' must be a variable of Boolean type, but got {type(periodic)}"
-        )
     if dtype is not None and dtype not in mstype.float_type:
         raise TypeError(f"For 'kaiser_window', 'dtype' must be floating point dtypes, but got {dtype}.")
     if periodic:
@@ -8311,12 +8316,9 @@ def stft(x, n_fft, hop_length=None, win_length=None, window=None, center=True,
         >>> print(output.shape)
         (2, 33, 450, 2)
     """
-    if hop_length is None:
-        hop_length = int(n_fft // 4)
-    if win_length is None:
-        win_length = int(n_fft // 1)
-    if window is None:
-        window = ops.ones(win_length, mstype.float32)
+    hop_length = int(n_fft // 4) if hop_length is None else hop_length
+    win_length = int(n_fft // 1) if win_length is None else win_length
+    window = ops.ones(win_length, mstype.float32) if window is None else window
 
     def _is_complex(x):
         return dtype_(x) in [mstype.complex64, mstype.complex128]
@@ -8421,8 +8423,10 @@ def matmul(input, other):
     Return the matrix product of two tensors.
 
     Note:
-        - The dtype of `input` and `other` must be same.
+        - `input` and `other` must have same data type, and both of them must be not scalar and support broadcast.
         - On Ascend, the rank of `input` or `other` must be between 1 and 6.
+        - `input` and `other` must not be empty tensor when executing the backward process for dynamic shape case in
+          JIT mode.
 
     Args:
         input (Tensor): The first input tensor.
@@ -8441,18 +8445,19 @@ def matmul(input, other):
         >>> other = mindspore.ops.arange(20, dtype=mindspore.float32).reshape(4, 5)
         >>> output = mindspore.ops.matmul(input, other)
         >>> print(output)
-        [[[  70,   76,   82,   88,   94],
-          [ 190,  212,  234,  256,  278],
-          [ 310,  348,  386,  424,  462]],
-         [[ 430,  484,  538,  592,  646],
-          [ 550,  620,  690,  760,  830],
-          [ 670,  756,  842,  928, 1014]]]
+        [[[  70.   76.   82.   88.   94.]
+          [ 190.  212.  234.  256.  278.]
+          [ 310.  348.  386.  424.  462.]]
+         [[ 430.  484.  538.  592.  646.]
+          [ 550.  620.  690.  760.  830.]
+          [ 670.  756.  842.  928. 1014.]]]
         >>>
         >>> # case 2 : The rank of `input` is 1.
         >>> input = mindspore.ops.ones(([1, 2]))
         >>> other = mindspore.ops.ones(([2]))
-        >>> mindspore.ops.matmul(input, other)
-        Tensor(shape=[1], dtype=Float32, value= [ 2.00000000e+00])
+        >>> output = mindspore.ops.matmul(input, other)
+        >>> print(output)
+        [2.]
     """
     return auto_generate.matmul_ext(input, other)
 
@@ -8544,14 +8549,14 @@ def bmm(input_x, mat2):
         >>> mat2 = mindspore.ops.arange(72, dtype=mindspore.float32).reshape(2, 4, 3, 3)
         >>> out = mindspore.ops.bmm(input_x, mat2)
         >>> print(out)
-        [[[[  15,   18,   21]],
-         [[ 150,  162,  174]],
-         [[ 447,  468,  489]],
-         [[ 906,  936,  966]]],
-         [[[1527, 1566, 1605]],
-         [[2310, 2358, 2406]],
-         [[3255, 3312, 3369]],
-         [[4362, 4428, 4494]]]]
+        [[[[  15.   18.   21.]]
+          [[ 150.  162.  174.]]
+          [[ 447.  468.  489.]]
+          [[ 906.  936.  966.]]]
+         [[[1527. 1566. 1605.]]
+          [[2310. 2358. 2406.]]
+          [[3255. 3312. 3369.]]
+          [[4362. 4428. 4494.]]]]
     """
     return batch_matmul_(input_x, mat2)
 
@@ -9160,10 +9165,10 @@ def remainder_ext(input, other):
         input (Union[Tensor, numbers.Number, bool]): The dividend is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
-            a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
-            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool\_.
+            a bool or a tensor whose data type is number or bool when the dividend is a tensor.
+            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool.
 
     Returns:
         Tensor, with dtype promoted and shape broadcasted.
@@ -10177,23 +10182,23 @@ def logical_xor(input, other):
 
     Examples:
         >>> import mindspore
-        >>> x = mindspore.tensor([True, False, True], mindspore.bool_)
-        >>> y = mindspore.tensor([True, True, False], mindspore.bool_)
+        >>> x = mindspore.tensor([True, False, True], mindspore.bool)
+        >>> y = mindspore.tensor([True, True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         [False  True  True]
-        >>> x = mindspore.tensor(1, mindspore.bool_)
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> x = mindspore.tensor(1, mindspore.bool)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor(0, mindspore.bool_)
+        >>> y = mindspore.tensor(0, mindspore.bool)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         True
         >>> x = True
-        >>> y = mindspore.tensor([True, False], mindspore.bool_)
+        >>> y = mindspore.tensor([True, False], mindspore.bool)
         >>> output = mindspore.ops.logical_xor(x, y)
         >>> print(output)
         [False  True]
@@ -10334,8 +10339,6 @@ def diag_embed(input, offset=0, dim1=-2, dim2=-1):
          [[0, 0, 0], [0, 0, 0], [0, 0, 0], [3, 6, 9]],
          [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]])
     """
-
-    transpose_op = Transpose()
     matrix_set_diag_op = MatrixSetDiagV3(align="LEFT_RIGHT")
     zeros = ops.Zeros()
     if not isinstance(input, (Tensor, Tensor_)):
@@ -10652,7 +10655,7 @@ def _canonicalize_fft_shape_and_dim(input, shape, dim):
 
 
 def as_strided(x, shape=None, strides=None):
-    n = np.dtype(mstype.dtype_to_nptype(x.dtype)).itemsize
+    n = np.dtype(mstype._dtype_to_nptype(x.dtype)).itemsize  # pylint:disable=protected-access
     strides = tuple(np.array(strides) * n)
     if x.dtype == mstype.bfloat16:
         return Tensor(np.lib.stride_tricks.as_strided(x.float().asnumpy(), shape, strides, False, True), dtype=x.dtype)
@@ -10703,7 +10706,7 @@ def _permute_input(input, input_dim, ret_dim):
         (dim_permute_a if not is_transformed_dim[i] else dim_permute_b).append(value)
 
     # strides
-    type_size = np.dtype(mstype.dtype_to_nptype(input.dtype)).itemsize
+    type_size = np.dtype(mstype._dtype_to_nptype(input.dtype)).itemsize  # pylint:disable=protected-access
     input_strides = [int(x / type_size) for x in input.strides]
 
     def cmp(x, y):
@@ -10728,7 +10731,7 @@ def _permute_input(input, input_dim, ret_dim):
     dim_permute = dim_permute_a + dim_permute_b
 
     # permute
-    input = transpose_(input, tuple(dim_permute))
+    input = transpose_op(input, tuple(dim_permute))
 
     return input, dim_permute
 
@@ -10816,7 +10819,7 @@ def _handle_fftwithsize_output(out, input_dim, batch_dims, dim_permute, out_size
     for i in range(batch_dims, input_dim):
         out_strides[dim_permute[i]] = out.strides[1 + (i - batch_dims)]
 
-    type_size = np.dtype(mstype.dtype_to_nptype(out.dtype)).itemsize
+    type_size = np.dtype(mstype._dtype_to_nptype(out.dtype)).itemsize  # pylint:disable=protected-access
     if out.shape != out_sizes or out.strides != out_strides:
         out = as_strided(out, out_sizes, [int(i / type_size) for i in out_strides])
     return out
@@ -11194,7 +11197,7 @@ def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
             Default ``()`` , which counts all non-zero elements.
         keep_dims (bool, optional): Whether to maintain dimensions specified by `axis`.
             Default ``False`` , don't keep these dimensions.
-        dtype (Union[Number, mindspore.bool\_], optional): The data type returned.
+        dtype (Union[Number, mindspore.bool], optional): The data type returned.
             Default ``mstype.int32`` .
 
 
@@ -11438,8 +11441,8 @@ def tensor_dot(x1, x2, axes):
     x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape(x2_shape, axes, 1)
     output_shape = x1_ret + x2_ret  # combine free axes from both inputs
     # run tensor_dot op
-    x1_transposed = transpose_(x1, x1_transpose_fwd)
-    x2_transposed = transpose_(x2, x2_transpose_fwd)
+    x1_transposed = transpose_op(x1, x1_transpose_fwd)
+    x2_transposed = transpose_op(x2, x2_transpose_fwd)
     x1_reshaped = reshape_(x1_transposed, x1_reshape_fwd)
     x2_reshaped = reshape_(x2_transposed, x2_reshape_fwd)
     mul_result = matmul_op(x1_reshaped, x2_reshaped)
@@ -11607,7 +11610,7 @@ def dot(input, other):
 
     if len(input_shape) > 2 or len(other_shape) > 2:
         other_shape_transpose = _get_transpose_shape(other_shape)
-        other_transpose = transpose_(other, other_shape_transpose)
+        other_transpose = transpose_op(other, other_shape_transpose)
         input_reshape = reshape_(input, (-1, input_shape[-1]))
         other_reshape = reshape_(other_transpose, (other_shape[-2], -1))
         mul_result = matmul_op(input_reshape, other_reshape)
@@ -11840,8 +11843,8 @@ def batch_dot(x1, x2, axes=None):
     x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape_batchdot(x2_shape, axes, 1)
     output_shape = _get_output_shape(x1_batch_size, x1_ret, x2_ret)
 
-    x1_transposed = transpose_(x1, x1_transpose_fwd)
-    x2_transposed = transpose_(x2, x2_transpose_fwd)
+    x1_transposed = transpose_op(x1, x1_transpose_fwd)
+    x2_transposed = transpose_op(x2, x2_transpose_fwd)
     x1_reshaped = reshape_(x1_transposed, x1_reshape_fwd)
     x2_reshaped = reshape_(x2_transposed, x2_reshape_fwd)
 
@@ -12083,11 +12086,11 @@ def mul_ext(input, other):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,