mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-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.
 
@@ -159,11 +158,11 @@ def tensordump(file_name, tensor, mode='out'):
         >>> 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/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):
@@ -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
 
 
@@ -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
@@ -5436,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)
 
 
@@ -7705,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.
@@ -8218,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)}"
@@ -8228,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:
@@ -8323,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]
@@ -8433,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.
@@ -8453,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)
 
@@ -8556,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)
 
@@ -10346,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_)):
@@ -10740,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
 
@@ -11450,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)
@@ -11619,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)
@@ -11852,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)