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

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,15 @@
 # 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

msprobe/mindspore/api_accuracy_checker/api_accuracy_checker.py

@@ -30,6 +30,7 @@ from msprobe.mindspore.common.log import logger
 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 +50,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 +64,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,7 +78,7 @@ 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
@@ -104,8 +112,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 +121,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:
@@ -162,7 +170,8 @@ class ApiAccuracyChecker:
         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)
+                                                         "dump_data_dir field in api_info.json",
+                                                         accepted_type=str)
         else:
             dump_data_dir = ""
         global_context.init(is_constructed, dump_data_dir)
@@ -188,45 +197,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 +263,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)
-

msprobe/mindspore/api_accuracy_checker/cmd_parser.py

@@ -16,10 +16,10 @@
 import argparse
 import os
 
-
 from msprobe.core.common.file_utils import check_file_or_directory_path, create_directory
 from msprobe.core.common.utils import Const, MsprobeBaseException
 
+
 class UniqueDeviceAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
         unique_values = set(values)
@@ -40,6 +40,7 @@ def add_api_accuracy_checker_argument(parser):
     parser.add_argument("-csv_path", "--result_csv_path", dest="result_csv_path", default="", type=str, required=False,
                         help="<optional> the exit csv for continue")
 
+
 def multi_add_api_accuracy_checker_argument(parser):
     parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", type=str, required=True,
                         help="<Required> The api param tool result file: generate from api param tool, "

msprobe/mindspore/api_accuracy_checker/compute_element.py

@@ -78,12 +78,10 @@ class ComputeElement:
         else:
             torch_dtype = dtype_str_to_torch_dtype.get(dtype_str)
 
-        if dtype_str in float_dtype_str_list:
-            middle_dtype = mindspore.float64
-        elif dtype_str in int_dtype_str_list:
+        if dtype_str in int_dtype_str_list:
             middle_dtype = mindspore.int64
         else:
-            middle_dtype = mindspore.uint64
+            middle_dtype = mindspore.float64
         np_ndarray = ms_tensor.astype(middle_dtype).numpy()
         torch_tensor = torch.from_numpy(np_ndarray).to(torch_dtype)
         return torch_tensor
@@ -106,10 +104,10 @@ class ComputeElement:
         else:
             ms_dtype = dtype_str_to_ms_dtype.get(dtype_str)
 
-        if dtype_str in float_dtype_str_list:
-            middle_dtype = torch.float64
-        elif dtype_str in int_dtype_str_list:
+        if dtype_str in int_dtype_str_list:
             middle_dtype = torch.int64
+        else:
+            middle_dtype = torch.float64
         np_ndarray = torch_tensor.to(middle_dtype, copy=True).numpy()
         ms_tensor = mindspore.Tensor.from_numpy(np_ndarray).astype(ms_dtype)
         return ms_tensor

msprobe/mindspore/api_accuracy_checker/data_manager.py

@@ -80,6 +80,7 @@ def check_csv_header(headers, required_constants, csv_path):
 class DataManager:
     def __init__(self, csv_dir, result_csv_path):
         self.results = {}
+        self.results_exception_skip = {}
         self.is_first_write = True  # 标记用于添加表头
         self.csv_dir = csv_dir
         self.api_names_set = set()  # 存储已经出现的 API 名称的集合
@@ -184,10 +185,21 @@ class DataManager:
             logger.debug(f"Updated self.results for key {key}: {self.results[key]}")
         logger.debug(f"Complete self.results after recording: {self.results}")
 
+    def record_exception_skip(self, api_name, forward_or_backward, err_msg):
+        '''
+            record exception_skip infomation into self.record_exception_skip.
+            self.record_exception_skip: dict{str: dict{"forward": str/None, "backward": str/None}}
+            string in key is api_name, string in value is err_msg
+        '''
+        if api_name not in self.results_exception_skip:
+            self.results_exception_skip[api_name] = {Const.FORWARD: None, Const.BACKWARD: None}
+        self.results_exception_skip[api_name][forward_or_backward] = err_msg
+
     def clear_results(self):
         """清空 self.results 数据"""
         logger.debug("Clearing self.results data.")
         self.results.clear()
+        self.results_exception_skip.clear()
 
     def to_detail_csv(self, csv_path):
         logger.debug("Preparing detail CSV headers and rows.")
@@ -218,6 +230,9 @@ class DataManager:
         logger.debug(f"Detail CSV written successfully to {csv_path}.")
 
     def to_result_csv(self, csv_path):
+        '''
+            depend on both self.results and self.results_exception_skip
+        '''
         logger.debug("Preparing result CSV data.")
         result_csv = []
 
@@ -254,8 +269,30 @@ class DataManager:
                 entry.backward_pass_status,
                 overall_err_msg
             ]
+            # change row if this api has excption_skip infomation
+            if api_name in self.results_exception_skip:
+                if self.results_exception_skip[api_name][Const.FORWARD] is not None:
+                    row[1] = CompareConst.SKIP
+                    row[-1] += self.results_exception_skip[api_name][Const.FORWARD]
+                if self.results_exception_skip[api_name][Const.BACKWARD] is not None:
+                    row[2] = CompareConst.SKIP
+                    row[-1] += self.results_exception_skip[api_name][Const.BACKWARD]
+                del self.results_exception_skip[api_name]
             result_csv.append(row)
             logger.debug(f"Result CSV row added: {row}")
+        for api_name in self.results_exception_skip:
+            current_exception_skip = self.results_exception_skip[api_name]
+            forward_status = None
+            backward_status = None
+            err_msg = ""
+            if current_exception_skip[Const.FORWARD] is not None:
+                forward_status = CompareConst.SKIP
+                err_msg += current_exception_skip[Const.FORWARD]
+            if current_exception_skip[Const.BACKWARD] is not None:
+                backward_status = CompareConst.SKIP
+                err_msg += current_exception_skip[Const.BACKWARD]
+            row = [api_name, forward_status, backward_status, err_msg]
+            result_csv.append(row)
 
         write_csv(result_csv, csv_path, mode="a+")
         logger.debug(f"Result CSV written successfully to {csv_path}.")

msprobe/mindspore/api_accuracy_checker/main.py

@@ -26,6 +26,7 @@ def api_checker_main(args):
     api_accuracy_checker.parse(args.api_info_file)
     api_accuracy_checker.run_and_compare()
 
+
 def mul_api_checker_main(args):
     check_args(args)
     api_accuracy_checker = MultiApiAccuracyChecker(args)

msprobe/mindspore/api_accuracy_checker/multi_api_accuracy_checker.py

@@ -154,14 +154,16 @@ class MultiApiAccuracyChecker(ApiAccuracyChecker):
         """
         if not api_info.check_forward_info():
             logger.debug(
-                f"[Device {self.current_device_id}] API: {api_name_str} lacks forward information, skipping forward check.")
+                f"[Device {self.current_device_id}] API: {api_name_str} lacks forward information, skipping "
+                f"forward check.")
             return Const.EXCEPTION_NONE
 
         try:
             forward_inputs_aggregation = self.prepare_api_input_aggregation(api_info, Const.FORWARD)
         except Exception as e:
             logger.warning(
-                f"[Device {self.current_device_id}] Exception occurred while getting forward API inputs for {api_name_str}. Skipping forward check. Detailed exception information: {e}.")
+                f"[Device {self.current_device_id}] Exception occurred while getting forward API inputs for "
+                f"{api_name_str}. Skipping forward check. Detailed exception information: {e}.")
             return Const.EXCEPTION_NONE
 
         forward_output_list = None
@@ -170,7 +172,8 @@ class MultiApiAccuracyChecker(ApiAccuracyChecker):
                                                               Const.FORWARD)
         except Exception as e:
             logger.warning(
-                f"[Device {self.current_device_id}] Exception occurred while running and comparing {api_name_str} forward API. Detailed exception information: {e}.")
+                f"[Device {self.current_device_id}] Exception occurred while running and comparing {api_name_str} "
+                f"forward API. Detailed exception information: {e}.")
         return forward_output_list
 
     def process_backward(self, api_name_str, api_info):
@@ -186,14 +189,16 @@ class MultiApiAccuracyChecker(ApiAccuracyChecker):
         """
         if not api_info.check_backward_info():
             logger.debug(
-                f"[Device {self.current_device_id}] API: {api_name_str} lacks backward information, skipping backward check.")
+                f"[Device {self.current_device_id}] API: {api_name_str} lacks backward information, skipping "
+                f"backward check.")
             return Const.EXCEPTION_NONE
 
         try:
             backward_inputs_aggregation = self.prepare_api_input_aggregation(api_info, Const.BACKWARD)
         except Exception as e:
             logger.warning(
-                f"[Device {self.current_device_id}] Exception occurred while getting backward API inputs for {api_name_str}. Skipping backward check. Detailed exception information: {e}.")
+                f"[Device {self.current_device_id}] Exception occurred while getting backward API inputs for "
+                f"{api_name_str}. Skipping backward check. Detailed exception information: {e}.")
             return Const.EXCEPTION_NONE
 
         backward_output_list = None
@@ -202,5 +207,6 @@ class MultiApiAccuracyChecker(ApiAccuracyChecker):
                                                                Const.BACKWARD)
         except Exception as e:
             logger.warning(
-                f"[Device {self.current_device_id}] Exception occurred while running and comparing {api_name_str} backward API. Detailed exception information: {e}.")
+                f"[Device {self.current_device_id}] Exception occurred while running and comparing {api_name_str} "
+                f"backward API. Detailed exception information: {e}.")
         return backward_output_list

msprobe/mindspore/api_accuracy_checker/multi_data_manager.py

@@ -17,7 +17,9 @@
 import multiprocessing
 import os
 
-from msprobe.mindspore.api_accuracy_checker.data_manager import DataManager, ResultCsvEntry, write_csv_header, get_result_csv_header, get_detail_csv_header, check_csv_header
+from msprobe.mindspore.api_accuracy_checker.data_manager import (DataManager, ResultCsvEntry, write_csv_header,
+                                                                 get_result_csv_header, get_detail_csv_header,
+                                                                 check_csv_header)
 from msprobe.mindspore.common.log import logger