flowocr 0.1.0__py3-none-any.whl

flowocr/analyze/models/slot_pair.json

@@ -0,0 +1,148 @@
+{
+ "schema": "flowocr-slotpair-lr/1",
+ "train": "seed1,seed2,seed3",
+ "n_pairs": 520,
+ "same_share": 0.4846153846153846,
+ "films": [
+  "f1",
+  "f2",
+  "f5",
+  "gi1",
+  "gi2",
+  "hsr",
+  "zzz"
+ ],
+ "names": [
+  "geom:dx_min",
+  "geom:dx0",
+  "geom:dcx",
+  "geom:dx1",
+  "geom:dcy_h",
+  "geom:dcy",
+  "geom:log_h",
+  "geom:y_ov",
+  "geom:line_pitch",
+  "geom:adjacent",
+  "geom:adjacent_cooccur",
+  "text:d_kana",
+  "text:d_han",
+  "text:d_digit",
+  "text:d_latin",
+  "text:d_punct",
+  "text:d_len",
+  "text:both_sentence",
+  "text:one_sentence",
+  "text:both_digit",
+  "context:jaccard",
+  "context:empty",
+  "context:size_ratio",
+  "time:log_gap",
+  "time:same_win",
+  "time:cooccur",
+  "time:dur_ratio",
+  "block:d_log",
+  "block:min",
+  "motion:any",
+  "motion:both"
+ ],
+ "mean": [
+  0.0699228766025641,
+  0.10799429086538462,
+  0.1030068108974359,
+  0.12767177483974357,
+  3.1936652700273584,
+  0.09923344017094017,
+  0.30246944085804583,
+  0.35316681611785117,
+  0.24837446201624103,
+  0.1346153846153846,
+  0.007692307692307693,
+  0.3061476335921521,
+  0.24061425390179172,
+  0.09853019440556515,
+  0.14903000468764457,
+  0.08401970682965783,
+  0.516788669038046,
+  0.4576923076923077,
+  0.3403846153846154,
+  0.05961538461538462,
+  0.1330363353387835,
+  0.0019230769230769232,
+  0.6306918193550426,
+  7.592952697687726,
+  0.1,
+  0.01730769230769231,
+  1.0078705003845618,
+  0.681853793161734,
+  0.4485574931192945,
+  0.1519230769230769,
+  0.05961538461538462
+ ],
+ "scale": [
+  0.13388792386621018,
+  0.16085754868973048,
+  0.14479836490555978,
+  0.15020911351160118,
+  4.6376748461006905,
+  0.14218357888211486,
+  0.36134124663010053,
+  0.45206150864662475,
+  0.2073480274603558,
+  0.341312295178824,
+  0.0873678207046196,
+  0.3029061891248656,
+  0.26230960474646586,
+  0.23337660396216284,
+  0.31294393806224324,
+  0.11976005219725482,
+  0.48693909795094464,
+  0.49820684376230495,
+  0.47383850518302423,
+  0.2367728669686296,
+  0.15949265901986293,
+  0.04381071442267121,
+  0.5857174299340488,
+  2.345660014795674,
+  0.3,
+  0.13041524487066136,
+  0.8573828048996426,
+  0.740210935304176,
+  0.684135247485618,
+  0.3589463130069757,
+  0.2367728669686296
+ ],
+ "coef": [
+  -0.13316152736046133,
+  -0.3411358672387191,
+  -0.11410692547482951,
+  0.38227353581851553,
+  -0.8556508892457648,
+  0.5270848240780451,
+  -0.42942571709031624,
+  0.5520948637275153,
+  -0.22074383095431555,
+  0.22895759486717707,
+  0.029224699823575707,
+  -0.0482683314998253,
+  -0.2586310825741506,
+  -0.4625004096003223,
+  -0.2559156547516965,
+  -0.12127908932177868,
+  -0.16204901205862512,
+  0.5942057710862333,
+  -0.012059639241410746,
+  -0.04113937671082802,
+  0.9731627405821162,
+  -0.04713657421699171,
+  -0.4469760989209348,
+  -0.34000970439419825,
+  -0.10206692048539355,
+  0.14914510378121065,
+  -0.18930687051081943,
+  -0.7373219232853451,
+  -0.04902222631119288,
+  -0.3098984971627217,
+  0.49250801094168795
+ ],
+ "intercept": -0.22617480264433304
+}

flowocr/analyze/nameplate.py

@@ -0,0 +1,148 @@
+"""**名牌带的几何判据（七条阈值）**——⚠ **2026-09-20 起不再是唯一实现，也不再是推荐的那份**。
+
+取代它的是 `flowocr.analyze.uigate` 的**框位 + 相对位置**判据（ui-gate 计划）：
+五部整片上这七条**四部挑中 0 个**，框位那条五部都有输出，唯一可比的 f3 上精确率打平、召回 +14 个点。
+病根有两层：①第 3 条"字比正文大"和第 6 条"时长落在 [2,10] 秒"**实测全不成立**
+（owner 2026-09-19：第 3 条"不对，删掉"，第 6 条改成"时长通常 >= 台词"）；
+②更要紧的是**输入**——五部里三部的名牌 run 被一个五千到一万条的巨型区域吞掉了，
+**区域那一侧根本没有名牌可挑**。
+
+**2026-09-20 起 `merge_nameplate` 默认不用它了**（`--np-source track`）：名牌改由
+`build_tracks` 打标、投影成一条 `kind="nameplate"` 的轨。这里留下的是：
+`attach()`（贴法 99.8% 准，和判据是两件事）+ 七条阈值本身（`--np-source geom` 的对照臂）。
+**要删七条，先把 `probe_nameplate_geom.py` 一起处理掉**——它存在的意义就是评这七条。
+
+以下是原来的说明。
+
+来历（methodology-audit-2 报告）：把名牌并进主轨，input1 上命中 +66、
+纯标点行漏条率 97.6% → 52.4%，比"并整个辩论屏区域"两项都好。但那次挑名牌用的是
+**角色名表**——探针能用、修法不能用（换素材就没有名表了）。所以判据只看几何和
+区域统计量，**一个字都不看**；名表只出现在 `probe_nameplate_geom.py` 里，用来评
+这个模块准不准（精确率/召回）。
+
+放在单独模块而不是留在探针里，是因为它现在有两个消费者
+（`probe_nameplate_geom.py` 评判据、`merge_nameplate.py` 用判据）。
+历史上这个项目在"同一条规则抄两份"上栽过——methodology-audit 报告那次
+是 5 个工具各写各的 SRT 解析，代价是一个错了 30 小时的计数。
+
+形状假设（每一条都在五部整片上验过，数见 methodology-audit-2 报告）：
+
+* 位置固定：`cx` 在全片上几乎不动（`--cx-std`）；
+* 在正文**上方紧挨着的一档**：`cy` 比主轨小 `--dy` ~ `--dy-max`——
+  **上界不能省**，否则屏幕顶上的标题/计时器也会被挑中；
+* **字比正文大**：字高中位是主轨的 `--font-ratio` 倍以上；
+* **词表很小**：十来个名字轮着出，`distinct_text_ratio` 低；
+* **cue 时长像台词**：中位 4.5–5.5 s。
+  这一条是 2026-09-07 换上去的，换掉的是 `dominant_share <= 0.5`——
+  那道闸门本意是排水印，实际**先把主角的名牌排除了**（`階堂ヒロ` 占那块区域
+  68–85%），f3/f4/f5 的召回因此卡在 40–51%。真正分得开的是时长：
+  名牌 4.5–5.5 s、`Auto` 按钮 21–43 s、误识的 `大`/`米`/`è` 0.5–1.5 s。
+"""
+from __future__ import annotations
+
+import statistics as st
+from bisect import bisect_left
+
+
+def region_stats(d: dict) -> list[dict]:
+    """把 `tracks.json` 的每个区域压成判据要用的那几个量（`runs` 原样带着）。"""
+    W, H = d["size"]
+    regs = []
+    for r in d["regions"]:
+        runs = r["runs"]
+        if not runs:
+            continue
+        cx = [(b["box"][0] + b["box"][2]) / 2 / W for b in runs]
+        f = r["features"]
+        regs.append({"i": r["index"], "label": r["label"], "n": len(runs),
+                     "cy": st.median((b["box"][1] + b["box"][3]) / 2 / H for b in runs),
+                     "cx_std": st.pstdev(cx) if len(cx) > 1 else 0.0,
+                     "h": st.median(b["box"][3] - b["box"][1] for b in runs),
+                     "pers": f["persistence"], "distinct": f["distinct_text_ratio"],
+                     "domi": f["dominant_share"], "dur": f["median_dur_s"],
+                     "fill": f["fill_active"], "score": r["primary_score"], "runs": runs})
+    return regs
+
+
+def explain(r: dict, main_r: dict, a) -> list[tuple[str, bool, str]]:
+    """逐条判据的 (名字, 过没过, 实测值 vs 门槛)。**`pick()` 就是按它判的**——
+    两处分开写必然漂移，这个项目在"同一条规则抄两份"上栽过。
+
+    换素材时最常问的是"为什么一个都没挑中"，而那时**没有角色名表**
+    （名表只有 yuka 那套有）。所以这个函数不看文本、不需要参照，
+    `probe_nameplate_geom.py --names` 省掉时就靠它回答。
+    """
+    return [
+        ("run 数", r["n"] >= a.min_runs, f"{r['n']} >= {a.min_runs}"),
+        ("在正文上方一档", main_r["cy"] - a.dy_max <= r["cy"] <= main_r["cy"] - a.dy,
+         f"cy {r['cy']:.3f}，要落在 [{main_r['cy'] - a.dy_max:.3f}, {main_r['cy'] - a.dy:.3f}]"),
+        ("字比正文大", r["h"] >= main_r["h"] * a.font_ratio,
+         f"字高 {r['h']:.0f} >= {main_r['h']:.0f}×{a.font_ratio} = {main_r['h'] * a.font_ratio:.0f}"),
+        ("位置固定", r["cx_std"] <= a.cx_std, f"cx std {r['cx_std']:.3f} <= {a.cx_std}"),
+        ("词表小", r["distinct"] <= a.max_distinct,
+         f"distinct {r['distinct']:.3f} <= {a.max_distinct}"),
+        ("时长像台词", a.dur_lo <= r["dur"] <= a.dur_hi,
+         f"中位 {r['dur']:.1f}s 落在 [{a.dur_lo}, {a.dur_hi}]"),
+        ("不是常驻", r["fill"] <= a.max_fill, f"fill {r['fill']:.2f} <= {a.max_fill}"),
+    ]
+
+
+def pick(regs: list[dict], a) -> tuple[dict, list[dict]]:
+    """返回 `(主轨区域, 判为名牌的区域)`。`a` 是 `add_args()` 那组参数。"""
+    main_r = max(regs, key=lambda x: x["score"])
+    picked = [r for r in regs if r["i"] != main_r["i"]
+              and all(ok for _, ok, _ in explain(r, main_r, a))]
+    return main_r, picked
+
+
+def attach(main: list, names: list) -> tuple[list, int]:
+    """把名牌**贴进时间重叠最大的那条正文 cue 的首行**，返回 (SRT blocks, 贴上几条)。
+
+    贴法决定一切（speaker-name-line 报告离线量过三种）：
+    "覆盖 cue 起点的最后一条" 只有 73.1% 对、"起点最近 ±1.5s" 97.2%、
+    **"时间重叠最大" 99.8%**（938/940）。第一版探针用的是 73% 那种，
+    结论出来是"贴了等于没贴"——那是贴错了 27%，不是名字没用。
+
+    两个消费者：`probe_add_speaker.py`（探针，名表过滤后贴）和
+    `merge_nameplate.py --paste`（修法，几何判据挑区域后贴）。**别抄第三份。**
+    """
+    starts = [c.start for c in names]
+    blocks, tagged = [], 0
+    for c in main:
+        i = bisect_left(starts, c.start)
+        nm, best = None, 0.0
+        for j in range(max(0, i - 8), min(len(names), i + 8)):
+            o = min(names[j].end, c.end) - max(names[j].start, c.start)
+            if o > best:
+                nm, best = names[j], o
+        lines = list(c.lines)
+        if nm is not None and nm.lines and nm.text("") not in c.text(""):
+            lines = [nm.lines[0]] + lines
+            tagged += 1
+        blocks.append((int(round(c.start * 1e6)), int(round(c.end * 1e6)), lines))
+    return blocks, tagged
+
+
+def add_args(ap) -> None:
+    """判据的旋钮。两个消费者共用，**别抄第二份**。"""
+    ap.add_argument("--dy", type=float, default=0.04,
+                    help="名牌至少要在主轨上方这么多（归一化 cy）")
+    ap.add_argument("--dy-max", type=float, default=0.15,
+                    help="但也不能高太多——那是屏幕顶上的标题")
+    ap.add_argument("--max-distinct", type=float, default=0.25,
+                    help="不同文本的占比上限：名牌就十来个名字轮着出")
+    ap.add_argument("--dur-lo", type=float, default=2.0,
+                    help="cue 时长中位的下限（秒）：名牌跟着台词走，一句几秒")
+    ap.add_argument("--dur-hi", type=float, default=10.0,
+                    help="上限：常驻按钮/水印一挂就是几十秒（`Auto` 实测 21-43 s）")
+    ap.add_argument("--max-fill", type=float, default=0.8,
+                    help="fill_active 上限：真水印几乎全程在（`#` 实测 1.00）。"
+                         "**在 yuka 五部上一个数都不改**，是给别的素材兜底的")
+    ap.add_argument("--font-ratio", type=float, default=1.3,
+                    help="字高中位至少是主轨的几倍")
+    ap.add_argument("--cx-std", type=float, default=0.10,
+                    help="cx 的标准差上限（位置固定）。0.06 -> 0.10 让 f4 的召回从 "
+                         "50.7%% 涨到 90.1%%，另外四部一个数不动；0.14 和 0.10 结果完全相同，"
+                         "**阈值坐在平台上而不是悬崖上**")
+    ap.add_argument("--min-runs", type=int, default=30,
+                    help="区域小于这么多 run 就不考虑")

flowocr/analyze/pair_features.py

@@ -0,0 +1,168 @@
+"""**两条 run 该不该在一起**的成对特征，按"通道"分组——用来回答"哪种信号真有信息"（next-steps，owner 2026-09-21）。
+
+聚类的尺（`slot_pairs.py`）产出了带标注的 run 对；这里给每一对算特征，`pair_model.py` 拿它们做逐通道消融。
+**先知道哪条通道有用，再决定把它怎么接进聚类**——不先造算法再找证据。
+
+通道：
+
+    geom     几何：x0 / cx / x1 / cy / 上下边的差、字高比、y 区间重叠。现行缝合只用这一条
+    text     文本形态：长度、假名 / 汉字 / 拉丁 / 数字 / 标点占比、是不是句子样（句末标点、含假名）。
+             同一个元素里的文本形态很稳（台词是句子、HUD 是数字、名牌是短名词）
+    context  **时间当关系信号用**（owner："时间是个可用于否决的弱信号，但怎么用需要好的设计"）：
+             一条 run 在屏时，**同屏还有哪些位置有字**。对话正文总和名牌、Auto 键一起出现；
+             菜单项总和别的菜单项一起出现。两条 run 位置相同、同屏伙伴却完全不同 → 多半不是同一个元素。
+             做法：画面切成 CELLS 网格，每秒记哪些格子有字；run 的上下文 = 它在屏期间出现过的格子
+             （去掉自己那一格和紧邻的），按 idf 加权（常驻水印那种格子几乎不计）；两条 run 比加权 Jaccard
+    time     朴素的时间：间隔（对数）、是否同一个 60 s 窗、在屏时长比
+    block    块：同屏、同左边、同字高的行数（阅读面板 / 名单是一大块，对话是 1~3 行）
+    motion   `Run.moving` / `Run.scrolling`
+
+用法：
+    F = PairFeatures(L)                 # L 来自 cluster_layers.load
+    x, names = F.pair(i, j)             # 两条 run 的下标 -> 特征向量
+"""
+from __future__ import annotations
+
+import math
+import unicodedata
+from collections import Counter, defaultdict
+
+
+CELLS = (16, 18)                        # x 方向 16 格、y 方向 18 格（1080p 上 120 × 60 px）
+CTX_SECONDS = 12                        # 一条 run 只取在屏的前这么多秒算上下文（常驻的不必扫全程）
+CHANNELS = ("geom", "text", "context", "time", "block", "motion")
+
+
+def char_profile(t: str) -> dict[str, float]:
+    t = "".join(unicodedata.normalize("NFKC", t).split())
+    n = max(1, len(t))
+    c = Counter()
+    for ch in t:
+        o = ord(ch)
+        if 0x3040 <= o <= 0x30FF:
+            c["kana"] += 1
+        elif 0x4E00 <= o <= 0x9FFF:
+            c["han"] += 1
+        elif ch.isdigit():
+            c["digit"] += 1
+        elif ch.isascii() and ch.isalpha():
+            c["latin"] += 1
+        elif not ch.isalnum():
+            c["punct"] += 1
+    out = {k: c[k] / n for k in ("kana", "han", "digit", "latin", "punct")}
+    out["len"] = math.log1p(len(t))
+    out["sentence"] = float(bool(t) and (t[-1] in "。！？!?…」』）)" or c["kana"] >= 3))
+    return out
+
+
+def content_len(t: str) -> int:
+    return sum(1 for c in t if c.isalnum())
+
+
+MIN_CONTENT, MIN_OBS = 3, 2
+"""**只在"像样的文字"里抽**：内容 ≥3 字、至少 2 次观测。第一版按 run 数加权、不筛，
+f5 头 4 对里 3 对是 OCR 把**鼠标指针**读成的字（只能标 unsure），标注预算被垃圾区域吃掉。
+⚠ 这是一道筛子：尺量不到"垃圾 run 落在哪个槽位"——那是清噪的事，不是聚类的对错；
+`sample` 会把筛掉的 run 占比打出来，读数时摆在旁边。"""
+
+
+def good_run(r) -> bool:
+    return content_len(r.text) >= MIN_CONTENT and r.n_obs >= MIN_OBS
+
+
+FEATURE_NAMES = [
+    "geom:dx_min", "geom:dx0", "geom:dcx", "geom:dx1", "geom:dcy_h", "geom:dcy", "geom:log_h", "geom:y_ov",
+    "geom:line_pitch", "geom:adjacent", "geom:adjacent_cooccur", "text:d_kana", "text:d_han", "text:d_digit", "text:d_latin", "text:d_punct", "text:d_len",
+    "text:both_sentence", "text:one_sentence", "text:both_digit", "context:jaccard", "context:empty",
+    "context:size_ratio", "time:log_gap", "time:same_win", "time:cooccur", "time:dur_ratio", "block:d_log",
+    "block:min", "motion:any", "motion:both"]
+"""`pair()` 吐的特征顺序。落盘的模型按这张表核对——特征一改，旧模型就不许再用。"""
+
+
+class PairFeatures:
+    def __init__(self, L) -> None:
+        self.L = L
+        self.runs = L.runs
+        W, H = L.W, L.H
+        self.cell = [(min(CELLS[0] - 1, int(r.cx / W * CELLS[0])), min(CELLS[1] - 1, int(r.cy / H * CELLS[1])))
+                     for r in self.runs]
+        self.prof = [char_profile(r.text) for r in self.runs]
+        # 每秒哪些格子有字 / 哪些 run 在屏
+        self.by_sec: dict[int, list[int]] = defaultdict(list)
+        for i, r in enumerate(self.runs):
+            for s in range(int(r.t_start // 1e6), int(r.t_end // 1e6) + 1):
+                self.by_sec[s].append(i)
+        occ = Counter()
+        for s, ids in self.by_sec.items():
+            for c in {self.cell[i] for i in ids}:
+                occ[c] += 1
+        T = max(1, len(self.by_sec))
+        self.idf = {c: math.log(T / n) for c, n in occ.items()}
+        self._ctx: dict[int, dict] = {}
+        self._blk: dict[int, int] = {}
+
+    def context(self, i: int) -> dict[tuple, float]:
+        if i not in self._ctx:
+            r, (cx, cy) = self.runs[i], self.cell[i]
+            s0 = int(r.t_start // 1e6)
+            cells = set()
+            for s in range(s0, min(int(r.t_end // 1e6), s0 + CTX_SECONDS) + 1):
+                cells.update(self.cell[j] for j in self.by_sec.get(s, ()) if j != i)
+            self._ctx[i] = {c: self.idf.get(c, 0.0) for c in cells
+                            if abs(c[0] - cx) > 1 or abs(c[1] - cy) > 1}
+        return self._ctx[i]
+
+    def block(self, i: int) -> int:
+        """同屏、左边对齐（±1.5% 画面宽）、字高相近（比 ≤1.3）的行数（含自己）。"""
+        if i not in self._blk:
+            r = self.runs[i]
+            s = int((r.t_start + min(r.t_end, r.t_start + 2_000_000)) // 2e6)
+            self._blk[i] = sum(1 for j in self.by_sec.get(s, ())
+                               if abs(self.runs[j].box[0] - r.box[0]) <= 0.015 * self.L.W
+                               and max(self.runs[j].h, r.h) / max(1.0, min(self.runs[j].h, r.h)) <= 1.3)
+        return self._blk[i]
+
+    def pair(self, i: int, j: int) -> tuple[list[float], list[str]]:
+        a, b, W, H = self.runs[i], self.runs[j], self.L.W, self.L.H
+        h = max(1.0, min(a.h, b.h))
+        f: dict[str, float] = {}
+        dx0, dcx, dx1 = abs(a.box[0] - b.box[0]) / W, abs(a.cx - b.cx) / W, abs(a.box[2] - b.box[2]) / W
+        f["geom:dx_min"] = min(dx0, dcx, dx1)
+        f["geom:dx0"], f["geom:dcx"], f["geom:dx1"] = dx0, dcx, dx1
+        f["geom:dcy_h"] = min(20.0, abs(a.cy - b.cy) / h)
+        f["geom:dcy"] = abs(a.cy - b.cy) / H
+        f["geom:log_h"] = abs(math.log(max(1.0, a.h) / max(1.0, b.h)))
+        ov = min(a.box[3], b.box[3]) - max(a.box[1], b.box[1])
+        f["geom:y_ov"] = max(0.0, ov) / h
+        f["geom:line_pitch"] = abs((abs(a.cy - b.cy) / h) - round(abs(a.cy - b.cy) / h / 1.35) * 1.35)   # 离"整数行距"多远
+        # **相邻行**：同锚点、同字高、隔一到两个行距。线性模型只有"竖直距离越大越不像"一项，表达不了
+        # "多行正文的上下行是同一块"——hsr 的三行台词因此被拆成两个区域、每段都够不着剧本行（2026-09-21）。
+        # 同屏出现的相邻行是最强的证据（同一时刻、同一个锚点、差一个行距 = 同一块多行文本），单列一项。
+        gap0 = max(0, max(a.t_start, b.t_start) - min(a.t_end, b.t_end))
+        adj = float(0.7 <= f["geom:dcy_h"] <= 2.9 and f["geom:dx_min"] <= 0.02 and f["geom:log_h"] <= 0.26)
+        f["geom:adjacent"] = adj
+        f["geom:adjacent_cooccur"] = adj * float(gap0 == 0)
+        pa, pb = self.prof[i], self.prof[j]
+        for k in ("kana", "han", "digit", "latin", "punct", "len"):
+            f[f"text:d_{k}"] = abs(pa[k] - pb[k])
+        f["text:both_sentence"] = pa["sentence"] * pb["sentence"]
+        f["text:one_sentence"] = abs(pa["sentence"] - pb["sentence"])
+        f["text:both_digit"] = float(pa["digit"] > 0.3 and pb["digit"] > 0.3)
+        ca, cb = self.context(i), self.context(j)
+        inter = sum(min(ca[c], cb[c]) for c in ca.keys() & cb.keys())
+        union = sum(ca.values()) + sum(cb.values()) - inter
+        f["context:jaccard"] = inter / union if union > 0 else 0.0
+        f["context:empty"] = float(not ca or not cb)
+        f["context:size_ratio"] = abs(math.log((1 + len(ca)) / (1 + len(cb))))
+        gap = max(0, max(a.t_start, b.t_start) - min(a.t_end, b.t_end)) / 1e6
+        f["time:log_gap"] = math.log1p(gap)
+        f["time:same_win"] = float(a.t_start // 60_000_000 == b.t_start // 60_000_000)
+        f["time:cooccur"] = float(gap == 0)
+        f["time:dur_ratio"] = abs(math.log((1 + a.t_end - a.t_start) / (1 + b.t_end - b.t_start)))
+        f["block:d_log"] = abs(math.log(self.block(i) / self.block(j)))
+        f["block:min"] = math.log(min(self.block(i), self.block(j)))
+        f["motion:any"] = float(a.moving or a.scrolling or b.moving or b.scrolling)
+        f["motion:both"] = float((a.moving or a.scrolling) and (b.moving or b.scrolling))
+        names = list(f)
+        assert names == FEATURE_NAMES, "pair() 的特征顺序和 FEATURE_NAMES 对不上"
+        return [f[k] for k in names], names

flowocr/analyze/pair_model.py

@@ -0,0 +1,127 @@
+"""逐通道消融：哪种信号对"这两条 run 该不该在一起"真有信息（特征见 `pair_features.py`）。
+
+在 dev 的标注对上训一个小模型、在留出集上测，**逐通道**报：单独用这一条 / 全用 / 全用但去掉这一条。
+同一批留出对上各条缝合臂的对错率摆在旁边当参照（臂只有"同槽 / 异槽"两个输出，模型是它的上界参照，不是替代品）。
+
+⚠ 样本只有几百对：只读**方向和量级**，别读小数点。模型用带标准化的逻辑回归（可解释、不容易过拟合）；
+`--gbdt` 另报一个浅的梯度提升做对照——两者方向不一致的通道不要信。
+
+用法：
+    python -m flowocr.analyze.pair_model --train dev --test acceptance
+    python -m flowocr.analyze.pair_model --train dev,acceptance --test seed3        # seed 3 那批标完之后
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+from pathlib import Path
+
+import numpy as np
+
+from flowocr.analyze import cluster_layers as CL  # noqa: E402
+from flowocr.analyze import pair_features as PF  # noqa: E402
+from flowocr import paths  # noqa: E402
+from flowocr.analyze import slot_pairs as SP  # noqa: E402
+
+
+def load(selectors: list[str]):
+    """selectors：`dev` / `acceptance`（按 split）或 `seedN`（按 seed）。返回 X, y, 元信息, 特征名。"""
+    X, y, meta, names = [], [], [], None
+    by_tag: dict[str, list] = {}
+    for p in sorted(glob.glob(str(paths.data_root() / "data/gt/slotpairs-*.json"))):
+        doc = json.loads(Path(p).read_text(encoding="utf-8"))
+        if not (doc.get("split") in selectors or f"seed{doc['seed']}" in selectors):
+            continue
+        if any(s.startswith("seed") for s in selectors) and f"seed{doc['seed']}" not in selectors:
+            continue
+        by_tag.setdefault(doc["tag"], []).extend(doc["items"])
+    for tag, items in by_tag.items():
+        L = CL.load(tag)
+        F = PF.PairFeatures(L)
+        key = {(r.t_start, r.t_end, r.text, tuple(round(v) for v in r.box)): i for i, r in enumerate(L.runs)}
+        for it in items:
+            if it["label"] not in ("same", "different"):
+                continue
+            i, j = key.get(SP.item_key(it["a"])), key.get(SP.item_key(it["b"]))
+            if i is None or j is None:
+                continue
+            x, names = F.pair(i, j)
+            X.append(x)
+            y.append(int(it["label"] == "same"))
+            meta.append((tag, it["id"], it["stratum"]))
+    return np.array(X, float), np.array(y), meta, names
+
+
+def main() -> int:
+    from sklearn.ensemble import GradientBoostingClassifier
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.metrics import roc_auc_score
+    from sklearn.pipeline import make_pipeline
+    from sklearn.preprocessing import StandardScaler
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--train", default="dev")
+    ap.add_argument("--test", default="acceptance")
+    ap.add_argument("--gbdt", action="store_true")
+    a = ap.parse_args()
+    Xtr, ytr, _, names = load(a.train.split(","))
+    Xte, yte, mte, _ = load(a.test.split(","))
+    print(f"训练 {len(ytr)} 对（same {ytr.mean():.0%}）、留出 {len(yte)} 对（same {yte.mean():.0%}）；特征 {len(names)} 个")
+
+    def fit_eval(cols: list[int], gbdt: bool = False) -> tuple[float, float]:
+        m = (GradientBoostingClassifier(n_estimators=60, max_depth=2, subsample=0.8, random_state=0) if gbdt
+             else make_pipeline(StandardScaler(), LogisticRegression(C=0.5, max_iter=2000)))
+        m.fit(Xtr[:, cols], ytr)
+        p = m.predict_proba(Xte[:, cols])[:, 1]
+        return float(((p > 0.5) == yte).mean()), float(roc_auc_score(yte, p))
+
+    chan = {c: [k for k, n in enumerate(names) if n.startswith(c + ":")] for c in PF.CHANNELS}
+    allc = list(range(len(names)))
+    kinds = [("LR", False)] + ([("GBDT", True)] if a.gbdt else [])
+    for kind, g in kinds:
+        acc, auc = fit_eval(allc, g)
+        print(f"\n[{kind}] 全部通道：准确率 {acc:.1%}、AUC {auc:.3f}")
+        print(f"  {'通道':<10}{'只用它':>16}{'去掉它':>16}   （准确率 / AUC）")
+        for c, cols in chan.items():
+            a1, u1 = fit_eval(cols, g)
+            a0, u0 = fit_eval([k for k in allc if k not in cols], g)
+            print(f"  {c:<10}{f'{a1:.1%} / {u1:.3f}':>16}{f'{a0:.1%} / {u0:.3f}':>16}")
+    m = make_pipeline(StandardScaler(), LogisticRegression(C=0.5, max_iter=2000)).fit(Xtr, ytr)
+    coef = m[-1].coef_[0]
+    print("\nLR 标准化系数（正 = 倾向 same）：")
+    for k in np.argsort(-np.abs(coef))[:14]:
+        print(f"  {names[k]:<24}{coef[k]:+.2f}")
+
+    # 参照：同一批留出对上各条缝合臂的准确率
+    from flowocr.analyze import slot_lines
+    from flowocr.analyze import slot_modes
+    by_tag: dict[str, list[int]] = {}
+    for k, (tag, _, _) in enumerate(mte):
+        by_tag.setdefault(tag, []).append(k)
+    docs = {}
+    for p in sorted(glob.glob(str(paths.data_root() / "data/gt/slotpairs-*.json"))):
+        d = json.loads(Path(p).read_text(encoding="utf-8"))
+        for it in d["items"]:
+            docs[it["id"]] = it
+    right: dict[str, int] = {}
+    n_ref = 0
+    for tag, ks in by_tag.items():
+        L = CL.load(tag)
+        asg = {name: SP.assignment(L, CL.stitch(L, **over)) for name, over in SP.ARMS.items()}
+        asg["modes"] = SP.assignment(L, slot_modes.stitch(L))
+        got = slot_lines.assign(L)
+        asg["lines"] = {(r.t_start, r.t_end, r.text, tuple(round(v) for v in r.box)): got[i] for i, r in enumerate(L.runs)}
+        for k in ks:
+            v = SP.verdicts(asg, docs[mte[k][1]])
+            if v is None:                          # 对不回 run 的不进任何臂的分母
+                continue
+            n_ref += 1
+            for name, ok in v.items():
+                right[name] = right.get(name, 0) + int(ok)
+    print("\n参照——同一批留出对上各条缝合臂的准确率（含 S1）：")
+    print(f"  （{n_ref}/{len(yte)} 对在各臂上都对得回 run）  " + "  ".join(f"{n} {v / max(1, n_ref):.1%}" for n, v in right.items()))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())