mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/auto_generate/cpp_create_prim_instance_helper.py

@@ -0,0 +1,133 @@
+# 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},
+    "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},
+    "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},
+    "AvgPoolGrad": {"kernel_size": 1, "strides": 1, "pad_mode": 'VALID', "data_format": 'NCHW'},
+    "AvgPool": {"kernel_size": 1, "strides": 1, "pad_mode": 'VALID', "data_format": 'NCHW'},
+    "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'},
+    "CeLU": {"alpha": 1.0},
+    "CholeskyInverse": {"upper": False},
+    "Cholesky": {"upper": False},
+    "Concat": {"axis": 0},
+    "Correlate": {"mode": 'valid'},
+    "CumProd": {"exclusive": False, "reverse": False},
+    "CumSum": {"exclusive": False, "reverse": False},
+    "DCT": {"axis": -1, "norm": 'BACKWARD', "forward": True, "grad": False},
+    "Diagonal": {"offset": 0, "dim1": 0, "dim2": 1},
+    "Dropout": {"keep_prob": 0.5, "Seed0": 0, "Seed1": 0},
+    "Eig": {"compute_v": False},
+    "Elu": {"alpha": 1.0},
+    "ExtractImagePatches": {"padding": 'VALID'},
+    "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},
+    "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},
+    "HShrinkGrad": {"lambd": 0.5},
+    "HShrink": {"lambd": 0.5},
+    "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},
+    "IRFFTGrad": {"n": None, "dim": -1, "norm": None},
+    "IRFFT": {"n": None, "dim": -1, "norm": None},
+    "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},
+    "LogSoftmaxGrad": {"axis": -1},
+    "LogSoftmax": {"axis": -1},
+    "LogitGrad": {"eps": -1.0},
+    "Logit": {"eps": -1.0},
+    "MaximumGradGrad": {"grad_x": True, "grad_y": True},
+    "MaximumGrad": {"grad_x": True, "grad_y": True},
+    "MinimumGrad": {"grad_x": True, "grad_y": True},
+    "NanToNum": {"nan": None, "posinf": None, "neginf": None},
+    "NLLLossGrad": {"reduction": 'mean', "ignore_index": -100},
+    "NLLLoss": {"reduction": 'mean', "ignore_index": -100},
+    "OneHot": {"axis": -1},
+    "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},
+    "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},
+    "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},
+    "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},
+    "RFFTGrad": {"n": None, "dim": -1, "norm": None},
+    "RFFT": {"n": None, "dim": -1, "norm": None},
+    "ScalarToTensor": {"dtype": None},
+    "SequenceConcat": {"axis": 0},
+    "SoftmaxBackward": {"dim": -1},
+    "Softmax": {"axis": -1},
+    "SolveTriangular": {"trans": 0, "lower": False, "unit_diagonal": False},
+    "Split": {"axis": 0, "output_num": 1},
+    "StridedSlice": {"begin_mask": 0, "end_mask": 0, "ellipsis_mask": 0, "new_axis_mask": 0, "shrink_axis_mask": 0},
+    "SubExt": {"alpha": 1},
+    "TupleToTensor": {"dtype": None},
+    "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},
+    "AssignAdd": {"side_effect_mem": True},
+    "Assign": {"side_effect_mem": True},
+    "DecoderKVCache": {"side_effect_mem": True},
+    "Dropout": {"side_effect_hidden": True},
+    "Log": {"cust_aicpu": 'Log', "base": -1.0, "scale": 1.0, "shift": 0.0},
+    "PromptKVCache": {"side_effect_mem": True},
+    "ReshapeAndCache": {"side_effect_mem": True},
+}

mindspore/ops/auto_generate/gen_arg_dtype_cast.py

@@ -0,0 +1,248 @@
+# 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 ListToTuple, 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 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 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)

mindspore/ops/auto_generate/gen_arg_handler.py

@@ -0,0 +1,147 @@
+# 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 argument handle function."""
+
+from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum, StringToEnum
+# Enum Class:
+from mindspore._c_expression import FormatEnum as Format
+from mindspore._c_expression import ReductionEnum as Reduction
+
+
+def arg_invalid_info(op_name, arg_name, arg_val):
+    """
+    generate invalid msg.
+    """
+    return f"For '{op_name}', the value of '{arg_name}' is invalid: '{arg_val}'."
+
+
+def to_kernel_size(op_name, arg_name, kernel_size):
+    """
+    convert kernel_size: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(kernel_size, int):
+        return (kernel_size, kernel_size)
+    if isinstance(kernel_size, (tuple, list)):
+        if len(kernel_size) == 4:
+            return (kernel_size[2], kernel_size[3])
+        return kernel_size
+    raise ValueError(arg_invalid_info(op_name, arg_name, kernel_size))
+
+
+def to_strides(op_name, arg_name, stride):
+    """
+    convert strides: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(stride, int):
+        return (stride, stride)
+    if isinstance(stride, (tuple, list)):
+        if len(stride) == 4:
+            return (stride[2], stride[3])
+        return stride
+    raise ValueError(arg_invalid_info(op_name, arg_name, stride))
+
+
+def to_rates(op_name, arg_name, rates):
+    """
+    convert rates: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(rates, int):
+        return (rates, rates)
+    if isinstance(rates, (tuple, list)):
+        if len(rates) == 4:
+            return (rates[2], rates[3])
+        return rates
+    raise ValueError(arg_invalid_info(op_name, arg_name, rates))
+
+
+def to_dilations(op_name, arg_name, dilation):
+    """
+    convert dilations: int/tuple[int*4] -> tuple[int*2].
+    """
+    if isinstance(dilation, int):
+        return (dilation, dilation)
+    if isinstance(dilation, (tuple, list)):
+        if len(dilation) == 4:
+            return (dilation[2], dilation[3])
+        return dilation
+    raise ValueError(arg_invalid_info(op_name, arg_name, dilation))
+
+
+def to_paddings(op_name, arg_name, pad):
+    """
+    convert paddings: int -> tuple[int*4].
+    """
+    if isinstance(pad, int):
+        return (pad,) * 4
+    if isinstance(pad, (tuple, list)):
+        return pad
+    raise ValueError(arg_invalid_info(op_name, arg_name, pad))
+
+
+def to_3d_kernel_size(op_name, arg_name, kernel_size):
+    """
+    convert 3d kernel_size: int/tuple[int*6] -> tuple[int*3].
+    """
+    if isinstance(kernel_size, int):
+        return (kernel_size, kernel_size, kernel_size)
+    if isinstance(kernel_size, (tuple, list)):
+        if len(kernel_size) == 5:
+            return (kernel_size[2], kernel_size[3], kernel_size[4])
+        return kernel_size
+    raise ValueError(arg_invalid_info(op_name, arg_name, kernel_size))
+
+
+def to_3d_strides(op_name, arg_name, stride):
+    """
+    convert 3d stride: int/tuple[int*6] -> tuple[int*3].
+    """
+    if isinstance(stride, int):
+        return (stride, stride, stride)
+    if isinstance(stride, (tuple, list)):
+        if len(stride) == 5:
+            return (stride[2], stride[3], stride[4])
+        return stride
+    raise ValueError(arg_invalid_info(op_name, arg_name, stride))
+
+
+def to_3d_dilations(op_name, arg_name, dilation):
+    """
+    convert 3d dilation: int/tuple[int*6] -> tuple[int*3].
+    """
+    if isinstance(dilation, int):
+        return (dilation, dilation, dilation)
+    if isinstance(dilation, (tuple, list)):
+        if len(dilation) == 5:
+            return (dilation[2], dilation[3], dilation[4])
+        return dilation
+    raise ValueError(arg_invalid_info(op_name, arg_name, dilation))
+
+
+def to_3d_paddings(op_name, arg_name, pad):
+    """
+    convert 3d paddings: int -> tuple[int*6].
+    """
+    if isinstance(pad, int):
+        return (pad,) * 6
+    if isinstance(pad, (tuple, list)):
+        return pad
+    raise ValueError(arg_invalid_info(op_name, arg_name, pad))
+
+dtype_to_type_id = DtypeToEnum()
+
+# string to enum
+# A function for converting str type to enum type are written here,
+# but the backend supports str input, and converting str input to enum input is not necessary.
+str_to_enum = StringToEnum()

mindspore/ops/auto_generate/gen_extend_func.py

@@ -0,0 +1,130 @@
+# 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.
+# ============================================================================
+
+from mindspore.common import dtype as mstype
+from mindspore.ops.auto_generate.pyboost_inner_prim import *
+
+
+def add(input, other, alpha=1):
+    r"""
+    Adds scaled other value to input Tensor.
+    
+    .. math::
+    
+        out_{i} = input_{i} + alpha \times other_{i}
+    
+    Note:
+        - When the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs and alpha comply with the implicit type conversion rules to make the data types
+          consistent.
+    
+    Args:
+        input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+        other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+        alpha (number.Number): A scaling factor applied to `other`, default 1.
+    
+    Returns:
+        Tensor, the shape is the same as the one of the input `input`, `other` after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs and alpha.
+    
+    Raises:
+        TypeError: If the type of `input`, `other`, or `alpha` is not one of the following: Tensor, number.Number, bool.
+        TypeError: If `alpha` is of type float but `input` and `other` are not of type float.
+        TypeError: If `alpha` is of type bool but `input` and `other` are not of type bool.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.extend import add
+        >>> x = Tensor(1, mindspore.int32)
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> alpha = 0.5
+        >>> output = add(x, y, alpha)
+        >>> print(output)
+        [3. 3.5 4.]
+        >>> # the data type of x is int32, the data type of y is float32,
+        >>> # alpha is a float, and the output is the data format of higher precision float32.
+        >>> print(output.dtype)
+        Float32
+    """
+    return add_impl(input, other, alpha)
+
+
+def sub(input, other, alpha=1):
+    r"""
+    Subtracts scaled other value from input Tensor.
+    
+    .. math::
+    
+        out_{i} = input_{i} - alpha \times other_{i}
+    
+    Note:
+        - When the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs and alpha comply with the implicit type conversion rules to make the data types
+          consistent.
+    
+    Args:
+        input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+        other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+        alpha (number.Number): A scaling factor applied to `other`, default 1.
+    
+    Returns:
+        Tensor, the shape is the same as the one of the input `input`, `other` after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs and alpha.
+    
+    Raises:
+        TypeError: If the type of `input`, `other`, or `alpha` is not one of the following: Tensor, number.Number, bool.
+        TypeError: If `alpha` is of type float but `input` and `other` are not of type float.
+        TypeError: If `alpha` is of type bool but `input` and `other` are not of type bool.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.extend import sub
+        >>> x = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> y = Tensor(1, mindspore.int32)
+        >>> alpha = 0.5
+        >>> output = sub(x, y, alpha)
+        >>> print(output)
+        [3.5 4.5 5.5]
+        >>> # the data type of x is float32, the data type of y is int32,
+        >>> # alpha is a float, and the output is the data format of higher precision float32.
+        >>> print(output.dtype)
+        Float32
+    """
+    return sub_impl(input, other, alpha)
+