mindspore 2.4.0__cp311-cp311-macosx_10_15_x86_64.whl

mindspore/ops/auto_generate/cpp_create_prim_instance_helper.py

@@ -0,0 +1,309 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Operator labels and args default value."""
+from mindspore.common import dtype as mstype
+
+op_args_default_value = {
+    "AdamWeightDecay": {"use_locking": False},
+    "AdamW": {"amsgrad": False, "maximize": False},
+    "AddExt": {"alpha": 1},
+    "AddLayerNormV2": {"epsilon": 1e-5, "additionalOut": False},
+    "ApplyAdamW": {"max_grad_norm": None, "amsgrad": False, "maximize": False},
+    "ApplyCamePart2": {"sum_r": None, "global_shape": None},
+    "ApplyCamePart3": {"global_shape": None, "use_first_moment": False},
+    "ApplyCamePart4": {"global_shape": None},
+    "ApplyRotaryPosEmb": {"cos_format": 0},
+    "Arange": {"dtype": None},
+    "ArgMaxExt": {"dim": None, "keepdim": False},
+    "Argmax": {"axis": -1, "output_type": mstype.int32},
+    "ArgMaxWithValue": {"axis": 0, "keep_dims": False},
+    "ArgMinExt": {"dim": None, "keepdim": 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": {"running_mean": None, "runnning_var": None, "training": False, "momentum": 0.1, "epsilon": 1e-5},
+    "BatchNormGradExt": {"running_mean": None, "running_var": None, "saved_mean": None, "saved_rstd": None, "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'},
+    "BatchNorm": {"is_training": False, "epsilon": 1e-5, "momentum": 0.1, "data_format": 'NCHW'},
+    "BatchNormWithActivation": {"is_training": False, "epsilon": 1e-5, "momentum": 0.1, "data_format": 'NCHW'},
+    "BatchNormWithAddAndActivation": {"is_training": False, "epsilon": 1e-5, "momentum": 0.1, "data_format": 'NCHW'},
+    "BiasAddGrad": {"data_format": 'NCHW'},
+    "BiasAdd": {"data_format": 'NCHW'},
+    "BinaryCrossEntropyGrad": {"weight": None, "reduction": 'mean'},
+    "BinaryCrossEntropy": {"weight": None, "reduction": 'mean'},
+    "BinaryCrossEntropyWithLogitsBackward": {"weight": None, "posWeight": None, "reduction": 'mean'},
+    "BCEWithLogitsLoss": {"weight": None, "posWeight": None, "reduction": 'mean'},
+    "CeLU": {"alpha": 1.0},
+    "CholeskyInverse": {"upper": False},
+    "Cholesky": {"upper": False},
+    "Chunk": {"dim": 0},
+    "ClampScalar": {"min": None, "max": None},
+    "ClampTensor": {"min": None, "max": None},
+    "Col2ImExt": {"dilation": 1, "padding": 0, "stride": 1},
+    "Col2ImGrad": {"dilation": 1, "padding": 0, "stride": 1},
+    "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'},
+    "Cross": {"dim": -65530},
+    "CumProd": {"exclusive": False, "reverse": False},
+    "CumSum": {"exclusive": False, "reverse": False},
+    "CumsumExt": {"dtype": None},
+    "DCT": {"type": 2, "n": None, "axis": -1, "norm": None},
+    "DCTN": {"type": 2, "s": None, "axes": None, "norm": None},
+    "Dense": {"bias": None},
+    "Diagonal": {"offset": 0, "dim1": 0, "dim2": 1},
+    "DivMod": {"rounding_mode": None},
+    "Dropout": {"keep_prob": 0.5, "Seed0": 0, "Seed1": 0},
+    "Eig": {"compute_v": False},
+    "EluExt": {"alpha": 1.0},
+    "EluGradExt": {"alpha": 1.0},
+    "Elu": {"alpha": 1.0},
+    "EmbeddingApplyAdaGrad": {"mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingApplyAdam": {"mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingApplyAdamW": {"ams_grad": (0,), "mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingApplyFtrl": {"mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingApplyRmsprop": {"mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingApplySgd": {"mask_zero": (0,), "padding_key": (0,), "padding_key_mask": (1,), "completion_key": (0,), "completion_key_mask": (1,), "_embedding_dim": 1, "_max_key_num": 1},
+    "EmbeddingDenseBackward": {"padding_idx": None, "scale_grad_by_freq": False},
+    "EmbeddingFeatureMappingFileSize": {"only_offset_flag": True},
+    "EmbeddingFeatureMappingFind": {"num": 1},
+    "EmbeddingFeatureMappingImport": {"only_offset_flag": True, "num": 1},
+    "Embedding": {"padding_idx": None, "max_norm": None, "norm_type": 2.0, "scale_grad_by_freq": False},
+    "EmbeddingTableEvict": {"steps_to_live": 0},
+    "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},
+    "FFTOrtho": {"axes": None, "forward": True},
+    "FFTWithSize": {"norm": 'backward', "onesided": True, "signal_sizes": ()},
+    "FFTFreq": {"d": 1.0, "dtype": None},
+    "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},
+    "GenerateEodMaskV2": {"start": 0, "steps": 1, "error_mode": 'cycle', "flip_mode": 'bitflip', "multiply_factor": 0.0, "bit_pos": 0, "flip_probability": 0.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},
+    "HFFT2": {"s": None, "dim": (-2, -1), "norm": None},
+    "HFFT": {"n": None, "dim": -1, "norm": None},
+    "HFFTN": {"s": None, "dim": None, "norm": None},
+    "HistcExt": {"bins": 100, "min": 0, "max": 0},
+    "HShrinkGrad": {"lambd": 0.5},
+    "HShrink": {"lambd": 0.5},
+    "IDCT": {"type": 2, "n": None, "axis": -1, "norm": None},
+    "IDCTN": {"type": 2, "s": None, "axes": None, "norm": None},
+    "IFFT2": {"s": None, "dim": (-2, -1), "norm": None},
+    "IFFT": {"n": None, "dim": -1, "norm": None},
+    "IFFTN": {"s": None, "dim": None, "norm": None},
+    "IFFTShift": {"dim": None},
+    "IHFFT2": {"s": None, "dim": (-2, -1), "norm": None},
+    "IHFFT": {"n": None, "dim": -1, "norm": None},
+    "IHFFTN": {"s": None, "dim": None, "norm": None},
+    "Im2ColExt": {"dilation": 1, "padding": 0, "stride": 1},
+    "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},
+    "InplaceAddExt": {"alpha": 1},
+    "InplaceAddmm": {"beta": 1, "alpha": 1},
+    "InplaceAddsExt": {"alpha": 1},
+    "InsertGemV2InBackward": {"start": 0, "steps": 1, "error_mode": 'cycle', "flip_mode": 'bitflip', "multiply_factor": 0.0, "bit_pos": 0, "flip_probability": 0.0},
+    "IRFFT2": {"s": None, "dim": (-2, -1), "norm": None},
+    "IRFFTDouble": {"dim": -1},
+    "IRFFT": {"n": None, "dim": -1, "norm": None},
+    "IRFFTN": {"s": None, "dim": None, "norm": None},
+    "IsClose": {"rtol": 1e-05, "atol": 1e-08, "equal_nan": True},
+    "L1LossBackwardExt": {"reduction": 'mean'},
+    "L1LossExt": {"reduction": 'mean'},
+    "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},
+    "LogSoftmaxExt": {"dim": None, "dtype": None},
+    "LogSoftmaxGrad": {"axis": -1},
+    "LogSoftmax": {"axis": -1},
+    "LogitGrad": {"eps": -1.0},
+    "Logit": {"eps": -1.0},
+    "LpNormV2": {"p": 2.0, "dim": None, "keepdim": False, "epsilon": 1e-12},
+    "LstsqV2": {"driver": None},
+    "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},
+    "MedianDim": {"dim": -1, "keepdim": False},
+    "MinimumGrad": {"grad_x": True, "grad_y": True},
+    "MSELossExt": {"reduction": 'mean'},
+    "MSELossGradExt": {"reduction": 'mean'},
+    "NanToNum": {"nan": None, "posinf": None, "neginf": None},
+    "NLLLossGrad": {"reduction": 'mean', "ignore_index": -100},
+    "NLLLoss": {"reduction": 'mean', "ignore_index": -100},
+    "Norm": {"p": 2.0, "dim": None, "keepdim": False, "dtype": None},
+    "OneHotExt": {"axis": -1},
+    "OneHot": {"axis": -1},
+    "OnesLikeExt": {"dtype": None},
+    "Ones": {"dtype": None},
+    "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, "kv_cache_quant_mode": 'DEFAULT'},
+    "ProdExt": {"axis": None, "keep_dims": False, "dtype": None},
+    "PromptKVCache": {"align_mode": 'LEFT'},
+    "Qr": {"full_matrices": False},
+    "RandExt": {"dtype": None},
+    "RandLikeExt": {"dtype": None},
+    "RandpermV2": {"seed": 0, "offset": 0, "dtype": mstype.int64},
+    "Range": {"maxlen": 1000000},
+    "ReduceAll": {"axis": None, "keep_dims": False},
+    "ReduceAny": {"axis": (), "keep_dims": False},
+    "ReduceMax": {"axis": (), "keep_dims": False},
+    "ReduceMean": {"axis": (), "keep_dims": False},
+    "ReduceMin": {"axis": (), "keep_dims": False},
+    "ReduceProd": {"axis": (), "keep_dims": False},
+    "ReduceStd": {"axis": [], "unbiased": True, "keep_dims": False},
+    "ReduceSum": {"axis": (), "keep_dims": False, "skip_mode": False},
+    "RepeatInterleaveInt": {"dim": None, "output_size": None},
+    "RepeatInterleaveTensor": {"dim": 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},
+    "ResizeNearestNeighbor": {"align_corners": False, "half_pixel_centers": False},
+    "ResizeNearestNeighborV2Grad": {"align_corners": False, "half_pixel_centers": False},
+    "ResizeNearestNeighborV2": {"align_corners": False, "half_pixel_centers": False},
+    "RFFT2": {"s": None, "dim": (-2, -1), "norm": None},
+    "RFFT": {"n": None, "dim": -1, "norm": None},
+    "RFFTFreq": {"d": 1.0, "dtype": None},
+    "RFFTN": {"s": None, "dim": None, "norm": None},
+    "RmsNorm": {"epsilon": 1e-6},
+    "Roll": {"axis": None},
+    "RotaryPositionEmbeddingGrad": {"dx": None, "mode": 0},
+    "RotaryPositionEmbedding": {"mode": 0},
+    "Round": {"decimals": 0},
+    "ScalarToTensor": {"dtype": None},
+    "Scatter": {"reduce": 'none'},
+    "ScatterValue": {"reduce": 'none'},
+    "SearchSorted": {"sorter": None, "dtype": mstype.int64, "right": False},
+    "SequenceConcat": {"axis": 0},
+    "SilentCheckV2": {"c_min_steps": 7, "c_thresh_l1": 1000000.0, "c_coeff_l1": 100000.0, "c_thresh_l2": 10000.0, "c_coeff_l2": 5000.0, "npu_asd_detect": 1},
+    "SoftmaxBackward": {"dim": -1},
+    "Softmax": {"axis": -1},
+    "SoftplusExt": {"beta": 1, "threshold": 20},
+    "SoftplusGradExt": {"beta": 1, "threshold": 20},
+    "SoftShrinkGrad": {"lambd": 0.5},
+    "SoftShrink": {"lambd": 0.5},
+    "SolveTriangular": {"trans": 0, "lower": False, "unit_diagonal": False},
+    "SortExt": {"dim": -1, "descending": False, "stable": 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},
+    "SwigluGrad": {"dim": -1},
+    "Swiglu": {"dim": -1},
+    "TensorScatterElements": {"axis": 0, "reduce": 'none'},
+    "TopkExt": {"dim": -1, "largest": True, "sorted": True},
+    "TopKRouter": {"drop_type": 0},
+    "TraceV2Grad": {"offset": 0, "axis1": 1, "axis2": 0},
+    "TraceV2": {"offset": 0, "axis1": 1, "axis2": 0, "dtype": None},
+    "TrilExt": {"diagonal": 0},
+    "Triu": {"diagonal": 0},
+    "TupleToTensor": {"dtype": None},
+    "Unique2": {"sorted": True, "return_inverse": False, "return_counts": False},
+    "UnstackExt": {"axis": 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},
+    "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},
+    "ZerosLikeExt": {"dtype": None},
+    "Zeros": {"dtype": None},
+    "AddRmsNormQuantV2": {"epsilon": 1e-5},
+    "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, "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},
+    "GroupedMatmul": {"bias": None, "scale": None, "offset": None, "antiquant_scale": None, "antiquant_offset": None, "group_list": None, "split_item": 0, "group_type": -1},
+    "KVCacheScatterUpdate": {"reduce": 'none'},
+    "MoeFinalizeRouting": {"x2": None, "bias": None, "scales": None, "expanded_row_idx": None, "expanded_expert_idx": None},
+    "QuantBatchMatmul": {"offset": None, "bias": None, "pertokenScaleOptional": None, "transpose_x1": False, "transpose_x2": False, "dtype": mstype.float16},
+    "QuantV2": {"sqrt_mode": False, "rounding_mode": 'ROUND', "dst_type": mstype.int8},
+    "WeightQuantBatchMatmul": {"antiquant_offset": None, "quant_scale": None, "quant_offset": None, "bias": None, "transpose_x": False, "transpose_weight": False, "antiquant_group_size": 0},
+}
+
+op_labels = {
+    "AdamWeightDecay": {"side_effect_mem": True},
+    "AdamW": {"side_effect_mem": True},
+    "ApplyAdamW": {"side_effect_mem": True},
+    "AssignAdd": {"side_effect_mem": True},
+    "Assign": {"side_effect_mem": True},
+    "CopyExt": {"side_effect_mem": True},
+    "DecoderKVCache": {"side_effect_mem": True},
+    "DropoutExt": {"side_effect_hidden": True},
+    "DropoutGenMaskExt": {"side_effect_hidden": True},
+    "Dropout": {"side_effect_hidden": True},
+    "EmbeddingApplyAdaGrad": {"_process_node_engine_id": 'PS'},
+    "EmbeddingApplyAdam": {"_process_node_engine_id": 'PS'},
+    "EmbeddingApplyAdamW": {"_process_node_engine_id": 'PS'},
+    "EmbeddingApplyFtrl": {"_process_node_engine_id": 'PS'},
+    "EmbeddingApplyRmsprop": {"_process_node_engine_id": 'PS'},
+    "EmbeddingApplySgd": {"_process_node_engine_id": 'PS'},
+    "Embedding": {"side_effect_mem": True},
+    "EmbeddingTableEvict": {"_process_node_engine_id": 'PS'},
+    "Generator": {"side_effect_mem": True},
+    "InplaceAddExt": {"side_effect_mem": True},
+    "InplaceAddmm": {"side_effect_mem": True},
+    "InplaceAddsExt": {"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'},
+    "SilentCheckV2": {"side_effect_mem": True},
+    "KVCacheScatterUpdate": {"side_effect_mem": True},
+}

mindspore/ops/auto_generate/gen_arg_dtype_cast.py

@@ -0,0 +1,252 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2023-2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Operator argument data type cast function."""
+
+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 TupleToList, ListToTuple
+from mindspore._c_expression import OpDtype
+
+tensor_to_tuple_ = TensorToTuple()
+tuple_to_list = TupleToList()
+list_to_tuple = ListToTuple()
+
+
+def int_to_float(data):
+    return float(data)
+
+
+def scalar_to_tuple(data):
+    return (data,)
+
+
+def tensor_to_tuple(data):
+    # Since tuple is not supported for precision conversion during KernelSelect, the original int32 tensor input cases
+    # would be failed. Thus, the tuple precision is raised from int32 to int64 at frontend. But sequence data type cast
+    # must be adapted in future version.
+    if data.dtype == ms.int32:
+        data = ops.cast(data, ms.int64)
+    return tensor_to_tuple_(data)
+
+
+def scalar_to_tensor(data):
+    if isinstance(data, bool):
+        return ops.scalar_to_tensor(data, ms.bool_)
+    if isinstance(data, int):
+        return ops.scalar_to_tensor(data, ms.int32)
+    if isinstance(data, float):
+        return ops.scalar_to_tensor(data, ms.float32)
+    return ops.scalar_to_tensor(data)
+
+
+def tuple_to_tensor(data):
+    return ops.tuple_to_array(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)
+# scalar
+DT_INT_VAL = int(OpDtype.DT_INT)
+DT_FLOAT_VAL = int(OpDtype.DT_FLOAT)
+DT_BOOL_VAL = int(OpDtype.DT_BOOL)
+DT_NUMBER_VAL = int(OpDtype.DT_NUMBER)
+# tuple
+DT_TUPLE_BOOL_VAL = int(OpDtype.DT_TUPLE_BOOL)
+DT_TUPLE_INT_VAL = int(OpDtype.DT_TUPLE_INT)
+DT_TUPLE_FLOAT_VAL = int(OpDtype.DT_TUPLE_FLOAT)
+DT_TUPLE_NUMBER_VAL = int(OpDtype.DT_TUPLE_NUMBER)
+DT_TUPLE_TENSOR_VAL = int(OpDtype.DT_TUPLE_TENSOR)
+DT_TUPLE_STR_VAL = int(OpDtype.DT_TUPLE_STR)
+DT_TUPLE_ANY_VAL = int(OpDtype.DT_TUPLE_ANY)
+# list
+DT_LIST_BOOL_VAL = int(OpDtype.DT_LIST_BOOL)
+DT_LIST_INT_VAL = int(OpDtype.DT_LIST_INT)
+DT_LIST_FLOAT_VAL = int(OpDtype.DT_LIST_FLOAT)
+DT_LIST_NUMBER_VAL = int(OpDtype.DT_LIST_NUMBER)
+DT_LIST_TENSOR_VAL = int(OpDtype.DT_LIST_TENSOR)
+DT_LIST_STR_VAL = int(OpDtype.DT_LIST_STR)
+DT_LIST_ANY_VAL = int(OpDtype.DT_LIST_ANY)
+# tensor
+DT_TENSOR_VAL = int(OpDtype.DT_TENSOR)
+
+dtype_to_string = {
+    DT_INT_VAL: "int",
+    DT_FLOAT_VAL: "float",
+    DT_BOOL_VAL: "bool",
+    DT_NUMBER_VAL: "number",
+    DT_TENSOR_VAL: "Tensor",
+    DT_TUPLE_BOOL_VAL: "tuple of bool",
+    DT_TUPLE_INT_VAL: "tuple of int",
+    DT_TUPLE_FLOAT_VAL: "tuple of float",
+    DT_TUPLE_NUMBER_VAL: "tuple of number",
+    DT_TUPLE_TENSOR_VAL: "tuple of tensor",
+    DT_TUPLE_STR_VAL: "tuple of string",
+    DT_TUPLE_ANY_VAL: "tuple of Any",
+    DT_LIST_BOOL_VAL: "list of bool",
+    DT_LIST_INT_VAL: "list of int",
+    DT_LIST_FLOAT_VAL: "list of float",
+    DT_LIST_NUMBER_VAL: "list of number",
+    DT_LIST_TENSOR_VAL: "list of Tensor",
+    DT_LIST_STR_VAL: "list of string",
+    DT_LIST_ANY_VAL: "list of Any"
+}
+
+
+def is_tuple(type_id):
+    """
+    Check type id is tuple.
+    """
+    return type_id in (DT_TUPLE_BOOL_VAL, DT_TUPLE_INT_VAL, DT_TUPLE_FLOAT_VAL, DT_TUPLE_NUMBER_VAL,
+                       DT_TUPLE_TENSOR_VAL, DT_TUPLE_STR_VAL, DT_TUPLE_ANY_VAL)
+
+
+def is_list(type_id):
+    """
+    Check type id is list.
+    """
+    return type_id in (DT_LIST_BOOL_VAL, DT_LIST_INT_VAL, DT_LIST_FLOAT_VAL, DT_LIST_NUMBER_VAL,
+                       DT_LIST_TENSOR_VAL,
+                       DT_LIST_STR_VAL, DT_LIST_ANY_VAL)
+
+
+def is_number(type_id):
+    """
+    Check type id is number.
+    """
+    return type_id in (DT_INT_VAL, DT_FLOAT_VAL, DT_BOOL_VAL, DT_NUMBER_VAL)
+
+
+def is_instance_of(data, type_id):
+    """
+    Instead isinstance(obj, type).
+    """
+    if type_id == DT_INT_VAL:
+        return isinstance(data, int)
+    if type_id == DT_FLOAT_VAL:
+        return isinstance(data, float)
+    if type_id == DT_BOOL_VAL:
+        return isinstance(data, bool)
+    if is_number(type_id):
+        return isinstance(data, (int, float, bool))
+    if is_tuple(type_id):
+        return isinstance(data, tuple)
+    if is_list(type_id):
+        return isinstance(data, list)
+    if type_id == DT_TENSOR_VAL:
+        return isinstance(data, Tensor)
+    return False
+
+
+def is_instance_in(data, type_id):
+    """
+    Instead isinstance(obj, tuple_types).
+    """
+    if not isinstance(type_id, tuple):
+        return is_instance_of(data, type_id)
+    for type_id_i in type_id:
+        if is_instance_of(data, type_id_i):
+            return True
+    return False
+
+
+def get_support_dtype_list(src_type, dst_type):
+    """
+    Get support dtype list.
+    """
+    support_list = ""
+    if isinstance(src_type, tuple):
+        for dtype in src_type:
+            support_list += dtype_to_string.get(dtype) + ", "
+    else:
+        support_list += dtype_to_string.get(src_type) + ", "
+    support_list += dtype_to_string.get(dst_type)
+    return support_list
+
+
+def to_py_number(data, dst_type):
+    """Convert tensor to python number"""
+    if dst_type == DT_INT_VAL:
+        data = ops.cast(data, ms.int64)
+    elif dst_type == DT_FLOAT_VAL:
+        data = ops.cast(data, ms.float32)
+    elif dst_type == DT_NUMBER_VAL:
+        src_type = data.dtype
+        if src_type in (ms.uint8, ms.uint16, ms.uint32, ms.uint64,
+                        ms.int8, ms.int16, ms.int32, ms.int64):
+            data = ops.cast(data, ms.int64)
+        elif src_type in (ms.bfloat16, ms.float16, ms.float32, ms.float64):
+            data = ops.cast(data, ms.float32)
+    return TensorToScalar()(data)
+
+
+def do_type_cast(data, dst_type):
+    """Type conversion."""
+    if is_instance_of(data, dst_type):
+        return data
+    if dst_type == DT_FLOAT_VAL:
+        if isinstance(data, int):
+            return int_to_float(data)
+    elif is_tuple(dst_type):
+        if isinstance(data, (int, float, bool)):
+            return scalar_to_tuple(data)
+        if isinstance(data, list):
+            return list_to_tuple(data)
+        if isinstance(data, Tensor):
+            return tensor_to_tuple(data)
+    elif is_list(dst_type):
+        if isinstance(data, (int, float, bool)):
+            return tuple_to_list(scalar_to_tuple(data))
+        if isinstance(data, tuple):
+            return tuple_to_list(data)
+        if isinstance(data, Tensor):
+            return tuple_to_list(tensor_to_tuple(data))
+    elif dst_type == DT_TENSOR_VAL:
+        if isinstance(data, (int, float, bool)):
+            return scalar_to_tensor(data)
+        if isinstance(data, tuple):
+            return tuple_to_tensor(data)
+        if isinstance(data, list):
+            return list_to_tensor(data)
+    elif is_number(dst_type):
+        if isinstance(data, Tensor):
+            return to_py_number(data, dst_type)
+    raise TypeError("Type conversion failed.")
+
+
+def type_it(op_name, arg_name, data, src_type, dst_type):
+    """
+    cast operator argument data type.
+    """
+    if isinstance(data, type(None)):
+        return data
+    if not isinstance(src_type, tuple):
+        src_type = int(src_type)
+    else:
+        src_type = tuple((int(t) for t in src_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}]', "
+                        f"but got {type(data)}.")
+    return do_type_cast(data, dst_type)