mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops_generate/op_def/ops_name_h_generator.py

@@ -0,0 +1,83 @@
+# 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.
+# ============================================================================
+"""
+Module for generating C++ header files with operator name definitions.
+
+This module defines the `OpsNameHGenerator` class, which produces C++ code to define
+constants for operator names based on given prototypes.
+"""
+
+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
+
+
+OP_NAME_OP_DEF = """
+#ifndef MINDSPORE_CORE_OP_NAME_${suffix}_H_
+#define MINDSPORE_CORE_OP_NAME_${suffix}_H_
+
+namespace mindspore::ops {
+$ops_namespace_body
+}  // namespace mindspore::ops
+
+#endif  // MINDSPORE_CORE_OP_NAME_${suffix}_H_
+"""
+
+
+class OpsNameHGenerator(BaseGenerator):
+    """
+    Class for generating C++ header files containing operator name constants.
+    """
+
+    def __init__(self):
+        """
+        Initializes the OpsNameHGenerator instance.
+        """
+        self.op_name_op_def_template = template.Template(OP_NAME_OP_DEF)
+        self.op_def_body_template = template.Template("""constexpr auto kName${k_name_op} = "${k_name_op}";\n""")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates C++ code for operator names and saves it to a header file.
+
+        Args:
+            work_path (str): The directory to save the generated files.
+            op_protos (list): A list of operator prototypes.
+
+        Returns:
+            None
+        """
+        import os
+        import collections
+
+        op_name_gen_dict = collections.defaultdict(list)
+
+        for op_proto in op_protos:
+            k_name_op = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            first_char = k_name_op[0].lower()
+            op_name_gen_dict[first_char].append(self.op_def_body_template.replace(k_name_op=k_name_op))
+
+        for first_char, op_name_gen_list in op_name_gen_dict.items():
+            op_name_code = self.op_name_op_def_template.replace(ops_namespace_body=op_name_gen_list,
+                                                                suffix=first_char.upper())
+            op_name_code = template.CC_LICENSE_STR + op_name_code
+
+            save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+            file_name = f"gen_ops_name_{first_char}.h"
+            gen_utils.save_file(save_path, file_name, op_name_code)

mindspore/ops_generate/op_def/ops_primitive_h_generator.py

@@ -0,0 +1,125 @@
+# 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.
+# ============================================================================
+"""
+Module for generating C++ header files for operator primitives.
+
+This module defines the `OpsPrimitiveHGenerator` class, which creates C++ header files
+containing definitions for operator primitives based on provided operator prototypes.
+"""
+
+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
+
+
+OP_PRIM_OP_DEF_H = """
+#ifndef MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
+#define MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
+
+#include "ir/primitive.h"
+#include "mindapi/base/macros.h"
+#include "$auto_gen_path/gen_ops_name_${suffix}.h"
+
+namespace mindspore::prim {
+$ops_prim_gen
+}  // namespace mindspore::prim
+#endif  // MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
+"""
+
+
+OP_PRIM_OP_DEF_CC = """
+
+#include "$auto_gen_path/gen_ops_primitive_${suffix}.h"
+
+#include <memory>
+
+namespace mindspore::prim {
+$ops_prim_gen
+}  // namespace mindspore::prim
+
+"""
+
+
+class OpsPrimitiveHGenerator(BaseGenerator):
+    """
+    This class generates the header file for operator primitives.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with templates for operator primitive definitions.
+        """
+        self.op_prim_op_def_template = template.Template(OP_PRIM_OP_DEF_H)
+        self.op_prim_op_def_cc_template = template.Template(OP_PRIM_OP_DEF_CC)
+        self.op_def_h_template = template.Template(
+            "OPS_API extern const PrimitivePtr kPrim${k_name_op};\n")
+        self.op_def_template = template.Template(
+            "const PrimitivePtr kPrim${k_name_op} = std::make_shared<Primitive>(ops::kName${k_name_op});\n")
+        self.op_def_rw_template = template.Template(
+            "const PrimitivePtr kPrim${k_name_op} = std::make_shared<Primitive>(ops::kName${k_name_op}, "
+            "true, kPrimTypeBuiltIn, true);\n")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the header file content for operator primitives and saves it.
+
+        Args:
+            work_path (str): The directory to save the generated files.
+            op_protos (list): A list of operator prototypes.
+
+        Returns:
+            None
+
+        The method generates the content of the header file for each operator primitive
+        defined in the 'op_protos' list and saves it to the specified work path.
+        """
+        import os
+        import collections
+        ops_prim_gen_dict = collections.defaultdict(list)
+        ops_prim_cc_gen_dict = collections.defaultdict(list)
+
+        for op_proto in op_protos:
+            k_name_op = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            first_char = k_name_op[0].lower()
+            if op_proto.op_args_signature:
+                if op_proto.op_args_signature.rw_write:
+                    ops_prim_gen_dict[first_char].append(self.op_def_h_template.replace(k_name_op=k_name_op))
+                    ops_prim_cc_gen_dict[first_char].append(self.op_def_rw_template.replace(k_name_op=k_name_op))
+                    continue
+
+            ops_prim_gen_dict[first_char].append(self.op_def_h_template.replace(k_name_op=k_name_op))
+            ops_prim_cc_gen_dict[first_char].append(self.op_def_template.replace(k_name_op=k_name_op))
+
+        for first_char, ops_prim_gen_list in ops_prim_gen_dict.items():
+            op_prim_op_def = self.op_prim_op_def_template.replace(auto_gen_path=K.MS_OP_DEF_AUTO_GENERATE_PATH,
+                                                                  ops_prim_gen=ops_prim_gen_list, suffix=first_char)
+            res_str = template.CC_LICENSE_STR + op_prim_op_def
+
+            save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+            file_name = f"gen_ops_primitive_{first_char}.h"
+            gen_utils.save_file(save_path, file_name, res_str)
+
+        for first_char, ops_prim_gen_list in ops_prim_cc_gen_dict.items():
+            op_prim_op_def = self.op_prim_op_def_cc_template.replace(auto_gen_path=K.MS_OP_DEF_AUTO_GENERATE_PATH,
+                                                                     ops_prim_gen=ops_prim_gen_list, suffix=first_char)
+            res_str = template.CC_LICENSE_STR + op_prim_op_def
+
+            save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+            file_name = f"gen_ops_primitive_{first_char}.cc"
+            gen_utils.save_file(save_path, file_name, res_str)

mindspore/ops_generate/op_def_py/gen_op_def_py.py

@@ -0,0 +1,47 @@
+# Copyright 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 definition python files.
+"""
+import os
+import shutil
+
+from op_def_py.op_prim_py_generator import OpPrimPyGenerator
+from op_def_py.op_def_py_generator import OpDefPyGenerator
+from resources.resource_list import ResourceType
+from common import gen_constants as K
+
+
+def generate_ops_prim_file(work_path, op_protos, doc_dict, file_pre):
+    generator = OpPrimPyGenerator()
+    generator.generate(work_path, op_protos, doc_dict, file_pre)
+
+
+def generate_ops_def_file(work_path, os_protos, doc_dict, file_pre):
+    generator = OpDefPyGenerator()
+    generator.generate(work_path, os_protos, doc_dict, file_pre)
+
+
+def generate_ops_py_files(resource_mgr, file_pre='gen'):
+    """
+    Generate ops python file from yaml.
+    """
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    op_protos += resource_mgr.get_resource(ResourceType.FUNC_OP_PROTO)
+    doc_dict = resource_mgr.get_resource(ResourceType.OP_DOC_YAML)
+    generate_ops_prim_file(K.WORK_DIR, op_protos, doc_dict, file_pre)
+    generate_ops_def_file(K.WORK_DIR, op_protos, doc_dict, file_pre)
+    shutil.copy(os.path.join(K.WORK_DIR, K.PY_OPS_GEN_PATH, 'ops_auto_generate_init.txt'),
+                os.path.join(K.WORK_DIR, K.PY_AUTO_GEN_PATH, "__init__.py"))

mindspore/ops_generate/op_def_py/op_def_py_generator.py

@@ -0,0 +1,132 @@
+# 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.
+# ============================================================================
+"""
+Generate Python operator definitions.
+"""
+
+import os
+
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+
+# refactored
+import common.template as template
+
+from common.base_generator import BaseGenerator
+
+
+class OpDefPyGenerator(BaseGenerator):
+    """
+    This class is responsible for generating Python operator definitions based on provided
+    operation prototypes and documentation strings. It generates the code for the operator
+    functions that can be used in Python scripts to interact with the underlying operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with the template for primitive class definitions.
+        """
+        self.op_prim_class_define_template = template.OP_PRIM_CLASS_DEFINE_TEMPLATE
+
+    def generate(self, work_path, op_protos, doc_dict, file_pre):
+        """
+        Generates Python code for operator definitions and saves it to a file.
+
+        Args:
+            work_path (str): The base directory where the generated files will be saved.
+            op_protos (list): A list of operation prototypes to generate Python code for.
+            doc_dict (dict): A dictionary containing documentation strings for the operators.
+            file_pre (str): The prefix for the generated Python files.
+
+        Returns:
+            None
+
+        The generated Python code includes function definitions for each operator, using
+        the provided operation prototypes and documentation. It saves the code in a file
+        with the given prefix in the specified work path.
+        """
+        gen_py = "\n"
+        for op_proto in op_protos:
+            if op_proto.op_function.disable:
+                continue
+
+            class_name = op_proto.op_class.name
+            func_name = op_proto.op_function.name
+            op_args = op_proto.op_args
+            func_args, prim_call_args, prim_init_args = self.get_op_args(op_args)
+
+            func_code = "\n"
+            description = gen_utils.get_op_description(op_proto.op_name, doc_dict)
+            func_formal_param = ", ".join(arg_name for arg_name in func_args)
+            op_prim_input_args = ", ".join(arg_name for arg_name in prim_call_args)
+            if prim_init_args:
+                if op_proto.op_dispatch and op_proto.op_dispatch.enable:
+                    func_impl_input_args = ", ".join(op_args.arg_name for op_args in op_args)
+                    func_code += f"def {func_name}({func_formal_param}):\n"
+                    func_code += f"{description}"
+                    func_code += f"    return {op_proto.op_name}_impl({func_impl_input_args})\n"
+                else:
+                    cache_prim_input_args = ", ".join(arg_name for arg_name in prim_init_args)
+                    func_code += f"def {func_name}({func_formal_param}):\n"
+                    func_code += f"{description}"
+                    func_code += f"    {op_proto.op_name}_op = _get_cache_prim({class_name})({cache_prim_input_args})\n"
+                    func_code += f"    return {op_proto.op_name}_op({op_prim_input_args})\n"
+            else:
+                if op_proto.op_class and op_proto.op_class.disable:
+                    gen_py += f"{op_proto.op_name}_op={class_name}()\n"
+                func_code += f"def {func_name}({func_formal_param}):\n"
+                func_code += f"{description}"
+                func_code += f"    return {op_proto.op_name}_op({op_prim_input_args})\n"
+
+            gen_py += func_code
+            gen_py += "\n"
+
+        res_str = template.PY_LICENSE_STR + \
+            template.OPS_PY_DEF_HEADER + gen_py[:-len(template.NEW_LINE)]
+        save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
+        file_name = f"{file_pre}_ops_def.py"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+    def get_op_args(self, op_args):
+        """
+        Processes the list of OpArg objects to categorize them into function arguments,
+        primitive initialization arguments, and primitive call arguments.
+
+        Args:
+            op_args (list): A list of OpArg objects representing the arguments of an operator.
+
+        Returns:
+            tuple: A tuple containing three lists:
+                - func_args (list): Names of the function arguments.
+                - prim_call_args (list): Names of the primitive call arguments.
+                - prim_init_args (list): Names of the primitive initialization arguments.
+        """
+        func_args = []
+        prim_init_args = []
+        prim_call_args = []
+        for op_arg in op_args:
+            # step1: Process function args.
+            if op_arg.default is None:
+                func_args.append(f"""{op_arg.arg_name}""")
+            else:
+                func_args.append(f"""{op_arg.arg_name}={op_arg.default}""")
+
+            # step2: Process primitive object init args.
+            if op_arg.is_prim_init:
+                prim_init_args.append(op_arg.arg_name)
+            # step3: Process primitive object call args.
+            else:
+                prim_call_args.append(op_arg.arg_name)
+        return func_args, prim_call_args, prim_init_args