mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.1__cp310-cp310-win_amd64.whl

mindspore/ops/operations/math_ops.py

@@ -38,9 +38,9 @@ from ..auto_generate import (Add, Addcdiv, Addcmul, ReduceMean, ReduceSum, Reduc
                              Greater, GreaterEqual, Gcd, LogicalNot, LogicalAnd, LogicalOr,
                              LogicalXor, Cos, ACos, Sin, Asin, Abs, Round, Atan, Atanh, Atan2,
                              LinSpace, MatrixDeterminant, LogMatrixDeterminant, Erfinv, Conj,
-                             Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky,
+                             Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky, Cross,
                              FFTWithSize, NextAfter, NanToNum, Eig, Qr, Roll, Maximum, Div, DivMod, CumProd,
-                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad)
+                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad, Xlogy, Trunc, Sign)
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
@@ -136,64 +136,6 @@ 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):
     """
@@ -1041,8 +983,8 @@ class Sub(_MathBinaryOp):
     Inputs:
         - **x** (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.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `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>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
@@ -1246,7 +1188,7 @@ class Histogram(Primitive):
         - **x** (Tensor) - the input tensor, type support list: [float16, float32, int32].
 
     Outputs:
-        Tensor, 1-D Tensor with type int32.
+        1-D Tensor. If the input is int32, the output returns int32, otherwise it returns float32.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -1264,7 +1206,7 @@ class Histogram(Primitive):
         >>> op = ops.Histogram(bins=4, min=0.0, max=3.0)
         >>> y = op(x)
         >>> print(y)
-        [0 2 1 0]
+        [0. 2. 1. 0.]
     """
 
     @prim_attr_register
@@ -1440,8 +1382,8 @@ class DivNoNan(Primitive):
     Inputs:
         - **x1** (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.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `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>`_.
         - **x2** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
           a bool when the first input is a bool or a tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -1803,48 +1745,6 @@ class Xdivy(Primitive):
         return None
 
 
-class Xlogy(Primitive):
-    r"""
-    Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
-    Returns zero when `x` is zero.
-
-    Refer to :func:`mindspore.ops.xlogy` for more details.
-
-    Inputs:
-        - **x** (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.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
-        - **y** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
-          a bool when the first input is a tensor or a tensor whose data type is number or bool\_.
-          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
-
-    Outputs:
-        Tensor, the shape is the same as the one after broadcasting,
-        and the data type is the one with higher precision or higher digits among the two inputs.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
-        >>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
-        >>> xlogy = ops.Xlogy()
-        >>> output = xlogy(x, y)
-        >>> print(output)
-        [-3.465736   0.        2.7725887]
-    """
-    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Xlogy."""
-        self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
-
-
 class _LogicBinaryOp(_BinaryOp):
     """
     Define logic binary operators.
@@ -2564,54 +2464,17 @@ class NMSWithMask(PrimitiveWithInfer):
         return bboxes_dtype, mstype.int32, mstype.bool_
 
 
-class Sign(Primitive):
-    r"""
-    Performs sign on the tensor element-wise.
-
-    .. math::
-        sign(x) = \begin{cases} -1, &if\ x < 0 \cr
-        0, &if\ x = 0 \cr
-        1, &if\ x > 0\end{cases}
-
-    Inputs:
-        - **x** (Tensor) - The input tensor of any dimension.
-
-    Outputs:
-        Tensor, has the same shape and dtype as the `x`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-         >>> import mindspore
-         >>> import numpy as np
-         >>> from mindspore import Tensor, ops
-         >>> x = Tensor(np.array([[2.0, 0.0, -1.0]]), mindspore.float32)
-         >>> sign = ops.Sign()
-         >>> output = sign(x)
-         >>> print(output)
-         [[ 1.  0. -1.]]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-
 class Tan(Primitive):
     r"""
-    Computes tangent of `x` element-wise.
+    Computes tangent of `input` element-wise.
 
     Refer to :func:`mindspore.ops.tan` for more details.
 
     Inputs:
-        - **x** (Tensor) - Input tensor of any dimension.
+        - **input** (Tensor) - Input tensor of any dimension.
 
     Outputs:
-        Tensor, has the same shape as `x`.
+        Tensor, has the same shape as `input`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2630,7 +2493,7 @@ class Tan(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize Tan"""
-        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        self.init_prim_io_names(inputs=['input'], outputs=['output'])
 
 
 class SquareSumAll(Primitive):
@@ -3702,37 +3565,6 @@ class Imag(Primitive):
         self.init_prim_io_names(inputs=['input'], outputs=['output'])
 
 
-class Trunc(Primitive):
-    """
-    Returns a new tensor with the truncated integer values of the elements of input.
-
-    Refer to :func:`mindspore.ops.trunc` for more details.
-
-    Inputs:
-        - **input_x** (Tensor) - Input tensor of any dimension.
-
-    Outputs:
-        Tensor, the same shape and data type as `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]), mindspore.float32)
-        >>> output = ops.Trunc()(x)
-        >>> print(output)
-        [ 3.  0. -0. -3.]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize Trunc"""
-        self.init_prim_io_names(inputs=['input'], outputs=['output'])
-
-
 class TridiagonalMatMul(Primitive):
     """
     Return the result of a multiplication of two matrices, where the left one is a Tridiagonal Matrix.
@@ -4294,49 +4126,6 @@ class Polygamma(Primitive):
         self.init_prim_io_names(inputs=['a', 'x'], outputs=['y'])
 
 
-class Cross(Primitive):
-    """
-    Returns the cross product of vectors in dimension `dim` of x1 and x2.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.cross` for more details.
-
-    Args:
-        dim (int): Spefcified dim along which to cumpute cross product with. Default: ``-65530`` .
-
-    Inputs:
-        - **x1** (Tensor) - Input Tensor.
-        - **x2** (Tensor) - Another input Tensor, must have the same shape and
-          the same type as `x1`, and the size of their `dim` dimension should be 3.
-
-    Outputs:
-        Tensor, has the same shape and type as inputs.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
-        >>> from mindspore import ops
-        >>> cross = ops.Cross(dim = 0)
-        >>> x1 = Tensor([1, 2, 3], mstype.int8)
-        >>> x2 = Tensor([1, 2, 3], mstype.int8)
-        >>> output = cross(x1, x2)
-        >>> print(output)
-        [0 0 0]
-    """
-
-    @prim_attr_register
-    def __init__(self, dim=-65530):
-        validator.check_value_type('dim', dim, [int], self.name)
-        self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
-
-
 class RaggedRange(Primitive):
     """
     Returns a `RaggedTensor` containing the specified sequences of numbers.

mindspore/ops/operations/nn_ops.py

@@ -30,15 +30,16 @@ from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import PrimitiveWithInfer
 from mindspore.ops.primitive import PrimitiveWithCheck
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6, Dense, Tanh,
+from mindspore.run_check._check_version import AscendEnvChecker
+from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, ReLU, ReLU6, Dense, Tanh,
                              Elu, Sigmoid, Softmax, SoftplusExt, HSwish, HSigmoid, AvgPool, BiasAdd,
-                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm,
+                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm, IncreFlashAttention, MSELossExt,
                              GridSampler3D, GridSampler2D, LayerNorm, LayerNormExt, HShrink, AdamWeightDecay, Dropout,
                              ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache,
                              FlashAttentionScore, Embedding, UpsampleNearest1D, UpsampleNearest2D,
                              UpsampleNearest3D, UpsampleTrilinear3D,
                              UpsampleBilinear2D, UpsampleLinear1D,
-                             BinaryCrossEntropy, BCEWithLogitsLoss)
+                             BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink)
 from .manually_defined import BatchNorm
 
 
@@ -453,7 +454,7 @@ class ReLUV3(Primitive):
     Inputs:
         - **input_x** (Tensor) - Tensor of shape :math:`(N, *)`, where :math:`*` means, any number of
           additional dimensions, data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Outputs:
         Tensor of shape :math:`(N, *)`, with the same type and shape as the `input_x`.
@@ -569,8 +570,6 @@ class SeLU(Primitive):
         self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
 
 
-
-
 class FusedBatchNorm(Primitive):
     r"""
     The FusedBatchNorm interface is deprecated, please use the BatchNorm interface.
@@ -3075,9 +3074,9 @@ class LSTM(Primitive):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        num_layers (int): Number of layers of stacked LSTM.
-        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`.
-        bidirectional (bool): Specifies whether it is a bidirectional LSTM.
+        num_layers (int): Number of layers of stacked LSTM, , which is only support `1` on CPU.
+        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh` , which is only support `False` on CPU.
+        bidirectional (bool): Specifies whether it is a bidirectional LSTM, , which is only support `False` on CPU.
         dropout (float): If not 0, append `Dropout` layer on the outputs of each
             LSTM layer except the last layer. The range of dropout is [0.0, 1.0].
         proj_size (int): If `proj_size` > 0, a projection of the corresponding size will be used,
@@ -3776,6 +3775,7 @@ class AdamNoUpdateParam(Primitive):
     @prim_attr_register
     def __init__(self, use_locking=False, use_nesterov=False):
         """Initialize AdamNoUpdateParam."""
+        self.add_prim_attr('side_effect_mem', True)
         validator.check_value_type("use_locking", use_locking, [bool], self.name)
         validator.check_value_type("use_nesterov", use_nesterov, [bool], self.name)
 
@@ -6376,6 +6376,9 @@ class AvgPool3D(Primitive):
         \frac{1}{d_{ker} * h_{ker} * w_{ker}} \sum_{l=0}^{d_{ker}-1} \sum_{m=0}^{h_{ker}-1} \sum_{n=0}^{w_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times d + l, s_1 \times h + m, s_2 \times w + n)
 
+    Note:
+        This interface currently does not support Atlas A2 training series products.
+
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the average value,
             is an int number that represents depth, height and width are both kernel_size, or a tuple
@@ -7091,7 +7094,7 @@ class CTCLossV2Grad(Primitive):
         zero_infinity (bool): Whether to set infinite loss and correlation gradient to zero. Default: ``False`` .
 
     Inputs:
-        - **grad_out** (Tenosr) - Gradient renewal codfficient, A tensor for shape (N), where N is batch size.
+        - **grad_out** (Tensor) - Gradient renewal codfficient, A tensor for shape (N), where N is batch size.
         - **log_probs** (Tensor) - A tensor of shape (T, N, C), where T is input length, N is batch size and C is number
           of classes (including blank).
         - **targets** (Tensor) - A tensor of shape (N, S), where S is max target length, means the target sequences.
@@ -7461,43 +7464,6 @@ class Dilation2D(Primitive):
         self.add_prim_attr('dilation', self.dilation)
 
 
-class SoftShrink(Primitive):
-    r"""
-    Applies the SoftShrink function element-wise.
-
-    Refer to :func:`mindspore.ops.softshrink` for more details.
-
-    Args:
-        lambd(float, optional): The :math:`\lambda` must be no less than zero. Default: ``0.5`` .
-
-    Inputs:
-        - **input_x** (Tensor) - The input of soft shrink with data type of float16 or float32.
-
-    Outputs:
-        Tensor, has the same shape and data type as `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[ 0.5297,  0.7871,  1.1754], [ 0.7836,  0.6218, -1.1542]]), mindspore.float16)
-        >>> softshrink = ops.SoftShrink()
-        >>> output = softshrink(input_x)
-        >>> print(output)
-        [[ 0.02979  0.287    0.676  ]
-         [ 0.2837   0.1216  -0.6543 ]]
-    """
-
-    @prim_attr_register
-    def __init__(self, lambd=0.5):
-        """Initialize SoftShrink"""
-        validator.check_value_type("lambd", lambd, [float], self.name)
-        validator.check_number("lambd", lambd, 0, validator.GE, self.name)
-
-
 class ApplyAdagradDA(Primitive):
     r"""
     Update `var` according to the proximal adagrad scheme.
@@ -9591,79 +9557,19 @@ class PromptFlashAttention(Primitive):
                                 outputs=["attention_out"])
 
 
-class IncreFlashAttention(Primitive):
-    r"""
-    The interface for fully inference.
-
-    B -- Batch size
-
-    S -- Sequence length
-
-    H -- Hidden size
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-        If there is no input parameter and no default value, None needs to be passed.
-
-    Args:
-    - **num_heads**  (int) - The number of heads.
-    - **input_layout** (str) - the data layout of the input qkv, support `(BSH)` and `(BNSD)`. Default `BSH`.
-    - **scale_value** (double) - The scale value indicating the scale coefficient, which is used as the scalar of
-        Muls in the calculation. Default: 1.0.
-    - **num_key_value_heads** (int) - head numbers of key/value which are used in GQA algorithm.
-        The value o indicates if the key and value have the same head nums, use numHeads.  Default: 0.
-    - **block_size** (int) - Default: 0.
-    - **inner_precise** (int) - Default: 1.
-
-    Inputs:
-        - **query** (Tensor) - The query tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, 1, H)` / :math:`(B, N, 1, D)`.
-        - **key** (TensorList) - The key tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, S, H)` / :math:`(B, N, S, D)`.
-        - **value** (TensorList) - The value tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, S, H)` / :math:`(B, N, S, D)`.
-        - **attn_mask** (Tensor) - The attention mask tensor with data type of float16 or bool.
-          Input tensor of shape :math:`(B, S)` / :math:`(B, 1, S)` / :math:`(B, 1, 1, S)`.
-        - **actual_seq_lengths** (Tensor) - 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.
-        - **dequant_scale1** (Tensor) - Quantitative parametor, the tensor with data type of uint64.
-        - **quant_scale1** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **dequant_scale2** (Tensor) - Quantitative parametor, the tensor with data type of uint64.
-        - **quant_scale2** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **quant_offset2** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **antiquant_scale** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **antiquant_offset** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **block_table** (Tensor) - The tensor with data type of float.
-
-    Outputs:
-        - **attention_out** (Tensor) - Input tensor of shape :math:`(B, 1, H)` / :math:`(B, N, 1, D)`.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-
-    @prim_attr_register
-    def __init__(self, num_heads, input_layout="BSH", scale_value=1.0, num_key_value_heads=0, block_size=0,
-                 inner_precise=1):
-        """Initialize IncreFlashAttention."""
-        validator.check_value_type('num_heads', num_heads, [int], self.name)
-        validator.check_value_type('input_layout', input_layout, [str], self.name)
-        validator.check_value_type('scale_value', scale_value, [float], self.name)
-        validator.check_value_type('num_key_value_heads', num_key_value_heads, [int], self.name)
-        validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check_value_type('inner_precise', inner_precise, [int], self.name)
-        self.init_prim_io_names(inputs=["query", "key", "value", "attn_mask", "actual_seq_lengths", "pse_shift",
-                                        "dequant_scale1", "quant_scale1", "dequant_scale2", "quant_scale2",
-                                        "quant_offset2", "antiquant_scale", "antiquant_offset", "block_table"],
-                                outputs=["attention_out"])
-
-
 class AllFinite(Primitive):
     r"""
     Check all gradients is finite.
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize"""
         self.init_prim_io_names(inputs=['gradients'],
                                 outputs=["is_finite"])
+        if context.get_context("device_target") == "Ascend":
+            checker = AscendEnvChecker(None)
+            if not checker.check_custom_version():
+                raise RuntimeError(
+                    "The version of Ascend AI software package installed "
+                    "in the current environment does not support AllFinite.")

mindspore/ops/operations/other_ops.py

@@ -300,10 +300,10 @@ class SampleDistortedBoundingBoxV2(Primitive):
 
     @prim_attr_register
     def __init__(self, seed=0, seed2=0, \
-                  aspect_ratio_range=(0.75, 1.33), \
-                  area_range=(0.05, 1.0), \
-                  max_attempts=100, \
-                  use_image_if_no_bounding_boxes=False):
+                 aspect_ratio_range=(0.75, 1.33), \
+                 area_range=(0.05, 1.0), \
+                 max_attempts=100, \
+                 use_image_if_no_bounding_boxes=False):
         validator.check_is_int(seed, "seed", self.name)
         validator.check_is_int(seed2, "seed2", self.name)
         validator.check_value_type("aspect_ratio_range", aspect_ratio_range, [list, tuple], self.name)
@@ -584,6 +584,9 @@ class StopGradient(Primitive):
         pass
 
 
+stop_gradient_ = StopGradient()
+
+
 class ConfusionMatrix(PrimitiveWithInfer):
     r"""
     Calculates the confusion matrix from labels and predictions.

mindspore/ops/operations/random_ops.py

@@ -89,6 +89,10 @@ class TruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -153,6 +157,10 @@ class StandardNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -204,6 +212,10 @@ class StandardLaplace(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -367,6 +379,10 @@ class Gamma(PrimitiveWithInfer):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -450,6 +466,10 @@ class ParameterizedTruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -672,6 +692,10 @@ class UniformInt(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -737,6 +761,10 @@ class UniformReal(Primitive):
           - GPU: int32, int64.
           - CPU: int16, int32, int64.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -837,6 +865,10 @@ class RandomCategorical(PrimitiveWithInfer):
     r"""
     Generates random samples from a given categorical distribution tensor.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         dtype (mindspore.dtype): The type of output. Its value must be one of mstype.int16,
             mstype.int32 and mstype.int64. Default: ``mstype.int64`` .
@@ -903,6 +935,10 @@ class Multinomial(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -1012,6 +1048,11 @@ class UniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more details.
 
+    .. warning::
+        - The Ascend backend does not support the reproducibility of random numbers, so
+          the `seed` parameter has no effect.
+        - The Ascend backend does not support dynamic shape scenarios currently.
+
     Args:
         num_true (int): The number of target classes in each training example.
         num_sampled (int): The number of classes to randomly sample. The sampled_candidates will have a shape
@@ -1026,7 +1067,7 @@ class UniformCandidateSampler(Primitive):
 
     Inputs:
         - **true_classes** (Tensor) - A Tensor. The target classes with a Tensor shape of
-          :math:`(batch\_size, num\_true)`.
+          :math:`(batch\_size, num\_true)`. The value range of the elements must be :math:`[0, range\_max)`.
 
     Outputs:
         - **sampled_candidates** (Tensor) - The sampled_candidates is independent of the true classes.
@@ -1086,6 +1127,10 @@ class LogUniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.log_uniform_candidate_sampler` for more details.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         num_true (int, optional): The number of target classes per training example. Default: ``1`` .
         num_sampled (int, optional): The number of classes to randomly sample. Default: ``5`` .