Upload folder using huggingface_hub

eval/README.md

@@ -0,0 +1,180 @@
+# Chronicles-OCR Benchmark
+
+A multi-task benchmark for vision-language models on **Chinese historical script OCR**, covering all seven canonical scripts of Chinese characters: Oracle Bone (甲骨文), Bronze Script (金文), Seal Script (篆书), Clerical Script (隶书), Regular Script (楷书), Running Script (行书), Cursive Script (草书).
+
+| Group   | Scripts                                                            | Tasks                                             |
+| ------- | ------------------------------------------------------------------ | ------------------------------------------------- |
+| Ancient | Oracle Bone / Bronze Script / Seal Script                          | Spotting · Recognition · Parsing · Classification |
+| Modern  | Clerical Script / Regular Script / Running Script / Cursive Script | Parsing · Classification                          |
+
+The four tasks:
+
+| Task                                       | Short Name     | Metric                | Description                                                                |
+| ------------------------------------------ | -------------- | --------------------- | -------------------------------------------------------------------------- |
+| Cross-period Character Spotting            | Spotting       | F1 @ IoU > 0.75       | Detect bounding boxes and identify the modern character for each box       |
+| Fine-grained Archaic Character Recognition | Recognition    | Exact-match Accuracy  | Identify the modern character inside a red bounding box drawn on the image |
+| Ancient Text Parsing                       | Parsing        | 1 − NED (Levenshtein) | Read all characters in reading order; `[UNK]` is filtered before scoring   |
+| Script Classification                      | Classification | Accuracy              | Classify the image into one of the seven canonical scripts                 |
+
+All scoring is **rule-based** — no LLM judge is needed.
+
+> Note: the Spotting task internally also reports a Detection F1 (bbox-only, IoU > 0.75 without character matching) as a diagnostic; the headline Spotting score requires both IoU and character match.
+
+---
+
+## 1. Setup
+
+```bash
+git clone <this-repo>
+cd ChronoText/Opensource
+pip install -r requirements.txt
+# Optional: only if you plan to use --api_type local_vllm
+pip install vllm
+```
+
+## 2. Download benchmark data
+
+The dataset (jsonl + images) is released as a single archive. Place the files under `Opensource/data/`:
+
+```
+Opensource/data/
+├── Chronicles_OCR.jsonl
+└── images/
+    ├── 甲骨文/...   # Oracle Bone
+    ├── 金文/...     # Bronze Script
+    ├── 篆书/...     # Seal Script
+    ├── 隶书/...     # Clerical Script
+    ├── 楷书/...     # Regular Script
+    ├── 行书/...     # Running Script
+    └── 草书/...     # Cursive Script
+```
+
+Each line of the jsonl looks like:
+
+```json
+{
+  "image_path": "images/甲骨文/abcdef0123.jpg",
+  "font_type": "甲骨文",
+  "annotation": "...",
+  "spotting": [{"bbox": {"x1":..,"y1":..,"x2":..,"y2":..}, "modern_char": ".."}, ...],
+  "width": 800,
+  "height": 600
+}
+```
+
+`spotting` / `width` / `height` only exist for the three ancient scripts; modern scripts only carry `image_path`, `font_type`, and `annotation`.
+
+## 3. Inference
+
+Three backends are supported via `--api_type`:
+
+### (a) `openai_compat` — any OpenAI-compatible HTTP service
+
+Works with locally-served models (`vllm serve`, `sglang`, `lmdeploy`) **or** public APIs that speak the OpenAI Chat Completions protocol (OpenAI, Gemini OpenAI-compat, Claude OpenAI-compat, Together, …).
+
+```bash
+python infer.py \
+    --api_type openai_compat \
+    --model_name Qwen2.5-VL-7B-Instruct \
+    --base_url http://127.0.0.1:8000/v1 \
+    --api_key EMPTY \
+    --max_workers 64
+```
+
+### (b) `local_vllm` — in-process vLLM, give it a model path
+
+No need to start a server first. The script loads the checkpoint directly with `vllm.LLM`.
+
+```bash
+python infer.py \
+    --api_type local_vllm \
+    --model_path /path/to/Qwen2.5-VL-7B-Instruct \
+    --tensor_parallel_size 1 \
+    --max_model_len 32768
+```
+
+### Output
+
+Each run writes one jsonl file:
+
+```
+Opensource/infer_results/<model_tag>/results.jsonl
+```
+
+`<model_tag>` defaults to `--model_name` / basename of `--model_path` / `--api_name`. You can override it with `--output_tag`.
+
+## 4. Judging
+
+```bash
+# All models under infer_results/
+python judge.py
+
+# Specific models
+python judge.py --models Qwen2.5-VL-7B-Instruct gemini-3.1-pro
+```
+
+Outputs to `Opensource/judge_results/<model_tag>/results.jsonl`. The judge step is purely rule-based and **always overwrites** previous output (it is very fast).
+
+## 5. Summary report
+
+```bash
+python summarize.py
+# → Opensource/judge_results/results_analysis.xlsx
+```
+
+The workbook has two sheets, displayed in the canonical task order **Spotting · Recognition · Parsing · Classification**:
+
+- **Per-group summary** — per-model averages aggregated by Ancient / Modern groups
+- **Per-script breakdown** — per-model averages broken down by each of the seven scripts
+
+Scores are scaled `×100` and shown to 1 decimal (e.g. `87.3` means 0.873).
+
+---
+
+## 6. End-to-end example
+
+```bash
+# 1. Run inference
+python infer.py --api_type openai_compat \
+    --model_name Qwen2.5-VL-7B-Instruct \
+    --base_url http://127.0.0.1:8000/v1
+
+# 2. Score
+python judge.py
+
+# 3. Aggregate to Excel
+python summarize.py
+```
+
+---
+
+## 7. Repo layout
+
+```
+Opensource/
+├── README.md / README_zh.md
+├── requirements.txt
+├── data/                            # ← download benchmark data here
+├── apis/
+│   ├── base.py                      # APIBase
+│   ├── openai_compat.py             # OpenAI-compatible client
+│   ├── local_vllm.py                # in-process vLLM
+├── prompts/
+│   ├── spotting.py                  # Cross-period Character Spotting
+│   ├── referring.py                 # Fine-grained Archaic Character Recognition (red-box rendering)
+│   ├── extract_text.py              # Ancient Text Parsing
+│   └── classify.py                  # Script Classification
+├── judges/
+│   ├── spotting.py
+│   ├── referring.py
+│   ├── extract_text.py
+│   └── classify.py
+├── utils/
+│   ├── image_utils.py               # base64 encoding for OpenAI-compat
+│   ├── io.py                        # ResultWriter / read_processed
+│   ├── signal_utils.py              # Ctrl+C aware shutdown
+│   └── unk.py                       # [UNK] / □ / ■ etc.
+├── infer.py                         # entry: inference
+├── judge.py                         # entry: rule-based scoring
+└── summarize.py                     # entry: Excel report
+```

eval/README_zh.md

@@ -0,0 +1,180 @@
+# Chronicles-OCR Benchmark
+
+面向视觉语言模型（VLM）的 **中国历代书体 OCR** 多任务评测基准，覆盖全部七种规范汉字书体：甲骨文（Oracle Bone）、金文（Bronze Script）、篆书（Seal Script）、隶书（Clerical Script）、楷书（Regular Script）、行书（Running Script）、草书（Cursive Script）。
+
+| 分组 | 书体                      | 任务                                              |
+| ---- | ------------------------- | ------------------------------------------------- |
+| 古代 | 甲骨文 / 金文 / 篆书      | Spotting · Recognition · Parsing · Classification |
+| 近代 | 隶书 / 楷书 / 行书 / 草书 | Parsing · Classification                          |
+
+四个任务：
+
+| 任务                                       | 简称           | 指标                   | 说明                                             |
+| ------------------------------------------ | -------------- | ---------------------- | ------------------------------------------------ |
+| Cross-period Character Spotting            | Spotting       | F1 @ IoU > 0.75        | 检测每个字符的 bbox 并识别其对应的现代汉字       |
+| Fine-grained Archaic Character Recognition | Recognition    | Exact-match Accuracy   | 识别图中红色矩形框内单个古文字符所对应的现代汉字 |
+| Ancient Text Parsing                       | Parsing        | 1 − NED（Levenshtein） | 按阅读顺序识别图中所有汉字；评分前会过滤 `[UNK]` |
+| Script Classification                      | Classification | Accuracy               | 将图像分类到七种规范书体中的其中之一             |
+
+全部评分均为 **基于规则**，**不需要 LLM 评审**。
+
+> 注：Spotting 任务内部还会同时报告一个 Detection F1（仅看 bbox、IoU > 0.75，不要求字符一致）作为诊断指标；Spotting 主指标要求 IoU 与字符同时命中。
+
+---
+
+## 1. 环境安装
+
+```bash
+git clone <this-repo>
+cd ChronoText/Opensource
+pip install -r requirements.txt
+# 可选：仅当使用 --api_type local_vllm 时需要
+pip install vllm
+```
+
+## 2. 下载评测数据
+
+数据（jsonl + 图片）以单一压缩包发布。请将其解压到 `Opensource/data/` 目录下：
+
+```
+Opensource/data/
+├── Chronicles_OCR.jsonl
+└── images/
+    ├── 甲骨文/...   # Oracle Bone
+    ├── 金文/...     # Bronze Script
+    ├── 篆书/...     # Seal Script
+    ├── 隶书/...     # Clerical Script
+    ├── 楷书/...     # Regular Script
+    ├── 行书/...     # Running Script
+    └── 草书/...     # Cursive Script
+```
+
+jsonl 每一行的格式如下：
+
+```json
+{
+  "image_path": "images/甲骨文/abcdef0123.jpg",
+  "font_type": "甲骨文",
+  "annotation": "...",
+  "spotting": [{"bbox": {"x1":..,"y1":..,"x2":..,"y2":..}, "modern_char": ".."}, ...],
+  "width": 800,
+  "height": 600
+}
+```
+
+`spotting` / `width` / `height` 仅在三种古代书体上存在；近代书体仅包含 `image_path`、`font_type`、`annotation`。
+
+## 3. 推理（Inference）
+
+通过 `--api_type` 切换三种后端：
+
+### (a) `openai_compat` — 任意 OpenAI 兼容 HTTP 服务
+
+适用于 `vllm serve` / `sglang` / `lmdeploy` 等本地服务，也适用于符合 OpenAI Chat Completions 协议的公有云接口（OpenAI、Gemini OpenAI-compat、Claude OpenAI-compat、Together 等）。
+
+```bash
+python infer.py \
+    --api_type openai_compat \
+    --model_name Qwen2.5-VL-7B-Instruct \
+    --base_url http://127.0.0.1:8000/v1 \
+    --api_key EMPTY \
+    --max_workers 64
+```
+
+### (b) `local_vllm` — 进程内加载 vLLM，直接给本地权重路径
+
+不需要先启动服务，脚本会通过 `vllm.LLM` 在进程内加载本地 checkpoint。
+
+```bash
+python infer.py \
+    --api_type local_vllm \
+    --model_path /path/to/Qwen2.5-VL-7B-Instruct \
+    --tensor_parallel_size 1 \
+    --max_model_len 32768
+```
+
+### 输出位置
+
+每次运行会写入一个 jsonl：
+
+```
+Opensource/infer_results/<model_tag>/results.jsonl
+```
+
+`<model_tag>` 默认依次取 `--model_name` / `--model_path` 的 basename / `--api_name`，也可以用 `--output_tag` 显式覆盖。
+
+## 4. 评分（Judging）
+
+```bash
+# 评分 infer_results/ 下的全部模型
+python judge.py
+
+# 只评分指定模型
+python judge.py --models Qwen2.5-VL-7B-Instruct gemini-3.1-pro
+```
+
+输出到 `Opensource/judge_results/<model_tag>/results.jsonl`。评分阶段为纯规则计算、速度很快，因此 **始终覆盖** 之前的结果。
+
+## 5. 汇总报表（Summary）
+
+```bash
+python summarize.py
+# → Opensource/judge_results/results_analysis.xlsx
+```
+
+输出的 Excel 含两张表，且任务列均按规范顺序 **Spotting · Recognition · Parsing · Classification** 排列：
+
+- **Per-group summary** — 按 Ancient / Modern 两个分组聚合的每模型平均分
+- **Per-script breakdown** — 拆解到七种书体的每模型平均分
+
+分数会乘��� `100`，保留 1 位小数（例如 `87.3` 表示 0.873）。
+
+---
+
+## 6. 完整流程示例
+
+```bash
+# 1. 推理
+python infer.py --api_type openai_compat \
+    --model_name Qwen2.5-VL-7B-Instruct \
+    --base_url http://127.0.0.1:8000/v1
+
+# 2. 评分
+python judge.py
+
+# 3. 汇总到 Excel
+python summarize.py
+```
+
+---
+
+## 7. 代码结构
+
+```
+Opensource/
+├── README.md / README_zh.md
+├── requirements.txt
+├── data/                            # ← 数据下载到这里
+├── apis/
+│   ├── base.py                      # APIBase
+│   ├── openai_compat.py             # OpenAI 兼容客户端
+│   ├── local_vllm.py                # 进程内 vLLM
+├── prompts/
+│   ├── spotting.py                  # Cross-period Character Spotting
+│   ├── referring.py                 # Fine-grained Archaic Character Recognition（红框采样 + 渲染）
+│   ├── extract_text.py              # Ancient Text Parsing
+│   └── classify.py                  # Script Classification
+├── judges/
+│   ├── spotting.py
+│   ├── referring.py
+│   ├── extract_text.py
+│   └── classify.py
+├── utils/
+│   ├── image_utils.py               # OpenAI 兼容 API 的 base64 编码
+│   ├── io.py                        # ResultWriter / read_processed
+│   ├── signal_utils.py              # 友好响应 Ctrl+C
+│   └── unk.py                       # [UNK] / □ / ■ 等占位归一化
+├── infer.py                         # 入口：推理
+├── judge.py                         # 入口：规则评分
+└── summarize.py                     # 入口：Excel 报表
+```

eval/apis/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from .base import APIBase
+
+API_TYPES = ("local_vllm", "openai_compat")
+
+
+def get_api(api_type: str, **kwargs) -> APIBase:
+    """构造一个 API 实例。
+
+    Args:
+        api_type: 取值 ``"local_vllm"`` / ``"openai_compat"``
+        **kwargs: 转发给具体 API 类的参数
+
+    Returns:
+        APIBase 子类实例
+    """
+    if api_type == "local_vllm":
+        from .local_vllm import LocalVLLMAPI
+
+        return LocalVLLMAPI(**kwargs)
+    if api_type == "openai_compat":
+        from .openai_compat import OpenAICompatAPI
+
+        return OpenAICompatAPI(**kwargs)
+
+    raise ValueError(f"unsupported api_type: {api_type!r}, expected one of {API_TYPES}")

eval/apis/base.py

@@ -0,0 +1,23 @@
+"""APIBase：所有 API 实现的最小抽象基类。"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class APIBase(ABC):
+    @abstractmethod
+    def __call__(self, img_path: str | None, question: str, **kwargs) -> tuple[bool, str, str]:
+        """统一调用接口。
+
+        Args:
+            img_path: 本地图片路径（``None`` 表示纯文本任务）
+            question: prompt 文本
+
+        Returns:
+            ``(success, thinking, answer)`` 三元组：
+              - success: 调用是否成功
+              - thinking: 模型 think 段（可能为空）
+              - answer: 模型最终回复
+        """
+        ...

eval/apis/local_vllm.py

@@ -0,0 +1,76 @@
+"""本地 vLLM 进程内推理：``from vllm import LLM`` 加载一个本地模型路径。
+
+适用场景：用户提供一个本地权重路径（``--api_type local_vllm --model_path ...``），
+"""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+
+from PIL import Image
+
+from .base import APIBase
+
+DEFAULT_MAX_TOKENS = 4096
+DEFAULT_TEMPERATURE = 0.0
+
+
+class LocalVLLMAPI(APIBase):
+    """vLLM 进程内推理。线程安全：同一个 ``LLM`` 实例可多线程并发调用 ``generate``。"""
+
+    def __init__(
+        self,
+        model_path: str,
+        tensor_parallel_size: int = 1,
+        max_model_len: int | None = None,
+        dtype: str = "auto",
+        gpu_memory_utilization: float = 0.9,
+        trust_remote_code: bool = True,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+        temperature: float = DEFAULT_TEMPERATURE,
+        max_try: int = 1,
+        **engine_kwargs,
+    ):
+        from vllm import LLM, SamplingParams  # 延迟导入：openai_compat 用户可能没装 vllm
+
+        self.model_path = model_path
+        self.max_try = max_try
+        self.sampling_params = SamplingParams(
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+        engine_args = dict(
+            model=model_path,
+            tensor_parallel_size=tensor_parallel_size,
+            dtype=dtype,
+            gpu_memory_utilization=gpu_memory_utilization,
+            trust_remote_code=trust_remote_code,
+        )
+        if max_model_len is not None:
+            engine_args["max_model_len"] = max_model_len
+        engine_args.update(engine_kwargs)
+        self.llm = LLM(**engine_args)
+        self._lock = threading.Lock()  # vLLM 自带异步引擎，但部分版本对 generate 调用串行更稳
+
+        self._model_name = Path(model_path).name
+
+    def __call__(self, img_path: str | None, question: str, **kwargs):
+        try:
+            inputs = self._build_inputs(img_path, question)
+            with self._lock:
+                outputs = self.llm.generate([inputs], self.sampling_params)
+            text = outputs[0].outputs[0].text or ""
+            return True, "", text.strip()
+        except Exception as e:
+            print(f"[LocalVLLMAPI] inference 失败: {e}")
+            return False, "", ""
+
+    def _build_inputs(self, img_path: str | None, question: str) -> dict:
+        if not img_path:
+            return {"prompt": question}
+        # vLLM 多模态格式：使用 ``multi_modal_data``
+        image = Image.open(img_path).convert("RGB")
+        prompt = f"<|im_start|>user\n<image>\n{question}<|im_end|>\n<|im_start|>assistant\n"
+        return {"prompt": prompt, "multi_modal_data": {"image": image}}

eval/apis/openai_compat.py

@@ -0,0 +1,84 @@
+"""OpenAI 兼容 API 客户端。
+
+适用场景：
+  1. 用户用 ``vllm serve`` / ``sglang`` / ``lmdeploy`` 等起的本地 OpenAI 兼容服务
+  2. OpenAI 官方 / Gemini-OpenAI-compat / Claude-OpenAI-compat 等公有云
+  3. 任意自托管的 OpenAI Chat Completions 协议网关
+
+只依赖标准 ``openai`` Python 客户端，不引入任何特殊鉴权 / cos url 逻辑。
+"""
+
+from __future__ import annotations
+
+import re
+import time
+
+from openai import OpenAI
+
+from ..utils.image_utils import encode_image
+from .base import APIBase
+
+DEFAULT_TIMEOUT = 1200
+
+
+def _split_think_answer(response: str) -> tuple[str, str]:
+    """从模型输出中拆出 thinking / final answer。"""
+    if not response or not response.strip():
+        return "", ""
+    m = re.search(r"<think>\n(.*?)\n</think>\n<answer>\n(.*?)\n</answer>", response, flags=re.DOTALL)
+    if m:
+        return m.group(1).strip(), m.group(2).strip()
+    return "", response.strip()
+
+
+class OpenAICompatAPI(APIBase):
+    """走 OpenAI Chat Completions 协议的通用客户端。"""
+
+    def __init__(
+        self,
+        model_name: str,
+        base_url: str,
+        api_key: str = "EMPTY",
+        max_try: int = 3,
+        timeout: int = DEFAULT_TIMEOUT,
+        image_first: bool = True,
+    ):
+        self.model_name = model_name
+        self.base_url = base_url
+        self.api_key = api_key
+        self.max_try = max_try
+        self.timeout = timeout
+        self.image_first = image_first
+        self.client = OpenAI(base_url=base_url, api_key=api_key)
+
+    def __call__(self, img_path: str | None, question: str, temperature: float | None = None, **kwargs):
+        messages = self._build_messages(img_path, question)
+        return self._send(messages, temperature=temperature)
+
+    def _build_messages(self, img_path: str | None, question: str) -> list[dict]:
+        if not img_path:
+            assert question, "question is required when img_path is empty"
+            return [{"role": "user", "content": [{"type": "text", "text": question}]}]
+        data_uri = encode_image(img_path)
+        img_part = {"type": "image_url", "image_url": {"url": data_uri}}
+        txt_part = {"type": "text", "text": question}
+        content = [img_part, txt_part] if self.image_first else [txt_part, img_part]
+        return [{"role": "user", "content": content}]
+
+    def _send(self, messages: list[dict], temperature: float | None = None):
+        for attempt in range(1, self.max_try + 1):
+            try:
+                completion = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=messages,
+                    temperature=temperature,
+                    timeout=self.timeout,
+                )
+                response = completion.choices[0].message.content or ""
+                thinking, answer = _split_think_answer(response)
+                return True, thinking, answer
+            except Exception as e:
+                print(f"[OpenAICompatAPI] 尝试 {attempt}/{self.max_try} 失败: {e}")
+                if attempt < self.max_try:
+                    time.sleep(min(2 * attempt, 10))
+        return False, "", ""

eval/infer.py

@@ -0,0 +1,392 @@
+"""ChronoText benchmark inference entry point.
+
+Usage:
+    # 1) Local OpenAI-compatible service started by ``vllm serve`` / sglang / lmdeploy
+    python infer.py --api_type openai_compat \
+        --model_name Qwen2.5-VL-7B-Instruct \
+        --base_url http://127.0.0.1:8000/v1 \
+        --api_key EMPTY
+
+    # 2) In-process vLLM, point ``--model_path`` to a local checkpoint
+    python infer.py --api_type local_vllm \
+        --model_path /path/to/checkpoint \
+        --tensor_parallel_size 4
+
+    # 3) ⚠️ Internal only — distill backend (delete before release)
+    python infer.py --api_type distill --api_name doubao-seed-1-8-251228-nonthinking
+
+Outputs:
+    Opensource/infer_results/<model_tag>/results.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import json
+import os
+import sys
+import time
+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.apis import API_TYPES, get_api  # noqa: E402
+from Opensource.prompts import (  # noqa: E402
+    EXTRACT_FUNCS,
+    PROMPTS,
+    TASK_CLASSIFY,
+    TASK_EXTRACT,
+    TASK_REFERRING,
+    TASK_SPOTTING,
+)
+from Opensource.prompts.referring import DEFAULT_SEED, prepare_referring_sample  # noqa: E402
+from Opensource.utils.io import ResultWriter, get_image_path, read_processed  # noqa: E402
+from Opensource.utils.signal_utils import ABORT_EVENT, install_signal_handlers_once  # noqa: E402
+
+# ============================================================
+# 配置
+# ============================================================
+DEFAULT_DATA_FILE = REPO_ROOT / "data" / "Chronicles_OCR.jsonl"
+DEFAULT_OUTPUT_DIR = REPO_ROOT / "infer_results"
+
+# 古代三种字体额外执行 spotting / referring；近代字体只跑 classify / extract
+ANCIENT_FONTS = {"甲骨文", "金文", "篆书"}
+ALL_TASKS = [TASK_CLASSIFY, TASK_EXTRACT, TASK_SPOTTING, TASK_REFERRING]
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="ChronoText inference entry point")
+
+    # API 选择
+    p.add_argument(
+        "--api_type",
+        choices=API_TYPES,
+        required=True,
+        help="local_vllm: 进程内 vllm.LLM; openai_compat: 标准 OpenAI 协议; distill: 内部专用",
+    )
+
+    # OpenAI compat 参数
+    p.add_argument("--model_name", type=str, default=None, help="openai_compat 调用时使用的 model 字段")
+    p.add_argument("--base_url", type=str, default=None, help="openai_compat 服务地址，例如 http://127.0.0.1:8000/v1")
+    p.add_argument("--api_key", type=str, default="EMPTY")
+
+    # local_vllm 参数
+    p.add_argument("--model_path", type=str, default=None, help="local_vllm: 本地模型权重路径")
+    p.add_argument("--tensor_parallel_size", type=int, default=1)
+    p.add_argument("--max_model_len", type=int, default=None)
+    p.add_argument("--gpu_memory_utilization", type=float, default=0.9)
+
+    # distill（内部）
+    p.add_argument("--api_name", type=str, default=None, help="distill: 内部 API 名称")
+
+    # 数据 / 输出
+    p.add_argument(
+        "--data_file", type=str, default=str(DEFAULT_DATA_FILE), help=f"benchmark jsonl 路径，默认 {DEFAULT_DATA_FILE}"
+    )
+    p.add_argument("--output_dir", type=str, default=str(DEFAULT_OUTPUT_DIR))
+    p.add_argument(
+        "--output_tag", type=str, default=None, help="结果子目录名，默认从 model_name / model_path / api_name 推断"
+    )
+
+    # 推理参数
+    p.add_argument("--max_workers", type=int, default=64)
+    p.add_argument("--max_try", type=int, default=3)
+    p.add_argument("--max_rows", type=int, default=-1)
+    p.add_argument("--save_interval", type=int, default=1)
+    p.add_argument("--seed", type=int, default=DEFAULT_SEED, help="单字识别红框采样的随机种子")
+    p.add_argument("--debug", action="store_true")
+
+    return p.parse_args()
+
+
+def build_api(args: argparse.Namespace):
+    if args.api_type == "openai_compat":
+        if not args.model_name or not args.base_url:
+            raise SystemExit("--api_type openai_compat 需要同时提供 --model_name 与 --base_url")
+        return get_api(
+            "openai_compat",
+            model_name=args.model_name,
+            base_url=args.base_url,
+            api_key=args.api_key,
+            max_try=args.max_try,
+        )
+    if args.api_type == "local_vllm":
+        if not args.model_path:
+            raise SystemExit("--api_type local_vllm 需要提供 --model_path")
+        return get_api(
+            "local_vllm",
+            model_path=args.model_path,
+            tensor_parallel_size=args.tensor_parallel_size,
+            max_model_len=args.max_model_len,
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            max_try=args.max_try,
+        )
+    # distill
+    if not args.api_name:
+        raise SystemExit("--api_type distill 需要提供 --api_name")
+    return get_api("distill", api_name=args.api_name, max_try=args.max_try)
+
+
+def derive_output_tag(args: argparse.Namespace) -> str:
+    if args.output_tag:
+        return args.output_tag
+    if args.api_type == "openai_compat" and args.model_name:
+        return args.model_name
+    if args.api_type == "local_vllm" and args.model_path:
+        return Path(args.model_path).name
+    if args.api_type == "distill" and args.api_name:
+        return args.api_name
+    return "default"
+
+
+def resolve_image_path(row: dict, data_file_dir: Path) -> str:
+    """开源 jsonl 里 ``image_path`` 是相对 data 目录的相对路径，需要拼成绝对路径。"""
+    rel = get_image_path(row)
+    if not rel:
+        return ""
+    if os.path.isabs(rel):
+        return rel
+    return str(data_file_dir / rel)
+
+
+def tasks_for_row(row: dict) -> list[str]:
+    """按 font_type 决定该样本应跑的任务列表（古代 4 / 近代 2）。"""
+    if str(row.get("font_type", "")).strip() in ANCIENT_FONTS:
+        return ALL_TASKS
+    return [TASK_CLASSIFY, TASK_EXTRACT]
+
+
+def process_one_row(
+    api_instance,
+    row: dict,
+    abs_img_path: str,
+    existing: dict,
+    max_retries: int,
+    referring_cache_dir: str,
+    seed: int,
+) -> dict | None:
+    """对单条样本跑所有未完成的任务。返回新 row（包含合并后的 infer_results）。"""
+    if not abs_img_path or not os.path.exists(abs_img_path):
+        print(f"警告：图片不存在 {abs_img_path}")
+        return None
+
+    file_tasks = tasks_for_row(row)
+    pending = [t for t in file_tasks if t not in existing]
+    if not pending:
+        return None
+
+    infer_results = dict(existing)
+
+    for task_name in pending:
+        prompt_text = PROMPTS[task_name]
+        task_img = abs_img_path
+        referring_meta: dict | None = None
+
+        # 单字识别：先采样 + 画红框，再用渲染图调用模型
+        if task_name == TASK_REFERRING:
+            sample = prepare_referring_sample(row, abs_img_path, seed=seed, out_dir=referring_cache_dir)
+            if sample is None:
+                infer_results[task_name] = {
+                    "thinking": "",
+                    "answer": "",
+                    "error": "no_referring_target",
+                    "skipped": True,
+                }
+                continue
+            task_img = sample["rendered_img_path"]
+            referring_meta = {
+                "gt_char": sample["target_char"],
+                "target_bbox_xyxy": sample["target_bbox_xyxy"],
+                "target_index": sample["index"],
+                "sample_key": sample["sample_key"],
+                "seed": seed,
+                "rendered_img_path": sample["rendered_img_path"],
+            }
+
+        last_error = None
+        for attempt in range(1, max_retries + 1):
+            if task_name == TASK_REFERRING and not os.path.exists(task_img):
+                # 渲染图被外部清理掉则就地重画
+                redrawn = prepare_referring_sample(row, abs_img_path, seed=seed, out_dir=referring_cache_dir)
+                if redrawn is not None:
+                    task_img = redrawn["rendered_img_path"]
+            try:
+                ok, thinking, answer = api_instance(task_img, prompt_text)
+                if not ok or answer is None:
+                    raise RuntimeError("API 调用失败或返回空结果")
+
+                extract_fn = EXTRACT_FUNCS.get(task_name)
+                extract_ok, extracted = (False, None)
+                if extract_fn is not None:
+                    try:
+                        extract_ok, extracted = extract_fn(answer)
+                    except Exception as e:
+                        print(f"  任务 '{task_name}' 提取异常: {e}")
+                        extract_ok = False
+
+                if extract_fn is not None and not extract_ok and attempt < max_retries:
+                    print(f"  任务 '{task_name}' 提取失败，重试 {attempt}/{max_retries}")
+                    time.sleep(2)
+                    continue
+
+                rec = {"thinking": thinking or "", "answer": answer}
+                if extract_ok:
+                    rec["extract"] = extracted
+                if referring_meta is not None:
+                    rec.update(
+                        {
+                            k: referring_meta[k]
+                            for k in ("gt_char", "target_bbox_xyxy", "target_index", "sample_key", "seed")
+                        }
+                    )
+                infer_results[task_name] = rec
+                break
+            except Exception as e:
+                last_error = str(e)
+                if attempt < max_retries:
+                    print(f"  任务 '{task_name}' 失败 ({attempt}/{max_retries}): {last_error}")
+                    time.sleep(2)
+                else:
+                    rec = {"thinking": "", "answer": "", "error": last_error}
+                    if referring_meta is not None:
+                        rec.update(
+                            {
+                                k: referring_meta[k]
+                                for k in ("gt_char", "target_bbox_xyxy", "target_index", "sample_key", "seed")
+                            }
+                        )
+                    infer_results[task_name] = rec
+
+    result = dict(row)
+    result["infer_results"] = infer_results
+    result["image_path"] = get_image_path(row)  # 保持相对路径作为主键
+    return result
+
+
+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}")
+    data_dir = data_file.parent
+
+    output_tag = derive_output_tag(args)
+    output_dir = Path(args.output_dir).resolve() / output_tag
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_file = output_dir / "results.jsonl"
+    referring_cache_dir = str(output_dir / ".referring_cache")
+
+    print("=" * 72)
+    print("ChronoText Inference")
+    print("=" * 72)
+    print(f"api_type     : {args.api_type}")
+    print(f"output_tag   : {output_tag}")
+    print(f"data_file    : {data_file}")
+    print(f"output_file  : {output_file}")
+    print(f"max_workers  : {args.max_workers}")
+    print(f"max_rows     : {args.max_rows if args.max_rows > 0 else 'all'}")
+    print(f"seed         : {args.seed}")
+
+    # 读 jsonl
+    rows: list[dict] = []
+    with open(data_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    if args.max_rows > 0:
+        rows = rows[: args.max_rows]
+    if args.debug:
+        rows = rows[: min(5, len(rows))]
+    print(f"loaded {len(rows)} rows")
+
+    # API
+    print("\n初始化 API...")
+    api_instance = build_api(args)
+    print("API 就绪")
+
+    # 历史结果（增量）
+    all_task_set = set(ALL_TASKS)
+    processed, _needs = read_processed(str(output_file), all_task_set)
+    print(f"历史结果: 已写入 {len(processed)} 条")
+
+    # 待处理列表
+    pending: list[tuple[dict, str, dict]] = []
+    fully_done = 0
+    for row in rows:
+        rel = get_image_path(row)
+        if not rel:
+            continue
+        abs_img = resolve_image_path(row, data_dir)
+        existing_infer = processed.get(rel, {}).get("infer_results", {})
+        file_tasks = set(tasks_for_row(row))
+        if file_tasks.issubset(set(existing_infer.keys())):
+            fully_done += 1
+            continue
+        pending.append((row, abs_img, existing_infer))
+
+    print(f"完全完成: {fully_done}, 待处理: {len(pending)}\n")
+    if not pending:
+        print("没有需要处理的数据")
+        return
+
+    install_signal_handlers_once()
+    writer = ResultWriter(str(output_file), processed, save_interval=args.save_interval)
+
+    executor = ThreadPoolExecutor(max_workers=args.max_workers)
+    aborted = False
+    try:
+        futures = {
+            executor.submit(
+                process_one_row,
+                api_instance,
+                row,
+                abs_img,
+                existing,
+                args.max_try,
+                referring_cache_dir,
+                args.seed,
+            ): row
+            for row, abs_img, existing in pending
+        }
+        pbar = tqdm.tqdm(total=len(futures), desc="inference")
+        for fut in concurrent.futures.as_completed(futures):
+            if ABORT_EVENT.is_set():
+                aborted = True
+                break
+            try:
+                result = fut.result()
+                if result:
+                    writer.update_and_save(result)
+            except Exception as e:
+                print(f"\n处理失败: {e}")
+                traceback.print_exc()
+            pbar.update(1)
+        pbar.close()
+        if aborted:
+            for f in futures:
+                if not f.done():
+                    f.cancel()
+    finally:
+        if ABORT_EVENT.is_set():
+            executor.shutdown(wait=False, cancel_futures=True)
+        else:
+            executor.shutdown(wait=True)
+
+    print("\n落盘最终结果...")
+    writer.finalize()
+    print(f"✅ 推理完成: {output_file}")
+    if ABORT_EVENT.is_set():
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

eval/judge.py

@@ -0,0 +1,219 @@
+"""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/<model_tag>/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()

eval/judges/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from . import classify, extract_text, referring, spotting
+
+JUDGE_FUNCS: dict[str, Callable[[dict, dict], dict]] = {
+    "字体分类": classify.judge,
+    "字符提取": extract_text.judge,
+    "字符检测": spotting.judge,
+    "单字识别": referring.judge,
+}

eval/judges/_text.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+
+def normalize_text(text: str) -> str:
+    if not text:
+        return ""
+    text = text.replace("\\n", "").replace("\\\n", "")
+    return text.replace(" ", "").replace("\u3000", "").replace("\t", "").replace("\r", "").replace("\n", "")
+
+
+_PUNCT_CHARS = (
+    r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
+    "，。、；：「」『』（）【】〔〕〈〉《》"
+    "！？…—–·．“”‘’「」『』〝〞"
+    "￥％＃＆＊＠／＼｜＋－＝＿"
+    "～｀＾"
+)
+_PUNCT_TRANS = str.maketrans("", "", _PUNCT_CHARS)
+
+
+def normalize_for_parsing(text: str) -> str:
+    """字符提取 / 1-NED 评分专用：基础清洗 + 去标点。"""
+    return normalize_text(text).translate(_PUNCT_TRANS)

eval/judges/classify.py

@@ -0,0 +1,18 @@
+"""字体分类（Classification）打分：exact match。
+
+GT 端不做任何归一化（输入 jsonl 保证字体名属于七体之一）；
+Pred 端的解析回退已在 ``prompts/classify.py`` 的 ``extract`` 中处理：
+  - 严格前缀命中
+  - 部分匹配（"楷书体" → "楷书"）
+  - 整段最后一次命中（标记 ``fallback=True``）
+因此这里只做严格相等比较。
+"""
+
+from __future__ import annotations
+
+
+def judge(extract: dict, row: dict) -> dict:
+    gt = str(row.get("font_type", "") or "").strip()
+    pred = str((extract or {}).get("category", "") or "").strip()
+    score = 1.0 if (gt and pred and gt == pred) else 0.0
+    return {"score": score, "gt": gt, "pred": pred}

eval/judges/extract_text.py

@@ -0,0 +1,63 @@
+"""字符提取（Parsing）打分：1 − NED (Normalized Edit Distance)。
+
+  score = 1 - Levenshtein(pred, gt) / max(|pred|, |gt|)
+
+双边都先做 ``normalize_for_parsing``（去空白 / 换行 / 标点），再剔除 ``[UNK]`` 占位。
+"""
+
+from __future__ import annotations
+
+from ..utils.unk import remove_unk
+from ._text import normalize_for_parsing
+
+try:
+    from rapidfuzz.distance import Levenshtein as _rf_Levenshtein
+
+    _HAS_RF = True
+except ImportError:
+    _rf_Levenshtein = None
+    _HAS_RF = False
+
+
+def _levenshtein(s1: str, s2: str) -> int:
+    if s1 == s2:
+        return 0
+    if not s1:
+        return len(s2)
+    if not s2:
+        return len(s1)
+    if _HAS_RF:
+        return _rf_Levenshtein.distance(s1, s2)
+    # 纯 Python 兜底实现：滚动数组 DP，O(|s1|*|s2|) 时间 / O(|s2|) 空间。
+    prev = list(range(len(s2) + 1))
+    curr = [0] * (len(s2) + 1)
+    for i, c1 in enumerate(s1, start=1):
+        curr[0] = i
+        for j, c2 in enumerate(s2, start=1):
+            curr[j] = prev[j - 1] if c1 == c2 else 1 + min(prev[j], curr[j - 1], prev[j - 1])
+        prev, curr = curr, prev
+    return prev[len(s2)]
+
+
+def judge(extract: dict, row: dict) -> dict:
+    gt_raw = normalize_for_parsing(row.get("annotation", "") or "")
+    pred_raw = normalize_for_parsing((extract or {}).get("extracted_text", "") or "")
+    gt = remove_unk(gt_raw)
+    pred = remove_unk(pred_raw)
+
+    len_gt, len_pred = len(gt), len(pred)
+    if len_gt == 0 and len_pred == 0:
+        return {"score": 1.0, "metric": "1ned", "edit_distance": 0, "len_pred": 0, "len_gt": 0}
+    if len_gt == 0:
+        return {"score": 0.0, "metric": "1ned", "edit_distance": len_pred, "len_pred": len_pred, "len_gt": 0}
+
+    ed = _levenshtein(pred, gt)
+    denom = max(len_pred, len_gt)
+    score = max(0.0, 1.0 - ed / denom)
+    return {
+        "score": score,
+        "metric": "1ned",
+        "edit_distance": ed,
+        "len_pred": len_pred,
+        "len_gt": len_gt,
+    }

eval/judges/referring.py

@@ -0,0 +1,21 @@
+"""单字识别（Recognition）打分：Exact Match Accuracy。
+
+GT 来自 infer 阶段写入 ``infer_results["单字识别"]["gt_char"]``。
+"""
+
+from __future__ import annotations
+
+
+def _norm(s: str) -> str:
+    return (s or "").strip().strip("。.；;，,\"'“”‘’《》<>()（）【】[]{}!?！？:：`·～~")
+
+
+def judge(extract: dict, row: dict) -> dict:
+    pred = str((extract or {}).get("char", "") or "").strip()
+    infer_results = row.get("infer_results") or {}
+    task_rec = infer_results.get("单字识别") or {}
+    gt = str(task_rec.get("gt_char", "") or "").strip()
+    if not gt:
+        return {"score": 0.0, "metric": "exact_match", "gt": "", "pred": pred, "error": "no_gt"}
+    score = 1.0 if _norm(pred) == _norm(gt) else 0.0
+    return {"score": score, "metric": "exact_match", "gt": gt, "pred": pred}

eval/judges/spotting.py

@@ -0,0 +1,150 @@
+"""字符检测（Detection / End-to-End Spotting）打分。
+
+  - Detection：仅看 bbox，IoU > 0.75 视为 TP，包含 [UNK]
+  - Spotting：IoU > 0.75 且字符匹配视为 TP，排除 [UNK]
+均输出 per-sample F1。GT bbox 像素单位会被归一化到 0-1000 与模型输出对齐。
+"""
+
+from __future__ import annotations
+
+from ..utils.unk import is_unk_char
+
+IOU_THRESH = 0.75
+
+
+def _iou(a, b) -> float:
+    ax1, ay1, ax2, ay2 = a
+    bx1, by1, bx2, by2 = b
+    if ax2 <= ax1 or ay2 <= ay1 or bx2 <= bx1 or by2 <= by1:
+        return 0.0
+    ix1, iy1 = max(ax1, bx1), max(ay1, by1)
+    ix2, iy2 = min(ax2, bx2), min(ay2, by2)
+    iw, ih = ix2 - ix1, iy2 - iy1
+    if iw <= 0 or ih <= 0:
+        return 0.0
+    inter = iw * ih
+    union = (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - inter
+    return inter / union if union > 0 else 0.0
+
+
+def _parse_gt(row: dict) -> tuple[list[dict], int, int]:
+    """解析 GT spotting，返回 [{'bbox':[x1,y1,x2,y2],'char':str}, ...] + 图像 W/H。"""
+    sp = row.get("spotting") or []
+    W = int(row.get("width") or 0)
+    H = int(row.get("height") or 0)
+    items: list[dict] = []
+    for it in sp:
+        if not isinstance(it, dict):
+            continue
+        ch = it.get("modern_char")
+        if ch is None:
+            ch = it.get("text", "")
+        ch = str(ch or "").strip()
+
+        bbox = it.get("bbox")
+        if bbox is None:
+            continue
+        x1 = y1 = x2 = y2 = None
+        if isinstance(bbox, dict):
+            try:
+                x1, y1, x2, y2 = (float(bbox[k]) for k in ("x1", "y1", "x2", "y2"))
+            except (KeyError, TypeError, ValueError):
+                continue
+        elif isinstance(bbox, (list, tuple)) and len(bbox) == 4:
+            try:
+                bx = [float(v) for v in bbox]
+            except (TypeError, ValueError):
+                continue
+            if bx[2] < bx[0] or bx[3] < bx[1]:
+                x1, y1, x2, y2 = bx[0], bx[1], bx[0] + bx[2], bx[1] + bx[3]
+            else:
+                if "modern_char" in it:
+                    x1, y1, x2, y2 = bx[0], bx[1], bx[0] + bx[2], bx[1] + bx[3]
+                else:
+                    x1, y1, x2, y2 = bx
+        else:
+            continue
+        if x2 <= x1 or y2 <= y1:
+            continue
+        items.append({"bbox": [float(x1), float(y1), float(x2), float(y2)], "char": ch})
+    return items, W, H
+
+
+def _scale_to_1000(items: list[dict], W: int, H: int) -> list[dict]:
+    if W <= 0 or H <= 0:
+        return []
+    sx, sy = 1000.0 / W, 1000.0 / H
+    return [
+        {"bbox": [it["bbox"][0] * sx, it["bbox"][1] * sy, it["bbox"][2] * sx, it["bbox"][3] * sy], "char": it["char"]}
+        for it in items
+    ]
+
+
+def _match(preds: list[dict], gts: list[dict], iou_thresh: float, require_char: bool) -> tuple[int, int, int]:
+    if not preds or not gts:
+        return 0, len(preds), len(gts)
+    pairs: list[tuple[float, int, int]] = []
+    for pi, p in enumerate(preds):
+        for gi, g in enumerate(gts):
+            if require_char and p.get("char", "") != g.get("char", ""):
+                continue
+            iou = _iou(p["bbox"], g["bbox"])
+            if iou >= iou_thresh:
+                pairs.append((iou, pi, gi))
+    pairs.sort(key=lambda x: x[0], reverse=True)
+    used_p, used_g, tp = set(), set(), 0
+    for _, pi, gi in pairs:
+        if pi in used_p or gi in used_g:
+            continue
+        used_p.add(pi)
+        used_g.add(gi)
+        tp += 1
+    return tp, len(preds) - tp, len(gts) - tp
+
+
+def _f1(tp: int, fp: int, fn: int) -> float:
+    if tp == 0:
+        return 0.0
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    return 2 * p * r / (p + r) if (p + r) else 0.0
+
+
+def judge(extract: dict, row: dict, iou_thresh: float = IOU_THRESH) -> dict:
+    gt_raw, W, H = _parse_gt(row)
+    gts = _scale_to_1000(gt_raw, W, H)
+
+    preds_src = (extract or {}).get("items") or []
+    preds: list[dict] = []
+    for it in preds_src:
+        if not isinstance(it, dict):
+            continue
+        bb = it.get("bbox")
+        if not isinstance(bb, (list, tuple)) or len(bb) != 4:
+            continue
+        try:
+            bb = [float(v) for v in bb]
+        except (TypeError, ValueError):
+            continue
+        if bb[2] <= bb[0] or bb[3] <= bb[1]:
+            continue
+        preds.append({"bbox": bb, "char": str(it.get("char", "") or "").strip()})
+
+    det_tp, det_fp, det_fn = _match(preds, gts, iou_thresh, require_char=False)
+    det_f1 = _f1(det_tp, det_fp, det_fn)
+
+    spot_gts = [it for it in gts if not is_unk_char(it["char"])]
+    spot_preds = [it for it in preds if not is_unk_char(it["char"])]
+    spot_tp, spot_fp, spot_fn = _match(spot_preds, spot_gts, iou_thresh, require_char=True)
+    spot_f1 = _f1(spot_tp, spot_fp, spot_fn)
+
+    return {
+        "score": spot_f1,
+        "iou_thresh": iou_thresh,
+        "detection_f1": det_f1,
+        "spotting_f1": spot_f1,
+        "detection": {"tp": det_tp, "fp": det_fp, "fn": det_fn},
+        "spotting": {"tp": spot_tp, "fp": spot_fp, "fn": spot_fn},
+        "n_pred": len(preds),
+        "n_gt": len(gts),
+    }

eval/prompts/__init__.py

@@ -0,0 +1,26 @@
+"""4 个任务的 prompt 与 extract 注册表。"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from . import classify, extract_text, referring, spotting
+
+TASK_CLASSIFY = "字体分类"
+TASK_EXTRACT = "字符提取"
+TASK_SPOTTING = "字符检测"
+TASK_REFERRING = "单字识别"
+
+PROMPTS: dict[str, str] = {
+    TASK_CLASSIFY: classify.PROMPT,
+    TASK_EXTRACT: extract_text.PROMPT,
+    TASK_SPOTTING: spotting.PROMPT,
+    TASK_REFERRING: referring.PROMPT,
+}
+
+EXTRACT_FUNCS: dict[str, Callable[[str], tuple[bool, dict]]] = {
+    TASK_CLASSIFY: classify.extract,
+    TASK_EXTRACT: extract_text.extract,
+    TASK_SPOTTING: spotting.extract,
+    TASK_REFERRING: referring.extract,
+}

eval/prompts/_text.py

@@ -0,0 +1,115 @@
+"""Prompt / Extract 共用文本工具。
+
+- ``strip_thinking``: 剥离模型输出里的 ``<think>...</think>`` / ``<answer>...</answer>``
+- ``extract_by_prefix``: 按多前缀（"字体分类:" / "字体:" / ...）从纯文本中抽取冒号后的内容
+- ``clean_value``: 清理首尾空白、代码块围栏、常见标点引号
+"""
+
+from __future__ import annotations
+
+import re
+
+_OTHER_PREFIX_RE = re.compile(r"^(?:字体分类|字体|分类|提取文本|提取结果|识别结果|识别文本|文本)\s*[:：]")
+
+
+def strip_thinking(text: str) -> str:
+    """剥离 thinking 段，只保留最终答案。
+
+    支持 ``<think>...</think><answer>...</answer>`` / 仅 ``</think>`` / 仅 ``<think>`` 等多种形态。
+    """
+    if not text:
+        return ""
+    s = text
+
+    ans_m = re.search(r"<\s*answer\s*>([\s\S]*?)<\s*/\s*answer\s*>", s, flags=re.IGNORECASE)
+    if ans_m:
+        return ans_m.group(1).strip()
+
+    close_matches = list(re.finditer(r"<\s*/\s*(?:think|thinking|reasoning)\s*>", s, flags=re.IGNORECASE))
+    if close_matches:
+        last = close_matches[-1]
+        tail = s[last.end() :].strip()
+        tail = re.sub(r"^\s*<\s*answer\s*>\s*", "", tail, flags=re.IGNORECASE)
+        tail = re.sub(r"\s*<\s*/?\s*answer\s*>\s*$", "", tail, flags=re.IGNORECASE)
+        return tail.strip()
+
+    open_m = re.search(r"<\s*(?:think|thinking|reasoning)\s*>", s, flags=re.IGNORECASE)
+    if open_m:
+        head = s[: open_m.start()].strip()
+        return head if head else ""
+
+    return s.strip()
+
+
+def strip_code_fence(s: str) -> str:
+    if s is None:
+        return ""
+    s = s.strip()
+    m = re.match(r"^`{3,}[^\n`]*\n?(.*?)\n?`{3,}\s*$", s, re.DOTALL)
+    if m:
+        return m.group(1).strip()
+    return s.strip("`").strip()
+
+
+def clean_value(s: str) -> str:
+    if not s:
+        return ""
+    s = strip_code_fence(s)
+    s = s.strip().strip("。.；;，,\"'“”‘’")
+    return s.strip()
+
+
+def extract_by_prefix(text: str, prefixes: list[str], merge_trailing_lines: bool = False) -> str:
+    """按 ``前缀:`` 抽取冒号之后的答案，命中多次取最后一次。
+
+    ``merge_trailing_lines=True`` 时，"同行答案 + 后续多行非空"一并合并，
+    用于"字符提取"任务（模型常把多行文本写在前缀之后）。
+    """
+    if not text:
+        return ""
+
+    prefix_pattern = "|".join(re.escape(p) for p in prefixes)
+    head_pattern = re.compile(rf"(?:{prefix_pattern})\s*[:：]")
+    matches = list(head_pattern.finditer(text))
+    if not matches:
+        return ""
+
+    last = matches[-1]
+    tail = text[last.end() :]
+    first_line, _nl, rest = tail.partition("\n")
+    first_line_stripped = first_line.strip()
+
+    starts_with_fence = bool(re.match(r"^`{3,}", first_line_stripped))
+    first_line_no_fence = re.sub(r"^`{3,}[^\n`]*", "", first_line_stripped).strip("` ").strip()
+
+    if not starts_with_fence and first_line_no_fence:
+        if not merge_trailing_lines:
+            return clean_value(first_line_no_fence)
+        follow_lines: list[str] = []
+        for ln in rest.splitlines():
+            ln_s = ln.strip().strip("`").strip()
+            if not ln_s:
+                continue
+            if _OTHER_PREFIX_RE.search(ln_s):
+                break
+            follow_lines.append(ln_s)
+        head_clean = clean_value(first_line_no_fence)
+        if not follow_lines:
+            return head_clean
+        cleaned_follow = [(clean_value(ln) or ln) for ln in follow_lines]
+        return "\n".join([head_clean, *cleaned_follow]).strip()
+
+    multiline_src = rest
+    if starts_with_fence:
+        close_m = re.search(r"\n?`{3,}\s*(\n|$)", rest)
+        if close_m:
+            multiline_src = rest[: close_m.start()]
+
+    lines = [ln.strip().strip("`").strip() for ln in multiline_src.splitlines()]
+    lines = [ln for ln in lines if ln]
+    if not lines:
+        return ""
+    if len(lines) == 1:
+        return clean_value(lines[0])
+    cleaned = [(clean_value(ln) or ln) for ln in lines]
+    return "\n".join(cleaned).strip()

eval/prompts/classify.py

@@ -0,0 +1,65 @@
+"""字体分类（Classification）任务。"""
+
+from __future__ import annotations
+
+from ._text import extract_by_prefix, strip_thinking
+
+VALID_FONT_CATEGORIES = {"甲骨文", "金文", "篆书", "隶书", "楷书", "行书", "草书"}
+
+PROMPT = """你是一名精通中国古文字学与书法史的专家。
+
+任务：
+请根据输入的古文字图像，对其中汉字的字体进行分类。
+
+分类范围（仅允许从以下七类中选择一个）：
+1. 甲骨文
+2. 金文
+3. 篆书
+4. 隶书
+5. 楷书
+6. 行书
+7. 草书
+
+要求：
+- 仔细观察字形结构、笔画特征、线条风格和整体布局
+- 只能输出一个最可能的类别
+- 不允许输出多个类别或"无法判断"（除非图像极其模糊）
+- 不要输出解释（除非额外要求）
+
+输出格式（必须严格遵守）：
+字体分类：<类别名称>
+"""
+
+
+def extract(answer: str) -> tuple[bool, dict[str, str | bool]]:
+    """三层回退：精确前缀 → 部分匹配（"楷书体"→"楷书"）→ 整段最后一次命中。"""
+    text = strip_thinking(answer)
+    category = extract_by_prefix(text, ["字体分类", "字体", "分类"])
+
+    data: dict[str, str | bool] = {}
+    if category and category in VALID_FONT_CATEGORIES:
+        data["category"] = category
+        return True, data
+
+    # 部分匹配
+    if category:
+        for c in VALID_FONT_CATEGORIES:
+            if c in category:
+                data["category"] = c
+                return True, data
+
+    # 回退：扫整段答案，取最后一次出现的合法字体名
+    if text:
+        last_pos = -1
+        last_hit: str | None = None
+        for c in VALID_FONT_CATEGORIES:
+            pos = text.rfind(c)
+            if pos > last_pos:
+                last_pos = pos
+                last_hit = c
+        if last_hit is not None:
+            data["category"] = last_hit
+            data["fallback"] = True
+            return True, data
+
+    return False, data

eval/prompts/extract_text.py

@@ -0,0 +1,76 @@
+"""字符提取（Parsing）任务。"""
+
+from __future__ import annotations
+
+import re
+
+from ._text import clean_value, extract_by_prefix, strip_code_fence, strip_thinking
+
+PROMPT = """你将被提供一张包含汉字字符的图片。请仔细观察图片，并将图片中的所有汉字字符以正确的阅读顺序提取出来。
+
+要求：
+- 严格按图片中文字的阅读顺序输出
+- 仅输出识别到的字符本身，不要输出任何解释、标点补充或分析
+
+输出格式（必须严格遵守）：
+提取文本：<识别到的汉字字符>
+"""
+
+_OTHER_PREFIX_RE = re.compile(r"(?:字体分类|字体|分类)\s*[:：]")
+_PREAMBLE_LINE_RE = re.compile(
+    r"^(?:好的|好|没问题|当然|根据(?:图片|图像)|这是|以下是|图片中(?:的)?(?:内容|文字|字符)?(?:为|是|如下)?|无法(?:识别|看清)|抱歉|对不起)"
+)
+
+
+def _fallback_full_answer(text: str) -> str:
+    """模型不按格式输出时，把整段答案当作字符提取结果，但清理"开场白"与"其它任务前缀"。"""
+    if not text:
+        return ""
+    raw = strip_code_fence(text.strip())
+    if not raw:
+        return ""
+
+    cleaned: list[str] = []
+    for ln in raw.splitlines():
+        s = ln.strip().strip("`").strip()
+        if not s:
+            continue
+        if _OTHER_PREFIX_RE.match(s):
+            continue
+        if _PREAMBLE_LINE_RE.match(s):
+            continue
+        m = _OTHER_PREFIX_RE.search(s)
+        if m:
+            s = s[: m.start()].rstrip()
+            if not s:
+                continue
+        cleaned.append(s)
+
+    if not cleaned:
+        return ""
+    candidate = "\n".join(cleaned).strip()
+    candidate = clean_value(candidate) or candidate
+    if len(candidate) < 2:
+        return ""
+    return candidate
+
+
+def extract(answer: str) -> tuple[bool, dict[str, str | bool]]:
+    text = strip_thinking(answer)
+    extracted = extract_by_prefix(
+        text,
+        ["提取文本", "提取结果", "识别结果", "识别文本", "文本"],
+        merge_trailing_lines=True,
+    )
+    data: dict[str, str | bool] = {}
+    if extracted:
+        data["extracted_text"] = extracted
+        return True, data
+
+    fb = _fallback_full_answer(text)
+    if fb:
+        data["extracted_text"] = fb
+        data["fallback"] = True
+        return True, data
+
+    return False, data

eval/prompts/referring.py

@@ -0,0 +1,221 @@
+"""单字识别（Fine-grained Archaic Character Recognition）任务。
+
+工作流：
+  1. ``prepare_referring_sample`` 从 spotting GT 中按 (seed + sample_key) 确定性采样一个非 [UNK] 字符；
+  2. 在原图上绘制红色矩形框，落盘到稳定缓存目录；
+  3. 用渲染图调用模型，模型只识别红框内字符；
+  4. 评分使用 Exact Match Accuracy。
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import random
+import re
+import tempfile
+import threading
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image, ImageDraw
+
+from ..utils.unk import is_unk_char
+from ._text import clean_value, extract_by_prefix, strip_thinking
+
+# ============================================================
+# Prompt / Extract
+# ============================================================
+PROMPT = """你是一名精通中国古文字学的专家。
+
+任务：
+图中有一个**红色矩形框**，框内是一个古文字。请识别该红框内的古文字对应的**现代汉字**。
+
+要求：
+- 只识别红框内的单个字符，不要识别图片中其他位置的字符
+- 输出必须是**一个**现代汉字（不要输出多个字，不要加拼音、标点、解释或其他任何字符）
+- 如果无法识别，则输出：[UNK]
+
+输出格式（必须严格遵守）：
+现代汉字：<单个汉字>
+"""
+
+_CJK_RE = re.compile(r"[\u4e00-\u9fff\u3400-\u4dbf\U00020000-\U0002a6df\U0002a700-\U0002ebef\U00030000-\U0003134f]")
+
+
+def extract(answer: str) -> tuple[bool, dict[str, str]]:
+    text = strip_thinking(answer)
+    raw = extract_by_prefix(text, ["现代汉字", "汉字", "识别结果", "识别", "答案", "char"])
+    if not raw:
+        raw = clean_value(text)
+    if not raw:
+        return False, {}
+
+    stripped = raw.strip()
+    if stripped.upper() in {"[UNK]", "<UNK>", "UNK"}:
+        return True, {"char": "[UNK]"}
+
+    m = _CJK_RE.search(stripped)
+    if m:
+        return True, {"char": m.group(0)}
+
+    first = stripped.split()[0] if stripped.split() else ""
+    if first:
+        return True, {"char": first[:1]}
+    return False, {}
+
+
+# ============================================================
+# 红框采样 + 渲染
+# ============================================================
+DEFAULT_SEED = 42
+RED_BOX_COLOR = (255, 0, 0)
+MIN_BOX_WIDTH = 3
+MAX_BOX_WIDTH = 12
+BOX_WIDTH_RATIO = 0.006  # 0.6% of min(W,H)
+
+
+def _bbox_to_xyxy(item: dict) -> Optional[tuple[float, float, float, float]]:
+    """规范化 spotting item 的 bbox 为像素坐标 (x1,y1,x2,y2)。
+
+    支持：
+      - {"bbox":[x,y,w,h], "modern_char": ...}（甲骨文）
+      - {"bbox":{"x1","y1","x2","y2"}, "text": ...}（金文/篆文）
+      - {"bbox":[x1,y1,x2,y2], "text": ...}（备用格式）
+    """
+    bbox = item.get("bbox")
+    if bbox is None:
+        return None
+
+    if isinstance(bbox, dict):
+        try:
+            x1 = float(bbox.get("x1"))
+            y1 = float(bbox.get("y1"))
+            x2 = float(bbox.get("x2"))
+            y2 = float(bbox.get("y2"))
+        except (TypeError, ValueError):
+            return None
+        return (x1, y1, x2, y2) if (x2 > x1 and y2 > y1) else None
+
+    if isinstance(bbox, (list, tuple)) and len(bbox) == 4:
+        try:
+            bx = [float(v) for v in bbox]
+        except (TypeError, ValueError):
+            return None
+        if "modern_char" in item:
+            x, y, w, h = bx
+            x1, y1, x2, y2 = x, y, x + w, y + h
+        else:
+            if bx[2] < bx[0] or bx[3] < bx[1]:
+                x, y, w, h = bx
+                x1, y1, x2, y2 = x, y, x + w, y + h
+            else:
+                x1, y1, x2, y2 = bx
+        return (x1, y1, x2, y2) if (x2 > x1 and y2 > y1) else None
+
+    return None
+
+
+def _item_char(item: dict) -> str:
+    ch = item.get("modern_char")
+    if ch is None:
+        ch = item.get("text", "")
+    return str(ch or "").strip()
+
+
+def _build_sample_key(row: dict) -> str:
+    parts: list[str] = []
+    for k in ("image_path", "img_path", "image"):
+        v = row.get(k)
+        if v:
+            parts.append(f"{k}={v}")
+    sp = row.get("spotting")
+    if isinstance(sp, list) and sp:
+        fp = hashlib.md5(json.dumps(sp, ensure_ascii=False, sort_keys=True).encode("utf-8")).hexdigest()[:12]
+        parts.append(f"sp_fp={fp}")
+    return "|".join(parts)
+
+
+def _seeded_rng(key: str, seed: int) -> random.Random:
+    h = hashlib.md5(f"{seed}::{key}".encode("utf-8")).hexdigest()
+    return random.Random(int(h[:16], 16))
+
+
+def _pick_target(row: dict, seed: int) -> Optional[dict]:
+    sp = row.get("spotting") or []
+    if not isinstance(sp, list) or not sp:
+        return None
+
+    candidates: list[tuple[int, str, tuple[float, float, float, float]]] = []
+    for idx, it in enumerate(sp):
+        if not isinstance(it, dict):
+            continue
+        ch = _item_char(it)
+        if is_unk_char(ch):
+            continue
+        bb = _bbox_to_xyxy(it)
+        if bb is None:
+            continue
+        candidates.append((idx, ch, bb))
+    if not candidates:
+        return None
+
+    sample_key = _build_sample_key(row) or "no-key"
+    rng = _seeded_rng(sample_key, seed)
+    idx, ch, bb = rng.choice(candidates)
+    return {"char": ch, "bbox_xyxy": bb, "index": idx, "sample_key": sample_key}
+
+
+def _box_width(W: int, H: int) -> int:
+    short = max(1, min(W, H))
+    w = int(round(short * BOX_WIDTH_RATIO))
+    return max(MIN_BOX_WIDTH, min(MAX_BOX_WIDTH, w))
+
+
+def _draw_box(img_path: str, bbox_xyxy, out_dir: Optional[str]) -> str:
+    with Image.open(img_path) as im:
+        im = im.convert("RGB")
+        W, H = im.size
+        x1, y1, x2, y2 = [
+            max(0.0, min(float(W - 1) if i % 2 == 0 else float(H - 1), float(v))) for i, v in enumerate(bbox_xyxy)
+        ]
+        bw = _box_width(W, H)
+        ImageDraw.Draw(im).rectangle([x1, y1, x2, y2], outline=RED_BOX_COLOR, width=bw)
+
+        if out_dir is None:
+            out_dir = os.path.join(tempfile.gettempdir(), "chronotext_referring")
+        os.makedirs(out_dir, exist_ok=True)
+        stem = Path(img_path).stem
+        tag = hashlib.md5(f"{img_path}|{x1:.2f},{y1:.2f},{x2:.2f},{y2:.2f}".encode("utf-8")).hexdigest()[:8]
+        out_path = os.path.join(out_dir, f"{stem}_redbox_{tag}_{os.getpid()}_{threading.get_ident()}.png")
+
+        tmp = f"{out_path}.tmp"
+        im.save(tmp, format="PNG")
+        os.replace(tmp, out_path)
+        return out_path
+
+
+def prepare_referring_sample(
+    row: dict,
+    img_path: str,
+    seed: int = DEFAULT_SEED,
+    out_dir: Optional[str] = None,
+) -> Optional[dict]:
+    """采样 + 画框 + 落盘。任一步失败返回 None。"""
+    picked = _pick_target(row, seed=seed)
+    if picked is None:
+        return None
+    if not img_path or not os.path.exists(img_path):
+        return None
+
+    rendered = _draw_box(img_path, picked["bbox_xyxy"], out_dir)
+    if not (rendered and os.path.exists(rendered)):
+        rendered = _draw_box(img_path, picked["bbox_xyxy"], out_dir)
+    return {
+        "rendered_img_path": rendered,
+        "target_char": picked["char"],
+        "target_bbox_xyxy": [float(v) for v in picked["bbox_xyxy"]],
+        "index": picked["index"],
+        "sample_key": picked["sample_key"],
+    }

eval/prompts/spotting.py

@@ -0,0 +1,133 @@
+"""字符检测（Detection / End-to-End Spotting）任务。
+
+模型输出 JSON 数组，bbox 归一化到 0-1000，char 是该 bbox 对应的现代汉字。
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+from ._text import strip_thinking
+
+PROMPT = """你是一名古文字图像检测与识别专家。
+
+任务：
+请检测输入图像中所有可见的古文单字符，并为每个单字符同时给出边界框 bbox 和该字符本身。
+
+检测对象：
+- 每个独立古文字符作为一个目标
+- 不要检测标点、背景纹理、裂纹、装饰线、器物边缘或非文字区域
+- 如果一个字符残缺但仍可辨认为字符，也应检测
+- 如果多个笔画明显属于同一个字符，只输出一个 bbox
+
+坐标要求：
+- bbox 格式为 [x1, y1, x2, y2]
+- x1, y1 表示左上角坐标
+- x2, y2 表示右下角坐标
+- 所有坐标必须基于整张输入图像归一化到 0–1000 的整数范围
+- x1 < x2，y1 < y2
+- 不要输出小数
+
+字符要求：
+- char 字段填写该 bbox 区域对应的字符本身（使用现代汉字写出）
+- 每个 bbox 只对应一个字符
+- 如果字符无法识别，可以使用 "[UNK]" 代替，但仍需要输出该字符的 bbox
+
+排序要求：
+- 按从上到下、从左到右的顺序排输出
+- idx 从 1 开始连续编号
+
+输出要求：
+- 只输出合法 JSON
+- 不要输出解释、Markdown、代码块或多余文字
+
+JSON 输出格式：
+[
+  {"idx": 1, "bbox": [x1, y1, x2, y2], "char": "<该bbox对应的字符>"},
+  {"idx": 2, "bbox": [x1, y1, x2, y2], "char": "<该bbox对应的字符>"}
+]
+"""
+
+
+def _strip_json_fence(text: str) -> str:
+    if not text:
+        return ""
+    s = text.strip()
+    m = re.match(r"^```(?:json|JSON)?\s*\n?(.*?)\n?```\s*$", s, flags=re.DOTALL)
+    return m.group(1).strip() if m else s
+
+
+def extract(answer: str) -> tuple[bool, dict]:
+    data: dict = {"items": []}
+    if not answer:
+        return False, data
+
+    s = _strip_json_fence(strip_thinking(answer))
+
+    parsed = None
+    try:
+        parsed = json.loads(s)
+    except Exception:
+        parsed = None
+
+    if parsed is None:
+        lb, rb = s.find("["), s.rfind("]")
+        if lb != -1 and rb != -1 and rb > lb:
+            try:
+                parsed = json.loads(s[lb : rb + 1])
+            except Exception:
+                parsed = None
+
+    if parsed is None:
+        for m in re.finditer(r"\[[\s\S]*?\]", s):
+            try:
+                cand = json.loads(m.group(0))
+                if isinstance(cand, list):
+                    parsed = cand
+                    break
+            except Exception:
+                continue
+
+    if parsed is None or not isinstance(parsed, list):
+        return False, data
+
+    items: list[dict] = []
+    valid_all = True
+    for i, it in enumerate(parsed, start=1):
+        if not isinstance(it, dict):
+            valid_all = False
+            continue
+        bbox = it.get("bbox")
+        if not isinstance(bbox, list) or len(bbox) != 4 or not all(isinstance(v, (int, float)) for v in bbox):
+            valid_all = False
+            continue
+        x1, y1, x2, y2 = [int(round(float(v))) for v in bbox]
+        x1 = max(0, min(1000, x1))
+        y1 = max(0, min(1000, y1))
+        x2 = max(0, min(1000, x2))
+        y2 = max(0, min(1000, y2))
+        if not (x1 < x2 and y1 < y2):
+            valid_all = False
+            continue
+
+        char = it.get("char", "")
+        if not isinstance(char, str):
+            char = str(char) if char is not None else ""
+        char = char.strip()
+
+        idx = it.get("idx", i)
+        items.append(
+            {
+                "idx": int(idx) if isinstance(idx, (int, float)) else i,
+                "bbox": [x1, y1, x2, y2],
+                "char": char,
+            }
+        )
+
+    data["items"] = items
+    if len(parsed) == 0:
+        return True, data
+    if not items:
+        return False, data
+    return valid_all, data

eval/requirements.txt

@@ -0,0 +1,14 @@
+# Core
+openai>=1.30.0
+Pillow>=9.0.0
+tqdm>=4.60.0
+
+# Optional but strongly recommended (C++ Levenshtein, ~10x faster than pure-Python fallback)
+rapidfuzz>=3.0.0
+
+# For summarize.py (Excel output)
+pandas>=1.5.0
+openpyxl>=3.1.0
+
+# Only required when --api_type local_vllm
+# vllm>=0.5.0

eval/summarize.py

@@ -0,0 +1,382 @@
+"""ChronoText benchmark scoring summary.
+
+Aggregates rule-based judging results from ``judge_results/<model>/results.jsonl``
+into a multi-sheet Excel workbook with per-model x per-task / per-font-type breakdowns.
+
+Usage:
+    python summarize.py                              # default: scan judge_results/
+    python summarize.py --input_dir judge_results
+    python summarize.py --output results_analysis.xlsx --num_workers 64
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import pandas as pd
+from openpyxl.styles import Alignment, Font, PatternFill
+from openpyxl.utils import get_column_letter
+from tqdm import tqdm
+
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT.parent))
+
+DEFAULT_INPUT_DIR = REPO_ROOT / "judge_results"
+DEFAULT_OUTPUT_FILE = REPO_ROOT / "judge_results" / "results_analysis.xlsx"
+
+# 数值格式：x100 保留 1 位（不加 %）
+SCORE_SCALE = 100
+SCORE_DECIMALS = 1
+AVG_HEADER = "Average"
+
+# 任务展示名：jsonl 中的 task key 用中文，输出表头统一映射为英文
+TASK_DISPLAY = {
+    "字体分类": "Classification",
+    "字符提取": "Parsing",
+    "字符检测_Detection": "Detection",
+    "字符检测_Spotting": "Spotting",
+    "单字识别": "Recognition",
+}
+DETECTION_TASK = "字符检测_Detection"
+SPOTTING_TASK = "字符检测_Spotting"
+RECOGNITION_TASK = "单字识别"
+
+# 字体顺序：学术顺序，不要按字典序
+FONT_TYPE_PRIORITY = ["甲骨文", "金文", "篆书", "隶书", "楷书", "行书", "草书"]
+ANCIENT_FONTS = {"甲骨文", "金文", "篆书"}
+
+ANCIENT_TASKS = ["字体分类", "字符提取", DETECTION_TASK, SPOTTING_TASK, RECOGNITION_TASK]
+MODERN_TASKS = ["字体分类", "字符提取"]
+DISPLAY_TASKS = [SPOTTING_TASK, RECOGNITION_TASK, "字符提取", "字体分类"]
+_DISPLAY_ORDER = {t: i for i, t in enumerate(DISPLAY_TASKS)}
+
+
+def display(t: str) -> str:
+    return TASK_DISPLAY.get(t, t)
+
+
+def filter_display(tasks: list[str]) -> list[str]:
+    inter = [t for t in tasks if t in _DISPLAY_ORDER]
+    inter.sort(key=lambda x: _DISPLAY_ORDER[x])
+    return inter
+
+
+def fmt(v) -> float | str:
+    if v is None or v == "":
+        return ""
+    try:
+        return round(float(v) * SCORE_SCALE, SCORE_DECIMALS)
+    except (TypeError, ValueError):
+        return ""
+
+
+def parse_judge_file(file_path: str) -> tuple[dict[str, list[float]], dict[str, dict[str, list[float]]]]:
+    """单次遍历同时返回整体分数 + 按字体分组的分数。"""
+    task_scores: dict[str, list[float]] = defaultdict(list)
+    type_task_scores: dict[str, dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                jr = data.get("judge_results") or {}
+                if not jr:
+                    continue
+                font_type = str(data.get("font_type", "") or "").strip() or "未知"
+                for task_name, task_result in jr.items():
+                    # 字符检测拆成 Detection / Spotting 两个虚拟任务
+                    if task_name == "字符检测":
+                        inner = task_result.get("score", task_result) if isinstance(task_result, dict) else None
+                        det = inner.get("detection_f1") if isinstance(inner, dict) else None
+                        spot = inner.get("spotting_f1") if isinstance(inner, dict) else None
+                        if det is not None:
+                            task_scores[DETECTION_TASK].append(det)
+                            type_task_scores[font_type][DETECTION_TASK].append(det)
+                        if spot is not None:
+                            task_scores[SPOTTING_TASK].append(spot)
+                            type_task_scores[font_type][SPOTTING_TASK].append(spot)
+                        continue
+                    score = task_result.get("score", 0.0) if isinstance(task_result, dict) else 0.0
+                    if isinstance(score, dict) and "score" in score:
+                        score = score["score"]
+                    task_scores[task_name].append(score)
+                    type_task_scores[font_type][task_name].append(score)
+    except Exception as e:
+        print(f"读取文件 {file_path} 时出错: {e}")
+    return task_scores, type_task_scores
+
+
+def calc_avg(task_scores: dict[str, list]) -> dict[str, float | None]:
+    out: dict[str, float | None] = {}
+    for k, scores in task_scores.items():
+        cleaned = []
+        for s in scores:
+            if isinstance(s, dict) and "score" in s:
+                s = s["score"]
+            if s is None:
+                continue
+            try:
+                cleaned.append(float(s))
+            except (TypeError, ValueError):
+                continue
+        out[k] = sum(cleaned) / len(cleaned) if cleaned else None
+    return out
+
+
+def font_allowed_tasks(font_type: str, available_tasks: list[str]) -> list[str]:
+    allowed = ANCIENT_TASKS if font_type in ANCIENT_FONTS else MODERN_TASKS
+    inter = [t for t in available_tasks if t in allowed]
+    return filter_display(inter)
+
+
+def get_group_tasks(group: str) -> list[str]:
+    base = ANCIENT_TASKS if group == "ancient" else MODERN_TASKS if group == "modern" else []
+    return filter_display(base)
+
+
+def analyze(input_dir: str, output_file: str, num_workers: int) -> None:
+    print("=" * 72)
+    print("ChronoText Summarize")
+    print("=" * 72)
+    print(f"input_dir   : {input_dir}")
+    print(f"output_file : {output_file}")
+    print(f"num_workers : {num_workers}\n")
+
+    if not os.path.isdir(input_dir):
+        raise SystemExit(f"输入目录不存在: {input_dir}")
+
+    model_tags = sorted(d for d in os.listdir(input_dir) if os.path.isdir(os.path.join(input_dir, d)))
+    print(f"找到 {len(model_tags)} 个模型: {model_tags}\n")
+
+    tasks: list[tuple[str, str]] = []
+    for tag in model_tags:
+        f = os.path.join(input_dir, tag, "results.jsonl")
+        if os.path.isfile(f):
+            tasks.append((tag, f))
+        else:
+            print(f"  跳过 {tag}：找不到 {f}")
+
+    per_model_overall: dict[str, dict[str, float | None]] = {}
+    per_model_by_font: dict[str, dict[str, dict[str, float | None]]] = {}
+    per_model_count: dict[str, dict[str, int]] = {}
+    all_tasks: set[str] = set()
+    all_fonts: set[str] = set()
+
+    def _worker(item):
+        tag, fpath = item
+        ts, tts = parse_judge_file(fpath)
+        return tag, calc_avg(ts), tts
+
+    workers = max(1, min(num_workers, len(tasks))) if tasks else 1
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futs = [ex.submit(_worker, t) for t in tasks]
+        for fut in tqdm(as_completed(futs), total=len(futs), desc="parse jsonl"):
+            tag, overall, tts = fut.result()
+            per_model_overall[tag] = overall
+            all_tasks.update(overall.keys())
+            font_avg: dict[str, dict[str, float | None]] = {}
+            cnt: dict[str, int] = {}
+            for ft, tmap in tts.items():
+                font_avg[ft] = {tn: (sum(v) / len(v) if v else None) for tn, v in tmap.items()}
+                cnt[ft] = max((len(v) for v in tmap.values()), default=0)
+            per_model_by_font[tag] = font_avg
+            per_model_count[tag] = cnt
+            all_fonts.update(tts.keys())
+
+    sorted_models = sorted(per_model_overall.keys())  # 按字典序展示
+    sorted_fonts = [f for f in FONT_TYPE_PRIORITY if f in all_fonts] + sorted(all_fonts - set(FONT_TYPE_PRIORITY))
+
+    ancient_tasks = get_group_tasks("ancient")
+    modern_tasks = get_group_tasks("modern")
+
+    # ==================== Sheet 1: 评分分析（古代 / 近代汇总） ====================
+    rows = []
+    for tag in sorted_models:
+        font_avg = per_model_by_font.get(tag, {})
+
+        row: dict[str, object] = {"模型名称": tag}
+
+        # 古代区块：只取古代字体下的 per-font 均分，再对字体求平均
+        anc_scores: dict[str, list[float]] = defaultdict(list)
+        for ft in sorted_fonts:
+            if ft not in ANCIENT_FONTS:
+                continue
+            for t, v in font_avg.get(ft, {}).items():
+                if t in ancient_tasks and v is not None:
+                    anc_scores[t].append(v)
+        anc_per = {t: (sum(v) / len(v) if v else None) for t, v in anc_scores.items()}
+        anc_valid = [anc_per.get(t) for t in ancient_tasks if anc_per.get(t) is not None]
+        row["平均分古代_avg"] = fmt(sum(anc_valid) / len(anc_valid) if anc_valid else None)
+        for t in ancient_tasks:
+            row[f"平均分古代_{t}"] = fmt(anc_per.get(t))
+
+        # 近代区块：只取近代字体下的 per-font 均分，再对字体求平均
+        mod_scores: dict[str, list[float]] = defaultdict(list)
+        for ft in sorted_fonts:
+            if ft in ANCIENT_FONTS:
+                continue
+            for t, v in font_avg.get(ft, {}).items():
+                if t in modern_tasks and v is not None:
+                    mod_scores[t].append(v)
+        mod_per = {t: (sum(v) / len(v) if v else None) for t, v in mod_scores.items()}
+        mod_valid = [mod_per.get(t) for t in modern_tasks if mod_per.get(t) is not None]
+        row["平均分近代_avg"] = fmt(sum(mod_valid) / len(mod_valid) if mod_valid else None)
+        for t in modern_tasks:
+            row[f"平均分近代_{t}"] = fmt(mod_per.get(t))
+
+        rows.append(row)
+
+    df = pd.DataFrame(rows)
+    header1 = ["模型名称"] + ["平均分_古代"] * (len(ancient_tasks) + 1) + ["平均分_近代"] * (len(modern_tasks) + 1)
+    header2 = (
+        ["模型名称", AVG_HEADER]
+        + [display(t) for t in ancient_tasks]
+        + [AVG_HEADER]
+        + [display(t) for t in modern_tasks]
+    )
+
+    column_order = (
+        ["模型名称", "平均分古代_avg"]
+        + [f"平均分古代_{t}" for t in ancient_tasks]
+        + ["平均分近代_avg"]
+        + [f"平均分近代_{t}" for t in modern_tasks]
+    )
+    for col in column_order:
+        if col not in df.columns:
+            df[col] = ""
+    df = df[column_order]
+
+    os.makedirs(os.path.dirname(output_file) or ".", exist_ok=True)
+    with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
+        df.to_excel(writer, sheet_name="评分分析", index=False, startrow=2, header=False)
+        ws = writer.sheets["评分分析"]
+        for ci, v in enumerate(header1, start=1):
+            ws.cell(row=1, column=ci, value=v)
+        for ci, v in enumerate(header2, start=1):
+            ws.cell(row=2, column=ci, value=v)
+        ws.merge_cells(start_row=1, start_column=1, end_row=2, end_column=1)
+        ci = 2
+        ws.merge_cells(start_row=1, start_column=ci, end_row=1, end_column=ci + len(ancient_tasks))
+        ci += len(ancient_tasks) + 1
+        ws.merge_cells(start_row=1, start_column=ci, end_row=1, end_column=ci + len(modern_tasks))
+
+        head_fill = PatternFill(start_color="CCE5FF", end_color="CCE5FF", fill_type="solid")
+        head_font = Font(bold=True)
+        center = Alignment(horizontal="center", vertical="center")
+        for r in (1, 2):
+            for c in range(1, len(header2) + 1):
+                cell = ws.cell(row=r, column=c)
+                cell.fill = head_fill
+                cell.font = head_font
+                cell.alignment = center
+        ws.column_dimensions["A"].width = 30
+        for c in range(2, len(header2) + 1):
+            ws.column_dimensions[get_column_letter(c)].width = 12
+
+    # ==================== Sheet 2: 按字体分析 ====================
+    if sorted_fonts:
+        # 顶部 Average 区域只展示出现过的、属于古代∪近代任一组、且在 DISPLAY_TASKS 内的任务
+        all_visible = filter_display([t for t in all_tasks if t in (set(ANCIENT_TASKS) | set(MODERN_TASKS))])
+
+        type_rows = []
+        for tag in sorted_models:
+            font_avg = per_model_by_font.get(tag, {})
+            cnt = per_model_count.get(tag, {})
+            row: dict[str, object] = {"模型名称": tag}
+
+            scores_by_task: dict[str, list[float]] = defaultdict(list)
+            all_for_avg: list[float] = []
+            for ft, tmap in font_avg.items():
+                allowed = set(font_allowed_tasks(ft, sorted(all_tasks)))
+                for t, v in tmap.items():
+                    if t.startswith("_") or t not in allowed or v is None:
+                        continue
+                    scores_by_task[t].append(v)
+                    all_for_avg.append(v)
+            row["平均分_avg"] = fmt(sum(all_for_avg) / len(all_for_avg) if all_for_avg else None)
+            for t in all_visible:
+                vs = scores_by_task.get(t, [])
+                row[f"平均分_{t}"] = fmt(sum(vs) / len(vs) if vs else None)
+
+            for ft in sorted_fonts:
+                tmap = font_avg.get(ft, {})
+                ft_tasks = font_allowed_tasks(ft, sorted(all_tasks))
+                allowed_set = set(ft_tasks)
+                valid = [v for k, v in tmap.items() if k in allowed_set and v is not None]
+                row[f"{ft}_avg"] = fmt(sum(valid) / len(valid) if valid else None)
+                for t in ft_tasks:
+                    v = tmap.get(t)
+                    row[f"{ft}_{t}"] = fmt(v) if v is not None else ""
+            type_rows.append(row)
+
+        df_t = pd.DataFrame(type_rows)
+        type_header1 = ["模型名称"] + ["平均分"] * (len(all_visible) + 1)
+        for ft in sorted_fonts:
+            type_header1.extend([ft] * (len(font_allowed_tasks(ft, sorted(all_tasks))) + 1))
+        type_header2 = ["模型名称", AVG_HEADER] + [display(t) for t in all_visible]
+        for ft in sorted_fonts:
+            ft_tasks = font_allowed_tasks(ft, sorted(all_tasks))
+            type_header2.append(AVG_HEADER)
+            type_header2.extend(display(t) for t in ft_tasks)
+
+        type_columns = ["模型名称", "平均分_avg"] + [f"平均分_{t}" for t in all_visible]
+        for ft in sorted_fonts:
+            ft_tasks = font_allowed_tasks(ft, sorted(all_tasks))
+            type_columns.append(f"{ft}_avg")
+            type_columns.extend(f"{ft}_{t}" for t in ft_tasks)
+        for col in type_columns:
+            if col not in df_t.columns:
+                df_t[col] = ""
+        df_t = df_t[type_columns]
+
+        with pd.ExcelWriter(output_file, engine="openpyxl", mode="a", if_sheet_exists="replace") as writer:
+            df_t.to_excel(writer, sheet_name="按字体分析", index=False, startrow=2, header=False)
+            ws_t = writer.sheets["按字体分析"]
+            for ci, v in enumerate(type_header1, start=1):
+                ws_t.cell(row=1, column=ci, value=v)
+            for ci, v in enumerate(type_header2, start=1):
+                ws_t.cell(row=2, column=ci, value=v)
+            ws_t.merge_cells(start_row=1, start_column=1, end_row=2, end_column=1)
+            ci = 2
+            ws_t.merge_cells(start_row=1, start_column=ci, end_row=1, end_column=ci + len(all_visible))
+            ci += len(all_visible) + 1
+            for ft in sorted_fonts:
+                span = len(font_allowed_tasks(ft, sorted(all_tasks))) + 1
+                ws_t.merge_cells(start_row=1, start_column=ci, end_row=1, end_column=ci + span - 1)
+                ci += span
+            head_fill_t = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+            for r in (1, 2):
+                for c in range(1, len(type_header2) + 1):
+                    cell = ws_t.cell(row=r, column=c)
+                    cell.fill = head_fill_t
+                    cell.font = head_font
+                    cell.alignment = center
+            ws_t.column_dimensions["A"].width = 30
+            for c in range(2, len(type_header2) + 1):
+                ws_t.column_dimensions[get_column_letter(c)].width = 12
+
+    print(f"\n✅ 已写入 {output_file}")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="ChronoText scoring summary")
+    p.add_argument("--input_dir", type=str, default=str(DEFAULT_INPUT_DIR))
+    p.add_argument("--output", type=str, default=str(DEFAULT_OUTPUT_FILE))
+    p.add_argument("--num_workers", type=int, default=32)
+    args = p.parse_args()
+    analyze(args.input_dir, args.output, args.num_workers)
+
+
+if __name__ == "__main__":
+    main()

eval/utils/image_utils.py

@@ -0,0 +1,77 @@
+"""
+图像编码：把本地图片读成 OpenAI / Anthropic 等通用网关接受的 data URI。
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+from io import BytesIO
+
+from PIL import Image
+
+MAX_IMAGE_SIZE = 8 * 1024 * 1024  # 8MB，超过则压缩
+
+try:
+    import imghdr
+
+    def _detect_format(image_bytes: bytes) -> str | None:
+        return imghdr.what(None, image_bytes)
+except ImportError:
+
+    def _detect_format(image_bytes: bytes) -> str | None:
+        try:
+            with Image.open(BytesIO(image_bytes)) as img:
+                return (img.format or "").lower() or None
+        except Exception:
+            return None
+
+
+def _compress(image_bytes: bytes, max_size: int = MAX_IMAGE_SIZE) -> tuple[bytes, str]:
+    with Image.open(BytesIO(image_bytes)) as img:
+        if img.mode in ("RGBA", "P"):
+            img = img.convert("RGB")
+        for quality in (95, 90, 85, 80, 75, 70, 60):
+            buf = BytesIO()
+            img.save(buf, format="JPEG", quality=quality)
+            if buf.tell() <= max_size:
+                return buf.getvalue(), "jpeg"
+        # 仍超限：缩小分辨率
+        scale = 0.95
+        while scale > 0.1:
+            new_size = (int(img.width * scale), int(img.height * scale))
+            resized = img.resize(new_size, Image.LANCZOS)
+            buf = BytesIO()
+            resized.save(buf, format="JPEG", quality=50)
+            if buf.tell() <= max_size:
+                return buf.getvalue(), "jpeg"
+            scale -= 0.05
+        return buf.getvalue(), "jpeg"
+
+
+def encode_image(image_path: str) -> str:
+    """把本地图片文件读成 ``data:image/<fmt>;base64,<b64>`` data URI。"""
+    if not isinstance(image_path, str) or not image_path:
+        raise ValueError(f"invalid image path: {image_path!r}")
+    if not os.path.isfile(image_path):
+        raise FileNotFoundError(image_path)
+
+    with open(image_path, "rb") as f:
+        image_bytes = f.read()
+
+    fmt = None
+    try:
+        with Image.open(BytesIO(image_bytes)) as img:
+            fmt = (img.format or "").lower() or None
+    except Exception:
+        fmt = _detect_format(image_bytes)
+    if not fmt:
+        raise ValueError(f"无法识别图像格式: {image_path}")
+
+    if len(image_bytes) > MAX_IMAGE_SIZE:
+        image_bytes, fmt = _compress(image_bytes)
+
+    if fmt == "jpeg":
+        fmt = "jpg"
+    b64 = base64.b64encode(image_bytes).decode("utf-8")
+    return f"data:image/{fmt};base64,{b64}"

eval/utils/io.py

@@ -0,0 +1,107 @@
+"""线程安全的增量结果写入器 + 历史结果读取。
+
+用于 infer / judge 场景：把每条样本以 ``image_path`` 为主键写入同一个 jsonl，
+在并发 worker 提交结果时按 ``save_interval`` 周期性落盘，崩溃也不会丢全量进度。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import traceback
+from threading import Lock
+
+from .signal_utils import install_signal_handlers_once
+
+
+def get_image_path(row: dict) -> str:
+    """从一条 row 中取规范化后的图片相对路径（开源 jsonl 唯一字段：image_path）。"""
+    for k in ("image_path", "img_path", "image"):
+        v = row.get(k)
+        if v:
+            return v
+    return ""
+
+
+def read_processed(output_file: str, current_tasks: set[str]) -> tuple[dict[str, dict], set[str]]:
+    """读历史落盘结果，返回 (image_path -> row, 需要重跑的 image_path 集合)。
+
+    缺任意一个 ``current_tasks`` 中的 task 就视为需要补跑。
+    """
+    processed: dict[str, dict] = {}
+    needs: set[str] = set()
+    if not os.path.isfile(output_file):
+        return processed, needs
+    try:
+        with open(output_file, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    item = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                key = get_image_path(item)
+                if not key:
+                    continue
+                infer_results = item.get("infer_results") or item.get("judge_results") or {}
+                completed = set(infer_results.keys())
+                if not current_tasks.issubset(completed):
+                    needs.add(key)
+                processed[key] = item
+    except Exception as e:
+        print(f"读取已处理数据时出错: {e}")
+    return processed, needs
+
+
+class ResultWriter:
+    """周期性落盘 + 全量替换写入；失败回退到 .tmp 文件。"""
+
+    def __init__(self, output_file: str, processed: dict[str, dict], save_interval: int = 1):
+        self.output_file = output_file
+        self.processed = processed
+        self.lock = Lock()
+        self.tmp_file = output_file + ".tmp"
+        self.save_interval = save_interval
+        self.update_count = 0
+        self.last_save_count = 0
+        install_signal_handlers_once()
+
+    def update_and_save(self, result: dict, force_save: bool = False) -> None:
+        with self.lock:
+            key = get_image_path(result)
+            if not key:
+                return
+            self.processed[key] = result
+            self.update_count += 1
+            if force_save or (self.update_count - self.last_save_count >= self.save_interval):
+                self._save_to_disk()
+                self.last_save_count = self.update_count
+
+    def _save_to_disk(self) -> None:
+        try:
+            os.makedirs(os.path.dirname(self.output_file) or ".", exist_ok=True)
+            with open(self.tmp_file, "w", encoding="utf-8") as f:
+                for data in self.processed.values():
+                    f.write(json.dumps(data, ensure_ascii=False) + "\n")
+            if os.path.exists(self.output_file):
+                os.remove(self.output_file)
+            os.rename(self.tmp_file, self.output_file)
+        except Exception as e:
+            print(f"保存到磁盘时出错: {e}")
+            traceback.print_exc()
+
+    def finalize(self) -> None:
+        with self.lock:
+            try:
+                self._save_to_disk()
+            except Exception as e:
+                print(f"保存最终结果时出错: {e}")
+                traceback.print_exc()
+            finally:
+                if os.path.exists(self.tmp_file):
+                    try:
+                        os.remove(self.tmp_file)
+                    except Exception:
+                        pass

eval/utils/signal_utils.py

@@ -0,0 +1,40 @@
+"""全局中止信号：第一次 Ctrl+C 设标志位优雅退出，第二次直接强退。"""
+
+from __future__ import annotations
+
+import os
+import signal
+import threading
+
+ABORT_EVENT = threading.Event()
+_INSTALLED = False
+_SIGINT_COUNT = 0
+
+
+def _handler(signum, frame):
+    global _SIGINT_COUNT
+    _SIGINT_COUNT += 1
+    ABORT_EVENT.set()
+    msg = (
+        "\n[中止] 收到 Ctrl+C，正在请求主循环退出并落盘，再次按 Ctrl+C 将强制退出...\n"
+        if _SIGINT_COUNT == 1
+        else "\n[中止] 再次收到 Ctrl+C，立即强制退出（可能丢失最近未落盘数据）。\n"
+    )
+    try:
+        os.write(2, msg.encode("utf-8", errors="replace"))
+    except Exception:
+        pass
+    if _SIGINT_COUNT >= 2:
+        os._exit(130)
+
+
+def install_signal_handlers_once() -> None:
+    global _INSTALLED
+    if _INSTALLED:
+        return
+    try:
+        signal.signal(signal.SIGINT, _handler)
+        signal.signal(signal.SIGTERM, _handler)
+    except Exception:
+        pass
+    _INSTALLED = True

eval/utils/unk.py

@@ -0,0 +1,57 @@
+"""UNK 占位符的统一定义与处理。
+
+数据集与模型预测里 "无法辨识的字符" 有多种写法，全部归一化到 ``[UNK]``：
+  1. token 形态：``[UNK]`` / ``<UNK>`` / 裸 ``UNK``（不区分大小写）
+  2. 方块占位 ：``□ ■ ▢ ◻ ◼``
+
+注意：全角/半角问号属于标点，不在本模块的处理范围内（由打分时的标点剥离统一处理）。
+"""
+
+from __future__ import annotations
+
+import re
+
+UNK_CANONICAL = "[UNK]"
+
+UNK_BLOCK_CHARS: frozenset[str] = frozenset(
+    {
+        "\u25a1",  # □
+        "\u25a0",  # ■
+        "\u25a2",  # ▢
+        "\u25fb",  # ◻
+        "\u25fc",  # ◼
+    }
+)
+
+UNK_TOKEN_FORMS: frozenset[str] = frozenset({"[unk]", "<unk>", "unk"})
+
+# 1-NED 等场景"剔除"用：[UNK] / <UNK> / 方块整体替换为空
+_UNK_STRIP_PATTERN = re.compile(
+    r"\[UNK\]|<UNK>|[" + "".join(UNK_BLOCK_CHARS) + r"]",
+    flags=re.IGNORECASE,
+)
+
+
+def is_unk_char(ch: str | None) -> bool:
+    """单 char 字段是否表示 UNK。
+
+    覆盖：空字符串、[UNK]/<UNK>/裸 UNK（不区分大小写、忽略首尾空白）、
+    以及 □ ■ ▢ ◻ ◼ 等方块占位（无论是单独一个还是包在空白里）。
+    """
+    if not ch:
+        return True
+    s = ch.strip()
+    if not s:
+        return True
+    if s.lower() in UNK_TOKEN_FORMS:
+        return True
+    if all(c in UNK_BLOCK_CHARS for c in s):
+        return True
+    return False
+
+
+def remove_unk(text: str) -> str:
+    """剔除文本中所有 UNK 占位（用于 1-NED 等需要"忽略 UNK"的指标）。"""
+    if not text:
+        return ""
+    return _UNK_STRIP_PATTERN.sub("", text)