mindspore 2.4.0__cp311-cp311-win_amd64.whl

mindspore/ops/op_info_register.py

@@ -0,0 +1,1572 @@
+# Copyright 2020-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.
+# ============================================================================
+
+"""Operators info register."""
+from __future__ import absolute_import
+from __future__ import division
+
+import inspect
+import json
+import os
+import functools
+import platform
+import hashlib
+import shutil
+
+from mindspore._c_expression import Oplib
+from mindspore import _checkparam as validator
+from mindspore import log as logger
+
+if platform.system() == "Linux":
+    import fcntl
+
+# path of built-in op info register.
+BUILT_IN_OPS_REGISTER_PATH = "mindspore/ops/_op_impl"
+BUILT_IN_CUSTOM_OPS_REGISTER_PATH = "mindspore/ops/_op_impl/_custom_op"
+
+KEY_NAME = "name"
+ASCEND_CUSTOM_OPP_PATH = "ASCEND_CUSTOM_OPP_PATH"
+
+
+def _get_reg_info_attr(op_info, attr_name, default_value=None):
+    """get attr value"""
+    for _, item in enumerate(op_info.get("attr", [])):
+        if item.get(KEY_NAME) == attr_name:
+            return item.get("defaultValue")
+    return default_value
+
+
+class _CustomInstaller:
+    """save custom op registration information to a json file which will be used by GE"""
+    reg_info_hash = []  # used to avoid writing the same reg info to file multiple times
+    copied_paths = []  # used to avoid copying the same file multiple times
+
+    def __init__(self, op_info, func=None):
+        self.op_info = op_info
+        self.func = func
+        self.op_type = op_info.get("op_name") if not func else func.__name__
+        vendor_name = "ms"
+        custom_dir = os.path.join(os.path.realpath("./"), "vendors", vendor_name)
+        self._set_env(custom_dir)
+        op_impl_dir = os.path.join(custom_dir, "op_impl")
+        self.ai_core_config_dir = os.path.join(op_impl_dir, "ai_core", "tbe", "config")
+        self.ai_core_impl_dir = os.path.join(op_impl_dir, "ai_core", "tbe", vendor_name + "_impl")
+        self.ai_cpu_config_dir = os.path.join(op_impl_dir, "cpu", "config")
+        self.ai_cpu_impl_dir = os.path.join(op_impl_dir, "cpu", "aicpu_kernel", "impl")
+
+    @staticmethod
+    def _set_env(custom_opp_path):
+        """set custom file path to env"""
+        if not os.environ.get(ASCEND_CUSTOM_OPP_PATH):
+            os.environ[ASCEND_CUSTOM_OPP_PATH] = custom_opp_path
+        else:
+            paths = os.environ[ASCEND_CUSTOM_OPP_PATH].split(':')
+            if custom_opp_path not in paths:
+                os.environ[ASCEND_CUSTOM_OPP_PATH] = custom_opp_path + ':' + os.environ[ASCEND_CUSTOM_OPP_PATH]
+
+    @staticmethod
+    def _create_dir(*dir_names):
+        """create directory"""
+        for dir_name in dir_names:
+            if not os.path.isdir(dir_name):
+                try:
+                    os.makedirs(dir_name, mode=0o700, exist_ok=True)
+                except OSError as err:
+                    if err.errno == 17:  # File exists
+                        pass
+                    else:
+                        raise err
+
+    @staticmethod
+    def _copy_file(src_path, dst_dir):
+        """copy file"""
+        if not os.path.exists(src_path) or src_path in _CustomInstaller.copied_paths:
+            return
+        _CustomInstaller.copied_paths.append(src_path)
+        if os.path.isfile(src_path):
+            lock_file = os.path.join(dst_dir, "file.lock")
+            with os.fdopen(os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                shutil.copy(src_path, dst_dir)
+
+    def check(self):
+        """check if the reg info need written"""
+        if platform.system() != "Linux":
+            return False
+        if not os.environ.get("MS_DEV_CUSTOM_OPP_PATH"):
+            # only process the first time import the mindspore module
+            return False
+        if self.op_info.get("target") in ["GPU", "CPU"]:
+            return False
+        sha256 = hashlib.sha256()
+        value = json.dumps(self.op_info, sort_keys=True).encode()
+        sha256.update(value)
+        hash_value = sha256.hexdigest()
+        if hash_value in _CustomInstaller.reg_info_hash:
+            return False
+        _CustomInstaller.reg_info_hash.append(hash_value)
+        return True
+
+    def _find_ai_cpu_so_path(self, so_file):
+        """find the absolute path of so"""
+        current_path = os.path.dirname(os.path.realpath(__file__))
+        search_paths = [current_path + "/../lib", current_path + "/../lib/plugin/ascend"]
+        for path in search_paths:
+            so_path = os.path.join(path, so_file)
+            if os.path.exists(so_path):
+                return so_path
+        logger.warning("For Custom op '{}', can not find the aicpu so file '{}' in the following directories:\n{}"
+                       .format(self.op_type, so_file, "\n".join(search_paths)))
+        return ""
+
+    def _gen_ai_core_reg_info(self, imply_path, func_name):
+        """generate reg info"""
+
+        def _get_dtype_format(idx):
+            data_type = []
+            data_format = []
+            for _, dtype_format in enumerate(self.op_info.get("dtype_format", [])):
+                if not dtype_format[idx][0]:
+                    data_type = None
+                else:
+                    data_type.append(dtype_format[idx][0])
+                if not dtype_format[idx][1]:
+                    data_format = None
+                else:
+                    if dtype_format[idx][1] == "DefaultFormat":
+                        data_format.append("ND")
+                    else:
+                        data_format.append(dtype_format[idx][1])
+            return data_type, data_format
+
+        op_info = {"opFile": {"value": os.path.splitext(os.path.basename(imply_path))[0]},
+                   "opInterface": {"value": func_name}}
+        # attr
+        attrs_name = []
+        for _, item in enumerate(self.op_info.get("attr", [])):
+            attr_name = item.get(KEY_NAME)
+            attrs_name.append(attr_name)
+            key = "attr_" + attr_name
+            op_info[key] = {}
+            for k, v in item.items():
+                if k != KEY_NAME:
+                    op_info[key][k] = v
+        if attrs_name:
+            op_info["attr"] = {"list": ",".join(attrs_name)}
+        # input and output
+        inputs = self.op_info.get("inputs", [])
+        outputs = self.op_info.get("outputs", [])
+        input_num = len(inputs)
+        output_num = len(outputs)
+        for i in range(input_num + output_num):
+            item = inputs[i] if i < input_num else outputs[i - input_num]
+            key = "input" if i < input_num else "output"
+            key += str(item.get("index"))
+            op_info[key] = {KEY_NAME: item.get(KEY_NAME),
+                            "paramType": item.get("paramType", "required"),
+                            "shape": item.get("shape", "all")}
+            dtype, formats = _get_dtype_format(i)
+            if dtype:
+                op_info[key]["dtype"] = ",".join(dtype)
+            if formats:
+                op_info[key]["format"] = ",".join(formats)
+        return op_info
+
+    @staticmethod
+    def _gen_ai_cpu_reg_info(so_file):
+        """generate reg info"""
+        op_info = {"opInfo": {"computeCost": "100",
+                              "engine": "DNN_VM_AICPU",
+                              "flagAsync": "False",
+                              "flagPartial": "False",
+                              "functionName": "RunCpuKernel",
+                              "kernelSo": so_file,
+                              "opKernelLib": "CUSTAICPUKernel",
+                              "userDefined": "True"}}
+        return op_info
+
+    def _save_op_info(self, dst_dir, file_name, op_info):
+        """save op info file"""
+        repo = {}
+        save_path = os.path.join(dst_dir, file_name)
+        lock_file = os.path.join(dst_dir, "file.lock")
+        with os.fdopen(os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            if os.path.isfile(save_path):
+                with open(save_path, 'r') as fr:
+                    json_str = fr.read()
+                json_str = "{}" if json_str == "" else json_str
+                repo = json.loads(json_str)
+            repo.update({self.op_type: op_info})
+            with os.fdopen(os.open(save_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fw:
+                json.dump(repo, fw, sort_keys=True, indent=4, separators=(',', ':'))
+
+    def run(self):
+        """save reg info to file"""
+        if not self.check():
+            return
+        so_name = _get_reg_info_attr(self.op_info, "cust_aicpu")
+        if so_name:
+            _CustomInstaller._create_dir(self.ai_cpu_config_dir, self.ai_cpu_impl_dir)
+            # copy so file
+            so_file = "lib" + so_name + ".so"
+            imply_path = self._find_ai_cpu_so_path(so_file)
+            self._copy_file(imply_path, self.ai_cpu_impl_dir)
+            # generate and copy reg info file
+            op_info = self._gen_ai_cpu_reg_info(so_file)
+            self._save_op_info(self.ai_cpu_config_dir, "cust_aicpu_kernel.json", op_info)
+        else:
+            _CustomInstaller._create_dir(self.ai_core_config_dir, self.ai_core_impl_dir)
+            # copy dsl file
+            imply_path = os.path.realpath(inspect.getfile(self.func))
+            self._copy_file(imply_path, self.ai_core_impl_dir)
+            # generate and copy reg info file
+            op_info = self._gen_ai_core_reg_info(imply_path, self.func.__name__)
+            self._copy_file(imply_path, self.ai_core_impl_dir)
+            for arc_name in ["ascend910", "ascend910b", "ascend910_93", "ascend310p"]:
+                arc_dir = os.path.join(self.ai_core_config_dir, arc_name)
+                _CustomInstaller._create_dir(arc_dir)
+                self._save_op_info(arc_dir, "aic-{}-ops-info.json".format(arc_name), op_info)
+
+
+def op_info_register(op_info):
+    r"""
+    A decorator which is used to register an operator.
+
+    Note:
+        'op_info' should represent the operator information by string with json format.
+        The 'op_info' will be added into oplib.
+
+    Args:
+        op_info (Union[str, dict]): operator information in json format.
+
+    Examples:
+        >>> from mindspore.ops import op_info_register, TBERegOp, DataType
+        >>> abs_op_info = TBERegOp("Abs") \
+        ...    .fusion_type("ELEMWISE") \
+        ...    .async_flag(False) \
+        ...    .binfile_name("abs.so") \
+        ...    .compute_cost(10) \
+        ...    .kernel_name("abs") \
+        ...    .partial_flag(True) \
+        ...    .op_pattern("formatAgnostic") \
+        ...    .input(0, "x", None, "required", None) \
+        ...    .output(0, "y", True, "required", "all") \
+        ...    .dtype_format(DataType.F16_None, DataType.F16_None) \
+        ...    .dtype_format(DataType.F32_None, DataType.F32_None) \
+        ...    .dtype_format(DataType.I32_None, DataType.I32_None) \
+        ...    .get_op_info()
+        >>>
+        >>> @op_info_register(abs_op_info)
+        ... def _abs_tbe():
+        ...    return
+        ...
+
+    Returns:
+        Function, returns a decorator for op info register.
+    """
+
+    def register_decorator(func):
+        if isinstance(op_info, dict):
+            op_info_real = json.dumps(op_info)
+        else:
+            op_info_real = op_info
+        validator.check_value_type("op_info", op_info_real, [str])
+        op_lib = Oplib()
+        file_path = os.path.realpath(inspect.getfile(func))
+        # keep the path custom ops implementation.
+        if BUILT_IN_CUSTOM_OPS_REGISTER_PATH in file_path:
+            imply_path = file_path
+        else:
+            imply_path = "" if BUILT_IN_OPS_REGISTER_PATH in file_path else file_path
+        if not op_lib.reg_op(op_info_real, imply_path):
+            raise ValueError('Invalid op info {}:\n{}\n'.format(file_path, op_info_real))
+
+        def wrapped_function(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapped_function
+
+    return register_decorator
+
+
+def custom_info_register(*reg_info):
+    r"""
+    A decorator which is used to bind the registration information to the `func` parameter of
+    :class:`mindspore.ops.Custom`.
+
+    Note:
+        The 'reg_info' will be added into oplib.
+
+    Args:
+        reg_info (tuple[str, dict]): Each item represents registration information in json format.
+
+    Returns:
+        Function, returns a decorator for op info register.
+
+    Raises:
+        TypeError: If `reg_info` is not a tuple.
+
+    Examples:
+        >>> from mindspore.ops import custom_info_register, CustomRegOp, DataType
+        >>> custom_func_ascend_info = CustomRegOp() \
+        ...     .input(0, "x", "dynamic") \
+        ...     .output(0, "y") \
+        ...     .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+        ...     .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+        ...     .target("Ascend") \
+        ...     .get_op_info()
+        >>>
+        >>> @custom_info_register(custom_func_ascend_info)
+        ... def custom_func(x):
+        ...     pass
+    """
+
+    def decorator(func):
+        setattr(func, "reg_info", reg_info)
+        if reg_info:
+            used_reg_info = reg_info[0]
+            if isinstance(used_reg_info, dict):
+                # ai_cpu should be parsed inside CustomRegOp, skip it here
+                if not _get_reg_info_attr(used_reg_info, "cust_aicpu"):
+                    _CustomInstaller(used_reg_info, func).run()
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+class RegOp:
+    """
+    Base class for op info register.
+
+    Args:
+        op_name (str): Name of operator.
+    """
+
+    def __init__(self, op_name=""):
+        if not isinstance(op_name, str):
+            raise ValueError("op name value must be string")
+        if not op_name.strip():
+            raise ValueError("op name is empty")
+        self.op_name = op_name
+        self.inputs = []
+        self.outputs = []
+        self.attr_ = []
+        self.fusion_type_ = ''
+        self.dtype_format_ = []
+
+    def _is_string(self, value):
+        """
+        Check if the value is a str type.
+
+        Args:
+            value: Parameter to be checked.
+
+        Raises:
+            TypeError: If the type of value is not a str.
+        """
+        if not isinstance(value, str):
+            raise TypeError("%s value must be str" % str(value))
+        return True
+
+    def _is_int(self, value):
+        """
+        Check if the value is an int.
+
+        Args:
+            value: Parameter to be checked.
+
+        Raises:
+            TypeError: If the type of value is not an int.
+        """
+        if not isinstance(value, int):
+            raise TypeError("%s value must be int" % str(value))
+        return True
+
+    def _is_bool(self, value):
+        """
+        Check if the value is a bool.
+
+        Args:
+            value: Parameter to be checked.
+
+        Raises:
+            TypeError: If the type of value is not a bool.
+        """
+        if not isinstance(value, bool):
+            raise TypeError("%s value must be bool" % str(value))
+        return True
+
+    @staticmethod
+    def _is_list(value):
+        """
+        Check if the value is a list.
+
+        Args:
+            value: Parameter to be checked.
+
+        Raises:
+            TypeError: If the type of value is not a list.
+        """
+        if not isinstance(value, list):
+            raise TypeError("%s value must be list" % str(value))
+        return True
+
+    def _check_param(self, param_list, key_list, fn_list, kwargs):
+        """
+        Check if the parameter type is correct.
+
+        Args:
+            param_list (list): Parameter list to be checked.
+            key_list (list): The keys of output dict.
+            fn_list (list): Function used for parameter checking. If the function list has only one element,
+                            all parameters will use the same function.
+            kwargs (dict): Other parameter information.
+
+        Raises:
+            TypeError: If the type of value is not list.
+            ValueError: If the size of param list is not equal to the size of key list, or
+                        the size of param list is not equal to the size of function list.
+        """
+        for i in [param_list, key_list, fn_list]:
+            if not isinstance(i, list):
+                raise TypeError("%s value must be list type" % str(i))
+        if len(param_list) != len(key_list) or (len(fn_list) != 1 and len(param_list) != len(fn_list)):
+            raise ValueError("param_list size {}, key_list size {}, must be equal.And fn_list size {}.".
+                             format(len(param_list), len(key_list), len(fn_list)))
+        out_dict = {}
+        for idx, element in enumerate(param_list):
+            if element is not None:
+                if len(fn_list) == 1:
+                    fn_list[0](element)
+                else:
+                    fn_list[idx](element)
+                out_dict[key_list[idx]] = element
+        if kwargs:
+            out_dict = dict(out_dict, **kwargs)
+        return out_dict
+
+    def fusion_type(self, fusion_type):
+        """
+        Fusion type of the operator.
+
+        Args:
+            fusion_type (str): Value of fusion type.
+        """
+        self._is_string(fusion_type)
+        self.fusion_type_ = fusion_type
+        return self
+
+    def dtype_format(self, *args):
+        """
+        A dtype and format supported by the operator.
+
+        Args:
+            args (tuple): Value of dtype and format.
+
+        Raises:
+            ValueError: If the size of args not equal to input size add output size.
+            TypeError: If the type of args is not tuple.
+        """
+        if len(self.inputs) + len(self.outputs) != len(args):
+            raise ValueError("input size add output size must be equal to dtype format size")
+        dtype_format = []
+        for arg in args:
+            if not isinstance(arg, tuple) or (len(arg) != 2 and len(arg) != 3):
+                raise ValueError("dtype and format value must be tuple of two or three elements")
+            self._is_string(arg[0])
+            self._is_string(arg[1])
+            if len(arg) == 3:
+                if self._is_string(arg[2]):
+                    dtype_format.append(arg)
+            else:
+                dtype_format.append(arg)
+        self.dtype_format_.append(tuple(dtype_format))
+        return self
+
+    def get_op_info(self):
+        """
+        Return all registration information for this instance.
+
+        The '_' character ending the key is removed here for compatibility with previous version.
+
+        Key will be unified into an underlined form later.
+        """
+        op_info = {}
+        for key, value in self.__dict__.items():
+            if isinstance(key, str) and key.endswith('_'):
+                key = key.rstrip('_')
+                key_dic = {"dynamic_shape_support": "dynamicShapeSupport",
+                           "dynamic_rank_support": "dynamicRankSupport",
+                           "dynamic_compile_static": "dynamicCompileStatic",
+                           "need_check_support": "needCheckSupport",
+                           "dynamic_format": "dynamicFormat"
+                           }
+                key = key_dic.get(key, key)
+            op_info[key] = value
+        return op_info
+
+
+class CpuRegOp(RegOp):
+    """Class for Cpu op info register"""
+
+    def __init__(self, op_name):
+        super(CpuRegOp, self).__init__(op_name)
+        self.imply_type = "CPU"
+
+    def input(self, index=None, name=None, param_type=None, **kwargs):
+        """
+        Register Cpu op input information.
+
+        Args:
+            index (int): Order of the input. Default: ``None`` .
+            name (str): Name of the input. Default: ``None`` .
+            param_type (str): Param type of the input. Default: ``None`` .
+            kwargs (dict): Other information of the input.
+        """
+        param_list = [index, name, param_type]
+        key_list = ["index", "name", "paramType"]
+        fn_list = [self._is_int, self._is_string, self._is_string]
+        input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.inputs.append(input_dict)
+        return self
+
+    def output(self, index=None, name=None, param_type=None, **kwargs):
+        """
+        Register AiCPU op output information.
+
+        Args:
+            index (int): Order of the output. Default: ``None`` .
+            name (str): Name of the output. Default: ``None`` .
+            param_type (str): Param type of the output. Default: ``None`` .
+            kwargs (dict): Other information of the output.
+        """
+        param_list = [index, name, param_type]
+        key_list = ["index", "name", "paramType"]
+        fn_list = [self._is_int, self._is_string, self._is_string]
+        output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.outputs.append(output_dict)
+        return self
+
+    def attr(self, name=None, value_type=None, value=None, **kwargs):
+        """
+        Register AiCPU op attribute information.
+
+        Args:
+            name (str): Name of the attribute. Default: ``None`` .
+            value_type (str): Value type of the attribute. Default: ``None`` .
+            value (str): Value of the attribute. Default: ``None`` .
+            kwargs (dict): Other information of the attribute.
+        """
+        param_list = [name, value_type, value]
+        key_list = ["name", "type", "value"]
+        fn_list = [self._is_string]
+        attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.attr_.append(attr_dict)
+        return self
+
+
+class AkgRegOp(RegOp):
+    """Class for Akg op info register."""
+
+    def __init__(self, op_name, processor):
+        super(AkgRegOp, self).__init__(op_name)
+        self.imply_type = "AKG"
+        self.processor = processor
+
+    def input(self, index=None, name=None, param_type=None, **kwargs):
+        """
+        Register Akg op input information.
+
+        Args:
+            index (int): Order of the input. Default: ``None`` .
+            name (str): Name of the input. Default: ``None`` .
+            param_type (str): Param type of the input. Default: ``None`` .
+            kwargs (dict): Other information of the input.
+        """
+        param_list = [index, name, param_type]
+        key_list = ["index", "name", "paramType"]
+        fn_list = [self._is_int, self._is_string, self._is_string]
+        input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.inputs.append(input_dict)
+        return self
+
+    def output(self, index=None, name=None, **kwargs):
+        """
+        Register Akg op output information.
+
+        Args:
+            index (int): Order of the output. Default: ``None`` .
+            name (str): Name of the output. Default: ``None`` .
+            kwargs (dict): Other information of the output.
+        """
+        param_list = [index, name]
+        key_list = ["index", "name"]
+        fn_list = [self._is_int, self._is_string]
+        output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.outputs.append(output_dict)
+        return self
+
+    def attr(self, name=None, param_type=None, value_type=None, **kwargs):
+        """
+        Register Akg op attribute information.
+
+        Args:
+            name (str): Name of the attribute. Default: ``None`` .
+            param_type (str): Param type of the attribute. Default: ``None`` .
+            value_type (str): Value type of the attribute. Default: ``None`` .
+            kwargs (dict): Other information of the attribute.
+        """
+        param_list = [name, param_type, value_type]
+        key_list = ["name", "paramType", "type"]
+        fn_list = [self._is_string]
+        attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.attr_.append(attr_dict)
+        return self
+
+
+class AkgGpuRegOp(AkgRegOp):
+    """Class for AkgGpu op info register"""
+
+    def __init__(self, op_name):
+        super(AkgGpuRegOp, self).__init__(op_name, "CUDA")
+
+
+class AkgAscendRegOp(AkgRegOp):
+    """Class for AkgAscend op info register"""
+
+    def __init__(self, op_name):
+        super(AkgAscendRegOp, self).__init__(op_name, "AiCore")
+
+
+class AkgCpuRegOp(AkgRegOp):
+    """Class for AkgCpu op info register"""
+
+    def __init__(self, op_name):
+        super(AkgCpuRegOp, self).__init__(op_name, "CPU")
+
+
+class AiCPURegOp(CpuRegOp):
+    r"""
+    Class for AiCPU operator information registration.
+
+    Args:
+        op_name (str): Name of operator.
+
+    Examples:
+        >>> from mindspore.ops import AiCPURegOp, DataType
+        >>> stack_op_info = AiCPURegOp("Stack") \
+        ...    .fusion_type("OPAQUE") \
+        ...    .attr("axis", "int") \
+        ...    .input(0, "x", "dynamic") \
+        ...    .output(0, "y", "required") \
+        ...    .dtype_format(DataType.I8_Default, DataType.I8_Default) \
+        ...    .dtype_format(DataType.I16_Default, DataType.I16_Default) \
+        ...    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
+        ...    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
+        ...    .dtype_format(DataType.U8_Default, DataType.U8_Default) \
+        ...    .dtype_format(DataType.U16_Default, DataType.U16_Default) \
+        ...    .dtype_format(DataType.U32_Default, DataType.U32_Default) \
+        ...    .dtype_format(DataType.U64_Default, DataType.U64_Default) \
+        ...    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+        ...    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+        ...    .dtype_format(DataType.F64_Default, DataType.F64_Default) \
+        ...    .dtype_format(DataType.BOOL_Default, DataType.BOOL_Default) \
+        ...    .get_op_info()
+        >>>
+    """
+
+    def __init__(self, op_name):
+        super(AiCPURegOp, self).__init__(op_name)
+        self.imply_type = "AiCPU"
+
+
+class TBERegOp(RegOp):
+    r"""
+    Class for TBE operator information registration. TBE (Tensor Boost Engine) is the Ascend operator development
+    tool, which is extended on the basis of the TVM framework to develop custom operators.
+
+    Args:
+        op_name (str): Name of operator.
+
+    Examples:
+        >>> from mindspore.ops import TBERegOp, DataType
+        >>> op_name_op_info = TBERegOp("OpName") \
+        ...    .fusion_type("ELEMWISE") \
+        ...    .async_flag(False) \
+        ...    .binfile_name("op_name.so") \
+        ...    .compute_cost(10) \
+        ...    .kernel_name("op_name") \
+        ...    .partial_flag(True) \
+        ...    .op_pattern("formatAgnostic") \
+        ...    .need_check_supported(True) \
+        ...    .dynamic_shape(True) \
+        ...    .dynamic_rank_support(True) \
+        ...    .dynamic_compile_static(True) \
+        ...    .attr("format", "required", "str", "all") \
+        ...    .input(0, "x1", None, "required", None) \
+        ...    .input(0, "x2", None, "required", None) \
+        ...    .input(1, "axis", None, "required", None) \
+        ...    .output(0, "y", True, "required", "all") \
+        ...    .real_input_index([1, 0]) \
+        ...    .input_to_attr_index([2]) \
+        ...    .unknown_shape_formats(["ND", "ND", "ND", "ND"]) \
+        ...    .reshape_type("NC") \
+        ...    .is_dynamic_format(True) \
+        ...    .dtype_format(DataType.F16_None, DataType.F16_None, DataType.F16_None, DataType.F16_None) \
+        ...    .dtype_format(DataType.F32_None, DataType.F32_None, DataType.F32_None, DataType.F32_None) \
+        ...    .dtype_format(DataType.I32_None, DataType.I32_None, DataType.I32_None, DataType.I32_None) \
+        ...    .get_op_info()
+        >>>
+    """
+
+    def __init__(self, op_name):
+        super(TBERegOp, self).__init__(op_name)
+        self.imply_type = "TBE"
+        self.async_flag_ = False
+        self.binfile_ = ''
+        self.compute_cost_ = 10
+        self.kernel_ = ''
+        self.partial_flag_ = False
+        self.reshape_type_ = ''
+        self.dynamic_rank_support_ = False
+        self.dynamic_shape_support_ = False
+        self.dynamic_compile_static_ = False
+        self.need_check_support_ = False
+        self.dynamic_format_ = False
+        self.op_pattern_ = ""
+        self.real_input_index_ = []
+        self.input_to_attr_index_ = []
+        self.unknown_shape_formats_ = []
+
+    def unknown_shape_formats(self, unknown_shape_formats):
+        """
+        Description data arrangement of operator input / output tensor in dynamic shape scene.
+
+        Args:
+            unknown_shape_formats (list): Description data arrangement of operator input / output tensor in dynamic
+                                          shape scene.
+        """
+        RegOp._is_list(unknown_shape_formats)
+        self.unknown_shape_formats_.append(unknown_shape_formats)
+        return self
+
+    def dynamic_rank_support(self, dynamic_rank_support):
+        """
+        Description whether the operator supports dynamic rank (dynamic dimension).
+
+        Args:
+            dynamic_rank_support (bool): Description whether the operator supports dynamic rank (dynamic dimension).
+                                         True: indicates that dynamic rank is supported, and the operator supports
+                                         shape (- 2), which is used to determine whether dynamic is performed.
+                                         False: indicates that the operator does not support dynamic rank.
+                                         Default: ``False`` .
+        """
+        if self._is_bool(dynamic_rank_support):
+            self.dynamic_rank_support_ = dynamic_rank_support
+        return self
+
+    def real_input_index(self, real_input_index):
+        """
+        Description operator front end and tbe operator input mapping.
+
+        Args:
+            real_input_index (list): Value of real_input_index. Default: ``()`` .
+        """
+        RegOp._is_list(real_input_index)
+        self.real_input_index_ = real_input_index
+        return self
+
+    def input_to_attr_index(self, input_to_attr_index):
+        """
+        Description the index of input need to cast to attr.
+
+        Args:
+            input_to_attr_index (list): Value of input_to_attr_index. Default: ``()`` .
+        """
+        RegOp._is_list(input_to_attr_index)
+        self.input_to_attr_index_ = input_to_attr_index
+        return self
+
+    def async_flag(self, async_flag=False):
+        """
+        Define the calculation efficiency of the operator, whether the asynchronous calculation is supported.
+
+        Args:
+            async_flag (bool): Value of async flag. Default: ``False`` .
+        """
+        self._is_bool(async_flag)
+        self.async_flag_ = async_flag
+        return self
+
+    def binfile_name(self, binfile_name):
+        """
+        Set the binary file name of the operator, it is optional.
+
+        Args:
+            binfile_name (str): The binary file name of the operator.
+        """
+        self._is_string(binfile_name)
+        self.binfile_ = binfile_name
+        return self
+
+    def compute_cost(self, compute_cost=10):
+        """
+        Define the calculation efficiency of operator, which refers to the value of the cost model
+        in the tiling module.
+
+        Args:
+            compute_cost (int): Value of compute cost. Default: ``10`` .
+        """
+        self._is_int(compute_cost)
+        self.compute_cost_ = compute_cost
+        return self
+
+    def kernel_name(self, kernel_name):
+        """
+        The name of operator kernel.
+
+        Args:
+            kernel_name (str): Name of operator kernel.
+        """
+        self._is_string(kernel_name)
+        self.kernel_ = kernel_name
+        return self
+
+    def partial_flag(self, partial_flag=True):
+        """
+        Define the calculation efficiency of operator, whether the partial calculation is supported.
+
+        Args:
+            partial_flag (bool): Value of partial flag. Default: ``True`` .
+        """
+        self._is_bool(partial_flag)
+        self.partial_flag_ = partial_flag
+        return self
+
+    def reshape_type(self, reshape_type):
+        """
+        Reshape type of operator.
+
+        Args:
+            reshape_type (str): Value of reshape type. For example, if the input shape is :math:`(2, 3)`
+                and `reshape_type` is set to "CH", then the new shape is :math:`(1, 2, 3, 1)`.
+                "CH" means the C and H dimensions are kept and
+                new dimensions are added for N and W dimension.
+        """
+        self._is_string(reshape_type)
+        self.reshape_type_ = reshape_type
+        return self
+
+    def dynamic_shape(self, dynamic_shape=False):
+        """
+        Whether the operator supports dynamic shape.
+
+        Args:
+            dynamic_shape (bool): Value of dynamic shape. Default: ``False`` .
+        """
+        self._is_bool(dynamic_shape)
+        self.dynamic_shape_support_ = dynamic_shape
+        return self
+
+    def dynamic_compile_static(self, dynamic_compile_static=False):
+        """
+        Whether the operator supports dynamic compile static.
+
+        Args:
+            dynamic_compile_static (bool): Value of dynamic compile static. Default: ``False`` .
+        """
+        if self._is_bool(dynamic_compile_static):
+            self.dynamic_compile_static_ = dynamic_compile_static
+        return self
+
+    def need_check_supported(self, need_check_supported=False):
+        """
+        Whether the operator needs check supports.
+
+        Args:
+            need_check_supported (bool): Value of need_check_supported. Default: ``False`` .
+        """
+        if self._is_bool(need_check_supported):
+            self.need_check_support_ = need_check_supported
+        return self
+
+    def is_dynamic_format(self, is_dynamic_format=False):
+        """
+        Whether the operator needs calop_select_format api.
+
+        Args:
+            is_dynamic_format (bool): Value of is_dynamic_format. Default: ``False`` .
+        """
+        if self._is_bool(is_dynamic_format):
+            self.dynamic_format_ = is_dynamic_format
+        return self
+
+    def op_pattern(self, pattern=None):
+        """
+        The behavior type of operator, such as broadcast, reduce and so on.
+
+        Args:
+            pattern (str): Value of op pattern, e.g. "broadcast", "reduce". Default: ``None`` .
+        """
+        if pattern is not None and self._is_string(pattern):
+            self.op_pattern_ = pattern
+        return self
+
+    def attr(self, name=None, param_type=None, value_type=None, value=None, default_value=None, **kwargs):
+        """
+        Register TBE op attribute information.
+
+        Args:
+            name (str): Name of the attribute. Default: ``None`` .
+            param_type (str): Param type of the attribute. Default: ``None`` .
+            value_type (str): Type of the attribute. Default: ``None`` .
+            value (str): Value of the attribute. Default: ``None`` .
+            default_value (str): Default value of attribute. Default: ``None`` .
+            kwargs (dict): Other information of the attribute.
+        """
+        param_list = [name, param_type, value_type, value, default_value]
+        key_list = ["name", "paramType", "type", "value", "defaultValue"]
+        fn_list = [self._is_string]
+        attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.attr_.append(attr_dict)
+        return self
+
+    def input(self, index=None, name=None, need_compile=None, param_type=None, shape=None, value_depend=None, **kwargs):
+        """
+        Register TBE op input information.
+
+        Args:
+            index (int): Order of the input. Default: ``None`` .
+            name (str): Name of the input. Default: ``None`` .
+            need_compile (bool): Whether the input needs to be compiled or not. Default: ``None`` .
+            param_type (str): Type of the input. Default: ``None`` .
+            shape (str): Shape of the input. Default: ``None`` .
+            value_depend (str): Whether the input is constant value depend. Default: ``None`` .
+            kwargs (dict): Other information of the input.
+        """
+        param_list = [index, name, need_compile, param_type, shape, value_depend]
+        key_list = ["index", "name", "needCompile", "paramType", "shape", "valueDepend"]
+        fn_list = [self._is_int, self._is_string, self._is_bool, self._is_string, self._is_string, self._is_string]
+        input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        value_depend_values = ("ignored", "optional", "required")
+        if value_depend and value_depend.lower() not in value_depend_values:
+            raise ValueError("Operator {} input{}'s value_depend's value ({}) is not in {}.".
+                             format(self.op_name, index, value_depend, value_depend_values))
+        self.inputs.append(input_dict)
+        return self
+
+    def output(self, index=None, name=None, need_compile=None, param_type=None, shape=None, **kwargs):
+        """
+        Register TBE op output information.
+
+        Args:
+            index (int): Order of the output. Default: ``None`` .
+            name (str): Name of the output. Default: ``None`` .
+            need_compile (bool): Whether the output needs to be compiled or not. Default: ``None`` .
+            param_type (str): Type of the output. Default: ``None`` .
+            shape (str): Shape of the output. Default: ``None`` .
+            kwargs (dict): Other information of the output.
+        """
+        param_list = [index, name, need_compile, param_type, shape]
+        key_list = ["index", "name", "need_compile", "paramType", "shape"]
+        fn_list = [self._is_int, self._is_string, self._is_bool, self._is_string, self._is_string]
+        output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.outputs.append(output_dict)
+        return self
+
+
+class CustomRegOp(RegOp):
+    r"""
+    Class used for generating the registration information for the `func` parameter of :class:`mindspore.ops.Custom`.
+    The registration information mainly specifies the supported data types and formats of input and output tensors,
+    attributes and target of `func`.
+
+    Args:
+        op_name (str): kernel name. The name will be record in the reg_op_name attr of the kernel node.
+            Besides, the operator will generate a unique name automatically to identify the reg info.
+            Default: ``"Custom"`` .
+
+    Examples:
+        >>> from mindspore.ops import CustomRegOp, DataType
+        >>> custom_op_ascend_info = CustomRegOp() \
+        ...     .input(0, "x", "dynamic") \
+        ...     .output(0, "y") \
+        ...     .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+        ...     .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+        ...     .target("Ascend") \
+        ...     .get_op_info()
+    """
+
+    def __init__(self, op_name="Custom"):
+        super(CustomRegOp, self).__init__(op_name)
+        self.target_ = "UnKnown"
+
+    def input(self, index=None, name=None, param_type="required", **kwargs):
+        """
+        Specifies the input tensor information for the `func` parameter of :class:`mindspore.ops.Custom`. Each
+        invocation of this function will generate one input tensor information, that means, if `func` has two input
+        tensors, then this function should be invoked two times continuously. The input tensor information will be
+        generated as a dict: {"index": `index`, "name": `name`, "param_type": `param_type`}.
+
+        Args:
+            index (int): Index of the input, starts from 0. 0 means the first input tensor, 1 means the second input
+                tensor and so on. If ``None`` , key "index" will not appear in the input tensor information dict.
+                Default: ``None`` .
+            name (str): Name of the `index` 'th input. If ``None`` , key "name" will not appear in the input tensor
+                information dict. Default: ``None`` .
+            param_type (str): Parameter type of the `index` 'th input, can be one of
+                [``"required"`` , ``"dynamic"`` , ``"optional"`` ]. If ``None`` , key "param_type" will not appear in
+                the input tensor information dict. Default: ``"required"`` .
+
+                - ``"required"``: means the `index` 'th input exist and can only be a single tensor.
+                - ``"dynamic":`` means the `index` 'th input exist and may be multiple tensors, such as the input of
+                  AddN.
+                - ``"optional"``: means the `index` 'th input may exist and be a single tensor or may not exist.
+
+            kwargs (dict): Other information of the input, used for extension.
+
+        Raises:
+            TypeError: If `index` is neither int nor None.
+            TypeError: If `name` is neither str nor None.
+            TypeError: If `param_type` is neither str nor None.
+        """
+        param_list = [index, name, param_type]
+        key_list = ["index", "name", "paramType"]
+        fn_list = [self._is_int, self._is_string, self._is_string]
+        input_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.inputs.append(input_dict)
+        return self
+
+    def output(self, index=None, name=None, param_type="required", **kwargs):
+        """
+        Specifies the output tensor information for the `func` parameter of :class:`mindspore.ops.Custom`. Each
+        invocation of this function will generate one output tensor information, which means, if `func` has two output
+        tensors, then this function should be invoked two times continuously. The output tensor information will be
+        generated as a dict: {"index": `index`, "name": `name`, "param_type": `param_type`}.
+
+        Args:
+            index (int): Index of the output, starts from 0. 0 means the first output tensor, 1 means the second output
+                tensor and so on. If ``None`` , key "index" will not appear in the output tensor information dict.
+                Default: ``None`` .
+            name (str): Name of the `index` 'th output. If ``None`` , key "name" will not appear in the output tensor
+                information dict. Default: ``None`` .
+            param_type (str): Parameter type of the `index` 'th output, can be one of
+                [ ``"required"`` , ``"dynamic"`` , ``"optional"`` ]. If ``None`` , key "param_type" will not appear in
+                the output tensor information dict. Default: ``"required"`` .
+
+                - ``"required"``: means the `index` 'th output exist and can only be a single tensor.
+                - ``"dynamic"``: means the `index` 'th output exist and may be multiple tensors.
+                - ``"optional"``: means the `index` 'th output may exist and be a single tensor or may not exist.
+
+            kwargs (dict): Other information of the output, used for extension.
+
+        Raises:
+            TypeError: If `index` is neither int nor None.
+            TypeError: If `name` is neither str nor None.
+            TypeError: If `param_type` is neither str nor None.
+        """
+        param_list = [index, name, param_type]
+        key_list = ["index", "name", "paramType"]
+        fn_list = [self._is_int, self._is_string, self._is_string]
+        output_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.outputs.append(output_dict)
+        return self
+
+    def dtype_format(self, *args):
+        """
+        Specifies the supported data type and format of each input tensor and output tensor for the `func` parameter
+        of :class:`mindspore.ops.Custom`. This function should be invoked after `input` and `output` function as shown
+        in the above example.
+
+        Args:
+            args (tuple): A tuple of (data type, format) pair, the length of `args` should be equal to the sum of input
+                tensors and output tensors. Each item in `args` is also a tuple, tuple[0] and tuple[1] are both str
+                type, which specifies the data type and format of a tensor respectively. :class:`mindspore.ops.DataType`
+                provides many predefined (data type, format) combinations, for example, `DataType.F16_Default` means the
+                data type is float16 and the format is default format.
+
+        Raises:
+            ValueError: If the size of `args` not equal to the sum of input tensors and output tensors.
+        """
+        io_nums = len(self.inputs) + len(self.outputs)
+        if len(args) != io_nums:
+            raise ValueError("The size of 'args' must be equal to the sum of input tensors and output tensors, but got "
+                             "{} vs {}".format(len(args), io_nums))
+        return super(CustomRegOp, self).dtype_format(*args)
+
+    def attr(self, name=None, param_type=None, value_type=None, default_value=None, **kwargs):
+        """
+        Specifies the attributes information for the `func` parameter of :class:`mindspore.ops.Custom`. Each
+        invocation of this function will generate one attribute information, that means, if `func` has two attributes,
+        then this function should be invoked two times continuously. The attributes information will be
+        generated as a dict: {"name": `name`, "param_type": `param_type`, "value_type": `value_type`, "default_value":
+        `default_value`}.
+
+        Args:
+            name (str): Name of the attribute. If ``None`` , key "name" will not appear in the attributes tensor
+                information dict. Default: ``None`` .
+            param_type (str): Parameter type of the attribute, can be one of ["required", "optional"]. If ``None`` ,
+                key "param_type" will not appear in the attributes tensor information dict. Default: ``None`` .
+
+                - "required": means must provide a value for this attribute either by setting a default value in the
+                  registration information or providing an input value when calling the Custom operator.
+                - "optional": means does not have to provide a value for this attribute.
+
+            value_type (str): Value type of the attribute, can be one of ["int", "str", "bool", "float", "listInt",
+                "listStr", "listBool", "listFloat"]. If ``None`` , key "value_type" will not appear in the attributes
+                tensor information dict. Default: ``None`` .
+
+                - "int": string representation of Python type int.
+                - "str": string representation of Python type str.
+                - "bool": string representation of Python type bool.
+                - "float": string representation of Python type float.
+                - "listInt": string representation of Python type list of int.
+                - "listStr": string representation of Python type list of str.
+                - "listBool": string representation of Python type list of bool.
+                - "listFloat": string representation of Python type list of float.
+
+            default_value (str): Default value of the attribute. `default_value` and `value_type` are used together.
+                If the real default value of the attribute is float type with value 1.0, then the `value_type` should be
+                "float" and `default_value` should be "1.0". If the real default value of the attribute is a list of int
+                with value [1, 2, 3], then the `value_type` should be "listInt" and `default_value` should be "1,2,3",
+                each item should split by ','. If ``None`` , means the attribute has no default value and key
+                "default_value" will not appear in the attributes tensor information dict. It is used for "akg",
+                "aicpu" and "tbe" Custom operators currently. Default: ``None`` .
+            kwargs (dict): Other information of the attribute, used for extension.
+
+        Raises:
+            TypeError: If `name` is neither str nor None.
+            TypeError: If `param_type` is neither str nor None.
+            TypeError: If `value_type` is neither str nor None.
+            TypeError: If `default_value` is neither str nor None.
+        """
+        param_list = [name, param_type, value_type, default_value]
+        key_list = ["name", "paramType", "type", "defaultValue"]
+        fn_list = [self._is_string]
+        attr_dict = self._check_param(param_list, key_list, fn_list, kwargs)
+        self.attr_.append(attr_dict)
+        return self
+
+    def target(self, target=None):
+        """
+        Specifies the target that this registration information is used for.
+
+        Args:
+            target (str): Device target for current operator information, should be one of ["Ascend", "GPU", "CPU"].
+                For the same `func` of :class:`mindspore.ops.Custom`, it may support different data types and formats
+                on different targets, use `target` to specify which target that this registration information is used
+                for. If ``None`` , it will be inferred automatically inside :class:`mindspore.ops.Custom`.
+                Default: ``None`` .
+
+        Raises:
+            TypeError: If `target` is neither str nor None.
+        """
+        if target is not None:
+            self._is_string(target)
+        self.target_ = target
+        return self
+
+    def get_op_info(self):
+        """
+        Return the generated registration information as a dict. This function should be invoked at last on the
+        `CustomRegOp` instance as shown in the above example.
+        """
+        op_info = {}
+        for k, v in self.__dict__.items():
+            if isinstance(k, str) and k.endswith('_'):
+                k = k.rstrip('_')
+            op_info[k] = v
+        if _get_reg_info_attr(op_info, "cust_aicpu"):
+            _CustomInstaller(op_info).run()
+        return op_info
+
+
+class DataType:
+    r"""
+    Various combinations of dtype and format of Ascend ops.
+
+    current support:
+
+    .. code-block::
+
+        None_None = ("", "")
+        None_Default = ("", "DefaultFormat")
+        BOOL_None = ("bool", "")
+        BOOL_Default = ("bool", "DefaultFormat")
+        BOOL_5HD = ("bool", "NC1HWC0")
+        BOOL_FracZ = ("bool", "FRACTAL_Z")
+        BOOL_FracNZ = ("bool", "FRACTAL_NZ")
+        BOOL_C1HWNCoC0 = ("bool", "C1HWNCoC0")
+        BOOL_NCHW = ("bool", "NCHW")
+        BOOL_NHWC = ("bool", "NHWC")
+        BOOL_HWCN = ("bool", "HWCN")
+        BOOL_NDHWC = ("bool", "NDHWC")
+        BOOL_ChannelLast = ("bool", "ChannelLast")
+
+        I8_None = ("int8", "")
+        I8_Default = ("int8", "DefaultFormat")
+        I8_5HD = ("int8", "NC1HWC0")
+        I8_FracZ = ("int8", "FRACTAL_Z")
+        I8_FracNZ = ("int8", "FRACTAL_NZ")
+        I8_C1HWNCoC0 = ("int8", "C1HWNCoC0")
+        I8_NCHW = ("int8", "NCHW")
+        I8_NHWC = ("int8", "NHWC")
+        I8_HWCN = ("int8", "HWCN")
+        I8_NDHWC = ("int8", "NDHWC")
+        I8_ChannelLast = ("int8", "ChannelLast")
+        I8_NDC1HWC0 = ("int8", "NDC1HWC0")
+
+        U8_None = ("uint8", "")
+        U8_Default = ("uint8", "DefaultFormat")
+        U8_5HD = ("uint8", "NC1HWC0")
+        U8_FracZ = ("uint8", "FRACTAL_Z")
+        U8_FracNZ = ("uint8", "FRACTAL_NZ")
+        U8_C1HWNCoC0 = ("uint8", "C1HWNCoC0")
+        U8_NCHW = ("uint8", "NCHW")
+        U8_NHWC = ("uint8", "NHWC")
+        U8_HWCN = ("uint8", "HWCN")
+        U8_NDHWC = ("uint8", "NDHWC")
+        U8_ChannelLast = ("uint8", "ChannelLast")
+        U8_NDC1HWC0 = ("uint8", "NDC1HWC0")
+
+        I16_None = ("int16", "")
+        I16_Default = ("int16", "DefaultFormat")
+        I16_5HD = ("int16", "NC1HWC0")
+        I16_FracZ = ("int16", "FRACTAL_Z")
+        I16_FracNZ = ("int16", "FRACTAL_NZ")
+        I16_C1HWNCoC0 = ("int16", "C1HWNCoC0")
+        I16_NCHW = ("int16", "NCHW")
+        I16_NHWC = ("int16", "NHWC")
+        I16_HWCN = ("int16", "HWCN")
+        I16_NDHWC = ("int16", "NDHWC")
+        I16_ChannelLast = ("int16", "ChannelLast")
+
+        U16_None = ("uint16", "")
+        U16_Default = ("uint16", "DefaultFormat")
+        U16_5HD = ("uint16", "NC1HWC0")
+        U16_FracZ = ("uint16", "FRACTAL_Z")
+        U16_FracNZ = ("uint16", "FRACTAL_NZ")
+        U16_C1HWNCoC0 = ("uint16", "C1HWNCoC0")
+        U16_NCHW = ("uint16", "NCHW")
+        U16_NHWC = ("uint16", "NHWC")
+        U16_HWCN = ("uint16", "HWCN")
+        U16_NDHWC = ("uint16", "NDHWC")
+        U16_ChannelLast = ("uint16", "ChannelLast")
+
+        I32_None = ("int32", "")
+        I32_Default = ("int32", "DefaultFormat")
+        I32_5HD = ("int32", "NC1HWC0")
+        I32_FracZ = ("int32", "FRACTAL_Z")
+        I32_FracNZ = ("int32", "FRACTAL_NZ")
+        I32_C1HWNCoC0 = ("int32", "C1HWNCoC0")
+        I32_NCHW = ("int32", "NCHW")
+        I32_NHWC = ("int32", "NHWC")
+        I32_HWCN = ("int32", "HWCN")
+        I32_NDHWC = ("int32", "NDHWC")
+        I32_ChannelLast = ("int32", "ChannelLast")
+
+        U32_None = ("uint32", "")
+        U32_Default = ("uint32", "DefaultFormat")
+        U32_5HD = ("uint32", "NC1HWC0")
+        U32_FracZ = ("uint32", "FRACTAL_Z")
+        U32_FracNZ = ("uint32", "FRACTAL_NZ")
+        U32_C1HWNCoC0 = ("uint32", "C1HWNCoC0")
+        U32_NCHW = ("uint32", "NCHW")
+        U32_NHWC = ("uint32", "NHWC")
+        U32_HWCN = ("uint32", "HWCN")
+        U32_NDHWC = ("uint32", "NDHWC")
+        U32_ChannelLast = ("uint32", "ChannelLast")
+
+        I64_None = ("int64", "")
+        I64_Default = ("int64", "DefaultFormat")
+        I64_5HD = ("int64", "NC1HWC0")
+        I64_FracZ = ("int64", "FRACTAL_Z")
+        I64_FracNZ = ("int64", "FRACTAL_NZ")
+        I64_C1HWNCoC0 = ("int64", "C1HWNCoC0")
+        I64_NCHW = ("int64", "NCHW")
+        I64_NHWC = ("int64", "NHWC")
+        I64_HWCN = ("int64", "HWCN")
+        I64_NDHWC = ("int64", "NDHWC")
+        I64_ChannelLast = ("int64", "ChannelLast")
+
+        U64_None = ("uint64", "")
+        U64_Default = ("uint64", "DefaultFormat")
+        U64_5HD = ("uint64", "NC1HWC0")
+        U64_FracZ = ("uint64", "FRACTAL_Z")
+        U64_FracNZ = ("uint64", "FRACTAL_NZ")
+        U64_C1HWNCoC0 = ("uint64", "C1HWNCoC0")
+        U64_NCHW = ("uint64", "NCHW")
+        U64_NHWC = ("uint64", "NHWC")
+        U64_HWCN = ("uint64", "HWCN")
+        U64_NDHWC = ("uint64", "NDHWC")
+        U64_ChannelLast = ("uint64", "ChannelLast")
+
+        F16_None = ("float16", "")
+        F16_Default = ("float16", "DefaultFormat")
+        F16_5HD = ("float16", "NC1HWC0")
+        F16_FracZ = ("float16", "FRACTAL_Z")
+        F16_FracNZ = ("float16", "FRACTAL_NZ")
+        F16_C1HWNCoC0 = ("float16", "C1HWNCoC0")
+        F16_NCHW = ("float16", "NCHW")
+        F16_NHWC = ("float16", "NHWC")
+        F16_HWCN = ("float16", "HWCN")
+        F16_NDHWC = ("float16", "NDHWC")
+        F16_NCDHW = ("float16", "NCDHW")
+        F16_DHWCN = ("float16", "DHWCN")
+        F16_NDC1HWC0 = ("float16", "NDC1HWC0")
+        F16_FRACTAL_Z_3D = ("float16", "FRACTAL_Z_3D")
+        F16_FracZNLSTM = ("float16", "FRACTAL_ZN_LSTM")
+        F16_FracZNRNN = ("float16", "FRACTAL_ZN_RNN")
+        F16_ND_RNNBIAS = ("float16", "ND_RNN_BIAS")
+        F16_ChannelLast = ("float16", "ChannelLast")
+
+        F32_None = ("float32", "")
+        F32_Default = ("float32", "DefaultFormat")
+        F32_5HD = ("float32", "NC1HWC0")
+        F32_FracZ = ("float32", "FRACTAL_Z")
+        F32_FracNZ = ("float32", "FRACTAL_NZ")
+        F32_C1HWNCoC0 = ("float32", "C1HWNCoC0")
+        F32_NCHW = ("float32", "NCHW")
+        F32_NHWC = ("float32", "NHWC")
+        F32_HWCN = ("float32", "HWCN")
+        F32_NDHWC = ("float32", "NDHWC")
+        F32_NCDHW = ("float32", "NCDHW")
+        F32_DHWCN = ("float32", "DHWCN")
+        F32_NDC1HWC0 = ("float32", "NDC1HWC0")
+        F32_FRACTAL_Z_3D = ("float32", "FRACTAL_Z_3D")
+        F32_FracZNLSTM = ("float32", "FRACTAL_ZN_LSTM")
+        F32_FracZNRNN = ("float32", "FRACTAL_ZN_RNN")
+        F32_ND_RNNBIAS = ("float32", "ND_RNN_BIAS")
+        F32_ChannelLast = ("float32", "ChannelLast")
+
+        F64_None = ("float64", "")
+        F64_Default = ("float64", "DefaultFormat")
+        F64_5HD = ("float64", "NC1HWC0")
+        F64_FracZ = ("float64", "FRACTAL_Z")
+        F64_FracNZ = ("float64", "FRACTAL_NZ")
+        F64_C1HWNCoC0 = ("float64", "C1HWNCoC0")
+        F64_NCHW = ("float64", "NCHW")
+        F64_NHWC = ("float64", "NHWC")
+        F64_HWCN = ("float64", "HWCN")
+        F64_NDHWC = ("float64", "NDHWC")
+        F64_ChannelLast = ("float64", "ChannelLast")
+
+        C64_Default = ("complex64", "DefaultFormat")
+        C128_Default = ("complex128", "DefaultFormat")
+    """
+
+    None_None = ("", "")
+    None_Default = ("", "DefaultFormat")
+
+    BOOL_None = ("bool", "")
+    BOOL_Default = ("bool", "DefaultFormat")
+    BOOL_5HD = ("bool", "NC1HWC0")
+    BOOL_FracZ = ("bool", "FRACTAL_Z")
+    BOOL_FracNZ = ("bool", "FRACTAL_NZ")
+    BOOL_C1HWNCoC0 = ("bool", "C1HWNCoC0")
+    BOOL_NCHW = ("bool", "NCHW")
+    BOOL_NHWC = ("bool", "NHWC")
+    BOOL_HWCN = ("bool", "HWCN")
+    BOOL_NDHWC = ("bool", "NDHWC")
+    BOOL_ChannelLast = ("bool", "ChannelLast")
+    BOOL_Default_Tuple = ("bool", "DefaultFormat", "tuple")
+    BOOL_Default_List = ("bool", "DefaultFormat", "list")
+
+    I8_None = ("int8", "")
+    I8_Default = ("int8", "DefaultFormat")
+    I8_5HD = ("int8", "NC1HWC0")
+    I8_FracZ = ("int8", "FRACTAL_Z")
+    I8_FracNZ = ("int8", "FRACTAL_NZ")
+    I8_C1HWNCoC0 = ("int8", "C1HWNCoC0")
+    I8_NCHW = ("int8", "NCHW")
+    I8_NHWC = ("int8", "NHWC")
+    I8_HWCN = ("int8", "HWCN")
+    I8_NDHWC = ("int8", "NDHWC")
+    I8_NCDHW = ("int8", "NCDHW")
+    I8_ChannelLast = ("int8", "ChannelLast")
+    I8_NDC1HWC0 = ("int8", "NDC1HWC0")
+    I8_NC1HWC0 = ("int8", "NC1HWC0")
+    I8_Default_Tuple = ("int8", "DefaultFormat", "tuple")
+    I8_Default_List = ("int8", "DefaultFormat", "list")
+
+    U8_None = ("uint8", "")
+    U8_Default = ("uint8", "DefaultFormat")
+    U8_5HD = ("uint8", "NC1HWC0")
+    U8_FracZ = ("uint8", "FRACTAL_Z")
+    U8_FracNZ = ("uint8", "FRACTAL_NZ")
+    U8_C1HWNCoC0 = ("uint8", "C1HWNCoC0")
+    U8_NCHW = ("uint8", "NCHW")
+    U8_NHWC = ("uint8", "NHWC")
+    U8_HWCN = ("uint8", "HWCN")
+    U8_NDHWC = ("uint8", "NDHWC")
+    U8_NCDHW = ("uint8", "NCDHW")
+    U8_ChannelLast = ("uint8", "ChannelLast")
+    U8_NDC1HWC0 = ("uint8", "NDC1HWC0")
+    U8_NC1HWC0 = ("uint8", "NC1HWC0")
+    U8_Default_Tuple = ("uint8", "DefaultFormat", "tuple")
+    U8_Default_List = ("uint8", "DefaultFormat", "list")
+
+    I16_None = ("int16", "")
+    I16_Default = ("int16", "DefaultFormat")
+    I16_5HD = ("int16", "NC1HWC0")
+    I16_FracZ = ("int16", "FRACTAL_Z")
+    I16_FracNZ = ("int16", "FRACTAL_NZ")
+    I16_C1HWNCoC0 = ("int16", "C1HWNCoC0")
+    I16_NCHW = ("int16", "NCHW")
+    I16_NHWC = ("int16", "NHWC")
+    I16_HWCN = ("int16", "HWCN")
+    I16_NDHWC = ("int16", "NDHWC")
+    I16_ChannelLast = ("int16", "ChannelLast")
+    I16_Default_Tuple = ("int16", "DefaultFormat", "tuple")
+    I16_Default_List = ("int16", "DefaultFormat", "list")
+
+    U16_None = ("uint16", "")
+    U16_Default = ("uint16", "DefaultFormat")
+    U16_5HD = ("uint16", "NC1HWC0")
+    U16_FracZ = ("uint16", "FRACTAL_Z")
+    U16_FracNZ = ("uint16", "FRACTAL_NZ")
+    U16_C1HWNCoC0 = ("uint16", "C1HWNCoC0")
+    U16_NCHW = ("uint16", "NCHW")
+    U16_NHWC = ("uint16", "NHWC")
+    U16_HWCN = ("uint16", "HWCN")
+    U16_NDHWC = ("uint16", "NDHWC")
+    U16_ChannelLast = ("uint16", "ChannelLast")
+    U16_Default_Tuple = ("uint16", "DefaultFormat", "tuple")
+    U16_Default_List = ("uint16", "DefaultFormat", "list")
+
+    I32_None = ("int32", "")
+    I32_Default = ("int32", "DefaultFormat")
+    I32_5HD = ("int32", "NC1HWC0")
+    I32_FracZ = ("int32", "FRACTAL_Z")
+    I32_FracNZ = ("int32", "FRACTAL_NZ")
+    I32_C1HWNCoC0 = ("int32", "C1HWNCoC0")
+    I32_NCHW = ("int32", "NCHW")
+    I32_NHWC = ("int32", "NHWC")
+    I32_HWCN = ("int32", "HWCN")
+    I32_NDHWC = ("int32", "NDHWC")
+    I32_NDC1HWC0 = ("int32", "NDC1HWC0")
+    I32_NCDHW = ("int32", "NCDHW")
+    I32_ChannelLast = ("int32", "ChannelLast")
+    I32_Default_Tuple = ("int32", "DefaultFormat", "tuple")
+    I32_Default_List = ("int32", "DefaultFormat", "list")
+
+    U32_None = ("uint32", "")
+    U32_Default = ("uint32", "DefaultFormat")
+    U32_5HD = ("uint32", "NC1HWC0")
+    U32_FracZ = ("uint32", "FRACTAL_Z")
+    U32_FracNZ = ("uint32", "FRACTAL_NZ")
+    U32_C1HWNCoC0 = ("uint32", "C1HWNCoC0")
+    U32_NCHW = ("uint32", "NCHW")
+    U32_NHWC = ("uint32", "NHWC")
+    U32_HWCN = ("uint32", "HWCN")
+    U32_NDHWC = ("uint32", "NDHWC")
+    U32_ChannelLast = ("uint32", "ChannelLast")
+    U32_Default_Tuple = ("uint32", "DefaultFormat", "tuple")
+    U32_Default_List = ("uint32", "DefaultFormat", "list")
+
+    I64_None = ("int64", "")
+    I64_Default = ("int64", "DefaultFormat")
+    I64_5HD = ("int64", "NC1HWC0")
+    I64_FracZ = ("int64", "FRACTAL_Z")
+    I64_FracNZ = ("int64", "FRACTAL_NZ")
+    I64_C1HWNCoC0 = ("int64", "C1HWNCoC0")
+    I64_NCHW = ("int64", "NCHW")
+    I64_NHWC = ("int64", "NHWC")
+    I64_HWCN = ("int64", "HWCN")
+    I64_NDHWC = ("int64", "NDHWC")
+    I64_ChannelLast = ("int64", "ChannelLast")
+    I64_Default_Tuple = ("int64", "DefaultFormat", "tuple")
+    I64_Default_List = ("int64", "DefaultFormat", "list")
+
+    U64_None = ("uint64", "")
+    U64_Default = ("uint64", "DefaultFormat")
+    U64_5HD = ("uint64", "NC1HWC0")
+    U64_FracZ = ("uint64", "FRACTAL_Z")
+    U64_FracNZ = ("uint64", "FRACTAL_NZ")
+    U64_C1HWNCoC0 = ("uint64", "C1HWNCoC0")
+    U64_NCHW = ("uint64", "NCHW")
+    U64_NHWC = ("uint64", "NHWC")
+    U64_HWCN = ("uint64", "HWCN")
+    U64_NDHWC = ("uint64", "NDHWC")
+    U64_ChannelLast = ("uint64", "ChannelLast")
+    U64_Default_Tuple = ("uint64", "DefaultFormat", "tuple")
+    U64_Default_List = ("uint64", "DefaultFormat", "list")
+
+    F16_None = ("float16", "")
+    F16_Default = ("float16", "DefaultFormat")
+    F16_5HD = ("float16", "NC1HWC0")
+    F16_FracZ = ("float16", "FRACTAL_Z")
+    F16_FracNZ = ("float16", "FRACTAL_NZ")
+    F16_C1HWNCoC0 = ("float16", "C1HWNCoC0")
+    F16_NCHW = ("float16", "NCHW")
+    F16_NHWC = ("float16", "NHWC")
+    F16_HWCN = ("float16", "HWCN")
+    F16_NDHWC = ("float16", "NDHWC")
+    F16_NCDHW = ("float16", "NCDHW")
+    F16_DHWCN = ("float16", "DHWCN")
+    F16_NDC1HWC0 = ("float16", "NDC1HWC0")
+    F16_FRACTAL_Z_3D = ("float16", "FRACTAL_Z_3D")
+    F16_FracZNLSTM = ("float16", "FRACTAL_ZN_LSTM")
+    F16_FracZNRNN = ("float16", "FRACTAL_ZN_RNN")
+    F16_ND_RNNBIAS = ("float16", "ND_RNN_BIAS")
+    F16_ChannelLast = ("float16", "ChannelLast")
+    F16_Default_Tuple = ("float16", "DefaultFormat", "tuple")
+    F16_Default_List = ("float16", "DefaultFormat", "list")
+
+    F32_None = ("float32", "")
+    F32_Default = ("float32", "DefaultFormat")
+    F32_5HD = ("float32", "NC1HWC0")
+    F32_FracZ = ("float32", "FRACTAL_Z")
+    F32_FracNZ = ("float32", "FRACTAL_NZ")
+    F32_C1HWNCoC0 = ("float32", "C1HWNCoC0")
+    F32_NCHW = ("float32", "NCHW")
+    F32_NHWC = ("float32", "NHWC")
+    F32_HWCN = ("float32", "HWCN")
+    F32_NDHWC = ("float32", "NDHWC")
+    F32_NCDHW = ("float32", "NCDHW")
+    F32_DHWCN = ("float32", "DHWCN")
+    F32_NDC1HWC0 = ("float32", "NDC1HWC0")
+    F32_FRACTAL_Z_3D = ("float32", "FRACTAL_Z_3D")
+    F32_FracZNLSTM = ("float32", "FRACTAL_ZN_LSTM")
+    F32_FracZNRNN = ("float32", "FRACTAL_ZN_RNN")
+    F32_ND_RNNBIAS = ("float32", "ND_RNN_BIAS")
+    F32_ChannelLast = ("float32", "ChannelLast")
+    F32_Default_Tuple = ("float32", "DefaultFormat", "tuple")
+    F32_Default_List = ("float32", "DefaultFormat", "list")
+
+    F64_None = ("float64", "")
+    F64_Default = ("float64", "DefaultFormat")
+    F64_5HD = ("float64", "NC1HWC0")
+    F64_FracZ = ("float64", "FRACTAL_Z")
+    F64_FracNZ = ("float64", "FRACTAL_NZ")
+    F64_C1HWNCoC0 = ("float64", "C1HWNCoC0")
+    F64_NCHW = ("float64", "NCHW")
+    F64_NHWC = ("float64", "NHWC")
+    F64_HWCN = ("float64", "HWCN")
+    F64_NDHWC = ("float64", "NDHWC")
+    F64_ChannelLast = ("float64", "ChannelLast")
+    F64_Default_Tuple = ("float64", "DefaultFormat", "tuple")
+    F64_Default_List = ("float64", "DefaultFormat", "list")
+
+    C64_Default = ("complex64", "DefaultFormat")
+    C128_Default = ("complex128", "DefaultFormat")
+    C64_Default_Tuple = ("complex64", "DefaultFormat", "tuple")
+    C128_Default_Tuple = ("complex128", "DefaultFormat", "tuple")