Add files using upload-large-folder tool

197d46b verified 2 months ago

13.5 kB

"""阶段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()

	"""阶段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()