"""阶段1..K：从**已建好的题池**分批优化 skill 库（替代旧的边出题边更新）。 与旧 pipeline.py 的区别（用户 2026-08-21 指出的三个缺陷）： 1. 题目一次性建池（build_pool.py），分布可控、按格子分层； 2. 验证池**冻结不变** → 前后轮可比（旧版每轮题不同，库变好还是题变简单分不清）； 3. 每格子在验证池里有足够多的**不同**题 → "同类型 N 道验证"这个门槛才可能满足 （旧版每轮每格子只有 1-2 道，min_n=6 几乎永远不满足）。 流程： 基线：冻结验证池全量测一次（v0 分数） 每批：取 batch_size 道 train 题 → 每题 G 次 rollout（自适应） → 成/败双 prompt 归纳 → ≤3 条算子 → 四道闸 → 该格子验证子集验收（不涨分即拒）→ 入库 每轮末：冻结验证池全量再测 → 得到可比的进化曲线 用法： python -m evo2.optimize --pool data/pool_egoschema.json --run-name ego_B --batch 28 --rounds 3 python -m evo2.optimize --pool data/pool_egoschema.json --run-name ego_A_none --arm none """ import argparse import json import logging import os import random import sys import time from collections import Counter, defaultdict sys.path.insert(0, "/mnt/tokyo-ai/gst/EvoStream") sys.path.insert(0, "/mnt/tokyo-ai/gst/EvoStream/cons_memory") from concurrent.futures import ThreadPoolExecutor, as_completed from evo2.curator import build_prompt, catalog_of from evo2.gates import gate_all from evo2.pipeline import run_one_episode, stage_c_induce from evo2.real_testset import load as load_real from evo2.seed_lib import build_seed from evo2.skill import SkillLibrary from evo2.tracelog import TraceLogger, summarize logger = logging.getLogger(__name__) def eval_pool(questions, lib, executor_llm, tools_factory, cfg, tl=None, workers=8, tag="") -> dict: """在给定题集上评测（并发）。返回总体与分格子准确率。""" def _one(q): try: return q, run_one_episode(q, lib, executor_llm, tools_factory, cfg, tl=tl, meta={"phase": f"eval_{tag}"}) except Exception as e: logger.warning("评测失败: %s", e) return q, None by_cell, ok, n = defaultdict(lambda: [0, 0]), 0, 0 with ThreadPoolExecutor(max_workers=workers) as ex: for fut in as_completed([ex.submit(_one, q) for q in questions]): q, log = fut.result() if log is None: continue n += 1 c = bool(log.get("correct")) ok += c key = q.get("cell") or q.get("schema") or "all" by_cell[key][0] += c by_cell[key][1] += 1 return {"n": n, "acc": round(ok / max(1, n), 4), "per_cell": {k: f"{v[0]}/{v[1]}" for k, v in sorted(by_cell.items())}, "per_cell_acc": {k: round(v[0] / max(1, v[1]), 3) for k, v in sorted(by_cell.items())}} def accept_ops(ops, lib, val_by_cell, executor_llm, tools_factory, cfg, min_n=4, margin=0.0, tl=None, rd=0, workers=6): """入库门槛：新/改卡在**该格子验证子集**上不降分才收（同类型多道不同题）。""" accepted, rejected = [], [] for op in ops: card = op.get("card") or {} before_card = None if op.get("op") == "modify": cid = op.get("card_id") before_card = next((c for c in lib.cards if c["card_id"] == cid), None) if before_card is None: rejected.append((op, "modify 目标卡不存在")) continue card = {**before_card, **(op.get("changes") or {})} ok, why = gate_all(card, lib.cards, op.get("op", "add")) if not ok: rejected.append((op, why)) if tl: tl.log_skill_op(op, before_card, card, False, why, accepted=False, meta={"round": rd}) continue # 该卡覆盖的格子 → 取验证池里这些格子的题 pr = card.get("soft_type_prior") or {} sp, tp = pr.get("space") or [], pr.get("time") or [] sample = [] for cid_, rows in val_by_cell.items(): s, t = cid_.split("-") if (not sp or s in sp) and (not tp or t in tp): sample.extend(rows) if len(sample) < min_n: rejected.append((op, f"验证池该题型题数不足({len(sample)}<{min_n})")) if tl: tl.log_skill_op(op, before_card, card, True, f"验证池不足({len(sample)})", accepted=False, meta={"round": rd}) continue sample = sample[:max(min_n, min(len(sample), 8))] before = eval_pool(sample, lib, executor_llm, tools_factory, cfg, workers=workers, tag="gate_before")["acc"] cand = SkillLibrary(list(lib.cards), lib.version, lib.embed_fn) if op.get("op") == "modify": cand.cards = [card if c["card_id"] == card["card_id"] else c for c in cand.cards] else: cand.cards = [*cand.cards, card] cand.index_library() after = eval_pool(sample, cand, executor_llm, tools_factory, cfg, workers=workers, tag="gate_after")["acc"] passed = after >= before + margin (accepted if passed else rejected).append( (op, card, before, after) if passed else (op, f"验证不通过 {before:.3f}→{after:.3f}")) if tl: tl.log_skill_op(op, before_card, card, True, "", before, after, accepted=passed, meta={"round": rd, "n_val": len(sample)}) return accepted, rejected def main(): ap = argparse.ArgumentParser() ap.add_argument("--pool", required=True, help="合成题池：只用于训练") ap.add_argument("--test-videos", type=int, default=80, help="真题测试集用多少个视频（测试集=benchmark原始真题，全程不参与优化）") ap.add_argument("--run-name", required=True) ap.add_argument("--arm", default="evolve", choices=["evolve", "frozen", "none"], help="evolve=进化(主) | frozen=种子冻结 | none=无skill") ap.add_argument("--seed-mode", default="empty", choices=["empty", "minimal"]) ap.add_argument("--batch", type=int, default=28) ap.add_argument("--rounds", type=int, default=3) ap.add_argument("--g-mode", default="adaptive", choices=["1", "adaptive"]) ap.add_argument("--executor-ep", default="qwen38_pool") ap.add_argument("--curator-ep", default="qwen38_pool") ap.add_argument("--min-val", type=int, default=4) ap.add_argument("--workers", type=int, default=10) a = ap.parse_args() logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(levelname)s %(message)s") from infer.config import RunConfig from infer.llm_clients import embed_texts, make_client from infer.tools import ToolRegistry, TOOL_SPECS pool = json.load(open(a.pool)) ds = pool["dataset"] # 合成题：**全部**用于训练（含入库门槛的验证子集）；不再当测试集 train = pool["train"] + pool["frozen_val"] # 入库门槛用的验证子集仍取自合成题（同类型多道不同题），但与练习批次不重叠 gate_val = pool["frozen_val"] # 测试集 = benchmark 原始真题，全程不参与优化（用户 2026-08-21 定稿） test = load_real(ds, a.test_videos) logger.info("合成题(训练用) %d 道 [其中门槛验证子集 %d]；" "真题测试集 %d 道 / %d 视频", len(train), len(gate_val), len(test), len({q["video_id"] for q in test})) out_dir = f"/mnt/tokyo-ai/gst/EvoStream/runs/{a.run_name}" tl = TraceLogger(out_dir) cfg = RunConfig() cfg.executor = a.executor_ep executor_llm = make_client(a.executor_ep, temperature=0.0) curator_llm = make_client(a.curator_ep, temperature=0.5) vlm = make_client(cfg.vlm_tool, temperature=0.0) tools_factory = lambda mem: ToolRegistry(mem, cfg, vlm_client=vlm) # A档 none：完全不注入 skill；B档 evolve：空库起步；C档 frozen：种子不进化 seed = [] if a.arm == "none" else build_seed( "minimal" if (a.arm == "frozen" or a.seed_mode == "minimal") else "empty") lib = SkillLibrary(seed, version=0, embed_fn=embed_texts) lib.index_library() tl.save_library(lib, "v0_initial") val_by_cell = defaultdict(list) for q in gate_val: val_by_cell[q["cell"]].append(q) # ---- 基线：冻结验证池全量 ---- t0 = time.time() base = eval_pool(test, lib, executor_llm, tools_factory, cfg, tl=tl, workers=a.workers, tag="baseline") logger.info("基线(v0) **真题测试集** %d 题 准确率 %.1f%% 分组 %s", base["n"], base["acc"] * 100, base["per_cell"]) curve = [{"round": 0, "lib_size": len(lib.cards), "version": lib.version, **base}] tl.log_round(curve[-1]) if a.arm != "evolve": json.dump(curve, open(f"{out_dir}/curve.json", "w"), ensure_ascii=False, indent=1) logger.info("%s 档不进化，结束。留痕汇总: %s", a.arm, json.dumps(summarize(out_dir), ensure_ascii=False)) tl.close() return random.seed(0) pool_train = list(train) random.shuffle(pool_train) specs = TOOL_SPECS if isinstance(TOOL_SPECS, str) else \ json.dumps(TOOL_SPECS, ensure_ascii=False)[:3000] for rd in range(1, a.rounds + 1): batch = pool_train[(rd - 1) * a.batch: rd * a.batch] if not batch: logger.info("train 池已用尽，提前结束") break logger.info("=" * 70) logger.info("第 %d/%d 轮 批量 %d 题 库 v%d(%d张)", rd, a.rounds, len(batch), lib.version, len(lib.cards)) # 练习：同题 G 次（自适应） groups = {} def _run(q): logs = [run_one_episode(q, lib, executor_llm, tools_factory, cfg, tl=tl, meta={"round": rd, "phase": "practice", "rollout": 0})] if a.g_mode != "1" and not logs[0]["correct"]: for gi in range(1, 3): logs.append(run_one_episode(q, lib, executor_llm, tools_factory, cfg, tl=tl, meta={"round": rd, "phase": "practice", "rollout": gi})) if logs[-1]["correct"]: break return q, logs with ThreadPoolExecutor(max_workers=a.workers) as ex: for fut in as_completed([ex.submit(_run, q) for q in batch]): try: q, logs = fut.result() groups[q.get("probe_id")] = (q, logs) except Exception as e: logger.warning("练习失败: %s", e) first_acc = sum(1 for _, (q, ls) in groups.items() if ls[0]["correct"]) / max(1, len(groups)) logger.info("练习 %d 组，首轮准确率 %.1f%%", len(groups), first_acc * 100) ops = stage_c_induce(groups, lib, curator_llm, specs, tl=tl, rd=rd) accepted, rejected = accept_ops(ops, lib, val_by_cell, executor_llm, tools_factory, cfg, min_n=a.min_val, tl=tl, rd=rd, workers=max(4, a.workers // 2)) for item in rejected: logger.info(" 拒绝[%s] %s", item[0].get("op"), item[1]) for op, card, b, af in accepted: if op.get("op") == "modify": lib.cards = [card if c["card_id"] == card["card_id"] else c for c in lib.cards] else: lib.cards.append(card) logger.info(" 入库[%s] %s %.3f→%.3f", op.get("op"), card["card_id"], b, af) if accepted: lib.version += 1 lib.index_library() tl.save_library(lib, f"r{rd}_v{lib.version}") # 轮末：冻结验证池全量（可比曲线） ev = eval_pool(test, lib, executor_llm, tools_factory, cfg, tl=tl, workers=a.workers, tag=f"round{rd}") logger.info("第 %d 轮末 **真题测试集**准确率 %.1f%% (基线 %.1f%%) 分组 %s", rd, ev["acc"] * 100, base["acc"] * 100, ev["per_cell"]) curve.append({"round": rd, "lib_size": len(lib.cards), "version": lib.version, "n_ops": len(ops), "n_accepted": len(accepted), "practice_acc": round(first_acc, 4), **ev}) tl.log_round(curve[-1]) json.dump(curve, open(f"{out_dir}/curve.json", "w"), ensure_ascii=False, indent=1) logger.info("=" * 70) for c in curve: logger.info(" 轮%d 真题测试集 %.1f%% 库 %d 张 v%d", c["round"], c["acc"] * 100, c["lib_size"], c["version"]) logger.info("留痕汇总: %s", json.dumps(summarize(out_dir), ensure_ascii=False)) tl.close() if __name__ == "__main__": main()