mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops/operations/nn_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2023 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -31,15 +31,18 @@ from mindspore.ops.primitive import PrimitiveWithInfer
 from mindspore.ops.primitive import PrimitiveWithCheck
 from mindspore.ops.primitive import prim_attr_register
 from mindspore.run_check._check_version import AscendEnvChecker
-from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, ReLU, ReLU6, Dense, Tanh,
+from mindspore._c_expression import pyboost_all_finite
+from mindspore.common._stub_tensor import _convert_stub
+from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, GLU, ReLU, ReLU6, Dense, Tanh,
                              Elu, Sigmoid, Softmax, SoftplusExt, HSwish, HSigmoid, AvgPool, BiasAdd,
                              NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm, IncreFlashAttention, MSELossExt,
                              GridSampler3D, GridSampler2D, LayerNorm, LayerNormExt, HShrink, AdamWeightDecay, Dropout,
-                             ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache,
-                             FlashAttentionScore, Embedding, UpsampleNearest1D, UpsampleNearest2D,
+                             ApplyRotaryPosEmb, GroupTopk, PagedAttention, PagedAttentionMask, ReshapeAndCache,
+                             FlashAttentionScore, PromptFlashAttention, Embedding, UpsampleNearest1D, UpsampleNearest2D,
                              UpsampleNearest3D, UpsampleTrilinear3D,
-                             UpsampleBilinear2D, UpsampleLinear1D,
-                             BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink)
+                             SoftMarginLoss, UpsampleBilinear2D, UpsampleLinear1D,
+                             BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink, AdaptiveMaxPool2D,
+                             SmoothL1Loss)
 from .manually_defined import BatchNorm
 
 
@@ -246,78 +249,6 @@ class AdaptiveAvgPool2D(Primitive):
         self.add_prim_attr('output_size', self.output_size)
 
 
-class AdaptiveMaxPool2D(Primitive):
-    r"""
-    Performs 2D adaptive max pooling on a multi-plane input signal.
-
-    Refer to :func:`mindspore.ops.adaptive_max_pool2d` for more details.
-
-    Args:
-        output_size (Union[int, tuple]): The target output size. `output_size` can be a tuple :math:`(H, W)`,
-            or an int H for :math:`(H, H)`. :math:`H` and :math:`W` can be int or None.
-            If it is None, it means the output size is the same as the input size.
-
-    Inputs:
-        - **input_x** (Tensor) - The input of AdaptiveMaxPool2D, which is a 3D or 4D tensor,
-          with float16, float32 or float64 data type.
-
-    Outputs:
-        Tensor, with the same type as the `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> # case 1: output_size=(None, 2)
-        >>> input_x = Tensor(np.array([[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
-        ...                             [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
-        ...                             [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]]), mindspore.float32)
-        >>> adaptive_max_pool_2d = ops.AdaptiveMaxPool2D((None, 2))
-        >>> output = adaptive_max_pool_2d(input_x)
-        >>> print(output[0])
-        [[[[2. 3.]
-           [5. 6.]
-           [8. 9.]]
-          [[2. 3.]
-           [5. 6.]
-           [8. 9.]]
-          [[2. 3.]
-           [5. 6.]
-           [8. 9.]]]]
-        >>> # case 2: output_size=2
-        >>> adaptive_max_pool_2d = ops.AdaptiveMaxPool2D(2)
-        >>> output = adaptive_max_pool_2d(input_x)
-        >>> print(output[0])
-        [[[[5. 6.]
-           [8. 9.]]
-          [[5. 6.]
-           [8. 9.]]
-          [[5. 6.]
-           [8. 9.]]]]
-        >>> # case 3: output_size=(1, 2)
-        >>> adaptive_max_pool_2d = ops.AdaptiveMaxPool2D((1, 2))
-        >>> output = adaptive_max_pool_2d(input_x)
-        >>> print(output[0])
-        [[[[8. 9.]]
-          [[8. 9.]]
-          [[8. 9.]]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, output_size):
-        """Initialize AdaptiveMaxPool2D."""
-        validator.check_value_type("output_size", output_size, [int, tuple], self.name)
-        if isinstance(output_size, tuple):
-            validator.check_int(len(output_size), 2, validator.EQ,
-                                'length of output_size', self.name)
-        self.output_size = (output_size, output_size) if isinstance(self.output_size, int) else output_size
-        self.output_size = (-1 if self.output_size[0] is None else self.output_size[0],
-                            -1 if self.output_size[1] is None else self.output_size[1])
-        for size in self.output_size:
-            validator.check_number("output_size", size, -1, validator.GE, None)
-        self.add_prim_attr('output_size', self.output_size)
-
-
 class AdaptiveMaxPool3D(Primitive):
     r"""
     Performs 3D adaptive max pooling on a multi-plane input signal.
@@ -612,12 +543,12 @@ class InstanceNorm(PrimitiveWithInfer):
     Inputs:
         - **input_x** (Tensor) - The input of InstanceNorm, Tensor of shape :math:`(N, C)`,
           data type: float16 or float32.
-        - **gamma** (Parameter) - Scale, Tensor of shape :math:`(C,)`,
+        - **gamma** (Union[Parameter, Tensor])) - Scale, Tensor of shape :math:`(C,)`,
           data type: float32.
-        - **beta** (Parameter) - Bias, Tensor of shape :math:`(C,)`,
+        - **beta** (Union[Parameter, Tensor])) - Bias, Tensor of shape :math:`(C,)`,
           data type: float32.
-        - **mean** (Parameter) - Mean value, Tensor of shape :math:`(C,)`, data type: float32.
-        - **variance** (Parameter) - Variance value, Tensor of shape :math:`(C,)`, data type: float32.
+        - **mean** (Union[Parameter, Tensor])) - Mean value, Tensor of shape :math:`(C,)`, data type: float32.
+        - **variance** (Union[Parameter, Tensor])) - Variance value, Tensor of shape :math:`(C,)`, data type: float32.
 
     Outputs:
         Tuple of 3 Tensors, the normalized input, the updated parameters.
@@ -880,13 +811,13 @@ class Conv2D(Primitive):
 
     Inputs:
         - **x** (Tensor) - Input tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or
-          :math:`(N, H_{in}, W_{in}, C_{in}, )` depending on `data_format` .
+          :math:`(N, H_{in}, W_{in}, C_{in})` depending on `data_format` .
         - **weight** (Tensor) - The convolutional kernel value, it should has shape
           :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})` .
 
     Outputs:
         Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`
-        or :math:`(N, H_{out}, W_{out}, C_{out}, )`.
+        or :math:`(N, H_{out}, W_{out}, C_{out})`.
         To see how different pad modes affect the output shape, please refer to
         :class:`mindspore.nn.Conv2d` for more details.
 
@@ -2052,17 +1983,18 @@ class Conv2DTranspose(Conv2DBackpropInput):
               If this mode is set, `pad` must be greater than or equal to 0.
 
             Please refer to :class:`mindspore.nn.Conv2dTranspose` for more specifications about `pad_mode`.
-        pad (Union[int, tuple[int]]): The pad value to be filled. Default: ``0`` . If `pad` is an integer, the paddings
-                    of top, bottom, left and right are the same, equal to pad. If `pad` is a tuple of four integers,
-                    the padding of top, bottom, left and right equal to pad[0], pad[1], pad[2], and pad[3]
-                    correspondingly.
-        pad_list (Union[str, None]): The pad list like (top, bottom, left, right). Default: ``None`` .
-        mode (int): Modes for different convolutions. The value is currently not used. Default: ``1`` .
-        stride (Union[int, tuple[int]]): The stride to be applied to the convolution filter. Default: ``1`` .
-        dilation (Union[int, tuple[int]]): Specifies the dilation rate to be used for the dilated convolution.
+        pad (Union[int, tuple[int]], optional): The pad value to be filled. Default: ``0`` .
+            If `pad` is an integer, the paddings
+            of top, bottom, left and right are the same, equal to pad. If `pad` is a tuple of four integers,
+            the padding of top, bottom, left and right equal to pad[0], pad[1], pad[2], and pad[3]
+            correspondingly.
+        pad_list (Union[str, None], optional): The pad list like (top, bottom, left, right). Default: ``None`` .
+        mode (int, optional): Modes for different convolutions. The value is currently not used. Default: ``1`` .
+        stride (Union[int, tuple[int]], optional): The stride to be applied to the convolution filter. Default: ``1`` .
+        dilation (Union[int, tuple[int]], optional): Specifies the dilation rate to be used for the dilated convolution.
             Default: ``1`` .
-        group (int): Splits input into groups. Default: ``1`` .
-        data_format (str): The format of input and output data. It should be ``'NHWC'`` or ``'NCHW'`` .
+        group (int, optional): Splits input into groups. Default: ``1`` .
+        data_format (str, optional): The format of input and output data. It should be ``'NHWC'`` or ``'NCHW'`` .
             Default is ``'NCHW'`` .
 
     Inputs:
@@ -2130,7 +2062,7 @@ class SoftmaxCrossEntropyWithLogits(Primitive):
         - **labels** (Tensor) - Ground truth labels, with shape :math:`(N, C)`, has the same data type with `logits`.
 
     Outputs:
-        Tuple of 2 tensors(loss, dlogits), the `loss` shape is :math:`(N,)`,
+        Tuple of 2 tensors( `loss` , `dlogits` ), the `loss` shape is :math:`(N,)`,
         and the `dlogits` with the same shape as `logits`.
 
     Raises:
@@ -2164,7 +2096,7 @@ class SparseSoftmaxCrossEntropyWithLogits(Primitive):
     r"""
     Computes the softmax cross-entropy value between logits and sparse encoding labels.
 
-    Sets input logits as `X`, input label as `Y`, output as `loss`. Then,
+    Sets input logits as `X`, input label as `Y`, output as `loss`. The formula is as follows:
 
     .. math::
         \begin{array}{ll} \\
@@ -2174,7 +2106,7 @@ class SparseSoftmaxCrossEntropyWithLogits(Primitive):
         \end{array}
 
     Args:
-        is_grad (bool): If ``True`` , this operation returns the computed gradient. Default: ``False`` .
+        is_grad (bool, optional): If ``True`` , this operation returns the computed gradient. Default: ``False`` .
 
     Inputs:
         - **logits** (Tensor) - Input logits, with shape :math:`(N, C)`. Data type must be float16 or float32.
@@ -2182,7 +2114,7 @@ class SparseSoftmaxCrossEntropyWithLogits(Primitive):
           Data type must be int32 or int64.
 
     Outputs:
-        Tensor, if `is_grad` is False, the output tensor is the value of loss which is a scalar tensor;
+        Tensor, if `is_grad` is ``False``, the output tensor is the value of loss;
         if `is_grad` is ``True`` , the output tensor is the gradient of input with the same shape as `logits`.
 
     Raises:
@@ -2281,15 +2213,15 @@ class ApplyMomentum(Primitive):
     Refer to :class:`mindspore.nn.Momentum` for more details about the formula and usage.
 
     Args:
-        use_locking (bool): Whether to enable a lock to protect the variable and accumulation tensors
+        use_locking (bool, optional): Whether to enable a lock to protect the variable and accumulation tensors
                             from being updated. Default: ``False`` .
-        use_nesterov (bool): Enable Nesterov momentum. Default: ``False`` .
-        gradient_scale (float): The scale of the gradient. Default: ``1.0`` .
+        use_nesterov (bool, optional): Enable Nesterov momentum. Default: ``False`` .
+        gradient_scale (float, optional): The scale of the gradient. Default: ``1.0`` .
 
     Inputs:
-        - **variable** (Parameter) - Weights to be updated. Data type must be float64, int64, float, float16,
-          int16, int32, int8, uint16, uint32, uint64, uint8, complex64, complex128.
-        - **accumulation** (Parameter) - Accumulated gradient value by moment weight,
+        - **variable** (Union[Parameter, Tensor]) - Weights to be updated. Data type must be float64, int64, float,
+          float16, int16, int32, int8, uint16, uint32, uint64, uint8, complex64, complex128.
+        - **accumulation** (Union[Parameter, Tensor]) - Accumulated gradient value by moment weight,
           has the same data type with `variable`.
         - **learning_rate** (Union[Number, Tensor]) - The learning rate value, must be a float64, int64, float,
           float16, int16, int32, int8, uint16, uint32, uint64, uint8, complex64, complex128 number or
@@ -2306,7 +2238,7 @@ class ApplyMomentum(Primitive):
 
     Raises:
         TypeError: If the `use_locking` or `use_nesterov` is not a bool or `gradient_scale` is not a float.
-        TypeError: If the data type of `var`, `accum` and `grad` conversion of Parameter is not supported.
+        TypeError: If the data type of `var`, `accum` and `grad` conversion is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2354,55 +2286,6 @@ class ApplyMomentum(Primitive):
         self.add_prim_attr('side_effect_mem', True)
 
 
-class SmoothL1Loss(Primitive):
-    r"""
-    Calculate the smooth L1 loss, and the L1 loss function has robustness.
-
-    Refer to :func:`mindspore.ops.smooth_l1_loss` for more details.
-
-    Args:
-        beta (float, optional): A parameter used to control the point where the function will change between
-            L1 to L2 loss. The value should be greater than zero. Default: ``1.0`` .
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'none'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-    Inputs:
-        - **logits** (Tensor) - Input Tensor of any dimension. Data type must be float16, float32 or float64.
-        - **labels** (Tensor) - Ground truth data, has the same shape and dtype as the `logits`.
-
-    Outputs:
-        Tensor, loss float tensor, same shape and dtype as the `logits`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> loss = ops.SmoothL1Loss()
-        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
-        >>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
-        >>> output = loss(logits, labels)
-        >>> print(output)
-        [0.  0.  0.5]
-    """
-
-    @prim_attr_register
-    def __init__(self, beta=1.0, reduction='none'):
-        """Initialize SmoothL1Loss."""
-        validator.check_value_type('beta', beta, [float], self.name)
-        validator.check('beta', beta, '', 0, validator.GT, self.name)
-        validator.check_string(
-            reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
-        self.add_prim_attr('sigma', self.beta)
-        self.init_prim_io_names(inputs=['prediction', 'target'], outputs=['output'])
-
-
 class MultiMarginLoss(Primitive):
     r"""
     Creates a loss function that minimizes the hinge loss
@@ -2470,63 +2353,6 @@ class MultiMarginLoss(Primitive):
         return super().__call__(x, target, weight)
 
 
-class SoftMarginLoss(Primitive):
-    r"""
-    SoftMarginLoss operation.
-
-    Creates a criterion that optimizes a two-class classification
-    logistic loss between input tensor :math:`x` and target tensor :math:`y`
-    (containing 1 or -1).
-
-    .. math::
-        \text{loss}(x, y) = \sum_i \frac{\log(1 + \exp(-y[i]*x[i]))}{\text{x.nelement}()}
-
-    where :math:`x.nelement()` is the number of elements of x.
-
-    Args:
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'mean'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-    Inputs:
-        - **logits** (Tensor) - Predict data. Data type must be float16 or float32.
-        - **labels** (Tensor) - Ground truth data, with the same type and shape as `logits`.
-
-    Outputs:
-        Tensor or Scalar, if `reduction` is ``"none"``, its shape is the same as `logits`.
-        Otherwise, a scalar value will be returned.
-
-    Raises:
-        TypeError: If `logits` or `labels` is not a Tensor.
-        TypeError: If dtype of `logits` or `labels` is neither float16 nor float32.
-        ValueError: If shape of `logits` is not the same as `labels`.
-        ValueError: If `reduction` is not one of ``"none"`` , ``"mean"`` or ``"sum"`` .
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> loss = ops.SoftMarginLoss()
-        >>> logits = Tensor(np.array([[0.3, 0.7], [0.5, 0.5]]), mindspore.float32)
-        >>> labels = Tensor(np.array([[-1, 1], [1, -1]]), mindspore.float32)
-        >>> output = loss(logits, labels)
-        >>> print(output)
-        0.6764238
-    """
-
-    @prim_attr_register
-    def __init__(self, reduction="mean"):
-        """Initialize SoftMarginLoss"""
-        self.init_prim_io_names(inputs=['predict', 'label'], outputs=['loss'])
-        self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
-
-
 class L2Loss(Primitive):
     r"""
     Calculates half of the L2 norm, but do not square the result.
@@ -2790,12 +2616,12 @@ class ApplyRMSProp(PrimitiveWithInfer):
     :math:`\eta` represents `learning_rate`. :math:`\nabla Q_{i}(w)` represents `grad`.
 
     .. warning::
-        Note that in dense implementation of this algorithm, "mean_square" and "moment" will update even if "grad" is 0,
-        but in this sparse implementation, "mean_square" and "moment" will not update
-        in iterations during which "grad" is 0.
+        Note that in dense implementation of this algorithm, `mean_square` and `moment` will update even if `grad` is 0,
+        but in this sparse implementation, `mean_square` and `moment` will not update
+        in iterations during which `grad` is 0.
 
     Args:
-        use_locking (bool): Whether to enable a lock to protect the variable and accumulation tensors
+        use_locking (bool, optional): Whether to enable a lock to protect the variable and accumulation tensors
                             from being updated. Default: ``False`` .
 
     Inputs:
@@ -3453,7 +3279,7 @@ class ComputeAccidentalHits(Primitive):
     the weight is FLOAT_MAX. FLOAT_MAX indicates the max value in the type of Float
 
     Args:
-        num_true (int): The number of target classes per training example. Default: ``1`` .
+        num_true (int, optional): The number of target classes per training example. Default: ``1`` .
 
     Inputs:
         - **true_classes** (Tensor) - The target classes. With data type of int64
@@ -3610,11 +3436,11 @@ class Adam(Primitive):
             If ``False`` , update the gradients without using NAG. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Weights to be updated. The shape is :math:`(N, *)` where :math:`*` means,
+        - **var** (Union[Parameter, Tensor]) - Weights to be updated. The shape is :math:`(N, *)` where :math:`*` means,
           any number of additional dimensions. The data type can be float16 or float32.
-        - **m** (Parameter) - The 1st moment vector in the updating formula,
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula,
           the shape should be the same as `var`.
-        - **v** (Parameter) - the 2nd moment vector in the updating formula,
+        - **v** (Union[Parameter, Tensor]) - the 2nd moment vector in the updating formula,
           the shape should be the same as `var`.
         - **beta1_power** (float) - :math:`beta_1^t(\beta_1^{t})` in the updating formula.
         - **beta2_power** (float) - :math:`beta_2^t(\beta_2^{t})` in the updating formula.
@@ -3785,8 +3611,8 @@ class AdamNoUpdateParam(Primitive):
 
 class FusedSparseAdam(Primitive):
     r"""
-    Merges the duplicate value of the gradient and then updates parameters by the Adaptive Moment Estimation (Adam)
-    algorithm. This operator is used when the gradient is sparse.
+    Merges the duplicate value of the gradient and then updates parameters or tensors by the Adaptive Moment Estimation
+    (Adam) algorithm. This operator is used when the gradient is sparse.
 
     The Adam algorithm is proposed in `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_.
 
@@ -3819,11 +3645,12 @@ class FusedSparseAdam(Primitive):
             If ``False`` , update the gradients without using NAG. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Parameters to be updated with float32 data type. The shape is :math:`(N, *)`
-          where :math:`*` means, any number of additional dimensions.
-        - **m** (Parameter) - The 1st moment vector in the updating formula, has the same shape and data type as `var`.
-        - **v** (Parameter) - The 2nd moment vector in the updating formula, has the same shape and data type as `var`.
-          Mean square gradients, has the same type as `var` with float32 data type.
+        - **var** (Union[Parameter, Tensor]) - Parameters or tensors to be updated with float32 data type. The shape is:
+          math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula, has the same shape and data
+          type as `var`.
+        - **v** (Union[Parameter, Tensor]) - The 2nd moment vector in the updating formula, has the same shape and data
+          type as `var`. Mean square gradients, has the same type as `var` with float32 data type.
         - **beta1_power** (Tensor) - :math:`beta_1^t` in the updating formula with float32 data type.
           The shape is :math:`(1, )`.
         - **beta2_power** (Tensor) - :math:`beta_2^t` in the updating formula with float32 data type.
@@ -3841,7 +3668,7 @@ class FusedSparseAdam(Primitive):
         - **indices** (Tensor) - Gradient indices with int32 data type and indices.shape[0] = gradient.shape[0].
 
     Outputs:
-        Tuple of 3 Tensors, this operator will update the input parameters directly, the outputs are useless.
+        Tuple of 3 Tensors, this operator will update the input parameters or tensors directly, the outputs are useless.
 
         - **var** (Tensor) - A Tensor with shape :math:`(N, *)`.
         - **m** (Tensor) - A Tensor with shape :math:`(1, )`.
@@ -3911,8 +3738,8 @@ class FusedSparseAdam(Primitive):
 
 class FusedSparseLazyAdam(Primitive):
     r"""
-    Merges the duplicate value of the gradient and then updates parameters by the Adaptive Moment Estimation (Adam)
-    algorithm. This operator is used when the gradient is sparse. The behavior is not equivalent to the
+    Merges the duplicate value of the gradient and then updates parameters or tensors by the Adaptive Moment Estimation
+    (Adam) algorithm. This operator is used when the gradient is sparse. The behavior is not equivalent to the
     original Adam algorithm, as only the current indices parameters will be updated.
 
     The Adam algorithm is proposed in `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_.
@@ -3946,11 +3773,12 @@ class FusedSparseLazyAdam(Primitive):
             If ``False`` , update the gradients without using NAG. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Parameters to be updated with float32 data type. The shape is :math:`(N, *)`
-          where :math:`*` means, any number of additional dimensions.
-        - **m** (Parameter) - The 1st moment vector in the updating formula, has the same shape and data type as `var`.
-        - **v** (Parameter) - The 2nd moment vector in the updating formula, has the same shape and data type as `var`.
-          Mean square gradients, has the same type as `var` with float32 data type.
+        - **var** (Union[Parameter, Tensor]) - Parameters or tensors to be updated with float32 data type. The shape is:
+          math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula, has the same shape and data
+          type as `var`.
+        - **v** (Union[Parameter, Tensor]) - The 2nd moment vector in the updating formula, has the same shape and data
+          type as `var`. Mean square gradients, has the same type as `var` with float32 data type.
         - **beta1_power** (Tensor) - :math:`beta_1^t` in the updating formula with float32 data type.
           The shape is :math:`(1, )`.
         - **beta2_power** (Tensor) - :math:`beta_2^t` in the updating formula with float32 data type.
@@ -3968,7 +3796,7 @@ class FusedSparseLazyAdam(Primitive):
         - **indices** (Tensor) - Gradient indices with int32 data type and indices.shape[0] = gradient.shape[0].
 
     Outputs:
-        Tuple of 3 Tensors, this operator will update the input parameters directly, the outputs are useless.
+        Tuple of 3 Tensors, this operator will update the input parameters or tensors directly, the outputs are useless.
 
         - **var** (Tensor) - A Tensor with shape :math:`(N, *)`.
         - **m** (Tensor) - A Tensor with shape :math:`(1, )`.
@@ -4054,17 +3882,18 @@ class FusedSparseFtrl(Primitive):
         use_locking (bool): Use locks for updating operation if True . Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - The variable to be updated. The data type must be float32. The shape is :math:`(N, *)`
-          where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - The accumulation to be updated, must be same type and shape as `var`.
-        - **linear** (Parameter) - the linear coefficient to be updated, must be same type and shape as `var`.
+        - **var** (Union[Parameter, Tensor]) - The variable to be updated. The data type must be float32. The shape is:
+          math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **accum** (Union[Parameter, Tensor]) - The accumulation to be updated, must be same type and shape as `var`.
+        - **linear** (Union[Parameter, Tensor]) - the linear coefficient to be updated, must be same type and shape as
+          `var`.
         - **grad** (Tensor) - A tensor of the same type as `var` and
           grad.shape[1:] = var.shape[1:] if var.shape > 1.
         - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
           The type must be int32 and indices.shape[0] = grad.shape[0].
 
     Outputs:
-        Tuple of 3 Tensor, this operator will update the input parameters directly, the outputs are useless.
+        Tuple of 3 Tensor, this operator will update the input parameters or tensors directly, the outputs are useless.
 
         - **var** (Tensor) - A Tensor with shape :math:`(N, *)`.
         - **accum** (Tensor) - A Tensor with shape :math:`(1, )`.
@@ -4151,9 +3980,10 @@ class FusedSparseProximalAdagrad(Primitive):
             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. The data type must be float32.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. The data type must be float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Variable tensor to be updated, has the same shape and data type as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Variable tensor to be updated, has the same shape and data type as
+          `var`.
         - **lr** (Tensor) - The learning rate value. The data type must be float32. The shape is :math:`(1, )`.
         - **l1** (Tensor) - l1 regularization strength. The data type must be float32. The shape is :math:`(1, )`.
         - **l2** (Tensor) - l2 regularization strength. The data type must be float32. The shape is :math:`(1, )`.
@@ -4163,7 +3993,7 @@ class FusedSparseProximalAdagrad(Primitive):
           The type must be int32 and indices.shape[0] = grad.shape[0].
 
     Outputs:
-        Tuple of 2 Tensors, this operator will update the input parameters directly, the outputs are useless.
+        Tuple of 2 Tensors, this operator will update the input parameters or tensors directly, the outputs are useless.
 
         - **var** (Tensor) - A Tensor with shape :math:`(N, *)`.
         - **accum** (Tensor) - A Tensor with shape :math:`(1, )`.
@@ -4254,7 +4084,7 @@ class KLDivLoss(Primitive):
           or ``'sum'``.
 
     Args:
-        reduction (str): Specifies the reduction to be applied to the output.
+        reduction (str, optional): Specifies the reduction to be applied to the output.
             Default: ``'mean'`` .
 
             - ``'none'``: no reduction will be applied.
@@ -4275,7 +4105,7 @@ class KLDivLoss(Primitive):
         TypeError: If neither `logits` nor `labels` is a Tensor.
         TypeError: If dtype of `logits` or `labels` is not currently supported.
         ValueError: If shape of `logits` is not the same as `labels`.
-        RuntimeError: If `logits` or `labels` is a scalar when `reduction` is 'batchmean'.
+        RuntimeError: If `logits` or `labels` is a scalar when `reduction` is ``'batchmean'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4342,11 +4172,11 @@ class ApplyAdaMax(Primitive):
     the relatively highest priority data type.
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. With float32 or float16 data type.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. With float32 or float16 data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **m** (Parameter) - The 1st moment vector in the updating formula, has the same shape as `var`.
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula, has the same shape as `var`.
           With float32 or float16 data type.
-        - **v** (Parameter) - The 2nd moment vector in the updating formula. Mean square gradients
+        - **v** (Union[Parameter, Tensor]) - The 2nd moment vector in the updating formula. Mean square gradients
           with the same shape as `var`. With float32 or float16 data type.
         - **beta1_power** (Union[Number, Tensor]) - :math:`beta_1^t` in the updating formula, must be a scalar.
           With float32 or float16 data type.
@@ -4362,7 +4192,7 @@ class ApplyAdaMax(Primitive):
           With float32 or float16 data type.
 
     Outputs:
-        Tuple of 3 Tensor, the updated parameters.
+        Tuple of 3 Tensor, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **m** (Tensor) - The same shape and data type as `m`.
@@ -4456,10 +4286,11 @@ class ApplyAdadelta(Primitive):
     the relatively highest priority data type.
 
     Inputs:
-        - **var** (Parameter) - Weights to be updated. With float32 or float16 data type.
+        - **var** (Union[Parameter, Tensor]) - Weights to be updated. With float32 or float16 data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Accumulation to be updated, has the same shape and data type as `var`.
-        - **accum_update** (Parameter) - Accum_update to be updated, has the same shape and data type as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated, has the same shape and data type as `var`.
+        - **accum_update** (Union[Parameter, Tensor]) - Accum_update to be updated, has the same shape and data type as
+          `var`.
         - **lr** (Union[Number, Tensor]) - Learning rate, must be a scalar. With float32 or float16 data type.
         - **rho** (Union[Number, Tensor]) - Decay rate, must be a scalar. With float32 or float16 data type.
         - **epsilon** (Union[Number, Tensor]) - A small value added for numerical stability, must be a scalar.
@@ -4467,7 +4298,7 @@ class ApplyAdadelta(Primitive):
         - **grad** (Tensor) - Gradients, has the same shape and data type as `var`.
 
     Outputs:
-        Tuple of 3 Tensor, the updated parameters.
+        Tuple of 3 Tensor, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -4558,14 +4389,14 @@ class ApplyAdagrad(Primitive):
         update_slots (bool): If ``True`` , `accum` will be updated. Default: ``True`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. With float or complex data type.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. With float or complex data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Accumulation to be updated. The shape must be the same as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated. The shape must be the same as `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be a scalar. With float or complex data type.
         - **grad** (Tensor) - A tensor for gradient. The shape must be the same as `var`.
 
     Outputs:
-        Tuple of 2 Tensors, the updated parameters.
+        Tuple of 2 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -4645,15 +4476,15 @@ class ApplyAdagradV2(Primitive):
         update_slots (bool): If ``True`` , `accum` will be updated. Default: ``True`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. With float16 or float32 data type.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. With float16 or float32 data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Accumulation to be updated. The shape must be the same as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated. The shape must be the same as `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be a float number or
           a scalar tensor with float16 or float32 data type.
         - **grad** (Tensor) - A tensor for gradient. The shape must be the same as `var`.
 
     Outputs:
-        Tuple of 2 Tensors, the updated parameters.
+        Tuple of 2 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -4751,14 +4582,15 @@ class SparseApplyAdagradV2(Primitive):
     Args:
         lr (float): Learning rate.
         epsilon (float): A small value added for numerical stability.
-        use_locking (bool): If ``True`` , the `var` and `accum` tensors will be protected from being updated.
+        use_locking (bool, optional): If ``True`` , the `var` and `accum` tensors will be protected from being updated.
             Default: ``False`` .
-        update_slots (bool): If ``True`` , the computation logic will be different to `False`. Default: ``True`` .
+        update_slots (bool, optional): If ``True`` , the computation logic will be different to `False`.
+            Default: ``True`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Accumulation to be updated. The shape must be the same as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated. The shape must be the same as `var`.
         - **grad** (Tensor) - Gradients has the same shape as `var` and
           :math:`grad.shape[1:] = var.shape[1:]` if var.shape > 1.
         - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
@@ -4766,7 +4598,7 @@ class SparseApplyAdagradV2(Primitive):
           must be unique. Otherwise, the result is unpredictable.
 
     Outputs:
-        Tuple of 2 tensors, the updated parameters.
+        Tuple of 2 tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -4842,13 +4674,14 @@ class ApplyProximalAdagrad(Primitive):
     the relatively highest priority data type.
 
     Args:
-        use_locking (bool): If ``True`` , the var and accumulation tensors will be protected from being updated.
-            Default: ``False`` .
+        use_locking (bool, optional): If ``True`` , the var and accumulation tensors will be protected
+            from being updated. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Accumulation to be updated, must have the same shape and dtype as `var`.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated, must have the same shape and dtype as
+          `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be a scalar. The data type must be
           float16 or float32.
         - **l1** (Union[Number, Tensor]) - l1 regularization strength, must be a scalar. The data type must be
@@ -4858,7 +4691,7 @@ class ApplyProximalAdagrad(Primitive):
         - **grad** (Tensor) - Gradient with the same shape and dtype as `var`.
 
     Outputs:
-        Tuple of 2 Tensors, the updated parameters.
+        Tuple of 2 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -4943,9 +4776,9 @@ class SparseApplyProximalAdagrad(Primitive):
             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - Variable tensor to be updated, has the same shape as `var`.
+        - **accum** (Parameterv) - Variable tensor to be updated, has the same shape as `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be a float number or
           a scalar tensor with float16 or float32 data type. It must be positive.
         - **l1** (Union[Number, Tensor]) - l1 regularization strength, must be a float number or
@@ -4959,7 +4792,7 @@ class SparseApplyProximalAdagrad(Primitive):
           following types: int32, int64 and :math:`indices.shape[0] = grad.shape[0]`.
 
     Outputs:
-        Tuple of 2 tensors, the updated parameters.
+        Tuple of 2 tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -5045,9 +4878,9 @@ class ApplyAddSign(Primitive):
     the relatively highest priority data type.
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **m** (Parameter) - Variable tensor to be updated, has the same data type as `var`.
+        - **m** (Union[Parameter, Tensor]) - Variable tensor to be updated, has the same data type as `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be a scalar.
         - **alpha** (Union[Number, Tensor]) - Must be a scalar.
         - **sign_decay** (Union[Number, Tensor]) - Must be a scalar.
@@ -5055,7 +4888,7 @@ class ApplyAddSign(Primitive):
         - **grad** (Tensor) - A tensor of the same shape as `var`, for the gradient.
 
     Outputs:
-        Tuple of 2 Tensors, the updated parameters.
+        Tuple of 2 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **m** (Tensor) - The same shape and data type as `m`.
@@ -5144,10 +4977,10 @@ class ApplyPowerSign(Primitive):
         On Ascend, input data type of float64 is currently not supported.
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. With float64, float32 or float16 data type.
-          If data type of `var` is float16, all inputs must have the same data type as `var`.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. With float64, float32 or float16 data
+          type. If data type of `var` is float16, all inputs must have the same data type as `var`.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **m** (Parameter) - Variable tensor to be updated, has the same shape as `var`.
+        - **m** (Union[Parameter, Tensor]) - Variable tensor to be updated, has the same shape as `var`.
         - **lr** (Union[Number, Tensor]) - The learning rate value, should be a scalar or Tensor
           with float64, float32 or float16 data type.
         - **logbase** (Union[Number, Tensor]) - Should be a scalar or Tensor with float64, float32 or float16 data type.
@@ -5158,7 +4991,7 @@ class ApplyPowerSign(Primitive):
         - **grad** (Tensor) - A tensor of the same shape as `var`, for the gradient.
 
     Outputs:
-        Tuple of 2 Tensors, the updated parameters.
+        Tuple of 2 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **m** (Tensor) - The same shape and data type as `m`.
@@ -5235,7 +5068,7 @@ class ApplyGradientDescent(Primitive):
     the relatively highest priority data type.
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. With float32 or float16 data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         - **alpha** (Union[Number, Tensor]) - Scaling factor, must be a scalar. With float32 or float16 data type.
         - **delta** (Tensor) - A tensor for the change, has the same shape as `var`.
@@ -5304,7 +5137,7 @@ class ApplyProximalGradientDescent(Primitive):
     the relatively highest priority data type.
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. With float32 or float16 data type.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         - **alpha** (Union[Number, Tensor]) - Scaling factor, must be a scalar. With float32 or float16 data type.
         - **l1** (Union[Number, Tensor]) - l1 regularization strength, must be a scalar.
@@ -5448,10 +5281,10 @@ class ApplyFtrl(Primitive):
         use_locking (bool): Use locks for updating operation if ``True`` . Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - The variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - The variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - The accumulation to be updated, must be same shape as `var`.
-        - **linear** (Parameter) - The linear coefficient to be updated, must be same shape as `var`.
+        - **accum** (Union[Parameter, Tensor]) - The accumulation to be updated, must be same shape as `var`.
+        - **linear** (Union[Parameter, Tensor]) - The linear coefficient to be updated, must be same shape as `var`.
         - **grad** (Tensor) - Gradient. The data type must be float16 or float32.
         - **lr** (Union[Number, Tensor]) - The learning rate value, must be positive. Default: ``0.001`` .
           It must be a float number or a scalar tensor with float16 or float32 data type.
@@ -5464,16 +5297,16 @@ class ApplyFtrl(Primitive):
           Default: ``-0.5`` . It must be a float number or a scalar tensor with float16 or float32 data type.
 
     Outputs:
-        - **var** (Tensor) - Represents the updated `var`. As the input parameters has been updated in-place, this
-          value is always zero when the platform is GPU.
+        - **var** (Tensor) - Represents the updated `var`. As the input parameters or tensors has been updated in-place,
+          this value is always zero when the platform is GPU.
 
     Raises:
         TypeError: If `use_locking` is not a bool.
         TypeError: If dtype of `var`, `grad`, `lr`, `l1`, `l2` or `lr_power` is neither float16 nor float32.
         TypeError: If `lr`, `l1`, `l2` or `lr_power` is neither a Number nor a Tensor.
         TypeError: If `grad` is not a Tensor.
-        TypeError: If the parameter types of `var`, `accum` and `linear` are inconsistent.
-        TypeError: If the parameter types of `grad`, `lr`, `l1`, `l2`, `lr_power` are inconsistent with `var`
+        TypeError: If the parameter or tensor types of `var`, `accum` and `linear` are inconsistent.
+        TypeError: If the parameter or tensor types of `grad`, `lr`, `l1`, `l2`, `lr_power` are inconsistent with `var`
             and the precision is greater than `var`.
 
     Supported Platforms:
@@ -5548,10 +5381,10 @@ class SparseApplyFtrl(Primitive):
         use_locking (bool, optional): Use locks for updating operation if ``True`` . Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - The variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - The variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **accum** (Parameter) - The accumulation to be updated, must be same shape as `var`.
-        - **linear** (Parameter) - The linear coefficient to be updated, must be the same shape as `var`.
+        - **accum** (Union[Parameter, Tensor]) - The accumulation to be updated, must be same shape as `var`.
+        - **linear** (Union[Parameter, Tensor]) - The linear coefficient to be updated, must be the same shape as `var`.
         - **grad** (Tensor) - A tensor must meet with :math:`grad.shape[1:] = var.shape[1:]`
           if var.shape > 1.
         - **indices** (Tensor) - A tensor of indices in the first dimension of `var` and `accum`.
@@ -5739,7 +5572,7 @@ class Dropout3D(PrimitiveWithInfer):
     Dropout3D can improve the independence between channel feature maps.
 
     Args:
-        keep_prob (float): The keep probability of a channel, between 0 and 1, e.g. `keep_prob` = 0.8,
+        keep_prob (float, optional): The keep probability of a channel, between 0 and 1, e.g. `keep_prob` = 0.8,
             means dropping out 20% of channels. Default: ``0.5`` .
 
     Inputs:
@@ -5791,12 +5624,14 @@ class CTCLoss(Primitive):
     such that the length of target series must be less than or equal to the length of input.
 
     Args:
-        preprocess_collapse_repeated (bool): If ``True`` , repeated labels will be collapsed prior to the CTC
+        preprocess_collapse_repeated (bool, optional): If ``True`` , repeated labels will be collapsed prior to the CTC
                                              calculation. Default: ``False`` .
-        ctc_merge_repeated (bool): If ``False`` , during CTC calculation, repeated non-blank labels will not be merged
+        ctc_merge_repeated (bool, optional): If ``False`` , during CTC calculation,
+                                   repeated non-blank labels will not be merged
                                    and these labels will be interpreted as individual ones. This is a simplified
                                    version of CTC. Default: ``True`` .
-        ignore_longer_outputs_than_inputs (bool): If ``True`` , sequences with longer outputs than inputs will be
+        ignore_longer_outputs_than_inputs (bool, optional): If ``True`` ,
+                                                  sequences with longer outputs than inputs will be
                                                   ignored. Default: ``False`` .
 
     Inputs:
@@ -6370,10 +6205,7 @@ class AvgPool3D(Primitive):
 
     Typically the input is of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`, AvgPool3D outputs
     regional average in the :math:`(D_{in}, H_{in}, W_{in})`-dimension. Given kernel size
-    :math:`ks = (d_{ker}, h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1, s_2)`, the operation is as follows.
-
-    .. warning::
-        "kernel_size" is in the range [1, 255]. "strides" is in the range [1, 63].
+    :math:`ks = (d_{ker}, h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1, s_2)`, the operation is as follows:
 
     .. math::
         \text{output}(N_i, C_j, d, h, w) =
@@ -6384,12 +6216,13 @@ class AvgPool3D(Primitive):
         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,
+        kernel_size (Union[int, tuple[int]], optional): 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
-            of three int numbers that represent depth, height and width respectively. Default: ``1`` .
-        strides (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
+            of three int numbers that represent depth, height and width respectively.
+            Default: ``1`` . The value range is: [1, 255].
+        strides (Union[int, tuple[int]], optional): The distance of kernel moving, an int number that represents
             the depth, height and width of movement are both strides, or a tuple of three int numbers that
-            represent depth, height and width of movement respectively. Default: ``1`` .
+            represent depth, height and width of movement respectively. Default: ``1`` . The value range is: [1, 63].
         pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
 
@@ -6406,16 +6239,18 @@ class AvgPool3D(Primitive):
               in the depth, height and width dimension is determined by the `pad` parameter.
               If this mode is set, `pad` must be greater than or equal to 0.
 
-        pad (Union(int, tuple[int], list[int])): The pad value to be filled. Default: ``0`` . If `pad` is an integer,
+        pad (Union(int, tuple[int], list[int]), optional): The pad value to be filled. Default: ``0`` .
+            If `pad` is an integer,
             the paddings of head, tail, top, bottom, left and right are the same, equal to pad.
             If `pad` is a tuple of six integers, the padding of head, tail, top, bottom, left and right equal to
             pad[0], pad[1], pad[2], pad[3], pad[4] and pad[5] correspondingly.
-        ceil_mode (bool): If ``True`` , ceil instead of floor to compute the output shape. Default: ``False`` .
-        count_include_pad (bool): If ``True`` , averaging calculation will include the zero-padding.
+        ceil_mode (bool, optional): If ``True`` , ceil instead of floor to compute the output shape.
+            Default: ``False`` .
+        count_include_pad (bool, optional): If ``True`` , averaging calculation will include the zero-padding.
             Default: ``True`` .
-        divisor_override (int): If specified, it will be used as divisor in the averaging calculation,
+        divisor_override (int, optional): If specified, it will be used as divisor in the averaging calculation,
             otherwise kernel_size will be used. Default: ``0`` .
-        data_format (str) : The optional value for data format. Currently only support ``'NCDHW'`` .
+        data_format (str, optional): The optional value for data format. Currently only support ``'NCDHW'`` .
             Default: ``'NCDHW'`` .
 
     Inputs:
@@ -6599,39 +6434,8 @@ class Conv3D(Primitive):
 
     Outputs:
         Tensor, the value that applied 3D convolution. The shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
-
-        `pad_mode` is ``"same"``:
-
-        .. math::
-            \begin{array}{ll} \\
-                D_{out} = \left \lceil{\frac{D_{in}}{\text{stride[0]}}} \right \rceil \\
-                H_{out} = \left \lceil{\frac{H_{in}}{\text{stride[1]}}} \right \rceil \\
-                W_{out} = \left \lceil{\frac{W_{in}}{\text{stride[2]}}} \right \rceil \\
-            \end{array}
-
-        `pad_mode` is ``"valid"``:
-
-        .. math::
-            \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
-                {\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
-                {\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[2]} \times (\text{kernel_size[2]} - 1) }
-                {\text{stride[2]}} + 1} \right \rfloor \\
-            \end{array}
-
-        `pad_mode` is ``"pad"``:
-
-        .. math::
-            \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} + pad[0] + pad[1] - (\text{dilation[0]} - 1) \times
-                \text{kernel_size[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} + pad[2] + pad[3] - (\text{dilation[1]} - 1) \times
-                \text{kernel_size[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} + pad[4] + pad[5] - (\text{dilation[2]} - 1) \times
-                \text{kernel_size[2]} - 1 }{\text{stride[2]}} + 1} \right \rfloor \\
-            \end{array}
+        To see how different pad modes affect the output shape, please refer to
+        :class:`mindspore.nn.Conv3d` for more details.
 
     Raises:
         TypeError: If `out_channel` or `group` is not an int.
@@ -6908,7 +6712,7 @@ class SparseApplyAdadelta(Primitive):
     to make the data types consistent. Besides, inputs of 'lr' and 'rho' also support implicit type conversion.
     If they have different data types, the lower priority data type will be converted to
     relatively highest priority data type.
-    RuntimeError exception will be thrown when the data type conversion of Parameter is required.
+    RuntimeError exception will be thrown when the data type conversion of Parameter or Tensor is required.
 
     Note:
         If there are negative values or values greater than or equal to var.shape[0] in `indices`,
@@ -6920,11 +6724,11 @@ class SparseApplyAdadelta(Primitive):
             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Weights to be updated. With float32 or float16 data type.
-        - **accum** (Parameter) - Accumulation to be updated. Mush have the same shape and dtype as `var`.
-          With float32 or float16 data type.
-        - **accum_update** (Parameter) - Accum_update to be updated. Must have the same shape and dtype as `var`.
-          With float32 or float16 data type.
+        - **var** (Union[Parameter, Tensor]) - Weights to be updated. With float32 or float16 data type.
+        - **accum** (Union[Parameter, Tensor]) - Accumulation to be updated. Mush have the same shape and dtype as
+          `var`. With float32 or float16 data type.
+        - **accum_update** (Union[Parameter, Tensor]) - Accum_update to be updated. Must have the same shape and dtype
+          as `var`. With float32 or float16 data type.
         - **lr** (Union[float, Tensor]) - Learning rate, must be a scalar. With float32 or float16 data type.
         - **rho** (Union[float, Tensor]) - Decay rate, must be a scalar. With float32 or float16 data type.
         - **grad** (Tensor) - A tensor for gradient. Must have the same shape and dtype as `var`.
@@ -6932,7 +6736,7 @@ class SparseApplyAdadelta(Primitive):
           Must be one of the following types: int32, int64 and indices.shape[0] = grad.shape[0].
 
     Outputs:
-        Tuple of 3 Tensor, the updated parameters.
+        Tuple of 3 Tensor, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **accum** (Tensor) - The same shape and data type as `accum`.
@@ -7020,9 +6824,9 @@ class CTCLossV2(Primitive):
             and its correlated gradient to zero. Default: ``False`` .
 
     Inputs:
-        - **log_probs** (Tensor) - A tensor of shape :math:`(T, N, C)`, where :math:`T` is input length, :math:`N` is
+        - **log_probs** (Tensor) - A 3D tensor of shape :math:`(T, N, C)`, where :math:`T` is input length, :math:`N` is
           batch size and :math:`C` is number of classes (including blank). Supported dtypes: float32, float64.
-        - **targets** (Tensor) - A tensor of shape :math:`(N, S)`, where :math:`S` is max target length,
+        - **targets** (Tensor) - A 2D tensor of shape :math:`(N, S)`, where :math:`S` is max target length,
           means the target sequences. Supported dtypes: int32, int64.
         - **input_lengths** (Union(Tuple, Tensor)) - A tuple or Tensor of shape :math:`(N)`.
           It means the lengths of the input. Supported dtypes: int32, int64.
@@ -7093,7 +6897,7 @@ class CTCLossV2Grad(Primitive):
 
     Args:
         blank (int): The blank label. Default: ``0`` .
-        reduction (string): Apply specific reduction method to the output. Currently only support 'none'.
+        reduction (str): Apply specific reduction method to the output. Currently only support 'none'.
             Default: ``"none"`` .
         zero_infinity (bool): Whether to set infinite loss and correlation gradient to zero. Default: ``False`` .
 
@@ -7209,12 +7013,15 @@ class Conv3DTranspose(Primitive):
     Inputs:
         - **dout** (Tensor) - The gradients with respect to the output of the convolution.
           The shape conforms to the default.
-          data_format :math:`(N, C_{in}, D_{out}, H_{out}, W_{out})`. Currently dout data type only supports float16
-          and float32.
+          data_format :math:`(N, C_{in}, D_{out}, H_{out}, W_{out})`.
+          Supported dtypes:
+
+          - Ascend: float16.
+          - GPU/CPU: float16, float32.
         - **weight** (Tensor) - Set size of kernel is :math:`(K_d, K_h, K_w)`, then the shape is
           :math:`(C_{in}, C_{out}//group, K_d, K_h, K_w)`. Where :math:`group` is the Args parameter,
           :math:`//` is the symbol for integer division.
-          Currently weight data type only supports float16 and float32.
+          It has the same dtype as `dout`.
         - **bias** (Tensor) - Tensor of shape :math:`C_{out}`. Currently, only support none. Default: ``None`` .
 
     Outputs:
@@ -7500,12 +7307,12 @@ class ApplyAdagradDA(Primitive):
                             Otherwise the behavior is undefined, but may exhibit less contention. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **gradient_accumulator** (Parameter) - The dict of mutable tensor :math:`grad\_accum`. Must have the same
-          shape as `var`.
-        - **gradient_squared_accumulator** (Parameter) - The dict of mutable tensor :math:`grad\_squared\_accum`.
+        - **gradient_accumulator** (Union[Parameter, Tensor]) - The dict of mutable tensor :math:`grad\_accum`.
           Must have the same shape as `var`.
+        - **gradient_squared_accumulator** (Union[Parameter, Tensor]) - The dict of mutable tensor
+          :math:`grad\_squared\_accum`. Must have the same shape as `var`.
         - **grad** (Tensor) - A tensor for gradient. Must have the same shape as `var`.
         - **lr** ([Number, Tensor]) - Scaling factor. Must be a scalar. With float32 or float16 data type.
         - **l1** ([Number, Tensor]) -  L1 regularization. Must be a scalar. With float32 or float16 data type.
@@ -7513,12 +7320,12 @@ class ApplyAdagradDA(Primitive):
         - **global_step** ([Number, Tensor]) - Training step number. Must be a scalar. With int32 or int64 data type.
 
     Outputs:
-        Tuple of 1 Tensors, the updated parameters.
+        Tuple of 1 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
 
     Raises:
-        TypeError: If `var`, `gradient_accumulator` or `gradient_squared_accumulator` is not a Parameter.
+        TypeError: If `var`, `gradient_accumulator` or `gradient_squared_accumulator` neither a Parameter nor a Tensor.
         TypeError: If `grad` is not a Tensor.
         TypeError: If `lr`, `l1`, `l2` or `global_step` is neither a Number nor a Tensor.
         TypeError: If use_locking is not a bool.
@@ -7564,9 +7371,8 @@ class ApplyAdagradDA(Primitive):
         >>> global_step = Tensor(2, mstype.int32)
         >>> output = net(grad, lr, l1, l2, global_step)
         >>> print(output)
-        (Tensor(shape=[2, 2], dtype=Float32, value=
-        [[-7.39064650e-04, -1.36888528e-03],
-         [-5.96988888e-04, -1.42478070e-03]]))
+        [[-0.00073906, -0.00136889],
+         [-0.00059699, -0.00142478]]
     """
 
     __mindspore_signature__ = (
@@ -7612,10 +7418,12 @@ class SparseApplyRMSProp(Primitive):
                             otherwise the behavior is undefined, but may exhibit less contention. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type must be float16 or float32.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **ms** (Parameter) - The dict of mutable tensor ms. Must have the same shape and dtype as `var`.
-        - **mom** (Parameter) - The dict of mutable tensor mom. Must have the same shape and dtype as `var`.
+        - **ms** (Union[Parameter, Tensor]) - The dict of mutable tensor ms. Must have the same shape and dtype as
+          `var`.
+        - **mom** (Union[Parameter, Tensor]) - The dict of mutable tensor mom. Must have the same shape and dtype as
+          `var`.
         - **lr** ([Number, Tensor]) - Learning rate. Must be a scalar. With float16 or float32 data type.
         - **grad** (Tensor) - A tensor for gradient. Must have the same shape and dtype as `var`.
         - **indices** (Tensor) - A tensor of indices in the first dimension of `var`, `ms` and `mom`.
@@ -7623,7 +7431,7 @@ class SparseApplyRMSProp(Primitive):
           following types: int32, int64 and indices.shape[0] = var.shape[0].
 
     Outputs:
-        Tuple of 3 Tensors, the updated parameters.
+        Tuple of 3 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) -  The same shape and data type as `var`.
         - **ms** (Tensor) - The same shape and data type as `ms`.
@@ -7729,12 +7537,12 @@ class SparseApplyCenteredRMSProp(Primitive):
                             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. The data type must be int8, int16, int32, int64,
-          uint8, uint16, uint32, uint64, float16, float32 or float64.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. The data type must be int8, int16, int32,
+          int64, uint8, uint16, uint32, uint64, float16, float32 or float64.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **mg** (Parameter) - Mean gradients. Must have the same shape and dtype as `var`.
-        - **ms** (Parameter) - Mean square gradients. Must have the same shape and dtype as `var`.
-        - **mom** (Parameter) - Delta of `var`. Must have the same shape and dtype as `var`.
+        - **mg** (Union[Parameter, Tensor]) - Mean gradients. Must have the same shape and dtype as `var`.
+        - **ms** (Union[Parameter, Tensor]) - Mean square gradients. Must have the same shape and dtype as `var`.
+        - **mom** (Union[Parameter, Tensor]) - Delta of `var`. Must have the same shape and dtype as `var`.
         - **lr** (Union[Number, Tensor]) - Learning rate. Must be a float number or a scalar tensor.
           Must have the same type as `var`.
         - **rho** (Union[Number, Tensor]) - Decay rate. Must be a float number or a scalar tensor.
@@ -7837,8 +7645,9 @@ class ApplyKerasMomentum(Primitive):
                             so in the end, the var you get is actually var + momentum * accum. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. With float16 or float32 data type.
-        - **accum** (Parameter) - Must have the same shape and type as `var`. With float16 or float32 data type.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. With float16 or float32 data type.
+        - **accum** (Union[Parameter, Tensor]) - Must have the same shape and type as `var`. With float16 or float32
+          data type.
         - **lr** (Union[Number, Tensor]) - Scaling factor. Must be a scalar. With float16 or float32 data type.
         - **grad** (Tensor) - The gradient. Must have the same shape and type as `var`.
           With float16 or float32 data type.
@@ -7989,12 +7798,12 @@ class ApplyAdamWithAmsgrad(Primitive):
           Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type can be float16 or float32.
-        - **m** (Parameter) - The 1st moment vector in the updating formula,
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type can be float16 or float32.
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula,
           the shape and data type value should be the same as `var`.
-        - **v** (Parameter) - the 2nd moment vector in the updating formula,
+        - **v** (Union[Parameter, Tensor]) - the 2nd moment vector in the updating formula,
           the shape and data type value should be the same as `var`.
-        - **vhat** (Parameter) - :math:`\hat v_t` in the updating formula,
+        - **vhat** (Union[Parameter, Tensor]) - :math:`\hat v_t` in the updating formula,
           the shape and data type value should be the same as `var`.
         - **beta1_power** (Union[float, Tensor]) - :math:`beta_1^t(\beta_1^{t})` in the updating formula,
           a scalar tensor with float16 or float32 data type.
@@ -8004,7 +7813,7 @@ class ApplyAdamWithAmsgrad(Primitive):
         - **grad** (Tensor) - The gradient, has the same shape and data type as `var`.
 
     Outputs:
-        Tuple of 4 Tensors, the updated parameters.
+        Tuple of 4 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **m** (Tensor) - The same shape and data type as `m`.
@@ -8012,7 +7821,7 @@ class ApplyAdamWithAmsgrad(Primitive):
         - **vhat** (Tensor) - The same shape and data type as `vhat`.
 
     Raises:
-        TypeError: If `var`, `m`, `v`, `vhat` is not a Parameter.
+        TypeError: If `var`, `m`, `v`, `vhat` neither a Parameter nor a Tensor.
         TypeError: If `beta1_power`, `beta2_power`, `lr` is neither a Number nor a Tensor.
         TypeError: If `grad` is not a Tensor.
         TypeError: If dtype of `var`, `m`, `v`, `vhat`, `beta1_power`, `beta2_power`,
@@ -8092,16 +7901,16 @@ class ApplyAdamWithAmsgradV2(Primitive):
 
     Args:
         use_locking (bool): If ``True`` , updating of the `var`, `m`, and `v` tensors will
-            be protected by a lock; Otherwise the behavior is undefined, but may exhibit less contention.
+            be protected by a lock; Otherwise some contention may occur.
             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated. The data type can be float16, float32 or float64.
-        - **m** (Parameter) - The 1st moment vector in the updating formula,
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated. The data type can be float16, float32 or float64.
+        - **m** (Union[Parameter, Tensor]) - The 1st moment vector in the updating formula,
           the shape should be the same as `var`.
-        - **v** (Parameter) - The 2nd moment vector in the updating formula,
+        - **v** (Union[Parameter, Tensor]) - The 2nd moment vector in the updating formula,
           the shape should be the same as `var`.
-        - **vhat** (Parameter) - :math:`\hat v_t` in the updating formula,
+        - **vhat** (Union[Parameter, Tensor]) - :math:`\hat v_t` in the updating formula,
           the shape and data type value should be the same as `var`.
         - **beta1_power** (Union[float, Tensor]) - :math:`beta_1^t(\beta_1^{t})` in the updating formula,
           with float16, float32 or float64 data type.
@@ -8117,7 +7926,7 @@ class ApplyAdamWithAmsgradV2(Primitive):
         - **grad** (Tensor) - The gradient, has the same shape as `var`.
 
     Outputs:
-        Tuple of 4 Tensors, the updated parameters.
+        Tuple of 4 Tensors, the updated parameters or tensors.
 
         - **var** (Tensor) - The same shape and data type as `var`.
         - **m** (Tensor) - The same shape and data type as `m`.
@@ -8125,7 +7934,7 @@ class ApplyAdamWithAmsgradV2(Primitive):
         - **vhat** (Tensor) - The same shape and data type as `vhat`.
 
     Raises:
-        TypeError: If `var`, `m`, `v`, `vhat` is not a Parameter.
+        TypeError: If `var`, `m`, `v`, `vhat` neither a Parameter nor a Tensor.
         TypeError: If dtype of `var`, `m`, `v`, `vhat`, `beta1_power`, `beta2_power`,
             `lr`, `beta1` , `beta2` , `epsilon` or `grad` is not float64, float32 or float16.
         RuntimeError: If the data type of `var`, `m`, `v` , `vhat` and `grad` conversion of Parameter is not supported.
@@ -8640,13 +8449,13 @@ class TripletMarginLoss(Primitive):
         - **margin** (Tensor) - Make a margin between the positive pair and the negative pair.
 
     Outputs:
-        Union[Tensor, Scalar], if `reduction` is ``"none"``, its shape is :math:`(N)`.
+        Union[Tensor, Scalar], if `reduction` is ``"none"``, a Ten sor will be returned with a shape of :math:`(N)`.
         Otherwise, a scalar value will be returned.
 
     Raises:
-        TypeError: If `x` or `positive` or `negative` or `margin` is not a Tensor.
-        TypeError: If dtype of `x` or `positive` or `negative` is not BasicType.
-        TypeError: If dtype of `x`, `positive` and `negative` is not the same.
+        TypeError: If `x`, `positive`, `negative`, or `margin` is not a Tensor.
+        TypeError: If dtype of `x`, `positive`, or `negative` is not BasicType.
+        TypeError: If dtypes of `x`, `positive` and `negative` are not the same.
         TypeError: If `margin` is not float32.
         TypeError: If `p` is not an int.
         TypeError: If `eps` is not a float.
@@ -8656,7 +8465,7 @@ class TripletMarginLoss(Primitive):
         ValueError: If the dimension of input `x` or `positive` or `negative`
           is bigger than or equal to 8.
         ValueError: If length of shape of `margin` is not 0.
-        ValueError: If shape of `x`, `positive` and `negative` cannot broadcast.
+        ValueError: If shapes of `x`, `positive` and `negative` cannot broadcast.
         ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
@@ -8805,11 +8614,11 @@ class SparseApplyAdagradDA(Primitive):
                             Otherwise the behavior is undefined, but may exhibit less contention. Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable to be updated.
+        - **var** (Union[Parameter, Tensor]) - Variable to be updated.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **grad_accum** (Parameter) - The dict of mutable tensor grad_accum. Must have the same
+        - **grad_accum** (Union[Parameter, Tensor]) - The dict of mutable tensor grad_accum. Must have the same
           shape and dtype as `var`.
-        - **grad_square_accum** (Parameter) - The dict of mutable tensor grad_square_accum.
+        - **grad_square_accum** (Union[Parameter, Tensor]) - The dict of mutable tensor grad_square_accum.
           Must have the same shape and dtype as `var`.
         - **grad** (Tensor) - A tensor of the same type as `var` and grad.shape[1:] = var.shape[1:] if rank(var) > 1.
         - **indices** (Tensor) - A tensor of indices in the first dimension of `var` and `accum`.
@@ -8987,8 +8796,8 @@ class SparseApplyProximalGradientDescent(Primitive):
             Default: ``False`` .
 
     Inputs:
-        - **var** (Parameter) - Variable tensor to be updated. The data type must be int8, int16, int32, int64,
-          uint8, uint16, uint32, uint64, float16, float32 or float64.
+        - **var** (Union[Parameter, Tensor]) - Variable tensor to be updated. The data type must be int8, int16, int32,
+          int64, uint8, uint16, uint32, uint64, float16, float32 or float64.
           The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         - **alpha** (Union[Number, Tensor]) - Scaling factor. Must be a scalar with same type as `var`.
         - **l1** (Union[Number, Tensor]) - L1 regularization. Must be a scalar with same type as `var`.
@@ -9003,7 +8812,7 @@ class SparseApplyProximalGradientDescent(Primitive):
         - **var** (Tensor) - Tensor, has the same shape and type as 'var'.
 
     Raises:
-        TypeError: If `var`, `grad` or `indices` is not a Parameter..
+        TypeError: If `var` neither a Parameter nor a Tensor.
         TypeError: If `alpha`, `l1`, `l2` is neither a Number nor a Tensor.
         TypeError: If `use_locking` is not a bool.
         TypeError: If dtype of `var`, `alpha`, `l1`, `l2` or `grad` is not one of int8, int16,
@@ -9139,51 +8948,6 @@ class NuclearNorm(Primitive):
         validator.check_value_type("keepdim", keepdim, [bool], self.name)
 
 
-class GLU(Primitive):
-    r"""
-    Computes GLU (Gated Linear Unit activation function) of input tensors.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.glu` for more details.
-
-    Args:
-        axis (int, optional): Axis on which to split the input.
-            The value of `axis` must be an int within range [-rank(`x`), rank(`x`)).
-            Default: ``-1`` , specifying the last dimension.
-
-    Inputs:
-        - **x** (Tensor) - Input tensor. `x.shape[axis]` must be even.
-
-    Outputs:
-        Tensor, has the same data type with `x`.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> from mindspore import ops, Tensor
-        >>> from mindspore import dtype as mstype
-        >>> import numpy as np
-        >>> axis = 0
-        >>> x = Tensor(np.array([0.3220, 0.9545, 0.7879, 0.0975, 0.3698,
-        ...                            0.5135, 0.5740, 0.3435, 0.1895, 0.8764,
-        ...                            0.4980, 0.9673, 0.9879, 0.6988, 0.9022,
-        ...                            0.9304, 0.1558, 0.0153, 0.1559, 0.9852]).reshape([2, 2, 5]), mstype.float32)
-        >>> glu = ops.GLU(axis=axis)
-        >>> y = glu(x)
-        >>> print(y)
-        [[[0.20028052 0.6916126  0.57412136 0.06512236 0.26307625]
-          [0.3682598  0.3093122  0.17306386 0.10212085 0.63814086]]]
-    """
-
-    @prim_attr_register
-    def __init__(self, axis=-1):
-        """Initialize GLU"""
-        validator.check_value_type("axis", axis, [int], self.name)
-
-
 class FractionalMaxPoolWithFixedKsize(Primitive):
     r"""
     Applies a 2D fractional max pooling to an input signal composed of multiple input planes.
@@ -9267,7 +9031,8 @@ class FractionalMaxPoolWithFixedKsize(Primitive):
 class ChannelShuffle(Primitive):
     r"""
     Divide the channels in a tensor of shape :math:`(*, C, H, W)` into :math:`g` group and
-    rearrange them as :math:`(*, \frac C g, g, H*W)`, while keeping the original tensor shapes.
+    rearrange them as :math:`(*, \frac{C}{g}, g, H*W)`, while retaining the original tensor
+    shape in the final output.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -9475,93 +9240,6 @@ class WKV(Primitive):
                                 outputs=["output", "out_sp", "out_sq", "out_sm"])
 
 
-class PromptFlashAttention(Primitive):
-    r"""
-    The interface for fully inference.
-    B -- Batch size
-    S -- Sequence length
-    H -- Hidden size
-
-    Note:
-    experiment ops
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        num_heads (int): The number of heads.
-        scale_value (float): The scale value indicating the scale coefficient, which is used as the scalar of
-          Muls in the calculation. Default: 1.0.
-        pre_tokens (int): Previous tokens. Default: 2147483547.
-        next_tokens (int): next tokens.  Default: 0.
-          indicate the upper triangle, Indicate the number of data blocks involved in the calculation. The value 0
-          indicates that the data blocks in the upper triangle are not involved in the calculation
-        input_layout (str): the data layout of the input qkv, support `(BSH)` and `(BNSD)`, Default `BSH`.
-        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.
-        sparse_mode (int): Default: 0
-        inner_precise (int): 0, float16 high precision. 1, high performance. default 1
-
-    Inputs:
-        - **query** (Tensor) - The query tensor with data type of float16 or float32.
-          Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
-        - **key** (Tensor) - The key tensor with data type of float16 or float32.
-          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)`.
-        - **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** (Tensor): Describe actual sequence length of each input with data type of int64.
-        - **actual_seq_lengths_kv** (Tensor): Describe actual sequence length of each input with data type of int64.
-        - **pse_shift** (Tensor) - The position encoding tensor with data type of float16 or float32.
-        - **dep_scale1** (Tensor)
-        - **quant_scale1** (Tensor)
-        - **deq_scale2** (Tensor)
-        - **quant_scale2** (Tensor)
-        - **quant_offset2** (Tensor)
-
-    Outputs:
-        - **attention_out** (Tensor) - Input tensor of shape :math:`(B, S, H)` / `(B, N, S, D)`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore.ops.operations.nn_ops as P
-        >>> from mindspore import Tensor
-        >>> import numpy as np
-        >>> B = 1
-        >>> N = 16
-        >>> S = 256
-        >>> D = 16
-        >>> query = Tensor(np.ones((B, N, S, D), dtype=np.float16))
-        >>> key = Tensor(np.ones((B, N, S, D), dtype=np.float16))
-        >>> value = Tensor(np.ones((B, N, S, D), dtype=np.float16))
-        >>> attn_mask = Tensor(np.ones((B, 1, S, S), dtype=np.float16))
-        >>> pfa = P.PromptFlashAttention(N, input_layout='BNSD')
-        >>> out = pfa(query, key, value, attn_mask, None, None, None, None, None, None, None, None)
-        >>> print(out.shape)
-        (1, 16, 256, 16)
-    """
-
-    @prim_attr_register
-    def __init__(self, num_heads, scale_value=1.0, pre_tokens=214748647, next_tokens=0, input_layout='BSH',
-                 num_key_value_heads=0, sparse_mode=0, inner_precise=1):
-        """Initialize PromptFlashAttention."""
-        validator.check_value_type('num_heads', num_heads, [int], self.name)
-        validator.check_value_type('scale_value', scale_value, [float], self.name)
-        validator.check_value_type('pre_tokens', pre_tokens, [int], self.name)
-        validator.check_value_type('next_tokens', next_tokens, [int], self.name)
-        validator.check_value_type('input_layout', input_layout, [str], self.name)
-        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)
-        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",
-                                        "actual_seq_lengths_kv", "pse_shift", "deq_scale1", "quant_scale1",
-                                        "deq_scale2", "quant_scale2", "quant_offset2"],
-                                outputs=["attention_out"])
-
-
 class AllFinite(Primitive):
     r"""
     Check all gradients is finite.
@@ -9578,3 +9256,6 @@ class AllFinite(Primitive):
                 raise RuntimeError(
                     "The version of Ascend AI software package installed "
                     "in the current environment does not support AllFinite.")
+
+    def __call__(self, *args):
+        return _convert_stub(pyboost_all_finite(self, args))