@cannbot-plugin/cannbot-harness 0.0.0-stage → 0.1.5

package/assets/ops-direct-invoke/skills/ops-precision-standard/references/random_generation.md

@@ -0,0 +1,198 @@
+# 随机数生成类算子精度验证
+
+## 1. 算子定义
+
+**定义特征：** 按指定分布生成随机数
+
+## 2. 验证方法
+
+**比对方法：** KS检验（Kolmogorov-Smirnov test）
+
+**验证脚本：** `scripts/random_distribution_check.py`
+
+## 3. 使用示例
+
+### 3.1 单次KS检验
+
+```python
+from scripts.random_distribution_check import ks_test_distribution
+
+# 执行算子
+npu_output = run_rand_on_npu()
+
+# 验证分布
+result = ks_test_distribution(
+    npu_output, 
+    expected_distribution='uniform',  # 或 'normal'
+    params={'low': 0, 'high': 1}  # 均匀分布参数
+)
+
+assert result['is_pass'], f"分布检验失败: p_value={result['p_value']}"
+```
+
+### 3.2 批量检验
+
+```python
+from scripts.random_distribution_check import check_random_distribution_batch
+
+# 生成多个随机数输出
+outputs_list = [run_rand_on_npu() for _ in range(100)]
+
+# 批量检验
+summary = check_random_distribution_batch(
+    outputs_list, 
+    expected_distribution='uniform',
+    params={'low': 0, 'high': 1},
+    N=100
+)
+
+print(f"通过率: {summary['actual_pass_rate_percent']:.2f}%")
+print(f"理论阈值: {summary['theoretical_pass_rate_percent']:.2f}%")
+```
+
+## 4. 通过标准
+
+### 4.1 p值检验
+
+**显著性水平：** α = 0.01
+
+**判定标准：** p值 > α
+
+**判定代码：**
+```python
+from scipy import stats
+
+statistic, p_value = stats.kstest(npu_output, 'uniform', args=(0, 1))
+is_pass = (p_value > 0.01)
+```
+
+### 4.2 批量检验通过标准
+
+**通过条件：**
+```
+至少 ((1-α) + z×√(α(1-α)/N)) × 100% 的测试用例满足 p > α
+```
+
+**参数说明：**
+- α = 0.01（显著性水平）
+- z = -3.0902（正态分布99.9%截尾点）
+- N = 测试次数（推荐100）
+
+**计算示例：**
+```python
+alpha = 0.01
+z = -3.0902
+N = 100
+
+theoretical_pass_rate = (1 - alpha) + z * np.sqrt(alpha * (1 - alpha) / N)
+theoretical_pass_rate_percent = theoretical_pass_rate * 100
+# 约95.93%
+```
+
+## 5. 支持的分布类型
+
+### 5.1 均匀分布（uniform）
+
+**参数：**
+- low: 下界（默认0）
+- high: 上界（默认1）
+
+**示例：**
+```python
+result = ks_test_distribution(
+    npu_output,
+    expected_distribution='uniform',
+    params={'low': -1, 'high': 1}
+)
+```
+
+### 5.2 正态分布（normal）
+
+**参数：**
+- mean: 均值（默认0）
+- std: 标准差（默认1）
+
+**示例：**
+```python
+result = ks_test_distribution(
+    npu_output,
+    expected_distribution='normal',
+    params={'mean': 0, 'std': 1}
+)
+```
+
+### 5.3 指数分布（exponential）
+
+**参数：**
+- scale: 尺度参数（默认1）
+
+**示例：**
+```python
+result = ks_test_distribution(
+    npu_output,
+    expected_distribution='exponential',
+    params={'scale': 1.0}
+)
+```
+
+## 6. 脚本详细使用
+
+### 6.1 ks_test_distribution函数
+
+```python
+from scripts.random_distribution_check import ks_test_distribution
+
+result = ks_test_distribution(
+    npu_output,
+    expected_distribution='uniform',
+    params={'low': 0, 'high': 1}
+)
+
+# 返回结果
+# {
+#   'is_valid': True,
+#   'ks_statistic': 0.05,
+#   'p_value': 0.85,
+#   'alpha': 0.01,
+#   'is_pass': True,
+#   'expected_distribution': 'uniform',
+#   'params': {'low': 0, 'high': 1},
+#   'sample_size': 1000,
+#   'interpretation': 'p_value 0.85 > alpha 0.01,分布与期望一致'
+# }
+```
+
+### 6.2 check_random_distribution_batch函数
+
+```python
+from scripts.random_distribution_check import check_random_distribution_batch
+
+outputs_list = [run_rand_on_npu() for _ in range(100)]
+
+summary = check_random_distribution_batch(
+    outputs_list,
+    expected_distribution='uniform',
+    params={'low': 0, 'high': 1},
+    N=100,
+    alpha=0.01
+)
+
+# 返回汇总信息
+# {
+#   'total_tests': 100,
+#   'pass_count': 99,
+#   'fail_count': 1,
+#   'actual_pass_rate': 0.99,
+#   'actual_pass_rate_percent': 99.0,
+#   'theoretical_pass_rate': 0.9593,
+#   'theoretical_pass_rate_percent': 95.93,
+#   'is_pass': True,  # 99% > 95.93%
+#   'p_value_mean': 0.65,
+#   'p_value_std': 0.15,
+#   'detail_results': [...]
+# }
+```
+
+## 7. 参考文档
+
+- KS检验理论：scipy.stats.kstest文档

package/assets/ops-direct-invoke/skills/ops-precision-standard/references/test_case_generation.md

@@ -0,0 +1,61 @@
+# 测试用例生成规则
+
+## 1. 用例规模要求
+
+| 要求项 | 说明 |
+|--------|------|
+| **覆盖目标** | 对算子支持的**数据类型**、**数据格式**、**数据维度**、**属性取值范围**实现**全组合覆盖**（即所有有效组合的 100% 覆盖） |
+| **数据类型覆盖** | 覆盖算子支持的所有数据类型 |
+
+> 说明：用例数量不设固定下限（如 ≥1,000），强调的是**输入组合的遍历式覆盖**，而非机械地要求用例数量。
+
+## 2. Tensor 生成规则
+
+| 维度 | 生成规则 |
+|------|----------|
+| **数据维度** | 覆盖算子支持的维度范围（1~8 维），维度值在 $[1, 2^{20}]$ 内取用（2 的幂次）和（2 的幂次方-1）两种取值。总元素数不超过 $2^{31}$ |
+| **数据格式** | 覆盖算子支持的所有数据格式（ND、NCHW 等） |
+
+**步长与组合生成：** 各参数类型之间应进行正交组合遍历，值域覆盖策略如下：
+
+| 分布类型 | 比例 | 值域范围 | 生成逻辑 |
+|---------|------|----------|----------|
+| 均匀分布 | 50% | [-5, 5] | 随机均匀采样 |
+| 正态分布 | 50% | μ ∈ [-5, 5], σ ∈ [0.1, 2] | 随机采样 μ 和 σ 后生成 |
+
+> 注：值域控制在 `[-5, 5]` 与 `μ ∈ [-5, 5], σ ∈ [0.1, 2]` 范围内，避免 μ 过大导致计算结果绝对值超出 32×ULP 硬上限而误判失败。
+>
+> **atol 验证关注点**：混合容差在 golden ≈ 0 时退化为 `|actual - golden| ≤ atol`（rtol 分量近似为 0）。虽然 `[-5, 5]` 的均匀分布会以约 0.02% 概率自然落入近零区间，但若需系统性验证 atol 分量，建议在特殊场景测试中补充近零值用例（如 golden 取 0、±1e-6 等小值），与第 4 节特殊场景测试配合使用。
+
+## 3. Attr 生成规则
+
+| 参数类型 | 生成规则 |
+|----------|----------|
+| 标量参数 | 覆盖所有等价类场景 |
+| 布尔参数 | 覆盖 True 和 False |
+| 枚举参数 | 覆盖所有支持的枚举值 |
+
+各类参数类型应进行组合遍历。
+
+## 4. 特殊场景测试
+
+| 场景 | 说明 | 覆盖要求 |
+|------|------|----------|
+| 空 Tensor | 某个维度为 0 的 Tensor | 每种 dtype 每个 tensor 至少覆盖一次 |
+| 标量 Tensor | shape 为 [1] 的 Tensor | 每种 dtype 覆盖 |
+| 边界测试 | 下边界：shape 各维度均为 1；上边界：shape 某维度取最大值 | 全部覆盖 |
+| INF/-INF/NAN | 输入元素值遍历 nan、inf、-inf、[-inf, inf] | 每种 dtype 每种值生成不同 shape 用例 |
+
+> 说明：特殊场景用例不与常规用例正交组合。
+
+## 5. 正反向级联测试
+
+**适用：** 训练中的反向算子
+
+**方法：** 设计正向 + 反向组合测试用例
+
+## 6. 生成注意事项
+
+1. 数据类型、格式、维度需正交组合遍历
+2. 特殊场景用例不与常规用例正交组合
+3. 不同随机种子视为相同用例

package/assets/ops-direct-invoke/skills/ops-precision-standard/scripts/bitwise_match.py

@@ -0,0 +1,103 @@
+# ----------------------------------------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------------------------------------
+
+"""
+二进制一致性比对脚本(Bitwise Match)
+用于非计算类算子(搬移/Cast等)的精度验证
+"""
+import numpy as np
+
+
+def check_bitwise_match(npu_output, golden_output):
+    """
+    检查NPU输出与Golden是否二进制一致
+    
+    Args:
+        npu_output: NPU算子输出(numpy array)
+        golden_output: CPU标杆输出(numpy array)
+    
+    Returns:
+        dict: 包含is_pass, bitwise_match_result等信息的字典
+    """
+    is_bitwise_match = np.array_equal(npu_output, golden_output)
+    
+    result = {
+        'is_pass': is_bitwise_match,
+        'bitwise_match': is_bitwise_match,
+        'npu_dtype': str(npu_output.dtype),
+        'golden_dtype': str(golden_output.dtype),
+        'npu_shape': npu_output.shape,
+        'golden_shape': golden_output.shape
+    }
+    
+    if not is_bitwise_match:
+        mismatch_count = np.sum(npu_output != golden_output)
+        result['mismatch_count'] = mismatch_count
+        result['total_elements'] = npu_output.size
+        result['mismatch_ratio'] = mismatch_count / npu_output.size
+        
+    return result
+
+
+def check_bitwise_match_batch(outputs_list):
+    """
+    批量检查多个用例的二进制一致性
+    
+    Args:
+        outputs_list: [(npu_output, golden_output), ...]列表
+    
+    Returns:
+        dict: 包含汇总信息的字典
+    """
+    results = []
+    pass_count = 0
+    
+    for npu_out, golden_out in outputs_list:
+        result = check_bitwise_match(npu_out, golden_out)
+        results.append(result)
+        if result['is_pass']:
+            pass_count += 1
+    
+    total = len(outputs_list)
+    summary = {
+        'total_cases': total,
+        'pass_count': pass_count,
+        'fail_count': total - pass_count,
+        'pass_rate': pass_count / total if total > 0 else 0,
+        'detail_results': results
+    }
+    
+    return summary
+
+
+if __name__ == '__main__':
+    # 示例用法
+    np.random.seed(42)
+    
+    # 测试1: 完全一致的情况
+    golden1 = np.array([1, 2, 3, 4, 5], dtype=np.int32)
+    npu1 = np.array([1, 2, 3, 4, 5], dtype=np.int32)
+    result1 = check_bitwise_match(npu1, golden1)
+    print(f"测试1 - 完全一致: {result1['is_pass']}")
+    
+    # 测试2: 不一致的情况
+    golden2 = np.array([1.0, 2.0, 3.0], dtype=np.float16)
+    npu2 = np.array([1.0, 2.0, 3.001], dtype=np.float16)
+    result2 = check_bitwise_match(npu2, golden2)
+    print(f"测试2 - 不一致: {result2['is_pass']}, 不匹配数量: {result2.get('mismatch_count', 0)}")
+    
+    # 测试3: 批量检查
+    outputs_list = [
+        (np.array([1, 2, 3], dtype=np.int32), np.array([1, 2, 3], dtype=np.int32)),
+        (np.array([1, 2, 3], dtype=np.int32), np.array([1, 2, 4], dtype=np.int32)),
+        (np.array([5, 6, 7], dtype=np.int32), np.array([5, 6, 7], dtype=np.int32))
+    ]
+    summary = check_bitwise_match_batch(outputs_list)
+    print(f"批量测试: 通过率 {summary['pass_rate']:.2%}")

package/assets/ops-direct-invoke/skills/ops-precision-standard/scripts/integer_compute_check.py

@@ -0,0 +1,157 @@
+# ----------------------------------------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------------------------------------
+
+"""
+整数计算类算子精度检查脚本
+用于INT8/INT16/INT32等整数算子的精度验证
+"""
+import numpy as np
+
+
+def check_integer_compute(npu_output, golden_output):
+    """
+    检查整数计算类算子精度
+    
+    通过标准:
+    1. 二进制一致: np.array_equal(npu_output, golden_output)
+    2. 若不满足二进制一致但绝对误差为0也视为通过
+    
+    Args:
+        npu_output: NPU算子输出(numpy array, int类型)
+        golden_output: CPU标杆输出(numpy array, int类型)
+    
+    Returns:
+        dict: 包含is_pass, bitwise_match, abs_error等信息的字典
+    """
+    # 检查数据类型
+    if not (np.issubdtype(npu_output.dtype, np.integer) and 
+            np.issubdtype(golden_output.dtype, np.integer)):
+        return {
+            'is_pass': False,
+            'error': 'Output dtype must be integer type',
+            'npu_dtype': str(npu_output.dtype),
+            'golden_dtype': str(golden_output.dtype)
+        }
+    
+    # 检查二进制一致
+    is_bitwise_match = np.array_equal(npu_output, golden_output)
+    
+    # 检查绝对误差: 先统一转为int64避免不同位宽整数相减溢出
+    npu_casted = npu_output.astype(np.int64)
+    golden_casted = golden_output.astype(np.int64)
+    abs_error = np.abs(npu_casted - golden_casted)
+    max_abs_error = int(np.max(abs_error))
+    mean_abs_error = float(np.mean(abs_error))
+    
+    # 通过条件: 二进制一致 OR 绝对误差为0
+    is_abs_zero = (max_abs_error == 0)
+    is_pass = is_bitwise_match or is_abs_zero
+    
+    result = {
+        'is_pass': is_pass,
+        'bitwise_match': is_bitwise_match,
+        'abs_error_zero': is_abs_zero,
+        'max_abs_error': max_abs_error,
+        'mean_abs_error': mean_abs_error,
+        'npu_dtype': str(npu_output.dtype),
+        'golden_dtype': str(golden_output.dtype),
+        'shape': npu_output.shape
+    }
+    
+    if not is_pass:
+        mismatch_count = np.sum(abs_error != 0)
+        result['mismatch_count'] = mismatch_count
+        result['total_elements'] = npu_output.size
+        result['mismatch_ratio'] = mismatch_count / npu_output.size
+        
+        # 提供不匹配的样本位置和值
+        mismatch_indices = np.where(abs_error != 0)
+        if len(mismatch_indices[0]) > 0:
+            sample_indices = mismatch_indices[0][:10]  # 只展示前10个
+            result['sample_mismatch'] = {
+                'indices': sample_indices,
+                'npu_values': npu_output[sample_indices],
+                'golden_values': golden_output[sample_indices],
+                'errors': abs_error[sample_indices]
+            }
+    
+    return result
+
+
+def check_integer_compute_batch(outputs_list):
+    """
+    批量检查多个用例的整数计算精度
+    
+    Args:
+        outputs_list: [(npu_output, golden_output), ...]列表
+    
+    Returns:
+        dict: 包含汇总信息的字典
+    """
+    results = []
+    pass_count = 0
+    bitwise_match_count = 0
+    abs_zero_count = 0
+    
+    for npu_out, golden_out in outputs_list:
+        result = check_integer_compute(npu_out, golden_out)
+        results.append(result)
+        
+        if result['is_pass']:
+            pass_count += 1
+            if result['bitwise_match']:
+                bitwise_match_count += 1
+            elif result['abs_error_zero']:
+                abs_zero_count += 1
+    
+    total = len(outputs_list)
+    summary = {
+        'total_cases': total,
+        'pass_count': pass_count,
+        'fail_count': total - pass_count,
+        'pass_rate': pass_count / total if total > 0 else 0,
+        'bitwise_match_count': bitwise_match_count,
+        'abs_zero_count': abs_zero_count,
+        'detail_results': results
+    }
+    
+    return summary
+
+
+if __name__ == '__main__':
+    # 示例用法
+    np.random.seed(42)
+    
+    # 测试1: 完全二进制一致
+    golden1 = np.array([10, 20, 30, 40], dtype=np.int32)
+    npu1 = np.array([10, 20, 30, 40], dtype=np.int32)
+    result1 = check_integer_compute(npu1, golden1)
+    print(f"测试1 - 二进制一致: {result1['is_pass']}, bitwise_match={result1['bitwise_match']}")
+    
+    # 测试2: 绝对误差为0的情况(可能dtype不同但数值相同)
+    golden2 = np.array([100, 200, 300], dtype=np.int64)
+    npu2 = np.array([100, 200, 300], dtype=np.int64)
+    result2 = check_integer_compute(npu2, golden2)
+    print(f"测试2 - 绝对误差为0: {result2['is_pass']}, abs_error_zero={result2['abs_error_zero']}")
+    
+    # 测试3: 不通过的情况
+    golden3 = np.array([1, 2, 3, 4, 5], dtype=np.int32)
+    npu3 = np.array([1, 2, 4, 4, 5], dtype=np.int32)
+    result3 = check_integer_compute(npu3, golden3)
+    print(f"测试3 - 不通过: {result3['is_pass']}, max_abs_error={result3['max_abs_error']}")
+    if 'sample_mismatch' in result3:
+        print(f"  不匹配样本: indices={result3['sample_mismatch']['indices']}, "
+              f"errors={result3['sample_mismatch']['errors']}")
+    
+    # 测试4: 非整数类型(应该报错)
+    golden4 = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    npu4 = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    result4 = check_integer_compute(npu4, golden4)
+    print(f"测试4 - 非整数类型: {result4['is_pass']}, error={result4.get('error', 'None')}")

package/assets/ops-direct-invoke/skills/ops-precision-standard/scripts/mixed_tolerance_check.py

@@ -0,0 +1,178 @@
+# ----------------------------------------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------------------------------------
+
+"""
+浮点计算类算子精度检查脚本 - 混合容差(Mixed Tolerance, atol/rtol)
+对齐生态算子开源精度标准(experimental_standard.md)第 2 节。
+"""
+import numpy as np
+
+
+_TOLERANCE_TABLE = {
+    'float16': (2 ** (-9), 2 ** (-9), 0.99, 1e-1),
+    'bfloat16': (2 ** (-6), 2 ** (-6), 0.99, 1e-0),
+    'float32': (2 ** (-10), 2 ** (-16), 0.99, 1e-2),
+    'hifloat32': (2 ** (-9), 2 ** (-10), 0.99, 1e-1),
+    'float8e4m3': (2 ** (-2), 2 ** (-4), 0.99, 1e-0),
+    'float8e4m3fn': (2 ** (-2), 2 ** (-4), 0.99, 1e-0),
+    'float8e5m2': (2 ** (-1), 2 ** (-3), 0.99, 1e-1),
+}
+
+_ULP_FACTOR = 32
+
+_ULP_TABLE = {
+    'float16': 2 ** (-10),
+    'bfloat16': 2 ** (-7),
+    'float32': 2 ** (-23),
+    'hifloat32': 2 ** (-24),
+    'float8e4m3': 2 ** (-3),
+    'float8e4m3fn': 2 ** (-3),
+    'float8e5m2': 2 ** (-2),
+}
+
+
+def _normalize_dtype(dtype):
+    return str(dtype).lower().replace(' ', '').replace('_', '')
+
+
+def get_tolerance_by_dtype(dtype):
+    """
+    根据数据类型获取混合容差阈值
+
+    Returns:
+        tuple: (rtol, atol, required_matched_ratio, max_abs_error_limit_fixed)
+    """
+    dtype_str = _normalize_dtype(dtype)
+    if dtype_str in _TOLERANCE_TABLE:
+        return _TOLERANCE_TABLE[dtype_str]
+    if 'float8e4m3' in dtype_str:
+        return _TOLERANCE_TABLE['float8e4m3']
+    if 'float8e5m2' in dtype_str:
+        return _TOLERANCE_TABLE['float8e5m2']
+    raise ValueError(f'Unsupported dtype: {dtype}')
+
+
+def _ulp_at_one(dtype):
+    dtype_str = _normalize_dtype(dtype)
+    if dtype_str in _ULP_TABLE:
+        return _ULP_TABLE[dtype_str]
+    if 'float8e4m3' in dtype_str:
+        return _ULP_TABLE['float8e4m3']
+    if 'float8e5m2' in dtype_str:
+        return _ULP_TABLE['float8e5m2']
+    raise ValueError(f'Unsupported dtype: {dtype}')
+
+
+def check_mixed_tolerance(npu_output, golden_output):
+    """
+    检查浮点算子精度(混合容差 atol/rtol 标准)
+
+    通过标准(同时满足):
+    1. matched_ratio >= required_matched_ratio
+    2. max_abs_error <= max_abs_error_limit
+       max_abs_error_limit = max(fixed_limit, 32 * ULP)
+
+    Args:
+        npu_output: NPU 算子输出(numpy array)
+        golden_output: CPU 标杆输出(numpy array)
+
+    Returns:
+        dict: 包含 is_pass 和各误差指标的字典
+    """
+    rtol, atol, required_matched_ratio, fixed_limit = get_tolerance_by_dtype(npu_output.dtype)
+
+    if npu_output.shape != golden_output.shape:
+        raise ValueError(
+            f"Shape mismatch: npu {npu_output.shape} vs golden {golden_output.shape}"
+        )
+
+    ulp_limit = _ULP_FACTOR * _ulp_at_one(npu_output.dtype)
+    max_abs_error_limit = max(fixed_limit, ulp_limit)
+
+    abs_error = np.abs(npu_output.astype(np.float64) - golden_output.astype(np.float64))
+    element_threshold = atol + rtol * np.abs(golden_output.astype(np.float64))
+    element_passed = abs_error <= element_threshold
+
+    total = npu_output.size
+    if total == 0:
+        matched_ratio = 1.0
+        max_abs_error = 0.0
+    else:
+        matched_ratio = float(np.sum(element_passed)) / total
+        max_abs_error = float(np.max(abs_error))
+
+    ratio_pass = matched_ratio >= required_matched_ratio
+    max_err_pass = max_abs_error <= max_abs_error_limit
+    is_pass = ratio_pass and max_err_pass
+
+    result = {
+        'is_pass': is_pass,
+        'matched_ratio': matched_ratio,
+        'required_matched_ratio': required_matched_ratio,
+        'max_abs_error': max_abs_error,
+        'max_abs_error_limit': max_abs_error_limit,
+        'max_abs_error_limit_fixed': fixed_limit,
+        'max_abs_error_limit_ulp': ulp_limit,
+        'rtol': rtol,
+        'atol': atol,
+        'ratio_pass': ratio_pass,
+        'max_err_pass': max_err_pass,
+        'npu_dtype': str(npu_output.dtype),
+        'golden_dtype': str(golden_output.dtype),
+        'shape': npu_output.shape,
+    }
+
+    if not is_pass:
+        result['failure_reasons'] = []
+        if not ratio_pass:
+            result['failure_reasons'].append(
+                f'matched_ratio {matched_ratio:.6f} < required {required_matched_ratio}'
+            )
+        if not max_err_pass:
+            result['failure_reasons'].append(
+                f'max_abs_error {max_abs_error:.6g} > limit {max_abs_error_limit:.6g}'
+            )
+
+    return result
+
+
+def check_mixed_tolerance_batch(outputs_list):
+    """
+    批量检查多个用例的浮点算子精度(混合容差标准)
+
+    Args:
+        outputs_list: [(npu_output, golden_output), ...] 列表
+
+    Returns:
+        dict: 包含汇总信息的字典
+    """
+    results = []
+    pass_count = 0
+    matched_ratios = []
+
+    for npu_out, golden_out in outputs_list:
+        result = check_mixed_tolerance(npu_out, golden_out)
+        results.append(result)
+        if result['is_pass']:
+            pass_count += 1
+        matched_ratios.append(result['matched_ratio'])
+
+    total = len(outputs_list)
+    summary = {
+        'total_cases': total,
+        'pass_count': pass_count,
+        'fail_count': total - pass_count,
+        'pass_rate': pass_count / total if total > 0 else 0,
+        'matched_ratio_mean': float(np.mean(matched_ratios)) if matched_ratios else 0.0,
+        'matched_ratio_min': float(np.min(matched_ratios)) if matched_ratios else 0.0,
+        'detail_results': results,
+    }
+
+    return summary