mindspore 2.4.1__cp310-cp310-win_amd64.whl → 2.5.0__cp310-cp310-win_amd64.whl

mindspore/ops_generate/aclnn_kernel_register_auto_cc_generator.py

@@ -0,0 +1,110 @@
+# 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 gen_constants as K
+import gen_utils
+import pyboost_utils
+
+import template
+
+from base_generator import BaseGenerator
+from gen_aclnn_implement import gen_aclnn_kernel
+
+
+class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
+    """Generates ACL NN kernel registration code for Ascend devices."""
+
+    def __init__(self):
+        self.aclnn_reg_code_template = template.Template(K.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
+            if op_proto.op_dispatch.ascend != 'default':  # KernelMod is provided by yaml, don't auto generate it.
+                continue
+            if check_op_registed(op_proto.op_name):
+                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/'
+    current_path = os.path.dirname(os.path.realpath(__file__))
+    work_path = os.path.join(current_path, '../../../../')
+    search_path = os.path.join(work_path, 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)

mindspore/ops_generate/add_tensor_docs_generator.py

@@ -0,0 +1,54 @@
+# 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 gen_constants as K
+from gen_utils import save_file
+import template
+from template import Template
+from 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}""")')
+
+    def generate(self, work_path, tensor_docs_data):
+        """
+        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 = []
+        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(work_path, K.ADD_TENSOR_DOCS_PY_PATH), "_tensor_docs.py", _tensor_docs_py_str)

mindspore/ops_generate/arg_handler.py

@@ -116,67 +116,6 @@ def to_2d_paddings(op_name, arg_name, pad):
     raise ValueError(arg_invalid_info(op_name, arg_name, pad))
 
 
-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))
-
-
 def generator_handler(op_name, arg_name, inputs):
     """
     convert constant value in tuple to tensor

mindspore/ops_generate/auto_grad_impl_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.
+# ============================================================================
+"""
+This module provides a generator class for creating C++ implementation files for AutoGrad functionality.
+"""
+
+import os
+
+import template
+from template import Template
+import gen_constants as K
+from gen_utils import save_file
+from base_generator import BaseGenerator
+from pyboost_utils import is_optional_param, get_input_dtype, is_op_multi_output
+
+
+class AutoGradImplGenerator(BaseGenerator):
+    """
+    Generates C++ implementation files for the AutoGrad functionality based on operator prototypes.
+    """
+
+    def __init__(self):
+        """
+        Initialize the AutoGrad implementation generator with templates for code generation.
+        """
+        self.AUTO_GRAD_IMPL_CC_TEMPLATE = template.AUTO_GRAD_IMPL_CC_TEMPLATE
+        self.DO_GRAD_FUNCTION_BODY_TEMPLATE = template.DO_GRAD_FUNCTION_BODY_TEMPLATE
+        self.auto_grad_reg_template = Template("const_cast<kernel::pyboost::${class_name}GradFunc&>(" + \
+                                               "kernel::pyboost::AutoGradFactory::Get()." + \
+                                               "ops_auto_grad_registers().${class_name}GradFuncObj) = " + \
+                                               "kernel::pyboost::${class_name}GradFunc(DoGrad${class_name});")
+        self.do_grad_op_args_with_type = Template(
+            "const kernel::pyboost::OpPtr &op, ${input_args_with_type}"
+        )
+
+    def generate(self, work_path, op_protos):
+        """
+        Generate the AutoGrad implementation file.
+
+        Args:
+            work_path (str): The directory where the generated file should be saved.
+            op_protos (list): A list of operator prototypes used to generate the implementation.
+        """
+        auto_grad_reg_list = []
+        do_grad_op_list = []
+        for op_proto in op_protos:
+            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+                continue
+            auto_grad_reg_list.append(self.auto_grad_reg_template.replace(class_name=op_proto.op_class.name))
+            do_grad_op_list.append(self._get_single_do_grad_op(op_proto))
+        pyboost_func_h_str = self.AUTO_GRAD_IMPL_CC_TEMPLATE.replace(do_grad_op=do_grad_op_list,
+                                                                     auto_grad_reg=auto_grad_reg_list)
+        save_path = os.path.join(work_path, K.PYBOOST_AUTO_GRAD_FUNC_GEN_PATH)
+        file_name = "auto_grad_impl.cc"
+        save_file(save_path, file_name, pyboost_func_h_str)
+
+    def _get_single_do_grad_op(self, op_proto):
+        """
+        Generate the DoGrad function for a single operator prototype.
+
+        Args:
+            op_proto: The operator prototype for which the DoGrad function is generated.
+
+        Returns:
+            str: The generated DoGrad function string.
+        """
+        input_args_str = self._get_input_args(op_proto, False, False)
+        input_args_with_optional_str = self._get_input_args(op_proto, False, True)
+        input_args_with_type_str = self._get_input_args(op_proto, True, False)
+        multi_output_str = 'Multi' if is_op_multi_output(op_proto.op_returns) else ''
+        view_arg_str = self._get_view_str(op_proto.op_view, input_args_str)
+        grad_args_with_type_str = self.do_grad_op_args_with_type.replace(input_args_with_type=input_args_with_type_str)
+        op_def_name_str = "g" + op_proto.op_class.name
+        bprop_expander = "true" if op_proto.bprop_expander else "false"
+        return self.DO_GRAD_FUNCTION_BODY_TEMPLATE.replace(class_name=op_proto.op_class.name,
+                                                           grad_args_with_type=grad_args_with_type_str,
+                                                           grad_input_args=input_args_str,
+                                                           grad_input_args_with_optional=input_args_with_optional_str,
+                                                           is_multi=multi_output_str,
+                                                           view_arg=view_arg_str,
+                                                           op_def_name=op_def_name_str,
+                                                           bprop_expander=bprop_expander)
+
+    def _get_input_args(self, op_proto, has_type, with_optional):
+        """
+        Get the input arguments for the DoGrad function.
+
+        Args:
+            op_proto: The operator prototype.
+            has_type (bool): Whether to include type information for the arguments.
+
+        Returns:
+            list: A list of input arguments for the DoGrad function.
+        """
+        args_list = []
+        for op_arg in op_proto.op_args:
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            if has_type:
+                args_list.append(f"const {input_dtype} &{op_arg.arg_name}_tensor")
+            else:
+                if not with_optional and is_optional_param(op_arg):
+                    args_list.append(f"OptionalToValue({op_arg.arg_name}_tensor)")
+                else:
+                    args_list.append(f"{op_arg.arg_name}_tensor")
+        return args_list
+
+    def _get_view_str(self, is_view_op: bool, grad_args: list):
+        """
+        Get the view argument string for a DoGrad function.
+
+        Args:
+            is_view_op (bool): Whether the operator is a view operator.
+            grad_args (list): A list of gradient arguments.
+
+        Returns:
+            str: The view argument string.
+        """
+        view_arg_str = ''
+        for i, grad_arg in enumerate(grad_args):
+            if is_view_op and i == 0:
+                view_arg_str = ", " + grad_arg
+                break
+        return view_arg_str

mindspore/ops_generate/auto_grad_reg_cc_generator.py

@@ -0,0 +1,93 @@
+# 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.
+# ============================================================================
+"""
+This module provides a generator class for creating C++ header files for AutoGrad registration functionality.
+"""
+
+import os
+
+import template
+from template import Template
+import gen_constants as K
+from gen_utils import save_file
+from base_generator import BaseGenerator
+from pyboost_utils import is_optional_param, get_input_dtype
+
+
+class AutoGradRegHeaderGenerator(BaseGenerator):
+    """
+    Generates C++ header files for the AutoGrad registration functionality based on operator prototypes.
+    """
+
+    def __init__(self):
+        """
+        Initialize the AutoGrad registration header generator with templates for code generation.
+        """
+        self.AUTO_GRAD_REG_H_TEMPLATE = template.AUTO_GRAD_REG_H_TEMPLATE
+        self.op_type_enum_template = Template("k${class_name} = ${enum_val},\n")
+        self.op_grad_func_template = Template("using ${class_name}GradFunc = std::function<void(${grad_func_args})>;")
+        self.op_grad_func_obj_template = Template("${class_name}GradFunc ${class_name}GradFuncObj;")
+        self.op_grad_func_args_template = Template(
+            "const kernel::pyboost::OpPtr &, ${input_tensor_prt_args}"
+        )
+
+    def generate(self, work_path, op_protos):
+        """
+        Generate the AutoGrad registration header file.
+
+        Args:
+            work_path (str): The directory where the generated file should be saved.
+            op_protos (list): A list of operator prototypes used to generate the header.
+        """
+        op_type_enum_list = []
+        op_grad_func_list = []
+        op_grad_func_obj_list = []
+        index = 0
+        for op_proto in op_protos:
+            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+                continue
+            op_type_enum_list.append(self.op_type_enum_template.replace(class_name=op_proto.op_class.name,
+                                                                        enum_val=index))
+            grad_func_args_with_type_str = self._get_grad_func_args_with_type_str(op_proto)
+            op_grad_func_list.append(self.op_grad_func_template.replace(class_name=op_proto.op_class.name,
+                                                                        grad_func_args=grad_func_args_with_type_str))
+            op_grad_func_obj_list.append(self.op_grad_func_obj_template.replace(class_name=op_proto.op_class.name))
+            index += 1
+
+        pyboost_func_h_str = self.AUTO_GRAD_REG_H_TEMPLATE.replace(op_enum=op_type_enum_list,
+                                                                   op_grad_func=op_grad_func_list,
+                                                                   op_grad_func_obj=op_grad_func_obj_list)
+
+        save_path = os.path.join(work_path, K.MS_OPS_KERNEL_FUNCTIONS_AUTO_GEN_PATH)
+        file_name = "auto_grad_op_reg.h"
+        save_file(save_path, file_name, pyboost_func_h_str)
+
+    def _get_grad_func_args_with_type_str(self, op_proto):
+        """
+        Get the gradient function arguments with type information.
+
+        Args:
+            op_proto: The operator prototype.
+
+        Returns:
+            str: A string of input tensor pointer arguments with types.
+        """
+        input_tensor_prt_args_str = ""
+        for op_arg in op_proto.op_args:
+            is_optional = is_optional_param(op_arg)
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional)
+            input_tensor_prt_args_str += f"const {input_dtype} &, "
+
+        return self.op_grad_func_args_template.replace(input_tensor_prt_args=input_tensor_prt_args_str.rstrip(', '))

mindspore/ops_generate/base_generator.py

@@ -0,0 +1,11 @@
+"""
+Base generator interface for other pyboost file generator classes
+"""
+
+from abc import ABC, abstractmethod
+
+
+class BaseGenerator(ABC):
+    @abstractmethod
+    def generate(self, **kwargs):
+        raise NotImplementedError

mindspore/ops_generate/cpp_create_prim_instance_helper_generator.py

@@ -0,0 +1,108 @@
+# 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 gen_constants as K
+import gen_utils
+import pyboost_utils
+
+# refactored
+import template
+
+from base_generator import BaseGenerator
+
+
+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_LICENCE_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)