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

mindspore/ops_generate/gen_utils.py

@@ -0,0 +1,188 @@
+# Copyright 2023-2025 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.
+# ============================================================================
+"""
+Generate operator utils function
+"""
+import os
+import glob
+import hashlib
+import stat
+import yaml
+
+
+py_licence_str = f"""# 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.
+# ============================================================================
+"""
+
+cc_license_str = f"""/**
+ * 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.
+ */"""
+
+
+def convert_dtype_str(dtype_str):
+    """
+    Convert dtype str to expression in ops file
+    """
+    return 'DT_' + dtype_str.replace('[', '_').replace(']', '').upper()
+
+
+def get_type_str(type_str):
+    """
+    Get the unified type str for operator arg dtype.
+    """
+    # add more type here
+    type_kind_set = {
+        'int',
+        'float',
+        'bool',
+        'number',
+        'tuple[int]',
+        'tuple[float]',
+        'tuple[bool]',
+        'tuple[tensor]',
+        'list[int]',
+        'list[float]',
+        'list[bool]',
+        'list[tensor]',
+        'tensor',
+        'type',
+    }
+    if type_str in type_kind_set:
+        return "OpDtype." + convert_dtype_str(type_str)
+    raise TypeError(f"""Unsupported type {type_str} for args.""")
+
+
+def get_file_md5(file_path):
+    """
+    Get the md5 value for file.
+    """
+    if not os.path.exists(file_path):
+        return ""
+    if os.path.isdir(file_path):
+        return ""
+    with open(file_path, 'rb') as f:
+        data = f.read()
+    md5_value = hashlib.md5(data).hexdigest()
+    return md5_value
+
+
+def check_change_and_replace_file(last_file_path, tmp_file_path):
+    """
+    Compare tmp_file with the md5 value of the last generated file.
+    If the md5 value is the same, retain the last generated file.
+    Otherwise, update the last generated file to tmp_file.
+    """
+    last_md5 = get_file_md5(last_file_path)
+    tmp_md5 = get_file_md5(tmp_file_path)
+
+    if last_md5 == tmp_md5:
+        os.remove(tmp_file_path)
+    else:
+        if os.path.exists(last_file_path):
+            os.remove(last_file_path)
+        os.rename(tmp_file_path, last_file_path)
+
+
+def merge_files_to_one_file(file_paths, merged_file_path):
+    """
+    Merge multiple files into one file.
+    """
+    merged_content = ''
+    file_paths.sort()
+    for file_path in file_paths:
+        with open(file_path, 'r') as file:
+            merged_content += file.read()
+            merged_content += '\n'
+    with open(merged_file_path, 'w') as file:
+        file.write(merged_content)
+
+
+def merge_files(origin_dir, merged_file_path, file_format):
+    """
+    Merge multiple files into one file.
+    origin_dir: indicates the origin file directory.
+    merged_file_path: indicates the merged file path.
+    file_format: indicates the format of regular matching.
+    Files whose names meet the regular matching in 'origin_dir' directory will be merged into one file.
+    """
+    op_yaml_file_names = glob.glob(os.path.join(origin_dir, file_format))
+    merge_files_to_one_file(op_yaml_file_names, merged_file_path)
+
+
+def safe_load_yaml(yaml_file_path):
+    """
+    Load yaml dictionary from file.
+    """
+    yaml_str = dict()
+    with open(yaml_file_path, 'r') as yaml_file:
+        yaml_str.update(yaml.safe_load(yaml_file))
+    return yaml_str
+
+
+def get_assign_str_by_type_it(class_name, arg_info, arg_name, dtype):
+    """
+    Make type_it(arg, src_types, dst_type) python sentences.
+    """
+    assign_str = ""
+    type_cast = arg_info.get('type_cast')
+    if type_cast is not None:
+        type_cast_tuple = tuple(ct.strip() for ct in type_cast.split(","))
+        assign_str += f"type_it('{class_name}', '{arg_name}', {arg_name}, "
+        if len(type_cast_tuple) == 1:
+            assign_str += get_type_str(type_cast_tuple[0]) + ', '
+        else:
+            assign_str += '(' + ', '.join(get_type_str(ct) for ct in type_cast_tuple) + '), '
+        assign_str += get_type_str(dtype) + ')'
+    else:
+        assign_str = arg_name
+    return assign_str
+
+
+def write_file(path, data):
+    """
+    write data to path
+    :param path:
+    :param data:
+    :return:
+    """
+    flags = os.O_RDWR | os.O_CREAT
+    mode = stat.S_IWUSR | stat.S_IRUSR
+    fd = os.open(path, flags, mode)
+    with os.fdopen(fd, "w") as f:
+        f.write(data)

mindspore/ops_generate/op_proto.py

@@ -0,0 +1,138 @@
+# 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.
+# ============================================================================
+"""Op Proto."""
+from pyboost_utils import convert_python_func_name_to_c
+
+
+class Arg:
+    def __init__(self, arg_name, arg_dtype, type_cast, is_type_id=False, as_init_arg=False, default=-1, inplace=''):
+        self.arg_name = arg_name
+        self.arg_dtype = arg_dtype
+        self.type_cast = type_cast
+        self.is_type_id = is_type_id
+        self.as_init_arg = as_init_arg
+        self.default = default
+        self.inplace = inplace
+
+
+class OpProto:
+    """
+    This class defines mindspore op prototype, we parse ops.yaml to the object, to auto generate primitive
+    and pyboost function.
+    """
+
+    def __init__(self,
+                 operator_name,
+                 op_args,
+                 returns,
+                 class_name,
+                 is_pyboost,
+                 is_view,
+                 cpu,
+                 gpu,
+                 ascend,
+                 prim_init,
+                 is_dispatch):
+        self.operator_name = operator_name
+        self.class_name = class_name
+        self.op_args = op_args
+        self.returns = returns
+        self.indexes = {arg.arg_name: index for index, arg in enumerate(op_args)}
+        self.pyboost_function_name = "Pyboost_" + self.class_name
+        self.is_pyboost = is_pyboost
+        self.is_view = is_view
+        self.cpu = cpu
+        self.gpu = gpu
+        self.ascend = ascend
+        self.prim_init = prim_init
+        self.is_dispatch = is_dispatch
+
+    @staticmethod
+    def get_device_special_name(dispatch, gpu, cpu, ascend):
+        if 'GPU' in dispatch.keys():
+            gpu = dispatch['GPU']
+        if 'CPU' in dispatch.keys():
+            cpu = dispatch['CPU']
+        if 'Ascend' in dispatch.keys():
+            ascend = dispatch['Ascend']
+        return gpu, cpu, ascend
+
+    @staticmethod
+    def load_from_yaml(op_name, yaml):
+        """
+        load from yaml
+        :param op_name:
+        :param yaml:
+        :return:
+        """
+        if 'args' not in yaml.keys():
+            raise TypeError("op define need key 'args'")
+        args_dict = yaml.get('args')
+        op_args = []
+        default_str = 'default'
+        is_type_id = False
+        prim_init = False
+        for arg_name in args_dict.keys():
+            arg_dtype = args_dict[arg_name]['dtype']
+            if arg_dtype == 'TypeId':
+                arg_dtype = 'int'
+            default = None
+            as_init_arg = False
+            is_type_id = False
+            type_cast = []
+            if default_str in args_dict[arg_name]:
+                default = args_dict[arg_name][default_str]
+                as_init_arg = True
+            if 'prim_init' in args_dict[arg_name]:
+                prim_init = args_dict[arg_name]['prim_init']
+            if 'type_cast' in args_dict[arg_name]:
+                type_cast = [cast_type.strip() for cast_type in args_dict[arg_name]['type_cast'].split(',')]
+            arg_handler_key = 'arg_handler'
+            if arg_handler_key in args_dict[arg_name] and args_dict[arg_name][arg_handler_key] == 'dtype_to_type_id':
+                is_type_id = True
+            arg = Arg(arg_name, arg_dtype, type_cast, is_type_id, as_init_arg, default)
+            op_args.append(arg)
+        if 'returns' not in yaml.keys():
+            raise TypeError("op define need key 'returns'")
+
+        is_pyboost = False
+        is_dispatch = False
+        gpu = default_str
+        cpu = default_str
+        ascend = default_str
+        dispatch_key = 'dispatch'
+        if dispatch_key in yaml.keys():
+            is_dispatch = True
+            is_pyboost = yaml[dispatch_key].get('enable')
+            gpu, cpu, ascend = OpProto.get_device_special_name(yaml[dispatch_key], gpu, cpu, ascend)
+        return_dict = yaml['returns']
+        class_name = convert_python_func_name_to_c(op_name)
+        class_key = 'class'
+        if class_key in yaml.keys() and 'name' in yaml[class_key].keys():
+            class_name = yaml[class_key]['name']
+        return_args = []
+        for return_name in return_dict.keys():
+            inplace = ''
+            if 'inplace' in return_dict[return_name]:
+                inplace = return_dict[return_name]['inplace']
+            dtype = return_dict[return_name]['dtype']
+            arg = Arg(return_name, dtype, type_cast=[], inplace=inplace)
+            return_args.append(arg)
+        is_view = False
+        if 'view' in yaml.keys():
+            is_view = True
+        op_proto = OpProto(op_name, op_args, return_args, class_name,
+                           is_pyboost, is_view, cpu, gpu, ascend, prim_init, is_dispatch)
+        return op_proto

mindspore/ops_generate/pyboost_utils.py

@@ -0,0 +1,364 @@
+# 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.
+# ============================================================================
+"""pyboost utils."""
+
+import os
+import logging
+from gen_utils import safe_load_yaml
+
+
+def is_optional_param(op_arg):
+    if op_arg.as_init_arg and str(op_arg.default) == 'None':
+        return True
+    return False
+
+
+def is_tensor(op_arg):
+    if op_arg.arg_dtype == 'tensor':
+        return True
+    return False
+
+
+def is_tensor_list(op_arg):
+    if op_arg.arg_dtype in ['list[tensor]', 'tuple[tensor]']:
+        return True
+    return False
+
+
+def is_list(op_arg):
+    if op_arg.arg_dtype in ['tuple[int]', 'tuple[float]', 'tuple[bool]',
+                            'tuple[tensor]', 'list[int]', 'list[bool]', 'list[tensor]']:
+        return True
+    return False
+
+
+def get_index(index: int):
+    """
+    get index
+    :param index:
+    :return: str
+    """
+    index_map = {
+        0: 'kIndex0',
+        1: 'kIndex1',
+        2: 'kIndex2',
+        3: 'kIndex3',
+        4: 'kIndex4',
+        5: 'kIndex5',
+        6: 'kIndex6',
+        7: 'kIndex7',
+        8: 'kIndex8',
+        9: 'kIndex9',
+        10: 'kIndex10',
+    }
+    if index in index_map:
+        return index_map[index]
+    raise TypeError(f"""Unsupported index {index} for index map.""")
+
+
+def get_convert_type_str(dtype: str, optional):
+    """
+    Convert type
+    """
+    # add more type here
+    native_type_convert = {
+        'int': 'ToInt',
+        'float': 'ToFloat',
+        'bool': 'ToBool',
+        'number': 'ToScalar',
+        'tuple[int]': 'ToIntList<py::tuple>',
+        'tuple[float]': 'ToFloatList<py::tuple>',
+        'tuple[bool]': 'ToBoolList<py::tuple>',
+        'tuple[tensor]': 'ToTensorList<py::tuple>',
+        'list[int]': 'ToIntList<py::list>',
+        'list[float]': 'ToFloatList<py::list>',
+        'list[bool]': 'ToBoolList<py::list>',
+        'list[tensor]': 'ToTensorList<py::list>',
+        'tensor': 'ToTensor',
+        'str': 'ToString',
+        'type': 'ToDtype',
+    }
+    optional_type_convert = {
+        'int': 'ToIntOptional',
+        'float': 'ToFloatOptional',
+        'number': 'ToScalarOptional',
+        'tensor': 'ToTensorOptional',
+        'type': 'ToDtypeOptional',
+        'str': 'ToStringOptional',
+        'tuple[int]': 'ToIntListOptional<py::tuple>',
+        'tuple[float]': 'ToFloatListOptional<py::tuple>',
+        'tuple[bool]': 'ToBoolListOptional<py::tuple>',
+        'list[int]': 'ToIntListOptional<py::list>',
+        'list[float]': 'ToFloatListOptional<py::list>',
+        'list[bool]': 'ToBoolListOptional<py::list>',
+    }
+    if optional:
+        if dtype in optional_type_convert:
+            return optional_type_convert[dtype]
+        raise TypeError(f"""Unsupported convert optional type {dtype} for args.""")
+    if dtype in native_type_convert:
+        return native_type_convert[dtype]
+    raise TypeError(f"""Unsupported convert type {dtype} for args.""")
+
+
+def get_value_convert_type_str(dtype: str, optional):
+    """
+    Convert type
+    """
+    # add more type here
+    native_type_convert = {
+        'int': 'ToInt',
+        'float': 'ToFloat',
+        'bool': 'ToBool',
+        'number': 'ToScalar',
+        'tensor': 'ToTensor',
+        'str': 'ToString',
+        'type': 'ToDtype',
+        'tuple[int]': 'ToValueTuple',
+        'tuple[float]': 'ToValueTuple',
+        'tuple[bool]': 'ToValueTuple',
+        'tuple[tensor]': 'ToValueTuple',
+    }
+    optional_type_convert = {
+        'int': 'ToIntOptional',
+        'float': 'ToFloatOptional',
+        'number': 'ToScalarOptional',
+        'tensor': 'ToTensorOptional',
+        'type': 'ToDtypeOptional',
+        'str': 'ToStringOptional',
+        'tuple[int]': 'ToValueTupleOptional',
+        'tuple[float]': 'ToValueTupleOptional',
+        'tuple[bool]': 'ToValueTupleOptional',
+        'tuple[tensor]': 'ToValueTupleOptional',
+    }
+    if optional:
+        if dtype in optional_type_convert:
+            return optional_type_convert[dtype]
+        raise TypeError(f"""Unsupported convert optional type {dtype} for args.""")
+    if dtype in native_type_convert:
+        return native_type_convert[dtype]
+    raise TypeError(f"""Unsupported convert type {dtype} for args.""")
+
+
+def tuple_input_to_cpp_type(dtype: str):
+    """
+    dtype convert
+    :param dtype:
+    :return:
+    """
+    types_map = {
+        'tuple[int]': 'int64_t',
+        'tuple[float]': 'float',
+        'tuple[bool]': 'bool',
+        'tuple[str]': 'string',
+        'tuple[tensor]': 'TensorPtr',
+        'list[int]': 'int64_t',
+        'list[float]': 'float',
+        'list[bool]': 'bool',
+        'list[tensor]': 'TensorPtr',
+    }
+    return types_map.get(dtype)
+
+
+def number_input_to_cpp_type(dtype: str):
+    types_map = {
+        'int': 'int64_t',
+        'float': 'float',
+        'bool': 'bool',
+        'str': 'string'
+    }
+    return types_map.get(dtype)
+
+
+def get_input_dtype(dtype: str, optional):
+    """
+    Convert type
+    """
+    # add more type here
+    value_tuple = 'ValueTuplePtr'
+    type_convert = {
+        'int': 'Int64ImmPtr',
+        'float': 'FP32ImmPtr',
+        'bool': 'BoolImmPtr',
+        'number': 'ScalarPtr',
+        'str': 'StringImmPtr',
+        'tensor': 'TensorPtr',
+        'tuple[int]': value_tuple,
+        'tuple[float]': value_tuple,
+        'tuple[bool]': value_tuple,
+        'tuple[tensor]': value_tuple,
+        'list[int]': value_tuple,
+        'list[float]': value_tuple,
+        'list[bool]': value_tuple,
+        'list[tensor]': value_tuple,
+    }
+    value_tuple_optional = 'std::optional<ValueTuplePtr>'
+    optional_type_convert = {
+        'int': 'std::optional<Int64ImmPtr>',
+        'float': 'std::optional<FP32ImmPtr>',
+        'bool': 'std::optional<BoolImmPtr>',
+        'number': 'std::optional<ScalarPtr>',
+        'str': 'std::optional<StringImmPtr>',
+        'tensor': 'std::optional<TensorPtr>',
+        'tuple[int]': value_tuple_optional,
+        'tuple[float]': value_tuple_optional,
+        'tuple[bool]': value_tuple_optional,
+    }
+    if optional:
+        if dtype in optional_type_convert:
+            return optional_type_convert[dtype]
+        raise TypeError(f"""Unsupported convert optional type {dtype} for args.""")
+    if dtype in type_convert:
+        return type_convert[dtype]
+    raise TypeError(f"""Unsupported convert type {dtype} for args.""")
+
+
+def is_cube(class_name):
+    cube_set = {'Bmm', 'Baddbmm', 'MatMul'}
+    if class_name in cube_set:
+        return True
+    return False
+
+
+def get_return_type(dtype: str):
+    """
+    Convert type
+    """
+    # add more type here
+    type_convert = {
+        'tuple[tensor]': 'std::vector<tensor::TensorPtr>',
+        'list[tensor]': 'std::vector<tensor::TensorPtr>',
+        'tensor': 'tensor::TensorPtr',
+    }
+    if dtype in type_convert:
+        return type_convert[dtype]
+    raise TypeError(f"""Unsupported convert type {dtype} for args.""")
+
+
+def get_disable_flag(yaml_def):
+    """
+    Get class or functional api disable generate flag.
+    """
+    disable_flag = False
+    if yaml_def is not None:
+        item = yaml_def.get("disable")
+        if item is not None:
+            if item is not True and item is not False:
+                raise TypeError(f"The disable label for function should be True or False, but get {item}.")
+            disable_flag = item
+    return disable_flag
+
+
+def get_op_name(operator_name, class_def):
+    """
+    Get op name for python class Primitive or c++ OpDef name.
+    """
+    class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
+    if class_def is not None:
+        item = class_def.get("name")
+        if item is not None:
+            class_name = item
+    return class_name
+
+
+def get_pyboost_name(operator_name):
+    return 'pyboost_' + operator_name
+
+
+def convert_python_func_name_to_c(func_name: str) -> str:
+    return ''.join(word.capitalize() for word in func_name.split('_'))
+
+
+def get_const_number_convert(arg_name, op_arg):
+    cpp_type = number_input_to_cpp_type(op_arg.arg_dtype)
+    if op_arg.is_type_id:
+        return f"TypeId {arg_name}_imm = static_cast<TypeId>(GetValue<{cpp_type}>({arg_name}));\n"
+    return f"auto {arg_name}_imm = GetValue<{cpp_type}>({arg_name});\n"
+
+
+def get_tuple_input_convert(arg_name, arg_type):
+    """
+    convert tuple input.
+    :param arg_name:
+    :param arg_type:
+    :return:
+    """
+    cpp_type = tuple_input_to_cpp_type(arg_type)
+    return f"std::vector<{cpp_type}> {arg_name}_vector = ConvertValueTupleToVector<{cpp_type}>({arg_name});\n"
+
+
+def is_pyboost_enable(operator_data):
+    dispatch_key = 'dispatch'
+    if dispatch_key in operator_data.keys():
+        enable = operator_data[dispatch_key].get('enable')
+        if enable:
+            return True
+    return False
+
+
+def convert_types(inputs):
+    '''convert type to acl type'''
+    inputs_dtypes = {}
+    flag = False
+    for i in inputs:
+        inputs_dtypes[i] = inputs.get(i).get('dtype')
+        if inputs_dtypes[i] != 'tensor':
+            flag = True
+        if 'tuple' in inputs_dtypes[i]:
+            data_type = inputs_dtypes[i].split('[')[1].strip(']')
+            if data_type == 'tensor':
+                logging.info("Not support tuple[tensor] input.")
+            elif data_type == 'int':
+                inputs_dtypes[i] = 'std::vector<int64_t>'
+            elif data_type == 'float':
+                inputs_dtypes[i] = 'std::vector<float>'
+            elif data_type == 'bool':
+                inputs_dtypes[i] = 'std::vector<uint8_t>'
+            else:
+                logging.warning("Not support tuple[%s]] input.", data_type)
+        if inputs_dtypes[i] == 'number':
+            inputs_dtypes[i] = 'ScalarPtr'
+        if inputs_dtypes[i] == 'int':
+            inputs_dtypes[i] = 'int64_t'
+    return inputs_dtypes, flag
+
+
+def get_dtypes(op_yaml):
+    """get op inputs and outputs dtypes"""
+    inputs = op_yaml.get('args')
+    outputs = op_yaml.get('returns')
+    inputs_dtypes, flag_in = convert_types(inputs)
+    outputs_dtypes, flag_out = convert_types(outputs)
+    none_tensor_exist = (flag_in or flag_out)
+    return inputs_dtypes, outputs_dtypes, none_tensor_exist
+
+
+class AclnnUtils:
+    """
+    aclnn utils
+    """
+    work_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../../")
+    aclnn_map = safe_load_yaml(os.path.join(work_path, "./mindspore/python/mindspore/ops_generate/aclnn_config.yaml"))
+
+    @staticmethod
+    def get_aclnn_interface(class_name):
+        """
+        get aclnn interface name.
+        :param class_name:
+        :return:
+        """
+        if class_name in AclnnUtils.aclnn_map.keys():
+            return AclnnUtils.aclnn_map[class_name]
+        return "aclnn" + class_name