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

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

@@ -0,0 +1,247 @@
+# ----------------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------------
+
+"""
+随机数生成算子分布检验脚本
+用于rand, randn, uniform等随机数生成算子的精度验证
+"""
+import numpy as np
+from scipy import stats
+
+
+def ks_test_distribution(npu_output, expected_distribution='uniform', params=None):
+    """
+    使用KS检验(Kolmogorov-Smirnov test)检查随机数分布
+    
+    Args:
+        npu_output: NPU生成的随机数(numpy array)
+        expected_distribution: 期望分布类型('uniform'/'normal'/'exponential'等)
+        params: 分布参数(dict)
+            - uniform: {'low': 0, 'high': 1}
+            - normal: {'mean': 0, 'std': 1}
+    
+    Returns:
+        dict: 包含p值和检验结果的字典
+    """
+    if params is None:
+        params = {}
+    
+    # 执行KS检验
+    if expected_distribution == 'uniform':
+        low = params.get('low', 0)
+        high = params.get('high', 1)
+        statistic, p_value = stats.kstest(npu_output, 'uniform', args=(low, high - low))
+    
+    elif expected_distribution == 'normal':
+        mean = params.get('mean', 0)
+        std = params.get('std', 1)
+        statistic, p_value = stats.kstest(npu_output, 'norm', args=(mean, std))
+    
+    elif expected_distribution == 'exponential':
+        scale = params.get('scale', 1)
+        statistic, p_value = stats.kstest(npu_output, 'expon', args=(0, scale))
+    
+    else:
+        return {
+            'is_valid': False,
+            'error': f'Unsupported distribution: {expected_distribution}'
+        }
+    
+    # 判定标准
+    alpha = 0.01  # 显著性水平
+    is_pass = p_value > alpha
+    
+    result = {
+        'is_valid': True,
+        'ks_statistic': statistic,
+        'p_value': p_value,
+        'alpha': alpha,
+        'is_pass': is_pass,
+        'expected_distribution': expected_distribution,
+        'params': params,
+        'sample_size': len(npu_output),
+        'interpretation': ''
+    }
+    
+    if is_pass:
+        result['interpretation'] = f'p_value {p_value:.4f} > alpha {alpha},分布与期望一致'
+    else:
+        result['interpretation'] = f'p_value {p_value:.4f} <= alpha {alpha},分布与期望不一致'
+    
+    return result
+
+
+def check_random_distribution_batch(outputs_list, expected_distribution='uniform', 
+                                     params=None, N=100, alpha=0.01):
+    """
+    批量检查随机数生成算子的分布
+    
+    通过标准:
+    至少((1-α) + z×√(α(1-α)/N))×100%的测试用例满足p>α
+    z为正态分布99.9%截尾点=-3.0902
+    
+    Args:
+        outputs_list: 多个随机数输出样本的列表
+        expected_distribution: 期望分布
+        params: 分布参数
+        N: 测试次数(默认100),与Golden标准中的N参数一致
+        alpha: 显著性水平(默认0.01)
+    
+    Returns:
+        dict: 包含汇总信息的字典
+    """
+    results = []
+    pass_count = 0
+    
+    p_values = []
+    
+    for output in outputs_list:
+        result = ks_test_distribution(output, expected_distribution, params)
+        results.append(result)
+        
+        if result['is_valid'] and result['is_pass']:
+            pass_count += 1
+        
+        if result['is_valid']:
+            p_values.append(result['p_value'])
+    
+    total = len(outputs_list)
+    
+    # 计算理论通过率阈值
+    z = -3.0902  # 正态分布99.9%截尾点
+    theoretical_pass_rate = (1 - alpha) + z * np.sqrt(alpha * (1 - alpha) / N)
+    theoretical_pass_rate_percent = theoretical_pass_rate * 100
+    
+    # 实际通过率
+    actual_pass_rate = pass_count / total if total > 0 else 0
+    actual_pass_rate_percent = actual_pass_rate * 100
+    
+    # 判定
+    is_pass = actual_pass_rate_percent >= theoretical_pass_rate_percent
+    
+    summary = {
+        'total_tests': total,
+        'pass_count': pass_count,
+        'fail_count': total - pass_count,
+        'actual_pass_rate': actual_pass_rate,
+        'actual_pass_rate_percent': actual_pass_rate_percent,
+        'theoretical_pass_rate': theoretical_pass_rate,
+        'theoretical_pass_rate_percent': theoretical_pass_rate_percent,
+        'is_pass': is_pass,
+        'expected_distribution': expected_distribution,
+        'alpha': alpha,
+        'N': N,
+        'p_value_mean': np.mean(p_values) if p_values else None,
+        'p_value_std': np.std(p_values) if p_values else None,
+        'detail_results': results
+    }
+    
+    if not is_pass:
+        summary['failure_reason'] = (
+            f'实际通过率 {actual_pass_rate_percent:.2f}% '
+            f'< 理论阈值 {theoretical_pass_rate_percent:.2f}%'
+        )
+    
+    return summary
+
+
+def check_distribution_statistics(npu_output, expected_distribution='uniform', params=None):
+    """
+    检查随机数分布的统计特性(均值、方差等)
+    
+    Args:
+        npu_output: NPU生成的随机数
+        expected_distribution: 期望分布
+        params: 分布参数
+    
+    Returns:
+        dict: 包含统计特性信息的字典
+    """
+    if params is None:
+        params = {}
+    
+    actual_mean = np.mean(npu_output)
+    actual_std = np.std(npu_output)
+    actual_min = np.min(npu_output)
+    actual_max = np.max(npu_output)
+    
+    if expected_distribution == 'uniform':
+        low = params.get('low', 0)
+        high = params.get('high', 1)
+        expected_mean = (low + high) / 2
+        expected_std = (high - low) / np.sqrt(12)
+        expected_min = low
+        expected_max = high
+    
+    elif expected_distribution == 'normal':
+        mean = params.get('mean', 0)
+        std = params.get('std', 1)
+        expected_mean = mean
+        expected_std = std
+        expected_min = None
+        expected_max = None
+    
+    else:
+        return {
+            'is_valid': False,
+            'error': f'Unsupported distribution: {expected_distribution}'
+        }
+    
+    result = {
+        'is_valid': True,
+        'actual_mean': actual_mean,
+        'actual_std': actual_std,
+        'actual_min': actual_min,
+        'actual_max': actual_max,
+        'expected_mean': expected_mean,
+        'expected_std': expected_std,
+        'expected_min': expected_min,
+        'expected_max': expected_max,
+        'mean_error': abs(actual_mean - expected_mean),
+        'std_error': abs(actual_std - expected_std),
+        'sample_size': len(npu_output)
+    }
+    
+    return result
+
+
+if __name__ == '__main__':
+    # 示例用法
+    np.random.seed(42)
+    
+    # 测试1: 均匀分布KS检验(通过)
+    uniform_data1 = np.random.uniform(0, 1, 1000)
+    result1 = ks_test_distribution(uniform_data1, 'uniform', {'low': 0, 'high': 1})
+    print(f"测试1 - 均匀分布KS检验: pass={result1['is_pass']}, p_value={result1['p_value']:.4f}")
+    
+    # 测试2: 正态分布KS检验(通过)
+    normal_data2 = np.random.normal(0, 1, 1000)
+    result2 = ks_test_distribution(normal_data2, 'normal', {'mean': 0, 'std': 1})
+    print(f"测试2 - 正态分布KS检验: pass={result2['is_pass']}, p_value={result2['p_value']:.4f}")
+    
+    # 测试3: 分布不匹配(不通过)
+    uniform_data3 = np.random.uniform(0.5, 1.5, 1000)  # 不是标准均匀分布
+    result3 = ks_test_distribution(uniform_data3, 'uniform', {'low': 0, 'high': 1})
+    print(f"测试3 - 分布不匹配: pass={result3['is_pass']}, p_value={result3['p_value']:.4f}")
+    print(f"  解释: {result3['interpretation']}")
+    
+    # 测试4: 批量检查
+    outputs_list = [np.random.uniform(0, 1, 100) for _ in range(100)]
+    summary4 = check_random_distribution_batch(outputs_list, 'uniform', {'low': 0, 'high': 1}, N=100)
+    print(f"测试4 - 批量检查: pass={summary4['is_pass']}")
+    print(f"  实际通过率: {summary4['actual_pass_rate_percent']:.2f}%")
+    print(f"  理论阈值: {summary4['theoretical_pass_rate_percent']:.2f}%")
+    
+    # 测试5: 统计特性检查
+    uniform_data5 = np.random.uniform(0, 1, 10000)
+    stats_result = check_distribution_statistics(uniform_data5, 'uniform', {'low': 0, 'high': 1})
+    print(f"测试5 - 统计特性:")
+    print(f"  实际均值: {stats_result['actual_mean']:.4f}, 期望均值: {stats_result['expected_mean']:.4f}")
+    print(f"  实际标准差: {stats_result['actual_std']:.4f}, 期望标准差: {stats_result['expected_std']:.4f}")

package/assets/ops-direct-invoke/skills/ops-profiling/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: ops-profiling
+description: NPU 性能采集与分析，融合 msprof 算子级瓶颈定位与 kernel-level 对比测试，用于采集算子性能数据、对比自定义算子 vs 标杆加速比、定位性能瓶颈并给出优化建议。核心工具：msprof_profile_run.sh（标准采集 / --compare 对比测试 / --quick 快速对比 / --batch 批量并行）与 msprof_perf_summary.py（瓶颈分析、对比报告）；加速比对比用 msprof_profile_run.sh 的 compare/quick 模式，输出 performance.json 和 markdown 对比报告即完成，无需可视化。另含 msopprof-visualization 子技能，仅当用户明确要求把已采集数据渲染为交互式 HTML 可视化报告时使用，不用于加速比对比场景。当用户在算子开发过程中提到"上板性能"、"算子性能测试"、"硬件性能验证"、"NPU性能采集"、"NPU profiling"、"性能对比"、"加速比"、"性能可视化"、"性能报告"等场景时触发。
+---
+
+# 上板性能采集与调优
+
+在真实 NPU 上采集算子性能数据，系统化解读指标文件，判定性能是否达标，定位瓶颈类型，并给出可操作的优化建议。
+
+## 高频问答速查（先查这里——本节答案即为权威结论，已与脚本实际行为对齐，无需再读源码验证）
+
+| 问题 | 答案 |
+|---|---|
+| compare 模式下用例文件加载优先级？ | ① `<op>_perf_cases.jsonl`（标准命名）→ ② 任意 `*.jsonl` → ③ 任意 `*.json`（非 `.bak`）→ ④ `model.py` 的 `get_input_groups()`。同时存在时**选①**（详见下文「用例加载优先级」） |
+| 怎么做加速比对比？ | `msprof_profile_run.sh --compare`（全量）/ `--quick`（1 轮快速），输出 `performance.json` + markdown 报告即完成，**不**走可视化子技能 |
+| MC² / 多 rank（fork）算子用什么采集？ | **必须 `msprof`**，禁止 `msprof op`（详见 msprof-guide.md「MC² 多 rank 算子采集」） |
+| 采集结果如何判定瓶颈？ | 用 `msprof_perf_summary.py` 解析 `PROF_GROUP_*`，输出瓶颈类型与各 pipe 占比，判定规则见 `references/msprof-guide.md` |
+
+### 阅读纪律（防上下文爆炸，必须遵守）
+
+- `scripts/msprof_perf_summary.py`（2400+ 行）与 `scripts/msprof_profile_run.sh` 是**可执行工具，不是文档**。需要确认某个行为时，只允许 `grep -n "<函数名/关键字>" scripts/msprof_perf_summary.py` 定位后**读命中处前后 ~30 行**；**禁止整文件通读**。
+- `references/` 下四份文档按文末「参考资源」表的"何时查阅"**按需加载**；回答本文件已写明的事实性问题时，不需要打开任何 reference 或 script。
+- 本 SKILL.md 覆盖全部使用决策；若与脚本实际行为发现不一致，以脚本行为为准并在本文件勘误。
+
+---
+
+本技能基于 **msprof** 工具链，统一入口为两个脚本：
+- **`msprof_profile_run.sh`** — 性能采集（标准采集 / 对比测试 / 批量并行）
+- **`msprof_perf_summary.py`** — 结果解析（瓶颈分析 / 对比报告 / 批量汇总）
+
+| 工具 | 流程文档 | 用途 |
+|------|----------|------|
+| **`msprof_profile_run.sh`** | [`references/msprof-guide.md`](references/msprof-guide.md) | 统一采集入口：标准采集、对比测试、批量并行 |
+| **`msprof_perf_summary.py`** | [`references/msprof-guide.md`](references/msprof-guide.md) | 统一解析入口：瓶颈分析、对比报告生成、批量汇总 |
+| **`perf_summary.py`** | [`references/msprof-op-guide.md`](references/msprof-op-guide.md) | msprof op 归档（需 msopprof） |
+
+---
+
+## 使用方式
+
+### 1. 标准采集模式（深度瓶颈分析）
+
+对单个可执行文件采集 7 组 aic-metrics + sample-based：
+
+```bash
+bash scripts/msprof_profile_run.sh --warm-up=3 --output=./msprof_output -- \
+    ./matmul_tutorial_mxfp4_pingpong 8448 4096 4096
+
+# 解析结果
+python3 scripts/msprof_perf_summary.py ./msprof_output/PROF_GROUP_* <ops_dir>
+```
+
+### 2. 对比测试模式（kernel-level 加速比）
+
+对算子目录下的 `model.py` vs `model_new_ascendc.py` 做对比测试：
+
+```bash
+bash scripts/msprof_profile_run.sh --compare --output-dir=./output/GELU --warm-up=3 --device=0
+```
+
+输出：`performance.json` + `performance.log` + `perf_report.md`
+
+### 3. 快速模式（1 轮采集，只获取 kernel 时间）
+
+对算子目录做快速对比测试，只跑 1 轮 msprof，不采集 7 个 aic-metrics：
+
+```bash
+bash scripts/msprof_profile_run.sh --quick --output-dir=./output/GELU --warm-up=3 --device=0
+```
+
+输出：`performance.json` + `performance.log` + `perf_report.md`
+
+### 4. 批量并行模式（多 NPU）
+
+扫描目录下所有算子子目录，多 NPU 并行执行对比测试：
+
+```bash
+bash scripts/msprof_profile_run.sh --batch --base-dir=./output_performance --max-jobs=7 --device-start=1
+```
+
+输出：各子目录 `performance.json` + `batch_performance.log` + `batch_report.md` + `batch_summary.json`
+
+---
+
+## 输入目录结构（对比模式）
+
+**传统模式（端到端自动开发）：**
+```
+{output_dir}/
+├── model.py              # 参考 PyTorch 实现
+├── model_new_ascendc.py  # AscendC 实现
+├── <op_name>.json        # 测试用例（JSON Lines）
+└── kernel/               # AscendC kernel + whl 包
+```
+
+**JSONL 模式（ascend-kernel 工程结构）：**
+```
+csrc/ops/<op>/test/
+├── <op>_perf_cases.jsonl   # JSONL 用例
+├── model.py                # 参考实现
+├── model_new_ascendc.py    # AscendC 实现
+└── kernel/                 # kernel 工程
+```
+
+### 用例加载优先级
+
+1. **优先**：`<op>_perf_cases.jsonl`（标准 JSONL 命名）
+2. **回退**：任意 `*.jsonl` 文件
+3. **回退**：任意 `*.json` 文件（非 `.bak`，JSON Lines 格式）
+4. **回退**：从 `model.py` 的 `get_input_groups()` 加载
+
+---
+
+## 输出格式（对比模式）
+
+Markdown 报告包含：
+- **对比表**：`Case | Shape | DType | 自定义算子(us) | 标杆(us) | 加速比`
+- **全量汇总**：用例数、平均加速比、自定义/标杆更优条数
+- **按数据类型汇总**：分 dtype 的统计
+- **简短分析**：整体趋势结论
+- **深度瓶颈分析入口**：提供 msprof 深度分析命令
+
+额外输出：
+- `performance.json` — 结构化数据（含 geomean/mean/median/min/max 加速比）
+- `performance.log` — 打屏日志
+
+---
+
+## 深度分析：msprof / msprof op
+
+当性能不达标或需要根因分析时，使用深度分析流程。
+
+### 选用哪个工具：决策树
+
+1. **用户显式指定工具**
+   - 指定 `msprof op` / msopprof → 加载 [`references/msprof-op-guide.md`](references/msprof-op-guide.md)
+   - 指定 `msprof` → 加载 [`references/msprof-guide.md`](references/msprof-guide.md)
+
+2. **用户未指定** — 先判定算子类型，再探测环境：
+   - **MC² / 多 rank 算子**（算子通过 `fork()` 创建多个子进程绑定不同 NPU 卡，子进程间通过 SHMEM UDMA / BarrierAll / CrossCoreFlag 协同通信，如 alltoall_matmul、allgather_matmul、matmul_reducescatter）→ **必须使用 `msprof`**，禁止使用 `msprof op`（`msprof op` 对 fork 程序的采集行为未定义，数据不可靠）。加载 [`references/msprof-guide.md`](references/msprof-guide.md) 的「MC² 多 rank 算子采集」章节，同时参考 `ascendc-perf-optimize` skill 的 `references/comm-compute/index.md`「性能采集方法」章节
+   - 仅 `msopprof` 可用 → [`references/msprof-op-guide.md`](references/msprof-op-guide.md)
+   - 仅 `msprof` 可用 → [`references/msprof-guide.md`](references/msprof-guide.md)
+   - 两者皆可用 → 须向用户确认或按项目约定选用其一
+   - 两者皆不可用 → 报错，提示检查 CANN / `ASCEND_HOME` 安装
+
+### 可视化报告（上板数据 → HTML）
+
+当用户要求把上板采集数据可视化为交互式 HTML 报告（Details、Roofline、Timeline、Cache 热力图、Source 等页面）时，加载子技能 [`msopprof-visualization/SKILL.md`](msopprof-visualization/SKILL.md)：
+
+- 有算子工程可上板 replay → 用其 `run_pipeline.py` 做最小非重复采集并生成报告；
+- 已有含 `collection_manifest.json` 的采集目录 → 只用 visualize 模式重渲染，不得重复采集。
+
+以下场景**不加载**可视化子技能：
+
+- 加速比对比（compare / quick / batch）：输出 `performance.json` + markdown 即完成；
+- MC² / fork 多进程算子：子技能基于 `msprof op`，该场景对 `msprof op` 禁用；
+- 纯瓶颈分析或 CSV 指标解读且用户未提及可视化。
+
+注意两套链路输出不互通：本技能的 `PROF_GROUP_*` 归档不能直接喂给可视化渲染，可视化子技能的采集目录结构由其自身 `collect.py` 产生。
+
+### 参考资源
+
+| 文件 | 内容 | 何时查阅 |
+|------|------|---------|
+| [`references/msprof-guide.md`](references/msprof-guide.md) | `msprof`：构建 / 采集 / 归档 / **主 Bound 判定** / 瓶颈 + **MC² 多 rank 采集**（文末章节） | 选用 `msprof` 时，或 MC² / fork 多进程算子 |
+| [`references/msprof-op-guide.md`](references/msprof-op-guide.md) | `msprof op`：构建 / 采集 / 归档 / 判定 / 瓶颈 / 回归 | 选用 `msprof op` 时（不适用于 MC²） |
+| [`references/csv_fields_reference.md`](references/csv_fields_reference.md) | CSV 字段定义与阈值 | 理解指标含义时 |
+| [`references/optimization_quickref.md`](references/optimization_quickref.md) | 瓶颈类型与优化方法 | 定位瓶颈后 |
+
+---
+
+## 适用场景总览
+
+| 场景 | 推荐命令 | 说明 |
+|------|----------|------|
+| **MC² 多 rank 算子采集** | `msprof --aic-mode=task-based` | **必须用 msprof，禁止 msprof op**，详见 msprof-guide.md「MC² 多 rank 算子采集」章节 |
+| 算子开发完成后的性能验收 | `msprof_profile_run.sh --compare` | 快速对比自定义算子 vs 标杆 |
+| 性能问题定位 | `msprof_profile_run.sh` + `msprof_perf_summary.py` | 深度瓶颈分析 |
+| 优化效果验证 | `msprof_profile_run.sh` + `msprof_perf_summary.py` | 对比优化前后的归档数据 |
+| 算子生成阶段快速测试 | `msprof_profile_run.sh --quick` | 快速对比测试（1 轮采集，只获取时间） |
+| Agent team 测试阶段 | `--quick` / `--compare` + 标准采集 | 先快速对比，不达标再深度分析 |
+| 端到端自动开发 Phase 5 | `msprof_profile_run.sh --quick` | 集成到 tilelang2ascendc-ops-generator 流程（只获取加速比） |
+| 进化优化前基线测试 | `msprof_profile_run.sh --quick` | 快速获取基线加速比 |
+| 批量性能测试 | `msprof_profile_run.sh --batch` | 多 NPU 并行批量测试 |
+| 上板数据可视化报告 | `msopprof-visualization` 子技能 | 交互式 HTML：Details/Roofline/Timeline/Cache/Source 等页面 |

package/assets/ops-direct-invoke/skills/ops-profiling/evals/evals.json

@@ -0,0 +1,196 @@
+{
+  "eval_mode": "text",
+  "evals": [
+    {
+      "id": 1,
+      "title": "Ascend C 算子性能数据采集工具",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "在 Ascend C 算子开发中，如何采集 NPU 性能数据？有哪些工具可以使用？不需要执行任何工具调用。",
+      "expected_output": "回复应介绍用于采集 NPU 性能数据的主要工具及其用途，说明如何选择合适的工具进行性能数据采集。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 2,
+      "title": "ops-profiling 的适用场景",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "ops-profiling 技能适用于哪些场景？请列举说明。不需要执行任何工具调用。",
+      "expected_output": "回复应列出 ops-profiling 的适用场景：上板性能测试、算子性能测试、硬件性能验证、NPU 性能采集、性能优化等，涵盖从性能数据采集到分析的全流程。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 3,
+      "title": "可视化报告路由到 msopprof-visualization",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我已经在 NPU 上采集了算子的 msprof 数据，想生成一份交互式 HTML 性能可视化报告，应该怎么做？不需要执行任何工具调用。",
+      "expected_output": "回复应指向 msopprof-visualization 子技能：已有含 collection_manifest.json 的采集目录时用 visualize 模式重渲染，有算子工程时用其 run_pipeline.py 采集并生成报告，不得建议使用 msprof_profile_run.sh 的对比测试链路。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 4,
+      "title": "对比测试场景不路由到可视化子技能",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我的自定义算子开发完成了，想对比一下它和标杆实现的加速比，用哪个工具？不需要执行任何工具调用。",
+      "expected_output": "回复应推荐 msprof_profile_run.sh 的 compare/quick 模式，输出 performance.json 和 markdown 报告，不应引导到 msopprof-visualization 可视化子技能。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 5,
+      "title": "MC² 多 Rank 算子禁止使用 msprof op",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "一个 alltoall_matmul 通过 fork 拉起多 rank，并用 SHMEM/BarrierAll 协同。我想用 msprof op 采集并生成 HTML，可行吗？",
+      "expected_output": "回复应说明 MC²/fork 多进程算子必须使用 msprof 的 task-based 采集，禁止 msprof op，因为其 fork 采集行为未定义、数据不可靠；该场景也不走基于 msprof op 的可视化子技能",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 6,
+      "title": "深度分析工具选择需探测环境",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "普通单 rank 算子要做深度瓶颈分析，用户没指定 msprof 还是 msprof op。环境选择规则是什么？",
+      "expected_output": "回复应先探测工具：只有 msopprof 时走 msprof op，只有 msprof 时走 msprof，两者都可用时向用户确认或遵循项目约定，两者都不可用则报告 CANN/ASCEND_HOME 环境问题；不得凭偏好随意选",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 7,
+      "title": "对比模式的用例加载优先级",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "算子 test 目录同时有 op_perf_cases.jsonl、other.jsonl、cases.json 和 model.py 的 get_input_groups。compare 模式应优先加载哪个？",
+      "expected_output": "回复应按优先级先加载标准命名的 <op>_perf_cases.jsonl，其次任意 jsonl，再次非 bak 的 JSON Lines json，最后才回退到 model.py 的 get_input_groups",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 8,
+      "title": "Quick 与标准深度采集的用途不同",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我只想快速知道自定义 kernel 相对标杆的加速比，是否要先采完 7 组 aic-metrics？什么时候才走标准模式？",
+      "expected_output": "回复应推荐 --quick 做一轮 kernel 时间对比并输出 performance.json/log/markdown；只有性能不达标或需要定位主 Bound、流水和搬运瓶颈时，才走标准采集 7 组 aic-metrics 并用 msprof_perf_summary.py 深度分析",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 9,
+      "title": "两套性能产物目录不能直接互喂",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我已有 msprof_profile_run.sh 生成的 PROF_GROUP_* 归档，能否直接交给 msopprof-visualization 的 visualize 模式渲染？",
+      "expected_output": "回复应说明两套链路产物不互通，PROF_GROUP_* 不能直接作为 visualization 的采集目录；visualize 模式要求其自身 collect.py 生成且含 collection_manifest.json 的目录，有算子工程时则用 run_pipeline.py 做最小非重复采集",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 10,
+      "title": "保留原始 PROF 目录（--keep-prof，quick/compare 均支持）",
+      "config": {
+        "max_tokens": 100000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 120000,
+          "glm-5": 110000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我用 msprof_profile_run.sh 的 quick 模式跑完性能对比后，想保留 msprof 原始 PROF 目录做后续深度分析（例如导入可视化工具逐指令看流水），应该怎么做？不需要执行任何工具调用。",
+      "expected_output": "回复应推荐 --keep-prof 选项（quick 与 compare 模式均支持透传），说明其作用是保留 msprof 原始 PROF 目录（默认采集后清理）；不得回答成需要手工备份 PROF 目录或改用标准模式重新采集。",
+      "files": [],
+      "expectations": []
+    }
+  ],
+  "skill_name": "ops-profiling"
+}