mindspore 2.2.11__cp39-none-any.whl → 2.2.14__cp39-none-any.whl

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/_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/_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:

mindspore/ops/operations/array_ops.py

@@ -227,7 +227,11 @@ class ExpandDims(PrimitiveWithCheck):
     def infer_value(self, input_x, axis):
         value = None
         if input_x is not None and axis is not None:
-            value = Tensor(np.expand_dims(input_x.asnumpy(), axis))
+            dtype = input_x.dtype
+            if input_x.dtype == mstype.bfloat16:
+                cpu_cast = Cast().set_device("CPU")
+                input_x = cpu_cast(input_x, mstype.float32)
+            value = Tensor(np.expand_dims(input_x.asnumpy(), axis), dtype)
         return value
 
 
@@ -375,6 +379,9 @@ class Cast(PrimitiveWithCheck):
         if isinstance(x, (int, float)):
             value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
         else:
+            if x.dtype == mstype.bfloat16:
+                cpu_cast = Cast().set_device("CPU")
+                x = cpu_cast(x, mstype.float32)
             value = Tensor(x.asnumpy().astype(np_dst_type), dtype=dst_type)
         return value
 
@@ -5837,6 +5844,9 @@ class SpaceToBatchND(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
         >>> block_shape = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
         >>> space_to_batch_nd = ops.SpaceToBatchND(block_shape, paddings)
@@ -6279,8 +6289,8 @@ class Sort(Primitive):
     Sorts the elements of the input tensor along the given dimension in the specified order.
 
     .. warning::
-        Currently, the data types of Float16 is well supported.
-        Using Float32 might cause loss of accuracy.
+        Currently, the data types of float16, uint8, int8, int16, int32, int64 are well supported.
+        If use float32, it may cause loss of accuracy.
 
     Args:
         axis (int, optional): The dimension to sort along. Default: ``-1``, means the last dimension.
@@ -8719,7 +8729,8 @@ class TopK(Primitive):
           - GPU: float16, float32.
           - CPU: all numeric types.
 
-        - **k** (int) - The number of top elements to be computed along the last dimension, constant input is needed.
+        - **k** (Union(Tensor, int)) - The number of top elements to be computed along the last dimension.
+          If `k` is a Tensor, the supported dtype is int32 and it should be 0-D or 1-D with shape :math:`(1, )` .
 
     Outputs:
         A tuple consisting of `values` and `indexes`.

mindspore/ops/operations/custom_ops.py

@@ -470,7 +470,7 @@ class Custom(ops.PrimitiveWithInfer):
     op_path_in_cache = []  # Save paths for op functions created in the cached.
     custom_aot_warning = True  # Flag to enable warnings about custom aot path white list
 
-    def __init__(self, func, out_shape=None, out_dtype=None, func_type=HYBRID_TYPE, bprop=None, reg_info=None):
+    def __init__(self, func, out_shape=None, out_dtype=None, func_type="hybrid", bprop=None, reg_info=None):
         super().__init__("Custom")
 
         self.supported_targets = [ASCEND, GPU, CPU]

mindspore/ops/operations/debug_ops.py

@@ -472,7 +472,7 @@ class Print(Primitive):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor, nn
+        >>> from mindspore import Tensor, nn, ops
         >>> class PrintDemo(nn.Cell):
         ...     def __init__(self):
         ...         super(PrintDemo, self).__init__()

mindspore/ops/operations/image_ops.py

@@ -388,7 +388,7 @@ class NonMaxSuppressionV3(Primitive):
           single score associated with each box (i.e., each row of the `boxes` Tensor).
           It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
           The supported data type is float32.
-        - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
+        - **max_output_size** (Union[Tensor, Number.int]) - A scalar integer Tensor representing the maximum
           number of boxes to be selected by non max suppression. The supported data type is int32.
         - **iou_threshold** (Union[Tensor, Number.Float]) - A scalar float Tensor represents the threshold
           used for determining if the intersection over union (IOU) between boxes is too high.
@@ -459,7 +459,7 @@ class NonMaxSuppressionWithOverlaps(Primitive):
           single score associated with each box (i.e., each row of the `boxes` Tensor).
           It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
           The supported data type is float32.
-        - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
+        - **max_output_size** (Union[Tensor, Number.int]) - A scalar integer Tensor representing the maximum
           number of boxes to be selected by non max suppression, and max_output_size must be equal to or greater
           than 0.
           Types allowed:int32.
@@ -816,7 +816,7 @@ class ResizeBicubic(Primitive):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, ops
+        >>> from mindspore import Tensor, ops, nn
         >>> class NetResizeBicubic(nn.Cell):
         ...     def __init__(self):
         ...         super(NetResizeBicubic, self).__init__()

mindspore/ops/operations/inner_ops.py

@@ -642,6 +642,55 @@ class FusedAdaFactorWithGlobalNorm(FusedAdaFactor):
         return param_type
 
 
+class GenerateEodMask(Primitive):
+    r"""
+    Given the input `inputs_ids`, if found eod_token_id, the output position and attention mask matrix will be reset.
+    This means the `position_id` will start counting from 0, and the corresponding mask matrix will be filled with 0.
+
+    Args:
+        eod_token_id (int) - In the NLP scenario, this value corresponds to the id of
+            the symbol of 'EodOfDocument' in the vocabulary.
+
+    Inputs:
+      - **inputs_ids** (Tensor) - token id, a 2-D Tensor with shape :math:`(batch\_size, seq\_length)`.
+
+    Outputs:
+      - **position_id** (Tensor) - position id matrix with same shape and type as original `inputs_ids`.
+      - **attention_mask** (Tensor) - attention mask matrix with type
+            float16 and shape :math:`(batch\_size, seq\_length)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> op = ops.GenerateEodMask(eod_token_id=0)
+        >>> position, mask = op(Tensor([[1, 0, 3], [1, 0, 0]], dtype=mindspore.int32))
+        >>> print(position)
+        [[0 1 0] [0 0 1]]
+        >>> print(mask)
+        [[[ 1. 0. 0.]
+          [1. 1. 0.]
+          [0. 0. 1.]]
+         [[1. 0. 0.]
+          [0. 1. 0.]
+          [0. 1. 1.]]]
+
+    Raises:
+        - **TypeError** - If `eod_token_id` is not int.
+        - **TypeError** - If `inputs_ids` is not int.
+        - **ValueError** - If `inputs_ids` is not a 2-D Tensor.
+    """
+    @prim_attr_register
+    def __init__(self, n_pos, eod_token_id, n_step, n_error_mode='specific'):
+        """Initialize GenerateEodMask"""
+        validator.check_value_type("eod_token_id", eod_token_id, [int], self.name)
+        validator.check_value_type("n_pos", n_pos, [int], self.name)
+        validator.check_value_type("n_step", n_step, [list], self.name)
+        validator.check_value_type("n_error_mode", n_error_mode, [str], self.name)
+        self.init_prim_io_names(inputs=['inputs_ids'],
+                                outputs=['position_ids'])
+
+
 class ScaleGrad(PrimitiveWithInfer):
     """
     Scale the input grad according to the loss scale.

mindspore/ops/operations/math_ops.py

@@ -123,6 +123,64 @@ class _MathBinaryOp(_BinaryOp):
         real_shape = [dim if cmp_dim > 0 else cmp_dim for dim, cmp_dim in zip(shape_value, cmp_shape)]
         return tuple(real_shape)
 
+class SilentCheck(Primitive):
+    """
+    Implement SilentCheck on `pre_val`, `min_val`, `max_val`, `result` and
+    update them inplace with given parameters.
+
+    Args:
+        c_min_steps (int): an int determines...
+
+        c_thresh_l1 (float): a float determines...
+
+        c_coeff_l1 (float): a float determines...
+
+        c_thresh_l2 (float): a float determines...
+
+        c_coeff_l2 (float): a float determines...
+
+    Inputs:
+        - **val** (Tensor) - Tensor with dtype float32.
+        - **input_grad** (Parameter) - Tensor with dtype float32.
+        - **pre_val** (Parameter) - Input Parameter with dtype float32.
+        - **min_val** (Parameter) - Input Parameter with dtype float32.
+        - **max_val** (Parameter) - Input Parameter with dtype float32.
+        - **val_counter** (Parameter) - Input Parameter with dtype int32.
+
+    Outputs:
+        Tuple of 5 Tensors, the updated parameters.
+        - **input_grad** (Tensor) - Tensor with dtype float32.
+        - **pre_val** (Tensor) - Tensor with dtype float32.
+        - **min_val** (Tensor) - Tensor with dtype float32.
+        - **max_val** (Tensor) - Tensor with dtype float32.
+        - **result** (Tensor) - Tensor with dtype int32.
+
+    Raises:
+        TypeError: If `val` is not Tensor with dtype float32.
+        TypeError: If `result` is not Tensor with dtype int32.
+        TypeError: If `pre_val`, `min_val`, `max_val`, `input_grad` are not all Parameter type with dtype float32.
+        TypeError: If `c_thresh_l1` or `c_coeff_l1` is not a float number.
+        TypeError: If `c_min_steps` is not an int number.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore.ops.operations.math_ops import SilentCheck
+        >>> silent_check = SilentCheck()
+        xxx
+    """
+
+    @prim_attr_register
+    def __init__(self, c_min_steps, c_thresh_l1, c_coeff_l1, c_thresh_l2, c_coeff_l2):
+        """Initialize SilentCheck."""
+        validator.check_value_type("c_min_steps", c_min_steps, [int], self.name)
+        validator.check_value_type("c_thresh_l1", c_thresh_l1, [float], self.name)
+        validator.check_value_type("c_coeff_l1", c_coeff_l1, [float], self.name)
+        validator.check_value_type("c_thresh_l2", c_thresh_l2, [float], self.name)
+        validator.check_value_type("c_coeff_l2", c_coeff_l2, [float], self.name)
+        self.add_prim_attr('side_effect_mem', True)
+
 
 class _BitwiseBinaryOp(_MathBinaryOp):
     """
@@ -462,6 +520,7 @@ class AssignAdd(Primitive):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops, nn
+        >>> from mindspore.common.initializer import initializer
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -512,6 +571,7 @@ class AssignSub(Primitive):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops, nn
+        >>> from mindspore.common.initializer import initializer
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -7253,6 +7313,7 @@ class Igamma(Primitive):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
         >>> x = Tensor(np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32))
@@ -7291,6 +7352,7 @@ class Igammac(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))

mindspore/ops/operations/nn_ops.py

@@ -3777,7 +3777,7 @@ class LayerNorm(Primitive):
         - **output_x** (Tensor) - The normalized input, has the same type and shape as the `input_x`.
         - **mean** (Tensor) - The first `begin_norm_axis` dimensions of `mean` shape is the same as `input_x`,
           and the remaining dimensions are 1. Suppose the shape of the `input_x` is :math:`(x_1, x_2, \ldots, x_R)`,
-          the shape of the `mean` is :math:`(x_1, \ldots, x_{begin_params_axis}, 1, \ldots, 1)`
+          the shape of the `mean` is :math:`(x_1, \ldots, x_{begin\_params\_axis}, 1, \ldots, 1)`
           (when `begin_params_axis=0`, the shape of `mean` is :math:`(1, \ldots, 1)` ).
         - **variance** (Tensor) - Shape is the same as `mean` .
 
@@ -4917,6 +4917,7 @@ class Adam(Primitive):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, nn, ops
+        >>> from mindspore import Parameter
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -9991,6 +9992,9 @@ class FractionalMaxPool3DWithFixedKsize(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
         ...       .reshape([1, 1, 2, 2, 4]), mstype.float32)
         >>> random_samples = Tensor(np.array([0.7, 0.7, 0.7]).reshape([1, 1, 3]), mstype.float32)
@@ -11363,7 +11367,7 @@ class PromptFlashAttention(Primitive):
           For each element, 0 indicates retention and 1 indicates discard. Input tensor of shape :math:`(B, 1, S, S)`.
         - **actual_seq_lengths** (Tensor): Describe actual sequence length of each input with data type of int.
         - **actual_seq_lengths_kv** (Tensor): Describe actual sequence length of each input with data type of int.
-        - **padding_mask** (Tensor) - The padding mask tensor with data type of float16 or float32
+        - **pse_shift** (Tensor) - The position encoding tensor with data type of float16 or float32.
         - **dep_scale1** (Tensor)
         - **quant_scale1** (Tensor)
         - **deq_scale2** (Tensor)
@@ -11406,7 +11410,7 @@ class PromptFlashAttention(Primitive):
         validator.check_value_type('num_key_value_heads', num_key_value_heads, [int], self.name)
         validator.check_value_type('sparse_mode', sparse_mode, [int], self.name)
         self.init_prim_io_names(inputs=["query", "key", "value", "attn_mask", "actual_seq_lengths",
-                                        "actual_seq_lengths_kv", "padding_mask", "deq_scale1", "quant_scale1",
+                                        "actual_seq_lengths_kv", "pse_shift", "deq_scale1", "quant_scale1",
                                         "deq_scale2", "quant_scale2", "quant_offset2"],
                                 outputs=["attention_out"])
 

mindspore/ops/operations/random_ops.py

@@ -1271,6 +1271,8 @@ class RandpermV2(Primitive):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> n = Tensor([4], mstype.int64)
         >>> seed = 0
         >>> offset = 0