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

mindspore/ops/auto_generate/gen_ops_prim.py

@@ -25,25 +25,17 @@ 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_adamw
+from mindspore._c_expression import pyboost_adam_weight_decay_ext
 from mindspore._c_expression import pyboost_add_ext
-from mindspore._c_expression import pyboost_add_layernorm_v2
-from mindspore._c_expression import pyboost_add
-from mindspore._c_expression import pyboost_addmm
 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_atan2_ext
 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_binary_cross_entropy_grad
-from mindspore._c_expression import pyboost_binary_cross_entropy
-from mindspore._c_expression import pyboost_binary_cross_entropy_with_logits_backward
-from mindspore._c_expression import pyboost_binary_cross_entropy_with_logits
 from mindspore._c_expression import pyboost_bmm_ext
 from mindspore._c_expression import pyboost_broadcast_to
 from mindspore._c_expression import pyboost_cast
@@ -51,8 +43,6 @@ 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_col2im_ext
-from mindspore._c_expression import pyboost_col2im_grad
 from mindspore._c_expression import pyboost_concat
 from mindspore._c_expression import pyboost_constant_pad_nd
 from mindspore._c_expression import pyboost_contiguous
@@ -60,7 +50,6 @@ 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_cumsum_ext
 from mindspore._c_expression import pyboost_dense
 from mindspore._c_expression import pyboost_div
 from mindspore._c_expression import pyboost_divmod
@@ -69,27 +58,22 @@ 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_elu_ext
-from mindspore._c_expression import pyboost_elu_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_eye
 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_floor
 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_generator
 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
@@ -98,10 +82,6 @@ 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_im2col_ext
-from mindspore._c_expression import pyboost_index_add_ext
-from mindspore._c_expression import pyboost_index_select
-from mindspore._c_expression import pyboost_isclose
 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
@@ -117,7 +97,6 @@ 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_matrix_inverse_ext
 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
@@ -130,21 +109,15 @@ 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_non_zero_ext
-from mindspore._c_expression import pyboost_non_zero
 from mindspore._c_expression import pyboost_norm
-from mindspore._c_expression import pyboost_normal_float_float
-from mindspore._c_expression import pyboost_normal_float_tensor
-from mindspore._c_expression import pyboost_normal_tensor_float
-from mindspore._c_expression import pyboost_normal_tensor_tensor
+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_rand_ext
-from mindspore._c_expression import pyboost_rand_like_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
@@ -156,27 +129,20 @@ 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_grad
-from mindspore._c_expression import pyboost_repeat_interleave_int
-from mindspore._c_expression import pyboost_repeat_interleave_tensor
+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_reshape
 from mindspore._c_expression import pyboost_reverse_v2
-from mindspore._c_expression import pyboost_rms_norm_grad
-from mindspore._c_expression import pyboost_rms_norm
 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_searchsorted
 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_sign
 from mindspore._c_expression import pyboost_silu_grad
 from mindspore._c_expression import pyboost_silu
 from mindspore._c_expression import pyboost_sin
@@ -185,24 +151,21 @@ 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_sort_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_sub
 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_unique2
-from mindspore._c_expression import pyboost_unique_dim
 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
@@ -215,14 +178,9 @@ 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
-from mindspore._c_expression import pyboost_dynamic_quant_ext
-from mindspore._c_expression import pyboost_grouped_matmul
-from mindspore._c_expression import pyboost_moe_finalize_routing
-from mindspore._c_expression import pyboost_quant_batch_matmul
-from mindspore._c_expression import pyboost_quant_v2
-from mindspore._c_expression import pyboost_weight_quant_batch_matmul
 
 
 class ACosGrad(Primitive):
@@ -350,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).
@@ -466,106 +524,6 @@ class AdamWeightDecay(Primitive):
           return super().__call__(var, m, v, lr, beta1, beta2, epsilon, decay, gradient, self.use_locking)
 
 
-class AdamW(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** (Tensor) - step
-            - **lr** (float) - :math:`lr` in the updating formula. The paper suggested value is :math:`10^{-8}`,
-              the data type should be float.
-            - **beta1** (float) - The exponential decay rate for the 1st moment estimations,
-              the data type should be float. The paper suggested value is :math:`0.9`
-            - **beta2** (float) - The exponential decay rate for the 2nd moment estimations,
-              the data type should be float. The paper suggested value is :math:`0.999`
-            - **decay** (float) - weight decay (L2 penalty), must be a scalar tensor with float data type.
-            - **eps** (float) - Term added to the denominator to improve numerical stability,
-              the data type should be float.
-            - **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_adamw(self, [var, m, v, max_v, gradient, step, lr, beta1, beta2, decay, eps, amsgrad, maximize]))
-
-adamw_op=AdamW()
-
-
 class AddExt(Primitive):
     r"""
     .. code-block::
@@ -619,7 +577,8 @@ class Add(Primitive):
         pass
 
     def __call__(self, input, other):
-          return _convert_stub(pyboost_add(self, [input, other]))
+          return super().__call__(input, other)
+
 
 add_op=Add()
 
@@ -728,31 +687,6 @@ class Addcmul(Primitive):
 addcmul_op=Addcmul()
 
 
-class Addmm(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.Addmm()
-        out = prim(input, mat1, mat2, beta, alpha)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.addmm(input, mat1, mat2, beta, alpha)
-        
-    Refer to :func:`mindspore.ops.addmm` for more details.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, mat1, mat2, beta, alpha):
-          return _convert_stub(pyboost_addmm(self, [input, mat1, mat2, beta, alpha]))
-
-addmm_op=Addmm()
-
-
 class AddN(Primitive):
     r"""
     .. code-block::
@@ -1108,56 +1042,16 @@ class ApplyRotaryPosEmb(Primitive):
 
 class Arange(Primitive):
     r"""
-    Creates a sequence of numbers that begins at `start` and extends by increments of
-    `step` up to but not including `end`.
-
-    Inputs:
-        start (number): The first number in the sequence.
-            Must have type: int32 ,int64, float32, or float64.
-        end (number): Upper end of the sequence, exclusive.
-            Must have type: int32 ,int64, float32, or float64.
-        step (number): Number that increments `start`.
-            Must have type: int32 ,int64, float32, or float64.
-        dtype (mindspore.dtype, optional): Specified dtype of the result tensor. Default: ``None`` .
-            Supported values are: int32, int64, float32, float64, and bfloat16.
-
-    Outputs:
-        A 1-D Tensor with the required dtype. When dtype is ``None``, then:
-        If `start`, `end` and `step` are all integers, the Tensor dtype is int64.
-        If at least one of `start`, `end` and `step` is floating-point numbers, the Tensor dtype is float32.
-
-    Raises:
-        TypeError: If the datatype of `start`, `end` or `step` is not supported.
-        ValueError: If `step` = 0.
-        ValueError: If `start` >= `end` when `step` > 0.
-        ValueError: If `start` <= `end` when `step` < 0.
-
-    Supported Platforms:
-        `Ascend`
-
-    Examples:
-        >>> from mindspore import ops
-        >>> start = 0
-        >>> end = 10
-        >>> step = 4
-        >>> net = ops.Arange()
-        >>> output = net(start, end, step)
-        >>> print(output)
-        [0 4 8]
+    
     """
-    __mindspore_signature__ =  (
-        sig.make_sig('start', dtype=sig.sig_dtype.T),
-        sig.make_sig('end', dtype=sig.sig_dtype.T),
-        sig.make_sig('step', dtype=sig.sig_dtype.T),
-        sig.make_sig('dtype', dtype=sig.sig_dtype.T1, default=None),
-    )
+    __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, dtype=None):
-          return _convert_stub(pyboost_arange(self, [start, end, step, dtype if dtype is None else dtype_to_type_id('Arange', 'dtype', dtype)]))
+    def __call__(self, start, end, step):
+          return _convert_stub(pyboost_arange(self, [start, end, step]))
 
 arange_op=Arange()
 
@@ -1173,9 +1067,9 @@ class ArgMaxExt(Primitive):
     
     .. code-block::
     
-        ops.argmax_ext(input, dim, keepdim)
+        ops.argmax(input, dim, keepdim)
         
-    Refer to :func:`mindspore.ops.argmax_ext` for more details.
+    Refer to :func:`mindspore.ops.argmax` for more details.
     """
     __mindspore_signature__ =  (
         sig.make_sig('input'),
@@ -1543,33 +1437,6 @@ class Assign(Primitive):
 assign_op=Assign()
 
 
-class Atan2Ext(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.Atan2Ext()
-        out = prim(input, other)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.atan2_ext(input, other)
-        
-    Refer to :func:`mindspore.ops.atan2_ext` 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_atan2_ext(self, [input, other]))
-
-atan2_ext_op=Atan2Ext()
-
-
 class Atan2(Primitive):
     r"""
     .. code-block::
@@ -1929,74 +1796,18 @@ class BatchMatMul(Primitive):
 
 class BatchNormExt(Primitive):
     r"""
-    Batch Normalization for input data and updated parameters.
-
-    Batch Normalization is widely used in convolutional neural networks. This operation
-    applies Batch Normalization over inputs to avoid internal covariate shift as described
-    in the paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
-    Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
-    features using a mini-batch of data and the learned parameters can be described
-    in the following formula,
-
-    .. math::
-
-        y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
-
-    where :math:`\gamma` is weight, :math:`\beta` is bias, :math:`\epsilon` is epsilon,
-    :math:`mean` is the mean of :math:`x`,
-    :math:`variance` is the variance of :math:`x`.
-
-    Args:
-        input (Tensor): Tensor of shape :math:`(N, C, *)`, where :math:`*` means, any number of additional
-            dimensions. with bfloat16, float16 or float32 data type. For Atlas training products, the shape must be
-            2-4 dimensions currently.
-        weight (Tensor): Tensor of shape :math:`(C,)`, with bfloat16, float16 or float32 data type.
-        bias (Tensor): Tensor of shape :math:`(C,)`, with bfloat16, float16 or float32 data type.
-        running_mean (Tensor): Tensor of shape :math:`(C,)`, with bfloat16, float16 or float32 data type.
-        running_var (Tensor): Tensor of shape :math:`(C,)`, with bfloat16, float16 or float32 data type.
-        training (bool, optional): If `training` is ``True`` , `mean` and `variance` are computed during
-            training. If `training` is ``False`` , they're loaded from checkpoint during inference. Default: ``False`` .
-        momentum (float, optional): The hyper parameter to compute moving average for running_mean and
-            running_var (e.g. :math:`new\_running\_mean = (1 - momentum) * running\_mean + momentum * current\_mean`).
-            Default: ``0.1`` 
-        epsilon (float, optional): A small value added for numerical stability. Default: ``1e-5``.
-
-    returns:
-        Tensor, the normalized inputs, has the same shape and dtype as `input`.
-
-    Raises:
-        TypeError: If `training` is not a bool.
-        TypeError: If dtype of `epsilon` or `momentum` is not float.
-        TypeError: If `input`, `weight`, `bias`, `running_mean` or `running_var` is not a Tensor.
-        TypeError: If dtype of `input`, `weight` is not bfloat16, float16 or float32.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.ones([2, 2]), mindspore.float32)
-        >>> weight = Tensor(np.ones([2]), mindspore.float32)
-        >>> bias = Tensor(np.ones([2]), mindspore.float32)
-        >>> running_mean = Tensor(np.ones([2]), mindspore.float32)
-        >>> running_var = Tensor(np.ones([2]), mindspore.float32)
-        >>> output = ops.batch_norm_ext(input_x, weight, bias, running_mean, running_var)
-        >>> print(output)
-        [[1. 1.]
-         [1. 1.]]
-    """
-    __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),
-    )
+    
+    """
+    __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):
@@ -2176,239 +1987,6 @@ class BiasAdd(Primitive):
           return super().__call__(input_x, bias, self.data_format)
 
 
-class BinaryCrossEntropyGrad(Primitive):
-    r"""
-    
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('target'),
-        sig.make_sig('grad_output'),
-        sig.make_sig('weight', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, reduction='mean'):
-        self._set_prim_arg_with_handler("reduction", reduction, str_to_enum)
-
-    def __call__(self, input, target, grad_output, weight=None):
-          return _convert_stub(pyboost_binary_cross_entropy_grad(self, [input, target, grad_output, weight, self.reduction]))
-
-class BinaryCrossEntropy(Primitive):
-    r"""
-    Computes the binary cross entropy between the logits and the labels.
-
-    Sets logits as :math:`x`, labels as :math:`y`, output as :math:`\ell(x, y)`.
-    Let,
-
-    .. math::
-        L = \{l_1,\dots,l_N\}^\top, \quad
-        l_n = - w_n \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]
-
-    In which, :math:`L` indicates the loss of all batch_sizes, :math:`l` indicates the loss of one batch_size,
-    and n indicates one batch_size in the 1-N range, :math:`w_n` indicates the
-    weight of :math:`n`-th batch of binary cross entropy. Then,
-
-    .. math::
-        \ell(x, y) = \begin{cases}
-        L, & \text{if reduction} = \text{'none';}\\
-        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
-        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
-        \end{cases}
-
-    .. warning::
-        - The value of :math:`x` must range from 0 to 1.
-
-    Args:
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'mean'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the weighted mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-    Inputs:
-        - **logits** (Tensor) - The predictive value whose data type must be float16 or float32,
-          The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **labels** (Tensor) - The target value which has the same shape and data type as `logits`. And the data type is float16 or float32.
-        - **weight** (Tensor, optional) - A rescaling weight applied to the loss of each batch element.
-          And it must have the same shape and data type as `logits`. Default: ``None`` .
-
-    Outputs:
-        Tensor or Scalar. Returns Tensor that has the same dtype and shape as `logits` if `reduction` is 'none'.
-        Otherwise, returns a scalar Tensor.
-
-    Raises:
-        TypeError: If dtype of `logits`, `labels` or `weight` (if given) is neither float16 nor float32.
-        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
-        ValueError: If shape of `labels` is not the same as `logits` or `weight` (if given).
-        TypeError: If `logits`, `labels` or `weight` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn, ops
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.binary_cross_entropy = ops.BinaryCrossEntropy()
-        ...     def construct(self, logits, labels, weight):
-        ...         result = self.binary_cross_entropy(logits, labels, weight)
-        ...         return result
-        ...
-        >>> net = Net()
-        >>> logits = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
-        >>> labels = Tensor(np.array([0., 1., 0.]), mindspore.float32)
-        >>> weight = Tensor(np.array([1, 2, 2]), mindspore.float32)
-        >>> output = net(logits, labels, weight)
-        >>> print(output)
-        0.38240486
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('target'),
-        sig.make_sig('weight', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, reduction='mean'):
-        self._set_prim_arg_with_handler("reduction", reduction, str_to_enum)
-
-    def __call__(self, input, target, weight=None):
-          return _convert_stub(pyboost_binary_cross_entropy(self, [input, target, weight, self.reduction]))
-
-class BinaryCrossEntropyWithLogitsBackward(Primitive):
-    r"""
-    
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('grad_output'),
-        sig.make_sig('input'),
-        sig.make_sig('target'),
-        sig.make_sig('weight', default=None),
-        sig.make_sig('posWeight', default=None),
-        sig.make_sig('reduction', default='mean'),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, grad_output, input, target, weight=None, posWeight=None, reduction='mean'):
-          return _convert_stub(pyboost_binary_cross_entropy_with_logits_backward(self, [grad_output, input, target, weight, posWeight, str_to_enum('BinaryCrossEntropyWithLogitsBackward', 'reduction', reduction)]))
-
-binary_cross_entropy_with_logits_backward_op=BinaryCrossEntropyWithLogitsBackward()
-
-
-class BCEWithLogitsLoss(Primitive):
-    r"""
-    Adds sigmoid activation function to `input` as logits, and uses the given logits to compute binary cross entropy
-    between the logits and the target.
-
-    Sets input `input` as :math:`X`, input `target` as :math:`Y`, input weight as :math:`W`, output as :math:`L`.
-    Then,
-
-    .. math::
-
-        \begin{array}{ll} \\
-            p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}} \\
-            L_{ij} = -[Y_{ij}log(p_{ij}) + (1 - Y_{ij})log(1 - p_{ij})]
-        \end{array}
-
-    :math:`i` indicates the :math:`i^{th}` sample, :math:`j` indicates the category. Then,
-
-    .. math::
-        \ell(x, y) = \begin{cases}
-        L, & \text{if reduction} = \text{'none';}\\
-        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
-        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
-        \end{cases}
-
-    :math:`\ell` indicates the method of calculating the loss. There are three methods:
-    the first method is to provide the loss value directly,
-    the second method is to calculate the average value of all losses,
-    and the third method is to calculate the sum of all losses.
-
-    This operator will multiply the output by the corresponding weight.
-    The tensor `weight` assigns different weights to each piece of data in the batch,
-    and the tensor `pos_weight` adds corresponding weights to the positive examples of each category.
-
-    In addition, it can trade off recall and precision by adding weights to positive examples.
-    In the case of multi-label classification the loss can be described as:
-
-    .. math::
-        \begin{array}{ll} \\
-            p_{ij,c} = sigmoid(X_{ij,c}) = \frac{1}{1 + e^{-X_{ij,c}}} \\
-            L_{ij,c} = -[P_{c}Y_{ij,c} * log(p_{ij,c}) + (1 - Y_{ij,c})log(1 - p_{ij,c})]
-        \end{array}
-
-    where c is the class number (c>1 for multi-label binary classification, c=1 for single-label binary classification),
-    n is the number of the sample in the batch and :math:`P_c` is the weight of the positive answer for the class c.
-    :math:`P_c>1` increases the recall, :math:`P_c<1` increases the precision.
-
-    Args:
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'mean'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the weighted mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-    Inputs:
-        - **input** (Tensor) - Input `input`. Data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-          Tensor of shape :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        - **target** (Tensor) - Ground truth label, has the same shape as `input`.
-          Data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-        - **weight** (Tensor) - A rescaling weight applied to the loss of each batch element. It can be
-          broadcast to a tensor with shape of `input`. Data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-        - **pos_weight** (Tensor) - A weight of positive examples. Must be a vector with length equal to the
-          number of classes. It can be broadcast to a tensor with shape of `input`.
-          Data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-
-    Outputs:
-        Tensor or Scalar, if `reduction` is ``'none'``, it's a tensor with the same shape and type as input `input`.
-        Otherwise, the output is a scalar.
-
-    Raises:
-        TypeError: If any input is not Tensor.
-        TypeError: If data type of any input is not float16, float32 or bfloat16.
-        TypeError: If data type of `reduction` is not string.
-        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `input`.
-        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]), mindspore.float32)
-        >>> target = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]), mindspore.float32)
-        >>> weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
-        >>> pos_weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
-        >>> loss = ops.BCEWithLogitsLoss()
-        >>> output = loss(input, target, weight, pos_weight)
-        >>> print(output)
-        0.3463612
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('target'),
-        sig.make_sig('weight', default=None),
-        sig.make_sig('posWeight', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, reduction='mean'):
-        self._set_prim_arg_with_handler("reduction", reduction, str_to_enum)
-
-    def __call__(self, input, target, weight=None, posWeight=None):
-          return _convert_stub(pyboost_binary_cross_entropy_with_logits(self, [input, target, weight, posWeight, self.reduction]))
-
 class BatchMatMulExt(Primitive):
     r"""
     .. code-block::
@@ -2756,62 +2334,6 @@ class ClampTensor(Primitive):
 clamp_tensor_op=ClampTensor()
 
 
-class Col2ImExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.Col2ImExt()
-        out = prim(input, output_size, kernel_size, dilation, padding, stride)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.fold_ext(input, output_size, kernel_size, dilation, padding, stride)
-        
-    Refer to :func:`mindspore.ops.fold_ext` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('output_size'),
-        sig.make_sig('kernel_size'),
-        sig.make_sig('dilation', default=1),
-        sig.make_sig('padding', default=0),
-        sig.make_sig('stride', default=1),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, output_size, kernel_size, dilation=1, padding=0, stride=1):
-          return _convert_stub(pyboost_col2im_ext(self, [input, to_pair('Col2ImExt', 'output_size', output_size), to_pair('Col2ImExt', 'kernel_size', kernel_size), to_pair('Col2ImExt', 'dilation', dilation), to_pair('Col2ImExt', 'padding', padding), to_pair('Col2ImExt', 'stride', stride)]))
-
-col2im_ext_op=Col2ImExt()
-
-
-class Col2ImGrad(Primitive):
-    r"""
-    
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('kernel_size'),
-        sig.make_sig('dilation', default=1),
-        sig.make_sig('padding', default=0),
-        sig.make_sig('stride', default=1),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, kernel_size, dilation=1, padding=0, stride=1):
-          return _convert_stub(pyboost_col2im_grad(self, [input, to_pair('Col2ImGrad', 'kernel_size', kernel_size), to_pair('Col2ImGrad', 'dilation', dilation), to_pair('Col2ImGrad', 'padding', padding), to_pair('Col2ImGrad', 'stride', stride)]))
-
-col2im_grad_op=Col2ImGrad()
-
-
 class Complex(Primitive):
     r"""
     Returns a complex Tensor from the real part and the imag part.
@@ -3303,37 +2825,6 @@ class Cummin(Primitive):
           return super().__call__(input, self.axis)
 
 
-class CumsumExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.CumsumExt()
-        out = prim(input, dim, dtype)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.cumsum_ext(input, dim, dtype)
-        
-    Refer to :func:`mindspore.ops.cumsum_ext` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('dim'),
-        sig.make_sig('dtype', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, dim, dtype=None):
-          return _convert_stub(pyboost_cumsum_ext(self, [input, dim, dtype if dtype is None else dtype_to_type_id('CumsumExt', 'dtype', dtype)]))
-
-cumsum_ext_op=CumsumExt()
-
-
 class DCT(Primitive):
     r"""
     
@@ -3593,11 +3084,18 @@ 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, seed, offset):
+    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()
@@ -3625,8 +3123,8 @@ class DropoutGradExt(Primitive):
     def __init__(self):
         pass
 
-    def __call__(self, input, mask, p):
-          return _convert_stub(pyboost_dropout_grad_ext(self, [input, mask, p]))
+    def __call__(self, x, mask, p):
+          return _convert_stub(pyboost_dropout_grad_ext(self, [x, mask, p]))
 
 dropout_grad_ext_op=DropoutGradExt()
 
@@ -3736,48 +3234,6 @@ class Eig(Primitive):
           return super().__call__(x, self.compute_v)
 
 
-class EluExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.EluExt(alpha)
-        out = prim(input)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.elu_ext(input, alpha)
-        
-    Refer to :func:`mindspore.ops.elu_ext` for more details.
-    """
-    @prim_arg_register
-    def __init__(self, alpha=1.0):
-        self._set_prim_arg("alpha", alpha)
-
-    def __call__(self, input):
-          return _convert_stub(pyboost_elu_ext(self, [input, self.alpha]))
-
-class EluGradExt(Primitive):
-    r"""
-    Gradients of EluExt operation.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('dout'),
-        sig.make_sig('x'),
-        sig.make_sig('alpha', default=1.0),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, dout, x, alpha=1.0):
-          return _convert_stub(pyboost_elu_grad_ext(self, [dout, x, alpha]))
-
-elu_grad_ext_op=EluGradExt()
-
-
 class EluGrad(Primitive):
     r"""
     Gradients of Elu operation.
@@ -4152,7 +3608,8 @@ class Eye(Primitive):
         pass
 
     def __call__(self, n, m, dtype):
-          return _convert_stub(pyboost_eye(self, [n, m, dtype_to_type_id('Eye', 'dtype', dtype)]))
+          return super().__call__(n, m, dtype_to_type_id('Eye', 'dtype', dtype))
+
 
 eye_op=Eye()
 
@@ -4932,7 +4389,8 @@ class Floor(Primitive):
         pass
 
     def __call__(self, input):
-          return _convert_stub(pyboost_floor(self, [input]))
+          return super().__call__(input)
+
 
 floor_op=Floor()
 
@@ -5115,20 +4573,6 @@ class GeLU(Primitive):
 gelu_op=GeLU()
 
 
-class Generator(Primitive):
-    r"""
-    
-    """
-    @prim_arg_register
-    def __init__(self):
-        self.add_prim_attr("side_effect_mem", True)
-
-    def __call__(self, cmd, inputs):
-          return _convert_stub(pyboost_generator(self, [cmd, inputs]))
-
-generator_op=Generator()
-
-
 class Geqrf(Primitive):
     r"""
     .. code-block::
@@ -5537,11 +4981,11 @@ class GroupNorm(Primitive):
            [0. 0. 0. 0.]]]]
     """
     __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('num_groups'),
-        sig.make_sig('weight', default=None),
-        sig.make_sig('bias', default=None),
-        sig.make_sig('eps', default=1e-5),
+        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
@@ -5881,86 +5325,6 @@ class IFFTShift(Primitive):
 ifftshift_op=IFFTShift()
 
 
-class Im2ColExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.Im2ColExt()
-        out = prim(input, kernel_size, dilation, padding, stride)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.unfold_ext(input, kernel_size, dilation, padding, stride)
-        
-    Refer to :func:`mindspore.ops.unfold_ext` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('kernel_size'),
-        sig.make_sig('dilation', default=1),
-        sig.make_sig('padding', default=0),
-        sig.make_sig('stride', default=1),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, kernel_size, dilation=1, padding=0, stride=1):
-          return _convert_stub(pyboost_im2col_ext(self, [input, to_pair('Im2ColExt', 'kernel_size', kernel_size), to_pair('Im2ColExt', 'dilation', dilation), to_pair('Im2ColExt', 'padding', padding), to_pair('Im2ColExt', 'stride', stride)]))
-
-im2col_ext_op=Im2ColExt()
-
-
-class IndexAddExt(Primitive):
-    r"""
-    
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
-        sig.make_sig('index', dtype=sig.sig_dtype.T1),
-        sig.make_sig('source', dtype=sig.sig_dtype.T),
-        sig.make_sig('axis', dtype=sig.sig_dtype.T2),
-        sig.make_sig('alpha', dtype=sig.sig_dtype.T3, default=1),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, index, source, axis, alpha=1):
-          return _convert_stub(pyboost_index_add_ext(self, [input, index, source, axis, alpha]))
-
-index_add_ext_op=IndexAddExt()
-
-
-class IndexSelect(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.IndexSelect()
-        out = prim(input, dim, index)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.index_select_ext(input, dim, index)
-        
-    Refer to :func:`mindspore.ops.index_select_ext` for more details.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, dim, index):
-          return _convert_stub(pyboost_index_select(self, [input, dim, index]))
-
-index_select_op=IndexSelect()
-
-
 class IRFFTGrad(Primitive):
     r"""
     
@@ -6017,52 +5381,6 @@ class IRFFT(Primitive):
 irfft_op=IRFFT()
 
 
-class IsClose(Primitive):
-    r"""
-    Returns a tensor of Boolean values indicating whether each element of `input`
-    is "close" to the corresponding element of `other`. Closeness is defined as:
-
-    .. math::
-        |input-other| <= atol + rtol * |other|
-
-    Refer to :func:`mindspore.ops.isclose` for more details.
-
-    Args:
-        rtol(float, optional): Relative tolerance. Default: ``1e-05`` .
-        atol(float, optional): Absolute tolerance. Default: ``1e-08`` .
-        equal_nan(bool, optional): If ``True`` , then two NaNs will be considered equal. Default: ``True`` .
-
-    Inputs:
-        - **input** (Tensor) - First tensor to compare.
-        - **other** (Tensor) - Second tensor to compare.
-
-    Outputs:
-        Tensor, with the same shape as `input` and `other` after broadcasting, its dtype is bool.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.ops import IsClose
-        >>> input = Tensor(np.array([1.3, 2.1, 3.2, 4.1, 5.1]), mindspore.float16)
-        >>> other = Tensor(np.array([1.3, 3.3, 2.3, 3.1, 5.1]), mindspore.float16)
-        >>> isclose = IsClose()
-        >>> output = isclose(input, other)
-        >>> print(output)
-        [ True False False False  True]
-    """
-    @prim_arg_register
-    def __init__(self, rtol=1e-05, atol=1e-08, equal_nan=True):
-        self._set_prim_arg("rtol", type_it('IsClose', 'rtol', rtol, (OpDtype.DT_BOOL, OpDtype.DT_INT), OpDtype.DT_FLOAT))
-        self._set_prim_arg("atol", type_it('IsClose', 'atol', atol, (OpDtype.DT_BOOL, OpDtype.DT_INT), OpDtype.DT_FLOAT))
-        self._set_prim_arg("equal_nan", equal_nan)
-
-    def __call__(self, input, other):
-          return _convert_stub(pyboost_isclose(self, [input, other, self.rtol, self.atol, self.equal_nan]))
-
 class IsFinite(Primitive):
     r"""
     .. code-block::
@@ -7159,31 +6477,6 @@ class MatrixExp(Primitive):
 matrix_exp_op=MatrixExp()
 
 
-class MatrixInverseExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.MatrixInverseExt()
-        out = prim(input)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.matrix_inverse_ext(input)
-        
-    Refer to :func:`mindspore.ops.matrix_inverse_ext` for more details.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input):
-          return _convert_stub(pyboost_matrix_inverse_ext(self, [input]))
-
-matrix_inverse_ext_op=MatrixInverseExt()
-
-
 class Max(Primitive):
     r"""
     .. code-block::
@@ -7543,6 +6836,42 @@ class Minimum(Primitive):
 minimum_op=Minimum()
 
 
+class MoeFinalizeRouting(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.MoeFinalizeRouting()
+        out = prim(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.moe_finalize_routing(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
+        
+    Refer to :func:`mindspore.ops.moe_finalize_routing` for more details.
+    """
+    __mindspore_signature__ =  (
+        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, 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::
@@ -7798,54 +7127,28 @@ class NLLLoss(Primitive):
           return super().__call__(logits, labels, weight, self.reduction, self.ignore_index)
 
 
-class NonZeroExt(Primitive):
+class NonZero(Primitive):
     r"""
+    .. code-block::
+        
+        prim = ops.NonZero()
+        out = prim(input)
+        
+    is equivalent to
+    
+    .. code-block::
     
+        ops.nonzero(input)
+        
+    Refer to :func:`mindspore.ops.nonzero` for more details.
     """
     @prim_arg_register
     def __init__(self):
         pass
 
     def __call__(self, input):
-          return _convert_stub(pyboost_non_zero_ext(self, [input]))
-
-non_zero_ext_op=NonZeroExt()
-
-
-class NonZero(Primitive):
-    r"""
-    Return a Tensor of the positions of all non-zero values.
-
-    Inputs:
-        - **input** (Tensor) - The input Tensor, its rank should be greater than or eaqual to 1.
-
-    Outputs:
-        Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
-
-    Raises:
-        TypeError: If `input` is not Tensor.
-        ValueError: If dim of `input` equals to 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
-        >>> output = ops.NonZero()(input)
-        >>> print(output)
-        [[0]
-         [2]
-         [4]]
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
+          return super().__call__(input)
 
-    def __call__(self, input):
-          return _convert_stub(pyboost_non_zero(self, [input]))
 
 non_zero_op=NonZero()
 
@@ -7872,60 +7175,32 @@ class Norm(Primitive):
 norm_op=Norm()
 
 
-class NormalFloatFloat(Primitive):
-    r"""
-    
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, mean, std, size, seed, offset):
-          return _convert_stub(pyboost_normal_float_float(self, [mean, std, size, seed, offset]))
-
-normal_float_float_op=NormalFloatFloat()
-
-
-class NormalFloatTensor(Primitive):
-    r"""
-    
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, mean, std, seed, offset):
-          return _convert_stub(pyboost_normal_float_tensor(self, [mean, std, seed, offset]))
-
-normal_float_tensor_op=NormalFloatTensor()
-
-
-class NormalTensorFloat(Primitive):
+class NormalExt(Primitive):
     r"""
-    
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
+    Generates random numbers according to the Normal random number distribution.
 
-    def __call__(self, mean, std, seed, offset):
-          return _convert_stub(pyboost_normal_tensor_float(self, [mean, std, seed, offset]))
+    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.
 
-normal_tensor_float_op=NormalTensorFloat()
+    Outputs:
+        - **output** (Tensor) - With the same type and shape as the 'mean'.
 
+    Raises:
+        TypeError: If `mean` or `std` is not Union[float, Tensor].
 
-class NormalTensorTensor(Primitive):
-    r"""
-    
+    Supported Platforms:
+        ``Ascend``
     """
     @prim_arg_register
     def __init__(self):
         pass
 
     def __call__(self, mean, std, seed, offset):
-          return _convert_stub(pyboost_normal_tensor_tensor(self, [mean, std, seed, offset]))
+          return _convert_stub(pyboost_normal_ext(self, [mean, std, seed, offset]))
 
-normal_tensor_tensor_op=NormalTensorTensor()
+normal_ext_op=NormalExt()
 
 
 class NotEqual(Primitive):
@@ -8155,9 +7430,9 @@ class OneHotExt(Primitive):
         >>> num_classes = 3
         >>> output = ops.extend.one_hot(tensor, num_classes)
         >>> print(output)
-        [[1 0 0]
-         [0 1 0]
-         [0 0 1]]
+        [[1. 0. 0.]
+         [0. 1. 0.]
+         [0. 0. 1.]]
     """
     @prim_arg_register
     def __init__(self, axis=-1):
@@ -8426,38 +7701,98 @@ prelu_op=PReLU()
 
 class ProdExt(Primitive):
     r"""
-    .. code-block::
-        
-        prim = ops.ProdExt()
-        out = prim(input, axis, keep_dims, dtype)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.prod_ext(input, axis, keep_dims, dtype)
-        
-    Refer to :func:`mindspore.ops.prod_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),
-    )
+    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`.
 
-    @prim_arg_register
-    def __init__(self):
-        pass
+    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`` .
 
-    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)]))
+    Returns:
+        Tensor, has the same data type as input tensor.
 
-prod_ext_op=ProdExt()
+        - 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.
 
-class PromptKVCache(Primitive):
-    r"""
+    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::
         
         prim = ops.PromptKVCache(align_mode)
@@ -8533,47 +7868,37 @@ class Qr(Primitive):
           return super().__call__(x, self.full_matrices)
 
 
-class RandExt(Primitive):
+class QuantBatchMatmul(Primitive):
     r"""
+    .. code-block::
+        
+        prim = ops.QuantBatchMatmul(transpose_x1, transpose_x2, dtype)
+        out = prim(x1, x2, scale, offset, bias)
+        
+    is equivalent to
     
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('shape'),
-        sig.make_sig('seed'),
-        sig.make_sig('offset'),
-        sig.make_sig('dtype', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, shape, seed, offset, dtype=None):
-          return _convert_stub(pyboost_rand_ext(self, [shape, seed, offset, dtype if dtype is None else dtype_to_type_id('RandExt', 'dtype', dtype)]))
-
-rand_ext_op=RandExt()
-
-
-class RandLikeExt(Primitive):
-    r"""
+    .. code-block::
     
+        ops.quant_batch_matmul(x1, x2, scale, offset, bias, transpose_x1, transpose_x2, dtype)
+        
+    Refer to :func:`mindspore.ops.quant_batch_matmul` for more details.
     """
     __mindspore_signature__ =  (
-        sig.make_sig('tensor'),
-        sig.make_sig('seed'),
-        sig.make_sig('offset'),
-        sig.make_sig('dtype', default=None),
+        sig.make_sig('x1', dtype=sig.sig_dtype.T),
+        sig.make_sig('x2', dtype=sig.sig_dtype.T),
+        sig.make_sig('scale', dtype=sig.sig_dtype.T1),
+        sig.make_sig('offset', dtype=sig.sig_dtype.T2, default=None),
+        sig.make_sig('bias', dtype=sig.sig_dtype.T3, default=None),
     )
 
     @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, tensor, seed, offset, dtype=None):
-          return _convert_stub(pyboost_rand_like_ext(self, [tensor, seed, offset, dtype if dtype is None else dtype_to_type_id('RandLikeExt', 'dtype', dtype)]))
-
-rand_like_ext_op=RandLikeExt()
+    def __init__(self, transpose_x1=False, transpose_x2=False, dtype=mstype.float16):
+        self._set_prim_arg("transpose_x1", transpose_x1)
+        self._set_prim_arg("transpose_x2", transpose_x2)
+        self._set_prim_arg_with_handler("dtype", dtype, dtype_to_type_id)
 
+    def __call__(self, x1, x2, scale, offset=None, bias=None):
+          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"""
@@ -9575,83 +8900,25 @@ class ReLU(Primitive):
 relu_op=ReLU()
 
 
-class RepeatInterleaveGrad(Primitive):
-    r"""
-    Gradients of RepeatInterleave operation.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, repeats, dim):
-          return _convert_stub(pyboost_repeat_interleave_grad(self, [input, repeats, dim]))
-
-repeat_interleave_grad_op=RepeatInterleaveGrad()
-
-
-class RepeatInterleaveInt(Primitive):
-    r"""
-    Repeat elements of a tensor along an axis, like `numpy.repeat`.
-
-    Args:
-        input (Tensor): The tensor to repeat values for. Must be of type: float16,
-            float32, int8, uint8, int16, int32, or int64.
-        repeats (int): The number of times to repeat, must be positive.
-        dim (int, optional): The dim along which to repeat, Default: ``None``. if dims is None,
-            the input Tensor will be flattened and the output will alse be flattened.
-        output_size (int, optional): Total output size for the given axis (e.g. sum of repeats),
-            Default: ``None``. 
-
-    Returns:
-        One tensor with values repeated along the specified dim. If input has shape
-        :math:`(s1, s2, ..., sn)` and dim is i, the output will have shape :math:`(s1, s2, ...,
-        si * repeats, ..., sn)`. The output type will be the same as the type of `input`.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('repeats'),
-        sig.make_sig('dim', default=None),
-        sig.make_sig('output_size', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, repeats, dim=None, output_size=None):
-          return _convert_stub(pyboost_repeat_interleave_int(self, [input, repeats, dim, output_size]))
-
-repeat_interleave_int_op=RepeatInterleaveInt()
-
-
-class RepeatInterleaveTensor(Primitive):
+class RepeatInterleave(Primitive):
     r"""
-    Repeat elements of a tensor along an axis, like `numpy.repeat`.
-
-    Args:
-        input (Tensor): The tensor to repeat values for. Must be of type: float16,
-            float32, int8, uint8, int16, int32, or int64.
-        repeats (Union[tuple, list, Tensor]): The number of times to repeat, must be positive.
-        dim (int, optional): The dim along which to repeat, Default: ``None``. if dims is None,
-            the input Tensor will be flattened and the output will alse be flattened.
-        output_size (int, optional): Total output size for the given axis (e.g. sum of repeats),
-            Default: ``None``. 
-
-    Returns:
-        One tensor with values repeated along the specified dim. If input has shape
-        :math:`(s1, s2, ..., sn)` and dim is i, the output will have shape :math:`(s1, s2, ...,
-        si * repeats, ..., sn)`. The output type will be the same as the type of `input`.
-
-    Supported Platforms:
-        ``Ascend``
+    .. 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('dim', default=None),
+        sig.make_sig('axis', default=None),
         sig.make_sig('output_size', default=None),
     )
 
@@ -9659,10 +8926,10 @@ class RepeatInterleaveTensor(Primitive):
     def __init__(self):
         pass
 
-    def __call__(self, input, repeats, dim=None, output_size=None):
-          return _convert_stub(pyboost_repeat_interleave_tensor(self, [input, repeats, dim, output_size]))
+    def __call__(self, input, repeats, axis=None, output_size=None):
+          return _convert_stub(pyboost_repeat_interleave(self, [input, repeats, axis, output_size]))
 
-repeat_interleave_tensor_op=RepeatInterleaveTensor()
+repeat_interleave_op=RepeatInterleave()
 
 
 class ReplicationPad1DGrad(Primitive):
@@ -9803,7 +9070,8 @@ class Reshape(Primitive):
         pass
 
     def __call__(self, input, shape):
-          return _convert_stub(pyboost_reshape(self, [input, shape]))
+          return super().__call__(input, shape)
+
 
 reshape_op=Reshape()
 
@@ -10339,58 +9607,6 @@ class RightShift(Primitive):
 right_shift_op=RightShift()
 
 
-class RmsNormGrad(Primitive):
-    r"""
-    Calculates the gradient of RmsNorm operation.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Inputs:
-        - **dy** (Tensor) - The grad of previous operator, support data type: float16, float32, bfloat16.
-        - **x** (Tensor) - Input data of RmsNorm, support data type: float16, float32, bfloat16.
-        - **rstd** (Tensor) - The second output of RmsNorm, support data type: float16, float32, bfloat16.
-        - **gamma** (Tensor) - Support data type: float16, float32, bfloat16.
-
-    Returns:
-        - **dx** (Tensor) - Has the same type and shape as `dy`.
-        - **dgamma** (Tensor) - A float32 Tensor with the same shape as `gamma`.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, dy, x, rstd, gamma):
-          return _convert_stub(pyboost_rms_norm_grad(self, [dy, x, rstd, gamma]))
-
-rms_norm_grad_op=RmsNormGrad()
-
-
-class RmsNorm(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.RmsNorm(epsilon)
-        out = prim(x, gamma)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.rms_norm(x, gamma, epsilon)
-        
-    Refer to :func:`mindspore.ops.rms_norm` for more details.
-    """
-    @prim_arg_register
-    def __init__(self, epsilon=1e-6):
-        self._set_prim_arg("epsilon", epsilon)
-
-    def __call__(self, x, gamma):
-          return _convert_stub(pyboost_rms_norm(self, [x, gamma, self.epsilon]))
-
 class Roll(Primitive):
     r"""
     Rolls the elements of a tensor along an axis.
@@ -10535,74 +9751,7 @@ scalar_cast_op=ScalarCast()
 
 class ScatterAddExt(Primitive):
     r"""
-    Add all elements in `src` to the index specified by `index` to `input` along dimension specified by `dim`.
-
-    It takes three inputs `input`, `src` and `index` of the same rank r >= 1.
-
-    For a 3-D tensor, the operation updates input as follows:
-
-    .. code-block::
-
-        input[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
-
-        input[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
-
-        input[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2
-
-    Inputs:
-        - **input** (Tensor) - The target tensor. The rank must be at least 1.
-        - **dim** (int) - Which dim to scatter. Accepted range is [-r, r) where r = rank(`input`). Default: ``0``.
-        - **index** (Tensor) - The index of `input` to do scatter operation whose data type must be mindspore.int32 or
-            mindspore.int64. Same rank as `input`. Except for the dimension specified by `dim`,
-            the size of each dimension of `index` must be less than or equal to the size of
-            the corresponding dimension of `input`.
-        - **src** (Tensor) - The tensor doing the scatter operation with `input`, has the same type as `input` and
-            the size of each dimension must be greater than or equal to that of `index`.
-
-    Outputs:
-        Tensor, has the same shape and type as `input`.
-
-    Raises:
-    TypeError: If `index` is neither int32 nor int64.
-    ValueError: If anyone of the rank among `input`, `index` and `src` less than 1.
-    ValueError: If the rank of `input`, `index` and `src` is not the same.
-    ValueError: If, outside dimension `dim`, the size of any dimension of `index` is greater than the size of
-        the corresponding dimension of `input` .
-    ValueError: If the size of any dimension of `src` is less than that of `index`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[1, 2, 3, 4, 5]]), dtype=ms.float32)
-        >>> src = Tensor(np.array([[8, 8]]), dtype=ms.float32)
-        >>> index = Tensor(np.array([[2, 4]]), dtype=ms.int64)
-        >>> out = ops.ScatterAddExt()(input=input, dim=1, index=index, src=src)
-        >>> print(out)
-        [[1. 2. 11. 4. 13.]]
-        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
-        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
-        >>> index = Tensor(np.array([[0, 0, 0], [2, 2, 2], [4, 4, 4]]), dtype=ms.int64)
-        >>> out = ops.ScatterAddExt()(input=input, dim=0, index=index, src=src)
-        >>> print(out)
-        [[1. 2. 3. 0. 0.]
-        [0. 0. 0. 0. 0.]
-        [4. 5. 6. 0. 0.]
-        [0. 0. 0. 0. 0.]
-        [7. 8. 9. 0. 0.]]
-        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
-        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
-        >>> index = Tensor(np.array([[0, 2, 4], [0, 2, 4], [0, 2, 4]]), dtype=ms.int64)
-        >>> out = ops.ScatterAddExt()(input=input, dim=1, index=index, src=src)
-        >>> print(out)
-        [[1. 0. 2. 0. 3.]
-        [4. 0. 5. 0. 6.]
-        [7. 0. 8. 0. 9.]
-        [0. 0. 0. 0. 0.]
-        [0. 0. 0. 0. 0.]]
+    
     """
     @prim_arg_register
     def __init__(self):
@@ -10654,68 +9803,6 @@ class Scatter(Primitive):
 scatter_op=Scatter()
 
 
-class SearchSorted(Primitive):
-    r"""
-    Return the position indices such that after inserting the values into the `sorted_sequence`, the order of innermost
-    dimension of the `sorted_sequence` remains unchanged.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.searchsorted` for more details.
-
-    Args:
-        dtype (mindspore.dtype, optional): The specified type of output tensor. Optional values are: ``mstype.int32`` and 
-            ``mstype.int64``. Default value: ``mstype.int64``.
-        right (bool, optional): Search Strategy. If ``True`` , return the last suitable index found;
-            if ``False`` , return the first such index. Default: ``False`` .
-
-    Inputs:
-        - **sorted_sequence** (Tensor) - The input tensor. It must contain a monotonically increasing sequence on the innermost dimension.
-        - **values** (Tensor) - The value that should be inserted.
-        - **sorter** (Tensor, optional) - if provided, a tensor matching the shape of the unsorted sorted_sequence
-          containing a sequence of indices that sort it in the ascending order on the innermost dimension and type must be int64. Default: ``None`` .
-
-    Outputs:
-        Tensor containing the indices from the innermost dimension of `sorted_sequence` such that,
-        if insert the corresponding value in the `values` Tensor, the order of `sorted_sequence` would be preserved,
-        whose datatype is int32 if out_int32 is ``True`` , otherwise int64, and shape is the same as the shape of
-        `values`.
-
-    Raises:
-        ValueError: If the dimension of `sorted_sequence` isn't 1 and all dimensions except the last dimension of `sorted_sequence` and `values` are different.
-        ValueError: If `sorted_sequence` value is a scalar.
-        ValueError: If `values` is a scalar when `sorted_sequence` dimension is not 1.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> searchsorted = ops.SearchSorted()
-        >>> sorted_sequence = Tensor(np.array([[0, 1, 3, 5, 7], [2, 4, 6, 8, 10]]), mindspore.float32)
-        >>> values = Tensor(np.array([[3, 6, 9], [3, 6, 9]]), mindspore.float32)
-        >>> output = searchsorted(sorted_sequence, values)
-        >>> print(output)
-        [[2 4 5]
-        [1 2 4]]
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('sorted_sequence'),
-        sig.make_sig('values'),
-        sig.make_sig('sorter', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, dtype=mstype.int64, right=False):
-        self._set_prim_arg_with_handler("dtype", dtype, dtype_to_type_id)
-        self._set_prim_arg("right", right)
-
-    def __call__(self, sorted_sequence, values, sorter=None):
-          return _convert_stub(pyboost_searchsorted(self, [sorted_sequence, values, sorter, self.dtype, self.right]))
-
 class Select(Primitive):
     r"""
     .. code-block::
@@ -10803,31 +9890,6 @@ class Sigmoid(Primitive):
 sigmoid_op=Sigmoid()
 
 
-class Sign(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.Sign()
-        out = prim(input)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.sign(input)
-        
-    Refer to :func:`mindspore.ops.sign` for more details.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input):
-          return _convert_stub(pyboost_sign(self, [input]))
-
-sign_op=Sign()
-
-
 class SiLUGrad(Primitive):
     r"""
     Performs grad of SiLU operation.
@@ -10946,41 +10008,7 @@ sinh_op=Sinh()
 
 class SliceExt(Primitive):
     r"""
-    Returns a sliced tensor from input tensor, and
-    the dimension axis is input from start to end by step.
-
-    Args:
-        input (Tensor): the tensor to slice.
-        dim (int): dimension  along which to slice.
-        start (int): the starting dimension.
-        end (int): the ending dimension.
-        step (int): the slice step size
-
-    Returns:
-        Tensor.
-
-    Raises:
-        ValueError: If dim is out of range [-input.ndim, input.ndim).
-        ValueError: If start is out of range [-input.shape[dim], input.shape[dim]].
-        ValueError: It end is out of range [start, input.shape[dim]].
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mindspore.int32)
-        >>> output = ops.SliceExt()(x, 0, 0, 2, 1)
-        >>> print(output)
-        [[ 1 2 3]
-         [ 4 5 6]]
-        >>> output = ops.SliceExt()(x, 1, 1, 3, 1)
-        >>> print(output)
-        [[ 2 3]
-         [ 5 6]
-         [ 8 9]]
+    
     """
     @prim_arg_register
     def __init__(self):
@@ -11134,38 +10162,6 @@ class SolveTriangular(Primitive):
 solve_triangular_op=SolveTriangular()
 
 
-class SortExt(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.SortExt()
-        out = prim(input, dim, descending, stable)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.sort_ext(input, dim, descending, stable)
-        
-    Refer to :func:`mindspore.ops.sort_ext` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('dim', default=-1),
-        sig.make_sig('descending', default=False),
-        sig.make_sig('stable', default=False),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, dim=-1, descending=False, stable=False):
-          return _convert_stub(pyboost_sort_ext(self, [input, dim, descending, stable]))
-
-sort_ext_op=SortExt()
-
-
 class Split(Primitive):
     r"""
     Splits the input tensor into output_num of tensors along the given axis and output numbers.
@@ -11432,7 +10428,8 @@ class Sub(Primitive):
         pass
 
     def __call__(self, input, other):
-          return _convert_stub(pyboost_sub(self, [input, other]))
+          return super().__call__(input, other)
+
 
 sub_op=Sub()
 
@@ -11657,32 +10654,6 @@ class TopkExt(Primitive):
 topk_ext_op=TopkExt()
 
 
-class TopKRouter(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.TopKRouter()
-        out = prim(input, capacity, expert_num)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.topkrouter(input, capacity, expert_num)
-        
-    Refer to :func:`mindspore.ops.topkrouter` for more details.
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, capacity, expert_num):
-          return super().__call__(input, capacity, expert_num)
-
-
-topkrouter_op=TopKRouter()
-
-
 class Trace(Primitive):
     r"""
     .. code-block::
@@ -11734,6 +10705,28 @@ 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::
@@ -11793,8 +10786,8 @@ class UniformExt(Primitive):
 
     Inputs:
         - **tensor** (Tensor) - The tensor of random tensor to be generated.
-        - **a** (number) - Lower bound of the random numbers. Default: 0.0.
-        - **b** (number) - Upper bound of the random numbers. Default: 0.0.
+        - **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.
 
@@ -11829,135 +10822,6 @@ class UniformExt(Primitive):
 uniform_ext_op=UniformExt()
 
 
-class Unique2(Primitive):
-    r"""
-    Returns the unique elements of input tensor.
-
-    when `return_inverse=True`, also return a tensor containing the index of each value of input
-    tensor corresponding to the output unique tensor.
-    when `return_counts=True`, also return a tensor containing the number of occurrences for each
-    unique value or tensor
-
-    Inputs:
-        - **input**(Tensor) - The input tensor.
-        - **sorted**(bool) - Whether to sort the unique elements in ascending order before returning as output.
-          Default: ``True`` .
-        - **return_inverse**(bool) - Whether to also return the indices for where elements in the original input ended up in
-          the returned unique list. Default: ``False`` .
-        - **return_counts**(bool) - Whether to also return the counts for each unique element. Default: ``False`` .
-
-
-    Returns:
-        A tensor or a tuple of tensors containing some of tensor objects (`output`, `inverse_indices`, `counts`).
-
-        - **output**(Tensor) - the output list of unique scalar elements.
-        - **inverse_indices**(Tensor) - Return when ``return_inverse`` is True. It represents the indices for where
-          elements in the original input map to in the output; The shape is input.shape[dim].
-        - **counts**(Tensor) - Return when ``return_counts`` is True. It represents the number of occurrences for each
-          unique value or tensor. The shape is output.shape(dim).
-
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn
-        >>> from mindspore import ops
-        >>> x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
-        >>> unique =  ops.auto_generate.Unique2()
-        >>> output = unique(x, return_inverse=True)
-        >>> print(output)
-        (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int32, value= [0, 1, 2, 1]))
-        >>> y = output[0]
-        >>> print(y)
-        [1 2 5]
-        >>> idx = output[1]
-        >>> print(idx)
-        [0 1 2 1]
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('input'),
-        sig.make_sig('sorted', default=True),
-        sig.make_sig('return_inverse', default=False),
-        sig.make_sig('return_counts', default=False),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, sorted=True, return_inverse=False, return_counts=False):
-          return _convert_stub(pyboost_unique2(self, [input, sorted, return_inverse, return_counts]))
-
-unique2_op=Unique2()
-
-
-class UniqueDim(Primitive):
-    r"""
-    Returns the unique elements of input tensor.
-
-    when `return_inverse=True`, also return a tensor containing the index of each value of input
-    tensor corresponding to the output unique tensor.
-
-    Inputs:
-        - **input**(Tensor) - The input tensor.
-        - **sorted**(bool) - Whether to sort the unique elements in ascending order before returning as output.
-        - **return_inverse**(bool) - Whether to also return the indices for where elements in the original input ended up in
-          the returned unique list.
-        - **dim**(int) - the dimension to operate upon.
-
-
-    Returns:
-        A tensor or a tuple of tensors containing some of tensor objects (`output`, `inverse_indices`, `counts`).
-
-        - **output**(Tensor) - the output list of unique scalar elements.
-        - **inverse_indices**(Tensor) - Return when ``return_inverse`` is True. It represents the indices for where
-          elements in the original input map to in the output; The shape is input.shape[dim].
-        - **counts**(Tensor) - Return the number of occurrences for each unique value or tensor. The shape is
-          output.shape(dim).
-
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn
-        >>> from mindspore import ops
-        >>> x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
-        >>> unique =  ops.auto_generate.UniqueDim()
-        >>> output = unique(x, sorted=True, return_inverse=True, dim=0)
-        >>> print(output)
-        (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int32, value= [0, 1, 2, 1]))
-        >>> y = output[0]
-        >>> print(y)
-        [1 2 5]
-        >>> idx = output[1]
-        >>> print(idx)
-        [0 1 2 1]
-        >>> counts = output[1]
-        >>> print(counts)
-        [1 2 1]
-    """
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, input, sorted, return_inverse, dim):
-          return _convert_stub(pyboost_unique_dim(self, [input, sorted, return_inverse, dim]))
-
-unique_dim_op=UniqueDim()
-
-
 class UnsortedSegmentSum(Primitive):
     r"""
     .. code-block::
@@ -12658,6 +11522,40 @@ class View(Primitive):
 view_op=View()
 
 
+class WeightQuantBatchMatmul(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.WeightQuantBatchMatmul(transpose_x, transpose_weight, antiquant_group_size)
+        out = prim(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.weight_quant_batch_matmul(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size)
+        
+    Refer to :func:`mindspore.ops.weight_quant_batch_matmul` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('x'),
+        sig.make_sig('weight'),
+        sig.make_sig('antiquant_scale'),
+        sig.make_sig('antiquant_offset', default=None),
+        sig.make_sig('quant_scale', default=None),
+        sig.make_sig('quant_offset', default=None),
+        sig.make_sig('bias', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self, transpose_x=False, transpose_weight=False, antiquant_group_size=0):
+        self._set_prim_arg("transpose_x", transpose_x)
+        self._set_prim_arg("transpose_weight", transpose_weight)
+        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 _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.
@@ -12668,7 +11566,7 @@ class ZerosLikeExt(Primitive):
         - **input_x** (Tensor) - Tensor of any dimension.
 
     Returns:
-        Return a tensor filled with the value 0, with the same size as input.
+        Tensor, has the same shape and type as `input_x` but filled with ones.
 
     Supported Platforms:
         ``Ascend``
@@ -12723,445 +11621,3 @@ class ZerosLike(Primitive):
 
 
 zeros_like_op=ZerosLike()
-
-
-class DynamicQuantExt(Primitive):
-    r"""
-    Performs dynamic quantization on the input tensor.
-
-    Note:
-      - Dynamic quantization is performed by adjusting the scale of the input tensor dynamically.
-      - The `smooth_scales` tensor provides a mechanism to smooth out the scaling factors to avoid sudden changes.
-      - The input tensor `x` must be at least 1-dimensional, with shape :math:`(batches, n)`.
-      - The `smooth_scales` tensor must have shape `(n)`.
-      - The output `scale` tensor has shape `(batches)`.
-
-    .. math::
-      \begin{array}{ll} \\
-          \text{scale} = \frac{\max(\left| x \right|, \text{axis}=-1)}{127} \\
-          \text{y} = \text{round}\left(\frac{x}{\text{scale}}\right) \\
-      \end{array}
-
-    Inputs:
-      x (Tensor): The first input is a tensor of data type float16 or bfloat16. 
-          It contains the data to be quantized. 
-      smooth_scales (Tensor): The second input is a tensor of data type float16 or bfloat16. 
-          It contains the scaling factors used for dynamic quantization.
-
-    Outputs:
-      tuple[Tensor], tuple of 2 tensors, representing the quantized values and the scales used.
-
-      - **y** (Tensor) - The quantized tensor.
-      - **scale** (Tensor) - The scales used for quantization.
-
-    Raises:
-      ValueError: If the rank of `x` is not at least 1.
-
-    Supported Platforms:
-      ``Ascend``
-
-    Examples:
-      >>> import mindspore
-      >>> import numpy as np
-      >>> from mindspore import Tensor, ops
-      >>> input = Tensor(np.random.rand(2, 3), mindspore.float16)
-      >>> smooth_scales = Tensor(np.random.rand(3), mindspore.float16)
-      >>> output = ops.auto_generate.DynamicQuantExt()(input, smooth_scales)
-      >>> print(output.shape)
-      (2, 3)
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x'),
-        sig.make_sig('smooth_scales', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, x, smooth_scales=None):
-          return _convert_stub(pyboost_dynamic_quant_ext(self, [x, smooth_scales]))
-
-dynamic_quant_ext_op=DynamicQuantExt()
-
-
-class FusedInferAttentionScore(Primitive):
-    r"""
-    The interface for fully inference.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        num_heads (int): The number of heads, equal to `N` when input_layout is `BNSD`.
-        scale_value (float): The scale value indicating the scale coefficient, which is used as the scalar of Muls in the calculation.
-            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.
-            Default: ``2147483547``. Invalid when Q_S is 1.
-        next_tokens (int): Parameter for sparse computation, represents how many tokens are counted backward.
-            Default: ``2147483547``. Invalid when Q_S is 1.
-        input_layout (str): Specifies the layout of input `query`, key and value. "BSH", "BNSD" or "BSND" is supported.
-            Default "BSH".
-        num_key_value_heads (int): head numbers of key/value which are used in GQA algorithm. Default: ``0``.
-            The value 0 indicates if the key and value have the same head nums, num_heads must be divisible by num_key_value_heads.
-        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, 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.
-
-        inner_precise (int): There are four modes: 0, 1, 2, and 3. Only support 0 and 1 when Q_S is 1. Default: ``1``. 
-            - 0: Enable high-precise mode, without row invalid correction.
-            - 1: High-performance mode, without row invalid correction.
-            - 2: Enable high-precise mode, with row invalid correction.
-            - 3: High-performance mode, with row invalid correction.
-
-        block_size (int): Maximum number of tokens per block in the KV cache block for PageAttention. Default: ``0``.
-        antiquant_mode (int): Pseudo-quantization mode, 0: per-channel, 1: per-token. This parameter is invalid when Q_S greater than or equal to 2. Default: ``0``.
-        softmax_lse_flag (bool): Whether to output softmax_lse. Default: ``False``.
-
-    Inputs:
-        - **query** (Tensor) - The query tensor with data type of Int8, float16 or BFloat16.
-          Input tensor of shape :math:`(B, S, H)`, :math:`(B, N, S, D)`, or :math:`(B, S, N, D)`.
-        - **key** (TensorList) - The key tensor with data type of float16 or BFloat16.
-          Input tensor of shape :math:`(B, S, H)`, :math:`(B, N, S, D)`, or :math:`(B, S, N, D)`.
-        - **value** (TensorList) - The value tensor with data type of float16 or BFloat16.
-          Input tensor of shape :math:`(B, S, H)`, :math:`(B, N, S, D)`, or :math:`(B, S, N, D)`.
-        - **pse_shift** (Tensor) - The padding mask tensor with data type of float16 or BFloat16. Default: ``None``.
-        - **attn_mask** (Tensor) - The attention mask tensor with data type of int8, uint8 or bool. For each element, 0 indicates retention and 1 indicates discard.
-          Default: ``None``.
-        - **actual_seq_lengths** (Tensor) - Describe actual sequence length of each input with data type of int64.
-          Default: ``None``.
-        - **actual_seq_lengths_kv** (Tensor) - Describe actual sequence length of each input with data type of int64.
-          Default: ``None``.
-        - **dequant_scale1** (Tensor) - Quantization factor for inverse quantization after BMM1 with data type of uint64.
-          Default: ``None``.
-        - **quant_scale1** (Tensor) - Quantization factors for quantization before BMM2 with data type of float32.
-          Default: ``None``.
-        - **dequant_scale2** (Tensor) - Quantization factors for quantification after BMM2 with data type of uint64.
-          Default: ``None``.
-        - **quant_scale2** (Tensor) - Quantization factors for output quantization with data type of float32, BFloat16.
-          Default: ``None``.
-        - **quant_offset2** (Tensor) - Quantization offset for output quantization with data type of float32, BFloat16.
-          Default: ``None``.
-        - **antiquant_scale** (Tensor) - Inverse quantization factor with data type of float16, float32, BFloat16. Only support float16 when Q_S greater than or equal to 2.
-          Default: ``None``.
-        - **antiquant_offset** (Tensor) - Inverse quantization offset with data type of float16, float32, BFloat16. Only support float16 when Q_S greater than or equal to 2.
-          Default: ``None``.
-        - **block_table** (Tensor) - Block mapping table in KV cache for PageAttention.
-          Default: ``None``.
-        - **query_padding_size** (Tensor) - Whether each batch of data in the Query is right-aligned. If yes, the number of alignment times is provided. Reserved parameter, not supported yet.
-          Default: ``None``.
-        - **kv_padding_size** (Tensor) - Whether each batch of data in the Key/Value is right-aligned. If yes, the number of alignment times is provided. Valid only when Q_S is 1.
-          Default: ``None``.
-
-    Outputs:
-        - **attention_out** (Tensor) - Input tensor, and the shape is :math:`(B, S, H)`, :math:`(B, N, S, D)`, or :math:`(B, S, N, D)`.
-        - **softmas_lse** (Tensor[Float32]) - Shape is `(B, N, Q_S, 1)`. The softmas_lse is calculated only if softmax_lse_flag is 1.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore.ops.operations import _infer_ops as infer_ops
-        >>> from mindspore import Tensor
-        >>> import numpy as np
-        >>> B = 1
-        >>> N = 16
-        >>> S = 256
-        >>> D = 16
-        >>> query = Tensor(np.ones((B, N, S, D), dtype=np.float16))
-        >>> key = [Tensor(np.ones((B, N, S, D), dtype=np.float16))]
-        >>> value = [Tensor(np.ones((B, N, S, D), dtype=np.float16))]
-        >>> fias = infer_ops.FusedInferAttentionScore(num_heads=N, input_layout='BNSD')
-        >>> out = fias(query, key, value, None, None,
-        ...            None, None, None, None, None,
-        ...            None, None, None, None, None,
-        ...            None, None)
-        >>> print(out[0].shape)
-        (1, 16, 256, 16)
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('query'),
-        sig.make_sig('key'),
-        sig.make_sig('value'),
-        sig.make_sig('pse_shift', default=None),
-        sig.make_sig('attn_mask', default=None),
-        sig.make_sig('actual_seq_lengths', default=None),
-        sig.make_sig('actual_seq_lengths_kv', default=None),
-        sig.make_sig('dequant_scale1', default=None),
-        sig.make_sig('quant_scale1', default=None),
-        sig.make_sig('dequant_scale2', default=None),
-        sig.make_sig('quant_scale2', default=None),
-        sig.make_sig('quant_offset2', default=None),
-        sig.make_sig('antiquant_scale', default=None),
-        sig.make_sig('antiquant_offset', default=None),
-        sig.make_sig('block_table', default=None),
-        sig.make_sig('query_padding_size', default=None),
-        sig.make_sig('kv_padding_size', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, num_heads, scale_value=1.0, pre_tokens=2147483647, next_tokens=2147483647, input_layout='BSH', num_key_value_heads=0, sparse_mode=0, inner_precise=1, block_size=0, antiquant_mode=0, softmax_lse_flag=False):
-        self._set_prim_arg("num_heads", num_heads)
-        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_with_handler("input_layout", input_layout, str_to_enum)
-        self._set_prim_arg("num_key_value_heads", num_key_value_heads)
-        self._set_prim_arg("sparse_mode", sparse_mode)
-        self._set_prim_arg("inner_precise", inner_precise)
-        self._set_prim_arg("block_size", block_size)
-        self._set_prim_arg("antiquant_mode", antiquant_mode)
-        self._set_prim_arg("softmax_lse_flag", softmax_lse_flag)
-
-    def __call__(self, query, key, value, pse_shift=None, attn_mask=None, actual_seq_lengths=None, actual_seq_lengths_kv=None, dequant_scale1=None, quant_scale1=None, dequant_scale2=None, quant_scale2=None, quant_offset2=None, antiquant_scale=None, antiquant_offset=None, block_table=None, query_padding_size=None, kv_padding_size=None):
-          return super().__call__(query, key, value, pse_shift, attn_mask, actual_seq_lengths, actual_seq_lengths_kv, dequant_scale1, quant_scale1, dequant_scale2, quant_scale2, quant_offset2, antiquant_scale, antiquant_offset, block_table, query_padding_size, kv_padding_size, self.num_heads, self.scale_value, self.pre_tokens, self.next_tokens, self.input_layout, self.num_key_value_heads, self.sparse_mode, self.inner_precise, self.block_size, self.antiquant_mode, self.softmax_lse_flag)
-
-
-class GroupedMatmul(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.GroupedMatmul(split_item, group_type)
-        out = prim(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.grouped_matmul(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, split_item, group_type)
-        
-    Refer to :func:`mindspore.ops.grouped_matmul` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x'),
-        sig.make_sig('weight'),
-        sig.make_sig('bias', default=None),
-        sig.make_sig('scale', default=None),
-        sig.make_sig('offset', default=None),
-        sig.make_sig('antiquant_scale', default=None),
-        sig.make_sig('antiquant_offset', default=None),
-        sig.make_sig('group_list', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, split_item=0, group_type=-1):
-        self._set_prim_arg("split_item", split_item)
-        self._set_prim_arg("group_type", group_type)
-
-    def __call__(self, x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, group_list=None):
-          return _convert_stub(pyboost_grouped_matmul(self, [x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, self.split_item, self.group_type]))
-
-class KVCacheScatterUpdate(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.KVCacheScatterUpdate()
-        out = prim(var, indices, updates, axis, reduce)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.kv_cache_scatter_update(var, indices, updates, axis, reduce)
-        
-    Refer to :func:`mindspore.ops.kv_cache_scatter_update` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('var'),
-        sig.make_sig('indices'),
-        sig.make_sig('updates'),
-        sig.make_sig('axis'),
-        sig.make_sig('reduce', default='none'),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, var, indices, updates, axis, reduce='none'):
-          return super().__call__(var, indices, updates, axis, str_to_enum('KVCacheScatterUpdate', 'reduce', reduce))
-
-
-kv_cache_scatter_update_op=KVCacheScatterUpdate()
-
-
-class MoeFinalizeRouting(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.MoeFinalizeRouting()
-        out = prim(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.moe_finalize_routing(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
-        
-    Refer to :func:`mindspore.ops.moe_finalize_routing` for more details.
-    """
-    __mindspore_signature__ =  (
-        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, expanded_x, x1, x2=None, bias=None, scales=None, expanded_row_idx=None, expanded_expert_idx=None):
-          return _convert_stub(pyboost_moe_finalize_routing(self, [expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx]))
-
-moe_finalize_routing_op=MoeFinalizeRouting()
-
-
-class QuantBatchMatmul(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.QuantBatchMatmul(transpose_x1, transpose_x2, dtype)
-        out = prim(x1, x2, scale, offset, bias)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.quant_batch_matmul(x1, x2, scale, offset, bias, transpose_x1, transpose_x2, dtype)
-        
-    Refer to :func:`mindspore.ops.quant_batch_matmul` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x1', dtype=sig.sig_dtype.T),
-        sig.make_sig('x2', dtype=sig.sig_dtype.T),
-        sig.make_sig('scale', dtype=sig.sig_dtype.T1),
-        sig.make_sig('offset', dtype=sig.sig_dtype.T2, default=None),
-        sig.make_sig('bias', dtype=sig.sig_dtype.T3, default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, transpose_x1=False, transpose_x2=False, dtype=mstype.float16):
-        self._set_prim_arg("transpose_x1", transpose_x1)
-        self._set_prim_arg("transpose_x2", transpose_x2)
-        self._set_prim_arg_with_handler("dtype", dtype, dtype_to_type_id)
-
-    def __call__(self, x1, x2, scale, offset=None, bias=None):
-          return _convert_stub(pyboost_quant_batch_matmul(self, [x1, x2, scale, offset, bias, self.transpose_x1, self.transpose_x2, self.dtype]))
-
-class QuantV2(Primitive):
-    r"""
-    Returns the quantized value of input x.
-
-    If `sqrt_mode` is False:
-
-    .. math::
-        y = round(scale * x + offset)
-
-    If `sqrt_mode` is True:
-
-    .. math::
-        y = round(scale * x * scale + offset)
-
-    Inputs:
-        x (Tensor) : Input tensor. 
-            Its data type must be mindspore.float16, mindspore.float32 or mindspore.bfloat32.
-        scale (Tensor) : Scaling ratio tensor in quantization. Its type is the same as x.
-            Its shape in the last axis must equal to the shape of x in the last axis,
-            and shapes of other dimensions must be 1.
-        offset (Tensor) : Offset tensor in quantization. Its type is the same as x.
-            Its shape in the last axis must equal to the shape of x in the last axis,
-            and shapes of other dimensions must be 1.
-        sqrt_mode (bool) : Specifies whether to perform square root on `scale`. Only support: ``False``.
-        rounding_mode (str) : Specifies the way to round. Only support: "ROUND".
-        dst_type (Type) : Specifies the output type. Only support ``int8``.
-
-    Returns:
-        Tensor, the quantized output tensor of type mindspore.int8. Its shape is the same as x.
-
-    Raises:
-        TypeError: If input, scale or offset is not a Tensor.
-        ValueError: The shape of scale or offset in the last axis is different from the shape of x in the last axis.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore import Tensor
-        >>> from mindspore.ops.operations import _infer_ops as infer_ops
-        >>> x = Tensor([100.0, 150.0], mstype.float32)
-        >>> scale = Tensor([80.0, 40.0], mstype.float32)
-        >>> offset = Tensor([0.0, 2.0], mstype.float32)
-        >>> quant = infer_ops.QuantV2()
-        >>> y = quant(x, scale, offset, False, "Round", mstype.int8)
-        [127 127]
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x'),
-        sig.make_sig('scale'),
-        sig.make_sig('offset'),
-        sig.make_sig('sqrt_mode', default=False),
-        sig.make_sig('rounding_mode', default='ROUND'),
-        sig.make_sig('dst_type', default=mstype.int8),
-    )
-
-    @prim_arg_register
-    def __init__(self):
-        pass
-
-    def __call__(self, x, scale, offset, sqrt_mode=False, rounding_mode='ROUND', dst_type=mstype.int8):
-          return _convert_stub(pyboost_quant_v2(self, [x, scale, offset, sqrt_mode, str_to_enum('QuantV2', 'rounding_mode', rounding_mode), dtype_to_type_id('QuantV2', 'dst_type', dst_type)]))
-
-quant_v2_op=QuantV2()
-
-
-class WeightQuantBatchMatmul(Primitive):
-    r"""
-    .. code-block::
-        
-        prim = ops.WeightQuantBatchMatmul(transpose_x, transpose_weight, antiquant_group_size)
-        out = prim(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias)
-        
-    is equivalent to
-    
-    .. code-block::
-    
-        ops.weight_quant_batch_matmul(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size)
-        
-    Refer to :func:`mindspore.ops.weight_quant_batch_matmul` for more details.
-    """
-    __mindspore_signature__ =  (
-        sig.make_sig('x'),
-        sig.make_sig('weight'),
-        sig.make_sig('antiquant_scale'),
-        sig.make_sig('antiquant_offset', default=None),
-        sig.make_sig('quant_scale', default=None),
-        sig.make_sig('quant_offset', default=None),
-        sig.make_sig('bias', default=None),
-    )
-
-    @prim_arg_register
-    def __init__(self, transpose_x=False, transpose_weight=False, antiquant_group_size=0):
-        self._set_prim_arg("transpose_x", transpose_x)
-        self._set_prim_arg("transpose_weight", transpose_weight)
-        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 _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]))