mindspore 2.3.0rc1__cp39-cp39-manylinux1_x86_64.whl → 2.3.0rc2__cp39-cp39-manylinux1_x86_64.whl

mindspore/nn/wrap/cell_wrapper.py

@@ -99,7 +99,7 @@ class WithLossCell(Cell):
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
         >>> net_with_criterion = nn.WithLossCell(net, loss_fn)
@@ -132,7 +132,7 @@ class WithLossCell(Cell):
         Examples:
             >>> from mindspore import nn
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
             >>> net_with_criterion = nn.WithLossCell(net, loss_fn)
@@ -175,7 +175,7 @@ class WithGradCell(Cell):
         >>> import mindspore as ms
         >>> from mindspore import nn
         >>> # Defined a network without loss function, taking LeNet5 as an example.
-        >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # Refer to https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> grad_net = nn.WithGradCell(net, loss_fn)
@@ -346,7 +346,7 @@ class TrainOneStepCell(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
@@ -586,7 +586,7 @@ class MicroBatchInterleaved(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> net = nn.MicroBatchInterleaved(net, 2)
     """
@@ -634,7 +634,7 @@ class PipelineCell(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> net = nn.PipelineCell(net, 4)
     """
@@ -685,7 +685,7 @@ class GradAccumulationCell(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> net = nn.GradAccumulationCell(net, 4)
     """
@@ -811,7 +811,7 @@ class VirtualDatasetCellTriple(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> net = nn.VirtualDatasetCellTriple(net)
     """
@@ -854,7 +854,7 @@ class WithEvalCell(Cell):
     Examples:
         >>> import mindspore.nn as nn
         >>> # Define a forward network without loss function, taking LeNet5 as an example.
-        >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # Refer to https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> eval_net = nn.WithEvalCell(net, loss_fn)

mindspore/nn/wrap/grad_reducer.py

@@ -335,14 +335,14 @@ class DistributedGradReducer(Cell):
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
             Please see the `rank table Startup
-            <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/rank_table.html>`_
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/rank_table.html>`_
             for more details.
 
             For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
-            <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/mpirun.html>`_ .
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/mpirun.html>`_ .
 
             For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
-            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/dynamic_cluster.html>`_ .
+            Startup <https://www.mindspore.cn/tutorials/experts/en/master/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with multiple devices.
 
@@ -509,11 +509,11 @@ class PipelineGradReducer(Cell):
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
             Please see the `rank table Startup
-            <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/rank_table.html>`_
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/rank_table.html>`_
             for more details.
 
             For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
-            <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/mpirun.html>`_ .
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/mpirun.html>`_ .
 
             This example should be run with multiple devices.
 

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -92,7 +92,8 @@ def get_bprop_send(self):
     """Generate bprop for Send."""
     shape = self.get_attr_dict()["shape"]
     dtype = self.get_attr_dict()["dtype"]
-    send_grad = Receive(self.sr_tag, self.rank, shape, dtype, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    send_grad = Receive(tag, self.rank, shape, dtype, self.group_back)
     virtual_input = Tensor(0.0, dtype)
 
     def bprop(x, out, dout):
@@ -105,7 +106,8 @@ def get_bprop_send(self):
 @bprop_getters.register(Receive)
 def get_bprop_receive(self):
     """Generate bprop for Receive."""
-    receive_grad = Send(self.tag, self.rank, self.group_back)
+    tag = self.get_attr_dict()["sr_tag"]
+    receive_grad = Send(tag, self.rank, self.group_back)
     receive_grad.add_prim_attr("shape", self.shape)
     depend = P.Depend()
     cast = P.Cast()

mindspore/ops/_vmap/vmap_grad_nn_ops.py

@@ -711,8 +711,7 @@ def get_grid_sampler_grad_vmap_rule(prim, axis_size):
 
 
 @vmap_rules_getters.register(G.UpsampleNearest3DGrad)
-@vmap_rules_getters.register(G.UpsampleTrilinear3DGrad)
-def get_upsample_grad_vmap_rule(prim, axis_size):
+def get_upsample_nearesst3d_grad_vmap_rule(prim, axis_size):
     """VmapRule for `UpsampleNearest3DGrad` and `UpsampleTrilinear3DGrad`."""
     cdhw_reverse_index = -4
 
@@ -746,6 +745,46 @@ def get_upsample_grad_vmap_rule(prim, axis_size):
     return vmap_rule
 
 
+@vmap_rules_getters.register(G.UpsampleTrilinear3DGrad)
+def get_upsample_trilinear3d_grad_vmap_rule(prim, axis_size):
+    """VmapRule for `UpsampleNearest3DGrad` and `UpsampleTrilinear3DGrad`."""
+    cdhw_reverse_index = -4
+
+    def vmap_rule(grad_bdim, isize_bdim, osize_bdim, scales_bdim, align_corners_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, grad_bdim)
+        if is_all_none:
+            return result
+
+        grad, grad_dim = grad_bdim
+        grad = _bdim_at_front(grad, grad_dim, axis_size)
+        grad_shape = F.shape(grad)
+        input_shape = (-1,) + grad_shape[cdhw_reverse_index:]
+        grad = F.reshape(grad, input_shape)
+        real_in_shape = F.shape(grad)
+
+        isize, isize_dim = isize_bdim
+        osize, osize_dim = osize_bdim
+        scales, scales_dim = scales_bdim
+        align_corners, align_corners_dim = align_corners_bdim
+        check_args = [isize_dim, osize_dim, scales_dim, align_corners_dim]
+        is_all_none = True
+        for arg in check_args:
+            is_all_none = is_all_none and arg is None
+        if not is_all_none:
+            _raise_value_error(
+                "The source axis of `input_size`, `output_size` and `scales` must be None, but got {0}, {1} and {2}."
+                .format(isize_dim, osize_dim, scales_dim))
+        # update batch dimension of input_size
+        new_isize = (real_in_shape[0],) + isize[1:]
+
+        out = prim(grad, new_isize, osize, scales, align_corners)
+        out_shape = F.shape(out)
+        real_out_shape = grad_shape[:cdhw_reverse_index] + out_shape[cdhw_reverse_index:]
+        out = F.reshape(out, real_out_shape)
+        return out, 0
+    return vmap_rule
+
+
 @vmap_rules_getters.register(G.LogSoftmaxGrad)
 def get_log_softmax_grad_vmap_rule(prim_func, axis_size):
     """VmapRule for 'LogSoftmaxGrad' operation."""

mindspore/ops/_vmap/vmap_math_ops.py

@@ -19,6 +19,7 @@ from __future__ import absolute_import
 import mindspore.numpy as mnp
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
+from mindspore.ops.auto_generate import MatMulExt
 from mindspore.ops.primitive import _primexpr
 from mindspore.common import Tensor
 from mindspore.ops.operations import math_ops
@@ -290,29 +291,47 @@ def get_matmul_vmap_rule(prim, axis_size):
     """VmapRule for `*MatMul` operation."""
     if isinstance(prim, str):
         prim = Primitive(prim)
-        transpose_a = False
-        transpose_b = False
-    else:
-        transpose_a = prim.transpose_a
-        transpose_b = prim.transpose_b
-    batch_matmul = P.BatchMatMul(transpose_a, transpose_b)
 
-    def vmap_rule(a_bdim, b_bdim):
-        is_all_none, result = vmap_general_preprocess(prim, a_bdim, b_bdim)
+    def vmap_rule(a_bdim, b_bdim, trans_a_bdim, trans_b_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, a_bdim, b_bdim, trans_a_bdim, trans_b_bdim)
         if is_all_none:
             return result
 
         a, a_dim = a_bdim
         b, b_dim = b_bdim
+        trans_a, _ = trans_a_bdim
+        trans_b, _ = trans_b_bdim
         a = _bdim_at_front(a, a_dim, axis_size)
         b = _bdim_at_front(b, b_dim, axis_size)
 
+        batch_matmul = P.BatchMatMul(trans_a, trans_b)
         out = batch_matmul(a, b)
         return out, 0
 
     return vmap_rule
 
 
+@vmap_rules_getters.register(MatMulExt)
+def get_matmul_ext_vmap_rule(prim, axis_size):
+    """VmapRule for `*MatMulExt` operation."""
+    if isinstance(prim, str):
+        prim = Primitive(prim)
+
+    def vmap_rule(a_bdim, b_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, a_bdim, b_bdim)
+        if is_all_none:
+            return result
+
+        a, _ = a_bdim
+        b, _ = b_bdim
+
+        matmul_ext = MatMulExt()
+        out = matmul_ext(a, b)
+        return out, 0
+
+    return vmap_rule
+
+
 @vmap_rules_getters.register(P.math_ops.MatrixSolve)
 def get_matrix_solve_vmap_rule(prim, axis_size):
     """VmapRule for `*MatMul` operation."""

mindspore/ops/_vmap/vmap_nn_ops.py

@@ -30,6 +30,7 @@ from mindspore.ops._vmap.vmap_base import vmap_rules_getters, vmap_general_prepr
     _vmap_clone_prim, _get_reduce_batch_axis
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.auto_generate.gen_arg_handler import Format
+from mindspore.ops.auto_generate import Embedding
 
 
 @vmap_rules_getters.register(P.ApplyAdaMax)
@@ -1936,11 +1937,18 @@ def get_grid_sampler_vmap_rule(prim, axis_size):
     return vmap_rule
 
 
+@vmap_rules_getters.register(NN.UpsampleNearest1D)
+@vmap_rules_getters.register(NN.UpsampleNearest2D)
 @vmap_rules_getters.register(NN.UpsampleNearest3D)
-@vmap_rules_getters.register(NN.UpsampleTrilinear3D)
 def get_upsample_nearest_3d_vmap_rule(prim, axis_size):
-    """VmapRule for `UpsampleNearest3D` and `UpsampleTrilinear3D`."""
-    cdhw_reverse_index = -4
+    """VmapRule for `UpsampleNearest1D`, `UpsampleNearest2D` and `UpsampleNearest3D`."""
+    prim_name = prim.name
+    if prim_name == "UpsampleNearest1D":
+        reverse_index = -2
+    elif prim_name == "UpsampleNearest2D":
+        reverse_index = -3
+    else:
+        reverse_index = -4
 
     def vmap_rule(x_bdim, size_bdim, scales_bdim):
         is_all_none, result = vmap_general_preprocess(prim, x_bdim, size_bdim,
@@ -1954,16 +1962,56 @@ def get_upsample_nearest_3d_vmap_rule(prim, axis_size):
         scales, scales_dim = scales_bdim
         if size_dim is not None or scales_dim is not None:
             _raise_value_error(
-                "The source axis of `output_size` and `scales` must be None, but got {0} and {1}."
-                .format(size_dim, scales_dim))
+                "For {0}, the source axis of `output_size` and `scales` must be None,"
+                " but got {1} and {2}.".format(prim_name, size_dim, scales_dim))
 
         x_shape = F.shape(x)
-        input_shape = (-1,) + x_shape[cdhw_reverse_index:]
+        input_shape = (-1,) + x_shape[reverse_index:]
         x = F.reshape(x, input_shape)
         out = prim(x, size, scales)
         out_shape = F.shape(out)
-        return_shape = x_shape[:cdhw_reverse_index] + out_shape[
-            cdhw_reverse_index:]
+        return_shape = x_shape[:reverse_index] + out_shape[reverse_index:]
+        out = F.reshape(out, return_shape)
+        return out, 0
+
+    return vmap_rule
+
+
+@vmap_rules_getters.register(NN.UpsampleLinear1D)
+@vmap_rules_getters.register(NN.UpsampleBilinear2D)
+@vmap_rules_getters.register(NN.UpsampleTrilinear3D)
+def get_upsample_linear_vmap_rule(prim, axis_size):
+    """VmapRule for `UpsampleLinear1D`, `UpsampleBilinear2D` and `UpsampleTrilinear3D`."""
+    prim_name = prim.name
+    if prim_name == "UpsampleLinear1D":
+        reverse_index = -2
+    elif prim_name == "UpsampleBilinear2D":
+        reverse_index = -3
+    else:
+        reverse_index = -4
+
+    def vmap_rule(x_bdim, size_bdim, scales_bdim, align_corners_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, x_bdim, size_bdim,
+                                                      scales_bdim, align_corners_bdim)
+        if is_all_none:
+            return result
+
+        x, x_dim = x_bdim
+        x = _bdim_at_front(x, x_dim, axis_size)
+        size, size_dim = size_bdim
+        scales, scales_dim = scales_bdim
+        align_corners, align_corners_dim = align_corners_bdim
+        if size_dim is not None or scales_dim is not None or align_corners_dim is not None:
+            _raise_value_error(
+                "For {0}, the source axis of `output_size`, `scales` and `align_corners`must"
+                "be None, but got {1} and {2}.".format(prim_name, size_dim, scales_dim))
+
+        x_shape = F.shape(x)
+        input_shape = (-1,) + x_shape[reverse_index:]
+        x = F.reshape(x, input_shape)
+        out = prim(x, size, scales, align_corners)
+        out_shape = F.shape(out)
+        return_shape = x_shape[:reverse_index] + out_shape[reverse_index:]
         out = F.reshape(out, return_shape)
         return out, 0
 
@@ -2130,6 +2178,16 @@ def get_elu_vmap_rule(prim, axis_size):
     return vmap_rule
 
 
+@vmap_rules_getters.register(Embedding)
+def get_embedding_vmap_rule(prim, axis_size):
+    """VmapRule for Embedding operations."""
+    if isinstance(prim, str):
+        prim_name = prim
+    else:
+        prim_name = prim.name
+    raise RuntimeError(f"THe {prim_name} does not support vmap.")
+
+
 # Unary vmap
 get_unop_vmap_rule = vmap_rules_getters.register(P.ReLU)(get_unop_vmap_rule)
 get_unop_vmap_rule = vmap_rules_getters.register(P.ReLU6)(get_unop_vmap_rule)

mindspore/ops/auto_generate/cpp_create_prim_instance_helper.py

@@ -17,18 +17,25 @@
 from mindspore.common import dtype as mstype
 
 op_args_default_value = {
+    "AdamWeightDecayExt": {"amsgrad": False, "maximize": False},
     "AdamWeightDecay": {"use_locking": False},
     "AddExt": {"alpha": 1},
     "ApplyCamePart2": {"sum_r": None, "global_shape": None},
     "ApplyCamePart3": {"global_shape": None, "use_first_moment": False},
     "ApplyCamePart4": {"global_shape": None},
     "ApplyRotaryPosEmb": {"cos_format": 0},
+    "ArgMaxExt": {"dim": None, "keepdim": False},
     "Argmax": {"axis": -1, "output_type": mstype.int32},
     "ArgMaxWithValue": {"axis": 0, "keep_dims": False},
     "Argmin": {"axis": -1, "output_type": mstype.int32},
     "ArgMinWithValue": {"axis": 0, "keep_dims": False},
+    "AvgPool2DGrad": {"padding": 0, "ceil_mode": False, "count_include_pad": True, "divisor_override": None},
+    "AvgPool2D": {"padding": 0, "ceil_mode": False, "count_include_pad": True, "divisor_override": None},
     "AvgPoolGrad": {"kernel_size": 1, "strides": 1, "pad_mode": 'VALID', "data_format": 'NCHW'},
     "AvgPool": {"kernel_size": 1, "strides": 1, "pad_mode": 'VALID', "data_format": 'NCHW'},
+    "BatchMatMul": {"transpose_a": False, "transpose_b": False},
+    "BatchNormExt": {"training": False, "momentum": 0.1, "epsilon": 1e-5},
+    "BatchNormGradExt": {"training": False, "eps": 1e-5},
     "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'},
@@ -40,26 +47,45 @@ op_args_default_value = {
     "CeLU": {"alpha": 1.0},
     "CholeskyInverse": {"upper": False},
     "Cholesky": {"upper": False},
+    "Chunk": {"dim": 0},
+    "ClampScalar": {"min": None, "max": None},
+    "ClampTensor": {"min": None, "max": None},
     "Concat": {"axis": 0},
+    "ConstantPadND": {"value": 0.0},
+    "ConvolutionGrad": {"bias": None, "stride": 1, "padding": 0, "dilation": 1, "transposed": False, "output_padding": 0, "groups": 1, "output_mask": ()},
+    "Convolution": {"bias": None, "stride": 1, "padding": 0, "dilation": 1, "transposed": False, "output_padding": 0, "groups": 1},
     "Correlate": {"mode": 'valid'},
     "CumProd": {"exclusive": False, "reverse": False},
     "CumSum": {"exclusive": False, "reverse": False},
     "DCT": {"axis": -1, "norm": 'BACKWARD', "forward": True, "grad": False},
+    "Dense": {"bias": None},
     "Diagonal": {"offset": 0, "dim1": 0, "dim2": 1},
+    "DivMod": {"rounding_mode": None},
+    "DropoutExt": {"p": 0.5, "seed": 0, "offset": 0},
     "Dropout": {"keep_prob": 0.5, "Seed0": 0, "Seed1": 0},
     "Eig": {"compute_v": False},
     "Elu": {"alpha": 1.0},
+    "EmbeddingDenseBackward": {"padding_idx": None, "scale_grad_by_freq": False},
+    "Embedding": {"padding_idx": None, "max_norm": None, "norm_type": 2.0, "scale_grad_by_freq": False},
     "ExtractImagePatches": {"padding": 'VALID'},
+    "FFNExt": {"expertTokens": None, "bias1": None, "bias2": None, "scale": None, "offset": None, "deqScale1": None, "deqScale2": None, "antiquant_scale1": None, "antiquant_scale2": None, "antiquant_offset1": None, "antiquant_offset2": None, "activation": 'fastgelu', "inner_precise": 0},
     "FFT2": {"s": None, "dim": (-2, -1), "norm": None},
     "FFT": {"n": None, "dim": -1, "norm": None},
     "FFTWithSize": {"norm": 'backward', "onesided": True, "signal_sizes": ()},
     "FFTN": {"s": None, "dim": None, "norm": None},
     "FFTShift": {"dim": None},
+    "FillScalar": {"dtype": None},
+    "FillTensor": {"dtype": None},
+    "FlashAttentionScoreGrad": {"pse_shift": None, "drop_mask": None, "padding_mask": None, "atten_mask": None, "softmax_max": None, "softmax_sum": None, "softmax_in": None, "attention_in": None, "prefix": None, "actual_seq_qlen": None, "actual_seq_kvlen": None, "keep_prob": 1.0, "scale_value": 1.0, "pre_tokens": 65536, "next_tokens": 65536, "inner_precise": 1, "input_layout": 'BSH', "sparse_mode": 0},
+    "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},
     "Gather": {"batch_dims": 0},
     "GridSampler2DGrad": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False},
     "GridSampler2D": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False},
     "GridSampler3DGrad": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False},
     "GridSampler3D": {"interpolation_mode": 'bilinear', "padding_mode": 'zeros', "align_corners": False},
+    "GroupNormGrad": {"dx_is_require": True, "dgamma_is_require": True, "dbeta_is_require": True},
+    "GroupNorm": {"weight": None, "bias": None, "eps": 1e-5},
     "HShrinkGrad": {"lambd": 0.5},
     "HShrink": {"lambd": 0.5},
     "IFFT2": {"s": None, "dim": (-2, -1), "norm": None},
@@ -68,28 +94,44 @@ op_args_default_value = {
     "IFFTShift": {"dim": None},
     "IRFFTGrad": {"n": None, "dim": -1, "norm": None},
     "IRFFT": {"n": None, "dim": -1, "norm": None},
+    "LayerNormExt": {"weight": None, "bias": None, "eps": 1e-5},
     "LayerNormGradGrad": {"begin_norm_axis": 1, "begin_params_axis": 1},
     "LayerNormGrad": {"begin_norm_axis": 1, "begin_params_axis": 1},
     "LayerNormGradV3": {"begin_norm_axis": 1, "begin_params_axis": 1},
     "LayerNorm": {"begin_norm_axis": 1, "begin_params_axis": 1, "epsilon": 1e-7},
     "LayerNormV3": {"begin_norm_axis": 1, "begin_params_axis": 1, "epsilon": 1e-7},
+    "LeakyReLUExt": {"negative_slope": 0.01},
+    "LeakyReLUGradExt": {"negative_slope": 0.01, "is_result": False},
+    "LinSpaceExt": {"dtype": None},
     "LogSoftmaxGrad": {"axis": -1},
     "LogSoftmax": {"axis": -1},
     "LogitGrad": {"eps": -1.0},
     "Logit": {"eps": -1.0},
+    "MatMul": {"transpose_a": False, "transpose_b": False},
+    "MaxPoolGradWithIndices": {"strides": None, "pads": 0, "dilation": (1, 1), "ceil_mode": False, "argmax_type": mstype.int64},
+    "MaxPoolGradWithMask": {"strides": None, "pads": 0, "dilation": (1, 1), "ceil_mode": False, "argmax_type": mstype.int64},
+    "MaxPoolWithIndices": {"strides": None, "pads": 0, "dilation": (1, 1), "ceil_mode": False, "argmax_type": mstype.int64},
+    "MaxPoolWithMask": {"strides": None, "pads": 0, "dilation": (1, 1), "ceil_mode": False, "argmax_type": mstype.int64},
     "MaximumGradGrad": {"grad_x": True, "grad_y": True},
     "MaximumGrad": {"grad_x": True, "grad_y": True},
+    "MeanExt": {"axis": None, "keep_dims": False, "dtype": None},
     "MinimumGrad": {"grad_x": True, "grad_y": True},
+    "MoeFinalizeRouting": {"x2": None, "bias": None, "scales": None, "expanded_row_idx": None, "expanded_expert_idx": None},
     "NanToNum": {"nan": None, "posinf": None, "neginf": None},
     "NLLLossGrad": {"reduction": 'mean', "ignore_index": -100},
     "NLLLoss": {"reduction": 'mean', "ignore_index": -100},
+    "Norm": {"ord": None, "dim": None, "keepdim": False, "dtype": None},
+    "OneHotExt": {"axis": -1},
     "OneHot": {"axis": -1},
+    "OnesLikeExt": {"dtype": None},
+    "Ones": {"dtype": None},
+    "ProdExt": {"axis": None, "keep_dims": False, "dtype": None},
     "PromptKVCache": {"align_mode": 'LEFT'},
     "Qr": {"full_matrices": False},
     "QuantBatchMatmul": {"offset": None, "bias": None, "transpose_x1": False, "transpose_x2": False, "dtype": mstype.float16},
     "RandpermV2": {"seed": 0, "offset": 0, "dtype": mstype.int64},
     "Range": {"maxlen": 1000000},
-    "ReduceAll": {"axis": (), "keep_dims": False},
+    "ReduceAll": {"axis": None, "keep_dims": False},
     "ReduceAny": {"axis": (), "keep_dims": False},
     "ReduceMax": {"axis": (), "keep_dims": False},
     "ReduceMean": {"axis": (), "keep_dims": False},
@@ -97,10 +139,12 @@ op_args_default_value = {
     "ReduceProd": {"axis": (), "keep_dims": False},
     "ReduceStd": {"axis": [], "unbiased": True, "keep_dims": False},
     "ReduceSum": {"axis": (), "keep_dims": False, "skip_mode": False},
+    "RepeatInterleave": {"axis": None, "output_size": None},
     "ResizeBicubicGrad": {"align_corners": False, "half_pixel_centers": False},
     "ResizeBicubic": {"align_corners": False, "half_pixel_centers": False},
     "ResizeBilinearGrad": {"align_corners": False, "half_pixel_centers": False},
     "ResizeBilinearV2": {"align_corners": False, "half_pixel_centers": False},
+    "ResizeD": {"coordinate_transformation_mode": 'align_corners'},
     "ResizeLinear1DGrad": {"coordinate_transformation_mode": 'align_corners'},
     "ResizeLinear1D": {"coordinate_transformation_mode": 'align_corners'},
     "ResizeNearestNeighborGrad": {"align_corners": False, "half_pixel_centers": False},
@@ -113,21 +157,49 @@ op_args_default_value = {
     "SequenceConcat": {"axis": 0},
     "SoftmaxBackward": {"dim": -1},
     "Softmax": {"axis": -1},
+    "SoftplusExt": {"beta": 1, "threshold": 20},
+    "SoftplusGradExt": {"beta": 1, "threshold": 20},
     "SolveTriangular": {"trans": 0, "lower": False, "unit_diagonal": False},
     "Split": {"axis": 0, "output_num": 1},
+    "SplitTensor": {"axis": 0},
+    "SplitWithSize": {"axis": 0},
+    "StackExt": {"dim": 0},
     "StridedSlice": {"begin_mask": 0, "end_mask": 0, "ellipsis_mask": 0, "new_axis_mask": 0, "shrink_axis_mask": 0},
     "SubExt": {"alpha": 1},
+    "SumExt": {"dim": None, "keepdim": False, "dtype": None},
+    "TopkExt": {"dim": -1, "largest": True, "sorted": True},
+    "Tril": {"diagonal": 0},
+    "Triu": {"diagonal": 0},
     "TupleToTensor": {"dtype": None},
+    "UpsampleBilinear2DGrad": {"output_size": None, "scales": None, "align_corners": False},
+    "UpsampleBilinear2D": {"output_size": None, "scales": None, "align_corners": False},
+    "UpsampleLinear1DGrad": {"output_size": None, "scales": None, "align_corners": False},
+    "UpsampleLinear1D": {"output_size": None, "scales": None, "align_corners": False},
+    "UpsampleNearest1DGrad": {"output_size": None, "scales": None},
+    "UpsampleNearest1D": {"output_size": None, "scales": None},
+    "UpsampleNearest2DGrad": {"output_size": None, "scales": None},
+    "UpsampleNearest2D": {"output_size": None, "scales": None},
+    "UpsampleNearest3DGrad": {"output_size": None, "scales": None},
+    "UpsampleNearest3D": {"output_size": None, "scales": None},
+    "UpsampleTrilinear3DGrad": {"output_size": None, "scales": None, "align_corners": False},
+    "UpsampleTrilinear3D": {"output_size": None, "scales": None, "align_corners": False},
     "WeightQuantBatchMatmul": {"antiquant_offset": None, "quant_scale": None, "quant_offset": None, "bias": None, "transpose_x": False, "transpose_weight": False, "antiquant_group_size": 0},
+    "ZerosLikeExt": {"dtype": None},
+    "Zeros": {"dtype": None},
 }
 
 op_labels = {
+    "AdamWeightDecayExt": {"side_effect_mem": True},
     "AdamWeightDecay": {"side_effect_mem": True},
     "AssignAdd": {"side_effect_mem": True},
     "Assign": {"side_effect_mem": True},
     "DecoderKVCache": {"side_effect_mem": True},
+    "DropoutExt": {"side_effect_hidden": True},
+    "DropoutGenMaskExt": {"side_effect_hidden": True},
     "Dropout": {"side_effect_hidden": True},
+    "Embedding": {"side_effect_mem": True},
     "Log": {"cust_aicpu": 'Log', "base": -1.0, "scale": 1.0, "shift": 0.0},
     "PromptKVCache": {"side_effect_mem": True},
     "ReshapeAndCache": {"side_effect_mem": True},
+    "ResizeD": {"mode": 'linear'},
 }

mindspore/ops/auto_generate/gen_arg_dtype_cast.py

@@ -20,17 +20,25 @@ import mindspore as ms
 from mindspore import ops
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations._sequence_ops import TensorToScalar, TensorToTuple
-from mindspore.ops_generate.gen_ops_inner_prim import ListToTuple, TupleToList
+from mindspore.ops_generate.gen_ops_inner_prim import TupleToList
 from mindspore._c_expression import OpDtype
 
 tensor_to_tuple_ = TensorToTuple()
-list_to_tuple = ListToTuple()
 tuple_to_list = TupleToList()
 
+
 def int_to_float(data):
     return float(data)
 
 
+def list_to_tuple(data):
+    # tuple() currently does not support Any from JIT Fallback.
+    res = ()
+    for element in data:
+        res += (element,)
+    return res
+
+
 def scalar_to_tuple(data):
     return (data,)
 
@@ -61,6 +69,7 @@ def tuple_to_tensor(data):
 def list_to_tensor(data):
     return ops.tuple_to_array(list_to_tuple(data))
 
+
 # There will be some problems in using OpDtype.xxx directly in GRAPH_MODE, so convert it to int.
 # type
 DT_TYPE_VAL = int(OpDtype.DT_TYPE)
@@ -243,6 +252,6 @@ def type_it(op_name, arg_name, data, src_type, dst_type):
     dst_type = int(dst_type)
     if not is_instance_in(data, src_type) and not is_instance_of(data, dst_type):
         support_list = get_support_dtype_list(src_type, dst_type)
-        raise TypeError(f"For '{op_name}', the type of '{arg_name}' should be one of '[{support_list}]', " \
+        raise TypeError(f"For '{op_name}', the type of '{arg_name}' should be one of '[{support_list}]', "
                         f"but got {type(data)}.")
     return do_type_cast(data, dst_type)

mindspore/ops/auto_generate/gen_arg_handler.py

@@ -79,6 +79,30 @@ def to_dilations(op_name, arg_name, dilation):
     raise ValueError(arg_invalid_info(op_name, arg_name, dilation))
 
 
+def to_output_padding(op_name, arg_name, output_padding):
+    """
+    convert output_padding: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(output_padding, int):
+        return (output_padding, output_padding)
+    if isinstance(output_padding, (tuple, list)):
+        if len(output_padding) == 4:
+            return (output_padding[2], output_padding[3])
+        return output_padding
+    raise ValueError(arg_invalid_info(op_name, arg_name, output_padding))
+
+
+def to_2d_paddings(op_name, arg_name, pad):
+    """
+    convert paddings: int -> tuple[int*2].
+    """
+    if isinstance(pad, int):
+        return (pad,) * 2
+    if isinstance(pad, (tuple, list)):
+        return pad
+    raise ValueError(arg_invalid_info(op_name, arg_name, pad))
+
+
 def to_paddings(op_name, arg_name, pad):
     """
     convert paddings: int -> tuple[int*4].