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

msprobe/core/data_dump/data_collector.py

@@ -1,7 +1,6 @@
-
 import os
 
-from msprobe.core.data_dump.scope import  build_scope, ListScope
+from msprobe.core.data_dump.scope import build_scope, ListScope
 from msprobe.core.data_dump.json_writer import DataWriter
 from msprobe.core.common.log import logger
 from msprobe.core.common.const import Const
@@ -21,7 +20,8 @@ class DataCollector:
         self.config = config
         self.data_writer = DataWriter()
         self.data_processor = DataProcessorFactory.create_processor(self.config, self.data_writer)
-        self.module_processor = DataProcessorFactory.get_module_processor(self.config.framework) if self.config.framework == Const.PT_FRAMEWORK else None
+        self.module_processor = DataProcessorFactory.get_module_processor(self.config.framework) \
+            if self.config.framework == Const.PT_FRAMEWORK else None
         self.module_count = {}
         if self.config.task == Const.FREE_BENCHMARK:
             self.scope = build_scope(ListScope, self.config.scope, self.config.list)
@@ -35,7 +35,7 @@ class DataCollector:
     @property
     def dump_file_path(self):
         return self.data_writer.dump_file_path
-    
+
     @staticmethod
     def check_scope_and_pid(scope, name, pid):
         return (not scope or scope.check(name)) and pid == os.getpid()
@@ -43,10 +43,10 @@ class DataCollector:
     @staticmethod
     def is_inplace(module):
         return getattr(module, "op_is_inplace", False)
-    
+
     def if_return_forward_new_output(self):
         return self.data_processor.if_return_forward_new_output()
-    
+
     def get_forward_new_output(self):
         return self.data_processor.get_forward_new_output()
 
@@ -71,12 +71,11 @@ class DataCollector:
         backward_name = name.replace(Const.FORWARD, Const.BACKWARD)
         if self.check_scope_and_pid(self.scope, backward_name, pid):
             self.data_processor.analyze_pre_forward(backward_name, module, module_input_output)
-        if not self.is_inplace(module):
+        if not self.is_inplace(module) or not self.check_scope_and_pid(self.scope, name, pid):
             return
         logger.info(f"API {name} is inplace.")
-        if self.check_scope_and_pid(self.scope, name, pid):
-            data_info = self.data_processor.analyze_pre_forward_inplace(name, module_input_output)
-            self.update_data(data_info)
+        data_info = self.data_processor.analyze_pre_forward_inplace(name, module_input_output)
+        self.handle_data(name, data_info)
 
     def forward_data_collect(self, name, module, pid, module_input_output):
         self.update_construct(name)
@@ -88,8 +87,11 @@ class DataCollector:
         else:
             data_info = self.data_processor.analyze_forward_inplace(name, module_input_output)
         if self.config.level == "L2":
-            return 
+            return
         self.data_writer.update_stack(self.data_processor.analyze_api_call_stack(name))
+        if self.data_processor.is_terminated:
+            self.handle_data(name, data_info, use_buffer=False)
+            raise Exception("[msprobe] exit")
         self.handle_data(name, data_info)
 
     def backward_data_collect(self, name, module, pid, module_input_output):
@@ -98,43 +100,45 @@ class DataCollector:
             return
 
         data_info = self.data_processor.analyze_backward(name, module, module_input_output)
+        if self.data_processor.is_terminated:
+            self.handle_data(name, data_info, use_buffer=False)
+            raise Exception("[msprobe] exit")
+        self.handle_data(name, data_info)
+
+    def backward_input_data_collect(self, name, module, pid, module_input_output):
+        self.update_construct(name)
+        if not self.check_scope_and_pid(self.scope, name, pid):
+            return
+
+        data_info = self.data_processor.analyze_backward_input(name, module, module_input_output)
+        self.handle_data(name, data_info)
+
+    def backward_output_data_collect(self, name, module, pid, module_input_output):
+        self.update_construct(name)
+        if not self.check_scope_and_pid(self.scope, name, pid):
+            return
+
+        data_info = self.data_processor.analyze_backward_output(name, module, module_input_output)
         self.handle_data(name, data_info)
 
     def update_construct(self, name):
-        if self.config.level not in DataCollector.level_without_construct:
+        if self.config.framework == Const.PT_FRAMEWORK and self.config.level not in DataCollector.level_without_construct:
             self.data_writer.update_construct({name: self.module_processor.api_parent_node})
             self.data_writer.update_construct(self.module_processor.module_node)
 
-    def handle_data(self, name, data_info):
-        msg = f"msProbe is collecting data on {name}. "
+    def handle_data(self, name, data_info, use_buffer=True):
         if data_info:
+            msg = f"msprobe is collecting data on {name}. "
             msg = self.update_data(data_info, msg)
             logger.info(msg)
-        self.data_writer.flush_data_when_buffer_is_full()
-
-    def module_count_func(self, name, name_template):
-        module_name = name.split(Const.SEP)[-3]
-        if "forward" in name_template:
-            if module_name not in self.module_count:
-                self.module_count[module_name] = [0, [0]]
-            else:
-                if self.module_count[module_name][-1] and \
-                        self.module_count[module_name][0] != self.module_count[module_name][-1][-1]:
-                    self.module_count[module_name][-1].pop()
-                self.module_count[module_name][0] += 1
-                self.module_count[module_name][-1].append(self.module_count[module_name][0])
-            index = self.module_count[module_name][0]
+        if use_buffer:
+            self.data_writer.flush_data_when_buffer_is_full()
         else:
-            backward_stack = self.module_count[module_name][-1] if module_name in self.module_count else []
-            if not backward_stack:
-                index = "abnormal"
-            else:
-                index = backward_stack.pop()
-        return index
+            self.write_json()
 
     def update_dump_paths(self, *args):
         self.data_writer.update_dump_paths(*args)
         self.data_writer.initialize_json_file(task=self.config.task, level=self.config.level)
-    
+
     def update_iter(self, current_iter):
         self.data_processor.update_iter(current_iter)

msprobe/core/data_dump/data_processor/base.py

@@ -35,11 +35,29 @@ class ModuleBackwardInputsOutputs:
     @property
     def grad_input_tuple(self):
         return convert_tuple(self.grad_input)
-        
+
     @property
     def grad_output_tuple(self):
-        return convert_tuple(self.grad_output)    
-        
+        return convert_tuple(self.grad_output)
+
+
+@dataclass
+class ModuleBackwardInputs:
+    grad_input: Optional[Tuple]
+
+    @property
+    def grad_input_tuple(self):
+        return convert_tuple(self.grad_input)
+
+
+@dataclass
+class ModuleBackwardOutputs:
+    grad_output: Optional[Tuple]
+
+    @property
+    def grad_output_tuple(self):
+        return convert_tuple(self.grad_output)
+
 
 class TensorStatInfo:
     def __init__(self, max_val=None, min_val=None, mean_val=None, norm_val=None):
@@ -53,7 +71,7 @@ class BaseDataProcessor:
     _recursive_key_stack = []
     special_type = (np.integer, np.floating, np.bool_, np.complexfloating, np.str_, np.byte, np.unicode_,
                     bool, int, float, str, slice)
-    
+
     def __init__(self, config, data_writer):
         self.data_writer = data_writer
         self.config = config
@@ -65,11 +83,15 @@ class BaseDataProcessor:
         self.current_iter = 0
         self._return_forward_new_output = False
         self._forward_new_output = None
-        
+
     @property
     def data_path(self):
         return self.data_writer.dump_tensor_data_dir
-        
+    
+    @property
+    def is_terminated(self):
+        return False
+
     @staticmethod
     def analyze_api_call_stack(name):
         stack_str = []
@@ -87,7 +109,17 @@ class BaseDataProcessor:
             stack_str.append(stack_line)
         stack_info_struct = {name: stack_str}
         return stack_info_struct
-    
+
+    @staticmethod
+    def transfer_type(data):
+        dtype = str(type(data))
+        if 'int' in dtype:
+            return int(data)
+        elif 'float' in dtype:
+            return float(data)
+        else:
+            return data
+
     @staticmethod
     def _convert_numpy_to_builtin(arg):
         type_mapping = {
@@ -103,26 +135,15 @@ class BaseDataProcessor:
             if isinstance(arg, numpy_type):
                 return builtin_type(arg), type(arg).__name__
         return arg, ''
-    
+
     @staticmethod
     def _analyze_numpy(value, numpy_type):
         return {"type": numpy_type, "value": value}
-    
-    @staticmethod
-    def _analyze_builtin(arg):
-        single_arg = {}
-        if isinstance(arg, slice):
-            single_arg.update({"type": "slice"})
-            single_arg.update({"value": [arg.start, arg.stop, arg.step]})
-        else:
-            single_arg.update({"type": type(arg).__name__})
-            single_arg.update({"value": arg})
-        return single_arg
-    
+
     @classmethod
     def get_special_types(cls):
         return cls.special_type
-    
+
     @classmethod
     def recursive_apply_transform(cls, args, transform):
         if isinstance(args, cls.get_special_types()):
@@ -177,13 +198,17 @@ class BaseDataProcessor:
         return (Const.ALL in self.config.data_mode or
                 forward_backward in self.config.data_mode or
                 input_output in self.config.data_mode)
-    
-    def analyze_pre_forward(self, name, module,module_input_output: ModuleForwardInputsOutputs):
+
+    def analyze_pre_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
         pass
     
+    def analyze_element(self, element):
+        return self.recursive_apply_transform(element, self.analyze_single_element)
+
     def analyze_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
         api_info_struct = {}
-        if self.is_dump_for_data_mode(Const.FORWARD, Const.INPUT): # check whether data_mode contains forward or input
+        # check whether data_mode contains forward or input
+        if self.is_dump_for_data_mode(Const.FORWARD, Const.INPUT):
             api_info_struct[name] = {}
             self.api_data_category = Const.INPUT
             args_info_list = self.analyze_element(module_input_output.args_tuple)
@@ -192,13 +217,14 @@ class BaseDataProcessor:
             kwargs_info_list = self.analyze_element(module_input_output.kwargs)
             api_info_struct[name][Const.INPUT_KWARGS] = kwargs_info_list
 
-        if self.is_dump_for_data_mode(Const.FORWARD, Const.OUTPUT): # check whether data_mode contains forward or output
+        # check whether data_mode contains forward or output
+        if self.is_dump_for_data_mode(Const.FORWARD, Const.OUTPUT):
             api_info_struct[name] = api_info_struct.get(name, {})
             self.api_data_category = Const.OUTPUT
             output_info_list = self.analyze_element(module_input_output.output_tuple)
             api_info_struct[name][Const.OUTPUT] = output_info_list
         return api_info_struct
-    
+
     def analyze_pre_forward_inplace(self, name, module_input_output: ModuleForwardInputsOutputs):
         api_info_struct = {}
         if self.is_dump_for_data_mode(Const.FORWARD, Const.INPUT):
@@ -210,7 +236,7 @@ class BaseDataProcessor:
             kwargs_info_list = self.analyze_element(module_input_output.kwargs)
             api_info_struct[name][Const.INPUT_KWARGS] = kwargs_info_list
         return api_info_struct
-    
+
     def analyze_forward_inplace(self, name, module_input_output: ModuleForwardInputsOutputs):
         concat_args = module_input_output.concat_args_and_kwargs()
         api_info_struct = {}
@@ -220,26 +246,48 @@ class BaseDataProcessor:
             output_info_list = self.analyze_element(concat_args)
             api_info_struct[name][Const.OUTPUT] = output_info_list
         return api_info_struct
-    
+
     def analyze_backward(self, name, module, module_input_output: ModuleBackwardInputsOutputs):
         api_info_struct = {}
-        if self.is_dump_for_data_mode(Const.BACKWARD, Const.OUTPUT):
+        if self.is_dump_for_data_mode(Const.BACKWARD, Const.INPUT):
             api_info_struct[name] = {}
-            self.api_data_category = Const.OUTPUT
+            self.api_data_category = Const.INPUT
             input_info_list = self.analyze_element(module_input_output.grad_input_tuple)
-            api_info_struct[name][Const.GRAD_INPUT] = input_info_list
+            api_info_struct[name][Const.INPUT] = input_info_list
 
-        if self.is_dump_for_data_mode(Const.BACKWARD, Const.INPUT):
+        if self.is_dump_for_data_mode(Const.BACKWARD, Const.OUTPUT):
             api_info_struct[name] = api_info_struct.get(name, {})
-            self.api_data_category = Const.INPUT
+            self.api_data_category = Const.OUTPUT
             output_info_list = self.analyze_element(module_input_output.grad_output_tuple)
-            api_info_struct[name][Const.GRAD_OUTPUT] = output_info_list
+            api_info_struct[name][Const.OUTPUT] = output_info_list
+
+        return api_info_struct
+
+    def analyze_backward_input(self, name, module,
+                               module_input_output: ModuleBackwardInputs):
+        api_info_struct = {}
+        if self.is_dump_for_data_mode(Const.BACKWARD, Const.INPUT):
+            api_info_struct[name] = {}
+            self.api_data_category = Const.INPUT
+
+            input_info_list = self.analyze_element(module_input_output.grad_input_tuple)
+            api_info_struct[name][Const.INPUT] = input_info_list
+        return api_info_struct
 
+    def analyze_backward_output(self, name, module,
+                                module_input_output: ModuleBackwardOutputs):
+        api_info_struct = {}
+        if self.is_dump_for_data_mode(Const.BACKWARD, Const.OUTPUT):
+            api_info_struct[name] = {}
+            self.api_data_category = Const.OUTPUT
+
+            output_info_list = self.analyze_element(module_input_output.grad_output_tuple)
+            api_info_struct[name][Const.OUTPUT] = output_info_list
         return api_info_struct
 
     def get_save_file_path(self, suffix):
-        file_format = "pt" if self.config.framework == Const.PT_FRAMEWORK else "npy"      
+        file_format = Const.PT_SUFFIX if self.config.framework == Const.PT_FRAMEWORK else Const.NUMPY_SUFFIX
         dump_data_name = (self.current_api_or_module_name + Const.SEP + self.api_data_category + Const.SEP +
-                          suffix + Const.SEP + file_format)
+                          suffix + file_format)
         file_path = os.path.join(self.data_writer.dump_tensor_data_dir, dump_data_name)
-        return dump_data_name, file_path
+        return dump_data_name, file_path

msprobe/core/data_dump/data_processor/factory.py

@@ -4,7 +4,7 @@ from msprobe.core.common.const import Const
 class DataProcessorFactory:
     _data_processor = {}
     _module_processor = {}
-    
+
     @classmethod
     def register_processor(cls, framework, task, processor_class):
         key = (framework, task)
@@ -13,7 +13,7 @@ class DataProcessorFactory:
     @classmethod
     def register_module_processor(cls, framework, processor_class):
         cls._module_processor[framework] = processor_class
-        
+
     @classmethod
     def get_module_processor(cls, framework):
         processor_class = cls._module_processor.get(framework)
@@ -39,7 +39,7 @@ class DataProcessorFactory:
                 TensorDataProcessor as PytorchTensorDataProcessor,
                 OverflowCheckDataProcessor as PytorchOverflowCheckDataProcessor,
                 FreeBenchmarkDataProcessor as PytorchFreeBenchmarkDataProcessor,
-                KernelDumpDataProcessor as PytorchKernelDumpDataProcessor 
+                KernelDumpDataProcessor as PytorchKernelDumpDataProcessor
             )
             from ....pytorch.module_processer import ModuleProcesser
             cls.register_processor(Const.PT_FRAMEWORK, Const.STATISTICS, PytorchStatisticsDataProcessor)
@@ -47,15 +47,13 @@ class DataProcessorFactory:
             cls.register_processor(Const.PT_FRAMEWORK, Const.OVERFLOW_CHECK, PytorchOverflowCheckDataProcessor)
             cls.register_processor(Const.PT_FRAMEWORK, Const.FREE_BENCHMARK, PytorchFreeBenchmarkDataProcessor)
             cls.register_processor(Const.PT_FRAMEWORK, Const.KERNEL_DUMP, PytorchKernelDumpDataProcessor)
-            cls.register_module_processor(Const.PT_FRAMEWORK, ModuleProcesser)                                              
+            cls.register_module_processor(Const.PT_FRAMEWORK, ModuleProcesser)
         elif framework == Const.MS_FRAMEWORK:
             from .mindspore_processor import (
                 StatisticsDataProcessor as MindsporeStatisticsDataProcessor,
                 TensorDataProcessor as MindsporeTensorDataProcessor,
-                OverflowCheckDataProcessor as MindsporeOverflowCheckDataProcessor,
-                FreeBenchmarkDataProcessor as MindsporeFreeBenchmarkDataProcessor
+                OverflowCheckDataProcessor as MindsporeOverflowCheckDataProcessor
             )
             cls.register_processor(Const.MS_FRAMEWORK, Const.STATISTICS, MindsporeStatisticsDataProcessor)
             cls.register_processor(Const.MS_FRAMEWORK, Const.TENSOR, MindsporeTensorDataProcessor)
             cls.register_processor(Const.MS_FRAMEWORK, Const.OVERFLOW_CHECK, MindsporeOverflowCheckDataProcessor)
-            cls.register_processor(Const.MS_FRAMEWORK, Const.FREE_BENCHMARK, MindsporeFreeBenchmarkDataProcessor)

msprobe/core/data_dump/data_processor/mindspore_processor.py

@@ -0,0 +1,198 @@
+# 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 zlib
+
+import mindspore as ms
+from mindspore import ops
+import numpy as np
+
+from msprobe.core.common.const import Const
+from msprobe.core.data_dump.data_processor.base import (BaseDataProcessor, TensorStatInfo,
+                                                        ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs)
+from msprobe.core.common.file_check import path_len_exceeds_limit
+from msprobe.mindspore.dump.hook_cell.wrap_functional import load_ops_functions
+from msprobe.mindspore.common.utils import convert_bf16_to_fp32, save_tensor_as_npy
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.dump.hook_cell.api_registry import api_register
+
+
+class MindsporeDataProcessor(BaseDataProcessor):
+    mindspore_special_type = tuple([ms.Tensor])
+    ops_func, mint_ops_func, _ = load_ops_functions()
+
+    def __init__(self, config, data_writer):
+        super().__init__(config, data_writer)
+        self.mindspore_object_key = {
+            "dtype": self.analyze_dtype_in_kwargs
+        }
+
+    @staticmethod
+    def get_md5_for_tensor(x):
+        x = convert_bf16_to_fp32(x)
+        tensor_bytes = x.asnumpy().tobytes()
+        crc32_hash = zlib.crc32(tensor_bytes)
+        return f"{crc32_hash:08x}"
+
+    @staticmethod
+    def analyze_dtype_in_kwargs(element):
+        return {"type": "mindspore.dtype", "value": str(element)}
+
+    @staticmethod
+    def _analyze_builtin(arg):
+        single_arg = {}
+        if isinstance(arg, slice):
+            single_arg.update({"type": "slice"})
+            # slice参数中可能存在tensor类型，json序列化，需要转换为python数值类型
+            values = [
+                value if not isinstance(value, ms.Tensor) else value.item()
+                for value in [arg.start, arg.stop, arg.step]
+            ]
+            single_arg.update({"value": values})
+        else:
+            single_arg.update({"type": type(arg).__name__})
+            single_arg.update({"value": arg})
+        return single_arg
+
+    @classmethod
+    def get_special_types(cls):
+        return super().get_special_types() + cls.mindspore_special_type
+
+    def get_stat_info(self, data):
+        tensor_stat = TensorStatInfo()
+        if data.numel() == 0:
+            return tensor_stat
+        elif data.dtype == ms.bool_:
+            data_np = data.asnumpy()
+            tensor_stat.max = np.max(data_np).item()
+            tensor_stat.min = np.min(data_np).item()
+        elif not data.shape:
+            tensor_stat.max = tensor_stat.min = tensor_stat.mean = tensor_stat.norm = data.item()
+        elif data.dtype == ms.complex64 or data.dtype == ms.complex128:
+            data_abs = np.abs(data.asnumpy())
+            tensor_stat.max = np.max(data_abs).item()
+            tensor_stat.min = np.min(data_abs).item()
+            tensor_stat.mean = np.mean(data_abs).item()
+            tensor_stat.norm = np.linalg.norm(data_abs).item()
+        else:
+            if data.dtype == ms.bfloat16 or not ops.is_floating_point(data):
+                data = data.to(ms.float32)
+            api_register.norm_inner_op_set_ori_func()
+            tensor_stat.max = self.mint_ops_func["max"](data).item()
+            tensor_stat.min = self.mint_ops_func["min"](data).item()
+            tensor_stat.mean = self.mint_ops_func["mean"](data).item()
+            tensor_stat.norm = self.ops_func["norm"](data).item()
+            api_register.norm_inner_op_set_hook_func()
+        return tensor_stat
+
+    def analyze_single_element(self, element, suffix_stack):
+        if suffix_stack and suffix_stack[-1] in self.mindspore_object_key:
+            return self.mindspore_object_key[suffix_stack[-1]](element)
+
+        converted_numpy, numpy_type = self._convert_numpy_to_builtin(element)
+        if converted_numpy is not element:
+            return self._analyze_numpy(converted_numpy, numpy_type)
+        if isinstance(element, ms.Tensor):
+            return self._analyze_tensor(element, Const.SEP.join(suffix_stack))
+
+        if isinstance(element, (bool, int, float, str, slice)):
+            return self._analyze_builtin(element)
+        return {}
+
+    def _analyze_tensor(self, tensor, suffix):
+        tensor_stat = self.get_stat_info(tensor)
+        tensor_json = {
+            'type': 'mindspore.Tensor',
+            'dtype': str(tensor.dtype),
+            'shape': tensor.shape,
+            'Max': self.transfer_type(tensor_stat.max),
+            'Min': self.transfer_type(tensor_stat.min),
+            'Mean': self.transfer_type(tensor_stat.mean),
+            'Norm': self.transfer_type(tensor_stat.norm),
+        }
+        if self.config.summary_mode == Const.MD5:
+            tensor_md5 = self.get_md5_for_tensor(tensor)
+            tensor_json.update({Const.MD5: tensor_md5})
+        return tensor_json
+
+
+class StatisticsDataProcessor(MindsporeDataProcessor):
+    pass
+
+
+class TensorDataProcessor(MindsporeDataProcessor):
+    def _analyze_tensor(self, tensor, suffix):
+        dump_data_name, file_path = self.get_save_file_path(suffix)
+        single_arg = super()._analyze_tensor(tensor, suffix)
+        single_arg.update({"data_name": dump_data_name})
+        save_tensor_as_npy(tensor, file_path)
+        return single_arg
+
+
+class OverflowCheckDataProcessor(MindsporeDataProcessor):
+    __slots__ = ["cached_tensors_and_file_paths"]
+
+    def __init__(self, config, data_writer):
+        super().__init__(config, data_writer)
+        self.cached_tensors_and_file_paths = {}
+        self.real_overflow_nums = 0
+        self.overflow_nums = config.overflow_nums
+
+    @property
+    def is_terminated(self):
+        if self.overflow_nums == -1:
+            return False
+        if self.real_overflow_nums >= self.overflow_nums:
+            logger.info(f"[msprobe] 超过预设溢出次数 当前溢出次数: {self.real_overflow_nums}")
+            return True
+        return False
+
+    def analyze_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
+        self.has_overflow = False
+        api_info_struct = super().analyze_forward(name, module, module_input_output)
+        self.maybe_save_overflow_data()
+        return api_info_struct if self.has_overflow else None
+
+    def analyze_backward(self, name, module, module_input_output: ModuleBackwardInputsOutputs):
+        self.has_overflow = False
+        api_info_struct = super().analyze_backward(name, module, module_input_output)
+        self.maybe_save_overflow_data()
+        return api_info_struct if self.has_overflow else None
+
+    def maybe_save_overflow_data(self):
+        if self.has_overflow:
+            for file_path, tensor in self.cached_tensors_and_file_paths.items():
+                save_tensor_as_npy(tensor, file_path)
+            self.real_overflow_nums += 1
+        self.cached_tensors_and_file_paths = {}
+
+    def _analyze_maybe_overflow_tensor(self, tensor_json):
+        if tensor_json['Max'] is None:
+            return
+        if np.isinf(tensor_json['Max']) or np.isnan(tensor_json['Max']):
+            self.has_overflow = True
+        if np.isinf(tensor_json['Min']) or np.isnan(tensor_json['Min']):
+            self.has_overflow = True
+
+    def _analyze_tensor(self, tensor, suffix):
+        dump_data_name, file_path = self.get_save_file_path(suffix)
+        if not path_len_exceeds_limit(file_path):
+            self.cached_tensors_and_file_paths.update({file_path: tensor})
+        else:
+            logger.warning(f'The file path {file_path} length exceeds limit.')
+        single_arg = super()._analyze_tensor(tensor, suffix)
+        self._analyze_maybe_overflow_tensor(single_arg)
+        single_arg.update({"data_name": dump_data_name})
+        return single_arg