mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/_vmap/vmap_nn_ops.py

@@ -2068,14 +2068,15 @@ def get_sparse_apply_adagrad_vmap_rule(prim, axis_size):
         indices, indices_dim = indices_bdim
         if var_dim is None:
             if any(dim is not None for dim in [accum_dim, grad_dim, indices_dim]):
-                ValueError("The source axis of `var` is None, but the source "
-                           "axis of `accum/grad/indices` is not None. The execution order of "
-                           "operator `{}` cannot be guaranteed.".format(prim_name))
+                _raise_value_error("The source axis of `var` is None, but the source "
+                                   "axis of `accum/grad/indices` is not None. The execution "
+                                   "order of operator `{}` cannot be guaranteed.".format(prim_name))
             var, accum = prim(var, accum, grad, indices, u_monad)
             return (var, None), (accum, None)
         if var_dim != 0 or accum_dim != var_dim:
-            ValueError("For `{}`, the source axis of `var` must be equal to `accum`, and not equal to 0, "
-                       "but got the source axis of `var`: {}, `accum`: {}.".format(prim_name, var_dim, accum_dim))
+            _raise_value_error("For `{}`, the source axis of `var` must be equal to `accum`, "
+                               "and not equal to 0, but got the source axis of `var`: {}, "
+                               "`accum`: {}.".format(prim_name, var_dim, accum_dim))
 
         grad = _bdim_at_front(grad, grad_dim, axis_size)
         indices = _bdim_at_front(indices, indices_dim, axis_size)
@@ -2094,27 +2095,18 @@ def get_sparse_apply_ftrl_vmap_rule(prim, axis_size):
     else:
         batch_rank = 1
 
-    prim_name = prim.name
     batch_prim = _vmap_clone_prim(prim)
     batch_prim.add_prim_attr('batch_rank', batch_rank)
 
     def vmap_rule(var_bdim, accum_bdim, linear_bdim, grad_bdim, indices_bdim, u_monad):
         var, var_dim = var_bdim
-        accum, accum_dim = accum_bdim
-        linear, linear_dim = linear_bdim
+        accum, _ = accum_bdim
+        linear, _ = linear_bdim
         grad, grad_dim = grad_bdim
         indices, indices_dim = indices_bdim
         if var_dim is None:
-            if any(dim is not None for dim in [accum_dim, linear_dim, grad_dim, indices_dim]):
-                ValueError("The source axis of `var` is None, but the source "
-                           "axis of `accum/linear/grad/indices` is not None. The execution order of "
-                           "operator `{}` cannot be guaranteed.".format(prim_name))
             var, accum, linear = prim(var, accum, linear, grad, indices, u_monad)
             return (var, None), (accum, None), (linear, None)
-        if var_dim != 0 or accum_dim != var_dim or linear_dim != var_dim:
-            ValueError("For `{}`, the source axis of `var`, `accum` and `linear` must be equal, and "
-                       "not equal to 0, but got the source axis of `var`: {}, `accum`: {}, "
-                       "`linear`:{}.".format(prim_name, var_dim, accum_dim, linear_dim))
 
         grad = _bdim_at_front(grad, grad_dim, axis_size)
         indices = _bdim_at_front(indices, indices_dim, axis_size)

mindspore/ops/auto_generate/cpp_create_prim_instance_helper.py

@@ -53,9 +53,9 @@ op_args_default_value = {
     "Baddbmm": {"beta": 1, "alpha": 1},
     "BatchMatMul": {"transpose_a": False, "transpose_b": False},
     "BatchNormElemt": {"weight": None, "bias": None, "mean": None, "invstd": None, "eps": 1e-5},
-    "BatchNormExt": {"running_mean": None, "runnning_var": None, "training": False, "momentum": 0.1, "epsilon": 1e-5},
+    "BatchNormExt": {"weight": None, "bias": None, "running_mean": None, "runnning_var": None, "training": False, "momentum": 0.1, "epsilon": 1e-5},
     "BatchNormGatherStatsWithCounts": {"running_mean": None, "running_var": None, "momentum": 1e-1, "eps": 1e-5, "counts": None},
-    "BatchNormGradExt": {"running_mean": None, "running_var": None, "saved_mean": None, "saved_rstd": None, "training": False, "eps": 1e-5, "output_mask": (1, 1, 1)},
+    "BatchNormGradExt": {"weight": None, "running_mean": None, "running_var": None, "saved_mean": None, "saved_rstd": None, "training": False, "eps": 1e-5, "output_mask": (1, 1, 1)},
     "BatchNormGradGrad": {"is_training": False, "epsilon": 1e-5, "data_format": 'NCHW'},
     "BatchNormGrad": {"is_training": False, "epsilon": 1e-5, "data_format": 'NCHW'},
     "BatchNormGradWithActivation": {"is_training": False, "epsilon": 1e-5, "data_format": 'NCHW'},
@@ -76,6 +76,7 @@ op_args_default_value = {
     "CholeskyInverse": {"upper": False},
     "Cholesky": {"upper": False},
     "Chunk": {"dim": 0},
+    "ChunkView": {"dim": 0},
     "ClampScalar": {"min": None, "max": None},
     "ClampTensor": {"min": None, "max": None},
     "Col2ImExt": {"dilation": 1, "padding": 0, "stride": 1},
@@ -103,6 +104,7 @@ op_args_default_value = {
     "DCT": {"type": 2, "n": None, "axis": -1, "norm": None},
     "Dense": {"bias": None},
     "Diagonal": {"offset": 0, "dim1": 0, "dim2": 1},
+    "DiagonalView": {"offset": 0, "dim1": 0, "dim2": 1},
     "DiagExt": {"diagonal": 0},
     "DivMods": {"rounding_mode": None},
     "DivMod": {"rounding_mode": None},
@@ -140,13 +142,12 @@ op_args_default_value = {
     "FlashAttentionScore": {"real_shift": None, "drop_mask": None, "padding_mask": None, "attn_mask": None, "prefix": None, "actual_seq_qlen": None, "actual_seq_kvlen": None, "keep_prob": 1.0, "scale_value": 1.0, "pre_tokens": 2147483647, "next_tokens": 2147483647, "inner_precise": 0, "input_layout": 'BSH', "sparse_mode": 0},
     "FlattenExt": {"start_dim": 0, "end_dim": -1},
     "FullLike": {"dtype": None},
+    "FusedAddTopKDiv": {"activate_type": 0, "is_norm": True, "scale": 2.5, "mapping_num": None, "mapping_table": None, "enable_expert_mapping": False},
     "Gather": {"batch_dims": 0},
     "GeluExt": {"approximate": 'none'},
     "GeluGradExt": {"approximate": 'none'},
     "GenerateEodMaskV2": {"start": 0, "steps": 1, "error_mode": 'cycle', "flip_mode": 'bitflip', "multiply_factor": 0.0, "bit_pos": 0, "flip_probability": 0.0},
     "GLU": {"axis": -1},
-    "GmmBackward": {"group_list": None},
-    "GmmV2Backward": {"group_list": None, "group_list_type": 0},
     "GridSampler2DGrad": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False, "output_mask": (1, 1)},
     "GridSampler2D": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False},
     "GridSampler3DGrad": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False, "output_mask": (1, 1)},
@@ -175,6 +176,7 @@ op_args_default_value = {
     "IncreFlashAttention": {"attn_mask": None, "actual_seq_lengths": None, "pse_shift": 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, "kv_padding_size": None, "num_heads": 1, "input_layout": 'BSH', "scale_value": 1.0, "num_key_value_heads": 0, "block_size": 0, "inner_precise": 1},
     "IndexAddExt": {"alpha": 1},
     "InnerInplaceIndexPut": {"accumulate": False},
+    "InnerMoeTokenUnpermute": {"probs": None, "padded_mode": False, "restore_shape": None},
     "InplaceAddmm": {"beta": 1, "alpha": 1},
     "InplaceAddsExt": {"alpha": 1},
     "InplaceAddExt": {"alpha": 1},
@@ -237,15 +239,17 @@ op_args_default_value = {
     "Meshgrid": {"indexing": 'xy'},
     "MinimumGrad": {"grad_x": True, "grad_y": True},
     "MinDim": {"keepdim": False},
+    "MoeDistributeCombine": {"tp_send_counts": None, "x_active_mask": None, "activate_scale": None, "weight_scale": None, "group_list": None, "expand_scales": None, "group_ep": None, "group_tp": None, "tp_world_size": 0, "tp_rank_id": 0, "expert_shard_type": 0, "shared_expert_num": 0, "shared_export_rank_num": 0, "global_bs": 0, "out_dtype": 0, "common_quant_mode": 0, "group_list_type": 0},
+    "MoeDistributeDispatch": {"expert_scales": None, "scales": None, "x_active_mask": None, "group_ep": None, "group_tp": None, "tp_world_size": 0, "tp_rank_id": 0, "expert_shard_type": 0, "shared_expert_num": 0, "shared_expert_rank_num": 0, "quant_mode": 0, "global_bs": 0, "expert_token_nums_type": 0},
     "MoeTokenPermuteGrad": {"num_topk": 1, "padded_mode": False},
     "MoeTokenPermute": {"num_out_tokens": None, "padded_mode": False},
     "MoeTokenUnpermuteGrad": {"probs": None, "padded_mode": False, "restore_shape": None},
-    "MoeTokenUnpermute": {"probs": None, "padded_mode": False, "restore_shape": None},
     "MSELossExt": {"reduction": 'mean'},
     "MSELossGradExt": {"reduction": 'mean'},
     "Nansum": {"dim": None, "keepdim": False, "dtype": None},
     "NanToNum": {"nan": None, "posinf": None, "neginf": None},
     "NewEmpty": {"dtype": None, "device": None},
+    "NewFull": {"dtype": None},
     "NewOnes": {"dtype": None},
     "NewZeros": {"dtype": None},
     "NLLLoss2d": {"reduction": 'mean', "ignore_index": -100},
@@ -257,10 +261,9 @@ op_args_default_value = {
     "OneHotExt": {"axis": -1},
     "OneHot": {"axis": -1},
     "PagedAttentionMask": {"antiquant_scale": None, "antiquant_offset": None, "alibi_mask": None, "kv_cache_quant_mode": 'DEFAULT'},
-    "PagedAttention": {"antiquant_scale": None, "antiquant_offset": None, "attn_mask": None, "q_seq_lens": None, "alibi_mask": None, "kv_cache_quant_mode": 'DEFAULT', "mask_mode": 'MASK_DEFAULT', "mla_v_dim": 0},
+    "PagedAttention": {"value_cache": None, "block_tables": None, "context_lens": None, "antiquant_scale": None, "antiquant_offset": None, "attn_mask": None, "q_seq_lens": None, "alibi_mask": None, "kv_cache_quant_mode": 'DEFAULT', "mask_mode": 'MASK_DEFAULT', "mla_v_dim": 0},
     "ProdExt": {"dim": None, "keepdim": False, "dtype": None},
     "PromptFlashAttention": {"attn_mask": None, "actual_seq_lengths": None, "actual_seq_lengths_kv": None, "pse_shift": None, "deq_scale1": None, "quant_scale1": None, "deq_scale2": None, "quant_scale2": None, "quant_offset2": None, "num_heads": 1, "scale_value": 1.0, "pre_tokens": 2147483647, "next_tokens": 0, "input_layout": 'BSH', "num_key_value_heads": 0, "sparse_mode": 0, "inner_precise": 1},
-    "PromptKVCache": {"align_mode": 'LEFT'},
     "Qr": {"full_matrices": False},
     "RandIntLike": {"dtype": None},
     "RandInt": {"dtype": None},
@@ -326,7 +329,9 @@ op_args_default_value = {
     "SpeedFusionAttention": {"pse": None, "padding_mask": None, "atten_mask": None, "scale": 1.0, "keep_prob": 1.0, "pre_tokens": 2147483647, "next_tokens": 2147483647, "inner_precise": 0, "prefix": None, "actual_seq_qlen": None, "actual_seq_kvlen": None, "sparse_mode": 0, "gen_mask_parallel": True, "sync": False, "pse_type": 1, "q_start_idx": None, "kv_start_idx": None},
     "Split": {"axis": 0, "output_num": 1},
     "SplitTensor": {"dim": 0},
+    "SplitTensorView": {"dim": 0},
     "SplitWithSize": {"dim": 0},
+    "SplitWithSizeView": {"dim": 0},
     "Squeeze": {"axis": ()},
     "StackExt": {"dim": 0},
     "StdMean": {"dim": None, "correction": 1, "keepdim": False},
@@ -341,6 +346,7 @@ op_args_default_value = {
     "TensorScatterElements": {"axis": 0, "reduce": 'none'},
     "TopKRouter": {"drop_type": 0},
     "TopkExt": {"dim": -1, "largest": True, "sorted": True},
+    "TopPRouter": {"drop_type": 0, "threshold": 0.0, "router_prob": 0.0},
     "TraceV2Grad": {"offset": 0, "axis1": 1, "axis2": 0},
     "TraceV2": {"offset": 0, "axis1": 1, "axis2": 0, "dtype": None},
     "TriangularSolve": {"upper": True, "transpose": False, "unitriangular": False},
@@ -349,7 +355,7 @@ op_args_default_value = {
     "TupleToTensor": {"dtype": None},
     "Unique2": {"sorted": True, "return_inverse": False, "return_counts": False},
     "UniqueConsecutive": {"return_inverse": False, "return_counts": False, "dim": None},
-    "UnstackExt": {"dim": 0},
+    "UnstackExtView": {"dim": 0},
     "UpsampleBicubic2DGrad": {"output_size": None, "scales": None, "align_corners": False},
     "UpsampleBicubic2D": {"output_size": None, "scales": None, "align_corners": False},
     "UpsampleBilinear2DGrad": {"output_size": None, "scales": None, "align_corners": False},
@@ -370,6 +376,7 @@ op_args_default_value = {
     "Zeros": {"dtype": None},
     "AddRmsNormDynamicQuant": {"smooth_scale2": None, "epsilon": 1e-5},
     "AddRmsNormQuantV2": {"epsilon": 1e-5},
+    "DynamicNTK": {"dtype": mstype.float16},
     "DynamicQuantExt": {"smooth_scales": None},
     "FusedInferAttentionScore": {"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, "key_antiquant_scale": None, "key_antiquant_offset": None, "value_antiquant_scale": None, "value_antiquant_offset": None, "key_shared_prefix": None, "value_shared_prefix": None, "actual_shared_prefix_len": None, "num_heads": 1, "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, "key_antiquant_mode": 0, "value_antiquant_mode": 0},
     "GroupedMatmul": {"bias": None, "scale": None, "offset": None, "antiquant_scale": None, "antiquant_offset": None, "group_list": None, "split_item": 0, "group_type": -1, "transpose_a": False, "transpose_b": False},
@@ -379,18 +386,29 @@ op_args_default_value = {
     "MatmulAllReduceAddRmsNorm": {"reduce_op": 'sum', "comm_turn": 0, "stream_mode": 1},
     "MoeFinalizeRouting": {"x2": None, "bias": None, "scales": None, "expanded_row_idx": None, "expanded_expert_idx": None},
     "MoeGatingTopKSoftmax": {"finished": None, "k": 1},
+    "MoeInitRoutingQuantV2": {"scale": None, "offset": None},
     "QuantBatchMatmul": {"offset": None, "bias": None, "pertokenScaleOptional": None, "transpose_x1": False, "transpose_x2": False, "dtype": mstype.float16},
+    "QuantMatmul": {"offset": None, "pertoken_scale": None, "bias": None, "output_dtype": None, "x1_dtype": None, "x2_dtype": None, "pertoken_scale_dtype": None, "scale_dtype": None, "group_sizes": None},
     "QuantV2": {"sqrt_mode": False, "rounding_mode": 'ROUND', "dst_type": mstype.int8},
     "RmsNormQuant": {"beta": None, "epsilon": 1e-6},
+    "SwiGLUDynamicQuant": {"smooth_scale": None},
     "TransposeBatchMatmulTranspose": {"transpose_a": False, "transpose_b": False},
     "WeightQuantBatchMatmul": {"antiquant_offset": None, "quant_scale": None, "quant_offset": None, "bias": None, "transpose_x": False, "transpose_weight": False, "antiquant_group_size": 0},
+    "AnyExt": {"keepdim": False},
+    "FuncMaxPool2D": {"stride": None, "padding": 0, "dilation": (1, 1), "ceil_mode": False, "return_indices": False},
+    "GmmBackwardFusion": {"group_list": None, "group_list_type": 0},
+    "GmmBackward": {"group_list": None, "group_list_type": 0},
+    "Gmm": {"bias": None, "group_list": None, "group_type": 0, "group_list_type": 0},
+    "GmmV2BackwardFusion": {"group_list": None, "group_list_type": 0},
+    "GmmV2Backward": {"group_list": None, "group_list_type": 0},
+    "GmmV2": {"bias": None, "group_list": None, "group_type": 0, "group_list_type": 0},
+    "MoeTokenUnpermute": {"probs": None, "padded_mode": False, "restore_shape": None},
     "DeprecatedAddbmm": {"beta": 1, "alpha": 1},
     "DeprecatedAddmm": {"beta": 1, "alpha": 1},
     "DeprecatedAddmv": {"beta": 1, "alpha": 1},
     "DeprecatedReduceAll": {"dim": None, "keepdim": False},
     "DeprecatedAllclose": {"rtol": 1e-05, "atol": 1e-08, "equal_nan": False},
     "DeprecatedReduceAny": {"axis": None, "keep_dims": False},
-    "DeprecatedAny": {"dim": None, "keepdim": False},
     "DeprecatedArgmax": {"axis": -1, "keepdims": False},
     "DeprecatedArgmin": {"axis": None, "keepdims": False},
     "DeprecatedArgsort": {"axis": -1, "descending": False},
@@ -437,7 +455,9 @@ op_labels = {
     "AssignSub": {"side_effect_mem": True},
     "BatchNormElemt": {"side_effect_mem": True},
     "BatchNormGatherStatsWithCounts": {"side_effect_mem": True},
-    "DecoderKVCache": {"side_effect_mem": True},
+    "BroadcastToView": {"side_effect_mem": True},
+    "ChunkView": {"side_effect_mem": True},
+    "DiagonalView": {"side_effect_mem": True},
     "DistCommAllReduce": {"side_effect_mem": True},
     "DistCommReduce": {"side_effect_mem": True},
     "DropoutExt": {"side_effect_hidden": True},
@@ -451,6 +471,7 @@ op_labels = {
     "EmbeddingApplySgd": {"_process_node_engine_id": 'PS'},
     "Embedding": {"side_effect_mem": True},
     "EmbeddingTableEvict": {"_process_node_engine_id": 'PS'},
+    "ExpandDimsView": {"side_effect_mem": True},
     "Generator": {"side_effect_mem": True},
     "GroupTopk": {"side_effect_mem": True},
     "InnerInplaceIndexPut": {"side_effect_mem": True},
@@ -478,6 +499,7 @@ op_labels = {
     "InplaceLog": {"side_effect_mem": True},
     "InplaceMaskedFillScalar": {"side_effect_mem": True},
     "InplaceMaskedFillTensor": {"side_effect_mem": True},
+    "InplaceMatmulAdd": {"side_effect_mem": True},
     "InplaceMuls": {"side_effect_mem": True},
     "InplaceMul": {"side_effect_mem": True},
     "InplaceNormal": {"side_effect_mem": True},
@@ -489,17 +511,26 @@ op_labels = {
     "InplaceScatterSrcReduce": {"side_effect_mem": True},
     "InplaceScatterValue": {"side_effect_mem": True},
     "InplaceScatterValueReduce": {"side_effect_mem": True},
+    "InplaceSiLU": {"side_effect_mem": True},
     "InplaceSubExt": {"side_effect_mem": True},
     "InplaceSubScalar": {"side_effect_mem": True},
     "InplaceTanh": {"side_effect_mem": True},
     "InplaceThreshold": {"side_effect_mem": True},
     "InplaceUniform": {"side_effect_mem": True},
     "Log": {"cust_aicpu": 'Log', "base": -1.0, "scale": 1.0, "shift": 0.0},
-    "PromptKVCache": {"side_effect_mem": True},
+    "NarrowView": {"side_effect_mem": True},
     "ReshapeAndCache": {"side_effect_mem": True},
     "ResizeD": {"mode": 'linear'},
+    "SelectExtView": {"side_effect_mem": True},
     "SilentCheckV2": {"side_effect_mem": True},
     "SilentCheckV3": {"side_effect_mem": True},
+    "SliceExtView": {"side_effect_mem": True},
+    "SplitTensorView": {"side_effect_mem": True},
+    "SplitWithSizeView": {"side_effect_mem": True},
+    "TransposeExtView": {"side_effect_mem": True},
+    "TransposeView": {"side_effect_mem": True},
+    "UnstackExtView": {"side_effect_mem": True},
     "KVCacheScatterUpdate": {"side_effect_mem": True},
+    "InplaceExponential": {"side_effect_mem": True},
     "DeprecatedInplaceCopy": {"side_effect_mem": True},
 }

mindspore/ops/auto_generate/gen_extend_func.py

@@ -237,9 +237,9 @@ def argmin(input, dim=None, keepdim=False):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import mint
+        >>> from mindspore import ops
         >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
-        >>> output = mint.argmin(x, dim=-1)
+        >>> output = ops.auto_generate.argmin_ext(x, dim=-1)
         >>> print(output)
         [0 1 2]
     """
@@ -276,14 +276,13 @@ def argsort(input, dim=-1, descending=False, stable=False):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> import mindspore.mint as mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-        >>> sort = mint.argsort(x)
+        >>> sort = ops.auto_generate.argsort_ext(x)
         >>> print(sort)
         [[2 1 0]
-        [2 0 1]
-        [0 1 2]]
+         [2 0 1]
+         [0 1 2]]
     """
     return argsort_impl(input, dim, descending, stable)
 
@@ -389,7 +388,7 @@ def atan2(input, other):
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([0, 1]), mindspore.float32)
         >>> other = Tensor(np.array([1, 1]), mindspore.float32)
-        >>> output = mint.atan2(input, other)
+        >>> output = ops.auto_generate.atan2_ext(input, other)
         >>> print(output)
         [0.        0.7853982]
     """
@@ -470,9 +469,9 @@ def avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, coun
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
-        >>> output = mint.nn.functional.avg_pool1d(input_x, kernel_size=6, stride=1)
+        >>> output = ops.auto_generate.avg_pool1d_ext(input_x, kernel_size=6, stride=1)
         >>> print(output.shape)
         (1, 3, 1)
     """
@@ -512,14 +511,14 @@ def bincount(input, weights=None, minlength=0):
         ``Ascend``
     
     Examples:
-        >>> from mindspore import mint, Tensor
-        >>> print(mint.bincount(Tensor(np.arange(5))))
+        >>> from mindspore import ops, Tensor
+        >>> print(ops.auto_generate.bincount_ext(Tensor(np.arange(5))))
         [1 1 1 1 1]
-        >>> print(mint.bincount(Tensor(np.array([0, 1, 1, 3, 2, 1, 7]))))
+        >>> print(ops.auto_generate.bincount_ext(Tensor(np.array([0, 1, 1, 3, 2, 1, 7]))))
         [1 3 1 1 0 0 0 1]
         >>> w = Tensor(np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6])) # weights
         >>> x = Tensor(np.array([0, 1, 1, 2, 2, 2]))
-        >>> print(mint.bincount(x,  weights=w, minlength=5))
+        >>> print(ops.auto_generate.bincount_ext(x,  weights=w, minlength=5))
         [0.3 0.7 1.1 0.  0. ]
     """
     return bincount_impl(input, weights, minlength)
@@ -643,7 +642,7 @@ def cummin(input, dim):
         \end{array}
     
     .. note::
-        O2 mode is not supported in Ascend.
+        GE backend is not supported in Ascend.
     
     Args:
         input (Tensor): The input Tensor, The dimension must be greater than 0.
@@ -759,9 +758,9 @@ def diag(input, diagonal=0):
         ``Ascend``
     
     Examples:
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor([1, 2, 3, 4]).astype('int32')
-        >>> output = mint.diag(input)
+        >>> output = ops.auto_generate.diag_ext(input)
         >>> print(output)
         [[1 0 0 0]
          [0 2 0 0]
@@ -1011,56 +1010,6 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     return unfold_impl(input, converted_kernel_size, converted_dilation, converted_padding, converted_stride)
 
 
-def index_add(input, dim, index, source, alpha=1):
-    r"""
-    Accumulate the elements of `alpha` times `source` into the `input` by adding to the index in the order given in `index`. For example, if ``dim == 0`` , ``index[i] == j`` , and ``alpha = -1`` , then the `i` th row of `source` is subtracted from the `j` th row of `input` . The `dim` th dimension of `source` must have the same size as the length of `index` , and all other dimensions must match `input`, or an error will be raised. For a 3-D tensor, the output is defined as follows:
-    
-    .. math::
-        \begin{array}{ll}
-        input[index[i],\ :,\ :]\ +=\ alpha * source[i,\ :,\ :]  \qquad \#if\ dim == 0 \\
-        input[:,\ \ index[i],\ :]\ +=\ alpha * source[:,\ \ i,\ :]  \qquad \#if\ dim == 1 \\
-        input[:,\ :,\ \ index[i]]\ +=\ alpha * source[:,\ :,\ \ i]  \qquad\#if\ dim == 2 \\
-        \end{array}
-        
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-        
-    Args:
-        input (Tensor): The input Tensor.
-        dim (int): The dimension along which to index.
-        index (Tensor): Add the value of "input Tensor" and `source` along the dimension of the `dim` according to the specified index value, with data type int32. The `index` must be 1D with the same size as the size of `source` in the `dim` dimension. The values of `index` should be in [0, b), where the b is the size of "input Tensor" in the `dim` dimension.
-        source (Tensor): The input tensor with the value to add. Must have same data type as "input Tensor". The shape must be the same as "input Tensor" except the `dim` th dimension.
-        alpha (number, optional): The scalar multiplier for source. Default: ``1``.
-        
-    Returns:
-        Tensor, has the same shape and dtype as `input`.
-    
-    Raises:
-        TypeError: If neither `index` nor `source` is a Tensor.
-        ValueError: If the value of `dim` is out of the dimension range of `source` shape.
-        ValueError: If `index` rank is not the same as `source` rank.
-        ValueError: If shape of `index` is not 1D or size of `index` is not equal to dimension of source[dim].
-        ValueError: If the shape of `source` is not the same as that of `input` except the `dim` axis.
-    
-    Supported Platforms:
-        ``Ascend``
-    
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
-        >>> index = Tensor(np.array([0, 2]), mindspore.int32)
-        >>> y = Tensor(np.array([[0.5, 1.0], [1.0, 1.5], [2.0, 2.5]]), mindspore.float32)
-        >>> output = ops.auto_generate.index_add_ext(x, 1, index, y, alpha=1)
-        >>> print(output)
-        [[ 1.5  2.   4. ]
-         [ 5.   5.   7.5]
-         [ 9.   8.  11.5]]
-    """
-    return index_add_impl(input, dim, index, source, alpha)
-
-
 def index_select(input, dim, index):
     r"""
     Generates a new Tensor that accesses the values of `input` along the specified `dim` dimension
@@ -1294,9 +1243,9 @@ def log10(input):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
-        >>> output = mint.log10(x)
+        >>> output = ops.auto_generate.log10_ext(x)
         >>> print(output)
         [0.47712136 0.69897    0.845098  ]
     """
@@ -1330,9 +1279,9 @@ def log2(input):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
-        >>> output = mint.log2(x)
+        >>> output = ops.auto_generate.log2_ext(x)
         >>> print(output)
         [1.5849625 2.321928  2.807355 ]
     """
@@ -1898,38 +1847,6 @@ def prod(input, dim=None, keepdim=False, dtype=None):
     return prod_impl(input, dim, keepdim, dtype)
 
 
-def select(input, dim, index):
-    r"""
-    Slices the input tensor along the selected dimension at the given index.
-    
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-    
-    Args:
-        input (Tensor): the input tensor.
-        dim (int): the dimension to slice.
-        index (int): the index to select with.
-    
-    Returns:
-        Tensor.
-    
-    Raises:
-        TypeError: If input is not a Tensor.
-    
-    Supported Platforms:
-        ``Ascend``
-    
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, mint
-        >>> input = Tensor([[2, 3, 4, 5],[3, 2, 4, 5]])
-        >>> y = mint.select(input, 0, 0)
-        >>> print(y)
-        [2 3 4 5]
-    """
-    return select_impl(input, dim, index)
-
-
 def selu(input):
     r"""
     Activation function SELU (Scaled exponential Linear Unit).
@@ -1969,13 +1886,13 @@ def selu(input):
     
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> input = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> output = mint.nn.functional.selu(input)
+        >>> output = ops.auto_generate.selu_ext(input)
         >>> print(output)
         [[-1.1113307 4.202804 -1.7575096]
-        [ 2.101402 -1.7462534 9.456309 ]]
+         [ 2.101402 -1.7462534 9.456309 ]]
     """
     return selu_impl(input)
 
@@ -2296,41 +2213,6 @@ def trace(input):
     return trace_impl(input)
 
 
-def transpose(input, dim0, dim1):
-    r"""
-    Interchange two axes of a tensor.
-    
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-    
-    Args:
-        input(Tensor): Input tensor.
-        dim0 (int): First axis.
-        dim1 (int): Second axis.
-    
-    Returns:
-        Transposed tensor, has the same data type as `input`.
-    
-    Raises:
-        TypeError: If argument `input` is not Tensor.
-        TypeError: If `dim0` or `dim1` is not integer.
-        ValueError: If `dim0` or `dim1` is not in the range of :math:`[-ndim, ndim-1]`.
-    
-    Supported Platforms:
-        ``Ascend``
-    
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import mint
-        >>> from mindspore import Tensor
-        >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
-        >>> output = mint.transpose(input, 0, 2)
-        >>> print(output.shape)
-        (4, 3, 2)
-    """
-    return transpose_impl(input, dim0, dim1)
-
-
 def tril(input, diagonal=0):
     r"""
     None