mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/operations/custom_ops.py

@@ -62,27 +62,6 @@ def _get_cache_path():
     return cache_path
 
 
-def _get_cuda_bare_metal_version():
-    """
-    Automatically get the cuda version.
-
-    Returns:
-        tuple(str), the version of cuda of the platform.ss
-    """
-    raw_output = subprocess.check_output(["nvcc", "-V"],
-                                         universal_newlines=True)
-    output = raw_output.split()
-    release_idx = output.index("release") + 1
-    release = output[release_idx].split(".")
-    version_major = release[0]
-    version_idx = release_idx + 1
-    version = output[version_idx].split(".")
-    version_middle = version[1] if len(version) > 1 else 0
-    version_minor = version[2] if len(version) > 2 else 0
-
-    return int(version_major), int(version_middle), int(version_minor)
-
-
 def _compile_aot(file):
     """
     Automatically compile the source file for custom aot
@@ -99,11 +78,7 @@ def _compile_aot(file):
         cache_path = os.path.join(cache_path, "rank_" + str(get_rank()), "")
         os.makedirs(cache_path, exist_ok=True)
 
-    search_res = importlib.util.find_spec("mindspore")
-    if search_res is None:
-        raise RuntimeError("Cannot find mindspore module!")
-
-    res_path = search_res.origin
+    res_path = importlib.util.find_spec("mindspore").origin
     find_pos = res_path.find("__init__.py")
     if find_pos == -1:
         raise RuntimeError(
@@ -111,9 +86,8 @@ def _compile_aot(file):
     include_file = "-I{}include/api/".format(res_path[:find_pos])
 
     file_name = file.split('/')[-1]
-    file_folder = file[:file.rindex('/')]
     func_path = cache_path + file_name + ".so"
-    include_file = "{} -I{}".format(include_file, file_folder)
+    include_file = "{} -I{}".format(include_file, file[:file.rindex('/')])
 
     if func_path not in Custom.compiled_bin:
         Custom.compiled_bin.append(func_path)
@@ -127,10 +101,23 @@ def _compile_aot(file):
             cmd += ["--use_fast_math", "--expt-relaxed-constexpr"]
             cmd += ["-D_GLIBCXX_USE_CXX11_ABI=0"]
 
+            def _get_cuda_bare_metal_version():
+                raw_output = subprocess.check_output(["nvcc", "-V"],
+                                                     universal_newlines=True)
+                output = raw_output.split()
+                release_idx = output.index("release") + 1
+                release = output[release_idx].split(".")
+                version_idx = release_idx + 1
+                version = output[version_idx].split(".")
+                version_middle = version[1] if len(version) > 1 else 0
+                version_minor = version[2] if len(version) > 2 else 0
+
+                return int(release[0]), int(version_middle), int(version_minor)
+
             v_major, v_mid, v_minor = _get_cuda_bare_metal_version()
             if v_major >= 11:
                 cmd += ["-gencode", "arch=compute_80,code=sm_80", "--expt-extended-lambda"]
-            elif v_major == 10 and not(v_mid >= 1 and v_minor >= 168):
+            elif v_major == 10 and not (v_mid >= 1 and v_minor >= 168):
                 logger.warning("The current version of nvcc, V{}.{}.{},  might have unfixed issues with std string, "
                                "which will lead to errors in aot custom op with attrs."
                                "The version higher than V10.1.168 is recommended".format(v_major, v_mid, v_minor))
@@ -159,10 +146,11 @@ class Custom(ops.PrimitiveWithInfer):
     function if needed. Then these `Custom` objects can be directly used in neural networks.
     Detailed description and introduction of user-defined operators, including correct writing of parameters,
     please refer to `Custom Operators Tutorial
-    <https://www.mindspore.cn/tutorials/experts/en/r2.0/operation/op_custom.html>`_ .
+    <https://www.mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html>`_ .
 
     .. warning::
-        This is an experimental API that is subject to change.
+        - This is an experimental API that is subject to change.
+        - Currently, the functionality of Custom does not support Ascend 910B.
 
     .. note::
         The supported platforms are determined by the input `func_type`. The supported platforms are as follows:
@@ -175,6 +163,12 @@ class Custom(ops.PrimitiveWithInfer):
         - "julia": supports ["CPU"].
         - "aicpu": supports ["Ascend"].
 
+        If run on ge backend, use `CustomRegOp` to generate the registration information of "aicpu" and "tbe" operator,
+        use `custom_info_register` to bind the registration information to the `func` of the "tbe" operator,
+        then save the registration information of "aicpu" operator and the `func` implementation of "tbe" operator to
+        a file or separate files, keep these files in a separate directory, and set the absolute path of this directory
+        to environment variable "MS_DEV_CUSTOM_OPP_PATH" before running the network.
+
     Args:
         func (Union[function, str]):
 
@@ -265,7 +259,7 @@ class Custom(ops.PrimitiveWithInfer):
                        (ex. Custom(func="./add.jl:Add:add", out_shape=[1], out_dtype=mstype.float32, "julia"))
 
         out_shape (Union[function, list, tuple]): The output shape infer function or the value of output shape of
-            `func`. Default: None.
+            `func`. Default: ``None`` .
 
             If func has single output, then the value of output shape is a list or tuple of int.
 
@@ -276,7 +270,7 @@ class Custom(ops.PrimitiveWithInfer):
             shape mechanic will be enabled.
 
         out_dtype (Union[function, :class:`mindspore.dtype`, tuple[:class:`mindspore.dtype`]]): The output data type
-            infer function or the value of output data type of `func`. Default: None.
+            infer function or the value of output data type of `func`. Default: ``None`` .
 
             If func has single output, then the value of output shape is a `mindspore.dtype`.
 
@@ -288,23 +282,23 @@ class Custom(ops.PrimitiveWithInfer):
 
         func_type (str): The implementation type of `func`, should be one of
 
-            ["hybrid", "akg", "tbe", "aot", "pyfunc", "julia", "aicpu"].
+            [ ``"hybrid"`` , ``"akg"`` , ``"tbe"`` , ``"aot"`` , ``"pyfunc"`` , ``"julia"`` , ``"aicpu"`` ].
 
-            Each `func_type` only supports specific platforms(targets). Default: "hybrid".
+            Each `func_type` only supports specific platforms(targets). Default: ``"hybrid"`` .
             The supported platforms of `func_type`:
 
-            - "hybrid": supports ["Ascend", "GPU", "CPU"].
-            - "akg": supports ["Ascend", "GPU", "CPU"].
-            - "tbe": supports ["Ascend"].
-            - "aot": supports ["GPU", "CPU"].
-            - "pyfunc": supports ["CPU"].
-            - "julia": supports ["CPU"].
-            - "aicpu": supports ["Ascend"].
+            - ``"hybrid"``: supports ["Ascend", "GPU", "CPU"].
+            - ``"akg"``: supports ["Ascend", "GPU", "CPU"].
+            - ``"tbe"``: supports ["Ascend"].
+            - ``"aot"``: supports ["GPU", "CPU"].
+            - ``"pyfunc"``: supports ["CPU"].
+            - ``"julia"``: supports ["CPU"].
+            - ``"aicpu"``: supports ["Ascend"].
 
-        bprop (function): The back propagation function of `func`. Default: None.
+        bprop (function): The back propagation function of `func`. Default: ``None`` .
         reg_info (Union[str, dict, list, tuple]): Represents the registration information(reg info) of `func` with
             json format of type str or dict. The reg info specifies supported data types and formats of inputs and
-            outputs, attributes and target of `func`. Default: None.
+            outputs, attributes and target of `func`. Default: ``None`` .
 
             If reg info is a list or tuple, then each item should be with json format of type str or dict, which
             represents the registration information of `func` in a specific target. You need to invoke `CustomRegOp`
@@ -457,6 +451,7 @@ class Custom(ops.PrimitiveWithInfer):
     tbe_path_checked = []  # Save paths for tbe functions which is safe to be imported as module.
     tbe_path_failed = []  # Save paths for tbe functions which fail to be imported as module.
     op_path_in_cache = []  # Save paths for op functions created in the cached.
+    custom_aot_warning = True  # Flag to enable warnings about custom aot path white list
 
     def __init__(self, func, out_shape=None, out_dtype=None, func_type="hybrid", bprop=None, reg_info=None):
         ops.PrimitiveWithInfer.__init__(self, "Custom")
@@ -473,6 +468,7 @@ class Custom(ops.PrimitiveWithInfer):
         self._func_compile_attrs = {}
         self._is_ms_kernel = False
 
+        self._check_platform()
         self._check_func()
         self._update_func_info(reg_info)
         self.add_prim_attr("func_name", self.func_name)
@@ -487,21 +483,24 @@ class Custom(ops.PrimitiveWithInfer):
             self.add_prim_attr("fn_id", func_id)
 
         self.out_shape = out_shape
+        if self.out_shape is None and self.func_type == "aot":
+            self.add_prim_attr("cpp_infer_shape", True)
         self.out_dtype = out_dtype
         self.bprop = bprop
-        self._update_op_attr()
+        self.fake_output = False
+        self.single_scalar_output = False
+        if not self.out_dtype:
+            self.fake_output = True
+        elif not self.out_shape:
+            self.single_scalar_output = True
+        self.add_prim_attr("fake_output", self.fake_output)
+        self.add_prim_attr("single_scalar_output", self.single_scalar_output)
+
         # Register info
         self._register_info(reg_info)
 
         if func_type == "akg":
-            self.add_prim_attr('func_source_str', self.func_source_str)
-            if "ir_builder" in self.func_source_str:
-                self.func_type = "ir_builder"
-            elif "compute" in self.func_source_str:
-                self.func_type = "tvm_compute"
-            else:
-                self.func_type = "hybrid"
-                self._hybrid_func_analyser()
+            self._set_akg_kernel_type()
 
         if not self.bprop and self.func_type == "hybrid":
             self._hybrid_autodiff(func_type)
@@ -510,7 +509,6 @@ class Custom(ops.PrimitiveWithInfer):
         self._update_attr()
 
     def __infer__(self, *args):
-        """Infer function of the custom op"""
         if callable(self.out_shape):
             infer_shape = self.out_shape(*(x["shape"] for x in args))
         else:
@@ -570,21 +568,17 @@ class Custom(ops.PrimitiveWithInfer):
         return out
 
     def get_bprop(self):
-        """Get the bprop of the custom op"""
         return self.bprop
 
-    def _update_op_attr(self):
-        """Update the attrs of the custom op"""
-        if self.out_shape is None and self.func_type == "aot":
-            self.add_prim_attr("cpp_infer_shape", True)
-        self.fake_output = False
-        self.single_scalar_output = False
-        if not self.out_dtype:
-            self.fake_output = True
-        elif not self.out_shape:
-            self.single_scalar_output = True
-        self.add_prim_attr("fake_output", self.fake_output)
-        self.add_prim_attr("single_scalar_output", self.single_scalar_output)
+    def _set_akg_kernel_type(self):
+        self.add_prim_attr('func_source_str', self.func_source_str)
+        if "ir_builder" in self.func_source_str:
+            self.func_type = "ir_builder"
+        elif "compute" in self.func_source_str:
+            self.func_type = "tvm_compute"
+        else:
+            self.func_type = "hybrid"
+            self._hybrid_func_analyser()
 
     def _check_julia_func(self):
         """Check the validity of julia func"""
@@ -602,6 +596,10 @@ class Custom(ops.PrimitiveWithInfer):
                 raise Exception("{}, function {} is not found in source file {}!"
                                 .format(self.log_prefix, func, source_file))
 
+    def _check_platform(self):
+        if platform.system() != 'Linux':
+            raise Exception("Custom op only supported on Linux platform currently.")
+
     def _check_func(self):
         """Check the validity of func_type and type of func"""
         if self.func_type not in self.supported_func_type:
@@ -617,7 +615,19 @@ class Custom(ops.PrimitiveWithInfer):
                     "{}, 'func' should be like 'file_name:func_name', but got {}".format(
                         self.log_prefix, self.func))
             file_path = os.path.abspath(file_name_list[0])
-            if not file_path.endswith("so"):
+            if os.environ.get('MS_CUSTOM_AOT_WHITE_LIST') is None:
+                if Custom.custom_aot_warning:
+                    logger.warning("{}, no white list is set and it might cause problems. "
+                                   "Set the legal path of the file in MS_CUSTOM_AOT_WHITE_LIST"
+                                   .format(self.log_prefix))
+                    Custom.custom_aot_warning = False
+            else:
+                legal_path = os.path.abspath(os.environ.get('MS_CUSTOM_AOT_WHITE_LIST'))
+                if legal_path not in file_path:
+                    raise TypeError(
+                        "{}, the legal path for the file is {}, but the file is {}".format(
+                            self.log_prefix, legal_path, file_path))
+            if file_path.endswith(("cu", "cpp", "cc")):
                 file_path = _compile_aot(file_path)
                 self.func = file_path + ":" + file_name_list[1]
 
@@ -639,7 +649,7 @@ class Custom(ops.PrimitiveWithInfer):
                                "The kernel will be executed as a native python function, which might lead to "
                                "low efficiency. To accelerate the kernel, set the 'func_type' to be \"hybrid\""
                                .format(self.log_prefix))
-        else:
+        elif self.func_type == "tbe":
             if not callable(self.func):
                 raise TypeError("{}, 'func' must be of type function, but got {}"
                                 .format(self.log_prefix, type(self.func)))
@@ -661,10 +671,10 @@ class Custom(ops.PrimitiveWithInfer):
         if file_path not in Custom.tbe_path_failed:
             # As a single file might include multiply functions
             # we will not try the file path which already failed in previous trials
-            mod_spec = importlib.util.spec_from_file_location(
-                self.func_name, file_path)
-            custom_mod = importlib.util.module_from_spec(mod_spec)
             try:
+                mod_spec = importlib.util.spec_from_file_location(
+                    self.func_name, file_path)
+                custom_mod = importlib.util.module_from_spec(mod_spec)
                 mod_spec.loader.exec_module(custom_mod)
             except (ImportError, RecursionError):
                 Custom.tbe_path_failed.append(file_path)
@@ -756,16 +766,21 @@ class Custom(ops.PrimitiveWithInfer):
 
     def _update_reg_attrs(self, reg_info):
         """Update op attrs in reg_info."""
+        output_name_list = []
         for _, item in enumerate(reg_info.get("outputs", [])):
-            output_name_list = []
             if isinstance(item, dict) and item.get("name"):
                 output_name_list.append(item.get("name"))
+        if output_name_list:
             self.add_prim_attr("output_names", output_name_list)
 
         if isinstance(reg_info.get("op_name"), str):
             self.add_prim_attr("reg_op_name", reg_info.get("op_name"))
 
-        if self.func_type == "aot":
+        if self.func_type == "aicpu":
+            self.uniq_name = reg_info["op_name"]
+            self.add_prim_attr("uniq_name", self.uniq_name)
+
+        if self.func_type in ["aot", "aicpu"]:
             if reg_info.get("attr") is not None and isinstance(reg_info["attr"], list):
                 for item in reg_info["attr"]:
                     if isinstance(item, dict) and item.get("value") is not None:
@@ -852,12 +867,6 @@ class Custom(ops.PrimitiveWithInfer):
             else:
                 Custom.registered_func[func_name] = [target]
 
-    def _get_op_name(self, reg_info):
-        if self.func_type == "aicpu":
-            self.uniq_name = reg_info["op_name"]
-            self.add_prim_attr("uniq_name", self.uniq_name)
-        return self.uniq_name
-
     def _reformat_reg_info(self, reg_info, target):
         """Reformat registration information."""
         if not isinstance(reg_info, dict):
@@ -865,7 +874,7 @@ class Custom(ops.PrimitiveWithInfer):
                             "'CustomRegOp' to generate the registration information, then pass it to 'reg_info' or "
                             "use 'custom_info_register' to bind it to 'func' if 'func' is a function."
                             .format(self.log_prefix, reg_info, type(reg_info)))
-        reg_info["op_name"] = self._get_op_name(reg_info)
+        reg_info["op_name"] = self.uniq_name
         reg_info["imply_type"] = self._get_imply_type(reg_info, target)
         if not isinstance(reg_info.get("fusion_type"), str) or not reg_info["fusion_type"].strip():
             reg_info["fusion_type"] = "OPAQUE"
@@ -926,26 +935,37 @@ class Custom(ops.PrimitiveWithInfer):
         """Save input_names and attr_names of current func."""
         if not isinstance(reg_info, dict):
             return
-        tensor_inputs = reg_info.get("inputs", [])
-        attr = reg_info.get("attr", [])
-        if not isinstance(tensor_inputs, (list, tuple)):
-            tensor_inputs = [tensor_inputs]
-        if not isinstance(attr, (list, tuple)):
-            attr = [attr]
-        # input_names include tensor input names and attr input names
-        input_names = []
-        # attr_names only includes attr input names
+
+        def _get_value_list(key):
+            value = reg_info.get(key, [])
+            if not isinstance(value, (list, tuple)):
+                value = [value]
+            return value
+
+        tensor_inputs = _get_value_list("inputs")
+        attr = _get_value_list("attr")
+        input_names = []  # include tensor input names and attr input names
         attr_names = []
+        pure_input_names = []
         for item in tensor_inputs:
             if isinstance(item, dict) and item.get("name") is not None:
                 input_names.append(item["name"])
-        has_input_name = bool(input_names)
+                pure_input_names.append(item["name"])
+        # attr is converted from inputs only when graph mode or when inputs name is also in reg info
+        attr_to_input_safe = bool(input_names) or context.get_context("mode") == ms.GRAPH_MODE
         for item in attr:
             if isinstance(item, dict) and item.get("name") is not None:
-                if has_input_name or context.get_context("mode") != ms.PYNATIVE_MODE:
+                # for custom op with function tbe, we always add attrs to inputs as we don't
+                # deal with attr value here and leave them to the backend process to fit the
+                # usual process of tbe op compiling in mindspore
+                # for the rest cases, namely aot and aicpu, if we find values for attrs, we
+                # have already add them as prim attr of the op in the fun _update_reg_attrs
+                # add attr name to input name only when the value of attr is None in reg info
+                # as we need to get values of attrs from inputs
+                if attr_to_input_safe and (self.func_type == "tbe" or item.get("value", None) is None):
                     input_names.append(item["name"])
                 attr_names.append(item["name"])
-        cur_attr = {"input_names": input_names, "attr_names": attr_names}
+        cur_attr = {"input_names": input_names, "attr_names": attr_names, "pure_input_names": pure_input_names}
         # If func does not have attr, save current attr.
         # Else, check if current attr is same as previous saved one.
         prev_attr_names = attr_names
@@ -994,7 +1014,12 @@ class Custom(ops.PrimitiveWithInfer):
 
     def _update_attr(self):
         """Add input_names, attr_names, primitive_target to primitive's attr."""
-        # add input_names, attr_names
+
+        def _add_prim_attr(key):
+            value = func_attr.get(key)
+            if value:
+                self.add_prim_attr(key, value)
+
         func_attr = {}
         if callable(self.func):
             inputs_num = len(inspect.signature(self.func).parameters)
@@ -1003,12 +1028,9 @@ class Custom(ops.PrimitiveWithInfer):
         elif isinstance(self.func, str):
             func_attr = Custom.attr_dict.get(self.func)
         if isinstance(func_attr, dict):
-            input_names = func_attr.get("input_names")
-            attr_names = func_attr.get("attr_names")
-            if input_names:
-                self.add_prim_attr("input_names", input_names)
-            if attr_names:
-                self.add_prim_attr("attr_names", attr_names)
+            _add_prim_attr("input_names")
+            _add_prim_attr("attr_names")
+            _add_prim_attr("pure_input_names")
         self._add_prim_target()
         if callable(self.func) and callable(self.out_shape):
             if hasattr(self.out_shape, "type") and getattr(self.out_shape, "type") == "autodiff":
@@ -1065,7 +1087,7 @@ class Custom(ops.PrimitiveWithInfer):
                 arg_dtype = arg["dtype"]
                 # if any value is missing from input, disable infer value
                 enable_infer_value = False
-                if isinstance(arg_dtype, mstype.tensor_type):
+                if isinstance(arg_dtype, mstype.TensorType):
                     arg_dtype = arg_dtype.element_type()
                 fake_arg = np.zeros(arg["shape"]).astype(
                     mstype.dtype_to_nptype(arg_dtype))
@@ -1075,7 +1097,7 @@ class Custom(ops.PrimitiveWithInfer):
 
         if hasattr(fake_output, 'shape'):
             infer_shape = fake_output.shape
-            infer_dtype = mstype.tensor_type(mstype.pytype_to_dtype(fake_output.dtype))
+            infer_dtype = mstype.TensorType(mstype.pytype_to_dtype(fake_output.dtype))
         else:
             infer_shape = (1,)
             infer_dtype = mstype.pytype_to_dtype(fake_output.dtype)

mindspore/ops/operations/debug_ops.py

@@ -43,7 +43,7 @@ def _check_summary_param(name, value, class_name):
         raise ValueError(f"For '{class_name}', the name must be valid string, but got '{n_value}'.")
 
     v_type = value['dtype']
-    validator.check_value_type('value', v_type, [type(mstype.tensor)], class_name)
+    validator.check_value_type('value', v_type, [type(mstype.tensor_type)], class_name)
 
 
 # Note: The return value of the summary operator is not used,
@@ -58,7 +58,7 @@ class ScalarSummary(Primitive):
     This operator will put a scalar to a summary file with protocol buffer format. It must be used with SummaryRecord
     or SummaryCollector, which specify the directory of the summary file. The summary file can
     be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/r2.0/index.html>`_ for details.
+    mindinsight/docs/en/r2.2/index.html>`_ for details.
 
     Inputs:
         - **name** (str) - The name of the input variable, it must not be an empty string.
@@ -104,6 +104,7 @@ class ScalarSummary(Primitive):
             raise ValueError('The Summary is not supported, please without `-s on` and recompile source.')
 
         self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("channel_name", "ms_scalar_summary")
 
     def __call__(self, *args):
         _cache_summary_data(self.name, args[0], args[1])
@@ -114,7 +115,7 @@ class ImageSummary(PrimitiveWithInfer):
     This operator will put an image tensor to a summary file with protocol buffer format. It must be used with
     SummaryRecord or SummaryCollector, which specify the directory of the summary file. The summary file can
     be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/r2.0/index.html>`_ for details.
+    mindinsight/docs/en/r2.2/index.html>`_ for details.
 
     Inputs:
         - **name** (str) - The name of the input variable, it must not be an empty string.
@@ -153,6 +154,7 @@ class ImageSummary(PrimitiveWithInfer):
             raise ValueError('The Summary is not supported, please without `-s on` and recompile source.')
 
         self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("channel_name", "ms_image_summary")
 
     def __infer__(self, name, value):
         _check_summary_param(name, value, self.__class__.__name__)
@@ -175,7 +177,7 @@ class TensorSummary(Primitive):
     This operator will put a tensor to a summary file with protocol buffer format. It must be used with SummaryRecord
     or SummaryCollector, which specify the directory of the summary file. The summary file can
     be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/r2.0/index.html>`_ for details.
+    mindinsight/docs/en/r2.2/index.html>`_ for details.
 
     Inputs:
         - **name** (str) - The name of the input variable.
@@ -221,6 +223,7 @@ class TensorSummary(Primitive):
             raise ValueError('The Summary is not supported, please without `-s on` and recompile source.')
 
         self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("channel_name", "ms_tensor_summary")
 
     def __call__(self, *args):
         _cache_summary_data(self.name, args[0], args[1])
@@ -231,7 +234,7 @@ class HistogramSummary(PrimitiveWithInfer):
     This operator will calculate the histogram of a tensor and put it to a summary file with protocol buffer format.
     It must be used with SummaryRecord or SummaryCollector, which specify the directory of the summary file.
     The summary file can be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/r2.0/index.html>`_ for details.
+    mindinsight/docs/en/r2.2/index.html>`_ for details.
 
     Inputs:
         - **name** (str) - The name of the input variable.
@@ -276,6 +279,7 @@ class HistogramSummary(PrimitiveWithInfer):
             raise ValueError('The Summary is not supported, please without `-s on` and recompile source.')
 
         self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("channel_name", "ms_histogram_summary")
 
     def __infer__(self, name, value):
         _check_summary_param(name, value, self.__class__.__name__)
@@ -380,7 +384,7 @@ class HookBackward(PrimitiveWithInfer):
         hook_fn (Function): Python function. hook function.
         cell_id (str, optional): Used to identify whether the function registered by the hook is actually registered on
                        the specified cell object. For example, 'nn.Conv2d' is a cell object.
-                       The default value of `cell_id` is empty string(""), in this case, the system will automatically
+                       Default: ``""``, in this case, the system will automatically
                        register a value of `cell_id`.
                        The value of `cell_id` currently does not support custom values.
 
@@ -444,7 +448,7 @@ class HookBackward(PrimitiveWithInfer):
 
     def infer_dtype(self, *inputs_type):
         for dtype in inputs_type:
-            validator.check_subclass("input", dtype, [mstype.tensor], self.name)
+            validator.check_subclass("input", dtype, [mstype.tensor_type], self.name)
         if len(inputs_type) == 1:
             return inputs_type[0]
         return inputs_type
@@ -456,10 +460,19 @@ class Print(Primitive):
 
     Refer to :func:`mindspore.ops.print_` for more detail.
 
+    Inputs:
+        - **input_x** (Union[Tensor, bool, int, float, str]) - The graph node to attach to.
+          Supports multiple inputs which are separated by ','.
+
+    Outputs:
+        Tensor, has the same data type and shape as original `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn
         >>> class PrintDemo(nn.Cell):
         ...     def __init__(self):
         ...         super(PrintDemo, self).__init__()
@@ -503,16 +516,16 @@ class Print(Primitive):
 class Assert(PrimitiveWithInfer):
     """
     Asserts whether the given condition is True.
-    If input condition is identified to be false, print a list of the tensor in data.
+    If input condition is identified to be ``False``, print a list of the tensor in data.
 
     Args:
         summarize (int, optional): The number of entries to be printed in each tensor while the given condition is
-            identified to be False. Default: 3.
+            identified to be ``False`` . Default: ``3`` .
 
     Inputs:
         - **condition** (Union[Tensor[bool], bool]) - The condition to be identified.
         - **input_data** (Union[tuple[Tensor], list[Tensor]]) - The tensors to be printed out when the condition
-          is false.
+          is ``False``.
 
     Raises:
         TypeError: If `summarize` is not an int.
@@ -560,5 +573,5 @@ class Assert(PrimitiveWithInfer):
     def infer_dtype(self, condition, inputs):
         validator.check_scalar_or_tensor_types_same({"condition": condition}, [mstype.bool_], self.name)
         for dtype in inputs:
-            validator.check_subclass("input", dtype, [mstype.tensor], self.name)
+            validator.check_subclass("input", dtype, [mstype.tensor_type], self.name)
         return mstype.int32