mindstudio-probe 1.1.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

msprobe/docs/28.kernel_dump_MindSpore.md

@@ -0,0 +1,69 @@
+# MindSpore 场景的 kernel dump 说明
+
+当使用 msprobe 数据采集功能时，level 配置为 "L2" 表示采集 kernel 层级的算子数据，仅支持昇腾 NPU 平台。 
+
+本文主要介绍 kernel dump 的配置示例和采集结果介绍， msprobe 数据采集功能的详细使用参考 《[MindSpore 场景的精度数据采集](./06.data_dump_MindSpore.md)》。
+
+## 1 kernel dump 配置示例
+
+使用 kernel dump 时，list 必须要填一个 API 名称，kernel dump 目前每个 step 只支持采集一个 API 的数据。
+API 名称填写参考 L1 dump 结果文件 dump.json 中的API名称，命名格式为：`{api_type}.{api_name}.{API调用次数}.{forward/backward}`。
+
+```json
+{
+    "task": "tensor",
+    "dump_path": "/home/data_dump",
+    "level": "L2",
+    "rank": [],
+    "step": [],
+    "tensor": {
+        "scope": [],
+        "list": ["Functional.linear.0.backward"]
+    }
+}
+```
+
+## 2 结果文件介绍
+
+### 2.1 采集结果说明
+    
+如果 API kernel 级数据采集成功，会打印以下信息：
+
+```bash
+The kernel data of {api_name} is dumped successfully.
+```
+
+注意：如果打印该信息后，没有数据生成，参考**常见问题3.1**进行排查。
+
+如果 kernel dump 遇到不支持的 API， 会打印以下信息：
+
+```bash
+The kernel dump does not support the {api_name} API.
+```
+
+其中 {api_name} 是对应溢出的 API 名称。
+
+### 2.2 输出文件说明
+kernel dump 采集成功后，会在指定的 dump_path 目录下生成如下文件：
+
+```
+├── /home/data_dump/
+│   ├── step0
+│   │   ├── 20241201103000    # 日期时间格式，表示2024-12-01 10:30:00
+│   │   │   ├── 0             # 表示 device id
+│   │   │   │   ├──{op_type}.{op_name}.{task_id}.{stream_id}.{timestamp}    # kernel 层算子数据
+│   │   │  ...
+│   │   ├── kernel_config_{device_id}.json    # kernel dump 在接口调用过程中生成的中间文件，一般情况下无需关注
+│   │  ...     
+│   ├── step1
+│  ...
+```
+成功采集到数据后，可以使用 msprobe 工具提供的《[PyTorch 场景的数据解析](./14.data_parse_PyTorch.md)》功能分析数据。
+
+## 3 常见问题
+
+#### 3.1 采集结果文件为空，有可能是什么原因？
+
+1. 首先需要确认工具使用方式、配置文件内容、list 填写的 API 名称格式是否都正确无误。
+
+2. 其次需要确认 API 是否运行在昇腾 NPU 上，如果是运行在其他设备上则不会存在 kernel 级数据。

msprobe/docs/FAQ.md

@@ -13,6 +13,29 @@
 2. 如果存在namedtuple类型的数据作为nn.Module的输出，工具会将各字段数据dump下来，但是输出数据类型会被转成tuple，原因是什么？
    - 这是由于pytorch框架自身，在注册module的backward hook时，会将namedtuple类型转成tuple类型。
 
+3. 如果某个api在dump支持列表support_wrap_ops.yaml中，但没有dump该api的数据，原因是什么？
+   - 首先确认api调用是否在采集范围内，即需要在 **start** 和 **stop** 接口涵盖的范围内。
+   - 其次，由于工具只在被调用时才对api进行patch，从而使得数据可以被dump下来。因此当api是被直接import进行调用时，由于该api的地址已经确定，
+   工具无法再对其进行patch，故而该api数据无法被dump下来。如下示例，relu将无法被dump：
+   ```python
+   import torch
+   from torch import relu  # 此时relu地址已经确定，无法修改
+
+   from msprobe.pytorch import PrecisionDebugger
+
+   debugger = PrecisionDebugger(dump_path="./dump_data")
+   x = torch.randn(10)
+   debugger.start()  # 此时会对torch下面的api进行patch，但已无法对import进来的api进行patch了
+   x = relu(x)          
+   debugger.stop()
+   ```
+   在上述场景中，若希望采集relu数据，只需要将`relu(x)`修改为`torch.relu(x)`即可。
+
+4. 在使用L0 dump时，发现有些 module 的数据没有采集下来，原因是什么？
+   - 确认日志打印中是否存在`The {module_name} has registered deprecated register_backward_hook`信息，
+     该信息说明 module 挂载了被 PyTorch 框架废弃的 register_backward_hook，这与工具使用的 register_full_backward_hook 接口会产生冲突，故工具会跳过该 module 的反向数据采集。
+   - 如果您希望所有 module 数据都能采集下来，可以将模型中使用的 register_backward_hook 接口改为 PyTorch 框架推荐的 register_full_backward_pre_hook 或 register_full_backward_hook 接口。
+
 # 2 精度预检(PyTorch)
 
 1. 预检工具在 dump 和 run_ut 的过程中，是否需要同时开启或关闭 jit 编译（jit_compile）？
@@ -183,9 +206,10 @@ def npu_forward_fused_softmax(self, input_, mask):
 
     答：注释工具目录 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中 `Tensor: ` 下的 `- __getitem__`，工具会跳过采集该 API。如果是需要采集关键位置 API 也可以考虑根据报错堆栈信息注释引发报错的类型检查。
 
-11. 添加 msprobe 工具后 F.gelu 触发 ValueError 报错：`activation_func must be F.gelu` 等。以及采集 Megatron 数据时报错：`ValueError(Only support fusion of gelu and swiglu)`。
+11. 使用 msprobe 工具数据采集功能后，模型出现报错，报错信息为：`activation_func must be F.gelu` 或 `ValueError(Only support fusion of gelu and swiglu)`。
 
-    答：这一类问题是因为工具本身封装了 torch 算子，所以校验算子名时会报错。注释 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中的 `-gelu` 或者 `-silu`，工具会跳过采集该 API。如果需要采集关键位置 API 也可以考虑根据报错堆栈信息注释引发报错的类型检查。
+    答：这一类报错常见于 Megatron/MindSpeed/ModelLink 等加速库或模型仓中，原因是工具本身会封装 torch 的 API（API类型和地址会发生改变），而有些 API 在工具使能前类型和地址就已经确定，此时工具无法对这类 API 再进行封装，而加速库中会对某些 API 进行类型检查，即会把工具无法封装的原始的 API和工具封装之后的 API 进行判断，所以会报错。
+    规避方式有3种：①将PrecisionDebugger的实例化放在文件的开始位置，即导包后的位置，确保所有API都被封装；②注释 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中的 `-gelu` 或者 `-silu`，工具会跳过采集该 API。③ 可以考虑根据报错堆栈信息注释引发报错的类型检查。
 
 12. 添加 msprobe 工具后触发与 AsStrided 算子相关、或者编译相关的报错，如：`Failed to compile Op [AsStrided]`。
 

msprobe/docs/accuracy_checker_MindSpore/accuracy_checker_MindSpore_baseline.md

@@ -0,0 +1,14 @@
+# MindSpore 场景的精度预检基线
+
+## "multi_run_ut"模式精度预检耗时参考基线
+
+该基线为MindSpore框架下，使用"multi_run_ut"模式精度预检耗时参考基线。本基线测试了38B语言大模型在不同卡数下耗时的变化。
+
+### 38B语言大模型
+
+| 卡数  | 总耗时 (分钟) | 备注       |
+| ----- |----------|---------- |
+| 1 卡  | 21.0     | 单卡基线    |
+| 2 卡  | 11.5     | 双卡基线    |
+| 4 卡  | 6.7      | 四卡基线    |
+| 8 卡  | 3.5      | 八卡基线    |

msprobe/docs/data_dump_MindSpore/data_dump_MindSpore_baseline.md

@@ -0,0 +1,22 @@
+# MindSpore 场景的精度数据采集基线
+
+## "tensor"模式采集数据量参考基线
+
+该基线为MindSpore框架下，使用"tensor"模式采集数据量参考基线。本基线测试了38B语言大模型在不同采集模式下，不同global_batch_size下，单卡和8卡下，数据量的变化。
+
+### 38B语言大模型
+
+<table>
+    <tr><th>采集模式</th><th>global_batch_size</th><th>单卡</th><th>8卡</th></tr>
+    </td><td rowspan="3">L0</td><td>1</td><td>262GB</td><td>2.1T</td></tr>
+    <tr><td>2</td><td>480GB</td><td>3.8T</td></tr>
+    <tr><td>3</td><td>928GB</td><td>7.4T</td></tr>
+    </td><td rowspan="3">L1</td><td>1</td><td>2.1TB</td><td>17.1TB</td></tr>
+    <tr><td>2</td><td>2.8T</td><td>22.7TB</td></tr>
+    <tr><td>3</td><td>4.2T</td><td>34.3TB</td></tr>
+    </td><td rowspan="3">mix</td><td>1</td><td>2.4T</td><td>19.2TB</td></tr>
+    <tr><td>2</td><td>3.3TB</td><td>26.6TB</td></tr>
+    <tr><td>3</td><td>5.1TB</td><td>41.4TB</td></tr>
+
+</table>
+

msprobe/docs/visualization/layer_mapping_example.md

@@ -0,0 +1,132 @@
+# 模型分级可视化如何配置layer mapping映射文件
+
+## 1.使用场景
+同框架跨套件比对（例如PyTorch DeepSpeed vs Megatron），或者跨框架比对（例如PyTorch vs MindSpore），**由于代码实现的差异，导致一些模型层级和层级命名有所不同无法进行匹配**，需要进行layer层名称映射，才能够比对。
+
+## 2.模块命名说明
+
+由于有些节点的名称比较长，例如Module.module.module.language_model.embedding.Embedding.forward.0，在图节点上由于字符串过长无法完整显示，forward或backward信息被省略，**因此节点中显示的名称字符串去掉了Module前缀，并将forward或backward信息提取到名称字符串的第二位展示**。
+
+![module_name.png](./module_name.png)
+
+![module_name1.png](./module_name1.png)
+
+### 2.1 命名格式
+
+**{Module}.{module_name}.{class_name}.{forward/backward}.{调用次数}**
+
+**layer mapping主要是针对module_name的映射**
+
+#### 2.1.1 命名示例
+
+- **Module.module.Float16Module.forward.0** -----> Module{**Module**}.module{**module_name**}.Float16Module{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.GPTModel.forward.0** -----> Module{**Module**}.module.module{**module_name**}.GPTModel{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.language_model.TransformerLanguageModel.forward.0** -----> Module{**Module**}.module.module.language_model{**module_name**}.TransformerLanguageModel{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.language_model.embedding.Embedding.forward.0** -----> Module{**Module**}.module.module.language_model.embedding{**module_name**}.Embedding{**class_name**}.forward.0{**调用次数**}
+
+可以看到，module_name随着模型层级的深入在变长，**embedding层module_name拼接了它的上层language_model、上上层module和顶层module**。
+
+## 3.示例
+
+如图所示，左边为NPU模型，右边为GPU模型，由于代码实现上的差异，导致模型层级和层级命名有所不同，导致节点无法匹配，**图上节点显示为灰色，表示节点未匹配**。
+
+![no_mapping.png](./no_mapping.png)
+
+### 3.1 看图分析
+
+同一模型使用了不同套件或者框架，虽然两个模型的层级关系和层级命名可能有所不同，但也可以从图上的**节点名称**看出一些匹配关系，例如同是embedding层，代码里也是会命名为xxx_embedding，不会命名为xxx_norm，体现在节点名称上也是带有embedding的信息，并且层级关系也是大致相同的。
+
+![no_mapping_analyze.png](./no_mapping_analyze.png)
+
+分析可知，节点匹配关系如下：
+
+**注意，仅需关注module_name的差异**
+
+| NPU节点名称           | GPU节点名称                                                        | module_name差异                        |
+|-------------------|----------------------------------------------------------------|---------------------------|
+| Module.module.Float16Module.forward.0 | Module.model.FloatModule.forward.0                                 | NPU为module，GPU为model      |
+| Module.module.module.GPTModel.forward.0 | Module.model.module.GPT2Model.forward.0                            | NPU为module，GPU为module，无差异 |
+| Module.module.module.language_model.TransformerLanguageModel.forward.0 | 无                                                              | NPU多了一层                   |
+| Module.module.module.language_model.embedding.Embedding.forward.0 | Module.module.module.embedding.LanguageModelEmbedding.forward.0  | NPU为language_model.embedding，GPU为embedding           |
+| Module.module.module.language_model.rotary_pos_emb.RotaryEmbedding.forward.0 | Module.module.module.rotary_pos_emb.RotaryEmbedding.forward.0    | NPU为language_model.rotary_pos_emb，GPU为rotary_pos_emb |
+| Module.module.module.language_model.encoder.ParallelTransformer.forward.0 | Module.module.module.decoder.TransformerBlock.forward.0          | NPU为language_model.encoder，GPU为decoder               |
+| Module.module.module.language_model.encoder.layers.0.ParallelTransformerLayer.forward.0 | Module.module.module.decoder.layers.0.TransformerLayer.forward.0 | 父层级有差异，本层级NPU和GPU都叫layers，无差异                        |
+
+### 3.2 构建layer_mapping配置文件
+准备一个命名为mapping.yaml文件，建立**module_name**的映射关系
+
+#### 3.2.1 顶层模块映射
+NPU和GPU侧的模块Module.module.Float16Module.forward.0和Module.model.FloatModule.forward.0处于图的顶层，需要进行如下配置：
+
+![top_layer.png](./top_layer.png)
+
+```yaml
+TopLayer:
+  module: model
+```
+
+#### 3.2.2 其他模块映射
+配置module下的子模块，虽然两边的class_name不同（NPU侧为GPTModel，GPU侧为GPT2Model），**但是仅需取NPU侧也就是左边图的class_name进行配置，无需关心右边图的class_name叫什么**。
+
+**这里涉及到跨层级的配置，NPU多了一层language_model层**，将language_model作为embedding层、rotary_pos_emb层和encoder层的前缀，进行如下配置：
+
+![GPTModel.png](./GPTModel.png)
+
+```yaml
+GPTModel:
+    language_model.embedding: embedding
+    language_model.rotary_pos_emb: rotary_pos_emb
+    language_model.encoder: decoder
+```
+然后看Module.module.module.language_model.encoder.ParallelTransformer.forward.0层下的子模块：
+
+此层下的若干个层，NPU和GPU的层名都叫layers，**当前层名称相同，则不用进行配置**。
+
+### 3.3 查看效果
+
+执行命令，指定-lm：
+```
+msprobe -f pytorch graph -i ./compare.json -o ./output -lm ./mapping.yaml
+```
+或
+```
+msprobe -f mindspore graph -i ./compare.json -o ./output -lm ./mapping.yaml
+```
+可以看到，除了language_model层（NPU多的一层，GPU没有层与其匹配），其余在mapping.yaml文件配置的层均匹配上了。
+
+![mapping.png](./mapping.png)
+
+### 3.4 继续配置
+
+展开节点过程中，如果发现还有未匹配节点，则继续配置mapping.yaml
+
+![no_mapping1.png](./no_mapping1.png)
+
+按前一章过程进行分析配置，分析可知，节点匹配关系如下：
+
+| NPU节点名称           | GPU节点名称                                                          | 差异                                          |
+|-------------------|------------------------------------------------------------------|---------------------------------------------|
+| Module.module.module.language_model.encoder.layers.0.mlp.dense_h_to_4h.ColumnParallelLinear.forward.0 | Module.module.module.decoder.layers.0.mlp.linear_fc1.TELayerNormColumnParallelLinear.forward.0      | NPU为dense_h_to_4h，GPU为linear_fc1            |
+| Module.module.module.language_model.encoder.layers.0.mlp.dense_4h_to_h.RowParallelLinear.forward.0 | Module.module.module.decoder.layers.0.mlp.linear_fc2.TERowParallelLinear.forward.0  | NPU为dense_4h_to_h，GPU为linear_fc2 |
+
+![ParallelMLP.png](./ParallelMLP.png)
+
+追加mapping.yaml配置：
+
+```yaml
+TopLayer:
+  module: model
+
+GPTModel:
+    language_model.embedding: embedding
+    language_model.rotary_pos_emb: rotary_pos_emb
+    language_model.encoder: decoder
+
+ParallelMLP:
+    dense_h_to_4h: linear_fc1
+    dense_4h_to_h: linear_fc2
+```
+
+执行命令，查看效果，可以看到节点已成功匹配上。
+
+![mapping1.png](./mapping1.png)

msprobe/mindspore/__init__.py

@@ -13,5 +13,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+
+try:
+    from msprobe.lib import _msprobe_c
+    os.environ["MS_HOOK_ENABLE"] = "on"
+    os.environ["HOOK_TOOL_PATH"] = _msprobe_c.__file__
+except ImportError:
+    from .common.log import logger
+    logger.info("Module _msprobe_c has not been installed. L2-Dump may not work normally.")
+
 from msprobe.mindspore.debugger.precision_debugger import PrecisionDebugger
 from msprobe.mindspore.common.utils import seed_all
+from msprobe.mindspore.monitor.module_hook import TrainerMon

msprobe/mindspore/api_accuracy_checker/api_accuracy_checker.py

@@ -26,10 +26,12 @@ from msprobe.mindspore.api_accuracy_checker.data_manager import DataManager
 from msprobe.mindspore.api_accuracy_checker.utils import (check_and_get_from_json_dict, global_context,
                                                           trim_output_compute_element_list)
 from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.api_accuracy_checker import torch_mindtorch_importer
 
 cur_path = os.path.dirname(os.path.realpath(__file__))
 yaml_path = os.path.join(cur_path, MsCompareConst.SUPPORTED_API_LIST_FILE)
 
+
 class BasicInfoAndStatus:
     def __init__(self, api_name, bench_dtype, tested_dtype, shape, status, err_msg) -> None:
         self.api_name = api_name
@@ -49,6 +51,13 @@ class ResultCsvEntry:
         self.overall_err_msg = None
 
 
+class ProcessResultPacket:
+    def __init__(self, process_status, result, err_msg) -> None:
+        self.process_status = process_status
+        self.result = result
+        self.err_msg = err_msg
+
+
 class ApiAccuracyChecker:
     def __init__(self, args):
         self.api_infos = dict()
@@ -56,7 +65,7 @@ class ApiAccuracyChecker:
 
     @staticmethod
     def run_and_compare_helper(api_info, api_name_str, api_input_aggregation, forward_or_backward):
-        '''
+        """
         Args:
             api_info: ApiInfo
             api_name_str: str
@@ -70,13 +79,15 @@ class ApiAccuracyChecker:
             get mindspore api output, run torch api and get output.
             compare output.
             record compare result.
-        '''
+        """
         # get output
         if global_context.get_is_constructed():
             # constructed situation, need use constructed input to run mindspore api getting tested_output
-            tested_outputs = api_runner(api_input_aggregation, api_name_str, forward_or_backward, Const.MS_FRAMEWORK)
+            tested_outputs = api_runner(api_input_aggregation, api_name_str,
+                                        forward_or_backward, global_context.get_framework())
         else:
             tested_outputs = api_info.get_compute_element_list(forward_or_backward, Const.OUTPUT)
+
         bench_outputs = api_runner(api_input_aggregation, api_name_str, forward_or_backward, Const.PT_FRAMEWORK)
         tested_outputs = trim_output_compute_element_list(tested_outputs, forward_or_backward)
         bench_outputs = trim_output_compute_element_list(bench_outputs, forward_or_backward)
@@ -104,8 +115,8 @@ class ApiAccuracyChecker:
                 err_msg = ""
             else:
                 status = CompareConst.ERROR
-                err_msg = compare_result_dict.get(CompareConst.COSINE).err_msg + \
-                          compare_result_dict.get(CompareConst.MAX_ABS_ERR).err_msg
+                err_msg = (compare_result_dict.get(CompareConst.COSINE).err_msg +
+                           compare_result_dict.get(CompareConst.MAX_ABS_ERR).err_msg)
             basic_info_status = \
                 BasicInfoAndStatus(api_name_with_slot, bench_dtype, tested_dtype, shape, status, err_msg)
             output_list.append(tuple([api_name_str, forward_or_backward, basic_info_status, compare_result_dict]))
@@ -113,13 +124,13 @@ class ApiAccuracyChecker:
 
     @staticmethod
     def prepare_api_input_aggregation(api_info, forward_or_backward=Const.FORWARD):
-        '''
+        """
         Args:
             api_info: ApiInfo
             forward_or_backward: str
         Returns:
             ApiInputAggregation
-        '''
+        """
         forward_inputs = api_info.get_compute_element_list(Const.FORWARD, Const.INPUT)
         kwargs = api_info.get_kwargs()
         if forward_or_backward == Const.FORWARD:
@@ -145,13 +156,19 @@ class ApiAccuracyChecker:
         real_api_str = Const.SEP.join(api_name_str_list[1:-2])
         api_list = load_yaml(yaml_path)
         supported_tensor_api_list = api_list.get(MsCompareConst.SUPPORTED_TENSOR_LIST_KEY)
-        if api_type_str in (MsCompareConst.MINT, MsCompareConst.MINT_FUNCTIONAL):
+        if api_type_str in (MsCompareConst.MINT, MsCompareConst.MINT_FUNCTIONAL) \
+                and global_context.get_framework() == Const.MS_FRAMEWORK:
             return True
-        if api_type_str == MsCompareConst.TENSOR_API and real_api_str in supported_tensor_api_list:
+        if api_type_str in MsCompareConst.MT_VALID_API_TYPES \
+                and global_context.get_framework() == Const.MT_FRAMEWORK:
+            return True
+        if api_type_str == MsCompareConst.TENSOR_API and real_api_str in supported_tensor_api_list \
+                and global_context.get_framework() == Const.MS_FRAMEWORK:
             return True
         return False
 
     def parse(self, api_info_path):
+
         api_info_dict = load_json(api_info_path)
 
         # init global context
@@ -159,13 +176,25 @@ class ApiAccuracyChecker:
                                             "task field in api_info.json", accepted_type=str,
                                             accepted_value=(MsCompareConst.STATISTICS_TASK,
                                                             MsCompareConst.TENSOR_TASK))
+        try:
+            framework = check_and_get_from_json_dict(api_info_dict, MsCompareConst.FRAMEWORK,
+                                                "framework field in api_info.json", accepted_type=str,
+                                                accepted_value=(Const.MS_FRAMEWORK,
+                                                                Const.MT_FRAMEWORK))
+        except Exception as e:
+            framework = Const.MS_FRAMEWORK
+            logger.warning(f"JSON parsing error in framework field: {e}")
+
+        if framework == Const.MT_FRAMEWORK and not torch_mindtorch_importer.is_valid_pt_mt_env:
+            raise Exception(f"Please check if you have a valid PyTorch and MindTorch environment")
+
         is_constructed = task == MsCompareConst.STATISTICS_TASK
         if not is_constructed:
             dump_data_dir = check_and_get_from_json_dict(api_info_dict, MsCompareConst.DUMP_DATA_DIR_FIELD,
                                                          "dump_data_dir field in api_info.json", accepted_type=str)
         else:
             dump_data_dir = ""
-        global_context.init(is_constructed, dump_data_dir)
+        global_context.init(is_constructed, dump_data_dir, framework)
 
         api_info_data = check_and_get_from_json_dict(api_info_dict, MsCompareConst.DATA_FIELD,
                                                      "data field in api_info.json", accepted_type=dict)
@@ -188,45 +217,65 @@ class ApiAccuracyChecker:
         """处理前向检查"""
         if not api_info.check_forward_info():
             logger.debug(f"api: {api_name_str} is lack of forward information, skip forward check.")
-            return Const.EXCEPTION_NONE
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.API_NOT_FOUND,
+                                                        result=None,
+                                                        err_msg=f"forward info of {api_name_str} is not found")
+            return process_result_packet
 
         try:
             forward_inputs_aggregation = self.prepare_api_input_aggregation(api_info, Const.FORWARD)
         except Exception as e:
             logger.warning(f"Exception occurs when getting inputs for {api_name_str} forward api. "
                            f"Skipping forward check. Detailed exception information: {e}.")
-            return Const.EXCEPTION_NONE
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.EXCEPTION_SKIP,
+                                                        result=None, err_msg=f"{e}")
+            return process_result_packet
 
-        forward_output_list = None
         try:
-            forward_output_list = self.run_and_compare_helper(api_info, api_name_str, forward_inputs_aggregation, Const.FORWARD)
+            forward_output_list = self.run_and_compare_helper(api_info, api_name_str, forward_inputs_aggregation,
+                                                              Const.FORWARD)
         except Exception as e:
             logger.warning(f"Exception occurs when running and comparing {api_name_str} forward api. "
                            f"Detailed exception information: {e}.")
-        return forward_output_list
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.EXCEPTION_SKIP,
+                                                        result=None, err_msg=f"{e}")
+            return process_result_packet
+
+        process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.SUCCESS,
+                                                    result=forward_output_list, err_msg="")
+        return process_result_packet
 
     def process_backward(self, api_name_str, api_info):
         """处理反向检查"""
         if not api_info.check_backward_info():
             logger.debug(f"api: {api_name_str} is lack of backward information, skipping backward check.")
-            return Const.EXCEPTION_NONE
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.API_NOT_FOUND,
+                                                        result=None,
+                                                        err_msg=f"backward info of {api_name_str} is not found")
+            return process_result_packet
 
         try:
             backward_inputs_aggregation = self.prepare_api_input_aggregation(api_info, Const.BACKWARD)
         except Exception as e:
             logger.warning(f"Exception occurs when getting inputs for {api_name_str} backward api. "
                            f"Skipping backward check. Detailed exception information: {e}.")
-            return Const.EXCEPTION_NONE
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.EXCEPTION_SKIP,
+                                                        result=None, err_msg=f"{e}")
+            return process_result_packet
 
-        backward_output_list = None
         try:
-            backward_output_list = self.run_and_compare_helper(api_info, api_name_str, backward_inputs_aggregation, Const.BACKWARD)
+            backward_output_list = self.run_and_compare_helper(api_info, api_name_str, backward_inputs_aggregation,
+                                                               Const.BACKWARD)
         except Exception as e:
             logger.warning(f"Exception occurs when running and comparing {api_name_str} backward api. "
                            f"Detailed exception information: {e}.")
-        return backward_output_list
-
+            process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.EXCEPTION_SKIP,
+                                                        result=None, err_msg=f"{e}")
+            return process_result_packet
 
+        process_result_packet = ProcessResultPacket(process_status=MsCompareConst.ProcessStatus.SUCCESS,
+                                                    result=backward_output_list, err_msg="")
+        return process_result_packet
 
     def run_and_compare(self):
         for api_name_str, api_info in tqdm(self.api_infos.items()):
@@ -234,14 +283,17 @@ class ApiAccuracyChecker:
                 continue
 
             # 处理前向
-            forward_output_list = self.process_forward(api_name_str, api_info)
-            if forward_output_list is not Const.EXCEPTION_NONE:
-                self.data_manager.record(forward_output_list)
+            process_result_packet = self.process_forward(api_name_str, api_info)
+            if process_result_packet.process_status is MsCompareConst.ProcessStatus.SUCCESS:
+                self.data_manager.record(process_result_packet.result)
+            elif process_result_packet.process_status == MsCompareConst.ProcessStatus.EXCEPTION_SKIP:
+                self.data_manager.record_exception_skip(api_name_str, Const.FORWARD, process_result_packet.err_msg)
 
             # 处理反向
-            backward_output_list = self.process_backward(api_name_str, api_info)
-            if backward_output_list is not Const.EXCEPTION_NONE:
-                self.data_manager.record(backward_output_list)
+            process_result_packet = self.process_backward(api_name_str, api_info)
+            if process_result_packet.process_status is MsCompareConst.ProcessStatus.SUCCESS:
+                self.data_manager.record(process_result_packet.result)
+            elif process_result_packet.process_status == MsCompareConst.ProcessStatus.EXCEPTION_SKIP:
+                self.data_manager.record_exception_skip(api_name_str, Const.BACKWARD, process_result_packet.err_msg)
 
             self.data_manager.save_results(api_name_str)
-