"""ChronoText benchmark judging entry point. Rule-based scoring only — no LLM / API call needed. Usage: # Judge all models under infer_results/ python judge.py # Judge specific models python judge.py --models qwen3-vl-8b gemini-3.1-pro Outputs: Opensource/judge_results//results.jsonl """ from __future__ import annotations import argparse import concurrent.futures import json import sys import traceback from concurrent.futures import ThreadPoolExecutor from pathlib import Path import tqdm REPO_ROOT = Path(__file__).resolve().parent sys.path.insert(0, str(REPO_ROOT.parent)) from Opensource.judges import JUDGE_FUNCS # noqa: E402 from Opensource.utils.io import ResultWriter, get_image_path # noqa: E402 DEFAULT_DATA_FILE = REPO_ROOT / "data" / "Chronicles_OCR.jsonl" DEFAULT_INFER_DIR = REPO_ROOT / "infer_results" DEFAULT_JUDGE_DIR = REPO_ROOT / "judge_results" ANCIENT_FONTS = {"甲骨文", "金文", "篆书"} ALL_TASKS = ["字体分类", "字符提取", "字符检测", "单字识别"] def parse_args() -> argparse.Namespace: p = argparse.ArgumentParser(description="ChronoText rule-based judging") p.add_argument("--data_file", type=str, default=str(DEFAULT_DATA_FILE), help="benchmark jsonl 路径") p.add_argument("--infer_dir", type=str, default=str(DEFAULT_INFER_DIR), help="infer_results 目录") p.add_argument("--output_dir", type=str, default=str(DEFAULT_JUDGE_DIR), help="judge_results 目录") p.add_argument( "--models", type=str, nargs="*", default=None, help="只评分指定模型；不传则扫描 infer_dir 下所有子目录" ) p.add_argument("--max_workers", type=int, default=64) p.add_argument("--save_interval", type=int, default=1000) return p.parse_args() def load_gt_index(data_file: Path) -> dict[str, dict]: """加载 GT jsonl，按 image_path 建索引。""" index: dict[str, dict] = {} with open(data_file, "r", encoding="utf-8") as f: for line in f: line = line.strip() if not line: continue row = json.loads(line) key = get_image_path(row) if key: index[key] = row return index def tasks_for_row(gt_row: dict) -> list[str]: if str(gt_row.get("font_type", "")).strip() in ANCIENT_FONTS: return ALL_TASKS return ["字体分类", "字符提取"] def judge_one_row(infer_row: dict, gt_row: dict) -> dict: """对单条 infer 结果按对应 GT 评分。""" file_tasks = tasks_for_row(gt_row) # 把 GT 字段并入打分上下文 judge_ctx = dict(gt_row) judge_ctx["infer_results"] = infer_row.get("infer_results") or {} judge_results: dict = {} for task in file_tasks: infer_task = (infer_row.get("infer_results") or {}).get(task) if not isinstance(infer_task, dict): judge_results[task] = {"score": {"score": 0.0}, "error": "no_infer"} continue extract = infer_task.get("extract") if extract is None: judge_results[task] = {"score": {"score": 0.0}, "error": "no_extract"} continue try: score = JUDGE_FUNCS[task](extract, judge_ctx) judge_results[task] = {"score": score} except Exception as e: print(f" 任务 '{task}' 评分异常: {e}") judge_results[task] = {"score": 0.0, "error": str(e)} out = dict(infer_row) out["judge_results"] = judge_results out["font_type"] = gt_row.get("font_type", out.get("font_type", "")) out["annotation"] = gt_row.get("annotation", out.get("annotation", "")) return out def judge_one_model( model_tag: str, infer_file: Path, output_file: Path, gt_index: dict[str, dict], max_workers: int, save_interval: int, ) -> tuple[int, int, int]: """对单个模型的 infer 结果跑评分。返回 (total, judged, missing_in_gt)。""" infer_rows: list[dict] = [] with open(infer_file, "r", encoding="utf-8") as f: for line in f: line = line.strip() if not line: continue infer_rows.append(json.loads(line)) output_file.parent.mkdir(parents=True, exist_ok=True) # 默认覆盖：不读历史 judge 结果 writer = ResultWriter(str(output_file), processed={}, save_interval=save_interval) pairs: list[tuple[dict, dict]] = [] missing = 0 for r in infer_rows: key = get_image_path(r) gt = gt_index.get(key) if gt is None: missing += 1 continue pairs.append((r, gt)) if not pairs: print(f" [{model_tag}] 无可评分样本") writer.finalize() return len(infer_rows), 0, missing judged = 0 with ThreadPoolExecutor(max_workers=max_workers) as ex: futures = {ex.submit(judge_one_row, ir, gt): ir for ir, gt in pairs} pbar = tqdm.tqdm(total=len(futures), desc=f"judge[{model_tag}]") for fut in concurrent.futures.as_completed(futures): try: result = fut.result() writer.update_and_save(result) judged += 1 except Exception as e: print(f"\n评分失败: {e}") traceback.print_exc() pbar.update(1) pbar.close() writer.finalize() return len(infer_rows), judged, missing def main() -> None: args = parse_args() data_file = Path(args.data_file).resolve() if not data_file.is_file(): raise SystemExit(f"benchmark 文件不存在: {data_file}") infer_dir = Path(args.infer_dir).resolve() output_dir = Path(args.output_dir).resolve() if not infer_dir.is_dir(): raise SystemExit(f"infer 目录不存在: {infer_dir}") print("=" * 72) print("ChronoText Judging") print("=" * 72) print(f"data_file : {data_file}") print(f"infer_dir : {infer_dir}") print(f"output_dir : {output_dir}") # 加载 GT gt_index = load_gt_index(data_file) print(f"GT 样本数 : {len(gt_index)}") # 模型清单 if args.models: model_tags = args.models else: model_tags = sorted(d.name for d in infer_dir.iterdir() if d.is_dir() and not d.name.startswith(".")) print(f"模型数量 : {len(model_tags)} -> {model_tags}\n") summary: list[tuple[str, int, int, int]] = [] for tag in model_tags: infer_file = infer_dir / tag / "results.jsonl" if not infer_file.is_file(): print(f"[{tag}] 跳过：找不到 {infer_file}") continue output_file = output_dir / tag / "results.jsonl" total, judged, missing = judge_one_model( tag, infer_file, output_file, gt_index, max_workers=args.max_workers, save_interval=args.save_interval, ) summary.append((tag, total, judged, missing)) print(f"[{tag}] total={total}, judged={judged}, missing_in_gt={missing}") print("\n" + "=" * 72) print("Summary") print("=" * 72) for tag, total, judged, missing in summary: print(f" {tag:40s} total={total:6d} judged={judged:6d} missing={missing:6d}") print(f"\n✅ judge 全部完成，结果在 {output_dir}") if __name__ == "__main__": main()