@hupan56/wlkj 3.3.13 → 3.3.14

package/templates/qoder/scripts/validation/eval/recall_flywheel.py

@@ -1,148 +0,0 @@
-"""recall_flywheel.py — FW1 检索类召回飞轮（非循环 held-out gold）。
-
-T1.0 的召回 R~80% 用 ILIKE-gold 是循环的（改非ILIKE检索提不了R）。本飞轮用**非循环 gold**：
-held-out = 图邻居中【不含主题关键词】的实体（只有 graph/semantic 检索能找到，ILIKE 找不到）。
-量各检索策略对此 gold 的召回 → 改检索（加图扩展→语义）→ 重量 → 直到 ≥0.85。
-纯检索质量（无 LLM），快，可反复转飞轮。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/recall_flywheel.py
-"""
-import os
-import sys
-import json
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text, bindparam  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-THEMES = ["考勤", "排班", "加班", "车辆", "报警", "保险", "能耗", "预算", "导出", "审批"]
-TARGET = 0.85
-
-
-def _q(s, sql, params=None):
-    try:
-        return s.execute(text(sql), params or {}).fetchall()
-    except Exception:
-        try:
-            s.rollback()
-        except Exception:
-            pass
-        return []
-
-
-def ilike_ids(s, theme, limit):
-    """name/cn 关键词命中（T1.0 现状检索口径）。"""
-    return [r[0] for r in _q(s,
-        "SELECT id FROM entities WHERE (cn ILIKE :p OR canonical ILIKE :p) LIMIT :n",
-        {"p": f"%{theme}%", "n": limit})]
-
-
-def heldout_gold(s, theme, max_n=25):
-    """非循环 gold：cn_desc(描述)提及主题 但 name/cn 不含 = 只有描述/语义/图能找到，
-    关键词搜 name/cn 找不到。cn_desc 与 name/cn 是独立信号 → 公平。"""
-    rows = _q(s,
-        "SELECT id FROM entities WHERE cn_desc ILIKE :p "
-        "AND NOT (canonical ILIKE :p OR cn ILIKE :p) LIMIT :n",
-        {"p": f"%{theme}%", "n": max_n * 3})
-    return [r[0] for r in rows][:max_n]
-
-
-def strat_ilike(s, theme, limit=80):
-    """基线：name/cn 关键词（T1.0 现状）。"""
-    return set(ilike_ids(s, theme, limit))
-
-
-def strat_ilike_desc(s, theme, limit=80):
-    """杠杆1：name/cn + cn_desc（多搜描述列，廉价高杠杆）。"""
-    return set(r[0] for r in _q(s,
-        "SELECT id FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p OR cn_desc ILIKE :p) LIMIT :n",
-        {"p": f"%{theme}%", "n": limit}))
-
-
-def strat_ilike_graph(s, theme, seed_limit=25):
-    """杠杆2：name/cn 种子 + 1跳图扩展。"""
-    seeds = ilike_ids(s, theme, seed_limit)
-    res = set(seeds)
-    if seeds:
-        stmt = text(
-            "SELECT DISTINCT e.to_id FROM edges e WHERE e.from_id IN :ids"
-        ).bindparams(bindparam("ids", expanding=True))
-        try:
-            for r in s.execute(stmt, {"ids": seeds}).fetchall():
-                if r[0]:
-                    res.add(r[0])
-        except Exception:
-            try:
-                s.rollback()
-            except Exception:
-                pass
-    return res
-
-
-def recall(strategy_ids, gold):
-    if not gold:
-        return None
-    return len(set(gold) & strategy_ids) / len(gold)
-
-
-def run(verbose=True):
-    s = SessionLocal()
-    per_theme = []
-    accA = accB = accC = 0.0
-    cnt = 0
-    for th in THEMES:
-        gold = heldout_gold(s, th, 25)
-        if not gold:
-            continue
-        A = strat_ilike(s, th, 80)
-        B = strat_ilike_desc(s, th, 80)
-        C = strat_ilike_graph(s, th, 25)
-        rA, rB, rC = recall(A, gold), recall(B, gold), recall(C, gold)
-        per_theme.append({"theme": th, "gold_n": len(gold),
-                          "ilike": round(rA, 3), "ilike_desc": round(rB, 3), "ilike_graph": round(rC, 3)})
-        accA += rA
-        accB += rB
-        accC += rC
-        cnt += 1
-        if verbose:
-            print("  %s: gold=%d | ILIKE=%.2f | +desc=%.2f | +图=%.2f" % (th, len(gold), rA, rB, rC))
-    s.close()
-    n = cnt or 1
-    return {"per_theme": per_theme, "n_themes": cnt,
-            "ilike": round(accA / n, 3), "ilike_desc": round(accB / n, 3), "ilike_graph": round(accC / n, 3),
-            "desc_gain_pp": round((accB - accA) / n * 100, 1),
-            "graph_gain_pp": round((accC - accA) / n * 100, 1),
-            "target": TARGET}
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("\n## FW1 召回飞轮（held-out = cn_desc 提及但 name/cn 不含，非循环独立 gold）")
-    print("| 检索策略 | 召回 R | 达标(≥85%%) |")
-    print("|---|---|---|")
-    print("| ILIKE name/cn（T1.0 现状） | %.1f%% | %s |" % (r["ilike"] * 100, "✓" if r["ilike"] >= TARGET else "✗"))
-    print("| ILIKE +cn_desc（杠杆1 廉价） | %.1f%% | %s |" % (r["ilike_desc"] * 100, "✓" if r["ilike_desc"] >= TARGET else "✗"))
-    print("| ILIKE +图扩展（杠杆2） | %.1f%% | %s |" % (r["ilike_graph"] * 100, "✓" if r["ilike_graph"] >= TARGET else "✗"))
-    print("| +cn_desc 增益 | %+.1fpp | — |" % r["desc_gain_pp"])
-    print("| +图扩展 增益 | %+.1fpp | — |" % r["graph_gain_pp"])
-    best = max(r["ilike_desc"], r["ilike_graph"])
-    met = best >= TARGET
-    winner = "+cn_desc" if r["ilike_desc"] >= r["ilike_graph"] else "+图扩展"
-    print("\n飞轮状态: 最佳策略(%s)召回 %.1f%% %s 85%% 目标。%s" % (
-        winner, best * 100, "达标" if met else "未达",
-        "→ 胜出杠杆该接进 wl-search 检索；召回飞轮此轮达标，转 FW2" if met
-        else "→ 下轮：组合杠杆(+desc+图) / 语义 rag_search / 提种子数，继续转"))
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/validation/eval/robustness_flywheel.py

@@ -1,139 +0,0 @@
-"""robustness_flywheel.py — FW7 鲁棒性飞轮（§1.2 ⑨ 歧义/对抗输入下准确性）。
-
-两维鲁棒性：
-  - 歧义处理：「保险」在 ICS 既指车险(正确域)又指社保(养老/医疗/失业，KG 也有)。
-    bare 字面取 → 车险/社保混；+工作流(歧义提炼→车辆保险) → 车险精确率升。
-  - 对抗拒答：假功能「火星人登录」「时间穿越」该拒(说不存在)，不该编造实体。
-    bare 可能编造；+工作流(只列真实检索结果) → 拒答。
-飞轮量→改(歧义提炼 prompt / 只信检索)→重量→达标。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/robustness_flywheel.py
-"""
-import os
-import re
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODEL = "qwen-turbo"
-# 域分类：社保词 vs 车险词
-_SHEBAO = ["养老", "医疗", "失业", "工伤", "生育", "社保", "公积金"]
-_CHEXIAN = ["车", "vehicle", "交强", "商业险", "承保", "理赔", "保单"]
-
-
-def chat(prompt, max_tokens=400, timeout=80):
-    body = json.dumps({"model": MODEL,
-        "messages": [{"role": "system", "content": "你是车辆物联网系统(ICS)的代码/业务知识助手。只回答真实存在的对象。"},
-                     {"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    for a in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if a < 2: time.sleep(1.0*(a+1))
-            else: return f"[ERR {repr(e)[:50]}]"
-
-
-def _q(s, sql, p=None):
-    try: return s.execute(text(sql), p or {}).fetchall()
-    except Exception:
-        try: s.rollback()
-        except Exception: pass
-        return []
-
-
-def classify_line(line):
-    """行 → 车险 / 社保 / 其他。"""
-    low = line
-    if any(w in low for w in _SHEBAO): return "shebao"
-    if any(w in low for w in _CHEXIAN): return "chexian"
-    return "other"
-
-
-def ambiguity_run():
-    """「保险」查询 → 车险精确率（正确域占比）。bare vs +歧义提炼 scaffold。"""
-    # KG 里 保险 的真实体（车险+社保混）
-    s = SessionLocal()
-    rows = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE '%保险%' OR cn ILIKE '%保险%') LIMIT 30")
-    s.close()
-    kg_ctx = "\n".join("%s (%s)" % (c, n) for c, n in rows if c)
-
-    bare_p = ("找出 ICS 系统里和「保险」相关的具体对象（表/类/字段/接口），"
-              "逐行列出确信真实存在的名称，勿编造。")
-    scaff_p = ("找出 ICS 系统（车辆物联网）里和「保险」相关的具体对象。\n"
-               "⚠️ 歧义提炼：本系统是【车辆物联网】，'保险' 指【车辆保险/交强险/商业险/承保理赔】，"
-               "**不是社保（养老/医疗/失业）**。请只列车辆保险相关，排除社保。\n"
-               "知识图谱检索到的实体：\n%s\n请逐行列出【车辆保险】相关名称，勿列社保，勿编造。" % kg_ctx)
-
-    def chexian_precision(ans):
-        cls = [classify_line(l) for l in ans.splitlines() if l.strip() and len(l.strip()) <= 60]
-        cx = cls.count("chexian"); sb = cls.count("shebao")
-        tot = cx + sb
-        return round(cx / tot, 3) if tot else 0.0, cx, sb
-
-    b = chat(bare_p); f = chat(scaff_p)
-    bp, bcx, bsb = chexian_precision(b)
-    fp, fcx, fsb = chexian_precision(f)
-    return {"bare_chexian_precision": bp, "bare_chexian": bcx, "bare_shebao": bsb,
-            "scaffold_chexian_precision": fp, "scaffold_chexian": fcx, "scaffold_shebao": fsb}
-
-
-def adversarial_run():
-    """假功能查询 → 拒答率（说不存在 vs 编造）。"""
-    FAKES = ["火星人指纹登录", "时间穿越审批", "心灵感应派单"]
-    out = []
-    for fake in FAKES:
-        bare_p = f"为「{fake}」功能，逐行列出 ICS 系统里需修改的代码文件/类/方法名，确信真实存在的。"
-        scaff_p = (f"为「{fake}」功能，逐行列出需修改的代码实体。\n"
-                   f"⚠️ 若该功能在系统里不存在（知识图谱无相关实体），直接说'此功能不存在'，"
-                   f"不要编造任何名称。")
-        b = chat(bare_p); f = chat(scaff_p)
-        # 拒答 = 含"不存在"/"无"/"没找到" 且 不含具体编造的代码名(CamelCase/下划线标识符)
-        def refused(ans):
-            has_no = any(w in ans for w in ["不存在", "没有", "未找到", "无此", "找不到", "不在系统"])
-            has_fab = bool(re.search(r'[A-Za-z_][\w]{4,}', ans)) and not has_no
-            return has_no and not has_fab
-        out.append({"fake": fake, "bare_refused": refused(b), "scaffold_refused": refused(f),
-                    "bare_fab": bool(re.search(r'[A-Za-z_][\w]{4,}', b)), "scaffold_fab": bool(re.search(r'[A-Za-z_][\w]{4,}', f))})
-    n = len(FAKES)
-    return {"items": out,
-            "bare_refuse_rate": round(sum(1 for x in out if x["bare_refused"]) / n, 3),
-            "scaffold_refuse_rate": round(sum(1 for x in out if x["scaffold_refused"]) / n, 3)}
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    amb = ambiguity_run()
-    adv = adversarial_run()
-    r = {"ambiguity": amb, "adversarial": adv}
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("## FW7 鲁棒性飞轮（歧义/对抗）")
-    print("【歧义】「保险」车险精确率（正确域占比，越高越好）：")
-    print("  bare(字面):     %.0f%% (车险%d / 社保%d)" % (amb["bare_chexian_precision"]*100, amb["bare_chexian"], amb["bare_shebao"]))
-    print("  +歧义提炼:      %.0f%% (车险%d / 社保%d)" % (amb["scaffold_chexian_precision"]*100, amb["scaffold_chexian"], amb["scaffold_shebao"]))
-    print("【对抗】假功能拒答率（说不存在不编造，越高越好）：")
-    print("  bare:     %.0f%%" % (adv["bare_refuse_rate"]*100))
-    print("  +拒答铁律: %.0f%%" % (adv["scaffold_refuse_rate"]*100))
-    print("\n达标? 歧义车险精确率 +对抗拒答率 越高越好；不达标续转(更强歧义词表/硬拒答 prompt)。")
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/validation/eval/speed_accuracy_flywheel.py

@@ -1,188 +0,0 @@
-"""speed_accuracy_flywheel.py — FW6 又快又准对齐飞轮（准确性 × 速度 × token Pareto）。
-
-GOAL=又快又准。之前只测"准"(P/R/完整性/路由),没测"快"(latency)。本尺子对齐测：
-  - 准确性：grounding 精度 P(反幻觉) + 召回 R
-  - 速度：latency P50/P95（API 代理真测 wall-clock）
-  - token：prompt+completion total
-跨 {weak/mid/strong} × {bare/scaffold}, 搜 wl-search 任务(端到端: 检索+LLM)。
-找 Pareto 最优档（够准的最快最省 token 配置）→ 卖点"弱模型+工作流又快又准"的速度证据。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/speed_accuracy_flywheel.py
-"""
-import os
-import re
-import sys
-import json
-import time
-import statistics
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODELS = {"weak": "qwen-turbo", "mid": "qwen-plus", "strong": "qwen-max"}
-THEMES = ["考勤", "排班", "加班", "车辆", "保险"]  # 5 主题(K=5 量 latency)
-RETRIEVE_K = 45  # FW1 已证 K=45 达标
-ACC_TARGET_P = 0.85  # 准确性目标（精度/召回）
-_LINE_CLEAN = re.compile(r"^[\-\*\d\.\)、\s]+")
-_CODE_TOK = re.compile(r"[A-Za-z_][\w./\-:]{2,}")
-
-
-def chat_timed(model, prompt, max_tokens=500, timeout=90):
-    """返回 (text, total_tokens, latency_ms)。"""
-    body = json.dumps({"model": model,
-        "messages": [{"role": "system", "content": "你是车辆物联网系统(ICS)的代码/业务知识助手。只回答真实存在的对象，绝不编造。"},
-                     {"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    t0 = time.time()
-    for attempt in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            d = json.loads(urllib.request.urlopen(req, timeout=timeout).read())
-            return d["choices"][0]["message"]["content"], int(d.get("usage", {}).get("total_tokens", 0)), round((time.time() - t0) * 1000)
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if attempt < 2:
-                time.sleep(1.0 * (attempt + 1))
-            else:
-                return f"[ERR {repr(e)[:50]}]", 0, round((time.time() - t0) * 1000)
-
-
-def _q(s, sql, params=None):
-    try:
-        return s.execute(text(sql), params or {}).fetchall()
-    except Exception:
-        try:
-            s.rollback()
-        except Exception:
-            pass
-        return []
-
-
-def load_universe_and_gold():
-    s = SessionLocal()
-    rows = _q(s, "SELECT canonical, cn FROM entities WHERE canonical IS NOT NULL")
-    UNI = set()
-    for c, n in rows:
-        if c: UNI.add(c.strip())
-        if n: UNI.add(n.strip())
-    GOLD = {}
-    for th in THEMES:
-        rs = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) LIMIT 40", {"p": f"%{th}%"})
-        GOLD[th] = [(c, n) for c, n in rs if c]
-    s.close()
-    return UNI, GOLD
-
-
-def retrieve(theme, k=RETRIEVE_K):
-    s = SessionLocal()
-    rs = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) LIMIT :k",
-            {"p": f"%{theme}%", "k": k})
-    s.close()
-    return [(c, n) for c, n in rs if c]
-
-
-def score(ans, gold, UNI):
-    cands = set()
-    for line in ans.splitlines():
-        line = _LINE_CLEAN.sub("", line).strip()
-        if line and len(line) <= 60:
-            m = _CODE_TOK.findall(line)
-            if m:
-                cands.add(m[0])
-    real = {x for x in cands if x in UNI}
-    precision = (len(real) / len(cands)) if cands else 0.0
-    hit = sum(1 for c, n in gold if (c and c in ans) or (n and n in ans))
-    recall = (hit / len(gold)) if gold else 0.0
-    return precision, recall
-
-
-def prompt_bare(theme):
-    return (f"在我们的车辆物联网系统(ICS)里，找出和「{theme}」相关的具体对象（表/Java类/接口/按钮等）。\n"
-            f"逐行列出你确信真实存在的名称，每行一个，不要编造。")
-
-
-def prompt_scaffold(theme, ctx):
-    return (f"在我们的车辆物联网系统(ICS)里，找出和「{theme}」相关的具体对象。\n"
-            f"知识图谱检索到相关实体（均真实存在）：\n{ctx}\n\n"
-            f"请把检索结果里的实体【尽量全部逐行列出】，每行一个，直接用名称，勿筛选/省略，勿编造。")
-
-
-def pctile(vals, p):
-    if not vals:
-        return 0
-    vals = sorted(vals)
-    k = max(0, min(len(vals) - 1, int(round((p / 100.0) * (len(vals) - 1)))))
-    return vals[k]
-
-
-def run_cell(model, mode, UNI, GOLD):
-    """跑 5 主题，返回 (P, R, p50_lat, p95_lat, avg_tok)。"""
-    Ps, Rs, lats, toks = [], [], [], []
-    for th in THEMES:
-        gold = GOLD[th]
-        if mode == "bare":
-            p = prompt_bare(th)
-        else:
-            ents = retrieve(th)
-            ctx = "\n".join("%s (%s)" % (c, n) for c, n in ents)
-            p = prompt_scaffold(th, ctx)
-        ans, tok, lat = chat_timed(model, p)
-        prec, rec = score(ans, gold, UNI)
-        Ps.append(prec); Rs.append(rec); lats.append(lat); toks.append(tok)
-    n = len(THEMES) or 1
-    return {"P": round(sum(Ps)/n, 3), "R": round(sum(Rs)/n, 3),
-            "p50_lat": pctile(lats, 50), "p95_lat": pctile(lats, 95),
-            "avg_tok": round(sum(toks)/n)}
-
-
-def run():
-    UNI, GOLD = load_universe_and_gold()
-    cells = {}
-    for tier, model in MODELS.items():
-        for mode in ("bare", "scaffold"):
-            c = run_cell(model, mode, UNI, GOLD)
-            cells[f"{tier}/{mode}"] = c
-            print("  %s/%s: P=%.2f R=%.2f p50=%dms p95=%dms tok=%d" % (
-                tier, mode, c["P"], c["R"], c["p50_lat"], c["p95_lat"], c["avg_tok"]))
-    return {"cells": cells, "acc_target": ACC_TARGET_P}
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    c = r["cells"]
-    print("\n## FW6 又快又准对齐矩阵（准确性 P/R × 速度 P50/P95 × token）")
-    print("| 档 | 准 P | 全 R | 速 P50 | 速 P95 | token | 准达标? |")
-    print("|---|---|---|---|---|---|---|")
-    for tier in MODELS:
-        for mode in ("bare", "scaffold"):
-            x = c[f"{tier}/{mode}"]
-            acc_ok = x["P"] >= ACC_TARGET_P and x["R"] >= ACC_TARGET_P
-            print("| %s/%s | %.2f | %.2f | %dms | %dms | %d | %s |" % (
-                tier, mode, x["P"], x["R"], x["p50_lat"], x["p95_lat"], x["avg_tok"], "✓" if acc_ok else "✗"))
-    # Pareto：够准的档里最快最省
-    qual = [(k, v) for k, v in c.items() if v["P"] >= ACC_TARGET_P and v["R"] >= ACC_TARGET_P]
-    print("\n准达标的档:", [k for k, _ in qual] or "无")
-    if qual:
-        knee = min(qual, key=lambda kv: kv[1]["p50_lat"] + kv[1]["avg_tok"] * 0.5)
-        print("Pareto 最优档（准达标里 最快+最省）: %s → P%.2f R%.2f p50=%dms tok=%d" % (
-            knee[0], knee[1]["P"], knee[1]["R"], knee[1]["p50_lat"], knee[1]["avg_tok"]))
-        print("→ 卖点速度证据：弱模型+工作流既准又快又省，无需上强模型（强模型更慢更贵不更准）。")
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/validation/eval/task_flywheel.py

@@ -1,124 +0,0 @@
-"""task_flywheel.py — FW4 wl-task 操作类动作路由飞轮。
-
-操作类维度(SPEC §1.1)：成功率(操作成功/总试)/正确性(操作对对象)。
-可代理的是【动作路由正确性】：自然语言任务短语 → 正确动作(create/list/show/start/finish/...)。
-bare("判断该走哪个动作") vs +wl-task dispatcher 表 → 路由准确率。
-成功率(脚本真成功)/归属正确性(不改错队友任务)=执行流→🖥️。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/task_flywheel.py
-"""
-import os
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODELS = {"weak": "qwen-turbo", "mid": "qwen-plus", "strong": "qwen-max"}
-ACTIONS = ["create", "list", "show", "start", "finish", "archive", "rank", "plan", "sync", "zentao"]
-
-# gold 任务短语 → 正确动作（含语义类：无动作词靠意图）
-GOLD = [
-    ("建任务 报价单导出", "create"),
-    ("把R-231报价单导出拆成任务", "create"),
-    ("看任务", "list"),
-    ("接下来干啥", "list"),
-    ("看下登录页怎么样了", "show"),
-    ("开始做登录", "start"),
-    ("做完了", "finish"),
-    ("今天干了3小时", "zentao"),
-    ("归档 老需求", "archive"),
-    ("排优先级", "rank"),
-    ("排期 甘特图", "plan"),
-    ("PRD发禅道", "zentao"),
-    ("同步到禅道", "sync"),
-]
-
-SPEC_OLD = "按用户这句话的意图，判断 /wl-task 该走哪个动作（建/看/启动/完成/归档/排优先级/排期/同步/禅道）。"
-SPEC_NEW = """按 $ARGUMENTS 第一个词/意图确定性选动作（按表查，不要"判断"）：
-- create / "建任务" / "拆成任务" / "把XX建成任务" → create
-- list / "看任务" / "有哪些任务" / "接下来干啥" / "现在要做哪些" → list
-- show / "看下XX" / "XX怎么样了" → show
-- start / "开始做" / "启动XX" → start
-- finish / "做完了" / "完成了" → finish
-- archive / "归档" → archive
-- rank / "排优先级" / "排一下" → rank
-- plan / "排期" / "甘特图" / "排个日期" → plan
-- sync / "同步到禅道" → sync
-- zentao / "PRD发禅道" / "记工时" / "改任务状态" / "今天干了X小时" → zentao"""
-
-
-def chat(model, prompt, max_tokens=30, timeout=60):
-    body = json.dumps({"model": model,
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    for attempt in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"].strip()
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if attempt < 2:
-                time.sleep(1.0 * (attempt + 1))
-            else:
-                return f"[ERR {repr(e)[:50]}]"
-
-
-def _norm(ans):
-    a = ans.lower()
-    for act in ACTIONS:
-        if act in a:
-            return act
-    return "__none__"
-
-
-def run_spec(model, spec, label):
-    correct = 0
-    for query, gold in GOLD:
-        prompt = (f"你是任务管理命令 /wl-task 的路由器。严格按【路由规则】判断这条操作走哪个动作。\n\n"
-                  f"【路由规则】\n{spec}\n\n【操作】{query}\n\n"
-                  f"只输出一个动作名，从这些里选: {', '.join(ACTIONS)}。不要解释。")
-        got = _norm(chat(model, prompt))
-        ok = (got == gold)
-        correct += int(ok)
-        print("    [%s] %-22s gold=%-8s got=%-8s %s" % (label, query[:22], gold, got, "✓" if ok else "✗"))
-    return round(correct / len(GOLD), 3)
-
-
-def run():
-    rep = {"models": MODELS, "n": len(GOLD), "matrix": {}}
-    for tier, model in MODELS.items():
-        old = run_spec(model, SPEC_OLD, "old")
-        new = run_spec(model, SPEC_NEW, "new")
-        rep["matrix"][tier] = {"old_acc": old, "new_acc": new, "gain_pp": round((new - old) * 100, 1)}
-        print("  >> %s(%s): old=%.1f%% new=%.1f%% gain=%+.1fpp" % (tier, model, old*100, new*100, (new-old)*100))
-    return rep
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    m = r["matrix"]
-    print("\n## FW4 wl-task 操作类动作路由飞轮（选对动作准确率）")
-    print("| 模型档 | 旧'判断意图' | +dispatcher 表 | 增益 |")
-    print("|---|---|---|---|")
-    for t in MODELS:
-        c = m[t]
-        print("| %s(%s) | %.1f%% | %.1f%% | %+.1fpp |" % (t, MODELS[t], c["old_acc"]*100, c["new_acc"]*100, c["gain_pp"]))
-    print("\n成功率(脚本真成功)/归属正确性(不改错队友任务) = 执行流维度 → 🖥️ 宿主 wl-task 真跑")
-
-
-if __name__ == "__main__":
-    main()