mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/profiler/profiler_action_controller.py

@@ -0,0 +1,187 @@
+# Copyright 2024-2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Profiler Action Controller"""
+from functools import partial
+from typing import Dict, Optional, Callable, Any
+
+from mindspore.profiler.profiler_interface import ProfilerInterface
+from mindspore.profiler.schedule import ProfilerAction
+
+from mindspore import log as logger
+
+__all__ = []
+
+
+class ProfilerActionController:
+    """
+    A controller class for managing profiler actions and transitions.
+
+    This class handles the actions and transitions between different profiler states.
+    It uses two maps, abnormal_action_map and normal_action_map, to determine the actions
+    to take based on the previous and current profiler actions.
+
+    Attributes:
+        profiler: The profiler instance associated with this controller.
+        prof_interface (ProfilerInterface): The profiler interface instance.
+        on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
+        abnormal_action_map (Dict): A map of abnormal transitions and their corresponding actions.
+        normal_action_map (Dict): A map of normal transitions and their corresponding actions.
+    """
+
+    def __init__(self, prof_interface: ProfilerInterface, on_trace_ready: Optional[Callable[..., Any]] = None) -> None:
+        """
+        Initializes a new instance of ProfActionController.
+
+        Args:
+            prof_interface (ProfilerInterface): The profiler interface instance.
+            on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
+        """
+        self.prof_interface = prof_interface
+        self.abnormal_action_map: Dict = self.init_abnormal_action_map()
+        self.normal_action_map: Dict = self.init_normal_action_map()
+        self.on_trace_ready = on_trace_ready
+
+    def _trace_ready(self):
+        """
+        Calls the on_trace_ready callback function if it is set.
+
+        This method is called when the trace is ready to notify the callback function.
+        """
+        if self.on_trace_ready:
+            self.on_trace_ready()
+
+    def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
+        """
+        Handles actions between previous action and latter action
+
+        Args:
+            prev_action: The previous state
+            current_action: the latter state
+        """
+        # Check whether the action is in the abnormal map
+        action_list = self.abnormal_action_map.get((prev_action, current_action), [])
+        if not action_list:
+            if isinstance(prev_action, ProfilerAction) and isinstance(current_action, ProfilerAction):
+                # Check whether the action is in the normal map
+                action_list = self.handle_normal_action(prev_action, current_action)
+        if not action_list:
+            return
+        for action in action_list:
+            action()
+
+    def handle_normal_action(self, start_state: ProfilerAction, end_state: ProfilerAction) -> list:
+        """
+        Obtain the action in the normal state
+
+        Args:
+            start_state: The previous state
+            end_state: the latter state
+
+        Returns:
+            process_action list
+        """
+        process_action = []
+        initial_state = start_state
+
+        # Handle special case for ProfilerAction.RECORD_AND_SAVE to ProfilerAction.RECORD_AND_SAVE transition
+        if start_state == ProfilerAction.RECORD_AND_SAVE and end_state == ProfilerAction.RECORD_AND_SAVE:
+            process_action = [self.prof_interface.stop, self.prof_interface.finalize,
+                              self._trace_ready, self.prof_interface.clear, self.prof_interface.init,
+                              self.prof_interface.start]
+        else:
+            while start_state != end_state:
+                process_action.extend(self.normal_action_map[start_state])
+                start_state = ProfilerAction.get_by_value((start_state.value + 1) % len(ProfilerAction))
+
+            # Handle special cases for NONE to NONE, WARM_UP to WARM_UP, RECORD to RECORD transitions
+            if initial_state == start_state and initial_state != ProfilerAction.RECORD_AND_SAVE:
+                process_action = []
+
+        return process_action
+
+    def init_normal_action_map(self) -> dict:
+        """
+        Generate a normal action map
+
+        Returns:
+            normal_action_map map
+        """
+        return {
+            ProfilerAction.NONE: [self.prof_interface.init],
+            ProfilerAction.WARM_UP: [self.prof_interface.start],
+            ProfilerAction.RECORD: [],
+            ProfilerAction.RECORD_AND_SAVE: [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ]
+        }
+
+    def init_abnormal_action_map(self) -> dict:
+        """
+        Generate a abnormal action map
+
+        Returns:
+            abnormal_action_map map
+        """
+        return {
+            (ProfilerAction.WARM_UP, ProfilerAction.NONE): [
+                partial(logger.warning, "Incorrect schedule: WARMUP followed by NONE"),
+                self.prof_interface.start,
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD, ProfilerAction.NONE): [
+                partial(logger.warning, "Incorrect schedule: RECORD followed by NONE"),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD, ProfilerAction.WARM_UP): [
+                partial(logger.warning, "Incorrect schedule: RECORD followed by WARMUP"),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            # used for exit action
+            (ProfilerAction.WARM_UP, None): [
+                partial(logger.warning,
+                        "Incorrect schedule: Stop profiler while current state is WARMUP "
+                        "which will result in empty parsed data."),
+                self.prof_interface.finalize,
+                self.prof_interface.clear,
+                self.prof_interface.delete_dir
+            ],
+            (ProfilerAction.RECORD, None): [
+                partial(logger.warning,
+                        "Incorrect schedule: Stop profiler while current state is RECORD "
+                        "which may result in incomplete parsed data."),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, None): [
+                partial(logger.warning,
+                        "Stop profiler while current state is RECORD_AND_SAVE, "
+                        "perhaps the scheduling cycle has not yet completed."),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ]
+        }

mindspore/profiler/profiler_interface.py

@@ -0,0 +1,118 @@
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""ProfilerInterface"""
+from typing import Set
+
+from mindspore import log as logger
+from mindspore.common.api import _pynative_executor
+from mindspore.profiler.common.registry import PROFILERS
+from mindspore.profiler.platform.base_profiler import BaseProfiler
+from mindspore.profiler.common.profiler_context import ProfilerContext
+from mindspore.profiler.common.log import ProfilerLogger
+from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
+from mindspore.profiler.common.profiler_meta_data import ProfilerMetaData
+
+
+class ProfilerInterface:
+    """
+    Profiler interface
+    """
+
+    cpu_profiler: BaseProfiler = None
+    device_profiler: BaseProfiler = None
+    platform_profilers_set: Set[BaseProfiler] = set()
+    is_initialized = False
+
+    @classmethod
+    def init(cls):
+        """ProfilerInterface init"""
+        if cls.is_initialized:
+            return
+
+        ProfilerPathManager().set_ascend_ms_dir()
+        ProfilerPathManager().create_profiler_paths()
+        platforms = ProfilerContext().device_target_set
+        for device_target in platforms:
+            cls.platform_profilers_set.add(PROFILERS.modules.get(device_target)())
+
+        cls.is_initialized = True
+        logger.info("ProfilerInterface init")
+
+    @classmethod
+    def start(cls):
+        """ProfilerInterface start"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface start failed, profiler has not been initialized.")
+            return
+
+        for profiler in cls.platform_profilers_set:
+            profiler.start()
+
+        logger.info("ProfilerInterface start")
+
+    @classmethod
+    def stop(cls):
+        """ProfilerInterface stop"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface stop failed, profiler has not been initialized.")
+            return
+
+        _pynative_executor.sync()
+        for profiler in cls.platform_profilers_set:
+            profiler.stop()
+
+        logger.info("ProfilerInterface stop")
+
+    @classmethod
+    def analyse(cls):
+        """ProfilerInterface analyse"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface analyse failed, profiler has not been initialized.")
+            return
+
+        for profiler in cls.platform_profilers_set:
+            profiler.analyse()
+
+        logger.info("ProfilerInterface analyse")
+
+    @classmethod
+    def finalize(cls):
+        """ProfilerInterface finalize"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface finalize failed, profiler has not been initialized.")
+            return
+
+        ProfilerMetaData.dump_metadata()
+        for profiler in cls.platform_profilers_set:
+            profiler.finalize()
+            profiler = None
+
+        logger.info("ProfilerInterface finalize")
+
+    @classmethod
+    def clear(cls):
+        """ProfilerInterface clear"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface clear failed, profiler has not been initialized.")
+            return
+        cls.platform_profilers_set.clear()
+        cls.is_initialized = False
+        ProfilerLogger.destroy()
+        logger.info("ProfilerInterface clear")
+
+    @classmethod
+    def delete_dir(cls):
+        """ProfilerInterface delete dir"""
+        logger.info("ProfilerInterface delete dir")

mindspore/profiler/schedule.py

@@ -0,0 +1,243 @@
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Profiler Schedule"""
+from enum import Enum
+
+from mindspore import log as logger
+
+__all__ = ["ProfilerAction", "Schedule"]
+
+
+class ProfilerAction(Enum):
+    """
+    Enum class representing different actions that can be performed by the profiler.
+
+    Each member of the enum represents a specific profiling action, which can be used
+    to control the behavior of the profiler at different stages of execution.
+
+    Attributes:
+        NONE (ProfilerAction): No profiling action.
+        WARM_UP (ProfilerAction): Warm-up phase of profiling.
+        RECORD (ProfilerAction): Record phase of profiling.
+        RECORD_AND_SAVE (ProfilerAction): Record and save phase of profiling.
+    """
+    NONE = 0
+    WARM_UP = 1
+    RECORD = 2
+    RECORD_AND_SAVE = 3
+
+    @staticmethod
+    def get_by_value(value):
+        """
+        Retrieves a ProfilerAction enum member by its value.
+
+        Args:
+            value (int): The value of the ProfilerAction enum member to retrieve.
+
+        Returns:
+            ProfilerAction, The enum member corresponding to the given value, or None if not found.
+        """
+        value_map = {action.value: action for action in ProfilerAction}
+        return value_map.get(value, None)
+
+
+class Schedule:
+    r"""
+    This class use to get the actions of each step.
+    The schedule is as follows:
+
+    .. code-block::
+
+        (NONE)        (NONE)          (NONE)       (WARM_UP)       (RECORD)      (RECORD)     (RECORD_AND_SAVE)    None
+        START------->skip_first------->wait-------->warmup-------->active........active.........active----------->stop
+                                      |                                                             |
+                                      |                           repeat_1                          |
+                                      ---------------------------------------------------------------
+
+    The profiler will skip the first ``skip_first`` steps, then wait for ``wait`` steps,
+    then do the warmup for the next ``warmup`` steps, then do the active recording for the next
+    ``active`` steps and then repeat the cycle starting with ``wait`` steps. The optional number
+    of cycles is specified with the ``repeat`` parameter, the zero value means that
+    the cycles will continue until the profiling is finished.
+
+    Keyword Args:
+        wait (int): The number of steps to wait before starting the warm-up phase.
+            must be greater than or equal to 0. If the wait parameter is not set externally,
+            it is set to ``0`` when the schedule class is initialized.
+        active (int): The number of steps to record data during the active phase.
+            must be greater than or equal to 1. If the active parameter is not set externally,
+            it is set to ``1`` when the schedule class is initialized.
+        warmup (int, optional): The number of steps to perform the warm-up phase.
+            must be greater than or equal to 0. Default value: ``0``.
+        repeat (int, optional): The number of times to repeat the cycle.
+            If repeat is set to 0, the Profiler will determine the repeat value based on the number of times the model
+            is trained, which will generate one more performance data with incomplete collection. The data in the last
+            step is abnormal data that users do not need to pay attention to. Default value: ``0``.
+        skip_first (int, optional): The number of steps to skip at the beginning. Must be greater than or equal to 0.
+            Default value: ``0``
+
+    Raises:
+        ValueError: When the parameter step is less than 0.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> import mindspore.dataset as ds
+        >>> from mindspore import context, nn
+        >>> from mindspore.profiler import ProfilerLevel, AicoreMetrics, ExportType, ProfilerActivity
+        >>>
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.fc = nn.Dense(2, 2)
+        ...
+        ...     def construct(self, x):
+        ...         return self.fc(x)
+        >>>
+        >>> def generator_net():
+        ...     for _ in range(2):
+        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+        >>>
+        >>> def train(test_net):
+        ...     optimizer = nn.Momentum(test_net.trainable_params(), 1, 0.9)
+        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        ...     data = ds.GeneratorDataset(generator_net(), ["data", "label"])
+        ...     model = mindspore.train.Model(test_net, loss, optimizer)
+        ...     model.train(1, data)
+        >>>
+        >>> if __name__ == '__main__':
+        ...     # If the device_target is GPU, set the device_target to "GPU"
+        ...     context.set_context(mode=mindspore.GRAPH_MODE)
+        ...     mindspore.set_device("Ascend")
+        ...
+        ...     # Init Profiler
+        ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+        ...                                 profiler_level=ProfilerLevel.Level0,
+        ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
+        ...                                 l2_cache=False,
+        ...                                 mstx=False,
+        ...                                 data_simplification=False,
+        ...                                 export_type=[ExportType.Text])
+        ...     steps = 10
+        ...     net = Net()
+        ...     # Note that the Profiler should be initialized before model.train
+        ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
+        ...                                           repeat=1, skip_first=2),
+        ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+        ...                                     profile_memory=False,
+        ...                                     experimental_config=experimental_config) as prof:
+        ...
+        ...         # Train Model
+        ...         for step in range(steps):
+        ...             train(net)
+        ...             prof.step()
+    """
+
+    def __init__(self, *, wait: int, active: int, warmup: int = 0, repeat: int = 0, skip_first: int = 0) -> None:
+        self.wait = wait
+        self.active = active
+        self.warmup = warmup
+        self.repeat = repeat
+        self.skip_first = skip_first
+        self._check_params()
+
+    def __call__(self, step: int) -> ProfilerAction:
+        """
+        Obtain the action of the specified step from the schedule.
+
+        Args:
+            step (int): step num.
+
+        Returns:
+            ProfilerAction, The action corresponding to a step.
+        """
+        if step < 0:
+            raise ValueError("Invalid parameter step, which must be not less than 0.")
+        if step < self.skip_first:
+            return ProfilerAction.NONE
+
+        step -= self.skip_first
+
+        num_steps = self.wait + self.warmup + self.active
+        if 0 < self.repeat <= step / num_steps:
+            return ProfilerAction.NONE
+
+        mod_step = step % num_steps
+        if mod_step < self.wait:
+            return ProfilerAction.NONE
+        if mod_step < self.wait + self.warmup:
+            return ProfilerAction.WARM_UP
+        return ProfilerAction.RECORD if mod_step < num_steps - 1 else ProfilerAction.RECORD_AND_SAVE
+
+    def __repr__(self):
+        return (f"Schedule(wait={self.wait!r}, active={self.active!r}, "
+                f"warmup={self.warmup!r}, repeat={self.repeat!r}, "
+                f"skip_first={self.skip_first!r})")
+
+    def _check_params(self):
+        """
+        Verify all parameters in the schedule,
+        and set them to default values if the parameters are not compliant.
+        """
+        if not isinstance(self.wait, int) or isinstance(self.wait, bool) or self.wait < 0:
+            logger.warning(f"Parameter 'wait' should be of type int, but got "
+                           f"{type(self.wait).__name__}. reset to int 0.")
+            self.wait = 0
+        if not isinstance(self.warmup, int) or isinstance(self.warmup, bool) or self.warmup < 0:
+            logger.warning(f"Parameter 'warmup' should be of type int, but got "
+                           f"{type(self.warmup).__name__}. reset to int 0.")
+            self.warmup = 0
+        if not isinstance(self.active, int) or isinstance(self.active, bool) or self.active <= 0:
+            logger.warning(f"Parameter 'active' should be of type int, but got "
+                           f"{type(self.active).__name__}. reset to int 1.")
+            self.active = 1
+        if not isinstance(self.repeat, int) or isinstance(self.repeat, bool) or self.repeat < 0:
+            logger.warning(f"Parameter 'repeat' should be of type int, but got "
+                           f"{type(self.repeat).__name__}. reset to int 0.")
+            self.repeat = 0
+        if not isinstance(self.skip_first, int) or isinstance(self.skip_first, bool) or self.skip_first < 0:
+            logger.warning(f"Parameter 'skip_first' should be of type int, but got "
+                           f"{type(self.skip_first).__name__}. reset to int 0.")
+            self.skip_first = 0
+        if self.warmup == 0:
+            logger.warning("Profiler won't be using warmup, this can skew profiler results")
+
+    def to_dict(self):
+        """
+        Convert schedule to a dict.
+
+        Returns:
+            dict, the parameters of schedule and their values.
+        """
+        return {'wait': self.wait, 'active': self.active, 'warmup': self.warmup,
+                'repeat': self.repeat, 'skip_first': self.skip_first}
+
+
+def _default_schedule_fn(_: int) -> ProfilerAction:
+    """
+    Default profiler behavior - immediately starts recording the events,
+    keeps doing it on every profiler step.
+
+    Args:
+        _ (int): step num.
+
+    Returns:
+        ProfilerAction, The RECORD action.
+    """
+    return ProfilerAction.RECORD

mindspore/rewrite/api/node.py

@@ -28,9 +28,11 @@ from .scoped_value import ScopedValue
 
 class Node:
     """
-    A node is a data structure that expresses source code statements in a network.
-
-    Each node usually corresponds to a statement in expanded forward evaluation process.
+    A node (Node) can be understood as a basic data structure unit in the computational graph of a neural network,
+    which represents an operation or computational step in the network.
+    Each node usually corresponds to a statement or expression in the source code,
+    which contains the information needed to perform the operation,
+    such as the type of operation, input data, output result, and connection relationships with other nodes.
 
     Nodes can express a ``Cell`` call statement, a ``Primitive`` call statement, an arithmetic operation statement, a
     return statements, etc. of the forward calculation process.
@@ -66,9 +68,9 @@ class Node:
                 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[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.
+            kwargs (Dict[str, ScopedValue]): Used as kwargs of a call expression of an assign statement in source
+                code. Indicate keyword input names. Type of key must be `str` and type of value must be `ScopedValue`.
+                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 `cell` when name is None. Rewrite will check and ensure the uniqueness of `name`
                 while node being inserted. Default: ``""`` .
@@ -83,7 +85,7 @@ class Node:
             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`.
+            TypeError: If key of `kwargs` is not a str or value of kwarg in `kwargs` is not a `ScopedValue`.
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree, ScopedValue
@@ -125,9 +127,9 @@ class Node:
                 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.
+            kwargs (Dict[str, ScopedValue]): Used as kwargs of a call expression of an assign statement in source
+                code. Indicate keyword input names. Type of key must be `str` and type of value must be `ScopedValue`.
+                Default: ``None`` , which indicates the `function` has no kwargs inputs.
 
         Returns:
             An instance of `Node`.
@@ -137,7 +139,7 @@ class Node:
             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`.
+            TypeError: If key of `kwargs` is not a str or value of kwarg in `kwargs` is not a `ScopedValue`.
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree, ScopedValue
@@ -476,14 +478,14 @@ class Node:
             ...         self.relu = nn.ReLU()
             ...
             ...     def construct(self, input):
-            ...         output = self.relu(x=input)
+            ...         output = self.relu(input=input)
             ...         return output
             >>>
             >>> net = ReLUNet()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("relu")
             >>> print(node.get_kwargs())
-            {'x': input}
+            {'input': input}
         """
         return self._node.get_kwargs()
 

mindspore/rewrite/api/symbol_tree.py

@@ -74,7 +74,7 @@ class SymbolTree:
 
         - :class:`mindspore.nn.SequentialCell`
         - Functions(Excludes Python built-in functions and third-party library functions)
-        - Control flow statements, such as `if` statements
+        - Control flow statements(such as `if` statements)
 
         Note:
             Because the specific execution branch of control flows are still unknown during the rewrite operation
@@ -331,8 +331,7 @@ class SymbolTree:
         Nodes in `new_nodes` will be inserted into SymbolTree sequentially, and then `old_node` will be deleted.
 
         Note:
-            - Replace support one-to-one replacement or one-to-multi replacement. If you need multi-to-multi
-              replacement, please refer to `PatternEngine`.
+            - Replace only support one-to-one replacement or one-to-multi replacement.
             - Caller should maintain the topological relationship between each node in the `new_nodes` , as well as
               the topological relationship between nodes in the `new_nodes` and nodes in the original tree.