mindspore 2.3.0rc1__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/auto_generate/gen_ops_prim.py

@@ -24,52 +24,163 @@ from mindspore.ops.auto_generate.gen_arg_dtype_cast import type_it
 from mindspore.ops.auto_generate.gen_arg_handler import *
 from mindspore._c_expression import OpDtype
 from mindspore.common._stub_tensor import _convert_stub
+from mindspore._c_expression import pyboost_abs
+from mindspore._c_expression import pyboost_adam_weight_decay_ext
 from mindspore._c_expression import pyboost_add_ext
+from mindspore._c_expression import pyboost_arange
+from mindspore._c_expression import pyboost_argmax_ext
 from mindspore._c_expression import pyboost_argmax_with_value
 from mindspore._c_expression import pyboost_argmin_with_value
+from mindspore._c_expression import pyboost_avg_pool2d_grad
+from mindspore._c_expression import pyboost_avg_pool2d
+from mindspore._c_expression import pyboost_batch_mat_mul
+from mindspore._c_expression import pyboost_batch_norm_ext
+from mindspore._c_expression import pyboost_batch_norm_grad_ext
+from mindspore._c_expression import pyboost_bmm_ext
 from mindspore._c_expression import pyboost_broadcast_to
 from mindspore._c_expression import pyboost_cast
 from mindspore._c_expression import pyboost_ceil
+from mindspore._c_expression import pyboost_chunk
+from mindspore._c_expression import pyboost_clamp_scalar
+from mindspore._c_expression import pyboost_clamp_tensor
 from mindspore._c_expression import pyboost_concat
+from mindspore._c_expression import pyboost_constant_pad_nd
 from mindspore._c_expression import pyboost_contiguous
+from mindspore._c_expression import pyboost_convolution_grad
+from mindspore._c_expression import pyboost_convolution
 from mindspore._c_expression import pyboost_copy
 from mindspore._c_expression import pyboost_cos
+from mindspore._c_expression import pyboost_dense
 from mindspore._c_expression import pyboost_div
+from mindspore._c_expression import pyboost_divmod
+from mindspore._c_expression import pyboost_dot
+from mindspore._c_expression import pyboost_dropout_do_mask_ext
+from mindspore._c_expression import pyboost_dropout_ext
+from mindspore._c_expression import pyboost_dropout_gen_mask_ext
+from mindspore._c_expression import pyboost_dropout_grad_ext
+from mindspore._c_expression import pyboost_embedding_dense_backward
+from mindspore._c_expression import pyboost_embedding
 from mindspore._c_expression import pyboost_equal
+from mindspore._c_expression import pyboost_erf
 from mindspore._c_expression import pyboost_erfinv
 from mindspore._c_expression import pyboost_exp
+from mindspore._c_expression import pyboost_ffn_ext
+from mindspore._c_expression import pyboost_fill_scalar
+from mindspore._c_expression import pyboost_fill_tensor
+from mindspore._c_expression import pyboost_flash_attention_score_grad
+from mindspore._c_expression import pyboost_flash_attention_score
+from mindspore._c_expression import pyboost_flatten_ext
 from mindspore._c_expression import pyboost_gather_d_grad_v2
 from mindspore._c_expression import pyboost_gather_d
 from mindspore._c_expression import pyboost_gelu_grad
 from mindspore._c_expression import pyboost_gelu
 from mindspore._c_expression import pyboost_greater_equal
 from mindspore._c_expression import pyboost_greater
+from mindspore._c_expression import pyboost_grid_sampler_2d_grad
+from mindspore._c_expression import pyboost_grid_sampler_2d
+from mindspore._c_expression import pyboost_grid_sampler_3d_grad
+from mindspore._c_expression import pyboost_grid_sampler_3d
+from mindspore._c_expression import pyboost_group_norm_grad
+from mindspore._c_expression import pyboost_group_norm
+from mindspore._c_expression import pyboost_isfinite
+from mindspore._c_expression import pyboost_layer_norm_ext
+from mindspore._c_expression import pyboost_layer_norm_grad_ext
+from mindspore._c_expression import pyboost_leaky_relu_ext
+from mindspore._c_expression import pyboost_leaky_relu_grad_ext
 from mindspore._c_expression import pyboost_less_equal
+from mindspore._c_expression import pyboost_less
+from mindspore._c_expression import pyboost_lin_space_ext
 from mindspore._c_expression import pyboost_log
 from mindspore._c_expression import pyboost_logical_and
 from mindspore._c_expression import pyboost_logical_not
 from mindspore._c_expression import pyboost_logical_or
 from mindspore._c_expression import pyboost_masked_fill
+from mindspore._c_expression import pyboost_matmul_ext
+from mindspore._c_expression import pyboost_matmul
+from mindspore._c_expression import pyboost_max
+from mindspore._c_expression import pyboost_max_pool_grad_with_indices
+from mindspore._c_expression import pyboost_max_pool_grad_with_mask
+from mindspore._c_expression import pyboost_max_pool_with_indices
+from mindspore._c_expression import pyboost_max_pool_with_mask
+from mindspore._c_expression import pyboost_maximum
+from mindspore._c_expression import pyboost_mean_ext
+from mindspore._c_expression import pyboost_min
+from mindspore._c_expression import pyboost_minimum
 from mindspore._c_expression import pyboost_mul
+from mindspore._c_expression import pyboost_mv
 from mindspore._c_expression import pyboost_neg
+from mindspore._c_expression import pyboost_norm
+from mindspore._c_expression import pyboost_normal_ext
 from mindspore._c_expression import pyboost_not_equal
+from mindspore._c_expression import pyboost_one_hot_ext
+from mindspore._c_expression import pyboost_ones_like_ext
+from mindspore._c_expression import pyboost_ones
+from mindspore._c_expression import pyboost_pow
+from mindspore._c_expression import pyboost_prod_ext
+from mindspore._c_expression import pyboost_quant_batch_matmul
 from mindspore._c_expression import pyboost_reciprocal
+from mindspore._c_expression import pyboost_reduce_all
 from mindspore._c_expression import pyboost_reduce_any
+from mindspore._c_expression import pyboost_reflection_pad_1d_grad
+from mindspore._c_expression import pyboost_reflection_pad_1d
+from mindspore._c_expression import pyboost_reflection_pad_2d_grad
+from mindspore._c_expression import pyboost_reflection_pad_2d
+from mindspore._c_expression import pyboost_reflection_pad_3d_grad
+from mindspore._c_expression import pyboost_reflection_pad_3d
 from mindspore._c_expression import pyboost_relu_grad
 from mindspore._c_expression import pyboost_relu
+from mindspore._c_expression import pyboost_repeat_interleave
+from mindspore._c_expression import pyboost_replication_pad_1d_grad
+from mindspore._c_expression import pyboost_replication_pad_1d
+from mindspore._c_expression import pyboost_replication_pad_2d_grad
+from mindspore._c_expression import pyboost_replication_pad_2d
+from mindspore._c_expression import pyboost_replication_pad_3d_grad
+from mindspore._c_expression import pyboost_replication_pad_3d
+from mindspore._c_expression import pyboost_reverse_v2
+from mindspore._c_expression import pyboost_rsqrt
+from mindspore._c_expression import pyboost_scatter_add_ext
 from mindspore._c_expression import pyboost_scatter
+from mindspore._c_expression import pyboost_select
 from mindspore._c_expression import pyboost_sigmoid_grad
 from mindspore._c_expression import pyboost_sigmoid
 from mindspore._c_expression import pyboost_silu_grad
 from mindspore._c_expression import pyboost_silu
 from mindspore._c_expression import pyboost_sin
+from mindspore._c_expression import pyboost_slice_ext
 from mindspore._c_expression import pyboost_softmax_backward
 from mindspore._c_expression import pyboost_softmax
+from mindspore._c_expression import pyboost_softplus_ext
+from mindspore._c_expression import pyboost_softplus_grad_ext
+from mindspore._c_expression import pyboost_split_tensor
+from mindspore._c_expression import pyboost_split_with_size
 from mindspore._c_expression import pyboost_sqrt
 from mindspore._c_expression import pyboost_square
+from mindspore._c_expression import pyboost_stack_ext
 from mindspore._c_expression import pyboost_sub_ext
+from mindspore._c_expression import pyboost_sum_ext
+from mindspore._c_expression import pyboost_tanh_grad
+from mindspore._c_expression import pyboost_tanh
 from mindspore._c_expression import pyboost_tile
+from mindspore._c_expression import pyboost_topk_ext
 from mindspore._c_expression import pyboost_transpose
+from mindspore._c_expression import pyboost_tril
+from mindspore._c_expression import pyboost_triu
+from mindspore._c_expression import pyboost_uniform_ext
+from mindspore._c_expression import pyboost_upsample_bilinear2d_grad
+from mindspore._c_expression import pyboost_upsample_bilinear2d
+from mindspore._c_expression import pyboost_upsample_linear1d_grad
+from mindspore._c_expression import pyboost_upsample_linear1d
+from mindspore._c_expression import pyboost_upsample_nearest1d_grad
+from mindspore._c_expression import pyboost_upsample_nearest1d
+from mindspore._c_expression import pyboost_upsample_nearest2d_grad
+from mindspore._c_expression import pyboost_upsample_nearest2d
+from mindspore._c_expression import pyboost_upsample_nearest3d_grad
+from mindspore._c_expression import pyboost_upsample_nearest3d
+from mindspore._c_expression import pyboost_upsample_trilinear3d_grad
+from mindspore._c_expression import pyboost_upsample_trilinear3d
+from mindspore._c_expression import pyboost_weight_quant_batch_matmul
+from mindspore._c_expression import pyboost_zeros_like_ext
+from mindspore._c_expression import pyboost_zeros
 
 
 class ACosGrad(Primitive):
@@ -125,8 +236,7 @@ class Abs(Primitive):
         pass
 
     def __call__(self, input):
-          return super().__call__(input)
-
+          return _convert_stub(pyboost_abs(self, [input]))
 
 abs_op=Abs()
 
@@ -198,6 +308,106 @@ class Acosh(Primitive):
 acosh_op=Acosh()
 
 
+class AdamWeightDecayExt(Primitive):
+    r"""
+    Implements Adam Weight Decay algorithm.
+
+        .. math::
+            \begin{aligned}
+                &\textbf{input}      : \gamma \text{(lr)}, \: \beta_1, \beta_2
+                    \text{(betas)}, \: \theta_0 \text{(params)}, \: f(\theta) \text{(objective)},
+                    \: \epsilon \text{ (epsilon)}                                                    \\
+                &\hspace{13mm}      \lambda \text{(weight decay)},  \: \textit{amsgrad},
+                    \: \textit{maximize}                                                             \\
+                &\textbf{initialize} : m_0 \leftarrow 0 \text{ (first moment)}, v_0 \leftarrow 0
+                    \text{ ( second moment)}, \: \widehat{v_0}^{max}\leftarrow 0              \\[-1.ex]
+                &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
+                &\hspace{5mm}\textbf{if} \: \textit{maximize}:                                       \\
+                &\hspace{10mm}g_t           \leftarrow   -\nabla_{\theta} f_t (\theta_{t-1})          \\
+                &\hspace{5mm}\textbf{else}                                                           \\
+                &\hspace{10mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \\
+                &\hspace{5mm} \theta_t \leftarrow \theta_{t-1} - \gamma \lambda \theta_{t-1}         \\
+                &\hspace{5mm}m_t           \leftarrow   \beta_1 m_{t-1} + (1 - \beta_1) g_t          \\
+                &\hspace{5mm}v_t           \leftarrow   \beta_2 v_{t-1} + (1-\beta_2) g^2_t          \\
+                &\hspace{5mm}\widehat{m_t} \leftarrow   m_t/\big(1-\beta_1^t \big)                   \\
+                &\hspace{5mm}\widehat{v_t} \leftarrow   v_t/\big(1-\beta_2^t \big)                   \\
+                &\hspace{5mm}\textbf{if} \: amsgrad                                                  \\
+                &\hspace{10mm}\widehat{v_t}^{max} \leftarrow \mathrm{max}(\widehat{v_t}^{max},
+                    \widehat{v_t})                                                                   \\
+                &\hspace{10mm}\theta_t \leftarrow \theta_t - \gamma \widehat{m_t}/
+                    \big(\sqrt{\widehat{v_t}^{max}} + \epsilon \big)                                 \\
+                &\hspace{5mm}\textbf{else}                                                           \\
+                &\hspace{10mm}\theta_t \leftarrow \theta_t - \gamma \widehat{m_t}/
+                    \big(\sqrt{\widehat{v_t}} + \epsilon \big)                                       \\
+                &\bf{return} \:  \theta_t                                                     \\[-1.ex]
+          \end{aligned}
+
+        .. warning::
+            This is an experimental optimizer API that is subject to change.
+            This module must be used with lr scheduler module in `LRScheduler Class
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.experimental.html#lrscheduler-class>`_ .
+
+        Inputs:
+            - **var** (Parameter) - 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,
+              it should have the the shape as `var`. The data type can be float16 or float32.
+            - **v** (Parameter) - The 2nd moment vector in the updating formula,
+              it should have the same shape as `m`.
+            - **max_v** (Parameter) - The 2nd moment vector in the updating formula,
+              it should have the same shape as `m`.
+            - **gradient** (Tensor) - Gradient, has the same shape as `var`
+            - **step** (float, int) - step
+            - **lr** (float) - :math:`lr` in the updating formula. The paper suggested value is :math:`10^{-8}`,
+              the data type should be float32.
+            - **beta1** (float) - The exponential decay rate for the 1st moment estimations,
+              the data type should be float32. The paper suggested value is :math:`0.9`
+            - **beta2** (float) - The exponential decay rate for the 2nd moment estimations,
+              the data type should be float32. The paper suggested value is :math:`0.999`
+            - **decay** (float) - weight decay (L2 penalty), must be a scalar tensor with float32 data type.
+            - **eps** (float) - Term added to the denominator to improve numerical stability,
+              the data type should be float32.
+            - **amsgrad** (bool) - whether to use the AMSGrad algorithm. Default: ``False``.
+            - **maximize** (bool) - maximize the params based on the objective, instead of minimizing.
+              Default: ``False``.
+            .
+
+        Outputs:
+            Tuple of 3 Tensor, the updated parameters.
+
+            - **var** (Tensor) - The same shape and data type as `var`.
+            - **m** (Tensor) - The same shape and data type as `m`.
+            - **v** (Tensor) - The same shape and data type as `v`.
+
+        Supported Platforms:
+            ``Ascend``
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
+        sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T1),
+        sig.make_sig('v', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T1),
+        sig.make_sig('max_v', dtype=sig.sig_dtype.T1),
+        sig.make_sig('gradient', dtype=sig.sig_dtype.T),
+        sig.make_sig('step', dtype=sig.sig_dtype.T2),
+        sig.make_sig('lr', dtype=sig.sig_dtype.T3),
+        sig.make_sig('beta1', dtype=sig.sig_dtype.T3),
+        sig.make_sig('beta2', dtype=sig.sig_dtype.T3),
+        sig.make_sig('decay', dtype=sig.sig_dtype.T3),
+        sig.make_sig('eps', dtype=sig.sig_dtype.T3),
+        sig.make_sig('amsgrad', dtype=sig.sig_dtype.T4, default=False),
+        sig.make_sig('maximize', dtype=sig.sig_dtype.T5, default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        self.add_prim_attr("side_effect_mem", True)
+
+    def __call__(self, var, m, v, max_v, gradient, step, lr, beta1, beta2, decay, eps, amsgrad=False, maximize=False):
+          return _convert_stub(pyboost_adam_weight_decay_ext(self, [var, m, v, max_v, gradient, step, lr, beta1, beta2, decay, eps, amsgrad, maximize]))
+
+adam_weight_decay_ext_op=AdamWeightDecayExt()
+
+
 class AdamWeightDecay(Primitive):
     r"""
     Updates gradients by the Adaptive Moment Estimation algorithm with weight decay (AdamWeightDecay).
@@ -302,7 +512,7 @@ class AdamWeightDecay(Primitive):
         sig.make_sig('beta2', dtype=sig.sig_dtype.T2),
         sig.make_sig('epsilon', dtype=sig.sig_dtype.T2),
         sig.make_sig('decay', dtype=sig.sig_dtype.T2),
-        sig.make_sig('gradient', dtype=sig.sig_dtype.T3),
+        sig.make_sig('gradient', dtype=sig.sig_dtype.T),
     )
 
     @prim_arg_register
@@ -830,6 +1040,53 @@ class ApplyRotaryPosEmb(Primitive):
           return super().__call__(query, key, cos, sin, position_ids, self.cos_format)
 
 
+class Arange(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T, sig.sig_dtype.T)
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, start, end, step):
+          return _convert_stub(pyboost_arange(self, [start, end, step]))
+
+arange_op=Arange()
+
+
+class ArgMaxExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.ArgMaxExt()
+        out = prim(input, dim, keepdim)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.argmax(input, dim, keepdim)
+        
+    Refer to :func:`mindspore.ops.argmax` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('dim', default=None),
+        sig.make_sig('keepdim', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dim=None, keepdim=False):
+          return _convert_stub(pyboost_argmax_ext(self, [input, dim, keepdim]))
+
+argmax_ext_op=ArgMaxExt()
+
+
 class Argmax(Primitive):
     r"""
     Returns the indices of the maximum value along a specified `axis` of a Tensor.
@@ -1278,6 +1535,111 @@ class Atanh(Primitive):
 atanh_op=Atanh()
 
 
+class AvgPool2DGrad(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('grad'),
+        sig.make_sig('image'),
+        sig.make_sig('kernel_size'),
+        sig.make_sig('stride'),
+        sig.make_sig('padding', default=0),
+        sig.make_sig('ceil_mode', default=False),
+        sig.make_sig('count_include_pad', default=True),
+        sig.make_sig('divisor_override', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad, image, kernel_size, stride, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None):
+          return _convert_stub(pyboost_avg_pool2d_grad(self, [grad, image, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override]))
+
+avg_pool2d_grad_op=AvgPool2DGrad()
+
+
+class AvgPool2D(Primitive):
+    r"""
+    Applies a 2D average pooling over an input Tensor which can be regarded as a composition of 2D input planes.
+    Typically the input is of shape :math:`(N, C, H_{in}, W_{in})`, outputs regional average in the
+    :math:`(H_{in}, W_{in})`-dimension. Given kernel size :math:`(k_{H}, k_{W})` and `stride` , the operation
+    is as follows.
+
+    .. math::
+        \text{output}(N_i, C_j, h, w) = \frac{1}{k_{H} * k_{W}} \sum_{m=0}^{k_{H}-1} \sum_{n=0}^{k_{W}-1}
+        \text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)
+
+    Inputs:
+        input (Tensor): Tensor of shape :math:`(N, C, H_{in}, W_{in})`.
+        kernel_size (Union[int, tuple[int], list[int]]): The size of kernel used to take the average value. Can be
+            a single number or a tuple (kH, kW).
+        stride (Union[int, tuple[int], list[int]]): The distance of kernel moving. Can be a single number or
+            a tuple (sH, sW).
+        padding (Union(int, tuple[int], list[int])): Implicit zero padding to be added on both sides. Can be a single
+            number or a tuple (padH, padW). Default: 0.
+        ceil_mode (bool): If True, apply ceil instead of floor to compute the output shape. Default: ``False``.
+        count_include_pad (bool): If True, include the zero-padding in the averaging calculation. Default: ``True`` .
+        divisor_override (int): If specified, it will be used as divisor in the averaging calculation, otherwise
+            `kernel_size` will be used. Default: ``None``.
+
+    Outputs:
+        Tensor, with shape :math:`(N, C, H_{out}, W_{out})`.
+
+    .. math::
+
+        H_{out} = \frac{H_{in} + 2 \times padding[0] - kernel_size[0]}{stride[0]} + 1
+        W_{out} = \frac{W_{in} + 2 \times padding[1] - kernel_size[1]}{stride[1]} + 1
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `kernel_size` or `stride` is neither int nor tuple.
+        TypeError: If `ceil_mode` or `count_include_pad` is not a bool.
+        TypeError: If `divisor_override` is not an int.
+        ValueError: If length of shape of `input` is not equal to `4` or `3`.
+        ValueError: If `kernel_size` or `stride` is less than 1.
+        ValueError: If `kernel_size` or `stride` is a tuple whose length is not equal to `2` or `1`.
+        ValueError: If `padding` is neither a int nor a tuple whose length is equal to `2` or `1`.
+        ValueError: If value of `padding` is less than `0`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.arange(1 * 3 * 3 * 4).reshape(1, 3, 3, 4), mindspore.float32)
+        >>> output = ops.auto_generate.AvgPool2D()(x, 2, 1)
+        >>> print(output)
+        [[[[ 2.5   3.5   4.5]
+        [ 6.5   7.5   8.5]]
+        [[14.5  15.5  16.5]
+        [18.5  19.5  20.5]]
+        [[26.5  27.5  28.5]
+        [30.5  31.5  32.5]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('kernel_size'),
+        sig.make_sig('stride'),
+        sig.make_sig('padding', default=0),
+        sig.make_sig('ceil_mode', default=False),
+        sig.make_sig('count_include_pad', default=True),
+        sig.make_sig('divisor_override', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, kernel_size, stride, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None):
+          return _convert_stub(pyboost_avg_pool2d(self, [input, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override]))
+
+avg_pool2d_op=AvgPool2D()
+
+
 class AvgPoolGrad(Primitive):
     r"""
     Gradients of the avg pool operation.
@@ -1373,6 +1735,102 @@ class AvgPool(Primitive):
           return super().__call__(x, self.kernel_size, self.strides, self.pad_mode, self.data_format)
 
 
+class BatchMatMul(Primitive):
+    r"""
+    Computes matrix multiplication between two tensors by batch.
+
+    .. math::
+
+    \text{output}[..., :, :] = \text{matrix}(x[..., :, :]) * \text{matrix}(y[..., :, :])
+
+    The rank of both two input tensors must be same and not less than `2`.
+
+    Args:
+        transpose_a (bool): If ``True`` , the last two dimensions of `x` is transposed before multiplication.
+            Default: ``False`` .
+        transpose_b (bool): If ``True`` , the last two dimensions of `y` is transposed before multiplication.
+            Default: ``False`` .
+
+    Inputs:
+        - **x** (Tensor) - The first tensor to be multiplied. The shape of the tensor is :math:`(*B, N, C)`,
+          where :math:`*B` represents the batch size which can be multidimensional, :math:`N` and :math:`C` are the
+          size of the last two dimensions. If `transpose_a` is ``True`` , its shape must be :math:`(*B, C, N)`.
+        - **y** (Tensor) - The second tensor to be multiplied. The shape of the tensor is :math:`(*B, C, M)`. If
+          `transpose_b` is ``True`` , its shape must be :math:`(*B, M, C)`.
+
+    Outputs:
+        Tensor, the shape of the output tensor is :math:`(*B, N, M)`.
+
+    Raises:
+        TypeError: If `transpose_a` or `transpose_b` is not a bool.
+        ValueError: If length of shape of `x` is not equal to length of shape of `y` or
+            length of shape of inputs is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.ones(shape=[2, 4, 1, 3]), mindspore.float32)
+        >>> y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
+        >>> batmatmul = ops.BatchMatMul()
+        >>> output = batmatmul(x, y)
+        >>> print(output.shape)
+        (2, 4, 1, 4)
+        >>> x = Tensor(np.ones(shape=[2, 4, 3, 1]), mindspore.float32)
+        >>> y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
+        >>> batmatmul = ops.BatchMatMul(transpose_a=True)
+        >>> output = batmatmul(x, y)
+        >>> print(output.shape)
+        (2, 4, 1, 4)
+    """
+    @prim_arg_register
+    def __init__(self, transpose_a=False, transpose_b=False):
+        self._set_prim_arg("transpose_a", transpose_a)
+        self._set_prim_arg("transpose_b", transpose_b)
+
+    def __call__(self, x, y):
+          return _convert_stub(pyboost_batch_mat_mul(self, [x, y, self.transpose_a, self.transpose_b]))
+
+class BatchNormExt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('weight'),
+        sig.make_sig('bias'),
+        sig.make_sig('running_mean'),
+        sig.make_sig('runnning_var'),
+        sig.make_sig('training', default=False),
+        sig.make_sig('momentum', default=0.1),
+        sig.make_sig('epsilon', default=1e-5),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, weight, bias, running_mean, runnning_var, training=False, momentum=0.1, epsilon=1e-5):
+          return _convert_stub(pyboost_batch_norm_ext(self, [input, weight, bias, running_mean, runnning_var, training, momentum, epsilon]))
+
+batch_norm_ext_op=BatchNormExt()
+
+
+class BatchNormGradExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self, training=False, eps=1e-5):
+        self._set_prim_arg("training", training)
+        self._set_prim_arg("eps", eps)
+
+    def __call__(self, dout, input, weight, running_mean, running_var, saved_mean, saved_rstd):
+          return _convert_stub(pyboost_batch_norm_grad_ext(self, [dout, input, weight, running_mean, running_var, saved_mean, saved_rstd, self.training, self.eps]))
+
 class BatchNormGradGrad(Primitive):
     r"""
     Performs grad of BatchNormGrad operation.
@@ -1529,6 +1987,31 @@ class BiasAdd(Primitive):
           return super().__call__(input_x, bias, self.data_format)
 
 
+class BatchMatMulExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.BatchMatMulExt()
+        out = prim(input, mat2)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.bmm_ext(input, mat2)
+        
+    Refer to :func:`mindspore.ops.bmm_ext` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, mat2):
+          return _convert_stub(pyboost_bmm_ext(self, [input, mat2]))
+
+bmm_ext_op=BatchMatMulExt()
+
+
 class BoolNot(Primitive):
     r"""
     Returns bool_not `not` of bool input.
@@ -1738,6 +2221,119 @@ class Cholesky(Primitive):
           return super().__call__(input_x, self.upper)
 
 
+class Chunk(Primitive):
+    r"""
+    Cut the input Tensor into `chunks` sub-tensors along the specified axis.
+
+    Note:
+        This function may return less than the specified number of chunks!
+
+    Inputs:
+        input (Tensor): A Tensor to be cut.
+        chunks (int): Number of sub-tensors to cut.
+        dim (int, optional): Specify the dimensions that you want to split. Default: ``0`` .
+
+    Returns:
+        A tuple of sub-tensors.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: The sum of `chunks` is not int.
+        TypeError: If argument `dim` is not int.
+        ValueError: If argument `dim` is out of range of :math:`[-input.ndim, input.ndim)` .
+        ValueError: If argument `chunks` is not positive number.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import ops, Tensor
+        >>> input_x = np.arange(9).astype("float32")
+        >>> output = ops.Chunk()(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Float32, value= [ 0.00000000e+00,  1.00000000e+00,  2.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('chunks'),
+        sig.make_sig('dim', default=0),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, chunks, dim=0):
+          return _convert_stub(pyboost_chunk(self, [input, chunks, dim]))
+
+chunk_op=Chunk()
+
+
+class ClampScalar(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.ClampScalar()
+        out = prim(input, min, max)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.clamp_scalar(input, min, max)
+        
+    Refer to :func:`mindspore.ops.clamp_scalar` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('min', default=None),
+        sig.make_sig('max', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, min=None, max=None):
+          return _convert_stub(pyboost_clamp_scalar(self, [input, min, max]))
+
+clamp_scalar_op=ClampScalar()
+
+
+class ClampTensor(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.ClampTensor()
+        out = prim(input, min, max)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.clamp_tensor(input, min, max)
+        
+    Refer to :func:`mindspore.ops.clamp_tensor` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('min', default=None),
+        sig.make_sig('max', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, min=None, max=None):
+          return _convert_stub(pyboost_clamp_tensor(self, [input, min, max]))
+
+clamp_tensor_op=ClampTensor()
+
+
 class Complex(Primitive):
     r"""
     Returns a complex Tensor from the real part and the imag part.
@@ -1829,6 +2425,26 @@ class Conj(Primitive):
 conj_op=Conj()
 
 
+class ConstantPadND(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('padding'),
+        sig.make_sig('value', default=0.0),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding, value=0.0):
+          return _convert_stub(pyboost_constant_pad_nd(self, [input, padding, value]))
+
+constant_pad_nd_op=ConstantPadND()
+
+
 class Contiguous(Primitive):
     r"""
     .. code-block::
@@ -1854,7 +2470,53 @@ class Contiguous(Primitive):
 contiguous_op=Contiguous()
 
 
-class Copy(Primitive):
+class ConvolutionGrad(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dout'),
+        sig.make_sig('input'),
+        sig.make_sig('weight'),
+        sig.make_sig('bias', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, stride=1, padding=0, dilation=1, transposed=False, output_padding=0, groups=1, output_mask=()):
+        self._set_prim_arg_with_handler("stride", stride, to_strides)
+        self._set_prim_arg_with_handler("padding", padding, to_2d_paddings)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("transposed", transposed)
+        self._set_prim_arg_with_handler("output_padding", output_padding, to_output_padding)
+        self._set_prim_arg("groups", groups)
+        self._set_prim_arg("output_mask", output_mask)
+
+    def __call__(self, dout, input, weight, bias=None):
+          return _convert_stub(pyboost_convolution_grad(self, [dout, input, weight, bias, self.stride, self.padding, self.dilation, self.transposed, self.output_padding, self.groups, self.output_mask]))
+
+class Convolution(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('weight'),
+        sig.make_sig('bias', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, stride=1, padding=0, dilation=1, transposed=False, output_padding=0, groups=1):
+        self._set_prim_arg_with_handler("stride", stride, to_strides)
+        self._set_prim_arg_with_handler("padding", padding, to_2d_paddings)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("transposed", transposed)
+        self._set_prim_arg_with_handler("output_padding", output_padding, to_output_padding)
+        self._set_prim_arg("groups", groups)
+
+    def __call__(self, input, weight, bias=None):
+          return _convert_stub(pyboost_convolution(self, [input, weight, bias, self.stride, self.padding, self.dilation, self.transposed, self.output_padding, self.groups]))
+
+class Copy(Primitive):
     r"""
     .. code-block::
         
@@ -2214,6 +2876,37 @@ class DecoderKVCache(Primitive):
 decoder_k_v_cache_op=DecoderKVCache()
 
 
+class Dense(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Dense()
+        out = prim(input, weight, bias)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.dense(input, weight, bias)
+        
+    Refer to :func:`mindspore.ops.dense` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('weight'),
+        sig.make_sig('bias', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, weight, bias=None):
+          return _convert_stub(pyboost_dense(self, [input, weight, bias]))
+
+dense_op=Dense()
+
+
 class Diag(Primitive):
     r"""
     .. code-block::
@@ -2328,6 +3021,114 @@ class Div(Primitive):
 div_op=Div()
 
 
+class DivMod(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x', dtype=sig.sig_dtype.T),
+        sig.make_sig('y', dtype=sig.sig_dtype.T),
+        sig.make_sig('rounding_mode', dtype=sig.sig_dtype.T1, default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, y, rounding_mode=None):
+          return _convert_stub(pyboost_divmod(self, [x, y, rounding_mode if rounding_mode is None else str_to_enum('DivMod', 'rounding_mode', rounding_mode)]))
+
+divmod_op=DivMod()
+
+
+class Dot(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Dot()
+        out = prim(input, other)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.dot(input, other)
+        
+    Refer to :func:`mindspore.ops.dot` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, other):
+          return _convert_stub(pyboost_dot(self, [input, other]))
+
+dot_op=Dot()
+
+
+class DropoutDoMaskExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, mask, p):
+          return _convert_stub(pyboost_dropout_do_mask_ext(self, [input, mask, p]))
+
+dropout_do_mask_ext_op=DropoutDoMaskExt()
+
+
+class DropoutExt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('p', default=0.5),
+        sig.make_sig('seed', default=0),
+        sig.make_sig('offset', default=0),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        self.add_prim_attr("side_effect_hidden", True)
+
+    def __call__(self, input, p=0.5, seed=0, offset=0):
+          return _convert_stub(pyboost_dropout_ext(self, [input, p, seed, offset]))
+
+dropout_ext_op=DropoutExt()
+
+
+class DropoutGenMaskExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        self.add_prim_attr("side_effect_hidden", True)
+
+    def __call__(self, shape, p, seed, offset, dtype):
+          return _convert_stub(pyboost_dropout_gen_mask_ext(self, [shape, p, seed, offset, dtype_to_type_id('DropoutGenMaskExt', 'dtype', dtype)]))
+
+dropout_gen_mask_ext_op=DropoutGenMaskExt()
+
+
+class DropoutGradExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, mask, p):
+          return _convert_stub(pyboost_dropout_grad_ext(self, [x, mask, p]))
+
+dropout_grad_ext_op=DropoutGradExt()
+
+
 class Dropout(Primitive):
     r"""
     During training, randomly zeroes some of the elements of the input tensor
@@ -2471,6 +3272,93 @@ class Elu(Primitive):
           return super().__call__(input_x, self.alpha)
 
 
+class EmbeddingDenseBackward(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('grad'),
+        sig.make_sig('indices'),
+        sig.make_sig('num_weights'),
+        sig.make_sig('padding_idx', default=None),
+        sig.make_sig('scale_grad_by_freq', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad, indices, num_weights, padding_idx=None, scale_grad_by_freq=False):
+          return _convert_stub(pyboost_embedding_dense_backward(self, [grad, indices, num_weights, padding_idx, scale_grad_by_freq]))
+
+embedding_dense_backward_op=EmbeddingDenseBackward()
+
+
+class Embedding(Primitive):
+    r"""
+    Retrieve the word embeddings in `weight` using indices specified in `input`.
+
+    .. warning::
+        On Ascend, the behavior is unpredictable when the value of `input` is invalid.
+
+    Args:
+        input (Tensor): The indices used to lookup in the `weight`. The data type must be mindspore.int32 or mindspore.int64,
+            and the value should be in range `[0, weight.shape[0])`.
+        weight (Parameter): The matrix where to lookup from. The shape must be 2D.
+        padding_idx (int, optional): If the value is not None, the corresponding row of `weight` will not be updated in training.
+            The value should be in range `[-weight.shape[0], weight.shape[0])` if it's not ``None``. Default ``None``.
+        max_norm (float, optional): If not None, firstly get the p-norm result of the `weight` specified by `input` where p is specified by `norm_type`;
+            if the result is larger then `max_norm`, update the `weight` with :math:`\frac{max\_norm}{result+1e^{-7}}` in-place. Default ``None``.
+        norm_type (float, optional): Indicates the value of p in p-norm. Default ``2.0``.
+        scale_grad_by_freq (bool, optional): If ``True`` the gradients will be scaled by the inverse of frequency of the index in `input`. Default ``False``.
+
+    Returns:
+        Tensor, has the same data type as `weight`, the shape is :math:`(*input.shape, weight.shape[1])`.
+
+    Raises:
+        ValueError: If `padding_idx` is out of valid range.
+        ValueError: If the shape of `weight` is invalid.
+        TypeError: `weight` is not a :class:`mindspore.Parameter`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, Parameter, ops
+        >>> input = Tensor([[1, 0, 1, 1], [0, 0, 1, 0]])
+        >>> weight = Parameter(np.random.randn(3, 3).astype(np.float32))
+        >>> output = ops.auto_generate.Embedding()(input, weight, max_norm=0.4)
+        >>> print(output)
+        [[[ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
+          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
+          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
+          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01]],
+         [[ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
+          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
+          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
+          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('weight', sig.sig_rw.RW_WRITE),
+        sig.make_sig('padding_idx', default=None),
+        sig.make_sig('max_norm', default=None),
+        sig.make_sig('norm_type', default=2.0),
+        sig.make_sig('scale_grad_by_freq', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        self.add_prim_attr("side_effect_mem", True)
+
+    def __call__(self, input, weight, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False):
+          return _convert_stub(pyboost_embedding(self, [input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq]))
+
+embedding_op=Embedding()
+
+
 class Equal(Primitive):
     r"""
     .. code-block::
@@ -2518,8 +3406,7 @@ class Erf(Primitive):
         pass
 
     def __call__(self, input):
-          return super().__call__(input)
-
+          return _convert_stub(pyboost_erf(self, [input]))
 
 erf_op=Erf()
 
@@ -2768,6 +3655,46 @@ class FastGeLU(Primitive):
 fast_gelu_op=FastGeLU()
 
 
+class FFNExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.FFNExt(activation, inner_precise)
+        out = prim(x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.ffn_ext(x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2, activation, inner_precise)
+        
+    Refer to :func:`mindspore.ops.ffn_ext` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('weight1'),
+        sig.make_sig('weight2'),
+        sig.make_sig('expertTokens', default=None),
+        sig.make_sig('bias1', default=None),
+        sig.make_sig('bias2', default=None),
+        sig.make_sig('scale', default=None),
+        sig.make_sig('offset', default=None),
+        sig.make_sig('deqScale1', default=None),
+        sig.make_sig('deqScale2', default=None),
+        sig.make_sig('antiquant_scale1', default=None),
+        sig.make_sig('antiquant_scale2', default=None),
+        sig.make_sig('antiquant_offset1', default=None),
+        sig.make_sig('antiquant_offset2', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, activation='fastgelu', inner_precise=0):
+        self._set_prim_arg_with_handler("activation", activation, str_to_enum)
+        self._set_prim_arg("inner_precise", inner_precise)
+
+    def __call__(self, x, weight1, weight2, expertTokens=None, bias1=None, bias2=None, scale=None, offset=None, deqScale1=None, deqScale2=None, antiquant_scale1=None, antiquant_scale2=None, antiquant_offset1=None, antiquant_offset2=None):
+          return _convert_stub(pyboost_ffn_ext(self, [x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2, self.activation, self.inner_precise]))
+
 class FFT2(Primitive):
     r"""
     .. code-block::
@@ -3043,77 +3970,383 @@ class FFTShift(Primitive):
 fftshift_op=FFTShift()
 
 
-class Flatten(Primitive):
+class FillScalar(Primitive):
     r"""
-    Flattens a tensor without changing its batch size on the 0-th axis.
+    Create a Tensor of the specified shape and fill it with the specified scalar value.
 
-    Refer to :func:`mindspore.ops.flatten` for more details.
+    Args:
+        size (Union(tuple[int], list[int])): The specified shape of output tensor.
+        fill_value (number.Number): Value to fill the returned tensor. Complex numbers are not supported for now.
 
-    Inputs:
-        - **input_x** (Tensor) - Tensor of shape :math:`(N, \ldots)` to be flattened, where :math:`N` is batch size.
+    Keyword Args:
+        dtype (mindspore.dtype): The specified type of output tensor. `bool_` and `number` are supported, for
+            details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
-    Outputs:
-        Tensor, the shape of the output tensor is :math:`(N, X)`, where :math:`X` is
-        the product of the remaining dimension.
+    Returns:
+        Tensor.
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+    Raises:
+        TypeError: If `size` is not a tuple or list.
+        ValueError: The element in `size` is less than 0.
 
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
-        >>> flatten = ops.Flatten()
-        >>> output = flatten(input_x)
-        >>> print(output.shape)
-        (1, 24)
+    Supported Platforms:
+        ``Ascend``
     """
+    __mindspore_signature__ =  (
+        sig.make_sig('size'),
+        sig.make_sig('fill_value'),
+        sig.make_sig('dtype', default=None),
+    )
+
     @prim_arg_register
     def __init__(self):
         pass
 
-    def __call__(self, input_x):
-          return super().__call__(input_x)
+    def __call__(self, size, fill_value, dtype=None):
+          return _convert_stub(pyboost_fill_scalar(self, [size, fill_value, dtype if dtype is None else dtype_to_type_id('FillScalar', 'dtype', dtype)]))
 
-
-flatten_op=Flatten()
+fill_scalar_op=FillScalar()
 
 
-class FloorDiv(Primitive):
+class FillTensor(Primitive):
     r"""
-    .. code-block::
-        
-        prim = ops.FloorDiv()
-        out = prim(input, other)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.floor_divide(input, other)
-        
-    Refer to :func:`mindspore.ops.floor_divide` for more details.
+    Create a Tensor of the specified shape and fill it with the specified tensor value.
+
+    Args:
+        size (Union(tuple[int], list[int])): The specified shape of output tensor.
+        fill_value (Tensor): Value to fill the returned tensor. Complex numbers are not supported for now. Must be
+            scalar Tensor or 1-D Tensor with shape of [1].
+
+    Keyword Args:
+        dtype (mindspore.dtype): The specified type of output tensor. `bool_` and `number` are supported, for
+            details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `size` is not a tuple or list.
+        ValueError: The element in `size` is less than 0.
+
+    Supported Platforms:
+        ``Ascend``
     """
-    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+    __mindspore_signature__ =  (
+        sig.make_sig('size'),
+        sig.make_sig('fill_value'),
+        sig.make_sig('dtype', default=None),
+    )
 
     @prim_arg_register
     def __init__(self):
         pass
 
-    def __call__(self, input, other):
-          return super().__call__(input, other)
-
+    def __call__(self, size, fill_value, dtype=None):
+          return _convert_stub(pyboost_fill_tensor(self, [size, fill_value, dtype if dtype is None else dtype_to_type_id('FillTensor', 'dtype', dtype)]))
 
-floor_div_op=FloorDiv()
+fill_tensor_op=FillTensor()
 
 
-class FloorMod(Primitive):
+class FlashAttentionScoreGrad(Primitive):
     r"""
-    .. code-block::
-        
-        prim = ops.FloorMod()
-        out = prim(x, y)
+    Calculates the gradient of FlashAttentionScore operation.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('query'),
+        sig.make_sig('key'),
+        sig.make_sig('value'),
+        sig.make_sig('dy'),
+        sig.make_sig('pse_shift', default=None),
+        sig.make_sig('drop_mask', default=None),
+        sig.make_sig('padding_mask', default=None),
+        sig.make_sig('atten_mask', default=None),
+        sig.make_sig('softmax_max', default=None),
+        sig.make_sig('softmax_sum', default=None),
+        sig.make_sig('softmax_in', default=None),
+        sig.make_sig('attention_in', default=None),
+        sig.make_sig('prefix', default=None),
+        sig.make_sig('actual_seq_qlen', default=None),
+        sig.make_sig('actual_seq_kvlen', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, head_num, keep_prob=1.0, scale_value=1.0, pre_tokens=65536, next_tokens=65536, inner_precise=1, input_layout='BSH', sparse_mode=0):
+        self._set_prim_arg("head_num", head_num)
+        self._set_prim_arg("keep_prob", keep_prob)
+        self._set_prim_arg("scale_value", scale_value)
+        self._set_prim_arg("pre_tokens", pre_tokens)
+        self._set_prim_arg("next_tokens", next_tokens)
+        self._set_prim_arg("inner_precise", inner_precise)
+        self._set_prim_arg_with_handler("input_layout", input_layout, str_to_enum)
+        self._set_prim_arg("sparse_mode", sparse_mode)
+
+    def __call__(self, query, key, value, dy, pse_shift=None, drop_mask=None, padding_mask=None, atten_mask=None, softmax_max=None, softmax_sum=None, softmax_in=None, attention_in=None, prefix=None, actual_seq_qlen=None, actual_seq_kvlen=None):
+          return _convert_stub(pyboost_flash_attention_score_grad(self, [query, key, value, dy, pse_shift, drop_mask, padding_mask, atten_mask, softmax_max, softmax_sum, softmax_in, attention_in, prefix, actual_seq_qlen, actual_seq_kvlen, self.head_num, self.keep_prob, self.scale_value, self.pre_tokens, self.next_tokens, self.inner_precise, self.input_layout, self.sparse_mode]))
+
+class FlashAttentionScore(Primitive):
+    r"""
+    FlashAttentionScore.
+
+    .. math::
+        \begin{array}{ll} \\
+            y = Dropout(Softmax(Mask(scale_value \mul (real_shift + query * key), attn_mask), -1), keep_prob) \\
+            \mul value \\
+        \end{array}
+
+    B -- Batch size. Value range 1 to 2k.
+    S1 -- Sequence length of query. Value range 1 to 512k.
+    S2 -- Sequence length of key and value. Value range 1 to 512k.
+    N1 -- Num heads of query. Value range 1 to 256.
+    N2 -- Num heads of key and value, and N2 must be a factor of N1.
+    D -- Head size.  The value ranges is a multiple of 16, with the max value of 512.
+    H1 -- Hidden size of query, which equals to N1 * D.
+    H2 -- Hidden size of key and value, which equals to N2 * D.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion. Only support on Atlas A2 training series.
+
+    Args:
+        head_num (int): The head num of query, equal to N1.
+        keep_prob (float): The keep probability of dropout. Value range is (0.0, 1.0]. Default: 1.0. When keep_prob
+            is 1.0, drop_mask should be none.
+        scale_value (float): The scale factor of score. Generally, the value is 1.0 / (D ** 0.5). Default: 1.0.
+        pre_tokens (int): Parameter for sparse computation, represents how many tokens are counted forward.
+            When sparse_mode is set to 1, 2, 3, or 5, this parameter does not take effect. Default: 2147483647.
+        next_tokens (int): Parameter for sparse computation, represents how many tokens are counted backward.
+            When sparse_mode is set to 1, 2, 3, or 5, this parameter does not take effect. Default: 2147483647.
+            The value of pre_tokens corresponds to S1, and the value of next_tokens corresponds to S2. They define the
+            valid area on the attn_mask matrix. It must ensure that the band is not empty.
+            The following values are not allowed:
+
+            - pre_tokens < 0 and next_tokens < 0.
+            - (pre_tokens < 0 and next_tokens >= 0) and (next_tokens < abs(pre_tokens) or abs(pre_tokens) >= S2).
+            - (pre_tokens >= 0 and next_tokens < 0) and (abs(next_tokens) > pre_tokens or abs(next_tokens) >= S1).
+
+        inner_precise (int): The parameter is reserved and not implemented yet. Default: 0.
+        input_layout (str): Specifies the layout of input `query`, key and value. The value can be "BSH", "BNSD", "SBH",
+            "BSND" or "TND". "TND" is an experimental format. Default: "BSH".
+            When input_layout is "TND", the following restrictions must be met.
+            There are two lists that represent the length of the input sequence: list_seq_q and list_seq_k. Each
+            value in the list indicates the length of the sequence in the batch. For example, list_seq_q = [4, 2, 6],
+            list_seq_k = [10, 3, 9]. The element of list indicate S. T1 is sum(list_seq_q) = 12, T2 is
+            sum(list_seq_k) = 22.
+            max_seqlen_q = max(list_seq_q), max_seqlen_k = max(list_seq_k).
+            qk_pointer = sum(list_seq_q * list_seq_k), which is the sum of the element multiplication.
+
+            - The lengths of two lists are the same, and size of list is batch. batch is less than or equal to 1024.
+            - When input_layout is "TND", actual_seq_qlen and actual_seq_kvlen must be not none.
+              Otherwise, they are none.
+            - The actual_seq_qlen and actual_seq_kvlen are the cumulative sum of sequence of key/value, so they must
+              be non-decreasing.
+            - If real_shift is not none, list_seq_q and list_seq_k must be same. The maximum value of list_seq_q and
+              list_seq_k is greater than 1024. Real_shift should be `(B, N1, 1024, S2)` and `(1, N1, 1024, S2)`, and
+              S2 is equal to max_seqlen_k.
+            - Attn mask must be a lower trianglar matrix, so sparse_mode should be 2 or 3. The shape of attn_mask
+              should be `(2048, 2048)`.
+            - The shape of drop_mask is (qk_pointer * N1 // 8,).
+            - Prefix is none.
+            - Next_tokens is 0, and pre_tokens is not less than max_seqlen_q.
+            - When sparse_mode is 3, S1 of each batch should be less than or equal to S2.
+            - 0 should not exist in list_seq_k.
+
+        sparse_mode (int): Indicates sparse mode. Default 0.
+
+            - 0: Indicates the defaultMask mode. If attn_mask is not passed, the mask operation is not performed,
+              and preTokens and nextTokens(internally assigned as INT_MAX) are ignored. If passed in, the full attn_mask
+              matrix (S1 * S2) needs to be passed in, indicating that the part between preTokens and nextTokens needs to
+              be calculated.
+            - 1: Represents allMask, that is, passing in the complete attn_mask matrix.
+            - 2: Representing the leftUpCausal mode corresponds to the lower triangle scenario divided by the left
+              vertex, and the optimized attn_mask matrix (2048*2048) is required.
+            - 3: Representing the rightDownCausal model corresponds to the lower triangle scene divided by the lower
+              right vertex, and the optimized attn_mask matrix (2048*2048) is required.
+            - 4: Represents the band scenario, that is, the part between counting preTokens and nextTokens, and the
+              optimized attn_mask matrix (2048*2048) is required..
+            - 5: Represents the prefix scenario, that is, on the basis of rightDownCasual, a matrix with length S1 and
+              width N is added to the left side. The value of N is obtained by the new input prefix, and the N value of
+              each Batch axis is different, not implemented yet.
+            - 6: Represents the global scenario, not implemented yet.
+            - 7: Represents the dilated scenario, not implemented yet.
+            - 8: Represents the block_local scenario, not implemented yet.
+
+    Inputs:
+        - **query** (Tensor[float16, bfloat16]) - The query tensor.
+          Input tensor of shape :math:`(B, S1, H1)`, `(B, N1, S1, D)`, `(S1, B, H1)`, `(B, S1, N1, D)` or `(T1, N1, D)`.
+        - **key** (Tensor[float16, bfloat16]) - The key tensor.
+          Input tensor of shape :math:`(B, S2, H2)`, `(B, N2, S2, D)`, `(S2, B, H2)`, `(B, S2, N2, D)` or `(T2, N2, D)`.
+        - **value** (Tensor[float16, bfloat16]) - The value tensor.
+          Input tensor of shape :math:`(B, S2, H2)`, `(B, N2, S2, D)`, `(S2, B, H2)`, `(B, S2, N2, D)` or `(T2, N2, D)`.
+          The key and value have the same shape.
+        - **real_shift** (Union[Tensor[float16, bfloat16], None]) - Also known as pse. The position embedding code. If S
+          is greater than 1024 and the mask of the lower triangle is used, enter only the inverse 1024 lines of
+          the lower triangle for memory optimization. Input tensor of shape :math:`(B, N1, S1, S2)`,
+          `(1, N1, S1, S2)`, `(B, N1, 1024, S2)`, `(1, N1, 1024, S2)`.
+
+            - ALiBi scenario: real_shift must meet the ALiBi rule, and sparse_mode is 2 or 3 for the lower triangle.
+              In this scenario, real_shift is `(B, N1, 1024, S2)`, `(1, N1, 1024, S2)`.
+            - Non-ALiBi scenario: real_shift is `(B, N1, S1, S2)`, `(1, N1, S1, S2)`.
+
+          The shape of `real_shift` should be `(B, N1, 1024, S2)` and `(1, N1, 1024, S2)` when input_layout is `TND`.
+        - **drop_mask** (Union[Tensor[uint8], None]) - The dropout mask tensor.
+          Input tensor of shape :math:`(B, N1, S1, S2 // 8) or None`. S2 is a multiple of 8 when not None.
+        - **padding_mask** (None) - Reserved parameter. Not implemented yet.
+        - **attn_mask** (Union[Tensor[uint8], Tensor[bool], None]) - The attention mask tensor. For each element, 0
+          indicates retention and 1 indicates discard. Input tensor of shape :math:`(B, N1, S1, S2)`, `(B, 1, S1, S2)`,
+          `(S1, S2)` or (2048, 2048). In compression scenario, sparse_mode is 2, 3, or 4, attn_mask must be
+          `(2048, 2048)`. When sparse_mode is 5, attn_mask must be `(B, N1, S1, S2)`, `(B, 1, S1, S2)`. When sparse_mode
+          is 0 and 1, attn_mask should be `(B, N1, S1, S2)`, `(B, 1, S1, S2)`, `(S1, S2)`.
+        - **prefix** (Union[List[int64], Tuple[int64], None]) - N value of each Batch in the prefix sparse calculation
+          scenario. Input tensor of shape :math:`(B,)`. B max value 32. Not none only when sparse_mode is 5.
+          If S1 > S2, N ranges from 0 to S2. If S1 <= S2, N ranges from S2 - S1 to S2.
+        - **actual_seq_qlen** (Union[List[int64], Tuple[int64], None]) - Size of query corresponding to each batch, array
+          with increasing values and the last value equal to T1.
+        - **actual_seq_kvlen** (Union[List[int64], Tuple[int64], None]) - Size of key and value corresponding to each
+          batch, array with increasing values and the last value equal to T2.
+
+    Outputs:
+        - **softmax_max** (Tensor[float32]) - (B, N1, S1, 8) when input_layout is not `TND` else (T1, N1, D)
+        - **softmax_sum** (Tensor[float32]) - (B, N1, S1, 8) when input_layout is not `TND` else (T1, N1, D)
+        - **softmax_out** (Tensor[float16, bfloat16]) - Useless output, ignore it. Output tensor of shape : `()`
+        - **attention_out** (Tensor[float16, bfloat16]) - The output of attention, its shape, and data type
+          are the same as the query.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('query'),
+        sig.make_sig('key'),
+        sig.make_sig('value'),
+        sig.make_sig('real_shift', default=None),
+        sig.make_sig('drop_mask', default=None),
+        sig.make_sig('padding_mask', default=None),
+        sig.make_sig('attn_mask', default=None),
+        sig.make_sig('prefix', default=None),
+        sig.make_sig('actual_seq_qlen', default=None),
+        sig.make_sig('actual_seq_kvlen', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, head_num, keep_prob=1.0, scale_value=1.0, pre_tokens=2147483647, next_tokens=2147483647, inner_precise=0, input_layout='BSH', sparse_mode=0):
+        self._set_prim_arg("head_num", head_num)
+        self._set_prim_arg("keep_prob", keep_prob)
+        self._set_prim_arg("scale_value", scale_value)
+        self._set_prim_arg("pre_tokens", pre_tokens)
+        self._set_prim_arg("next_tokens", next_tokens)
+        self._set_prim_arg("inner_precise", inner_precise)
+        self._set_prim_arg_with_handler("input_layout", input_layout, str_to_enum)
+        self._set_prim_arg("sparse_mode", sparse_mode)
+
+    def __call__(self, query, key, value, real_shift=None, drop_mask=None, padding_mask=None, attn_mask=None, prefix=None, actual_seq_qlen=None, actual_seq_kvlen=None):
+          return _convert_stub(pyboost_flash_attention_score(self, [query, key, value, real_shift, drop_mask, padding_mask, attn_mask, prefix, actual_seq_qlen, actual_seq_kvlen, self.head_num, self.keep_prob, self.scale_value, self.pre_tokens, self.next_tokens, self.inner_precise, self.input_layout, self.sparse_mode]))
+
+class FlattenExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.FlattenExt()
+        out = prim(input, start_dim, end_dim)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.flatten_ext(input, start_dim, end_dim)
+        
+    Refer to :func:`mindspore.ops.flatten_ext` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('start_dim', default=0),
+        sig.make_sig('end_dim', default=-1),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, start_dim=0, end_dim=-1):
+          return _convert_stub(pyboost_flatten_ext(self, [input, start_dim, end_dim]))
+
+flatten_ext_op=FlattenExt()
+
+
+class Flatten(Primitive):
+    r"""
+    Flattens a tensor without changing its batch size on the 0-th axis.
+
+    Refer to :func:`mindspore.ops.flatten` for more details.
+
+    Inputs:
+        - **input_x** (Tensor) - Tensor of shape :math:`(N, \ldots)` to be flattened, where :math:`N` is batch size.
+
+    Outputs:
+        Tensor, the shape of the output tensor is :math:`(N, X)`, where :math:`X` is
+        the product of the remaining dimension.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
+        >>> flatten = ops.Flatten()
+        >>> output = flatten(input_x)
+        >>> print(output.shape)
+        (1, 24)
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input_x):
+          return super().__call__(input_x)
+
+
+flatten_op=Flatten()
+
+
+class FloorDiv(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.FloorDiv()
+        out = prim(input, other)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.floor_divide(input, other)
+        
+    Refer to :func:`mindspore.ops.floor_divide` for more details.
+    """
+    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, other):
+          return super().__call__(input, other)
+
+
+floor_div_op=FloorDiv()
+
+
+class FloorMod(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.FloorMod()
+        out = prim(x, y)
         
     is equivalent to
     
@@ -3464,8 +4697,7 @@ class GridSampler2DGrad(Primitive):
         self._set_prim_arg("align_corners", align_corners)
 
     def __call__(self, grad, input_x, grid):
-          return super().__call__(grad, input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners)
-
+          return _convert_stub(pyboost_grid_sampler_2d_grad(self, [grad, input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners]))
 
 class GridSampler2D(Primitive):
     r"""
@@ -3547,8 +4779,7 @@ class GridSampler2D(Primitive):
         self._set_prim_arg("align_corners", align_corners)
 
     def __call__(self, input_x, grid):
-          return super().__call__(input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners)
-
+          return _convert_stub(pyboost_grid_sampler_2d(self, [input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners]))
 
 class GridSampler3DGrad(Primitive):
     r"""
@@ -3594,8 +4825,7 @@ class GridSampler3DGrad(Primitive):
         self._set_prim_arg("align_corners", align_corners)
 
     def __call__(self, grad, input_x, grid):
-          return super().__call__(grad, input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners)
-
+          return _convert_stub(pyboost_grid_sampler_3d_grad(self, [grad, input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners]))
 
 class GridSampler3D(Primitive):
     r"""
@@ -3668,7 +4898,104 @@ class GridSampler3D(Primitive):
         self._set_prim_arg("align_corners", align_corners)
 
     def __call__(self, input_x, grid):
-          return super().__call__(input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners)
+          return _convert_stub(pyboost_grid_sampler_3d(self, [input_x, grid, self.interpolation_mode, self.padding_mode, self.align_corners]))
+
+class GroupNormGrad(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('x'),
+        sig.make_sig('mean'),
+        sig.make_sig('rstd'),
+        sig.make_sig('gamma_opt'),
+        sig.make_sig('num_groups'),
+        sig.make_sig('dx_is_require', default=True),
+        sig.make_sig('dgamma_is_require', default=True),
+        sig.make_sig('dbeta_is_require', default=True),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, x, mean, rstd, gamma_opt, num_groups, dx_is_require=True, dgamma_is_require=True, dbeta_is_require=True):
+          return _convert_stub(pyboost_group_norm_grad(self, [dy, x, mean, rstd, gamma_opt, num_groups, dx_is_require, dgamma_is_require, dbeta_is_require]))
+
+group_norm_grad_op=GroupNormGrad()
+
+
+class GroupNorm(Primitive):
+    r"""
+    Group Normalization over a mini-batch of inputs.
+
+    Group Normalization is widely used in recurrent neural networks. It applies
+    normalization on a mini-batch of inputs for each single training case as described
+    in the paper `Group Normalization <https://arxiv.org/pdf/1803.08494.pdf>`_. Group Normalization
+    divides the channels into groups and computes within each group the mean and variance for normalization,
+    and it performs very stable over a wide range of batch size. :math:`\gamma` and :math:`\beta` are trainable scale
+    and shift.
+    It can be described using the following formula:
+
+    .. math::
+        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
+
+    where :math:`\gamma` is `weight`, :math:`\beta` is `bias`, :math:`\epsilon` is `eps`.
+
+    Args:
+        input (Tensor): The input feature with shape :math:`(N, C, *)` where :math:`*` means, any number of
+            additional dimensions.
+        num_groups (int): The number of groups to be divided along the channel dimension.
+        weight (Tensor, optional): The shape :math:`(C,)`, Default: ``None``, has the same data type with `input`.
+        bias (Tensor, optional): The shape :math:`(C,)`, Default: ``None``, has the same data type with `input`.
+        eps (float, optional): A value added to the denominator for numerical stability. Default: ``1e-5`` .
+
+    Returns:
+        Tensor, the normalized and scaled offset tensor, has the same shape and data type as the `input`.
+
+    Raises:
+        TypeError: If `num_groups` is not an int.
+        TypeError: If `eps` is not a float.
+        ValueError: If `num_groups` is less than 1.
+        ValueError: If `C` (the second parameter of dimensions of `input`) is not divided by `num_groups`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> x = ms.Tensor(np.ones([1, 2, 4, 4], np.float32))
+        >>> group_norm_op = ops.GroupNorm()
+        >>> output = group_norm_op(x, 2)[0]
+        >>> print(output)
+        [[[[0. 0. 0. 0.]
+           [0. 0. 0. 0.]
+           [0. 0. 0. 0.]
+           [0. 0. 0. 0.]]
+          [[0. 0. 0. 0.]
+           [0. 0. 0. 0.]
+           [0. 0. 0. 0.]
+           [0. 0. 0. 0.]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input', dtype=sig.sig_dtype.T),
+        sig.make_sig('num_groups', dtype=sig.sig_dtype.T1),
+        sig.make_sig('weight', dtype=sig.sig_dtype.T, default=None),
+        sig.make_sig('bias', dtype=sig.sig_dtype.T, default=None),
+        sig.make_sig('eps', dtype=sig.sig_dtype.T2, default=1e-5),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, num_groups, weight=None, bias=None, eps=1e-5):
+          return _convert_stub(pyboost_group_norm(self, [input, num_groups, weight, bias, eps]))
+
+group_norm_op=GroupNorm()
 
 
 class HShrinkGrad(Primitive):
@@ -4065,19 +5392,108 @@ class IsFinite(Primitive):
     
     .. code-block::
     
-        ops.is_finite(x)
+        ops.isfinite(x)
         
-    Refer to :func:`mindspore.ops.is_finite` for more details.
+    Refer to :func:`mindspore.ops.isfinite` for more details.
     """
     @prim_arg_register
     def __init__(self):
         pass
 
     def __call__(self, x):
-          return super().__call__(x)
+          return _convert_stub(pyboost_isfinite(self, [x]))
+
+isfinite_op=IsFinite()
+
+
+class LayerNormExt(Primitive):
+    r"""
+    Applies the Layer Normalization to the input tensor.
+
+    This operator will normalize the input tensor on given axis. LayerNorm is described in the paper
+    `Layer Normalization <https://arxiv.org/abs/1607.06450>`_.
+
+    .. math::
+        y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
+
+    where :math:`\gamma` is weight, :math:`\beta` is bias, :math:`\epsilon` is eps.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, \ldots)`. The input of LayerNorm.
+        normalized_shape (Union(tuple[int], list[int])): The normalized shape of `input` for LayerNorm.
+        weight (Tensor, optional): Learnable parameter :math:`\gamma` . Tensor of shape `normalized_shape`. Default: ``None`` .
+        bias (Tensor, optional): Learnable parameter :math:`\beta` . Tensor of shape `normalized_shape`. Default: ``None`` .
+        eps (float, optional): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
+
+    Returns:
+        tuple[Tensor], tuple of 3 tensors, the normalized input and the updated parameters.
+
+        - **output_x** (Tensor) - The normalized input, has the same type and shape as the `input_x`.
+        - **mean** (Tensor) - The first `begin_norm_axis` (The begin axis of the `input_x` to apply LayerNorm) dimensions of `mean` shape is the same as `input_x`,
+          and the remaining dimensions are 1. Suppose the shape of the `input_x` is :math:`(x_1, x_2, \ldots, x_R)`,
+          the shape of the `mean` is :math:`(x_1, \ldots, x_{begin_params_axis}, 1, \ldots, 1)`
+          (when `begin_params_axis=0`, the shape of `mean` is :math:`(1, \ldots, 1)` ).
+        - **rstd** (Tensor) - Shape is the same as `mean` .
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `normalized_shape` is not an integer, a list or a tuple.
+        TypeError: If `eps` is not a float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.array([[1, 2, 3], [1, 2, 3]]), mindspore.float32)
+        >>> normalized_shape = (3,)
+        >>> gamma = Tensor(np.ones(normalized_shape), mindspore.float32)
+        >>> beta = Tensor(np.zeros(normalized_shape), mindspore.float32)
+        >>> eps = 1e-7
+        >>> layer_norm = ops.LayerNormExt()
+        >>> output, mean, rstd = layer_norm(input_x, normalized_shape, gamma, beta, eps)
+        >>> print(output)
+        [[-1.2247448  0.         1.2247448]
+         [-1.2247448  0.         1.2247448]]
+        >>> print(mean)
+        [[2.]
+         [2.]]
+        >>> print(rstd)
+        [[1.2247447]
+         [1.2247447]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('normalized_shape'),
+        sig.make_sig('weight', default=None),
+        sig.make_sig('bias', default=None),
+        sig.make_sig('eps', default=1e-5),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, normalized_shape, weight=None, bias=None, eps=1e-5):
+          return _convert_stub(pyboost_layer_norm_ext(self, [input, normalized_shape, weight, bias, eps]))
+
+layer_norm_ext_op=LayerNormExt()
+
+
+class LayerNormGradExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
 
+    def __call__(self, dy, x, normalized_shape, mean, variance, gamma, beta):
+          return _convert_stub(pyboost_layer_norm_grad_ext(self, [dy, x, normalized_shape, mean, variance, gamma, beta]))
 
-is_finite_op=IsFinite()
+layer_norm_grad_ext_op=LayerNormGradExt()
 
 
 class LayerNormGradGrad(Primitive):
@@ -4321,36 +5737,97 @@ class LayerNormV3(Primitive):
           return super().__call__(input_x, gamma, beta, self.begin_norm_axis, self.begin_params_axis, self.epsilon)
 
 
-class LessEqual(Primitive):
+class LeakyReLUExt(Primitive):
     r"""
     .. code-block::
         
-        prim = ops.LessEqual()
-        out = prim(input, other)
+        prim = ops.LeakyReLUExt()
+        out = prim(input, negative_slope)
         
     is equivalent to
     
     .. code-block::
     
-        ops.less_equal(input, other)
+        ops.leaky_relu_ext(input, negative_slope)
         
-    Refer to :func:`mindspore.ops.less_equal` for more details.
+    Refer to :func:`mindspore.ops.leaky_relu_ext` for more details.
     """
-    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('negative_slope', default=0.01),
+    )
 
     @prim_arg_register
     def __init__(self):
         pass
 
-    def __call__(self, input, other):
-          return _convert_stub(pyboost_less_equal(self, [input, other]))
+    def __call__(self, input, negative_slope=0.01):
+          return _convert_stub(pyboost_leaky_relu_ext(self, [input, negative_slope]))
 
-less_equal_op=LessEqual()
+leaky_relu_ext_op=LeakyReLUExt()
 
 
-class Less(Primitive):
+class LeakyReLUGradExt(Primitive):
     r"""
-    .. code-block::
+    Computes gradient for the LeakyReLU activation.
+
+    Args:
+        dy (Tensor): Input gradients tensor, has the same dtype and shape as `input`.
+        input (Tensor): Origin input tensor.
+        negative_slope (Scalar): Origin negative_slope
+        is_result(bool): Output input if True.
+
+    Returns:
+        Tensor, has the same dtype and shape as `input`.
+        
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input'),
+        sig.make_sig('negative_slope', default=0.01),
+        sig.make_sig('is_result', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input, negative_slope=0.01, is_result=False):
+          return _convert_stub(pyboost_leaky_relu_grad_ext(self, [dy, input, negative_slope, is_result]))
+
+leaky_relu_grad_ext_op=LeakyReLUGradExt()
+
+
+class LessEqual(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.LessEqual()
+        out = prim(input, other)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.less_equal(input, other)
+        
+    Refer to :func:`mindspore.ops.less_equal` for more details.
+    """
+    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, other):
+          return _convert_stub(pyboost_less_equal(self, [input, other]))
+
+less_equal_op=LessEqual()
+
+
+class Less(Primitive):
+    r"""
+    .. code-block::
         
         prim = ops.Less()
         out = prim(input, other)
@@ -4370,12 +5847,32 @@ class Less(Primitive):
         pass
 
     def __call__(self, input, other):
-          return super().__call__(input, other)
-
+          return _convert_stub(pyboost_less(self, [input, other]))
 
 less_op=Less()
 
 
+class LinSpaceExt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('start'),
+        sig.make_sig('end'),
+        sig.make_sig('steps'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, start, end, steps, dtype=None):
+          return _convert_stub(pyboost_lin_space_ext(self, [start, end, steps, dtype if dtype is None else dtype_to_type_id('LinSpaceExt', 'dtype', dtype)]))
+
+lin_space_ext_op=LinSpaceExt()
+
+
 class LinSpace(Primitive):
     r"""
     Returns a Tensor whose value is `num` evenly spaced in the interval `start` and `stop` (including `start` and
@@ -4838,6 +6335,88 @@ class MaskedFill(Primitive):
 masked_fill_op=MaskedFill()
 
 
+class MatMulExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.MatMulExt()
+        out = prim(input, mat2)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.matmul_ext(input, mat2)
+        
+    Refer to :func:`mindspore.ops.matmul_ext` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, mat2):
+          return _convert_stub(pyboost_matmul_ext(self, [input, mat2]))
+
+matmul_ext_op=MatMulExt()
+
+
+class MatMul(Primitive):
+    r"""
+    Multiplies matrix `a` and matrix `b`.
+
+    .. math::
+
+    Output_{i j}=\sum_{k=1}^{p} a_{i k} b_{k j}=a_{i 1} b_{1 j}+a_{i 2} b_{2 j}+\cdots+a_{i p} b_{p j}, p\in N
+
+    where the :math:`i,j` indicates the output of the i-th row and j-th column element.
+
+    Note:
+        - If :math:`N * M` cannot be divided by 16, the performance will be poor in ascend environment.
+        - The dtype of inputs must be same.
+        - On Ascend, float64 doesn't be supported.
+
+    Args:
+        transpose_a (bool): If ``True`` , `a` is transposed before multiplication. Default: ``False`` .
+        transpose_b (bool): If ``True`` , `b` is transposed before multiplication. Default: ``False`` .
+
+    Inputs:
+        - **a** (Tensor) - The first tensor to be multiplied. The shape of the tensor is :math:`(N, C)`. If
+          `transpose_a` is ``True`` , its shape must be :math:`(C, N)` after transpose.
+        - **b** (Tensor) - The second tensor to be multiplied. The shape of the tensor is :math:`(C, M)`. If
+          `transpose_b` is ``True`` , its shape must be :math:`(M, C)` after transpose.
+
+    Outputs:
+        Tensor, the shape of the output tensor is :math:`(N, M)`.
+
+    Raises:
+        TypeError: If `transpose_a` or `transpose_b` is not a bool.
+        TypeError: If the dtype of `a` and the dtype of `b` are not the same.
+        ValueError: If the column of matrix dimensions of `a` is not equal to
+            the row of matrix dimensions of `b`.
+        ValueError: If length of shape of `a` or `b` is not equal to 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
+        >>> b = Tensor(np.ones(shape=[3, 4]), mindspore.float32)
+        >>> matmul = ops.MatMul()
+        >>> output = matmul(a, b)
+        >>> print(output)
+        [[3. 3. 3. 3.]]
+    """
+    @prim_arg_register
+    def __init__(self, transpose_a=False, transpose_b=False):
+        self._set_prim_arg("transpose_a", transpose_a)
+        self._set_prim_arg("transpose_b", transpose_b)
+
+    def __call__(self, input, mat2):
+          return _convert_stub(pyboost_matmul(self, [input, mat2, self.transpose_a, self.transpose_b]))
+
 class MatrixDeterminant(Primitive):
     r"""
     Calculates the value of the determinant for one or more square matrices.
@@ -4898,6 +6477,215 @@ class MatrixExp(Primitive):
 matrix_exp_op=MatrixExp()
 
 
+class Max(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Max()
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.max_(input)
+        
+    Refer to :func:`mindspore.ops.max_` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input):
+          return _convert_stub(pyboost_max(self, [input]))
+
+max_op=Max()
+
+
+class MaxPoolGradWithIndices(Primitive):
+    r"""
+    Gradients of the MaxPoolWithIndices operation.
+    """
+    @prim_arg_register
+    def __init__(self, kernel_size, strides=None, pads=0, dilation=(1, 1), ceil_mode=False, argmax_type=mstype.int64):
+        self._set_prim_arg_with_handler("kernel_size", kernel_size, to_kernel_size)
+        self._set_prim_arg_with_handler("strides", strides, to_strides)
+        self._set_prim_arg_with_handler("pads", pads, to_output_padding)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("ceil_mode", ceil_mode)
+        self._set_prim_arg_with_handler("argmax_type", argmax_type, dtype_to_type_id)
+
+    def __call__(self, x, grad, argmax):
+          return _convert_stub(pyboost_max_pool_grad_with_indices(self, [x, grad, argmax, self.kernel_size, self.strides, self.pads, self.dilation, self.ceil_mode, self.argmax_type]))
+
+class MaxPoolGradWithMask(Primitive):
+    r"""
+    Gradients of the MaxPoolWithMask operation.
+    """
+    @prim_arg_register
+    def __init__(self, kernel_size, strides=None, pads=0, dilation=(1, 1), ceil_mode=False, argmax_type=mstype.int64):
+        self._set_prim_arg_with_handler("kernel_size", kernel_size, to_kernel_size)
+        self._set_prim_arg_with_handler("strides", strides, to_strides)
+        self._set_prim_arg_with_handler("pads", pads, to_output_padding)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("ceil_mode", ceil_mode)
+        self._set_prim_arg_with_handler("argmax_type", argmax_type, dtype_to_type_id)
+
+    def __call__(self, x, grad, mask):
+          return _convert_stub(pyboost_max_pool_grad_with_mask(self, [x, grad, mask, self.kernel_size, self.strides, self.pads, self.dilation, self.ceil_mode, self.argmax_type]))
+
+class MaxPoolWithIndices(Primitive):
+    r"""
+    Performs max pooling on the input Tensor and returns both max values and indices.
+
+    Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool outputs
+    regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
+    :math:`(h_{ker}, w_{ker})` and stride :math:`(s_0, s_1)`, the operation is as follows:
+
+    .. math::
+        \text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion. Only support on Atlas training series.
+
+    Args:
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value and argmax
+            value, is an int number that represents height and width of the kernel, or a tuple of
+            two int numbers that represent height and width respectively.
+        strides (Union[int, tuple[int]], optional): The distance of kernel moving, an int number that represents
+            not only the height of movement but also the width of movement, or a tuple of two int numbers that
+            represent height and width of movement respectively. Default: ``None`` , meaning that
+            `strides = kernel_size`.
+        pads (Union[int, tuple[int]], optional): An int number that represents the depth,
+            height and width of movement are both strides, or a tuple of two int numbers that represent
+            depth, height and width of movement respectively.
+            Default: 0.
+        dilation (Union[int, tuple[int]], optional): Control the stride of elements in the kernel. Default: ``(1, 1)`` .
+        ceil_mode (bool, optional): Whether to use ceil instead of floor to calculate output shape. Default: ``False`` .
+        argmax_type (mindspore.dtype, optional) : The dtype for argmax.
+            Default: ``mstype.int64`` . [Disabled in Ascend.]
+
+    Inputs:
+        - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})` with data type of float32 in Ascend.
+
+    Outputs:
+        Tuple of 2 Tensors, representing the maxpool result and where the max values are generated.
+
+        - **output** (Tensor) - Maxpooling result, with shape :math:`(N_{out}, C_{out}, H_{out}, W_{out})`.
+          It has the same data type as `x`.
+
+          .. math::
+              H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{pads[0]} - \text{dilation[0]}
+               \times (\text{kernel_size[0]} - 1) - 1}{\text{strides[0]}} + 1\right\rfloor
+
+          .. math::
+              W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{pads[1]} - \text{dilation[1]}
+               \times (\text{kernel_size[1]} - 1) - 1}{\text{strides[1]}} + 1\right\rfloor
+
+        - **argmax** (Tensor) - Index corresponding to the maximum value. Data type is int32 in Ascend.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        ValueError: If length of shape of `x` is not equal to 4.
+        TypeError: If `kernel_size` , `strides` , `pads` or `dilation` is not int or tuple.
+        ValueError: If `kernel_size`, `strides` or `dilation` is less than 1.
+        ValueError: If `pads` is less than 0.
+        ValueError: If `pads` is more than half of `kernel_size`.
+        TypeError: If `ceil_mode` is not bool.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    @prim_arg_register
+    def __init__(self, kernel_size, strides=None, pads=0, dilation=(1, 1), ceil_mode=False, argmax_type=mstype.int64):
+        self._set_prim_arg_with_handler("kernel_size", kernel_size, to_kernel_size)
+        self._set_prim_arg_with_handler("strides", strides, to_strides)
+        self._set_prim_arg_with_handler("pads", pads, to_output_padding)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("ceil_mode", ceil_mode)
+        self._set_prim_arg_with_handler("argmax_type", argmax_type, dtype_to_type_id)
+
+    def __call__(self, x):
+          return _convert_stub(pyboost_max_pool_with_indices(self, [x, self.kernel_size, self.strides, self.pads, self.dilation, self.ceil_mode, self.argmax_type]))
+
+class MaxPoolWithMask(Primitive):
+    r"""
+    Performs max pooling on the input Tensor and returns both max values and mask.
+
+    Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool outputs
+    regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
+    :math:`(h_{ker}, w_{ker})` and stride :math:`(s_0, s_1)`, the operation is as follows:
+
+    .. math::
+        \text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion. Only support on Atlas training series.
+
+    Args:
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value and argmax
+            value, is an int number that represents height and width of the kernel, or a tuple of
+            two int numbers that represent height and width respectively.
+        strides (Union[int, tuple[int]], optional): The distance of kernel moving, an int number that represents
+            not only the height of movement but also the width of movement, or a tuple of two int numbers that
+            represent height and width of movement respectively. Default: ``1``.
+        pads (Union[int, tuple[int]], optional): An int number that represents the depth,
+            height and width of movement are both strides, or a tuple of two int numbers that represent
+            depth, height and width of movement respectively.
+            Default: 0.
+        dilation (Union[int, tuple[int]], optional): Control the stride of elements in the kernel.
+            Default: ``(1, 1)`` .
+        ceil_mode (bool, optional): Whether to use ceil instead of floor to calculate output shape.
+            Default: ``False`` .
+        argmax_type (mindspore.dtype, optional) : The dtype for argmax.
+            Default: ``mstype.int64`` . [Disabled in Ascend.]
+
+    Inputs:
+        - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})` with data type of float16
+          and float32 in Ascend.
+
+    Outputs:
+        Tuple of 2 Tensors, representing the maxpool result and mask are generated.
+
+        - **output** (Tensor) - Maxpooling result, with shape :math:`(N_{out}, C_{out}, H_{out}, W_{out})`.
+          It has the same data type as `x`.
+
+          .. math::
+              H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{pads[0]} - \text{dilation[0]}
+               \times (\text{kernel_size[0]} - 1) - 1}{\text{strides[0]}} + 1\right\rfloor
+
+          .. math::
+              W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{pads[1]} - \text{dilation[1]}
+               \times (\text{kernel_size[1]} - 1) - 1}{\text{strides[1]}} + 1\right\rfloor
+
+        - **mask** (Tensor) - Maxpooling mask. Data type is int8 in Ascend.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        ValueError: If length of shape of `x` is not equal to 4.
+        TypeError: If `kernel_size` , `strides` , `pads` or `dilation` is not int or tuple.
+        ValueError: If `kernel_size`, `strides` or `dilation` is less than 1.
+        ValueError: If `pads` is less than 0.
+        ValueError: If `pads` is more than half of `kernel_size`.
+        TypeError: If `ceil_mode` is not bool.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    @prim_arg_register
+    def __init__(self, kernel_size, strides=None, pads=0, dilation=(1, 1), ceil_mode=False, argmax_type=mstype.int64):
+        self._set_prim_arg_with_handler("kernel_size", kernel_size, to_kernel_size)
+        self._set_prim_arg_with_handler("strides", strides, to_strides)
+        self._set_prim_arg_with_handler("pads", pads, to_output_padding)
+        self._set_prim_arg_with_handler("dilation", dilation, to_dilations)
+        self._set_prim_arg("ceil_mode", ceil_mode)
+        self._set_prim_arg_with_handler("argmax_type", argmax_type, dtype_to_type_id)
+
+    def __call__(self, x):
+          return _convert_stub(pyboost_max_pool_with_mask(self, [x, self.kernel_size, self.strides, self.pads, self.dilation, self.ceil_mode, self.argmax_type]))
+
 class MaximumGradGrad(Primitive):
     r"""
     Grad for maximum grad.
@@ -4946,12 +6734,68 @@ class Maximum(Primitive):
         pass
 
     def __call__(self, input, other):
-          return super().__call__(input, other)
-
+          return _convert_stub(pyboost_maximum(self, [input, other]))
 
 maximum_op=Maximum()
 
 
+class MeanExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.MeanExt()
+        out = prim(input, axis, keep_dims, dtype)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.mean_ext(input, axis, keep_dims, dtype)
+        
+    Refer to :func:`mindspore.ops.mean_ext` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('axis', default=None),
+        sig.make_sig('keep_dims', default=False),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, axis=None, keep_dims=False, dtype=None):
+          return _convert_stub(pyboost_mean_ext(self, [input, axis, keep_dims, dtype if dtype is None else dtype_to_type_id('MeanExt', 'dtype', dtype)]))
+
+mean_ext_op=MeanExt()
+
+
+class Min(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Min()
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.min_(input)
+        
+    Refer to :func:`mindspore.ops.min_` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input):
+          return _convert_stub(pyboost_min(self, [input]))
+
+min_op=Min()
+
+
 class MinimumGrad(Primitive):
     r"""
     Grad for minimum.
@@ -4987,42 +6831,102 @@ class Minimum(Primitive):
         pass
 
     def __call__(self, input, other):
-          return super().__call__(input, other)
-
+          return _convert_stub(pyboost_minimum(self, [input, other]))
 
 minimum_op=Minimum()
 
 
-class Mul(Primitive):
+class MoeFinalizeRouting(Primitive):
     r"""
     .. code-block::
         
-        prim = ops.Mul()
-        out = prim(input, other)
+        prim = ops.MoeFinalizeRouting()
+        out = prim(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
         
     is equivalent to
     
     .. code-block::
     
-        ops.mul(input, other)
+        ops.moe_finalize_routing(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
         
-    Refer to :func:`mindspore.ops.mul` for more details.
+    Refer to :func:`mindspore.ops.moe_finalize_routing` for more details.
     """
     __mindspore_signature__ =  (
-        sig.make_sig('input', sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T),
-        sig.make_sig('other', sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T),
+        sig.make_sig('expanded_x'),
+        sig.make_sig('x1'),
+        sig.make_sig('x2', default=None),
+        sig.make_sig('bias', default=None),
+        sig.make_sig('scales', default=None),
+        sig.make_sig('expanded_row_idx', default=None),
+        sig.make_sig('expanded_expert_idx', default=None),
     )
 
     @prim_arg_register
     def __init__(self):
         pass
 
-    def __call__(self, input, other):
+    def __call__(self, expanded_x, x1, x2=None, bias=None, scales=None, expanded_row_idx=None, expanded_expert_idx=None):
+          return super().__call__(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
+
+
+moe_finalize_routing_op=MoeFinalizeRouting()
+
+
+class Mul(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Mul()
+        out = prim(input, other)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.mul(input, other)
+        
+    Refer to :func:`mindspore.ops.mul` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input', sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T),
+        sig.make_sig('other', sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, other):
           return _convert_stub(pyboost_mul(self, [input, other]))
 
 mul_op=Mul()
 
 
+class Mv(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Mv()
+        out = prim(input, vec)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.mv(input, vec)
+        
+    Refer to :func:`mindspore.ops.mv` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, vec):
+          return _convert_stub(pyboost_mv(self, [input, vec]))
+
+mv_op=Mv()
+
+
 class NanToNum(Primitive):
     r"""
     Replaces `NaN`, positive infinity and negative infinity values in the input Tensor with the values
@@ -5249,6 +7153,56 @@ class NonZero(Primitive):
 non_zero_op=NonZero()
 
 
+class Norm(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input_x'),
+        sig.make_sig('ord', default=None),
+        sig.make_sig('dim', default=None),
+        sig.make_sig('keepdim', default=False),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input_x, ord=None, dim=None, keepdim=False, dtype=None):
+          return _convert_stub(pyboost_norm(self, [input_x, ord, dim, keepdim, dtype if dtype is None else dtype_to_type_id('Norm', 'dtype', dtype)]))
+
+norm_op=Norm()
+
+
+class NormalExt(Primitive):
+    r"""
+    Generates random numbers according to the Normal random number distribution.
+
+    Inputs:
+        - **mean** (Union[float, Tensor]) - The mean is a tensor with the mean of each output element's normal distribution.
+        - **std** (Union[float, Tensor]) - The tensor of per-element standard deviations.
+        - **generator** (Generator, optional) - Mindspore generator.
+
+    Outputs:
+        - **output** (Tensor) - With the same type and shape as the 'mean'.
+
+    Raises:
+        TypeError: If `mean` or `std` is not Union[float, Tensor].
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, mean, std, seed, offset):
+          return _convert_stub(pyboost_normal_ext(self, [mean, std, seed, offset]))
+
+normal_ext_op=NormalExt()
+
+
 class NotEqual(Primitive):
     r"""
     .. code-block::
@@ -5444,6 +7398,49 @@ class NPUGetFloatStatusV2(Primitive):
 npu_get_float_status_v2_op=NPUGetFloatStatusV2()
 
 
+class OneHotExt(Primitive):
+    r"""
+    Computes a one-hot tensor.
+
+    The locations represented by tensor in `tensor` take value `1`, while all
+    other locations take value `0`.
+
+    Args:
+        - **tensor** (Tensor) - A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
+          Data type must be int32 or int64.
+        - **num_classes** (int) - A scalar defining the depth of the one-hot dimension.
+
+    Returns:
+        Tensor, one-hot tensor.
+
+    Raises:
+        TypeError: If `num_classes` is not an int.
+        TypeError: If dtype of `tensor` is not int32 or int64.
+        ValueError: If `num_classes` is less than 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> import mindspore.ops as ops
+        >>> from mindspore import Tensor
+        >>> tensor = Tensor(np.array([0, 1, 2]), mindspore.int32)
+        >>> num_classes = 3
+        >>> output = ops.extend.one_hot(tensor, num_classes)
+        >>> print(output)
+        [[1. 0. 0.]
+         [0. 1. 0.]
+         [0. 0. 1.]]
+    """
+    @prim_arg_register
+    def __init__(self, axis=-1):
+        self._set_prim_arg("axis", axis)
+
+    def __call__(self, tensor, num_classes, on_value, off_value):
+          return _convert_stub(pyboost_one_hot_ext(self, [tensor, num_classes, on_value, off_value, self.axis]))
+
 class OneHot(Primitive):
     r"""
     Computes a one-hot tensor.
@@ -5504,6 +7501,36 @@ class OneHot(Primitive):
           return super().__call__(indices, depth, on_value, off_value, self.axis)
 
 
+class OnesLikeExt(Primitive):
+    r"""
+    Returns a Tensor with a value of 1 and its shape and data type is the same as the input.
+
+    Refer to :func:`mindspore.ops.ones_like` for more details.
+
+    Args:
+        - **input_x** (Tensor) - Tensor of any dimension.
+
+    Returns:
+        Tensor, has the same shape and type as `input_x` but filled with ones.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dtype=None):
+          return _convert_stub(pyboost_ones_like_ext(self, [input, dtype if dtype is None else dtype_to_type_id('OnesLikeExt', 'dtype', dtype)]))
+
+ones_like_ext_op=OnesLikeExt()
+
+
 class OnesLike(Primitive):
     r"""
     Returns a Tensor with a value of 1 and its shape and data type is the same as the input.
@@ -5611,8 +7638,7 @@ class Pow(Primitive):
         pass
 
     def __call__(self, input, exponent):
-          return super().__call__(input, exponent)
-
+          return _convert_stub(pyboost_pow(self, [input, exponent]))
 
 pow_op=Pow()
 
@@ -5673,6 +7699,98 @@ class PReLU(Primitive):
 prelu_op=PReLU()
 
 
+class ProdExt(Primitive):
+    r"""
+    Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
+    reduce a dimension of `input` along the `axis`. Determine whether the dimensions of the output and input are the
+    same by controlling `keep_dims`.
+
+    Args:
+        input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
+            :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        axis (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions.
+            Only constant value is allowed. Assume the rank of `input` is r, and the value range is [-r,r).
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+            If ``False`` , don't keep these dimensions. Default: ``False`` .
+        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        Tensor, has the same data type as input tensor.
+
+        - If `axis` is ``None`` , and `keep_dims` is  ``False`` ,
+          the output is a 0-D tensor representing the product of all elements in the input tensor.
+        - If `axis` is int, set as 1, and `keep_dims` is  ``False`` ,
+          the shape of output is :math:`(input_0, input_2, ..., input_R)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `axis` is not one of the following: int or None.
+        TypeError: If `keep_dims` is not a bool.
+        ValueError: If `axis` is out of range.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> output = ops.ProdExt()(x, 1, keep_dims=True)
+        >>> result = output.shape
+        >>> print(result)
+        (3, 1, 5, 6)
+        >>> # case 1: Reduces a dimension by multiplying all elements in the dimension.
+        >>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
+        ...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
+        >>> output = ops.ProdExt()(x)
+        >>> print(output)
+        2.2833798e+33
+        >>> print(output.shape)
+        ()
+        >>> # case 2: Reduces a dimension along axis 0.
+        >>> output = ops.ProdExt()(x, 0, True)
+        >>> print(output)
+        [[[ 28.  28.  28.  28.  28.  28.]
+        [ 80.  80.  80.  80.  80.  80.]
+        [162. 162. 162. 162. 162. 162.]]]
+        >>> # case 3: Reduces a dimension along axis 1.
+        >>> output = ops.ProdExt()(x, 1, True)
+        >>> print(output)
+        [[[  6.   6.   6.   6.   6.   6.]]
+        [[120. 120. 120. 120. 120. 120.]]
+        [[504. 504. 504. 504. 504. 504.]]]
+        >>> # case 4: Reduces a dimension along axis 2.
+        >>> output = ops.ProdExt()(x, 2, True)
+        >>> print(output)
+        [[[1.00000e+00]
+        [6.40000e+01]
+        [7.29000e+02]]
+        [[4.09600e+03]
+        [1.56250e+04]
+        [4.66560e+04]]
+        [[1.17649e+05]
+        [2.62144e+05]
+        [5.31441e+05]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('axis', default=None),
+        sig.make_sig('keep_dims', default=False),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, axis=None, keep_dims=False, dtype=None):
+          return _convert_stub(pyboost_prod_ext(self, [input, axis, keep_dims, dtype if dtype is None else dtype_to_type_id('ProdExt', 'dtype', dtype)]))
+
+prod_ext_op=ProdExt()
+
+
 class PromptKVCache(Primitive):
     r"""
     .. code-block::
@@ -5780,8 +7898,7 @@ class QuantBatchMatmul(Primitive):
         self._set_prim_arg_with_handler("dtype", dtype, dtype_to_type_id)
 
     def __call__(self, x1, x2, scale, offset=None, bias=None):
-          return super().__call__(x1, x2, scale, offset, bias, self.transpose_x1, self.transpose_x2, self.dtype)
-
+          return _convert_stub(pyboost_quant_batch_matmul(self, [x1, x2, scale, offset, bias, self.transpose_x1, self.transpose_x2, self.dtype]))
 
 class RandpermV2(Primitive):
     r"""
@@ -5957,7 +8074,34 @@ reciprocal_op=Reciprocal()
 
 class ReduceAll(Primitive):
     r"""
-    Reduces a dimension of a tensor by the "logicalAND" of all elements in the dimension, by default. And also can
+    .. code-block::
+        
+        prim = ops.ReduceAll(keep_dims)
+        out = prim(input, axis)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.all(input, axis, keep_dims)
+        
+    Refer to :func:`mindspore.ops.all` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('axis', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, keep_dims=False):
+        self._set_prim_arg("keep_dims", keep_dims)
+
+    def __call__(self, input, axis=None):
+          return _convert_stub(pyboost_reduce_all(self, [input, axis, self.keep_dims]))
+
+class ReduceAny(Primitive):
+    r"""
+    Reduces a dimension of a tensor by the "logical OR" of all elements in the dimension, by default. And also can
     reduce a dimension of `x` along the `axis`. Determine whether the dimensions of the output and input are the
     same by controlling `keep_dims`.
 
@@ -5977,7 +8121,7 @@ class ReduceAll(Primitive):
         Tensor, the dtype is bool.
 
         - If `axis` is ``()`` , and `keep_dims` is ``False`` ,
-          the output is a 0-D tensor representing the "logical and" of all elements in the input tensor.
+          the output is a 0-D tensor representing the "logical or" of all elements in the input tensor.
         - If `axis` is int, set as 2, and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_1, x_3, ..., x_R)`.
         - If `axis` is tuple(int), set as (2, 3), and `keep_dims` is ``False`` ,
@@ -5997,25 +8141,25 @@ class ReduceAll(Primitive):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[True, False], [True, True]]))
-        >>> op = ops.ReduceAll(keep_dims=True)
-        >>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
+        >>> op = ops.ReduceAny(keep_dims=True)
+        >>> # case 1: Reduces a dimension by the "logical OR" of all elements in the dimension.
         >>> output = op(x)
         >>> print(output)
-        [[False]]
+        [[ True]]
         >>> print(output.shape)
         (1, 1)
         >>> # case 2: Reduces a dimension along axis 0.
         >>> output = op(x, 0)
         >>> print(output)
-        [[ True False]]
+        [[ True True]]
         >>> # case 3: Reduces a dimension along axis 1.
         >>> output = op(x, 1)
         >>> print(output)
-        [[False]
+        [[True]
         [ True]]
         >>> # case 4: input is a scalar.
         >>> x = Tensor(True)
-        >>> op = ops.ReduceAll()
+        >>> op = ops.ReduceAny()
         >>> output = op(x)
         >>> print(output)
         True
@@ -6030,12 +8174,11 @@ class ReduceAll(Primitive):
         self._set_prim_arg("keep_dims", keep_dims)
 
     def __call__(self, x, axis=()):
-          return super().__call__(x, axis, self.keep_dims)
-
+          return _convert_stub(pyboost_reduce_any(self, [x, axis, self.keep_dims]))
 
-class ReduceAny(Primitive):
+class ReduceMax(Primitive):
     r"""
-    Reduces a dimension of a tensor by the "logical OR" of all elements in the dimension, by default. And also can
+    Reduces a dimension of a tensor by the maximum value in this dimension, by default. And also can
     reduce a dimension of `x` along the `axis`. Determine whether the dimensions of the output and input are the
     same by controlling `keep_dims`.
 
@@ -6047,89 +8190,12 @@ class ReduceAny(Primitive):
             If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[bool]) - The input tensor. The dtype of the tensor to be reduced is bool.
-        - **axis** (Union[int, tuple(int), list(int), Tensor]) - The dimensions to reduce. Default: ``()`` ,
-          reduce all dimensions. Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
+        - **x** (Tensor[Number]) - The input tensor.
+        - **axis** (Union[int, tuple(int), list(int), tensor]) - The dimensions to reduce. Default: ``()`` ,
+          reduce all dimensions. Must be in the range [-r, r).
 
     Outputs:
-        Tensor, the dtype is bool.
-
-        - If `axis` is ``()`` , and `keep_dims` is ``False`` ,
-          the output is a 0-D tensor representing the "logical or" of all elements in the input tensor.
-        - If `axis` is int, set as 2, and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(x_1, x_3, ..., x_R)`.
-        - If `axis` is tuple(int), set as (2, 3), and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(x_1, x_4, ..., x_R)`.
-        - If `axis` is 1-D Tensor, set as [2, 3], and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(x_1, x_4, ..., x_R)`.
-
-    Raises:
-        TypeError: If `keep_dims` is not a bool.
-        TypeError: If `x` is not a Tensor.
-        TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[True, False], [True, True]]))
-        >>> op = ops.ReduceAny(keep_dims=True)
-        >>> # case 1: Reduces a dimension by the "logical OR" of all elements in the dimension.
-        >>> output = op(x)
-        >>> print(output)
-        [[ True]]
-        >>> print(output.shape)
-        (1, 1)
-        >>> # case 2: Reduces a dimension along axis 0.
-        >>> output = op(x, 0)
-        >>> print(output)
-        [[ True True]]
-        >>> # case 3: Reduces a dimension along axis 1.
-        >>> output = op(x, 1)
-        >>> print(output)
-        [[True]
-        [ True]]
-        >>> # case 4: input is a scalar.
-        >>> x = Tensor(True)
-        >>> op = ops.ReduceAny()
-        >>> output = op(x)
-        >>> print(output)
-        True
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x'),
-        sig.make_sig('axis', default=()),
-    )
-
-    @prim_arg_register
-    def __init__(self, keep_dims=False):
-        self._set_prim_arg("keep_dims", keep_dims)
-
-    def __call__(self, x, axis=()):
-          return _convert_stub(pyboost_reduce_any(self, [x, axis, self.keep_dims]))
-
-class ReduceMax(Primitive):
-    r"""
-    Reduces a dimension of a tensor by the maximum value in this dimension, by default. And also can
-    reduce a dimension of `x` along the `axis`. Determine whether the dimensions of the output and input are the
-    same by controlling `keep_dims`.
-
-    Note:
-        The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
-
-    Args:
-        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
-            If ``False`` , don't keep these dimensions. Default: ``False`` .
-
-    Inputs:
-        - **x** (Tensor[Number]) - The input tensor.
-        - **axis** (Union[int, tuple(int), list(int), tensor]) - The dimensions to reduce. Default: ``()`` ,
-          reduce all dimensions. Must be in the range [-r, r).
-
-    Outputs:
-        output(Tensor): has the same dtype as the `x`.
+        output(Tensor): has the same dtype as the `x`.
 
         - If `axis` is ``()`` , and `keep_dims` is ``False`` ,
           the output is a 0-D tensor representing the maximum of all elements in the input tensor.
@@ -6656,6 +8722,90 @@ class ReduceSum(Primitive):
           return super().__call__(x, axis, self.keep_dims, self.skip_mode)
 
 
+class ReflectionPad1DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_reflection_pad_1d_grad(self, [grad_output, input, padding]))
+
+reflection_pad_1d_grad_op=ReflectionPad1DGrad()
+
+
+class ReflectionPad1D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_reflection_pad_1d(self, [input, padding]))
+
+reflection_pad_1d_op=ReflectionPad1D()
+
+
+class ReflectionPad2DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_reflection_pad_2d_grad(self, [grad_output, input, padding]))
+
+reflection_pad_2d_grad_op=ReflectionPad2DGrad()
+
+
+class ReflectionPad2D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_reflection_pad_2d(self, [input, padding]))
+
+reflection_pad_2d_op=ReflectionPad2D()
+
+
+class ReflectionPad3DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_reflection_pad_3d_grad(self, [grad_output, input, padding]))
+
+reflection_pad_3d_grad_op=ReflectionPad3DGrad()
+
+
+class ReflectionPad3D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_reflection_pad_3d(self, [input, padding]))
+
+reflection_pad_3d_op=ReflectionPad3D()
+
+
 class ReLU6Grad(Primitive):
     r"""
     Computes gradient for the ReLU6 activation.
@@ -6750,6 +8900,122 @@ class ReLU(Primitive):
 relu_op=ReLU()
 
 
+class RepeatInterleave(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.RepeatInterleave()
+        out = prim(input, repeats, axis, output_size)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.repeat_interleave(input, repeats, axis, output_size)
+        
+    Refer to :func:`mindspore.ops.repeat_interleave` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('repeats'),
+        sig.make_sig('axis', default=None),
+        sig.make_sig('output_size', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, repeats, axis=None, output_size=None):
+          return _convert_stub(pyboost_repeat_interleave(self, [input, repeats, axis, output_size]))
+
+repeat_interleave_op=RepeatInterleave()
+
+
+class ReplicationPad1DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_replication_pad_1d_grad(self, [grad_output, input, padding]))
+
+replication_pad_1d_grad_op=ReplicationPad1DGrad()
+
+
+class ReplicationPad1D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_replication_pad_1d(self, [input, padding]))
+
+replication_pad_1d_op=ReplicationPad1D()
+
+
+class ReplicationPad2DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_replication_pad_2d_grad(self, [grad_output, input, padding]))
+
+replication_pad_2d_grad_op=ReplicationPad2DGrad()
+
+
+class ReplicationPad2D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_replication_pad_2d(self, [input, padding]))
+
+replication_pad_2d_op=ReplicationPad2D()
+
+
+class ReplicationPad3DGrad(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, grad_output, input, padding):
+          return _convert_stub(pyboost_replication_pad_3d_grad(self, [grad_output, input, padding]))
+
+replication_pad_3d_grad_op=ReplicationPad3DGrad()
+
+
+class ReplicationPad3D(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, padding):
+          return _convert_stub(pyboost_replication_pad_3d(self, [input, padding]))
+
+replication_pad_3d_op=ReplicationPad3D()
+
+
 class ReshapeAndCache(Primitive):
     r"""
     .. code-block::
@@ -7218,23 +9484,22 @@ class ReverseV2(Primitive):
     .. code-block::
         
         prim = ops.ReverseV2(axis)
-        out = prim(x)
+        out = prim(input)
         
     is equivalent to
     
     .. code-block::
     
-        ops.reverse(x, axis)
+        ops.flip(input, axis)
         
-    Refer to :func:`mindspore.ops.reverse` for more details.
+    Refer to :func:`mindspore.ops.flip` for more details.
     """
     @prim_arg_register
     def __init__(self, axis):
         self._set_prim_arg("axis", type_it('ReverseV2', 'axis', axis, OpDtype.DT_LIST_INT, OpDtype.DT_TUPLE_INT))
 
-    def __call__(self, x):
-          return super().__call__(x, self.axis)
-
+    def __call__(self, input):
+          return _convert_stub(pyboost_reverse_v2(self, [input, self.axis]))
 
 class RFFTGrad(Primitive):
     r"""
@@ -7453,8 +9718,7 @@ class Rsqrt(Primitive):
         pass
 
     def __call__(self, input):
-          return super().__call__(input)
-
+          return _convert_stub(pyboost_rsqrt(self, [input]))
 
 rsqrt_op=Rsqrt()
 
@@ -7485,6 +9749,20 @@ class ScalarCast(Primitive):
 scalar_cast_op=ScalarCast()
 
 
+class ScatterAddExt(Primitive):
+    r"""
+    
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dim, index, src):
+          return _convert_stub(pyboost_scatter_add_ext(self, [input, dim, index, src]))
+
+scatter_add_ext_op=ScatterAddExt()
+
+
 class ScatterNd(Primitive):
     r"""
     .. code-block::
@@ -7527,56 +9805,25 @@ scatter_op=Scatter()
 
 class Select(Primitive):
     r"""
-    The conditional tensor determines whether the corresponding element in the output must be
-    selected from `x` (if True) or `y` (if False) based on the value of each
-    element.
-
-    It can be defined as:
-
-    .. math::
-        out_i = \begin{cases}
-        x_i, & \text{if } cond_i \\
-        y_i, & \text{otherwise}
-        \end{cases}
-
-    Inputs:
-      - **cond** (Tensor[bool]): The condition tensor, decides which element is chosen.
-        The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-      - **x** (Tensor): The first Tensor to be selected.
-        The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-      - **y** (Tensor): The second Tensor to be selected.
-        The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-
-    Outputs:
-        Tensor, has the same shape as `cond`.
-
-    Raises:
-        TypeError: If x or y is not a Tensor.
-        ValueError: The shape of inputs are different.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> # Both inputs are Tensor
-        >>> select = ops.Select()
-        >>> cond = Tensor([True, False])
-        >>> x = Tensor([2,3], mindspore.float32)
-        >>> y = Tensor([1,2], mindspore.float32)
-        >>> output = select(cond, x, y)
-        >>> print(output)
-        [2. 2.]
+    .. code-block::
+        
+        prim = ops.Select()
+        out = prim(condition, input, other)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.select(condition, input, other)
         
+    Refer to :func:`mindspore.ops.select` for more details.
     """
     @prim_arg_register
     def __init__(self):
         pass
 
-    def __call__(self, cond, x, y):
-          return super().__call__(cond, x, y)
-
+    def __call__(self, condition, input, other):
+          return _convert_stub(pyboost_select(self, [condition, input, other]))
 
 select_op=Select()
 
@@ -7759,13 +10006,27 @@ class Sinh(Primitive):
 sinh_op=Sinh()
 
 
-class SoftmaxBackward(Primitive):
+class SliceExt(Primitive):
     r"""
     
     """
-    __mindspore_signature__ =  (
-        sig.make_sig('dout'),
-        sig.make_sig('out'),
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dim, start, end, step):
+          return _convert_stub(pyboost_slice_ext(self, [input, dim, start, end, step]))
+
+slice_ext_op=SliceExt()
+
+
+class SoftmaxBackward(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dout'),
+        sig.make_sig('out'),
         sig.make_sig('dim', default=-1),
     )
 
@@ -7815,6 +10076,58 @@ class Softmax(Primitive):
     def __call__(self, input):
           return _convert_stub(pyboost_softmax(self, [input, self.axis]))
 
+class SoftplusExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.SoftplusExt()
+        out = prim(input, beta, threshold)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.softplus_ext(input, beta, threshold)
+        
+    Refer to :func:`mindspore.ops.softplus_ext` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('beta', default=1),
+        sig.make_sig('threshold', default=20),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, beta=1, threshold=20):
+          return _convert_stub(pyboost_softplus_ext(self, [input, beta, threshold]))
+
+softplus_ext_op=SoftplusExt()
+
+
+class SoftplusGradExt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dout'),
+        sig.make_sig('x'),
+        sig.make_sig('beta', default=1),
+        sig.make_sig('threshold', default=20),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dout, x, beta=1, threshold=20):
+          return _convert_stub(pyboost_softplus_grad_ext(self, [dout, x, beta, threshold]))
+
+softplus_grad_ext_op=SoftplusGradExt()
+
+
 class SolveTriangular(Primitive):
     r"""
     .. code-block::
@@ -7908,6 +10221,46 @@ class Split(Primitive):
           return super().__call__(input_x, self.axis, self.output_num)
 
 
+class SplitTensor(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input_x'),
+        sig.make_sig('split_int'),
+        sig.make_sig('axis', default=0),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input_x, split_int, axis=0):
+          return _convert_stub(pyboost_split_tensor(self, [input_x, split_int, axis]))
+
+split_tensor_op=SplitTensor()
+
+
+class SplitWithSize(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input_x'),
+        sig.make_sig('split_sections'),
+        sig.make_sig('axis', default=0),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input_x, split_sections, axis=0):
+          return _convert_stub(pyboost_split_with_size(self, [input_x, split_sections, axis]))
+
+split_with_size_op=SplitWithSize()
+
+
 class SqrtGrad(Primitive):
     r"""
     Performs grad of Sqrt operation.
@@ -7973,6 +10326,28 @@ class Square(Primitive):
 square_op=Square()
 
 
+class StackExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.StackExt(dim)
+        out = prim(tensors)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.stack_ext(tensors, dim)
+        
+    Refer to :func:`mindspore.ops.stack_ext` for more details.
+    """
+    @prim_arg_register
+    def __init__(self, dim=0):
+        self._set_prim_arg("dim", dim)
+
+    def __call__(self, tensors):
+          return _convert_stub(pyboost_stack_ext(self, [tensors, self.dim]))
+
 class StridedSlice(Primitive):
     r"""
     .. code-block::
@@ -8059,6 +10434,123 @@ class Sub(Primitive):
 sub_op=Sub()
 
 
+class SumExt(Primitive):
+    r"""
+    Calculate sum of Tensor elements over a given dim.
+
+    Note:
+        The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
+
+    Args:
+        input (Tensor): The input tensor.
+        dim (Union[None, int, tuple(int), list(int), Tensor]): Dimensions along which a sum is performed.
+            If ``None`` , sum all the elements of the input tensor.
+            If the `dim` is a tuple or list of ints, a sum is performed on all the dimensions specified in the tuple.
+            Must be in the range :math:`[-input.ndim, input.ndim)` . Default: ``None`` .
+        keepdim (bool): Whether the output tensor has `dim` retained or not.
+            If ``True`` , keep these reduced dimensions and the length is 1.
+            If ``False`` , don't keep these dimensions. Default: ``False`` .
+        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        A Tensor, sum of elements over a given `dim` in `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int, tulpe(int), list(int), Tensor or None.
+        ValueError: If `dim` is not in the range :math:`[-input.ndim, input.ndim)` .
+        TypeError: If `keepdim` is not a bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
+        ...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mstype.float32)
+        >>> out = ops.sum(x)
+        >>> print(out)
+        270.0
+        >>> out = ops.sum(x, dim=2)
+        >>> print(out)
+        [[ 6. 12. 18.]
+        [24. 30. 36.]
+        [42. 48. 54.]]
+        >>> out = ops.sum(x, dim=2, keepdim=True)
+        >>> print(out)
+        [[[ 6.]
+        [12.]
+        [18.]]
+        [[24.]
+        [30.]
+        [36.]]
+        [[42.]
+        [48.]
+        [54.]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('dim', default=None),
+        sig.make_sig('keepdim', default=False),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dim=None, keepdim=False, dtype=None):
+          return _convert_stub(pyboost_sum_ext(self, [input, dim, keepdim, dtype if dtype is None else dtype_to_type_id('SumExt', 'dtype', dtype)]))
+
+sum_ext_op=SumExt()
+
+
+class TanhGrad(Primitive):
+    r"""
+    Computes TanhGrad of input element-wise.
+
+    Returns:
+        Tensor, has the same type as input.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, y, dy):
+          return _convert_stub(pyboost_tanh_grad(self, [y, dy]))
+
+tanh_grad_op=TanhGrad()
+
+
+class Tanh(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Tanh()
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.tanh(input)
+        
+    Refer to :func:`mindspore.ops.tanh` for more details.
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input):
+          return _convert_stub(pyboost_tanh(self, [input]))
+
+tanh_op=Tanh()
+
+
 class TensorCopySlices(Primitive):
     r"""
     Copy continues memory.
@@ -8129,6 +10621,39 @@ class TensorShape(Primitive):
 tensor_shape_op=TensorShape()
 
 
+class TopkExt(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.TopkExt()
+        out = prim(input, k, dim, largest, sorted)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.topk_ext(input, k, dim, largest, sorted)
+        
+    Refer to :func:`mindspore.ops.topk_ext` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('k'),
+        sig.make_sig('dim', default=-1),
+        sig.make_sig('largest', default=True),
+        sig.make_sig('sorted', default=True),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, k, dim=-1, largest=True, sorted=True):
+          return _convert_stub(pyboost_topk_ext(self, [input, k, dim, largest, sorted]))
+
+topk_ext_op=TopkExt()
+
+
 class Trace(Primitive):
     r"""
     .. code-block::
@@ -8180,6 +10705,50 @@ class Transpose(Primitive):
 transpose_op=Transpose()
 
 
+class Tril(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Tril(diagonal)
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.tril(input, diagonal)
+        
+    Refer to :func:`mindspore.ops.tril` for more details.
+    """
+    @prim_arg_register
+    def __init__(self, diagonal=0):
+        self._set_prim_arg("diagonal", diagonal)
+
+    def __call__(self, input):
+          return _convert_stub(pyboost_tril(self, [input, self.diagonal]))
+
+class Triu(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.Triu(diagonal)
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.triu(input, diagonal)
+        
+    Refer to :func:`mindspore.ops.triu` for more details.
+    """
+    @prim_arg_register
+    def __init__(self, diagonal=0):
+        self._set_prim_arg("diagonal", diagonal)
+
+    def __call__(self, input):
+          return _convert_stub(pyboost_triu(self, [input, self.diagonal]))
+
 class TupleToTensor(Primitive):
     r"""
     .. code-block::
@@ -8211,6 +10780,48 @@ class TupleToTensor(Primitive):
 tuple_to_tensor_op=TupleToTensor()
 
 
+class UniformExt(Primitive):
+    r"""
+    Generates random numbers according to the Uniform random number distribution.
+
+    Inputs:
+        - **tensor** (Tensor) - The tensor of random tensor to be generated.
+        - **a** (float) - Lower bound of the random numbers. Default: 0.0.
+        - **b** (float) - Upper bound of the random numbers. Default: 0.0.
+        - **seed** (int) - Seed for random number generation. Default: 0.
+        - **offset** (int) - Positional offset in the tensor to start filling with random numbers. Default: 0.
+
+    Raises:
+        TypeError: If `a` or `b` is not a float.
+        TypeError: If `tensor` is not a Tensor.
+        ValueError: If `a` is larger than `b`.
+
+    Outputs:
+        - **output** (Tensor) - With the same type and shape as the 'tensor'.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.operations.random_ops import UniformExt
+        >>> x = Tensor(np.random.randn(3,4), mstype.float64)
+        >>> uniform = UniformExt()
+        >>> y = uniform(x, a=1.0, b=2.0, seed=10, offset=5)
+        >>> print(y.shape)
+        (3, 4)
+    """
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, tensor, a, b, seed, offset):
+          return _convert_stub(pyboost_uniform_ext(self, [tensor, a, b, seed, offset]))
+
+uniform_ext_op=UniformExt()
+
+
 class UnsortedSegmentSum(Primitive):
     r"""
     .. code-block::
@@ -8237,18 +10848,666 @@ class UnsortedSegmentSum(Primitive):
 unsorted_segment_sum_op=UnsortedSegmentSum()
 
 
-class View(Primitive):
+class UpsampleBilinear2DGrad(Primitive):
     r"""
-    .. code-block::
-        
-        prim = ops.View()
-        out = prim(input, shape)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.view(input, shape)
+    Upsample the 2-D gradient data with bilinear interpolation algorithm.
+
+    Note:
+        One of 'scales' and 'output_size' must be specified. And it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, H, W]. Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (Union[tuple[int], list[int]]): An required tuple[int] which contains 4 elements:
+            [batch, channels, height, width]. Must:
+            input_size[0] == dy.shape[0]
+            input_size[1] == dy.shape[1].
+        - **output_size** (Union[tuple[int], list[int]]): An optional tuple[int]. Default: ``None``.
+            It contains 2 elements: height, width, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0],
+            dy.shape[3] == output_size[1].
+        - **scales** (Union[tuple[float], list[float]]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 2 elements: scale_height, scale_width. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0],
+            dy.shape[3] == floor(input_size[3] * scales[1].
+        - **align_corners** (bool): An optional bool. Default: ``False``.
+
+    Outputs:
+        - **dx** (Tensor) - A Tensor with shape depending on intput_size, and its' dtype is the same as `dy`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+        sig.make_sig('align_corners', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input_size, output_size=None, scales=None, align_corners=False):
+          return _convert_stub(pyboost_upsample_bilinear2d_grad(self, [dy, input_size, output_size, scales, align_corners]))
+
+upsample_bilinear2d_grad_op=UpsampleBilinear2DGrad()
+
+
+class UpsampleBilinear2D(Primitive):
+    r"""
+    Performs upsampling with trilinear interpolation across 2dims for 4dim input Tensor.
+
+    This operator scale up the volumetric input with specified `output_size` or `scales` factors,
+    using trilinear upscaling algorithm.
+
+    Note:
+        One of `scales` and `output_size` must be specified. And it is an error if both are specified.
+
+    Inputs:
+        - **x** (Tensor) - 4D tensor of shape :math:`(N, C, H_{in}, W_{in})`. Supporting types:
+            float16, float32, float64].
+        - **output_size** (Union[tuple[int], list[int]]):  A tuple or list of 2 int elements
+            :math:`(output\_height, output\_width)`. Default: ``None``.
+        - **scales** (Union[tuple[float], list[float]]): A tuple or list of 2 float
+            elements :math:`(scale\_height, scale\_width)`. Default: ``None``.
+        - **align_corners** (bool, optional): An optional bool. Default: ``False``.
+            If ``True``, the input and output tensors are aligned by the center points of their corner pixels,
+            preserving the values at the corner pixels.
+            If ``False`` , the input and output tensors are aligned by the corner points of their corner pixels,
+            and the interpolation use edge value padding for out of boundary values.
+
+    Outputs:
+        - **y** (Tensor) - Upsampled output with the same data type as `x`, whose shape is
+            :math:`(N, C, H_{out}, W_{out})`.
+
+    Raises:
+        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
+        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
+        TypeError: If dtype of `x` is not in [float16, float32, float64].
+        TypeError: If type of `align_corners` is not bool.
+        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
+        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
+        ValueError: If shape of `x` is not 4D.
+        ValueError: If none of `scales` and `output_size` is specified or both specified.
+        ValueError: If size of `scales` is not equal 2 when `scales` is specified.
+        ValueError: If size of `output_size` is not equal 2 when `output_size` is specified.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> net = ops.UpsampleTrilinear3D()
+        >>> in_x = Tensor(input_data=np.random.randn(2, 3, 4, 512, 256))
+        >>> output_size=[4, 64, 48]
+        >>> out = net(in_x, output_size, None)
+        >>> print(out.shape)
+        (2, 3, 4, 64, 48)
+        >>>
+        >>> net = ops.auto_generate.UpsampleBilinear2D()
+        >>> in_x = Tensor(np.array([[[[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]], [[0.7, 0.8, 0.9], [1.0, 1.1, 1.2]]]]).astype(np.float32))
+        >>> output_size=[4, 5]
+        >>> out = net(in_x, output_size, None, True)
+        >>> print(out)
+        [[[[0.1000, 0.1500, 0.2000, 0.2500, 0.3000],
+           [0.2000, 0.2500, 0.3000, 0.3500, 0.4000],
+           [0.3000, 0.3500, 0.4000, 0.4500, 0.5000],
+           [0.4000, 0.4500, 0.5000, 0.5500, 0.6000]],
+          [[0.7000, 0.7500, 0.8000, 0.8500, 0.9000],
+           [0.8000, 0.8500, 0.9000, 0.9500, 1.0000],
+           [0.9000, 0.9500, 1.0000, 1.0500, 1.1000],
+           [1.0000, 1.0500, 1.1000, 1.1500, 1.2000]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+        sig.make_sig('align_corners', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, output_size=None, scales=None, align_corners=False):
+          return _convert_stub(pyboost_upsample_bilinear2d(self, [x, output_size, scales, align_corners]))
+
+upsample_bilinear2d_op=UpsampleBilinear2D()
+
+
+class UpsampleLinear1DGrad(Primitive):
+    r"""
+    Upsample the 1-D gradient data with linear interpolation algorithm.
+
+    Note:
+        One of 'scales' and 'output_size' must be specified. And it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, L]. Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (Union[tuple[int], list[int]]): An required tuple[int] which contains 3 elements:
+            [batch, channels, length]. Must:
+            input_size[0] == dy.shape[0]
+            input_size[1] == dy.shape[1].
+        - **output_size** (Union[tuple[int], list[int]]): An optional tuple[int]. Default: ``None``.
+            It contains 1 elements: length, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0].
+        - **scales** (Union[tuple[float], list[float]]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 1 elements: length_depth. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0].
+        - **align_corners** (bool): An optional bool. Default: ``False``.
+
+    Outputs:
+        - **dx** (Tensor) - A Tensor with shape depending on intput_size, and its' dtype is the same as `dy`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+        sig.make_sig('align_corners', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input_size, output_size=None, scales=None, align_corners=False):
+          return _convert_stub(pyboost_upsample_linear1d_grad(self, [dy, input_size, output_size, scales, align_corners]))
+
+upsample_linear1d_grad_op=UpsampleLinear1DGrad()
+
+
+class UpsampleLinear1D(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+        sig.make_sig('align_corners', default=False),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, output_size=None, scales=None, align_corners=False):
+          return _convert_stub(pyboost_upsample_linear1d(self, [x, output_size, scales, align_corners]))
+
+upsample_linear1d_op=UpsampleLinear1D()
+
+
+class UpsampleNearest1DGrad(Primitive):
+    r"""
+    Upsample the 1-D gradient data  with the nearest neighbor interpolation algorithm.
+
+    Note:
+        Only one of 'scales' and 'output_size' can be specified, and it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, L], Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (tuple[int]): An required tuple[int], which contain 3 elements:
+            [min_batch, channels, length].
+            Must: input_size[0] == dy.shape[0], input_size[1] == dy.shape[1].
+        - **output_size** (tuple[int]): An optional tuple[int]. Default: ``None``.
+            It contains 1 elements: length, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0].
+        - **scales** (tuple[float]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 1 elements: scale_length. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0].
+
+    Outputs:
+        - **dx**- (Tensor) - A 3-D tensor. Has the same type as `dy`, shape depends on `input_size`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input_size, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest1d_grad(self, [dy, input_size, output_size, scales]))
+
+upsample_nearest1d_grad_op=UpsampleNearest1DGrad()
+
+
+class UpsampleNearest1D(Primitive):
+    r"""
+    Performs nearest neighbor upsampling operation.
+
+    This operator scale up the volumetric input with specified `output_size` or `scales` factors, using nearest
+    neighbor algorithm.
+
+    One of `output_size` or `scales` must be given, and can not specified both at the same time.
+
+    Inputs:
+        - **x** (Tensor) - 3D tensor of shape :math:`(N, C, L_{in})`.
+          Supporting types: [uint8, float16, float32, float64].
+        - **output_size** (Union[tuple[int], list[int]]): A tuple or list of int specifying the output volumetric size.
+          Default: ``None``.
+        - **scales** (Union[tuple[float], list[float]]): A tuple or list of float specifying the upsampling factors.
+          Default: ``None``.
+
+    Outputs:
+        - **y** (Tensor) - Upsampled output with the same type as `x` , whose shape is
+          :math:`(N, C, L_{out})`.
+
+    Raises:
+        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
+        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
+        TypeError: If dtype of `x` is not int [uint8, float16, float32, float64].
+        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
+        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
+        ValueError: If shape of `x` is not 3D.
+        ValueError: If none of `scales` and `output_size` is specified or both specified.
+        ValueError: If size of `scales` is not equal 1 when `scales` is specified.
+        ValueError: If size of `output_size` is not equal 1 when `output_size` is specified.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(np.arange(10).reshape(1, 2, 5), mstype.float32)
+        >>> output_size = [8,]
+        >>> net = ops.auto_generate.UpsampleNearest1D()
+        >>> output = net(x, output_size, None)
+        >>> print(output)
+        [[[0., 0., 1., 1., 2., 3., 3., 4.],
+          [5., 5., 6., 6., 7., 8., 8., 9.]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest1d(self, [x, output_size, scales]))
+
+upsample_nearest1d_op=UpsampleNearest1D()
+
+
+class UpsampleNearest2DGrad(Primitive):
+    r"""
+    Upsample the 2-D gradient data  with the nearest neighbor interpolation algorithm.
+
+    Note:
+        Only one of 'scales' and 'output_size' can be specified, and it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, H, W], Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (tuple[int]): An required tuple[int], which contain 4 elements:
+            [min_batch, channels, height, width].
+            Must: input_size[0] == dy.shape[0], input_size[1] == dy.shape[1].
+        - **output_size** (tuple[int]): An optional tuple[int]. Default: ``None``.
+            It contains 2 elements: height, width, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0],
+            dy.shape[3] == output_size[1].
+        - **scales** (tuple[float]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 2 elements: scale_height, scale_width. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0],
+            dy.shape[3] == floor(input_size[3] * scales[1].
+
+    Outputs:
+        - **dx**- (Tensor) - A 4-D tensor. Has the same type as `dy`, shape depends on `input_size`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input_size, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest2d_grad(self, [dy, input_size, output_size, scales]))
+
+upsample_nearest2d_grad_op=UpsampleNearest2DGrad()
+
+
+class UpsampleNearest2D(Primitive):
+    r"""
+    Performs nearest neighbor upsampling operation.
+
+    This operator scale up the volumetric input with specified `output_size` or `scales` factors, using nearest
+    neighbor algorithm.
+
+    One of `output_size` or `scales` must be given, and can not specified both at the same time.
+
+    Inputs:
+        - **x** (Tensor) - 4D tensor of shape :math:`(N, C, H_{in}, W_{in})`.
+          Supporting types: [uint8, float16, float32, float64].
+        - **output_size** (Union[tuple[int], list[int]]): A tuple or list of int specifying the output volumetric size.
+          Default: ``None``.
+        - **scales** (Union[tuple[float], list[float]]): A tuple or list of float specifying the upsampling factors.
+          Default: ``None``.
+
+    Outputs:
+        - **y** (Tensor) - Upsampled output with the same type as `x` , whose shape is
+          :math:`(N, C, H_{out}, W_{out})`.
+
+    Raises:
+        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
+        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
+        TypeError: If dtype of `x` is not int [uint8, float16, float32, float64].
+        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
+        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
+        ValueError: If shape of `x` is not 4D.
+        ValueError: If none of `scales` and `output_size` is specified or both specified.
+        ValueError: If size of `scales` is not equal 2 when `scales` is specified.
+        ValueError: If size of `output_size` is not equal 2 when `output_size` is specified.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(np.arange(12).astype(np.float32).reshape(1, 2, 2, 3))
+        >>> output_size = [4, 4]
+        >>> net = ops.auto_generate.UpsampleNearest2D()
+        >>> output = net(x, output_size, None)
+        >>> print(output)
+        [[[[0., 0., 1., 2.],
+           [0., 0., 1., 2.],
+           [3., 3., 4., 5.],
+           [3., 3., 4., 5.]],
+          [[6., 6., 7., 8.],
+           [6., 6., 7., 8.],
+           [9., 9., 10., 10.],
+           [9., 9., 10., 10.]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest2d(self, [x, output_size, scales]))
+
+upsample_nearest2d_op=UpsampleNearest2D()
+
+
+class UpsampleNearest3DGrad(Primitive):
+    r"""
+    Upsample the 3-D gradient data  with the nearest neighbor interpolation algorithm.
+
+    Note:
+        Only one of 'scales' and 'output_size' can be specified, and it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W], Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (tuple[int]): An required tuple[int], which contain 5 elements:
+            [min_batch, channels, depth, height, width].
+            Must: input_size[0] == dy.shape[0], input_size[1] == dy.shape[1].
+        - **output_size** (tuple[int]): An optional tuple[int]. Default: ``None``.
+            It contains 3 elements: depth, height, width, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0],
+            dy.shape[3] == output_size[1],
+            dy.shape[4] == output_size[2].
+        - **scales** (tuple[float]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0],
+            dy.shape[3] == floor(input_size[3] * scales[1],
+            dy.shape[4] == floor(input_size[4] * scales[2].
+
+    Outputs:
+        - **dx**- (Tensor) - A 5-D tensor. Has the same type as `dy`, shape depends on `input_size`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, dy, input_size, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest3d_grad(self, [dy, input_size, output_size, scales]))
+
+upsample_nearest3d_grad_op=UpsampleNearest3DGrad()
+
+
+class UpsampleNearest3D(Primitive):
+    r"""
+    Performs nearest neighbor upsampling operation.
+
+    This operator scale up the volumetric input with specified `output_size` or `scales` factors, using nearest
+    neighbor algorithm.
+
+    One of `output_size` or `scales` must be given, and can not specified both at the same time.
+
+    Inputs:
+        - **x** (Tensor) - 5D tensor of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`.
+          Supporting types: [float16, float32, float64].
+        - **output_size** (Union[tuple[int], list[int]]): A tuple or list of int specifying the output volumetric size.
+          Default: ``None``.
+        - **scales** (Union[tuple[float], list[float]]): A tuple or list of float specifying the upsampling factors.
+          Default: ``None``.
+
+    Outputs:
+        - **y** (Tensor) - Upsampled output with the same type as `x` , whose shape is
+          :math:`(N, C, D_{out}, H_{out}, W_{out})`.
+
+    Raises:
+        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
+        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
+        TypeError: If dtype of `x` is not int [float16, float32, float64].
+        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
+        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
+        ValueError: If shape of `x` is not 5D.
+        ValueError: If none of `scales` and `output_size` is specified or both specified.
+        ValueError: If size of `scales` is not equal 3 when `scales` is specified.
+        ValueError: If size of `output_size` is not equal 3 when `output_size` is specified.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
+        ...       .reshape([1, 1, 2, 2, 4]), mstype.float32)
+        >>> output_size = [3, 4, 5]
+        >>> net = ops.UpsampleNearest3D()
+        >>> output = net(x, output_size, None)
+        >>> print(output)
+        [[[[[ 1.  1.  2.  3.  4.]
+            [ 1.  1.  2.  3.  4.]
+            [ 5.  5.  6.  7.  8.]
+            [ 5.  5.  6.  7.  8.]]
+          [[ 1.  1.  2.  3.  4.]
+            [ 1.  1.  2.  3.  4.]
+            [ 5.  5.  6.  7.  8.]
+            [ 5.  5.  6.  7.  8.]]
+          [[ 9.  9. 10. 11. 12.]
+            [ 9.  9. 10. 11. 12.]
+            [13. 13. 14. 15. 16.]
+            [13. 13. 14. 15. 16.]]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, x, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_nearest3d(self, [x, output_size, scales]))
+
+upsample_nearest3d_op=UpsampleNearest3D()
+
+
+class UpsampleTrilinear3DGrad(Primitive):
+    r"""
+    Upsample the 3-D gradient data with trilinear interpolation algorithm.
+
+    Note:
+        One of 'scales' and 'output_size' must be specified. And it is an error if both are specified.
+
+    Inputs:
+        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W]. Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (Union[tuple[int], list[int]]): An required tuple[int] which contains 5 elements:
+            [batch, channels, depth, height, width]. Must:
+            input_size[0] == dy.shape[0]
+            input_size[1] == dy.shape[1].
+        - **output_size** (Union[tuple[int], list[int]]): An optional tuple[int]. Default: ``None``.
+            It contains 3 elements: depth, height, width, whose elements should be the same as `dy`. Must:
+            dy.shape[2] == output_size[0],
+            dy.shape[3] == output_size[1],
+            dy.shape[4] == output_size[2].
+        - **scales** (Union[tuple[float], list[float]]): An optional tuple[float]. Default: ``None``.
+            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width. Must:
+            dy.shape[2] == floor(input_size[2] * scales[0],
+            dy.shape[3] == floor(input_size[3] * scales[1],
+            dy.shape[4] == floor(input_size[4] * scales[2].
+        - **align_corners** (bool): An optional bool. Default: ``False``.
+
+    Outputs:
+        - **dx** (Tensor) - A Tensor with shape depending on intput_size, and its' dtype is the same as `dy`.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('dy'),
+        sig.make_sig('input_size'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, align_corners=False):
+        self._set_prim_arg("align_corners", align_corners)
+
+    def __call__(self, dy, input_size, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_trilinear3d_grad(self, [dy, input_size, output_size, scales, self.align_corners]))
+
+class UpsampleTrilinear3D(Primitive):
+    r"""
+    Performs upsampling with trilinear interpolation across 3dims for 5dim input Tensor.
+
+    This operator scale up the volumetric input with specified `output_size` or `scales` factors,
+    using trilinear upscaling algorithm.
+
+    Note:
+        One of `scales` and `output_size` must be specified. And it is an error if both are specified.
+
+    Args:
+       align_corners (bool, optional): An optional bool. Default: ``False``.
+          If ``True``, the input and output tensors are aligned by the center points of their corner pixels,
+          preserving the values at the corner pixels.
+          If ``False`` , the input and output tensors are aligned by the corner points of their corner pixels,
+          and the interpolation use edge value padding for out of boundary values.
+
+    Inputs:
+        - **x** (Tensor) - 5D tensor of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`. Supporting types:
+          [float16, float32, float64].
+        - **output_size** (Union[tuple[int], list[int]]):  A tuple or list of 3 int elements
+          :math:`(output\_depth, output\_height, output\_width)`. Default: ``None``.
+        - **scales** (Union[tuple[float], list[float]]): A tuple or list of 3 float
+          elements :math:`(scale\_depth, scale\_height, scale\_width)`. Default: ``None``.
+
+    Outputs:
+        - **y** (Tensor) - Upsampled output with the same data type as `x`, whose shape is
+          :math:`(N, C, D_{out}, H_{out}, W_{out})`.
+
+    Raises:
+        TypeError: When `output_size` is not ``None`` and `output_size` is not list[int] or tuple[int].
+        TypeError: When `scales` is not ``None`` and `scales` is not list[float] or tuple[float].
+        TypeError: If dtype of `x` is not in [float16, float32, float64].
+        TypeError: If type of `align_corners` is not bool.
+        ValueError: If any value of `output_size` is negative or zero when `output_size` is not ``None``.
+        ValueError: If any value of `scales` is negative or zero when `scales` is not ``None``.
+        ValueError: If shape of `x` is not 5D.
+        ValueError: If none of `scales` and `output_size` is specified or both specified.
+        ValueError: If size of `scales` is not equal 3 when `scales` is specified.
+        ValueError: If size of `output_size` is not equal 3 when `output_size` is specified.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> net = ops.UpsampleTrilinear3D()
+        >>> in_x = Tensor(input_data=np.random.randn(2, 3, 4, 512, 256))
+        >>> output_size=[4, 64, 48]
+        >>> out = net(in_x, output_size, None)
+        >>> print(out.shape)
+        (2, 3, 4, 64, 48)
+        >>>
+        >>> net = ops.UpsampleTrilinear3D()
+        >>> in_x = Tensor(np.arange(1, 5, dtype=np.float32).reshape((1, 1, 1, 2, 2)))
+        >>> output_size=[2, 4, 4]
+        >>> out = net(in_x, output_size, None)
+        >>> print(out)
+        [[[[[1.   1.25 1.75 2.  ]
+            [1.5  1.75 2.25 2.5 ]
+            [2.5  2.75 3.25 3.5 ]
+            [3.   3.25 3.75 4.  ]]
+          [[1.   1.25 1.75 2.  ]
+            [1.5  1.75 2.25 2.5 ]
+            [2.5  2.75 3.25 3.5 ]
+            [3.   3.25 3.75 4.  ]]]]]
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('output_size', default=None),
+        sig.make_sig('scales', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, align_corners=False):
+        self._set_prim_arg("align_corners", align_corners)
+
+    def __call__(self, x, output_size=None, scales=None):
+          return _convert_stub(pyboost_upsample_trilinear3d(self, [x, output_size, scales, self.align_corners]))
+
+class View(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.View()
+        out = prim(input, shape)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.view(input, shape)
         
     Refer to :func:`mindspore.ops.view` for more details.
     """
@@ -8295,7 +11554,36 @@ class WeightQuantBatchMatmul(Primitive):
         self._set_prim_arg("antiquant_group_size", antiquant_group_size)
 
     def __call__(self, x, weight, antiquant_scale, antiquant_offset=None, quant_scale=None, quant_offset=None, bias=None):
-          return super().__call__(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, self.transpose_x, self.transpose_weight, self.antiquant_group_size)
+          return _convert_stub(pyboost_weight_quant_batch_matmul(self, [x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, self.transpose_x, self.transpose_weight, self.antiquant_group_size]))
+
+class ZerosLikeExt(Primitive):
+    r"""
+    Returns a Tensor with a value of 0 and its shape and data type is the same as the input.
+
+    Refer to :func:`mindspore.ops.zeros_like` for more details.
+
+    Args:
+        - **input_x** (Tensor) - Tensor of any dimension.
+
+    Returns:
+        Tensor, has the same shape and type as `input_x` but filled with ones.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dtype=None):
+          return _convert_stub(pyboost_zeros_like_ext(self, [input, dtype if dtype is None else dtype_to_type_id('ZerosLikeExt', 'dtype', dtype)]))
+
+zeros_like_ext_op=ZerosLikeExt()
 
 
 class ZerosLike(Primitive):