mindstudio-probe 8.3.0__py3-none-any.whl → 8.3.1__py3-none-any.whl

msprobe/docs/02.config_introduction.md

@@ -73,14 +73,7 @@
 | data_mode      | 与[ 1.2 task 配置为 statistics ](#12-task-配置为-statistics)中的解释相同 | 否       |
 | file_format    | tensor 数据的保存格式，str 类型，仅支持 MindSpore 静态图场景的 L2 级别配置该字段，其他场景不生效。可选参数：<br/> "bin"：dump 的 tensor 文件为二进制格式；<br/>"npy"：dump 的 tensor 文件后缀为 .npy，默认值。 | 否       |
 | summary_mode  | 控制 dump 文件输出的模式，str 类型，支持 PyTorch、MSAdapter、MindSpore 动态图。可选参数：<br/> md5：dump 输出包含 CRC-32 值以及 API 统计信息的 dump.json 文件，用于验证数据的完整性；<br/> statistics：dump 仅输出包含 API 统计信息的 dump.json 文件，默认值。| 否 |
-| online_run_ut<sup>a</sup>  | 在线预检模式开关，bool 类型，可选参数 true（开启）、false（关闭），默认未配置，表示关闭。配置为 true 表示开启在线预检。| 否 |
-| nfs_path<sup>a</sup> | 在线预检模式共享存储目录路径，str 类型，用于 GPU 设备和 NPU 设备间进行通信。仅在 online_run_ut 字段配置为 true 时生效，配置该参数后 host 和 port 不生效。 | 否 |
-| host<sup>a</sup> | 在线预检模式局域网场景信息接收端 IP，str 类型，用于 GPU 设备和 NPU 设备间进行通信，NPU 侧须配置为 GPU 侧的局域网 IP 地址。仅在 online_run_ut 字段配置为 true 时生效，局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。 | 否 |
-| port<sup>a</sup> | 在线预检模式局域网场景信息接收端端口号，int 类型，用于 GPU 设备和 NPU 设备间进行通信，NPU 侧须配置为 GPU 侧的端口号。仅在 online_run_ut 字段配置为 true 时生效，局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。| 否 |
 
-**说明**：
-
-1. online_run_ut、nfs_path、host、port 等字段仅在线预检场景 NPU 机器生效。
 
 **示例**：
  - [PyTorch场景](03.config_examples.md#12-task-配置为-tensor)
@@ -95,17 +88,11 @@
 | white_list<sup>a</sup>      | API dump 白名单，仅对指定的 API 进行 dump。<br/>**配置示例**："white_list": ["conv1d", "conv2d"]。默认未配置白名单，即 dump 全量 API 数据。 | 否       |
 | black_list<sup>a</sup>      | API dump 黑名单，被指定的 API 不进行 dump。<br/>**配置示例**："black_list": ["conv1d", "conv2d"]。默认未配置黑名单，即 dump 全量 API 数据。 | 否       |
 | error_data_path | 配置保存精度未达标的 API 输入输出数据路径，默认为当前路径。<br/>**配置示例**："error_data_path": "./"。 | 否       |
-| is_online<sup>b</sup>       | 在线预检模式开关，bool 类型，可选参数 true（开启）、false（关闭），默认关闭。 | 否 |
-| nfs_path<sup>b</sup>        | 在线预检模式共享存储目录路径，str 类型，用于 GPU 设备和 NPU 设备间进行通信。配置该参数后 host 和 port 不生效，仅在 is_online 字段配置为 true 时生效。 | 否    |
-| host<sup>b</sup>            | 在线预检模式局域网场景信息接收端 IP，str 类型，用于 GPU 设备和 NPU 设备间进行通信，GPU 侧配置为本机地址 127.0.0.1 或本机局域网 IP。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。仅在 is_online 字段配置为 true 时生效。 | 否 |
-| port<sup>b</sup>            | 在线预检模式局域网场景信息接收端端口号，int 类型，用于 GPU 设备和 NPU 设备间进行通信，GPU 侧配置为本机可用端口。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。仅在 is_online 字段配置为 true 时生效。| 否 |
-| rank_list<sup>b</sup>       | 指定在线预检的 Rank ID，默认值为 [0]，list[int] 类型，应配置为大于等于 0 的整数，且须根据实际卡的 Rank ID 配置，若所配置的值大于实际训练所运行的卡的 Rank ID，则在线预检输出数据为空。GPU 和 NPU 须配置一致。仅在 is_online 字段配置为 true 时生效。 | 否    |
 
 **说明**：
 
 1. white_list 和 black_list 同时配置时，二者配置的 API 名单若无交集，则白名单生效，若 API 名单存在交集，则白名单排除的部分以及交集的 API 不进行 dump。
 
-2. is_online、nfs_path、host、port、rank_list 等字段仅在线预检场景 GPU 机器生效。
 
 **示例**：
 ```json

msprobe/docs/14.data_parse_PyTorch.md

@@ -8,6 +8,8 @@
 
 依赖：CANN 包中的 msaccucmp 工具，需要安装 Ascend-CANN-toolkit，详见《[CANN 软件安装指南](https://www.hiascend.com/document/detail/zh/canncommercial/700/envdeployment/instg/instg_0001.html)》。
 
+**安全注意事项**： 工具使用时传入的msaccucmp.py文件路径参数请务必确保为CANN中自带的msaccucmp.py原始路径且文件内容未被篡改，工具会在解析数据时直接执行该文件，用户需自行保证该文件内容安全性。
+
 ## 2 数据解析操作指导
 
 ### 2.1 进入 parse 交互式界面

msprobe/docs/21.visualization_PyTorch.md

@@ -2,7 +2,7 @@
 
 分级可视化工具将msprobe工具dump的精度数据进行解析，还原模型图结构，实现模型各个层级的精度数据比对，方便用户理解模型结构、分析精度问题。
 
-工具支持PyTorch版本：2.1/2.2
+工具支持PyTorch版本：2.1/2.2/2.5/2.6/2.7
 
 ## 工具特性
 

msprobe/docs/25.tool_function_introduction.md

@@ -7,7 +7,6 @@
 | [数据采集<br>（dump）](./05.data_dump_PyTorch.md)                                      | 采集模型训练过程中的API或Module层级的前反向输入输出数据，包括层次关系、统计值信息、真实数据和调用栈等。                                             | 1、将模型中训练的API或Module的前反向输入输出数据保存下来分析<br> 2、模型出现溢出时，可用于查看哪些API或Module出现了溢出                                         | 1、API级数据采集仅支持白名单列表上的API<br>2、工具会做一些同步操作，引入工具可能会导致一些同步问题消失<br>3、当前对inplace操作API或Module的支持度有限<br>4、暂不支持参数及参数梯度的采集      |
 | [离线预检<br>（api_accuracy_checker）](./07.accuracy_checker_PyTorch.md)               | 为网络中每个API创建用例，检验其精度，并根据不同比对算法综合判定API在NPU上的精度是否达标，快速找出精度差异API。                                      | 1、对模型中所有的API做精度初步排查<br>2、精度排查不受模型累计误差影响                                                                                           | 1、依赖GPU环境<br>2、不支持通信算子<br>3、仅支持部分融合算子                                                                                                                                      |
 | [整网比对<br>（compare）](./10.accuracy_compare_PyTorch.md)                            | 计算模型整网NPU和标杆设备的精度误差指标，标记精度异常API或Module，助力快速定位精度问题根因。                                                        | 1、整网比对定位精度可疑算子                                                                                                                                         | 1、由于使用整网dump数据，定位的可疑算子受累计误差影响<br>2、当模型规模较大时，比对所需时间较长                                                                                                        |
-| [在线预检<br>（online_api_accuracy_checker）](./08.accuracy_checker_online_PyTorch.md) | 通过TCP通信或共享存储空间的方式，进行在线精度预检，解决离线预检大数据量落盘、传输困难痛点。                                                         | 1、使用离线预检，数据量较大落盘困难或传输耗时长时，可通过在线预检进行精度排查                                                                                       | 1、依赖GPU环境，NPU和GPU能够通信<br>2、重计算模式下，不支持反向aten算子预检                                                                                                                           |
 | [溢出检查<br>（overflow_checker）](./12.overflow_check_PyTorch.md)                     | 检测模型计算过程的输入输出，并在溢出时落盘数据，助力用户快速定位溢出位置。                                                                          | 1、当模型出现溢出时，用于快速定位最先溢出的API或Module<br>2、相比数据采集，性能更优，磁盘压力更小                                                               | 1、局限性同数据采集                                                                                                                                                                                       |
 | [数据解析<br>（parse_tool）](./14.data_parse_PyTorch.md)                               | 交互式界面处理解析kernel层级dump数据，便于查看分析。                                                                                                | 1、比对kernel层级dump数据的一致性                                                                                                                                   | 1、仅限于NPU                                                                                                                                                                                              |
 | [无标杆比对<br>（free_benchmark）](./15.free_benchmarking_PyTorch.md)                  | 不依赖标杆数据，通过对算子输入增加微小扰动，计算扰动后输出与原始输出的相对误差，识别有精度风险算子。                                                | 1、无标杆数据场景下的算子精度排查<br>2、对个别算子进行升精度、“to cpu”等操作，以验证其对模型loss的影响                                                        | 1、由于需要拷贝输入进行二次执行，所以在遇到大张量的输入时容易发生显存OOM的问题, 特别是反向比对过程。建议结合白名单使用<br>2、比对会延长训练时间，整网比对可能会造成严重的耗时膨胀，建议结合白名单使用 |

msprobe/docs/32.ckpt_compare.md

@@ -19,11 +19,11 @@ Megatron、MindSpeed的ckpt加载依赖megatron，请确保megatron在python环
 msprobe --framework pytorch config_check --compare path1 path2 -o output_path.json
 ```
 
-| 参数名 | 解释 | 是否必选 |
-|--------|-------|--------|
-| -f 或 --framework | 深度学习框架，str类型。支持参数：pytorch,mindspore，注意：msadaptor场景传入mindspore。 | 是 |
-| -c 或 --compare | 2个ckpt的路径 | 是 |
-| -o 或 --output | 比对结果输出路径，默认为 ./ckpt_similarity.json。输出路径存在时将报错终止。 | 否 |
+| 参数名 | 解释                                                                                           | 是否必选 |
+|--------|----------------------------------------------------------------------------------------------|--------|
+| -f 或 --framework | 深度学习框架，str类型。支持参数：pytorch,mindspore，注意：msadaptor场景传入mindspore。                               | 是 |
+| -c 或 --compare | 2个ckpt的路径。在ckpt传给工具加载前，用户需要确保ckpt是安全可信的，若ckpt来源官方有提供SHA256等校验值，用户必须要进行校验，以确保ckpt没有被篡改。 | 是 |
+| -o 或 --output | 比对结果输出路径，默认为 ./ckpt_similarity.json。输出路径存在时将报错终止。                                            | 否 |
 
 Megatron-LM 和 MindSpeed 的 ckpt 目录结构如下：
 

msprobe/mindspore/monitor/module_hook.py

@@ -163,15 +163,11 @@ class GradContext:
     def __init__(self) -> None:
         self.pre = {}
         self.post = {}
-        self.acc_metric = {}
-        self.acc = {}
         self.actv = {}
 
     def reset(self):
         self.pre.clear()
         self.post.clear()
-        self.acc_metric.clear()
-        self.acc.clear()
         self.actv.clear()
 
 
@@ -312,7 +308,6 @@ class TrainerMon:
         self.recording_l2_features = self.config.get('recording_l2_features', False)
         self.sa_order = self.config.get('sa_order', "s,b,h,d")
 
-
         if not self.cc_distribution.get('enable', False):
             self.cc_log_only = False
         else:
@@ -403,7 +398,7 @@ class TrainerMon:
             if self.monitoring:
                 module_rank_valid = self.is_target_rank()
                 step_condition = (context.step >= self.start_step and (
-                            context.step - self.start_step) % self.step_interval == 0)
+                        context.step - self.start_step) % self.step_interval == 0)
                 if module_rank_valid and step_condition:
                     self.has_collect_times += 1
 
@@ -447,6 +442,7 @@ class TrainerMon:
                     hook(optimizer, args, kwargs)
                 step_final_hook(optimizer, args, kwargs)
                 return out
+
             return wrapper
 
         if self.is_mindtorch:
@@ -541,7 +537,7 @@ class TrainerMon:
             if self.mv_distribution or self.ur_distribution or self.mg_direction:
                 if self.is_mindtorch:
                     context.param_exp_avg, context.param_exp_avg_sq, context.param_adam_update, \
-                    context.param_adam_ratio = self.optimizer_mon.fetch_mv(self, self.param2name)
+                        context.param_adam_ratio = self.optimizer_mon.fetch_mv(self, self.param2name)
                 else:
                     context.param_exp_avg, context.param_exp_avg_sq = self.get_mv_for_ms(optimizer)
 
@@ -564,7 +560,6 @@ class TrainerMon:
             context = self.optimizer_context[optimizer]
             self.generate_param_metrics(context, MonitorConst.POST_PARAM)
 
-
         if self.optimizer_hooked or not self.is_target_rank():
             return
 
@@ -577,7 +572,6 @@ class TrainerMon:
         if not self.wg_distribution:
             return
 
-        get_metrics(self.ops, self.grad_context.acc, self.eps, self.grad_context.acc_metric)
         get_metrics(self.ops, grad_dict, self.eps, self.grad_context.post)
 
     def generate_param_map(self, tag, param_tensor):
@@ -671,7 +665,7 @@ class TrainerMon:
         if not self.wg_distribution:
             return
 
-        self.summary_writer.write_metrics(self.ops, self.grad_context.acc_metric, step, 'grad_unreduced',
+        self.summary_writer.write_metrics(self.ops, self.grad_context.pre, step, 'grad_unreduced',
                                           use_micro_step=self.monitor_mbs_grad)
         self.summary_writer.write_metrics(self.ops, self.grad_context.post, step, 'grad_reduced')
 
@@ -810,7 +804,7 @@ class TrainerMon:
                     f'{context.module_name}.{Const.INPUT}', f'{MonitorConst.NAME_SEP}{context.micro_step}',
                     MonitorConst.ACTV, module_input))
             module_output = [tensor for tensor in module_output if isinstance(tensor, Tensor)] \
-                            if isinstance(module_output, tuple) else module_output
+                if isinstance(module_output, tuple) else module_output
             tbtag_tensor_map.update(
                 self.build_tbtag_tensor_map(
                     f'{context.module_name}.{Const.OUTPUT}', f'{MonitorConst.NAME_SEP}{context.micro_step}',
@@ -868,11 +862,13 @@ class TrainerMon:
             if version.parse(mindspore.__version__) >= version.parse('2.6.0'):
                 def wrapper(module, args, kwargs, module_output):
                     return fwd_hook_fun(module, args, kwargs, module_output, name)
+
                 return module.register_forward_hook(wrapper, with_kwargs=True)
 
             else:
                 def wrapper(module, args, module_output):
                     return fwd_hook_fun(module, args, None, module_output, name)
+
                 return module.register_forward_hook(wrapper)
 
         def extract_attention_feature_hook(module, args, kwargs, module_output, name):
@@ -880,7 +876,7 @@ class TrainerMon:
             if kwargs:
                 kwargs_tensors = [tensor for tensor in kwargs.values() if isinstance(tensor, Tensor)]
                 module_input.extend(kwargs_tensors)
-            
+
             if module not in self.feature_hook_context_by_module:
                 self.feature_hook_context_by_module[module] = FeatureHookContext(name)
             context: FeatureHookContext = self.feature_hook_context_by_module[module]
@@ -890,7 +886,7 @@ class TrainerMon:
                 logger.warning(
                     "Calculate attention feature failed, the length of module_input in attention hook's module should "
                     "be greater than or equal to 2.")
-            
+
             q_h = module_input[0]
             k_h = module_input[1]
             qkt = cal_qkt(q_h, k_h, order=self.sa_order)
@@ -985,25 +981,26 @@ class TrainerMon:
         self._hook_weights()
 
     def _hook_weights(self):
-        context = self.grad_context
 
         @_no_grad()
-        def param_hook(grad, context_dict, param, name):
+        def param_hook(grad, param, name):
             key = name
             if self.monitor_mbs_grad:
                 key += f'{MonitorConst.NAME_SEP}{param.micro_step}'
             key = get_summary_writer_tag_name(key, 'acc_grad', self.rank)
             self.register_param_call_id("param_hook", key)
             param.micro_step += 1
-
+            grad_dict = {}
             if self.monitor_mbs_grad or (param.micro_step == self.micro_batch_number):
-                context_dict[key] = grad
+                grad_dict[key] = grad
+            get_metrics(self.ops, grad_dict, self.eps, self.grad_context.pre)
+
             if param.micro_step == self.micro_batch_number:
                 param.micro_step = 0
 
-        def param_hook_wrapper(param_hook, context_dict, param, name):
+        def param_hook_wrapper(param_hook, param, name):
             def wrapper(grad):
-                return param_hook(grad, context_dict, param, name)
+                return param_hook(grad, param, name)
 
             return wrapper
 
@@ -1011,7 +1008,7 @@ class TrainerMon:
         for param, name in self.param2name.items():
             setattr(param, 'micro_step', 0)
             handle = param.register_hook(
-                param_hook_wrapper(param_hook, context_dict=context.acc, param=param, name=name))
+                param_hook_wrapper(param_hook, param=param, name=name))
             self.handles['wgrads'].append(handle)
         self.weight_hooked = True
 

msprobe/pytorch/api_accuracy_checker/common/config.py

@@ -24,8 +24,7 @@ from msprobe.pytorch.pt_config import RunUTConfig
 
 RunUtConfig = namedtuple('RunUtConfig', ['forward_content', 'backward_content', 'result_csv_path', 'details_csv_path',
                                          'save_error_data', 'is_continue_run_ut', 'real_data_path', 'white_list',
-                                         'black_list', 'error_data_path', 'online_config'])
-OnlineConfig = namedtuple('OnlineConfig', ['is_online', 'nfs_path', 'host', 'port', 'rank_list', 'tls_path'])
+                                         'black_list', 'error_data_path'])
 
 
 class Config:
@@ -46,13 +45,7 @@ class Config:
             'white_list': list,
             'black_list': list,
             'error_data_path': str,
-            'precision': int,
-            'is_online': bool,
-            'nfs_path': str,
-            'host': str,
-            'port': int,
-            'rank_list': list,
-            'tls_path': str
+            'precision': int
         }
         if key not in validators:
             raise ValueError(f"{key} must be one of {validators.keys()}")
@@ -68,10 +61,6 @@ class Config:
             RunUTConfig.check_filter_list_config(key, value)
         if key == 'error_data_path':
             RunUTConfig.check_error_data_path_config(value)
-        if key == 'nfs_path':
-            RunUTConfig.check_nfs_path_config(value)
-        if key == 'tls_path':
-            RunUTConfig.check_tls_path_config(value)
         return value
 
 
@@ -85,12 +74,6 @@ class CheckerConfig:
         self.white_list = msCheckerConfig.white_list
         self.black_list = msCheckerConfig.black_list
         self.error_data_path = msCheckerConfig.error_data_path
-        self.is_online = msCheckerConfig.is_online
-        self.nfs_path = msCheckerConfig.nfs_path
-        self.host = msCheckerConfig.host
-        self.port = msCheckerConfig.port
-        self.rank_list = msCheckerConfig.rank_list
-        self.tls_path = msCheckerConfig.tls_path
 
         if task_config:
             self.load_config(task_config)
@@ -99,22 +82,7 @@ class CheckerConfig:
         self.white_list = task_config.white_list
         self.black_list = task_config.black_list
         self.error_data_path = task_config.error_data_path
-        self.is_online = task_config.is_online
-        self.nfs_path = task_config.nfs_path
-        self.host = task_config.host
-        self.port = task_config.port
-        self.rank_list = task_config.rank_list
-        self.tls_path = task_config.tls_path
     
-    def get_online_config(self):
-        return OnlineConfig(
-            is_online=self.is_online,
-            nfs_path=self.nfs_path,
-            host=self.host,
-            port=self.port,
-            rank_list=self.rank_list,
-            tls_path=self.tls_path
-        )
 
     def get_run_ut_config(self, **config_params):
         return RunUtConfig(
@@ -127,6 +95,5 @@ class CheckerConfig:
             real_data_path=config_params.get('real_data_path'),
             white_list=self.white_list.copy() if self.white_list else [],
             black_list=self.black_list.copy() if self.black_list else [],
-            error_data_path=config_params.get('error_data_path'),
-            online_config=self.get_online_config()
+            error_data_path=config_params.get('error_data_path')
         )

msprobe/pytorch/api_accuracy_checker/compare/api_precision_compare.py

@@ -117,30 +117,6 @@ def api_precision_compare(config):
     change_mode(config.details_csv_path, FileCheckConst.DATA_FILE_AUTHORITY)
 
 
-def online_api_precision_compare(online_config):
-    rank = online_config.rank
-    result_csv_path = os.path.join(Const.DEFAULT_PATH, online_config.result_csv_path).replace(
-                    "_rank*.csv", f"_rank{rank}.csv")
-    details_csv_path = os.path.join(Const.DEFAULT_PATH, online_config.details_csv_path).replace(
-                    "_rank*.csv", f"_rank{rank}.csv")
-    detail_csv_title = [ApiPrecisionCompareColumn.get_detail_csv_title()]
-    result_csv_title = [ApiPrecisionCompareColumn.get_result_csv_title()]
-    if not os.path.exists(result_csv_path):
-        write_csv(result_csv_title, result_csv_path)
-    if not os.path.exists(details_csv_path):
-        write_csv(detail_csv_title, details_csv_path)
-    config = CompareConfig("", "", result_csv_path, details_csv_path)
-    try:
-        npu_data, gpu_data = online_config.npu_data, online_config.gpu_data
-        check_csv_columns(npu_data.columns, "npu_csv")
-        check_csv_columns(gpu_data.columns, "gpu_csv")
-        analyse_csv(npu_data, gpu_data, config)
-    except Exception as err:
-        logger.error(f"Online api precision compare Error: {str(err)}")
-    change_mode(result_csv_path, FileCheckConst.DATA_FILE_AUTHORITY)
-    change_mode(details_csv_path, FileCheckConst.DATA_FILE_AUTHORITY)
-
-
 def analyse_csv(npu_data, gpu_data, config):
     forward_status, backward_status = [], []
     last_api_name, last_api_dtype, last_api_full_name = None, None, None

msprobe/pytorch/api_accuracy_checker/compare/compare.py

@@ -66,13 +66,6 @@ class Comparator:
         self.save_path_list = [result_csv_path]
         self.detail_save_path_list = [details_csv_path]
 
-        if config and config.online_config.is_online:
-            self.save_path_str = result_csv_path.replace(".csv", "_rank{}.csv")
-            self.detail_save_path_str = details_csv_path.replace(".csv", "_rank{}.csv")
-            self.save_path_list = [self.save_path_str.format(rank) for rank in config.online_config.rank_list]
-            self.detail_save_path_list = \
-                [self.detail_save_path_str.format(rank) for rank in config.online_config.rank_list]
-
         self.registry = self._register_compare_func()
 
         if not is_continue_run_ut:
@@ -245,9 +238,8 @@ class Comparator:
         self.write_detail_csv(args)
 
 
-    def compare_output(self, full_api_name, data_info, is_online=False):
+    def compare_output(self, full_api_name, data_info):
         """Get compare result and write to result and detail csv.
-        is_online: bool, default False. True: called by online api precision compare, only compare without write to csv.
         """
         _, api_name = extract_basic_api_segments(full_api_name)
         if not api_name:
@@ -280,9 +272,7 @@ class Comparator:
                                  fwd_compare_alg_results,
                                  bwd_compare_alg_results,
                                  data_info.rank)
-        if is_online:
-            # get run_ut compare detail
-            return self._get_run_ut_detail(result_info)
+
         self.record_results(result_info)
         return fwd_success_status == CompareConst.PASS, bwd_success_status == CompareConst.PASS \
                or bwd_success_status == CompareConst.SPACE

msprobe/pytorch/api_accuracy_checker/config.yaml

@@ -2,9 +2,4 @@ white_list: []
 black_list: []
 error_data_path: './'
 precision: 14
-is_online: False
-nfs_path: ""
-host: ""
-port: -1
-rank_list: [0]
-tls_path: "./"
+

msprobe/pytorch/api_accuracy_checker/run_ut/multi_run_ut.py

@@ -39,7 +39,12 @@ from msprobe.core.common.const import FileCheckConst, Const
 from msprobe.core.common.utils import CompareException
 
 
-def split_json_file(input_file, num_splits, filter_api):
+def split_json_file(input_file, num_splits, filter_api, device_id):
+    max_processes = len(device_id) * 8
+    if num_splits > max_processes:
+        logger.warning(f"A device supports a maximum of 8 processes. "
+                       f"The total number of processes exceeds the limit, and it is set to {max_processes}.")
+        num_splits = max_processes
     forward_data, backward_data, real_data_path = parse_json_info_forward_backward(input_file)
     input_dir = os.path.dirname(os.path.abspath(input_file))
     if filter_api:
@@ -88,7 +93,7 @@ def split_json_file(input_file, num_splits, filter_api):
                     logger.error(f"File not found or could not be deleted: {file}")
             msg = 'ERROR: Split json file failed, please check the input file and try again.'
             raise CompareException(CompareException.PARSE_FILE_ERROR, msg) from e
-    return split_files, total_items
+    return split_files, total_items, num_splits
 
 
 def signal_handler(signum, frame):
@@ -127,7 +132,8 @@ def run_parallel_ut(config):
     def read_process_output(process):
         try:
             while True:
-                if process.poll() is not None:
+                # 子进程标准输出流与进程本身状态是分开的，因此增加判断。子进程返回值非None表示子进程结束，标准输出为None表示结束。
+                if process.poll() is not None or process.stdout is None:
                     break
                 output = process.stdout.readline()
                 if output == '':
@@ -175,12 +181,17 @@ def run_parallel_ut(config):
 
     try:
         for process in processes:
-            process.communicate(timeout=None)
+            process.wait()  # wait仅阻塞，不捕获标准输出和标准错误，原communicate不仅阻塞，而且捕获标准输出和标准错误
     except KeyboardInterrupt:
         logger.warning("Interrupted by user, terminating processes and cleaning up...")
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
     finally:
+        # 最后再更新一次进度条，避免因缓存写入等原因子进程结束而进度未刷新的问题
+        if wait_for_file_write_complete(config.result_csv_path):
+            result_file = read_csv(config.result_csv_path)
+            completed_items = len(result_file)
+            progress_bar.update(completed_items - progress_bar.n)
         if progress_bar.n < config.total_items:
             logger.warning("The UT task has not been completed. The parameter '-csv_path' along with the path to " \
                            "the result CSV file will be utilized to resume the UT task.")
@@ -195,6 +206,22 @@ def run_parallel_ut(config):
         logger.error(f"An unexpected error occurred: {e}")
 
 
+def wait_for_file_write_complete(file_path, timeout=3600):
+    last_size = 0
+    start_time = time.time()  # 记录开始时间
+    while True:
+        current_size = os.path.getsize(file_path)
+        # 检查是否文件大小未变化
+        if current_size == last_size:
+            return True  # 文件写入完成，返回 True
+        last_size = current_size
+        # 检查是否超时
+        if time.time() - start_time > timeout:
+            logger.error("write the result csv file timeout.")
+            return False  # 超时，返回 False
+        time.sleep(0.1)  # 适当的延时
+
+
 def prepare_config(args):
     api_info_file_checker = FileChecker(file_path=args.api_info_file, path_type=FileCheckConst.FILE,
                                         ability=FileCheckConst.READ_ABLE, file_type=FileCheckConst.JSON_SUFFIX)
@@ -203,7 +230,9 @@ def prepare_config(args):
     create_directory(out_path)
     out_path_checker = FileChecker(out_path, FileCheckConst.DIR, ability=FileCheckConst.WRITE_ABLE)
     out_path = out_path_checker.common_check()
-    split_files, total_items = split_json_file(api_info, args.num_splits, args.filter_api)
+    split_files, total_items, modified_num_splits = split_json_file(api_info, args.num_splits,
+                                                                    args.filter_api, args.device_id)
+    args.num_splits = modified_num_splits
     config_path = args.config_path if args.config_path else None
     if config_path:
         config_path_checker = FileChecker(config_path, FileCheckConst.FILE,