mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/op_info_register.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# 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.
@@ -21,15 +21,222 @@ 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"
 
 
+def _get_reg_info_attr(op_info, attr_name):
+    """get attr value"""
+    for _, item in enumerate(op_info.get("attr", [])):
+        if item.get("name") == attr_name:
+            return item.get("defaultValue")
+    return None
+
+
+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, 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 open(lock_file, "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.abspath(__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("name")
+            attrs_name.append(attr_name)
+            key = "attr_" + attr_name
+            op_info[key] = {}
+            for k, v in item.items():
+                if k != "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] = {"name": item.get("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
+
+    def _gen_ai_cpu_reg_info(self, 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 open(lock_file, "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"]:
+                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.
@@ -125,6 +332,12 @@ def custom_info_register(*reg_info):
 
     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):
@@ -140,7 +353,7 @@ class RegOp:
     Base class for op info register.
 
     Args:
-        op_name (str): Name of op.
+        op_name (str): Name of operator.
     """
 
     def __init__(self, op_name=""):
@@ -317,9 +530,9 @@ class CpuRegOp(RegOp):
         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.
+            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]
@@ -334,9 +547,9 @@ class CpuRegOp(RegOp):
         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.
+            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]
@@ -351,9 +564,9 @@ class CpuRegOp(RegOp):
         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.
+            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]
@@ -377,9 +590,9 @@ class AkgRegOp(RegOp):
         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.
+            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]
@@ -394,8 +607,8 @@ class AkgRegOp(RegOp):
         Register Akg op output information.
 
         Args:
-            index (int): Order of the output. Default: None.
-            name (str): Name of the output. Default: None.
+            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]
@@ -410,9 +623,9 @@ class AkgRegOp(RegOp):
         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.
+            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]
@@ -446,10 +659,10 @@ class AkgCpuRegOp(AkgRegOp):
 
 class AiCPURegOp(CpuRegOp):
     r"""
-    Class for AiCPU operator information register.
+    Class for AiCPU operator information registration.
 
     Args:
-        op_name (str):kernel name.
+        op_name (str): Name of operator.
 
     Examples:
         >>> from mindspore.ops import AiCPURegOp, DataType
@@ -481,26 +694,39 @@ class AiCPURegOp(CpuRegOp):
 
 class TBERegOp(RegOp):
     r"""
-    Class for TBE operator information register.
+    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):kernel name.
+        op_name (str): Name of operator.
 
     Examples:
         >>> from mindspore.ops import TBERegOp, DataType
-        >>> abs_op_info = TBERegOp("Abs") \
+        >>> op_name_op_info = TBERegOp("OpName") \
         ...    .fusion_type("ELEMWISE") \
         ...    .async_flag(False) \
-        ...    .binfile_name("abs.so") \
+        ...    .binfile_name("op_name.so") \
         ...    .compute_cost(10) \
-        ...    .kernel_name("abs") \
+        ...    .kernel_name("op_name") \
         ...    .partial_flag(True) \
         ...    .op_pattern("formatAgnostic") \
-        ...    .input(0, "x", None, "required", None) \
+        ...    .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") \
-        ...    .dtype_format(DataType.F16_None, DataType.F16_None) \
-        ...    .dtype_format(DataType.F32_None, DataType.F32_None) \
-        ...    .dtype_format(DataType.I32_None, DataType.I32_None) \
+        ...    .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()
         >>>
     """
@@ -545,7 +771,7 @@ class TBERegOp(RegOp):
                                          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.
+                                         Default: ``False`` .
         """
         self._is_bool(dynamic_rank_support)
         self.dynamic_rank_support_ = dynamic_rank_support
@@ -556,7 +782,7 @@ class TBERegOp(RegOp):
         Description operator front end and tbe operator input mapping.
 
         Args:
-            real_input_index (list): Value of real_input_index. Default: ().
+            real_input_index (list): Value of real_input_index. Default: ``()`` .
         """
         RegOp._is_list(real_input_index)
         self.real_input_index_ = real_input_index
@@ -567,7 +793,7 @@ class TBERegOp(RegOp):
         Description the index of input need to cast to attr.
 
         Args:
-            input_to_attr_index (list): Value of input_to_attr_index. Default: ().
+            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
@@ -578,7 +804,7 @@ class TBERegOp(RegOp):
         Define the calculation efficiency of the operator, whether the asynchronous calculation is supported.
 
         Args:
-            async_flag (bool): Value of async flag. Default: false.
+            async_flag (bool): Value of async flag. Default: ``False`` .
         """
         self._is_bool(async_flag)
         self.async_flag_ = async_flag
@@ -601,7 +827,7 @@ class TBERegOp(RegOp):
         in the tiling module.
 
         Args:
-            compute_cost (int): Value of compute cost. Default: 10.
+            compute_cost (int): Value of compute cost. Default: ``10`` .
         """
         self._is_int(compute_cost)
         self.compute_cost_ = compute_cost
@@ -623,7 +849,7 @@ class TBERegOp(RegOp):
         Define the calculation efficiency of operator, whether the partial calculation is supported.
 
         Args:
-            partial_flag (bool): Value of partial flag. Default: true.
+            partial_flag (bool): Value of partial flag. Default: ``True`` .
         """
         self._is_bool(partial_flag)
         self.partial_flag_ = partial_flag
@@ -648,7 +874,7 @@ class TBERegOp(RegOp):
         Whether the operator supports dynamic shape.
 
         Args:
-            dynamic_shape (bool): Value of dynamic shape. Default: false.
+            dynamic_shape (bool): Value of dynamic shape. Default: ``False`` .
         """
         self._is_bool(dynamic_shape)
         self.dynamic_shape_support_ = dynamic_shape
@@ -659,7 +885,7 @@ class TBERegOp(RegOp):
         Whether the operator supports dynamic compile static.
 
         Args:
-            dynamic_compile_static (bool): Value of dynamic compile static. Default: false.
+            dynamic_compile_static (bool): Value of dynamic compile static. Default: ``False`` .
         """
         self._is_bool(dynamic_compile_static)
         self.dynamic_compile_static_ = dynamic_compile_static
@@ -670,7 +896,7 @@ class TBERegOp(RegOp):
         Whether the operator needs check supports.
 
         Args:
-            need_check_supported (bool): Value of need_check_supported. Default: false.
+            need_check_supported (bool): Value of need_check_supported. Default: ``False`` .
         """
         self._is_bool(need_check_supported)
         self.need_check_support_ = need_check_supported
@@ -681,7 +907,7 @@ class TBERegOp(RegOp):
         Whether the operator needs calop_select_format api.
 
         Args:
-            is_dynamic_format (bool): Value of is_dynamic_format. Default: false.
+            is_dynamic_format (bool): Value of is_dynamic_format. Default: ``False`` .
         """
         self._is_bool(is_dynamic_format)
         self.dynamic_format_ = is_dynamic_format
@@ -692,7 +918,7 @@ class TBERegOp(RegOp):
         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.
+            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
@@ -703,11 +929,11 @@ class TBERegOp(RegOp):
         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.
+            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]
@@ -722,12 +948,12 @@ class TBERegOp(RegOp):
         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.
+            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]
@@ -746,11 +972,11 @@ class TBERegOp(RegOp):
         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.
+            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]
@@ -770,7 +996,7 @@ class CustomRegOp(RegOp):
     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".
+            Default: ``"Custom"`` .
 
     Examples:
         >>> from mindspore.ops import CustomRegOp, DataType
@@ -796,17 +1022,18 @@ class CustomRegOp(RegOp):
 
         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.
+                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"`` , ``"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.
+                - ``"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.
 
@@ -814,6 +1041,11 @@ class CustomRegOp(RegOp):
             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.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -831,17 +1063,17 @@ class CustomRegOp(RegOp):
 
         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.
+                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"`` , ``"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.
+                - ``"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.
 
@@ -849,6 +1081,11 @@ class CustomRegOp(RegOp):
             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.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -872,6 +1109,11 @@ class CustomRegOp(RegOp):
 
         Raises:
             ValueError: If the size of `args` not equal to the sum of input tensors and output tensors.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         io_nums = len(self.inputs) + len(self.outputs)
         if len(args) != io_nums:
@@ -888,18 +1130,18 @@ class CustomRegOp(RegOp):
         `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.
+            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.
+                "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.
@@ -914,9 +1156,9 @@ class CustomRegOp(RegOp):
                 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.
+                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:
@@ -924,6 +1166,11 @@ class CustomRegOp(RegOp):
             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.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [name, param_type, value_type, default_value]
         key_list = ["name", "paramType", "type", "defaultValue"]
@@ -940,10 +1187,16 @@ class CustomRegOp(RegOp):
             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.
+                for. If ``None`` , it will be inferred automatically inside :class:`mindspore.ops.Custom`.
+                Default: ``None`` .
 
         Raises:
             TypeError: If `target` is neither str nor None.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         if target is not None:
             self._is_string(target)
@@ -954,12 +1207,19 @@ class CustomRegOp(RegOp):
         """
         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.
+
+        Tutorial Examples:
+            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
+              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
+              defining-custom-operator-of-aicpu-type>`_
         """
         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