mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/mindspore/common/log.py

@@ -1,38 +1,38 @@
-# Copyright 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.
-# ============================================================================
-
-import os
-import time
-import sys
-
-from msprobe.mindspore.common.utils import get_rank_if_initialized
-from msprobe.core.common.log import BaseLogger
-from msprobe.core.common.exceptions import DistributedNotInitializedError
-
-
-class MindsporeLogger(BaseLogger):
-    def __init__(self):
-        super().__init__()
-
-    def get_rank(self):
-        try:
-            current_rank = get_rank_if_initialized()
-        except DistributedNotInitializedError:
-            current_rank = None
-
-        return current_rank
-
-
+# Copyright 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.
+# ============================================================================
+
+import os
+import time
+import sys
+
+from msprobe.mindspore.common.utils import get_rank_if_initialized
+from msprobe.core.common.log import BaseLogger
+from msprobe.core.common.exceptions import DistributedNotInitializedError
+
+
+class MindsporeLogger(BaseLogger):
+    def __init__(self):
+        super().__init__()
+
+    def get_rank(self):
+        try:
+            current_rank = get_rank_if_initialized()
+        except DistributedNotInitializedError:
+            current_rank = None
+
+        return current_rank
+
+
 logger = MindsporeLogger()

msprobe/mindspore/common/utils.py

@@ -1,57 +1,97 @@
-# Copyright 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.
-# ============================================================================
-
-import mindspore as ms
-
-from msprobe.core.common.exceptions import DistributedNotInitializedError
-from msprobe.core.common.file_check import path_len_exceeds_limit
-from msprobe.core.common.utils import save_npy
-from msprobe.core.common.log import logger
-
-
-def get_rank_if_initialized():
-    if ms.communication.GlobalComm.INITED:
-        return ms.communication.get_rank()
-    else:
-        raise DistributedNotInitializedError("mindspore distributed environment is not initialized")
-
-
-def convert_bf16_to_fp32(tensor):
-    if tensor.dtype == ms.bfloat16:
-        tensor = tensor.to(ms.float32)
-    return tensor
-
-
-def save_tensor_as_npy(tensor, file_path):
-    if not path_len_exceeds_limit(file_path):
-        tensor = convert_bf16_to_fp32(tensor)
-        saved_tensor = tensor.asnumpy()
-        save_npy(saved_tensor, file_path)
-    else:
-        logger.warning(f'The file path {file_path} length exceeds limit.')
-
-
-class MsprobeStep(ms.train.Callback):
-
-    def __init__(self, debugger):
-        super(MsprobeStep, self).__init__()
-        self.debugger = debugger
-
-    def on_train_step_begin(self, run_context):
-        self.debugger.start()
-
-    def on_train_step_end(self, run_context):
-        self.debugger.stop()
-        self.debugger.step()
+# Copyright 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.
+# ============================================================================
+
+import os
+import random
+
+import mindspore as ms
+
+from msprobe.core.common.exceptions import DistributedNotInitializedError
+from msprobe.core.common.file_utils import path_len_exceeds_limit, check_path_exists, save_npy
+from msprobe.core.common.log import logger
+from msprobe.core.common.const import Const
+from msprobe.core.common.utils import CompareException, check_seed_all
+
+
+def get_rank_if_initialized():
+    if ms.communication.GlobalComm.INITED:
+        return ms.communication.get_rank()
+    else:
+        raise DistributedNotInitializedError("mindspore distributed environment is not initialized")
+
+
+def convert_bf16_to_fp32(tensor):
+    if tensor.dtype == ms.bfloat16:
+        tensor = tensor.to(ms.float32)
+    return tensor
+
+
+def save_tensor_as_npy(tensor, file_path):
+    if not path_len_exceeds_limit(file_path):
+        tensor = convert_bf16_to_fp32(tensor)
+        saved_tensor = tensor.asnumpy()
+        save_npy(saved_tensor, file_path)
+    else:
+        logger.warning(f'The file path {file_path} length exceeds limit.')
+
+
+def convert_to_int(value):
+    try:
+        return int(value)
+    except Exception:
+        return -1
+
+
+def list_lowest_level_directories(root_dir):
+    check_path_exists(root_dir)
+    lowest_level_dirs = []
+
+    def recurse_dirs(current_dir, depth=0):
+        if depth > Const.MAX_DEPTH:
+            logger.error(f'The directory {current_dir} has more than {Const.MAX_DEPTH} levels.')
+            raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
+        for entry in os.listdir(current_dir):
+            full_path = os.path.join(current_dir, entry)
+            if os.path.isdir(full_path):
+                if any(os.path.isdir(os.path.join(full_path, subentry)) for subentry in os.listdir(full_path)):
+                    recurse_dirs(full_path, depth=depth+1)
+                else:
+                    lowest_level_dirs.append(full_path)
+
+    recurse_dirs(root_dir)
+    return lowest_level_dirs
+
+
+def seed_all(seed=1234, mode=False):
+    check_seed_all(seed, mode)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    ms.set_seed(seed)
+    random.seed(seed)
+    ms.set_context(deterministic="ON" if mode else "OFF")
+    os.environ['HCCL_DETERMINISTIC'] = str(mode)
+
+
+class MsprobeStep(ms.train.Callback):
+
+    def __init__(self, debugger):
+        super(MsprobeStep, self).__init__()
+        self.debugger = debugger
+
+    def on_train_step_begin(self, run_context):
+        self.debugger.start()
+
+    def on_train_step_end(self, run_context):
+        self.debugger.stop()
+        self.debugger.step()

msprobe/mindspore/compare/distributed_compare.py

@@ -1,75 +1,62 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-# Copyright (C) 2019-2024. Huawei Technologies Co., Ltd. All rights reserved.
-# 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.
-"""
-import os
-from msprobe.core.common.utils import CompareException, check_compare_param, \
-    check_configuration_param, task_dumppath_get
-from msprobe.core.common.file_check import create_directory
-from msprobe.core.common.exceptions import FileCheckException
-from msprobe.core.common.log import logger
-from msprobe.mindspore.compare.ms_compare import MSComparator
-from msprobe.core.compare.utils import check_and_return_dir_contents, extract_json
-from msprobe.mindspore.compare.ms_graph_compare import GraphMSComparator
-
-def ms_compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
-    if kwargs.get('suffix'):
-        logger.error("Argument 'suffix' is not supported for compare_distributed.")
-        raise CompareException(CompareException.INVALID_PARAM_ERROR)
-    stack_mode = kwargs.get('stack_mode', False)
-    auto_analyze = kwargs.get('auto_analyze', True)
-    fuzzy_match = kwargs.get('fuzzy_match', False)
-    # get the ranks and match by order
-    npu_ranks = sorted(check_and_return_dir_contents(npu_dump_dir, 'rank'))
-    bench_ranks = sorted(check_and_return_dir_contents(bench_dump_dir, 'rank'))
-    if len(npu_ranks) != len(bench_ranks):
-        logger.error('The number of ranks in the two runs are different. '
-                        'Unable to match the ranks. Please use another folder to compare '
-                        'or use compare() api and manually match the ranks.')
-        raise CompareException(CompareException.INVALID_PATH_ERROR)
-    for nr, br in zip(npu_ranks, bench_ranks):
-        npu_data_dir = os.path.join(npu_dump_dir, nr)
-        bench_data_dir = os.path.join(bench_dump_dir, br)
-        npu_path = extract_json(npu_data_dir, stack_json=False)
-        bench_path = extract_json(bench_data_dir, stack_json=False)
-        stack_path = extract_json(npu_data_dir, stack_json=True)
-
-        dump_result_param = {
-            'npu_json_path': npu_path,
-            'bench_json_path': bench_path,
-            'stack_json_path': stack_path,
-            'is_print_compare_log': True
-        }
-        try:
-            summary_compare, md5_compare = task_dumppath_get(dump_result_param)
-            check_configuration_param(stack_mode, auto_analyze, fuzzy_match)
-            create_directory(output_path)
-            check_compare_param(dump_result_param, output_path, summary_compare=summary_compare, md5_compare=md5_compare)
-        except (CompareException, FileCheckException) as error:
-            logger.error('Compare failed. Please check the arguments and do it again!')
-            raise CompareException(error.code) from error
-        ms_comparator = MSComparator()
-        ms_comparator.compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', summary_compare=summary_compare,
-                     md5_compare=md5_compare, **kwargs)
-
-
-def ms_graph_compare(inputs, outputs):
-    try:
-        create_directory(outputs)
-    except (CompareException, FileCheckException) as error:
-        logger.error('Compare failed. Please check the arguments and do it again!')
-        return
-    msComparator = GraphMSComparator(inputs, outputs)
-    msComparator.compare_core()
+import os
+from msprobe.core.common.utils import CompareException, check_compare_param, \
+    check_configuration_param, task_dumppath_get
+from msprobe.core.common.file_utils import create_directory
+from msprobe.core.common.exceptions import FileCheckException
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.compare.ms_compare import MSComparator
+from msprobe.core.compare.utils import check_and_return_dir_contents, extract_json
+from msprobe.mindspore.compare.ms_graph_compare import GraphMSComparator
+
+
+def ms_compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
+    if kwargs.get('suffix'):
+        logger.error("Argument 'suffix' is not supported for compare_distributed.")
+        raise CompareException(CompareException.INVALID_PARAM_ERROR)
+    stack_mode = kwargs.get('stack_mode', False)
+    auto_analyze = kwargs.get('auto_analyze', True)
+    fuzzy_match = kwargs.get('fuzzy_match', False)
+    # get the ranks and match by order
+    npu_ranks = sorted(check_and_return_dir_contents(npu_dump_dir, 'rank'))
+    bench_ranks = sorted(check_and_return_dir_contents(bench_dump_dir, 'rank'))
+    if len(npu_ranks) != len(bench_ranks):
+        logger.error('The number of ranks in the two runs are different. '
+                        'Unable to match the ranks. Please use another folder to compare '
+                        'or use compare() api and manually match the ranks.')
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+    for nr, br in zip(npu_ranks, bench_ranks):
+        npu_data_dir = os.path.join(npu_dump_dir, nr)
+        bench_data_dir = os.path.join(bench_dump_dir, br)
+        npu_path = extract_json(npu_data_dir, stack_json=False)
+        bench_path = extract_json(bench_data_dir, stack_json=False)
+        stack_path = extract_json(npu_data_dir, stack_json=True)
+
+        dump_result_param = {
+            'npu_json_path': npu_path,
+            'bench_json_path': bench_path,
+            'stack_json_path': stack_path,
+            'is_print_compare_log': True
+        }
+        try:
+            summary_compare, md5_compare = task_dumppath_get(dump_result_param)
+            check_configuration_param(stack_mode, auto_analyze, fuzzy_match, 
+                                      dump_result_param.get('is_print_compare_log', True))
+            create_directory(output_path)
+            check_compare_param(dump_result_param, output_path, 
+                                summary_compare=summary_compare, md5_compare=md5_compare)
+        except (CompareException, FileCheckException) as error:
+            logger.error('Compare failed. Please check the arguments and do it again!')
+            raise CompareException(error.code) from error
+        ms_comparator = MSComparator()
+        ms_comparator.compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', 
+                                   summary_compare=summary_compare, md5_compare=md5_compare, **kwargs)
+
+
+def ms_graph_compare(inputs, outputs):
+    try:
+        create_directory(outputs)
+    except (CompareException, FileCheckException) as error:
+        logger.error('Compare failed. Please check the arguments and do it again!')
+        return
+    ms_comparator = GraphMSComparator(inputs, outputs)
+    ms_comparator.compare_core()

msprobe/mindspore/compare/layer_mapping.py

@@ -0,0 +1,146 @@
+import re
+
+from msprobe.core.common.const import Const
+from msprobe.core.common.log import logger
+from msprobe.core.common.utils import CompareException
+
+
+class Trie:
+    def __init__(self, type_name=None, has_data=False):
+        self.type_name = type_name
+        self.call_count_list = []
+        self.children = {}
+        self.has_data = has_data
+        self.node_type = None
+
+    def __repr__(self):
+        return (f"Node(type_name={self.type_name}, "
+                f"has_data={self.has_data}, call number={len(self.call_count_list)})")
+
+    def insert(self, word, word_type="func"):
+        parts = word.split(Const.SEP)
+        if len(parts) < 2:
+            logger.error('result dataframe elements can not be access.')
+            raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR)
+        """
+        xxx, node_name, type_name, execute_num
+        etc: Cell.network_with_loss.language_model.encoder.layers.1.attention.out_proj.RowParallelLinear.1
+        prefix_name_list: Cell.network_with_loss.language_model.encoder.layers.1.attention
+        node_name: out_proj
+        type_name: RowParallelLinear
+        call_count: 1
+        """
+        type_name = parts[-2]
+        call_count = parts[-1]
+        node = self
+        prefix_name_list = parts[:-2]
+
+        for name in prefix_name_list:
+            if name not in node.children:
+                node.children[name] = Trie()
+            node = node.children[name]
+            if node.type_name is None:
+                node.type_name = name
+
+        node.type_name = type_name
+        node.has_data = True
+        node.call_count_list.append(call_count)
+        node.node_type = word_type
+
+
+class DFSConverter:
+    def __init__(self, mapping, max_depth=100):
+        self.mapping = mapping
+        self.max_depth = max_depth
+        self.result = {}
+
+    def traverse_and_collect(self, node, path="", mapping_path="", depth=0):
+        if depth > self.max_depth:
+            logger.error("The converted data depth is too large, please check the data")
+            raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
+
+        if node is None:
+            return self.result
+
+        type_name = node.type_name
+        if node.has_data:
+            for count in node.call_count_list:
+                origin_name = f"{path}.{count}" if node.node_type == "Cell" else f"{path}.{type_name}.{count}"
+                mapping_name = f"{mapping_path}.{count}" if node.node_type == "Cell" else f"{mapping_path}.{type_name}.{count}"
+                self.result[origin_name] = mapping_name
+
+        name_mapping = self.mapping.get(type_name, {})
+
+        for child_name, child_node in node.children.items():
+            new_path = f"{path}.{child_name}" if path else child_name
+            converted_name = name_mapping.get(child_name, child_name)
+            new_mapping_path = f"{mapping_path}.{converted_name}" if mapping_path else converted_name
+            self.traverse_and_collect(child_node, new_path, new_mapping_path, depth+1)
+
+        return self.result
+
+
+def get_mapping_list(ms_tree, mapping):
+    dfs_converter = DFSConverter(mapping)
+    ms_pt_mapping = dfs_converter.traverse_and_collect(ms_tree)
+    mapping_list = []
+    for ms_name, pt_name in ms_pt_mapping.items():
+        pt_name = re.sub(r"^Cell", "Module", pt_name)
+        mapping_list.append((ms_name, pt_name))
+    return mapping_list
+
+
+def get_prefix_mapping(scope_list):
+    """layer name to layer name.class_name"""
+    layer_mapping = {}
+    for name, v in scope_list.items():
+        origin_data = v.get("origin_data")
+        if not origin_data.startswith(("Cell", "Module")):
+            continue
+        name_list = name.split(Const.SEP)
+        if len(name_list) < 2:
+            logger.error('result dataframe elements can not be access.')
+            raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR)
+        prefix_name_list = name_list[:-2] + [name_list[-1]]
+        prefix_name = Const.SEP.join(prefix_name_list)
+        layer_mapping[prefix_name] = name
+    return layer_mapping
+
+
+def get_layer_mapping(ms_scope_list, pt_scope_list, mapping):
+    # 1. get layer prefix to full name mapping
+    # ect: Cell.network_with_loss.language_model.embedding.3 : Cell.network_with_loss.language_model.embedding.Embedding.3
+    ms_prefix2fullname = get_prefix_mapping(ms_scope_list)
+    # 2. build trie tree
+    ms_tree = Trie(type_name="Cell")
+    for k, r in ms_scope_list.items():
+        origin_data_name = r.get('origin_data')
+        data_type = origin_data_name.split(Const.SEP)[0]
+        ms_tree.insert(k, data_type)
+    msname2ptname = get_mapping_list(ms_tree, mapping)
+    # 3. get pt layer prefix to full name mapping
+    # ect: Module.network_with_loss.language_model.embedding.3 : Module.network_with_loss.language_model.embedding.Embedding.3
+    pt_prefix2fullname = get_prefix_mapping(pt_scope_list)
+
+    final_mapping = []
+    for ms_name, pt_name in msname2ptname:
+        final_ms_name = ms_name
+        final_pt_name = pt_name
+        # cell
+        if ms_name in ms_prefix2fullname:
+            final_ms_name = ms_prefix2fullname.get(ms_name)
+            final_pt_name = pt_prefix2fullname.get(pt_name, None)
+        # func
+        elif final_ms_name in ms_scope_list:
+            final_ms_name = ms_scope_list.get(ms_name)['origin_data']
+            # remove forward/backward
+            final_ms_name = Const.SEP.join(final_ms_name.split(Const.SEP)[:-1])
+            final_pt_name = pt_scope_list.get(pt_name, None)
+            if final_pt_name:
+                final_pt_name = final_pt_name['origin_data']
+                final_pt_name = Const.SEP.join(final_pt_name.split(Const.SEP)[:-1])
+        else:
+            continue
+        final_mapping.append((final_ms_name, final_pt_name))
+
+    return final_mapping

msprobe/mindspore/compare/modify_mapping.py

@@ -0,0 +1,107 @@
+from msprobe.core.common.const import Const
+from msprobe.core.common.log import logger
+
+def find_regard_scope(lines, start_sign, end_sign):
+    # 找出 start_pos 和 end_pos
+    start_pos = end_pos = -1
+    for idx, ii in enumerate(lines):
+        if start_sign in ii:
+            start_pos = idx
+        elif end_sign in ii:
+            end_pos = idx
+            break
+    return start_pos, end_pos
+
+
+def find_stack_func_list(lines):
+    res_list = []
+    # 过滤和处理 regard_scope
+    for line in lines:
+        ele_list = line.split(',')
+        file_ele = ele_list[Const.STACK_FILE_INDEX]
+        if any(ii in file_ele for ii in Const.FILE_SKIP_LIST):
+            continue
+
+        func_ele = ele_list[Const.STACK_FUNC_INDEX]
+        if any(ii in func_ele for ii in Const.FUNC_SKIP_LIST):
+            continue
+
+        in_func_name = func_ele.split()[Const.STACK_FUNC_ELE_INDEX]
+
+        res_list.append(in_func_name)
+    # 反转res_list并生成final_res
+    reversed_list = res_list[::-1]
+    return reversed_list
+
+
+def get_duplicated_name(components):
+    duplicated_components = components
+    if len(components) < 3 or components[Const.CONSTRUCT_NAME_INDEX].isdigit():
+        logger.warning("key in construct.json is shorter than 3 parts or not name valid.")
+    else:
+        # 重复name，如Functional.add.add.X ward
+        duplicated_components = components[:Const.CONSTRUCT_NAME_INDEX + 1] + components[Const.CONSTRUCT_NAME_INDEX:]
+    return duplicated_components
+
+
+def modify_mapping_with_stack(stack, construct):
+    if not stack or not construct:
+        return {}
+
+    # 是否是mindspore的数据结构
+    is_ms = any("Cell" in ii for ii in construct)
+    # 调整后的mapping结构
+    final_pres = {}
+    # 查看归属关系
+    for key in construct:
+        key_components = key.split(Const.SEP)
+        code_list = stack.get(key, None)
+        parent_node = construct.get(key, None)
+        # 名称如果非标准开头，转为标准开头
+        if not key.startswith(("Module", "Cell")):
+            # 如果没有拿到父属scope name，默认顶级域名为Module或Cell
+            if not parent_node:
+                # 将节点名字转为标准的Module或Cell
+                key_components[0] = "Cell" if is_ms else "Module"
+                # 重复该节点的名字作为类型 如add.add add在-3位置
+                duplicated_components = get_duplicated_name(key_components)
+                modified_key = Const.SEP.join(duplicated_components)
+
+                modified_key = modified_key.replace(".forward", "").replace(".backward", "")
+                final_pres[modified_key] = {Const.ORIGIN_DATA: key, Const.SCOPE: None, Const.STACK: None}
+                continue
+            parent = parent_node.split(Const.SEP)
+            if len(parent) < 4:
+                logger.info(f"Parent name in construct.json is not valid")
+                continue
+            parent_idx = Const.NAME_FIRST_POSSIBLE_INDEX if not \
+            parent[Const.NAME_FIRST_POSSIBLE_INDEX].isdigit() else Const.NAME_SECOND_POSSIBLE_INDEX
+            parent_name = parent[parent_idx]
+
+            if code_list:
+                # {name}.Class.count_number.X ward Or {name}.Class.count_number.X ward.ele_number
+                if parent_name.endswith('s'):
+                    parent_name = parent_name[:-1]
+                if len(key_components) < 3:
+                    logger.info("The length of key in construct is less than 3, please check")
+                    continue
+                # {name}.count_number.X ward
+                func_name = key_components[-3]
+                start_pos, end_pos = find_regard_scope(code_list, func_name, parent_name)
+
+                # 获取指定范围的代码
+                regard_scope = code_list[start_pos:end_pos]
+
+                func_stack_list = find_stack_func_list(regard_scope)
+            else:
+                func_stack_list = []
+            # 组合逻辑：parent的节点名（到节点名字为止）加上调用栈名[reversed_list]加上原来key重复key的节点名[key_components[1:-2] + key_components[-3:]]
+            final_res_key = Const.SEP.join(parent[:parent_idx + 1] + func_stack_list +
+                                     key_components[1:Const.CONSTRUCT_NAME_INDEX + 1] + key_components[Const.CONSTRUCT_NAME_INDEX:])
+            final_res_key = final_res_key.strip(".forward").strip(".backward")
+        else:
+            final_res_key = Const.SEP.join(key_components[:-2] + [key_components[-1]])
+            func_stack_list = []
+        final_pres[final_res_key] = {Const.ORIGIN_DATA: key, Const.SCOPE: parent_node,
+                                     Const.STACK: Const.SEP.join(func_stack_list) if func_stack_list else None}
+    return final_pres