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

package/assets/ops-direct-invoke/skills/ascendc-whitebox-design/scripts/ttk_validate_csv.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+# ----------------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------------
+import sys
+import csv
+import logging
+import re
+
+_logger = logging.getLogger(__name__)
+
+
+KERNEL_COLUMNS = [
+    "testcase_name", "network_name", "op_name",
+    "input_shapes", "input_dtypes", "input_formats",
+    "output_shapes", "output_dtypes", "output_formats",
+    "input_ori_shapes", "input_ori_formats",
+    "output_ori_shapes", "output_ori_formats",
+    "attributes", "input_data_ranges", "precision_tolerances",
+    "absolute_precision",
+    "output_inplace_indexes", "output_shape_unknown_indexes",
+    "is_enabled", "remark", "soc_series", "priority",
+    "dump_file_prefix", "manual_input_binaries", "manual_golden_binaries",
+]
+
+ACLNN_COLUMNS = [
+    "testcase_name", "network_name", "api_name",
+    "tensor_view_shapes", "tensor_dtypes", "tensor_formats",
+    "tensor_storage_shapes", "tensor_view_offsets", "tensor_view_strides",
+    "output_tensor_indexes", "output_inplace_indexes",
+    "attributes", "scalar_dtypes", "scalar_data_ranges",
+    "input_data_ranges", "precision_tolerances", "absolute_precision",
+    "is_enabled", "remark", "soc_series", "priority",
+    "dump_file_prefix", "manual_tensor_binaries", "manual_golden_binaries",
+]
+
+E2E_COLUMNS = [
+    "testcase_name", "network_name", "api_name",
+    "tensor_view_shapes", "tensor_dtypes", "tensor_formats",
+    "tensor_storage_shapes", "tensor_view_offsets", "tensor_view_strides",
+    "output_tensor_indexes", "attributes", "golden_api",
+    "input_data_ranges", "precision_tolerances", "absolute_precision",
+    "is_enabled", "remark", "soc_series", "priority",
+]
+
+KERNEL_REQUIRED = [
+    "testcase_name", "op_name", "input_shapes", "input_dtypes", "output_dtypes", "output_shapes",
+]
+
+TUPLE_COLUMNS_KERNEL = [
+    "input_dtypes", "input_formats", "output_dtypes", "output_formats",
+]
+
+COMMON_REQUIRED = ["testcase_name"]
+
+
+def detect_mode(headers):
+    if "api_name" in headers:
+        api_values = [v.strip() for v in headers]
+        return "e2e"
+    return "kernel"
+
+
+def get_expected_columns(mode):
+    return {"kernel": KERNEL_COLUMNS, "aclnn": ACLNN_COLUMNS, "e2e": E2E_COLUMNS}[mode]
+
+
+def get_required_columns(mode):
+    if mode == "kernel":
+        return KERNEL_REQUIRED
+    return COMMON_REQUIRED
+
+
+def get_tuple_columns(mode):
+    if mode == "kernel":
+        return TUPLE_COLUMNS_KERNEL
+    return []
+
+
+def check_encoding(file_path):
+    passed = True
+    try:
+        with open(file_path, "rb") as f:
+            raw = f.read()
+        if raw[:3] == b"\xef\xbb\xbf":
+            passed = False
+            _logger.info("  [FAIL] 编码为 UTF-8 BOM，应为 UTF-8（不带 BOM）")
+        else:
+            raw.decode("utf-8")
+            _logger.info("  [PASS] 编码为 UTF-8（不带 BOM）")
+    except UnicodeDecodeError:
+        passed = False
+        _logger.info("  [FAIL] 无法以 UTF-8 解码")
+    return passed
+
+
+def check_header(headers, expected):
+    passed = True
+    if headers != expected:
+        passed = False
+        missing = set(expected) - set(headers)
+        extra = set(headers) - set(expected)
+        order_diff = [i for i, (e, a) in enumerate(zip(expected, headers)) if e != a]
+        parts = []
+        if missing:
+            parts.append(f"缺少: {missing}")
+        if extra:
+            parts.append(f"多余: {extra}")
+        if order_diff:
+            parts.append(f"顺序不一致的列索引: {order_diff}")
+        _logger.info("  [FAIL] 表头列名/顺序不正确: %s", '; '.join(parts))
+    else:
+        _logger.info("  [PASS] 表头列名和顺序正确 (%d 列)", len(expected))
+    return passed
+
+
+def check_row_count(row_count):
+    passed = True
+    if row_count == 0:
+        passed = False
+        _logger.info("  [FAIL] CSV 数据行数为 0")
+    else:
+        _logger.info("  [PASS] CSV 数据行数: %d", row_count)
+    return passed
+
+
+def check_testcase_names(rows):
+    passed = True
+    names = [row["testcase_name"] for row in rows]
+    pattern = re.compile(r"^(case|network)\d+(_\w+)?$")
+    non_matching = [(i, n) for i, n in enumerate(names) if not pattern.match(n)]
+    if non_matching:
+        passed = False
+        for i, n in non_matching[:5]:
+            _logger.info("  [FAIL] testcase_name 格式错误: 行%d '%s'", i, n)
+        if len(non_matching) > 5:
+            _logger.info("  ... 共 %d 处格式错误", len(non_matching))
+    unique = set(names)
+    if len(unique) != len(names):
+        passed = False
+        dupes = [n for n in unique if names.count(n) > 1]
+        _logger.info("  [FAIL] testcase_name 存在重复: %s", dupes[:5])
+    if passed:
+        _logger.info("  [PASS] testcase_name 唯一且格式正确 (%d 条)", len(names))
+    return passed
+
+
+def check_op_name(rows):
+    passed = True
+    pattern = re.compile(r"^[a-z][a-z0-9_]*$")
+    values = set()
+    for i, row in enumerate(rows):
+        val = row["op_name"].strip()
+        values.add(val)
+        if not val:
+            passed = False
+            _logger.info("  [FAIL] op_name 为空: 行%d", i)
+        elif not pattern.match(val):
+            passed = False
+            _logger.info("  [FAIL] op_name 格式错误: 行%d '%s'", i, val)
+    if passed:
+        _logger.info("  [PASS] op_name 格式正确: %s", values)
+    return passed
+
+
+def check_required_fields(rows, required):
+    passed = True
+    for col in required:
+        if col not in rows[0]:
+            continue
+        empty_count = sum(1 for row in rows if not row[col].strip())
+        if empty_count > 0:
+            passed = False
+            _logger.info("  [FAIL] 必填字段 '%s' 有 %d 行为空", col, empty_count)
+    if passed:
+        _logger.info("  [PASS] 所有必填字段均非空")
+    return passed
+
+
+def check_precision_tolerances(rows):
+    passed = True
+    for i, row in enumerate(rows):
+        val = row["precision_tolerances"].strip()
+        if val.lower() == "none" or val == "":
+            continue
+        if not val.startswith("(("):
+            passed = False
+            _logger.info("  [FAIL] precision_tolerances 格式错误: 行%d '%s'", i, val)
+        else:
+            stripped = val.rstrip()
+            if not (stripped.endswith("))") or stripped.endswith("),)")):
+                passed = False
+                _logger.info("  [FAIL] precision_tolerances 格式错误: 行%d '%s'", i, val)
+    if passed:
+        non_none = 0
+        for row in rows:
+            val = row["precision_tolerances"].strip()
+            if val and val.lower() != "none":
+                non_none += 1
+        none_count = len(rows) - non_none
+        _logger.info(
+            "  [PASS] precision_tolerances 格式正确 (%d 条有值, %d 条为 None)",
+            non_none, none_count
+        )
+    return passed
+
+
+def _count_outer_elements(s):
+    if not s:
+        return 0
+    s = s.strip()
+    if not (s.startswith("(") and s.endswith(")")):
+        return 0
+    inner = s[1:-1]
+    depth = 0
+    count = 1
+    for ch in inner:
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+        elif ch == "," and depth == 0:
+            count += 1
+    return count
+
+
+def check_tuple_length_consistency(rows, tuple_cols, input_ref_col, output_ref_col=None):
+    if output_ref_col is None:
+        output_ref_col = input_ref_col
+    passed = True
+    for i, row in enumerate(rows):
+        for col in tuple_cols:
+            val = row[col].strip()
+            if val.lower() == "none" or val == "" or val == "None":
+                continue
+            is_output = col.startswith("output_")
+            ref = output_ref_col if is_output else input_ref_col
+            ref_str = row[ref].strip()
+            if ref_str.lower() == "none" or ref_str == "":
+                continue
+            ref_count = _count_outer_elements(ref_str)
+            col_count = _count_outer_elements(val)
+            if col_count != ref_count:
+                passed = False
+                _logger.info(
+                    "  [FAIL] 行%d: '%s' tuple 长度(%d) != '%s' 长度(%d)",
+                    i, col, col_count, ref, ref_count
+                )
+    if passed:
+        _logger.info("  [PASS] tuple 字段长度与 shapes 一致")
+    return passed
+
+
+def check_mode_detection(headers):
+    mode = detect_mode(headers)
+    _logger.info(
+        "  [PASS] 模式识别: %s (表头%s api_name)",
+        mode, '含' if mode != 'kernel' else '不含'
+    )
+    return mode
+
+
+def validate(csv_path):
+    _logger.info("=== TTK CSV 校验: %s ===\n", csv_path)
+    results = {}
+
+    results["encoding"] = check_encoding(csv_path)
+
+    with open(csv_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        headers = reader.fieldnames
+        rows = list(reader)
+
+    mode = check_mode_detection(headers)
+    expected = get_expected_columns(mode)
+    required = get_required_columns(mode)
+    tuple_cols = get_tuple_columns(mode)
+    input_ref_col = "input_shapes" if mode == "kernel" else "tensor_view_shapes"
+    output_ref_col = "output_shapes" if mode == "kernel" else "tensor_view_shapes"
+
+    results["header"] = check_header(headers, expected)
+    results["row_count"] = check_row_count(len(rows))
+
+    if len(rows) == 0:
+        _logger.info("\n=== 校验完成: CSV 无数据行，跳过字段校验 ===")
+        all_pass = all(results.values())
+        _logger.info("\n总计: %s", 'PASS' if all_pass else 'FAIL')
+        return all_pass
+
+    results["testcase_names"] = check_testcase_names(rows)
+    if "op_name" in rows[0]:
+        results["op_name"] = check_op_name(rows)
+    results["required_fields"] = check_required_fields(rows, required)
+    results["precision_tolerances"] = check_precision_tolerances(rows)
+    results["tuple_length"] = check_tuple_length_consistency(rows, tuple_cols, input_ref_col, output_ref_col)
+
+    all_pass = all(results.values())
+    _logger.info("\n=== 校验完成: %s ===", 'PASS' if all_pass else 'FAIL')
+    return all_pass
+
+
+if __name__ == "__main__":
+    logging.basicConfig(format="%(message)s")
+    if len(sys.argv) != 2:
+        _logger.info("用法: python ttk_validate_csv.py <csv_file>")
+        sys.exit(1)
+    csv_file = sys.argv[1]
+    ok = validate(csv_file)
+    sys.exit(0 if ok else 1)

package/assets/ops-direct-invoke/skills/ascendc-whitebox-design/scripts/update_path_list.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+# ----------------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------------
+"""Update S2P1_path_list.json with reachability/group data and validate.
+
+Usage:
+  python3 update_path_list.py \
+    --path-list S2P1_path_list.json \
+    --param-def S2P2_param_def.json \
+    --reach-data S2P2_reachability_data.json \
+    --op-name resize_bilinear_v2 \
+    --platform "npu_arch=DAV_3510, soc_version=ASCEND950, chip_model=Ascend950PR, core_count=64, ub_size=248"
+
+Updates path_list.json in-place, then runs 6 validation checks.
+Exit 0 on success, exit 1 on validation failure.
+"""
+
+import json
+import argparse
+import logging
+import sys
+from collections import Counter
+
+_logger = logging.getLogger(__name__)
+
+
+def main():
+    logging.basicConfig(format="%(message)s")
+    parser = argparse.ArgumentParser(description="Update path_list with reachability data")
+    parser.add_argument("--path-list", required=True, help="Path to S2P1_path_list.json")
+    parser.add_argument("--param-def", required=True, help="Path to S2P2_param_def.json")
+    parser.add_argument("--reach-data", required=True, help="Path to S2P2_reachability_data.json")
+    parser.add_argument("--op-name", required=True, help="Operator name")
+    parser.add_argument("--platform", required=True, help="Platform string")
+    args = parser.parse_args()
+
+    with open(args.path_list, encoding="utf-8") as f:
+        path_list = json.load(f)
+    with open(args.param_def, encoding="utf-8") as f:
+        param_def = json.load(f)
+    with open(args.reach_data, encoding="utf-8") as f:
+        reach_data = json.load(f)
+
+    reach_map = {p["id"]: p for p in reach_data["paths"]}
+
+    path_list["op_name"] = args.op_name
+    path_list["platform"] = args.platform
+    path_list["groups"] = reach_data["groups"]
+
+    for path in path_list["paths"]:
+        pid = path["id"]
+        if pid not in reach_map:
+            continue
+        rd = reach_map[pid]
+        path["reachability"] = rd["reachability"]
+        if "group" in rd:
+            path["group"] = rd["group"]
+        if "dead_reason" in rd:
+            path["dead_reason"] = rd["dead_reason"]
+
+    with open(args.path_list, "w", encoding="utf-8") as f:
+        json.dump(path_list, f, indent=2, ensure_ascii=False)
+
+    errors = validate(path_list, param_def)
+    if errors:
+        _logger.info("Validation FAILED:")
+        for e in errors:
+            _logger.info("  %s", e)
+        sys.exit(1)
+
+    counts = Counter(p["reachability"] for p in path_list["paths"])
+    _logger.info("Validation PASSED:")
+    _logger.info("  Total paths: %d", len(path_list['paths']))
+    for status, count in sorted(counts.items()):
+        _logger.info("    %s: %d", status, count)
+    _logger.info("  Groups: %s", path_list['groups'])
+    sys.exit(0)
+
+
+def validate(path_list, param_def):
+    errors = []
+    paths = path_list["paths"]
+    valid_statuses = {"reachable", "api_dead", "api_warn", "dead", "disputed"}
+
+    # [1] reachability 全覆盖
+    for p in paths:
+        r = p.get("reachability")
+        if r is None or r not in valid_statuses:
+            errors.append(f"[1] {p['id']}: reachability={r} invalid")
+
+    # [2] 数量等式
+    counts = Counter(p.get("reachability") for p in paths)
+    total_counted = sum(counts.get(s, 0) for s in valid_statuses)
+    if total_counted != len(paths):
+        errors.append(f"[2] count mismatch: {total_counted} != {len(paths)}")
+
+    # [3] reachable 必有 group
+    for p in paths:
+        if p.get("reachability") == "reachable" and not p.get("group"):
+            errors.append(f"[3] {p['id']}: reachable but no group")
+
+    # [4] groups 列表一致
+    s1_groups = set(path_list.get("groups", []))
+    s2_groups = set(g["id"] for g in param_def["groups"])
+    if s1_groups != s2_groups:
+        errors.append(f"[4] groups mismatch: S1={s1_groups} S2={s2_groups}")
+
+    # [5] 无空 group
+    referenced = set(p["group"] for p in paths if p.get("reachability") == "reachable" and p.get("group"))
+    for gid in s2_groups:
+        if gid not in referenced:
+            errors.append(f"[5] empty group: {gid}")
+
+    # [6] per_dtype 路径覆盖
+    for g in param_def["groups"]:
+        gid = g["id"]
+        reachable_paths = set(p["id"] for p in paths if p.get("reachability") == "reachable" and p.get("group") == gid)
+        all_covered = set()
+        per_dtype_paths = {}
+        for dtype, entries in g["per_dtype"].items():
+            covered = set(e["path"] for e in entries)
+            per_dtype_paths[dtype] = covered
+            all_covered |= covered
+            extra = covered - reachable_paths
+            if extra:
+                errors.append(f"[6] {gid}/{dtype}: extra paths {extra}")
+        if all_covered != reachable_paths:
+            missing = reachable_paths - all_covered
+            if missing:
+                errors.append(f"[6] {gid}: missing paths across all dtypes: {missing}")
+
+    return errors
+
+
+if __name__ == "__main__":
+    main()

package/assets/ops-direct-invoke/skills/cann-env-setup/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: cann-env-setup
+description: "昇腾 NPU 上 CANN 安装与环境配置指导。触发场景：需安装 CANN、配置开发环境或排查安装问题时。"
+---
+
+# CANN开发环境配置
+
+此技能为在昇腾NPU平台上安装CANN（神经网络计算架构）提供全面指导。
+
+## 调用时机
+
+在以下情况下调用此技能：
+- 用户询问CANN安装
+- 用户需要帮助设置昇腾开发环境
+- 用户遇到CANN安装问题
+- 用户想了解CANN安装方法
+
+## 安装步骤
+
+### 第1步：检查驱动是否安装
+
+**硬件要求**
+- 已安装昇腾NPU设备
+- 设备状态正常
+
+**驱动检查命令**
+```bash
+npu-smi info
+```
+
+**检查结果**
+- 如果显示NPU设备信息，说明驱动已安装
+- 记录驱动版本用于后续CANN版本兼容性检查
+- 如果提示"command not found"，需要先安装昇腾驱动
+
+### 第2步：检查CANN安装依赖
+检查CANN安装依赖（Python和pip）是否已安装：
+```bash
+# 检查Python
+if ! command -v python3 &> /dev/null && ! command -v python &> /dev/null; then
+    echo "Python not found, please install from env_dependence.md"
+fi
+
+# 检查pip
+if ! command -v pip3 &> /dev/null && ! command -v pip &> /dev/null; then
+    echo "pip not found, please install from env_dependence.md"
+fi
+```
+
+如果任何依赖缺少，会显示提示信息，请参考 [环境依赖安装指南](./references/env_dependence.md) 进行安装。
+
+### 第3步：安装CANN
+
+#### 方法一：离线安装
+
+**步骤3.1：检查当前文件夹是否存在安装包**
+```bash
+# 检查当前文件夹是否存在CANN安装包
+if ls Ascend-cann-toolkit_*.run 2>/dev/null | grep -q .; then
+    echo "找到CANN Toolkit安装包"
+    TOOLKIT_PACKAGE=$(ls Ascend-cann-toolkit_*.run)
+else
+    echo "未找到CANN Toolkit安装包，请使用在线安装方式"
+    # 退出离线安装，建议使用在线安装
+    exit 1
+fi
+
+# 检查当前文件夹是否存在ops安装包
+if ls Ascend-cann-*-ops_*.run 2>/dev/null | grep -q .; then
+    echo "找到CANN ops安装包"
+    OPS_PACKAGE=$(ls Ascend-cann-*-ops_*.run)
+else
+    echo "未找到CANN ops安装包，请使用在线安装方式"
+    # 退出离线安装，建议使用在线安装
+    exit 1
+fi
+```
+
+**步骤3.2：安装CANN**
+
+**重要：必须先安装Toolkit，再安装ops**
+
+**run格式安装：**
+```bash
+# 安装 Toolkit (默认路径 /usr/local/Ascend)
+bash "$TOOLKIT_PACKAGE" --install --quiet
+# 安装 ops
+bash "$OPS_PACKAGE" --install --quiet
+```
+
+#### 方法二：在线安装（conda方式）
+
+**注意：conda主要用于创建Python虚拟环境，CANN工具包仍需通过离线安装包安装。**
+
+**步骤3.1：创建conda虚拟环境**
+```bash
+# 创建Python环境（CANN支持Python 3.7.x - 3.13.11）
+conda create -n cann_env python
+# 激活环境
+conda activate cann_env
+```
+
+**步骤3.2：配置昇腾conda官方源**
+```bash
+# 添加昇腾conda源
+conda config --add channels https://repo.huaweicloud.com/ascend/repos/conda
+```
+
+**步骤3.3：安装CANN包**
+```bash
+# 使用conda安装CANN工具包
+conda install ascend::cann-toolkit
+# 安装CANN ops包（根据芯片类型选择，如910、910b、310等）
+conda install ascend::cann-{芯片类型}-ops
+```
+
+#### 方法三：在线安装（yum方式 - CentOS/RHEL）
+
+**步骤3.1：配置华为官方源**
+```bash
+sudo curl https://repo.oepkgs.net/ascend/cann/ascend.repo -o /etc/yum.repos.d/ascend.repo && yum makecache
+```
+
+**步骤3.2：安装CANN包**
+```bash
+yum install -y Ascend-cann-toolkit
+yum install -y Ascend-cann-{芯片类型}-ops
+```
+
+### 第4步：环境变量配置
+
+**临时设置（仅当前终端生效）**
+```bash
+source /usr/local/Ascend/ascend-toolkit/set_env.sh
+```
+
+**永久设置（写入Shell配置文件）**
+```bash
+echo "source /usr/local/Ascend/ascend-toolkit/set_env.sh" >> ~/.bashrc
+```
+
+### 第5步：安装验证
+
+**使用Python验证ACL接口**
+```bash
+python3 -c "import acl;acl.init();acl.rt.set_device(0)"
+```
+**验证结果**
+- 如果执行成功，说明CANN Python接口正常工作
+- 如果执行失败，检查环境变量是否配置正确
+
+### 第6步：安装运行时依赖
+```bash
+pip3 install attrs cython numpy decorator sympy cffi pyyaml pathlib2 psutil protobuf==3.20.0 scipy requests absl-py --user
+pip3 install protobuf==3.20.0
+```
+
+## 注意事项
+
+1. **版本兼容性**：确保CANN版本与驱动版本匹配
+2. **安装顺序**：必须先安装Toolkit，再安装ops
+3. **环境变量**：安装后必须设置环境变量
+4. **权限问题**：某些操作可能需要root权限
+5. **依赖包**：确保所有必要的依赖包已安装
+
+## 故障排查
+
+如果安装过程中遇到问题：
+- 检查驱动版本是否与CANN版本兼容
+- 检查依赖包是否安装完整
+- 查看安装日志获取详细错误信息
+- 参考昇腾社区文档或寻求技术支持
+
+## 参考资料
+
+详细参考资料请查看 [references](./references/) 目录，包含：
+- [环境依赖安装指南](./references/env_dependence.md)：必需软件安装命令和验证方法