mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops_generate/__init__.py

@@ -19,9 +19,4 @@ Primitive operator classes and operator functional.
 A collection of operators to build neural networks or to compute functions.
 """
 
-from . import (arg_dtype_cast, arg_handler)
-
-from .arg_dtype_cast import *
-from .arg_handler import *
-
 __all__ = []

mindspore/ops_generate/aclnn/aclnn_kernel_register_auto_cc_generator.py

@@ -0,0 +1,135 @@
+# Copyright 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.
+# ============================================================================
+"""
+Generates C++ registration code for ACL NN kernels based on operator prototypes.
+"""
+
+import os
+import logging
+import re
+
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+from common.base_generator import BaseGenerator
+from pyboost import pyboost_utils
+from aclnn.gen_aclnn_implement import gen_aclnn_kernel
+from resources.resource_list import ResourceType
+
+
+ACLNN_REG_CODE = """
+#include "$ops_gen_kernel_path/ascend/opapi/aclnn_kernel_mod.h"
+
+namespace mindspore {
+namespace kernel {
+
+$aclnn_reg_code
+}  // namespace kernel
+}  // namespace mindspore
+"""
+
+
+class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
+    """Generates ACL NN kernel registration code for Ascend devices."""
+
+    def __init__(self):
+        self.aclnn_reg_code_template = template.Template(ACLNN_REG_CODE)
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates registration code for ACL NN kernels and saves it to a file.
+
+        Args:
+            work_path (str): The directory to save the generated file.
+            op_protos (list): List of operator prototypes.
+
+        Returns:
+            None
+        """
+        aclnn_reg_code = []
+        for op_proto in op_protos:
+            if not op_proto.op_dispatch or not op_proto.op_dispatch.enable:
+                continue
+            # KernelMod is provided by yaml, don't auto generate it.
+            if op_proto.op_dispatch.ascend != 'default':
+                continue
+            if check_op_registed(op_proto.op_name, True):
+                logging.warning(
+                    "Kernel {%s} is already registered.", op_proto.op_name)
+                continue
+            _, _, none_tensor_exist = pyboost_utils.get_dtypes(op_proto)
+            if none_tensor_exist:
+                # gen operator aclnn kernel c++ files
+                gen_aclnn_kernel(op_proto, auto=True)
+                continue
+
+            class_name = op_proto.op_class.name
+            inputs_outputs_num = len(op_proto.op_args) + \
+                len(op_proto.op_returns)
+            aclnn_name = pyboost_utils.AclnnUtils.get_aclnn_interface(
+                class_name)
+            aclnn_reg_code.append(
+                f"MS_ACLNN_COMMON_KERNEL_FACTORY_REG({class_name}, {aclnn_name}, {inputs_outputs_num});\n")
+
+        reg_code = self.aclnn_reg_code_template.replace(ops_gen_kernel_path=K.MS_OPS_KERNEL_PATH,
+                                                        aclnn_reg_code=aclnn_reg_code)
+        res_str = template.CC_LICENSE_STR + reg_code
+
+        save_path = os.path.join(
+            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/opapi/auto_generate")
+        file_name = "aclnn_kernel_register_auto.cc"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+
+def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+    '''get registered ops by search files'''
+    # default search in 'ops/kernel/ascend/opapi/'
+    search_path = os.path.join(K.WORK_DIR, file_path)
+    ret = []
+    try:
+        for root_path, _, files in os.walk(search_path):
+            for file_name in files:
+                if file_name == 'aclnn_kernel_register_auto.cc':
+                    continue
+                with open(os.path.join(root_path, file_name), "r") as f:
+                    file_context = f.read()
+                    search_re = re.search(
+                        r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
+                    if search_re:
+                        ret.append(search_re.group())
+    except OSError:
+        logging.warning("Something wrong in check op registered.")
+        return ret
+    return ret
+
+
+registed_ops = get_registed_ops()
+manual_registed_ops = get_registed_ops(
+    f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+
+
+def check_op_registed(op_name, manual=False):
+    '''if op already registered return true'''
+    class_name = ''.join(word.capitalize() for word in op_name.split('_'))
+    return (class_name in manual_registed_ops) if manual else (class_name in registed_ops)
+
+
+def generate_aclnn_reg_file(resource_mgr):
+    """
+    Generate nnacl kernelmod register
+    """
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    generator = AclnnKernelRegisterAutoCcGenerator()
+    generator.generate(K.WORK_DIR, op_protos)

mindspore/ops_generate/aclnn/gen_aclnn_implement.py

@@ -0,0 +1,257 @@
+# 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.
+# ============================================================================
+"""
+Generate aclnn kernelmod or call func by input name in ops.yaml
+"""
+import argparse
+import os
+import re
+import pathlib
+import logging
+import common.gen_utils as gen_utils
+import common.template as template
+import common.gen_constants as K
+from common.op_proto import OpProto
+from common.gen_constants import MS_OPS_KERNEL_PATH
+from pyboost.pyboost_utils import AclnnUtils, get_dtypes
+
+auto_gen = ''
+
+
+def gen_h(kernelmod_name, aclnn_name, op_proto, kernelmod_h_path, need_update_shape):
+    """generate h files"""
+    op_name = op_proto.op_name
+    update_shape = template.UPDATE_OUTPUT_SHAPE_AND_SIZE
+    if not need_update_shape:
+        update_shape = "\n  "
+
+    file_path = kernelmod_h_path + ".h"
+    aclnn_kernel_h_str = template.ACLNN_KERNEL_H_TEMPLATE.replace(aclnn_name=aclnn_name,
+                                                                  op_name=op_name.upper(),
+                                                                  auto_gen=auto_gen.upper(),
+                                                                  kernelmod_name=kernelmod_name,
+                                                                  update_shape=update_shape,
+                                                                  ops_kernel_path=MS_OPS_KERNEL_PATH)
+    gen_utils.save_file(os.path.dirname(file_path), os.path.basename(file_path), aclnn_kernel_h_str)
+
+
+def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_shape):
+    """generate cc files"""
+    op_name = op_proto.op_name
+    tuple_tensor_not_supported = template.TUPLE_TENSOR_NOT_SUPPORTED.replace(
+        op_name=op_name)
+    input_templete = '\n  '
+    inputs = ''
+    input_dtypes, output_dtypes, _ = get_dtypes(op_proto)
+    for idx, n in enumerate(input_dtypes):
+        input_name = "inputs[kIndex" + str(idx) + "], "
+        dtype = input_dtypes.get(n)
+        if dtype != 'tensor':
+            if dtype == 'int':
+                dtype = 'int64_t'
+            input_templete += "  auto {} = device::ascend::ConvertKernelTensor<{}>(inputs[kIndex{}]);\n".format(
+                n.arg_name, dtype, idx)
+            input_name = n.arg_name + ", "
+        if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
+            raise NotImplementedError(tuple_tensor_not_supported)
+        inputs += input_name
+    input_templete = '' if input_templete == '\n  ' else input_templete
+    for idx, n in enumerate(output_dtypes):
+        output_name = "outputs[kIndex" + str(idx) + "], "
+        dtype = output_dtypes.get(n)
+        if dtype != 'tensor':
+            if dtype == 'int':
+                dtype = 'int64_t'
+            input_templete += "  auto {} = device::ascend::ConvertKernelTensor<{}>(outputs[kIndex{}]);\n".format(
+                n.arg_name, dtype, idx)
+            output_name = n.arg_name + ", "
+        if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
+            raise NotImplementedError(tuple_tensor_not_supported)
+        inputs += output_name
+    inputs = inputs[:-2]
+
+    update_shape = template.update_output_shape_and_size_template.replace(
+        kernelmod_name=kernelmod_name)
+    if not need_update_shape:
+        update_shape = ""
+
+    file_path = kernelmod_cc_path + ".cc"
+    aclnn_kernel_cc_str = template.ACLNN_KERNEL_CC_TEMPLATE.replace(kernelmod_name=kernelmod_name,
+                                                                    input_templete=input_templete,
+                                                                    inputs=inputs,
+                                                                    update_shape=update_shape,
+                                                                    class_name=aclnn_name,
+                                                                    auto_gen_path=MS_OPS_KERNEL_PATH,
+                                                                    op_name=op_name,
+                                                                    auto_gen=auto_gen) + "    "
+    gen_utils.save_file(os.path.dirname(file_path), os.path.basename(file_path), aclnn_kernel_cc_str)
+
+
+def generate(kernelmod_name, class_name, op_proto, h_and_cc, need_update_shape):
+    """generate cc and h files"""
+    aclnn_name = AclnnUtils.get_aclnn_interface(class_name)
+    gen_h(kernelmod_name, aclnn_name, op_proto, h_and_cc, need_update_shape)
+    gen_cc(kernelmod_name, class_name, op_proto, h_and_cc, need_update_shape)
+
+
+def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
+    """gen_aclnn_kernel function"""
+    op_name = op_proto.op_name
+    skip_aclnn_list = {"slice", "expand_dims", "squeeze", "split", "generator"}
+    if op_name in skip_aclnn_list:
+        logging.warning(
+            "Operator {%s} has no aclnn interface, no aclnn kernel will be generated.", op_name)
+        return
+    if check_op_registed(op_proto.op_name) and not auto:
+        logging.warning("Kernel {%s} is already registered.", op_name)
+        return
+
+    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
+    # merge inner ops
+    dispatch = op_proto.op_dispatch
+    aclnn_name = ''.join(word.capitalize() for word in op_name.split('_'))
+    kernelmod_name = op_proto.op_dispatch.ascend
+    if not dispatch or not op_proto.op_dispatch.enable:
+        raise ValueError(
+            "Op {} is not enabled dispatch, please check.".format(op_name))
+    global auto_gen
+    if auto:
+        auto_gen = "_auto_gen"
+        kernelmod_name = aclnn_name + "Ascend"
+        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_auto_gen/'
+        pathlib.Path(os.path.join(K.WORK_DIR, aclnn_path)
+                     ).mkdir(parents=True, exist_ok=True)
+    if dispatch.ascend is None:
+        raise ValueError("KernelMod {} is auto generated. If need achieve it, "
+                         "please provide the KernelMod name in dispatch.".format(op_name))
+    op_class = op_proto.op_class
+    if op_class is not None and op_class.name is not None:
+        aclnn_name = op_class.name
+    kernelmod_h_and_cc_path = os.path.join(
+        K.WORK_DIR, aclnn_path + '{}_aclnn_kernel'.format(op_name))
+    generate(kernelmod_name, aclnn_name, op_proto,
+             kernelmod_h_and_cc_path, need_update_shape)
+
+
+def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+    '''get registered ops by search files'''
+    # default search in 'ops/kernel/ascend/opapi/'
+    search_path = os.path.join(K.WORK_DIR, file_path)
+    ret = []
+    try:
+        for root_path, _, files in os.walk(search_path):
+            for file_name in files:
+                with open(os.path.join(root_path, file_name), "r") as f:
+                    file_context = f.read()
+                    search_re = re.search(
+                        r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
+                    if search_re:
+                        ret.append(search_re.group())
+    except OSError:
+        logging.warning("Something wrong in check op registered.")
+        return ret
+    return ret
+
+
+registed_ops = get_registed_ops()
+manual_registed_ops = get_registed_ops(
+    f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+
+
+def check_op_registed(op_name, manual=False):
+    '''if op already registered return true'''
+    class_name = ''.join(word.capitalize() for word in op_name.split('_'))
+    return (class_name in manual_registed_ops) if manual else (class_name in registed_ops)
+
+
+def generate_aclnn_reg_code(yaml_data):
+    """generate aclnn register code"""
+    ops_yaml_path = os.path.join(K.WORK_DIR, K.PY_OPS_GEN_PATH, "ops.yaml")
+    yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
+
+    reg_code = f"""
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
+
+namespace mindspore {{
+namespace kernel {{
+"""
+    for operator_name, operator_data in yaml_data.items():
+        dispatch = operator_data.get("dispatch")
+        if not dispatch or not dispatch.get("enable"):
+            continue
+        Ascend = dispatch.get("Ascend")
+        if Ascend is not None:  # KernelMod is provided by yaml, don't auto generate it.
+            continue
+        if check_op_registed(operator_name):
+            logging.warning(
+                "Kernel {%s} is already registered.", operator_name)
+            continue
+        _, _, none_tensor_exist = get_dtypes(operator_data)
+        if none_tensor_exist:
+            gen_aclnn_kernel(operator_name, yaml_str, auto=True)
+            continue
+        class_name = ''.join(word.capitalize()
+                             for word in operator_name.split('_'))
+        op_class = operator_data.get("class")
+        if op_class and op_class.get("name") is not None:
+            class_name = op_class.get("name")
+        inputs_outputs_num = len(operator_data.get(
+            "args")) + len(operator_data.get("returns"))
+        aclnn_name = AclnnUtils.get_aclnn_interface(class_name)
+        reg_code += f"""
+MS_ACLNN_COMMON_KERNEL_FACTORY_REG({class_name}, {aclnn_name}, {inputs_outputs_num});"""
+    reg_code += f"""
+}}  // namespace kernel
+}}  // namespace mindspore
+"""
+    return reg_code
+
+
+def generate_aclnn_reg_file(work_path, yaml_str):
+    """
+    Generate nnacl kernelmod register
+    """
+    tmp_register_file = work_path + \
+        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/tmp_aclnn_kernel_register.cc'
+    register_file = work_path + \
+        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
+    reg_code = generate_aclnn_reg_code(yaml_str)
+    gen_utils.save_file(
+        os.path.dirname(tmp_register_file), os.path.basename(tmp_register_file), gen_utils.cc_license_str + reg_code)
+    gen_utils.check_change_and_replace_file(register_file, tmp_register_file)
+
+
+def main(op_name, need_update_shape):
+    '''main func'''
+    gen_aclnn_kernel(op_name, need_update_shape)
+
+
+parser = argparse.ArgumentParser(description="Generate aclnn KernelMod.")
+parser.add_argument('-n', '--name', type=str, default=None,
+                    help='Kernel name in yaml.')
+parser.add_argument('-d', '--need_update_shape', type=bool, default=False,
+                    help="Some kernel like:unique need update shape and size after launch. Default: False")
+options, _ = parser.parse_known_args()
+
+if __name__ == "__main__":
+    try:
+        name = options.name
+        if name is None:
+            raise ValueError(
+                "Please provide op name to generate aclnn kernelmod.")
+        is_need_update_shape = options.need_update_shape
+        main(name, is_need_update_shape)
+    except Exception as e:  # pylint: disable=W0703
+        logging.exception("Generate aclnn kernelmod failed, err info: %s", e)

mindspore/ops_generate/api/add_tensor_docs_generator.py

@@ -0,0 +1,56 @@
+# Copyright 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.
+# ============================================================================
+"""
+Generates mindspore/common/_tensor_docs.py that attaches docs to tensor func APIs when import mindspore
+"""
+
+import os
+import common.gen_constants as K
+from common.gen_utils import save_file, safe_load_yaml_from_dir
+import common.template as template
+from common.template import Template
+from common.base_generator import BaseGenerator
+
+
+class AddTensorDocsGenerator(BaseGenerator):
+    """
+    This class is responsible for generating a helper file that enable users to view the docstrings of Tensor func APIs.
+    """
+
+    def __init__(self):
+        self.ADD_TENSOR_DOCS_TEMPLATE = template.ADD_TENSOR_DOCS_TEMPLATE
+        self.attach_single_docstr_template = Template('attach_docstr("${api_name}", r"""${docstr}""")')
+        self.tensor_method_doc_yaml_dir_path = os.path.join(K.WORK_DIR, K.MS_TENSOR_METHOD_DOC_YAML_PATH)
+
+    def generate(self):
+        """
+        Generates the content for the helper file and saves it to the specified path.
+
+        Args:
+            work_path (str): The directory where the generated file will be saved.
+            tensor_docs_data (dict): A dict mapping from Tensor func API names to their docstrings.
+
+        Returns:
+            None
+        """
+        add_doc_statements = []
+        tensor_docs_data = safe_load_yaml_from_dir(self.tensor_method_doc_yaml_dir_path)
+        for api_name, tensor_doc in tensor_docs_data.items():
+            single_add_doc_statement = self.attach_single_docstr_template.replace(api_name=api_name,
+                                                                                  docstr=tensor_doc['description'])
+            single_add_doc_statement += template.NEW_LINE
+            add_doc_statements.append(single_add_doc_statement)
+        _tensor_docs_py_str = self.ADD_TENSOR_DOCS_TEMPLATE.replace(add_doc_statements=add_doc_statements)
+        save_file(os.path.join(K.WORK_DIR, K.ADD_TENSOR_DOCS_PY_PATH), "_tensor_docs.py", _tensor_docs_py_str)

mindspore/ops_generate/api/cpp_create_prim_instance_helper_generator.py

@@ -0,0 +1,105 @@
+# Copyright 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.
+# ============================================================================
+"""
+Generates C++ helper files for primitive instance creation based on operator metadata.
+"""
+
+import os
+
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+from common.base_generator import BaseGenerator
+from pyboost import pyboost_utils
+
+
+class CppCreatePrimInstanceHelperGenerator(BaseGenerator):
+    """
+    This class is responsible for generating a helper file that contains
+    operation labels and default values for creating primitive instances in C++.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with templates for operation labels and default values.
+        """
+        self.op_labels_template = template.op_labels_template
+        self.op_args_default_value_template = template.arg_default_value
+        self.op_label_template = template.Template("""    "$op_name": {$op_label_body},\n""")
+        self.op_arg_default_val_template = template.Template("""    "$op_name": {$op_arg_default_value},\n""")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the content for the helper file and saves it to the specified path.
+
+        Args:
+            work_path (str): The directory where the generated file will be saved.
+            op_protos (list): A list of operation prototypes to generate content for.
+
+        Returns:
+            None
+        """
+        py_arg_default = self.generate_op_arg_default_value(op_protos)
+        py_labels = self.generate_op_labels(op_protos)
+        res_str = (template.PY_LICENSE_STR + py_arg_default + py_labels)
+
+        save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
+        file_name = "cpp_create_prim_instance_helper.py"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+    def generate_op_labels(self, op_protos):
+        """
+        Generates a string containing labels for each operation.
+
+        Args:
+            op_protos (list): A list of operation prototypes.
+
+        Returns:
+            str: A string representing the labels in the specified format.
+        """
+        gen_label_list = []
+        for op_proto in op_protos:
+            labels = op_proto.op_labels
+            if labels is not None:
+                op_name = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+                op_label_list = [f"\"{name}\": {value}" for name, value in labels.items()]
+                gen_label_list.append(self.op_label_template.replace(op_name=op_name, op_label_body=op_label_list))
+
+        return self.op_labels_template.replace(gen_label_py=gen_label_list)
+
+    def generate_op_arg_default_value(self, op_protos):
+        """
+        Generates a string containing default values for each operation's arguments.
+
+        Args:
+            op_protos (list): A list of operation prototypes.
+
+        Returns:
+            str: A string representing the default argument values in the specified format.
+        """
+        gen_default_list = []
+        for op_proto in op_protos:
+            arg_default_dict = {}
+            for op_arg in op_proto.op_args:
+                arg_default = op_arg.default
+                if arg_default is not None:
+                    arg_default_dict[op_arg.arg_name] = arg_default
+            if arg_default_dict:
+                op_name = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+                arg_default_list = [f"\"{key}\": {value}" for key, value in arg_default_dict.items()]
+                gen_default_list.append(self.op_arg_default_val_template.replace(op_name=op_name,
+                                                                                 op_arg_default_value=arg_default_list))
+
+        return self.op_args_default_value_template.replace(gen_default_py=gen_default_list)