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

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -18,11 +18,13 @@
 import numpy as np
 import mindspore.numpy as mnp
 from mindspore.common import dtype as mstype
+import mindspore.ops as ops
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore import Tensor
 from mindspore.ops.operations.math_ops import Real, Imag, Complex, Angle
-from mindspore.ops.operations.math_ops import Polar
+from mindspore.ops.operations.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
@@ -763,6 +765,7 @@ def get_bprop_fft_with_size(self):
     to_tensor_op = P.ScalarToTensor()
     type_op = P.DType()
     concat_op = P.Concat()
+    concat_op_last = P.Concat(axis=-1)
     ones_op = P.Ones()
     zeros_op = P.Zeros()
     real_op = P.Real()
@@ -794,8 +797,7 @@ def get_bprop_fft_with_size(self):
                                  signal_sizes=offset_shape[-1:])
             irfft2d_ = FFTWithSize(signal_ndim=2, inverse=True, real=True, norm="backward", onesided=onesided,
                                    signal_sizes=offset_shape[-2:])
-            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=True, norm="backward", onesided=onesided,
-                                   signal_sizes=offset_shape[-3:])
+            irfft3d_ = FFTWithSize(signal_ndim=3, inverse=True, real=False, norm="backward", onesided=onesided)
             if inverse is False:
                 if onesided is True:
                     terms = 0
@@ -811,6 +813,7 @@ def get_bprop_fft_with_size(self):
                         vec_mask = complex_op(1 - 2 * (mnp.arange(0, input_shape[-1], 1, input_type) % 2),
                                               zeros_op(input_shape[-1], input_type))
                         terms = real_op(dout_first) + is_even * real_op(dout_last * vec_mask)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 2:
                         dx = irfft2d_(dout)
                         arange_inner = mnp.arange(0, input_shape[-2], 1, input_type)
@@ -852,26 +855,27 @@ def get_bprop_fft_with_size(self):
                                                         dout_shape, [input_shape[-1]])))
                         dout_last_term = dout_last_term * vec_mask
                         terms = real_op(dout_first_term) + is_even * real_op(dout_last_term)
+                        dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
                     elif signal_ndim == 3:
-                        dx = irfft3d_(dout) * real_op(offset_size)
-                    dx = to_tensor_op(0.5, input_type) * (dx * rfft_offset_size + terms) * rfft_norm_offset
+                        zeros_shape = offset_shape[:-1] + (offset_shape[-1] - dout_shape[-1],)
+                        zeros_values = zeros_op(zeros_shape, input_type)
+                        zeros_padding = complex_op(zeros_values, zeros_values)
+                        dout = concat_op_last((dout, zeros_padding))
+                        dx = real_op(irfft3d_(dout)) * real_op(offset_size)
                 else:
                     dx = irfft_fn(dout) * real_op(offset_size)
             else:
                 dx = rfft_fn(dout)
                 if onesided is True:
-                    if signal_ndim != 3:
-                        is_odd = dout_shape[-1] % 2
-                        last_shape = offset_shape[-1]
-                        mask = concat_op((ones_op(1, output_type), 2.0 * ones_op(
-                            (last_shape - 2 + is_odd,), output_type), ones_op((1 - is_odd,), output_type)))
-                        dx = dx * complex_op(mask, zeros_op(shape_op(mask), output_type))
-                        irfft_offset_size = to_tensor_op(
-                            _fft_with_size_back_norm(shape_op(dout), norm, inverse, signal_ndim),
-                            output_type)
-                        dx = dx * complex_op(irfft_offset_size, zeros_op(1, output_type))
-                    else:
-                        dx = dx * complex_op(offset_size, zeros_op(1, output_type))
+                    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,)
@@ -1017,3 +1021,19 @@ 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/_op_impl/aicpu/__init__.py

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

mindspore/ops/_op_impl/aicpu/generate_eod_mask.py

@@ -0,0 +1,38 @@
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""GenerateEodMask op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+generate_eod_mask_op_info = AiCPURegOp("GenerateEodMask") \
+    .fusion_type("OPAQUE") \
+    .attr("eod_token_id", "int") \
+    .attr("n_pos", "int") \
+    .attr("n_step", "listint") \
+    .attr("n_error_mode", "str") \
+    .input(0, "inputs_ids", "required") \
+    .output(0, "position_ids", "required") \
+    .dtype_format(DataType.U16_Default, DataType.U16_Default) \
+    .dtype_format(DataType.U32_Default, DataType.U32_Default) \
+    .dtype_format(DataType.U64_Default, DataType.U64_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
+    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
+    .get_op_info()
+
+
+@op_info_register(generate_eod_mask_op_info)
+def _generate_eod_mask_aicpu():
+    """GenerateEodMask AiCPU register"""
+    return

mindspore/ops/_op_impl/aicpu/linear_sum_assignment.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 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.
@@ -24,11 +24,30 @@ lsap_op_info = AiCPURegOp("LinearSumAssignment") \
     .input(2, 'maximize', "required") \
     .output(0, "row_ind", "required") \
     .output(1, "col_ind", "required") \
-    .attr("cust_aicpu", "str") \
     .dtype_format(DataType.F64_Default, DataType.I64_Default,
                   DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
     .dtype_format(DataType.F32_Default, DataType.I64_Default,
                   DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.F16_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.BOOL_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.I16_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.I32_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.I64_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.I8_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.U16_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.U32_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.U64_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
+    .dtype_format(DataType.U8_Default, DataType.I64_Default,
+                  DataType.BOOL_Default, DataType.I64_Default, DataType.I64_Default,) \
     .get_op_info()
 
 

mindspore/ops/function/array_func.py

@@ -268,7 +268,7 @@ def cat(tensors, axis=0):
 
     Returns:
         Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
-            The data type is the same with `tensors`.
+        The data type is the same with `tensors`.
 
     Raises:
         TypeError: If `axis` is not an int.
@@ -660,7 +660,7 @@ def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
 
     Note:
         If the input indices is rank `N`, the output will have rank `N+1`. The new axis is created at dimension `axis`.
-        On Ascend, if `on_value` is Int64 dtype, `indices` must be Int64 dtype.
+        On Ascend, if `on_value` is int64 dtype, `indices` must be int64 dtype.
 
     Args:
         indices(Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
@@ -4228,6 +4228,7 @@ def space_to_batch_nd(input_x, block_size, paddings):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> block_size = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
@@ -5395,8 +5396,8 @@ def masked_select(input, mask):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore.ops as ops
-        >>> from mindspore import Tensor
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
         >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
         >>> output = ops.masked_select(x, mask)
@@ -6520,7 +6521,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
     Args:
         input (Tensor): Input to be computed, data type must be float16, float32 or int32.
-        k (int): The number of top or bottom elements to be computed along the last dimension, constant input is needed.
+        k (int): The number of top or bottom elements to be computed along the last dimension.
         dim (int, optional): The dimension to sort along. Default: ``None`` .
         largest (bool, optional): If largest is ``False``  then the k smallest elements are returned.
             Default: ``True`` .

mindspore/ops/function/debug_func.py

@@ -51,7 +51,7 @@ def print_(*input_x):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.ones([2, 1]).astype(np.int32))
         >>> y = Tensor(np.ones([2, 2]).astype(np.int32))
         >>> result = ops.print_('Print Tensor x and Tensor y:', x, y)

mindspore/ops/function/linalg_func.py

@@ -59,6 +59,8 @@ def cond(A, p=None):
 
     Args:
         A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)` where * is zero or more batch dimensions.
+            If `p` is one of Union[1, -1, inf, -inf, 'fro', 'nuc'], the function uses
+            :class:`mindspore.ops.MatrixInverse` , therefore, :math:`(*, m, n)` has to be square and ivertible.
         p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. Refer to the table above for
             behavior. Default: ``None``.
 
@@ -84,8 +86,8 @@ def cond(A, p=None):
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
     if p is None:
         p = 2
-    norm_a = F.norm(A, p)
-    norm_inv_a = F.norm(matrix_inverse(A), p)
+    norm_a = F.matrix_norm(A, p)
+    norm_inv_a = F.matrix_norm(matrix_inverse(A), p)
     return norm_a * norm_inv_a
 
 
@@ -194,6 +196,8 @@ def geqrf(input):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
         >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
         >>> y, tau = ops.geqrf(input_x)
         >>> print(y)
@@ -266,6 +270,16 @@ def svd(input, full_matrices=False, compute_uv=True):
     return s
 
 
+def _check_pinv_shape(x):
+    if not isinstance(x, (Tensor, Tensor_)):
+        raise TypeError("The input x must be tensor")
+    if x.shape == ():
+        raise TypeError("For pinv, the 0-D input is not supported")
+    x_shape = F.shape(x)
+    if len(x_shape) < 2:
+        raise ValueError("input x should have 2 or more dimensions, " f"but got {len(x_shape)}.")
+
+
 def pinv(x, *, atol=None, rtol=None, hermitian=False):
     r"""
     Computes the (Moore-Penrose) pseudo-inverse of a matrix.
@@ -318,19 +332,15 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
         ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[4., 0.], [0., 5.]], mindspore.float32)
         >>> output = ops.pinv(x)
         >>> print(output)
-        [[0.25  0. ]
-        [0.  0.2 ]]
+        [[0.25 0.  ]
+         [0.   0.2 ]]
     """
-    if not isinstance(x, (Tensor, Tensor_)):
-        raise TypeError("The input x must be tensor")
-    if x.shape == ():
-        raise TypeError("For pinv, the 0-D input is not supported")
-    x_shape = F.shape(x)
-    if len(x_shape) < 2:
-        raise ValueError("input x should have 2 or more dimensions, " f"but got {len(x_shape)}.")
+    _check_pinv_shape(x)
     x_dtype = _get_cache_prim(P.DType)()(x)
     _check_input_dtype("x", x_dtype, [mstype.float32, mstype.float64], "pinv")
     _check_attr_dtype("hermitian", hermitian, [bool], "pinv")

mindspore/ops/function/math_func.py

@@ -343,6 +343,7 @@ def add(input, other):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> # case 1: x and y are both Tensor.
         >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
@@ -12784,6 +12785,7 @@ def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
     Examples:
         >>> from mindspore import Tensor, ops
         >>> import numpy as np
+        >>> import mindspore
         >>> # case 1: each value specified.
         >>> x = Tensor(np.array([[0, 1, 0], [1, 1, 0]]).astype(np.float32))
         >>> nonzero_num = ops.count_nonzero(x=x, axis=[0, 1], keep_dims=True, dtype=mindspore.int32)
@@ -13392,6 +13394,7 @@ def batch_dot(x1, x2, axes=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> x1 = Tensor(np.ones(shape=[2, 2, 3]), mindspore.float32)

mindspore/ops/function/nn_func.py

@@ -2748,6 +2748,7 @@ def softshrink(x, lambd=0.5):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> from mindspore import Tensor
         >>> from mindspore import ops
         >>> import numpy as np
@@ -3000,11 +3001,12 @@ def dense(input, weight, bias=None):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
-        >>> input = mindspore.Tensor([[-1., 1., 2.], [-3., -3., 1.]], mindspore.float32)
-        >>> weight = mindspore.Tensor([[-2., -2., -2.], [0., -1., 0.]], mindspore.float32)
-        >>> bias = mindspore.Tensor([0., 1.], mindspore.float32)
-        >>> output = mindspore.ops.dense(input, weight, bias)
+        >>> input = Tensor([[-1., 1., 2.], [-3., -3., 1.]], mindspore.float32)
+        >>> weight = Tensor([[-2., -2., -2.], [0., -1., 0.]], mindspore.float32)
+        >>> bias = Tensor([0., 1.], mindspore.float32)
+        >>> output = ops.dense(input, weight, bias)
         >>> print(output)
         [[-4.  0.]
          [10.  4.]]
@@ -3992,8 +3994,8 @@ def l1_loss(input, target, reduction='mean'):
     Examples:
         >>> from mindspore import Tensor, ops
         >>> from mindspore import dtype as mstype
-        >>> x = ms.Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
-        >>> target = ms.Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
+        >>> target = Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
         >>> output = ops.l1_loss(x, target, reduction="mean")
         >>> print(output)
         3.0
@@ -5342,7 +5344,7 @@ def conv1d(input, weight, bias=None, stride=1, pad_mode="valid", padding=0, dila
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.arange(64).reshape((4, 4, 4)), mindspore.float32)
         >>> weight = Tensor(np.arange(8).reshape((2, 2, 2)), mindspore.float32)
-        >>> bias = Tensor([-0.12345, 2.7683], ms.float32)
+        >>> bias = Tensor([-0.12345, 2.7683], mindspore.float32)
         >>> output = ops.conv1d(x, weight, pad_mode='pad', padding=(1,), bias=bias, groups=2)
         >>> print(output.shape)
         (4, 2, 5)
@@ -7444,8 +7446,8 @@ def max_pool2d(x, kernel_size, stride=None, padding=0, dilation=1, return_indice
     return out
 
 
-def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_seq_lengths,
-                           actual_seq_lengths_kv, deq_scale1, quant_scale1,
+def prompt_flash_attention(query, key, value, attn_mask, actual_seq_lengths,
+                           actual_seq_lengths_kv, pse_shift, deq_scale1, quant_scale1,
                            deq_scale2, quant_scale2, quant_offset2, num_heads, scale_value=1.0, pre_tokens=2147483547,
                            next_tokens=0, input_layout='BSH',
                            num_key_value_heads=0, sparse_mode=0):
@@ -7468,11 +7470,11 @@ def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_se
           Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
         value (Tensor) - The value tensor with data type of float16 or float32.
           Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
-        padding_mask (Tensor) - The padding mask tensor with data type of float16 or float32
         attn_mask (Tensor) - The attention mask tensor with data type of float16 or float32.
           For each element, 0 indicates retention and 1 indicates discard. Input tensor of shape :math:`(B, 1, S, S)`.
         actual_seq_lengths (list[int]): Describe actual sequence length of each input with data type of int.
         actual_seq_lengths_kv (list[int]): Describe actual sequence length of each input with data type of int.
+        pse_shift (Tensor) - The position encoding tensor with data type of float16 or float32.
         dep_scale1 (Tensor)
         quant_scale1 (Tensor)
         deq_scale2 (Tensor)
@@ -7516,7 +7518,7 @@ def prompt_flash_attention(query, key, value, padding_mask, attn_mask, actual_se
 
     pfa = _get_cache_prim(NN_OPS.PromptFlashAttention)(num_heads, scale_value, pre_tokens, next_tokens, input_layout,
                                                        num_key_value_heads, sparse_mode)
-    return pfa(query, key, value, padding_mask, attn_mask, actual_seq_lengths, actual_seq_lengths_kv, deq_scale1,
+    return pfa(query, key, value, attn_mask, actual_seq_lengths, actual_seq_lengths_kv, pse_shift, deq_scale1,
                quant_scale1, deq_scale2, quant_scale2, quant_offset2)
 
 

mindspore/ops/function/parameter_func.py

@@ -99,6 +99,7 @@ def assign_sub(variable, value):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
+        >>> from mindspore.common.initializer import initializer
         >>> variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
         >>> value = Tensor(np.ones([1]).astype(np.int32) * 100)
         >>> ops.assign_sub(variable, value)
@@ -149,6 +150,7 @@ def assign_add(variable, value):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
+        >>> from mindspore.common.initializer import initializer
         >>> variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
         >>> value = Tensor(np.ones([1]).astype(np.int32) * 100)
         >>> ops.assign_add(variable, value)

mindspore/ops/function/sparse_unary_func.py

@@ -28,7 +28,7 @@ def csr_cos(x: CSRTensor) -> CSRTensor:
         out_i = \cos(x_i)
 
     .. warning::
-        Currently support data types float16 and float32. If use Float64, there may be a problem of missing precision.
+        Currently support data types float16 and float32. If use float64, there may be a problem of missing precision.
 
     Args:
         x (CSRTensor): Input CSRTensor.
@@ -69,7 +69,7 @@ def coo_cos(x: COOTensor) -> COOTensor:
         out_i = \cos(x_i)
 
     .. warning::
-        If use Float64, there may be a problem of missing precision.
+        If use float64, there may be a problem of missing precision.
 
     Args:
         x (COOTensor): Input COOTensor.

mindspore/ops/function/vmap_func.py

@@ -81,6 +81,7 @@ def vmap(fn, in_axes=0, out_axes=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> from mindspore import Tensor
         >>> from mindspore import vmap
         >>> def test_vmap(x, y, z):                                              # ([a],[a],[a]) -> [a]

mindspore/ops/operations/__init__.py

@@ -118,7 +118,7 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      Dilation2D, DataFormatVecPermute, DeformableOffsets, Dense, FractionalAvgPool,
                      FractionalMaxPool, FractionalMaxPool3DWithFixedKsize, FractionalMaxPoolWithFixedKsize,
                      GridSampler2D, TripletMarginLoss, UpsampleNearest3D, UpsampleTrilinear3D, PadV3, ChannelShuffle,
-                     GLU, MaxUnpool3D, Pdist, RmsNorm)
+                     GLU, MaxUnpool3D, Pdist, RmsNorm, PagedAttention, PagedAttentionMask, ReshapeAndCache)
 from .other_ops import (Assign, IOU, BoundingBoxDecode, BoundingBoxEncode,
                         ConfusionMatrix, UpdateState, Load, StopGradient,
                         CheckValid, Partial, Depend, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
@@ -692,7 +692,10 @@ __all__ = [
     "MaskedScatter",
     "Ormqr",
     "RandpermV2",
-    "RmsNorm"
+    "RmsNorm",
+    "PagedAttention",
+    "PagedAttentionMask",
+    "ReshapeAndCache"
 ]
 
 __custom__ = [

mindspore/ops/operations/_embedding_cache_ops.py

@@ -65,7 +65,7 @@ class SubAndFilter(PrimitiveWithCheck):
 
     Inputs:
         - **input_x** (Tensor) - Input tensor.
-        - **max_num** (Int) - The max value of element that after sub `offset`.
+        - **max_num** (int) - The max value of element that after sub `offset`.
         - **offset** (int) - Specifies the offset value of this `input_x`.
 
     Outputs:

mindspore/ops/operations/_grad_ops.py

@@ -3861,10 +3861,10 @@ class FlashAttentionScoreGrad(Primitive):
         validator.check_value_type('input_layout', input_layout, [str], self.name)
         if input_layout not in ["BSH", "BNSD"]:
             raise ValueError(f"Attribute 'input_layout' must be either 'BSH' or 'BNSD', but got {input_layout}")
-        self.init_prim_io_names(inputs=['query', 'key', 'value', 'attn_mask', 'attention_in', 'softmax_max',
-                                        'softmax_sum', 'dy', 'drop_mask', 'real_shift', "padding_mask", 'softmax_out',
+        self.init_prim_io_names(inputs=['query', 'key', 'value', 'dy', 'pse_shift', 'drop_mask', "padding_mask",
+                                        'attn_mask', 'softmax_max', 'softmax_sum', 'softmax_out', 'attention_in',
                                         'prefix'],
-                                outputs=['dq', 'dk', 'dv'])
+                                outputs=['dq', 'dk', 'dv', 'dpse'])
 
 
 class RmsNormGrad(Primitive):
@@ -3882,4 +3882,3 @@ class RmsNormGrad(Primitive):
         """Initialize RmsNormGrad."""
         self.init_prim_io_names(inputs=["dy", "x", "rstd", "gamma"],
                                 outputs=["dx", "dgamma"])
-        

mindspore/ops/operations/_inner_ops.py

@@ -16,6 +16,7 @@
 """Inner operators."""
 from types import FunctionType, MethodType
 from collections.abc import Iterable
+import os
 import numpy as np
 
 from mindspore.common import Tensor
@@ -1008,7 +1009,7 @@ class Centralization(PrimitiveWithInfer):
 
     Inputs:
         - **input_x** (Tensor) - The input tensor. The data type mast be float16 or float32.
-        - **axis** (Union[Int, Tuple(Int), List(Int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
+        - **axis** (Union[int, Tuple(int), List(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
           Only constant value is allowed. Must be in the range [-rank(input_x), rank(input_x)).
 
     Outputs:
@@ -2858,6 +2859,60 @@ class DecoderKVCache(Primitive):
         self.add_prim_attr('side_effect_mem', True)
 
 
+class _MirrorSilentCheck(PrimitiveWithInfer):
+    """
+    The operator _MirrorSilentCheck implements accuracy-sensitive detection on the tensor input in backpropagator.
+    Call _MirrorSilentCheck in method __call__ of derived class to implement accuracy-sensitive detection.
+
+    Inputs:
+        - **input** (Tensor) : The tensor used for detection.
+          Its data type must be mindspore.float16, mindspore.float32 or mindspore.bfloat16.
+        - **pre_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
+          Please only generated by method generate_params() of ASDBase.
+        - **min_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
+          Please only generated by method generate_params() of ASDBase.
+        - **max_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
+          Please only generated by method generate_params() of ASDBase.
+        - **cnt** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
+          Please only generated by method generate_params() of ASDBase.
+          After each invocation of _MirrorSilentCheck, increment the value of cnt by one.
+
+    Outputs:
+        - **output** (Tensor) - Same shape, type and value as `input`.
+    """
+    @prim_attr_register
+    def __init__(self, min_steps=8):
+        upper_thresh, sigma_thresh = self.get_thresh()
+        self.min_steps = min_steps
+        self.thresh_l1 = upper_thresh[0]
+        self.coeff_l1 = sigma_thresh[0]
+        self.thresh_l2 = upper_thresh[1]
+        self.coeff_l2 = sigma_thresh[1]
+        self.add_prim_attr('side_effect_mem', True)
+
+    def parse_thresh(self, env_var_name, default_value, min_value):
+        env_var = os.environ.get(env_var_name, default=default_value)
+        thresh = [value.strip() for value in env_var.split(",")]
+        if len(thresh) != 2 or not all(value.isdigit() for value in thresh):
+            thresh = default_value.split(",")
+        thresh = [float(max(int(value), min_value)) for value in thresh]
+        if thresh[0] <= thresh[1]:
+            thresh = [float(value) for value in default_value.split(",")]
+
+        return thresh
+
+    def get_thresh(self):
+        upper_thresh = self.parse_thresh("NPU_ASD_UPPER_THRESH", "1000000,10000", 3)
+        sigma_thresh = self.parse_thresh("NPU_ASD_SIGMA_THRESH", "100000,5000", 3)
+        return upper_thresh, sigma_thresh
+
+    def infer_shape(self, x_shape, pre_shape, min_shape, max_shape, n_step, loss_scale_shape):
+        return x_shape
+
+    def infer_dtype(self, x_dtype, pre_dtype, min_dtype, max_dtype, n_dtype, loss_scale_dtype):
+        return x_dtype
+
+
 class PromptKVCache(Primitive):
     r"""
     The PromptKVCache is used for prefill the KVCache of transformer network.

mindspore/ops/operations/_quant_ops.py

@@ -579,7 +579,7 @@ class FakeQuantWithMinMaxVars(PrimitiveWithInfer):
             range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
-        - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
+        - **x** (Tensor) - float32 tensor representing the shape of the output tensor.
         - **min** (Tensor) - Value of the min range of the input data x.
         - **max** (Tensor) - Value of the max range of the input data x.
 
@@ -638,7 +638,7 @@ class FakeQuantWithMinMaxVarsGradient(PrimitiveWithInfer):
 
     Inputs:
         - **gradients** (Tensor) - The gradient above the FakeQuantWithMinMaxVars.
-        - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
+        - **x** (Tensor) - float32 tensor representing the shape of the output tensor.
         - **min** (Tensor) - Value of the min range of the input data x.
         - **max** (Tensor) - Value of the max range of the input data x.
 
@@ -702,7 +702,7 @@ class FakeQuantWithMinMaxVarsPerChannel(PrimitiveWithInfer):
             range is [1, 2^num_bits-1]. Default: ``False``.
 
     Inputs:
-        - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
+        - **x** (Tensor) - float32 tensor representing the shape of the output tensor.
         - **min** (Tensor) - Value of the min range of the input data x.
         - **max** (Tensor) - Value of the max range of the input data x.
 
@@ -754,7 +754,7 @@ class FakeQuantWithMinMaxVarsPerChannelGradient(PrimitiveWithInfer):
 
     Inputs:
         - **gradients** (Tensor) - The gradient above the FakeQuantWithMinMaxVars.
-        - **x** (Tensor) - Float32 tensor representing the shape of the output tensor.
+        - **x** (Tensor) - float32 tensor representing the shape of the output tensor.
         - **min** (Tensor) - Value of the min range of the input data x.
         - **max** (Tensor) - Value of the max range of the input data x.
 

mindspore/ops/operations/_rl_inner_ops.py

@@ -341,7 +341,7 @@ class LSTMV2(Primitive):
         - **h** (Tensor) - Tensor of shape (num_directions * `num_layers`, batch_size, `hidden_size`).
         - **c** (Tensor) - Tensor of shape (num_directions * `num_layers`, batch_size, `hidden_size`).
         - **w** (Tensor) - The input tensor which states for weights.
-        - **seq_lengths** (Tensor) - The Tensor[Int32] of shape (batch_size, ),
+        - **seq_lengths** (Tensor) - The Tensor[int32] of shape (batch_size, ),
           indicates the seq_length of each batch dim.
 
     Outputs: