mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/profiler/profiling.py

@@ -71,15 +71,21 @@ AICORE_METRICS_DICT = {
 class DeviceSupportParam(Enum):
     """The device target enum."""
     CPU = ['start', 'start_profile', 'output_path', 'timeline_limit', 'profile_framework', 'op_time']
-    GPU = ['start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'sync_enable', 'op_time',
-           'profile_framework']
-    ASCEND = ['start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'profile_memory',
-              'parallel_strategy', 'profile_communication', 'aicore_metrics', 'l2_cache', 'op_time', 'ascend_job_id',
-              'profile_framework']
+    GPU = [
+        'start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'sync_enable', 'op_time',
+        'profile_framework'
+    ]
+    ASCEND = [
+        'start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'profile_memory',
+        'parallel_strategy', 'profile_communication', 'aicore_metrics', 'l2_cache', 'op_time', 'ascend_job_id',
+        'profile_framework'
+    ]
 
 
-ALWAYS_VALID_PARAM = ['start', 'start_profile', 'output_path', 'data_process', 'parallel_strategy', 'l2_cache',
-                      'ascend_job_id', 'op_time', 'profile_framework']
+ALWAYS_VALID_PARAM = [
+    'start', 'start_profile', 'output_path', 'data_process', 'parallel_strategy', 'l2_cache',
+    'ascend_job_id', 'op_time', 'profile_framework'
+]
 
 
 def _environment_check():
@@ -161,6 +167,7 @@ def _calculate_dataset_execution_time(input_file, output_file):
         csv_writer.writerow(['Operation', 'Stage', 'Occurrences', 'Avg. time (us)', 'Custom Info'])
         for _, v in execution_time_map.items():
             csv_writer.writerow([v.event, v.stage, v.count, v.average_execution, v.custom_info])
+    os.chmod(output_file, modes)
     logger.info('Successfully calculate the execution time and write it to file: %s.', output_file)
 
 
@@ -188,8 +195,10 @@ def _extract_timeline_item(row, time_line, ts_map):
     # Put the instance event into timeline.
     elif start_end == '2':
         title = row['event'] + '::' + row['stage']
-        event = {'name': title, 'cat': row['module_name'], 'ts': int(row['time_stamp(us)']), 'ph': 'i',
-                 'pid': row['pid'], 'tid': row['tid'], 'args': {'parent_pid': row['parent_pid']}}
+        event = {
+            'name': title, 'cat': row['module_name'], 'ts': int(row['time_stamp(us)']), 'ph': 'i',
+            'pid': row['pid'], 'tid': row['tid'], 'args': {'parent_pid': row['parent_pid']}
+        }
         time_line.append(event)
     else:
         logger.warning("Can not map the start time for item: %s.", row)
@@ -209,8 +218,10 @@ def _parse_host_info(input_file, output_timeline_file, output_memory_file, is_de
     time_line = []
     # ts_map is used to store the start time of each event_stage_tid_pid
     ts_map = {}
-    memory_header = ['tid', 'pid', 'parent_pid', 'module_name', 'event', 'stage', 'level', 'start_end', 'custom_info',
-                     'memory_usage(kB)', 'time_stamp(us)']
+    memory_header = [
+        'tid', 'pid', 'parent_pid', 'module_name', 'event', 'stage', 'level', 'start_end', 'custom_info',
+        'memory_usage(kB)', 'time_stamp(us)'
+    ]
     memory_info = []
     with open(input_file, 'r') as f:
         for row in csv.DictReader(f):
@@ -226,12 +237,12 @@ def _parse_host_info(input_file, output_timeline_file, output_memory_file, is_de
                 logger.error("Error occur when analyse line: %s, Details is: %s", row, e)
                 continue
     if memory_info:
-        with os.fdopen(os.open(output_memory_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
-                       'w') as csv_file:
+        with os.fdopen(os.open(output_memory_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as csv_file:
             csv_writer = csv.DictWriter(csv_file, fieldnames=memory_header)
             csv_writer.writeheader()
             for item in memory_info:
                 csv_writer.writerow(item)
+        os.chmod(output_memory_file, stat.S_IREAD | stat.S_IWRITE)
     else:
         logger.warning("No memory_usage is record in file: %s", input_file)
 
@@ -255,13 +266,23 @@ def _parse_host_info(input_file, output_timeline_file, output_memory_file, is_de
 
     if time_line:
         timeline_file = validate_and_normalize_path(output_timeline_file)
-        with os.fdopen(os.open(timeline_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
-                       'w') as json_file:
+        with os.fdopen(os.open(timeline_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
             json.dump(time_line, json_file)
+        os.chmod(timeline_file, stat.S_IREAD | stat.S_IWRITE)
     else:
         logger.warning("No valid time_stamp is record in file: %s", input_file)
 
 
+def _ascend_graph_msprof_generator(source_path, model_iteration_dict):
+    try:
+        msprof_exporter = AscendMsprofExporter(source_path)
+        msprof_exporter.export(model_iteration_dict)
+    except ProfilerException as err:
+        logger.warning(err.message)
+    finally:
+        pass
+
+
 def _ascend_graph_msprof_analyse(source_path):
     """
     Ascend graph model msprof data analyse.
@@ -287,7 +308,8 @@ class Profiler:
     This class to enable the profiling of MindSpore neural networks.
     MindSpore users can import the mindspore.Profiler, initialize the Profiler object to start profiling,
     and use Profiler.analyse() to stop profiling and analyse the results.
-    Users can visualize the results using the MindInsight tool.
+    Users can visualize the results using the `MindSpore Insight
+    <https://www.mindspore.cn/mindinsight/docs/en/r2.2/index.html>`_ tool.
     Now, Profiler supports AICORE operator, AICPU operator, HostCPU operator, memory,
     correspondence, cluster, etc data analysis.
 
@@ -330,11 +352,16 @@ class Profiler:
             Default value: ``True`` .
         timeline_limit (int, optional): (Ascend/GPU) Set the maximum storage size of the timeline file (unit M).
             When using this parameter, `op_time` must be set to True. Default value: ``500`` .
-        profile_framework (str, optional): (Ascend/GPU) Whether to collect host memory and time, it must be one of
-            ["all", "time", "memory", None]. When is enabled, a subdirectory host_info will be generated in the
+        profile_framework (str, optional): (Ascend/GPU) The host information to collect, it must be one of
+            ["all", "time", "memory", None], When is not set to None, a subdirectory host_info will be generated in the
             specified profiler directory, which stores the collected memory and time files on the Host side.
             Default: "all".
 
+            - "all": Record both host timestamp and host memory usage.
+            - "time": Only record host timestamp.
+            - "memory": Only record host memory usage.
+            - None: Not record host information.
+
     Raises:
         RuntimeError: When the version of CANN does not match the version of MindSpore,
             MindSpore cannot parse the generated ascend_job_id directory structure.
@@ -407,7 +434,6 @@ class Profiler:
         self._rank_size = 1
         self._rank_id = 0
         self._ascend_profiler = None
-        self._ascend_msprof_exporter = None
         self._timeline_size_limit_byte = 500 * 1024 * 1024  # 500MB
         self._parallel_strategy = True
         _environment_check()
@@ -424,6 +450,7 @@ class Profiler:
         self._sync_enable = True
         self._stop_time = 0
         self._dynamic_status = False
+        self._model_iteration_dict = None
         self._profile_framework = "all"
         self._msprof_enable = os.getenv("PROFILER_SAMPLECONFIG")
         if self._msprof_enable:
@@ -476,6 +503,25 @@ class Profiler:
 
         return job_start_time
 
+    @staticmethod
+    def _parse_info_json(info_file):
+        """
+        Parse info log file, get the rank id and device id of the job.
+        Args:
+             input_file (str): The file path of the parse info log file.
+
+        Returns:
+            rank id, device id
+        """
+        with open(info_file, "r") as f:
+            info_dict = json.load(f)
+
+            rank_id = info_dict.get("rank_id", 0)
+            dev_info = info_dict.get("DeviceInfo", [])
+            dev_id = dev_info[0].get("id", -1)
+
+            return str(rank_id), str(dev_id)
+
     def op_analyse(self, op_name, device_id=None):
         """
         Profiler users can use this interface to obtain operator performance data.
@@ -487,8 +533,8 @@ class Profiler:
                 parse. If this interface is used for offline data parsing, Default: ``0`` .
 
         Raises:
-            TypeError: If the op_name parameter type is incorrect.
-            TypeError: If the device_id parameter type is incorrect.
+            TypeError: If the `op_name` parameter type is incorrect.
+            TypeError: If the `device_id` parameter type is incorrect.
             RuntimeError: If MindSpore runs on Ascend, this interface cannot be used.
 
         Supported Platforms:
@@ -501,12 +547,12 @@ class Profiler:
             >>> # Profiler init.
             >>> profiler = Profiler()
             >>> # Train Model or eval Model, taking LeNet5 as an example.
-            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
             >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
             >>> # Create the dataset taking MNIST as an example.
-            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/mnist.py
+            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
             >>> dataloader = create_dataset()
             >>> model = Model(net, loss, optimizer)
             >>> model.train(5, dataloader, dataset_sink_mode=False)
@@ -550,7 +596,22 @@ class Profiler:
                 Offline mode isused in abnormal exit scenario. This parameter should be set to ``None``
                 for online mode. Default: ``None``.
         """
+        self._analyse(offline_path=offline_path)
+
+    def _analyse(self, offline_path=None, model_iteration_dict=None):
+        """
+        Collect and analyze training performance data, support calls during and after training. The example shows above.
+
+        Args:
+            offline_path (Union[str, None], optional): The data path which need to be analysed with offline mode.
+                Offline mode isused in abnormal exit scenario. This parameter should be set to ``None``
+                for online mode. Default: ``None``.
+            model_iteration_dict: Dictionary with model id as the key and iteration id as the value, Default: ``None``.
+        """
+        self._model_iteration_dict = model_iteration_dict
         if offline_path:
+            if self._is_offline_parser():
+                self._ascend_graph_analyse()
             _offline_parse(offline_path)
             return
         if self._msprof_enable:
@@ -602,7 +663,7 @@ class Profiler:
         Raises:
             RuntimeError: If the profiler has already started.
             RuntimeError: If MD profiling has stopped, repeated start action is not supported.
-            RuntimeError: If the start_profile parameter is not set or is set to True.
+            RuntimeError: If the `start_profile` parameter is not set or is set to ``True``.
 
         Examples:
             >>> from mindspore.train import Callback
@@ -749,7 +810,6 @@ class Profiler:
 
         if self._device_target == DeviceTarget.ASCEND.value:
             self._ascend_profiler = c_expression.Profiler.get_instance("Ascend")
-            self._ascend_msprof_exporter = AscendMsprofExporter(self._output_path)
         self._get_devid_rankid_and_devtarget()
 
     def _init_profiler_info(self):
@@ -827,7 +887,6 @@ class Profiler:
         # use context interface to open profiling, for the new mindspore version(after 2020.5.21)
         self._ascend_profiler = c_expression.Profiler.get_instance("Ascend")
         self._ascend_profiler.init(self._output_path, int(self._dev_id), self._ascend_profiling_options)
-        self._ascend_msprof_exporter = AscendMsprofExporter(self._output_path)
         base_profiling_container_path = os.path.join(self._output_path, "container")
         container_path = os.path.join(base_profiling_container_path, self._dev_id)
         data_path = os.path.join(container_path, "data")
@@ -965,8 +1024,6 @@ class Profiler:
         else:
             logger.info("No need to stop profiler because profiler has been stopped.")
         # export op data before analyse
-        if self._op_time:
-            self._ascend_msprof_exporter.export(self._start_time, support_step_trace=False)
         self._ascend_graph_analyse()
 
     def _minddata_analyse(self, source_path):
@@ -1040,8 +1097,11 @@ class Profiler:
             aicpu_intermediate_detail_path = validate_and_normalize_path(aicpu_intermediate_detail_path)
             framework_raw_path = validate_and_normalize_path(framework_raw_path)
 
-            output_timeline_data_path = os.path.join(self._output_path, f'output_timeline_data_{dev_id}.txt')
-            output_timeline_data_path = validate_and_normalize_path(output_timeline_data_path)
+            if context.get_context("mode") == context.GRAPH_MODE:
+                output_timeline_data_path = os.path.join(self._output_path, f'output_timeline_data_{dev_id}.txt')
+                output_timeline_data_path = validate_and_normalize_path(output_timeline_data_path)
+            else:
+                output_timeline_data_path = None
 
             op_analyser = AscendOPGenerator(op_summary, op_statistic, dynamic_status)
             op_analyser.parse()
@@ -1070,7 +1130,7 @@ class Profiler:
         finally:
             pass
 
-    def _ascend_timeline_analyse(self, source_path, op_summary, steptrace):
+    def _ascend_timeline_analyse(self, op_summary, steptrace):
         """Analyse timeline info."""
         try:
             logger.info("Profiling: analyzing the timeline data")
@@ -1142,6 +1202,7 @@ class Profiler:
         if self._profile_communication and context.get_context("mode") == context.PYNATIVE_MODE:
             logger.warning("[Profiler]The parameter profile_communication is not supported on Ascend "
                            "PyNative mode currently.")
+            return
         try:
             logger.info("Profiling: analyzing the hccl profiler info.")
             dev_id = self._rank_id if self._device_target == DeviceTarget.ASCEND.value else self._dev_id
@@ -1191,9 +1252,10 @@ class Profiler:
         source_path = os.path.join(self._output_path, job_id)
         self._minddata_analyse(source_path)
         if self._op_time:
+            _ascend_graph_msprof_generator(source_path, self._model_iteration_dict)
             op_summary, op_statistic, steptrace = _ascend_graph_msprof_analyse(source_path)
             self._ascend_op_analyse(op_summary, op_statistic, self._dynamic_status)
-            self._ascend_timeline_analyse(source_path, op_summary, steptrace)
+            self._ascend_timeline_analyse(op_summary, steptrace)
             graph_ids = np.unique(op_summary['Model ID']).tolist()
             points = self._ascend_fpbp_analyse(op_summary, steptrace)
             if len(graph_ids) == 1:
@@ -1326,29 +1388,37 @@ class Profiler:
         point_info_file_path = validate_and_normalize_path(point_info_file_path)
 
         if self._device_target and self._device_target == DeviceTarget.GPU.value:
-            input_file_path = os.path.join(self._output_path, f'step_trace_profiling_{self._dev_id}.txt')
-            input_file_path = validate_and_normalize_path(input_file_path)
-            parser = GpuStepTraceParser(input_dir=input_file_path,
-                                        output_file_path=step_trace_intermediate_file_path,
-                                        is_training_mode=is_training_mode_flag,
-                                        is_gpu_kernel_async_launch=is_gpu_kernel_async_launch_flag)
-            parser.parse_and_save()
-            point_info = parser.record_point_info(point_info_file_path)
-        else:
-            # whether keep the first step
-            skip_first_step_flag = framework_parser.check_op_name(INIT_OP_NAME)
-            point_info = framework_parser.point_info
-            # recognize inference or training mode
-            is_training_mode_flag = framework_parser.check_op_name("Gradients")
-            # parser the step trace files and save the result to disk
-            source_path = validate_and_normalize_path(source_path)
-            parser = AscendStepTraceParser(input_dir=source_path,
-                                           output_file_path=step_trace_intermediate_file_path,
-                                           skip_first_step=skip_first_step_flag,
-                                           is_training_mode=is_training_mode_flag)
-            parser.set_task_id_op_name_dict(framework_parser.to_task_id_full_op_name_dict())
-            parser.parse_and_save()
-            point_info = parser.record_point_info(point_info_file_path)
+            if context.get_context("mode") != context.PYNATIVE_MODE:
+                input_file_path = os.path.join(self._output_path, f'step_trace_profiling_{self._dev_id}.txt')
+                input_file_path = validate_and_normalize_path(input_file_path)
+                parser = GpuStepTraceParser(input_dir=input_file_path,
+                                            output_file_path=step_trace_intermediate_file_path,
+                                            is_training_mode=is_training_mode_flag,
+                                            is_gpu_kernel_async_launch=is_gpu_kernel_async_launch_flag)
+                parser.parse_and_save()
+                point_info = parser.record_point_info(point_info_file_path)
+                # print parser result
+                parser.show()
+                logger.info("Finish saving the intermediate result: %s", step_trace_intermediate_file_path)
+                logger.info("The point info is: %s", point_info)
+
+                return point_info, is_training_mode_flag
+            return {}, is_training_mode_flag
+
+        # whether keep the first step
+        skip_first_step_flag = framework_parser.check_op_name(INIT_OP_NAME)
+        # recognize inference or training mode
+        is_training_mode_flag = framework_parser.check_op_name("Gradients")
+        # parser the step trace files and save the result to disk
+        source_path = validate_and_normalize_path(source_path)
+        parser = AscendStepTraceParser(input_dir=source_path,
+                                       output_file_path=step_trace_intermediate_file_path,
+                                       skip_first_step=skip_first_step_flag,
+                                       is_training_mode=is_training_mode_flag)
+        parser.set_task_id_op_name_dict(framework_parser.to_task_id_full_op_name_dict())
+        parser.parse_and_save()
+        point_info = parser.record_point_info(point_info_file_path)
+
         # print parser result
         parser.show()
         logger.info("Finish saving the intermediate result: %s", step_trace_intermediate_file_path)
@@ -1393,11 +1463,10 @@ class Profiler:
             return job_id
 
         job_id = ""
-        job_dirs = filter(lambda item: item.startswith('JOB') or item.startswith('PROF') and \
-                                       os.path.isdir(os.path.join(self._output_path, item)),
-                          os.listdir(self._output_path))
-        sorted_job_dirs = sorted(job_dirs, key=lambda x: os.path.getmtime(os.path.join(self._output_path, x)),
-                                 reverse=True)
+        job_dirs = filter(lambda item: item.startswith('JOB') or item.startswith('PROF') and os.path.isdir(
+            os.path.join(self._output_path, item)), os.listdir(self._output_path))
+        sorted_job_dirs = sorted(
+            job_dirs, key=lambda x: os.path.getmtime(os.path.join(self._output_path, x)), reverse=True)
 
         for dir_name in sorted_job_dirs:
             if dir_name.startswith('PROF'):
@@ -1414,22 +1483,21 @@ class Profiler:
                                "profiler will ignore this job dir.", job_dir)
                 continue
 
-            training_device_id = start_file_path.split('.')[-1]
+            info_file_path = get_file_path(job_dir, "info.json")
+            if info_file_path is None:
+                logger.warning("Find profiling job path %s, but info.json not exist, "
+                               "profiler will ignore this job dir.", job_dir)
+                continue
+
+            _, training_device_id = self._parse_info_json(info_file_path)
+            job_start_time = self._parse_start_log(start_file_path)
+
             if self._dev_id != training_device_id:
                 logger.debug("Find profiling find job path %s, but not current training device id. "
                              "Current training device id %s, but job path device id: %s, "
                              "profiler will ignore this job dir.", job_dir, self._dev_id, training_device_id)
                 continue
 
-            if not os.listdir(os.path.join(job_dir, 'data')):
-                continue
-
-            job_start_time = self._parse_start_log(start_file_path)
-            if not job_start_time:
-                logger.warning("Find profiling job path %s, but fail to get job start info, "
-                               "profiler will ignore this job dir.", job_start_time)
-                continue
-
             if int(job_start_time) < self._start_time:
                 logger.warning("Find profiling job path %s, but start_time(%d) is earlier than this training "
                                "start_time(%d), profiler will ignore this job dir.",
@@ -1586,7 +1654,7 @@ class Profiler:
         self._profile_framework = kwargs.pop("profile_framework", "all")
         if self._profile_framework not in ["memory", "time", "all", None]:
             logger.warning(f"For '{self.__class__.__name__}', the parameter profile_framework must be one of ['memory',"
-                           f" 'time', 'all', None]，but got {self._profile_framework}, it will be set to 'all'.")
+                           f" 'time', 'all', None], but got {self._profile_framework}, it will be set to 'all'.")
             self._profile_framework = "all"
 
     def _host_info_analyse(self):

mindspore/rewrite/api/node.py

@@ -14,12 +14,13 @@
 # ============================================================================
 """Rewrite module api: Node."""
 
-from typing import Union, Optional
+from typing import Union, Optional, List, Dict
+from types import FunctionType
 
 from mindspore.nn import Cell
 from mindspore.ops.primitive import Primitive
 from mindspore import _checkparam as Validator
-from ..node import Node as NodeImpl
+from ..node.node import Node as NodeImpl
 from ..symbol_tree import SymbolTree as SymbolTreeImpl
 from .node_type import NodeType
 from .scoped_value import ScopedValue
@@ -50,8 +51,8 @@ class Node:
         return self._node == other._node
 
     @staticmethod
-    def create_call_cell(cell: Cell, targets: [Union[ScopedValue, str]], args: [ScopedValue] = None,
-                         kwargs: {str: ScopedValue}=None, name: str = "", is_sub_net: bool = False) -> 'Node':
+    def create_call_cell(cell: Cell, targets: List[Union[ScopedValue, str]], args: List[ScopedValue] = None,
+                         kwargs: Dict[str, ScopedValue] = None, name: str = "", is_sub_net: bool = False) -> 'Node':
         """
         Create a node. Only support create from a `Cell` now.
 
@@ -63,14 +64,15 @@ class Node:
 
         Args:
             cell (Cell): Cell-operator of this forward-layer.
-            targets (list[ScopedValue]): Indicate output names. Used as targets of an assign statement in source code.
-            args (list[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
+            targets (List[Union[ScopedValue, str]]): Indicate output names. Used as targets of an assign statement in
+                source code.
+            args (List[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
                 source code. Default: ``None`` , which indicates the `cell` has no args inputs.
-            kwargs (dict): Type of key must be `str` and type of value must be `ScopedValue`.
+            kwargs (Dict[str, ScopedValue]): Type of key must be `str` and type of value must be `ScopedValue`.
                 Indicate keyword input names. Used as kwargs of a call expression of an assign statement in source
                 code. Default: ``None`` , which indicates the `cell` has no kwargs inputs.
             name (str): Indicate the name of node. Used as field name in source code. Default is None. Rewrite will
-                generate name from `targets` when name is None. Rewrite will check and ensure the uniqueness of `name`
+                generate name from `cell` when name is None. Rewrite will check and ensure the uniqueness of `name`
                 while node being inserted. Default: ``""`` .
             is_sub_net (bool): Indicate that is `cell` a network. If `is_sub_net` is true, Rewrite will try to parse
                 the `cell` to a TreeNode, otherwise the `cell` is parsed to a CallCell node. Default: ``False`` .
@@ -89,7 +91,7 @@ class Node:
             >>> from mindspore.rewrite import SymbolTree, ScopedValue
             >>> import mindspore.nn as nn
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -108,8 +110,66 @@ class Node:
             Validator.check_element_type_of_iterable("args", args, [ScopedValue], "Node")
         if kwargs is not None:
             Validator.check_element_type_of_dict("kwargs", kwargs, [str], [ScopedValue], "Node")
-        return Node(NodeImpl.create_call_op(cell, None, targets, ScopedValue.create_naming_value(name, "self"),
-                                            args, kwargs, name, is_sub_net))
+        return Node(NodeImpl.create_call_op(cell, None, targets, args, kwargs, name, is_sub_net))
+
+    @staticmethod
+    def create_call_function(function: FunctionType, targets: List[Union[ScopedValue, str]],
+                             args: List[ScopedValue] = None, kwargs: Dict[str, ScopedValue] = None) -> 'Node':
+        """
+        Create a node that corresponds to a function call. The `function` object is saved into network, and used via
+        getting object from `self.` .
+
+        Args:
+            function (FunctionType): The function to be called.
+            targets (List[Union[ScopedValue, str]]): indicates output names. Used as targets of an assign statement in
+                source code.
+            args (List[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
+                source code. Default: ``None`` , which indicates the `function` has no args inputs.
+            kwargs (Dict[str, ScopedValue]): Type of key must be `str` and type of value must be `ScopedValue`.
+                Indicate keyword input names. Used as kwargs of a call expression of an assign statement in source
+                code. Default: ``None`` , which indicates the `function` has no kwargs inputs.
+
+        Returns:
+            An instance of `Node`.
+
+        Raises:
+            TypeError: If `function` is not a `FunctionType`.
+            TypeError: If `targets` is not `list`.
+            TypeError: If the type of `targets` is not in `[ScopedValue, str]`.
+            TypeError: If arg in `args` is not a `ScopedValue`.
+            TypeError: If key of `kwarg` is not a str or value of kwarg in `kwargs` is not a `ScopedValue`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree, ScopedValue
+            >>> import mindspore.nn as nn
+            >>> import mindspore.ops as ops
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> position = stree.after(node)
+            >>> new_node = node.create_call_function(function=ops.abs, targets=['x'],
+            ...                                      args=[ScopedValue.create_naming_value('x')])
+            >>> stree.insert(position, new_node)
+            >>> print(new_node.get_node_type())
+            NodeType.CallFunction
+        """
+        Validator.check_value_type("function", function, [FunctionType, type], "create_call_function")
+        Validator.check_element_type_of_iterable("targets", targets, [ScopedValue, str], "create_call_function")
+        if args is not None:
+            Validator.check_element_type_of_iterable("args", args, [ScopedValue], "create_call_function")
+        if kwargs is not None:
+            Validator.check_element_type_of_dict("kwargs", kwargs, [str], [ScopedValue], "create_call_function")
+        return Node(NodeImpl._create_call_function(function, targets, args, kwargs))
+
+    @staticmethod
+    def create_input(param_name: str, default: Optional[ScopedValue] = None) -> 'Node':
+    # pylint: disable=missing-function-docstring
+        Validator.check_value_type("param_name", param_name, [str], "Node")
+        if default is not None:
+            Validator.check_value_type("default", default, [ScopedValue], "Node")
+        return Node(NodeImpl.create_input_node(None, param_name, default, name=f"input_{param_name}"))
 
     def get_handler(self) -> NodeImpl:
         return self._node
@@ -124,7 +184,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv2")
@@ -144,7 +204,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -177,7 +237,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("relu_3")
@@ -216,7 +276,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> src_node = stree.get_node("fc1")
@@ -256,7 +316,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -276,7 +336,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -303,7 +363,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -326,7 +386,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree
             >>> # Define the network structure of LeNet5. Refer to
-            >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
@@ -335,6 +395,29 @@ class Node:
         """
         return self._node.get_args()
 
+    def get_symbol_tree(self) -> 'SymbolTree':
+        """
+        Get the symbol tree which current node belongs to.
+
+        Returns:
+            SymbolTree, None if current node does not belong to any SymbolTree.
+
+        Examples:
+        >>> from mindspore.rewrite import SymbolTree
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>> stree = SymbolTree.create(net)
+        >>> node = stree.get_node("conv1")
+        >>> print(type(node.get_symbol_tree()))
+        <class 'mindspore.rewrite.api.symbol_tree.SymbolTree'>
+        """
+        from .symbol_tree import SymbolTree
+        stree_impl = self._node.get_belong_symbol_tree()
+        if not stree_impl:
+            return None
+        return SymbolTree(stree_impl)
+
     def get_kwargs(self) -> {str: ScopedValue}:
         return self._node.get_kwargs()