Datasets:

CheneyWong
/

table_recognition_eval_canonical

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""两个评测 run 的逐 cohort 对比 + bootstrap 置信区间。
v9 训完要回答的问题只有一个：「v9 相对基座/相对 v0，到底是真涨还是噪声」。
单看均值不够 —— 184,074 条上的 0.001 差异常常是噪声，0.02 才是信号。
口径与冻结协议一致：
    主指标 = TEDS-S（与 canonical_teds.primary_metric 一致；空 cell 表如
    synthtabnet / sprint_mustard 的 TEDS 恒为 null，只能看 TEDS-S）
    每个 cohort 单独算，**不把两种口径混在一张表里排序**
CI 用 bootstrap（重采样 10000 次，种子固定）：
    能按样本配对的 cohort -> 配对 bootstrap（消掉样本难易差异，CI 更窄）
    配不上的（上游 sample_id 为空的 9 个 cohort，orig_full 的 scores 里
    155,178/184,074 条 id 是空的）-> 各自独立重采样的非配对 CI
用法:
    python3 src/compare_runs.py --a v1-20261020-025952_checkpoint-3054 --b orig_full
    python3 src/compare_runs.py --a <tagA> --b <tagB> --out reports/x.json
"""
import argparse
import collections
import json
import os
import random
import statistics

V5 = "/autodl-fs/data/povl_v5"
RUNS = f"{V5}/eval/runs"
BOOT = 10000
SEED = 20261020


def load(tag, id_map=None):
    """-> {cohort: {sid: (teds, teds_s)}}
    eval_mix 换过 sample_id 的生成方式: 早期 run 用 pack 里的上游 id,
    后期 run 用 (shard, rg, idx) 定位符。id_map 把定位符翻译回上游 id,
    这样两个 run 才能按样本配对(上游 id 为空的 9 个 cohort 无解, 走非配对)。
    """
    p = f"{RUNS}/{tag}/scores.jsonl"
    out = collections.defaultdict(dict)
    with open(p, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            d = json.loads(line)
            c = d.get("cohort") or "?"
            sid = d.get("sample_id") or ""
            if sid and id_map and sid in id_map:
                sid = id_map[sid]
            if not sid:
                sid = f"__pos_{len(out[c])}"
            t = d.get("teds")
            s = d.get("teds_s")
            if t is None and s is None:
                continue
            out[c][sid] = (t, s)
    return out


def mean(vals):
    vals = [v for v in vals if v is not None]
    return statistics.fmean(vals) if vals else None


# n 大的时候 bootstrap 会慢到没法用(10k x 9.4万 = 9.4 亿次抽样),
# 而均值差的抽样分布在大样本下就是正态的。分界: n <= BOOT_MAX 用真 bootstrap,
# 更大的用正态近似(同样的 1.96 倍标准误), 差可以忽略。
BOOT_MAX = 8000
import numpy as np


def _boot_ci(arrs, paired=False, n=BOOT, seed=SEED):
    """arrs: [a, b] 或配对差值数组。返回 (mean_diff, lo, hi)。"""
    if paired:
        d = np.asarray(arrs, dtype=np.float64)
        m = float(d.mean())
        if len(d) > BOOT_MAX:
            se = float(d.std(ddof=1)) / np.sqrt(len(d))
            return m, m - 1.96 * se, m + 1.96 * se
        rng = np.random.default_rng(seed)
        idx = rng.integers(0, len(d), size=(n, len(d)))
        means = d[idx].mean(axis=1)
        return m, float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5))
    a = np.asarray(arrs[0], dtype=np.float64)
    b = np.asarray(arrs[1], dtype=np.float64)
    m = float(a.mean() - b.mean())
    if max(len(a), len(b)) > BOOT_MAX:
        se = float(np.sqrt(a.var(ddof=1) / len(a) + b.var(ddof=1) / len(b)))
        return m, m - 1.96 * se, m + 1.96 * se
    rng = np.random.default_rng(seed)
    ia = rng.integers(0, len(a), size=(n, len(a)))
    ib = rng.integers(0, len(b), size=(n, len(b)))
    means = a[ia].mean(axis=1) - b[ib].mean(axis=1)
    return m, float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5))


def boot_unpaired(a, b):
    if not a or not b:
        return None, None, None
    return _boot_ci([a, b], paired=False)


def boot_paired(d):
    if not d:
        return None, None, None
    return _boot_ci(d, paired=True)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--a", required=True, help="候选 run 的 tag")
    ap.add_argument("--b", default="orig_full", help="基线 run 的 tag")
    ap.add_argument("--out", default=None)
    ap.add_argument("--min-n", type=int, default=1)
    ap.add_argument("--id-map", default=f"{V5}/data/pack_id_map.json")
    a = ap.parse_args()

    id_map = {}
    if os.path.exists(a.id_map):
        id_map = json.load(open(a.id_map))
        print(f"[id-map] {len(id_map)} 条定位符映射（用于按样本配对）")
    A = load(a.a, id_map)
    B = load(a.b, id_map)
    cohorts = sorted(set(A) | set(B))
    print(f"A={a.a}  B={a.b}  cohorts={len(cohorts)}\n")

    rows = []
    for c in cohorts:
        da, db = A.get(c, {}), B.get(c, {})
        common = sorted(set(da) & set(db))
        paired = [(da[s][1], db[s][1]) for s in common if da[s][1] is not None and db[s][1] is not None]
        va = [v[1] for v in da.values() if v[1] is not None]
        vb = [v[1] for v in db.values() if v[1] is not None]
        if len(va) < a.min_n or len(vb) < a.min_n:
            continue
        ma, mb = mean(va), mean(vb)
        if paired and len(paired) >= 0.5 * min(len(va), len(vb)):
            d, lo, hi = boot_paired([p[0] - p[1] for p in paired])
            kind = "paired"
            npair = len(paired)
            # 关键(2026-10-21 修): 配对时 A/B 的均值必须都取**同一批 id**,
            # 否则 A(小样本 pilot)的均值和 B(全量)的均值是两个不同总体,
            # Δ 里混进了 A 子集的抽样噪声 -> 分母写 n_b=183706 但 A 只有 2500 条。
            ma = mean([p[0] for p in paired])
            mb = mean([p[1] for p in paired])
        else:
            d, lo, hi = boot_unpaired(va, vb)
            kind = "unpaired"
            npair = 0
        rows.append({
            "cohort": c, "n_a": len(va), "n_b": len(vb), "npair": npair,
            "teds_s_a": round(ma, 4), "teds_s_b": round(mb, 4),
            "delta": round(ma - mb, 4),
            "ci_lo": round(float(lo), 4), "ci_hi": round(float(hi), 4), "ci_kind": kind,
            "sig": bool((lo > 0) or (hi < 0)),
        })

    # 全量合计（按样本数加权，也就是所有样本的池化均值差）
    all_a = [v[1] for c in A for v in A[c].values() if v[1] is not None]
    all_b = [v[1] for c in B for v in B[c].values() if v[1] is not None]
    d, lo, hi = boot_unpaired(all_a, all_b)
    total = {
        "n_a": len(all_a), "n_b": len(all_b),
        "teds_s_a": round(mean(all_a), 5), "teds_s_b": round(mean(all_b), 5),
        "delta": round(mean(all_a) - mean(all_b), 5),
        "ci_lo": round(lo, 5), "ci_hi": round(hi, 5),
    }
    # 配对合计(2026-10-21 补): 同一批 sample_id 上 A−B 的均值。
    # 上面的 delta 是"A 的样本集均值 − B 的样本集均值", 当 A 是 pilot 小样本、
    # B 是全量时, 这个差值里混着 A 的抽样噪声(2500 条约 ±0.004),
    # 会让"退化了多少"被系统性夸大/缩小。配对差没有这个问题。
    paired_all = []
    for c in cohorts:
        da, db = A.get(c, {}), B.get(c, {})
        for s in set(da) & set(db):
            if da[s][1] is not None and db[s][1] is not None:
                paired_all.append((da[s][1], db[s][1]))
    if paired_all:
        diffs = [p[0] - p[1] for p in paired_all]
        _d, plo, phi = boot_paired(diffs)
        total["npair"] = len(paired_all)
        total["teds_s_a_paired"] = round(mean([p[0] for p in paired_all]), 5)
        total["teds_s_b_paired"] = round(mean([p[1] for p in paired_all]), 5)
        total["delta_paired"] = round(mean(diffs), 5)
        total["ci_lo_paired"] = round(float(plo), 5)
        total["ci_hi_paired"] = round(float(phi), 5)
        total["sig_paired"] = bool((plo > 0) or (phi < 0))
    # 按 cohort 加权（每个 cohort 等权，跟「17 源里涨跌几个」这种口径一致）
    if rows:
        total["delta_cohort_mean"] = round(statistics.fmean(r["delta"] for r in rows), 5)

    print(f"{'cohort':22s} {'n_a':>7s} {'n_b':>7s} {'A TEDS-S':>9s} {'B TEDS-S':>9s} "
          f"{'Δ':>8s}  {'95%CI':>18s}  显著")
    for r in sorted(rows, key=lambda x: x["delta"]):
        print(f"{r['cohort']:22s} {r['n_a']:7d} {r['n_b']:7d} {r['teds_s_a']:9.4f} "
              f"{r['teds_s_b']:9.4f} {r['delta']:+8.4f}  "
              f"[{r['ci_lo']:+.4f},{r['ci_hi']:+.4f}] {r['ci_kind'][:3]}  "
              f"{'YES' if r['sig'] else ''}")
    print(f"\n合计(按样本): A {total['teds_s_a']}  B {total['teds_s_b']}  "
          f"Δ {total['delta']:+.5f}  95%CI [{total['ci_lo']:+.5f},{total['ci_hi']:+.5f}]")
    if "delta_paired" in total:
        print(f"合计(配对同 id, n={total['npair']}): A {total['teds_s_a_paired']}  "
              f"B {total['teds_s_b_paired']}  Δ {total['delta_paired']:+.5f}  "
              f"95%CI [{total['ci_lo_paired']:+.5f},{total['ci_hi_paired']:+.5f}]"
              f"{'  显著' if total['sig_paired'] else ''}")
    if "delta_cohort_mean" in total:
        print(f"合计(每 cohort 等权): Δ {total['delta_cohort_mean']:+.5f}")
    n_sig = sum(1 for r in rows if r["sig"])
    print(f"显著变好的 cohort: {sum(1 for r in rows if r['sig'] and r['delta'] > 0)} / "
          f"显著变差的: {sum(1 for r in rows if r['sig'] and r['delta'] < 0)} / 共 {len(rows)}")

    out = a.out or f"{V5}/reports/compare_{a.a}_vs_{a.b}.json"
    with open(out, "w", encoding="utf-8") as f:
        json.dump({"a": a.a, "b": a.b, "total": total, "cohorts": rows}, f,
                  ensure_ascii=False, indent=2)
    print(f"\n写出 {out}")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	# -- coding: utf-8 --
	"""两个评测 run 的逐 cohort 对比 + bootstrap 置信区间。

	v9 训完要回答的问题只有一个：「v9 相对基座/相对 v0，到底是真涨还是噪声」。
	单看均值不够 —— 184,074 条上的 0.001 差异常常是噪声，0.02 才是信号。

	口径与冻结协议一致：
	主指标 = TEDS-S（与 canonical_teds.primary_metric 一致；空 cell 表如
	synthtabnet / sprint_mustard 的 TEDS 恒为 null，只能看 TEDS-S）
	每个 cohort 单独算，不把两种口径混在一张表里排序

	CI 用 bootstrap（重采样 10000 次，种子固定）：
	能按样本配对的 cohort -> 配对 bootstrap（消掉样本难易差异，CI 更窄）
	配不上的（上游 sample_id 为空的 9 个 cohort，orig_full 的 scores 里
	155,178/184,074 条 id 是空的）-> 各自独立重采样的非配对 CI

	用法:
	python3 src/compare_runs.py --a v1-20261020-025952_checkpoint-3054 --b orig_full
	python3 src/compare_runs.py --a <tagA> --b <tagB> --out reports/x.json
	"""
	import argparse
	import collections
	import json
	import os
	import random
	import statistics

	V5 = "/autodl-fs/data/povl_v5"
	RUNS = f"{V5}/eval/runs"
	BOOT = 10000
	SEED = 20261020


	def load(tag, id_map=None):
	"""-> {cohort: {sid: (teds, teds_s)}}

	eval_mix 换过 sample_id 的生成方式: 早期 run 用 pack 里的上游 id,
	后期 run 用 (shard, rg, idx) 定位符。id_map 把定位符翻译回上游 id,
	这样两个 run 才能按样本配对(上游 id 为空的 9 个 cohort 无解, 走非配对)。
	"""
	p = f"{RUNS}/{tag}/scores.jsonl"
	out = collections.defaultdict(dict)
	with open(p, encoding="utf-8") as f:
	for line in f:
	line = line.strip()
	if not line:
	continue
	d = json.loads(line)
	c = d.get("cohort") or "?"
	sid = d.get("sample_id") or ""
	if sid and id_map and sid in id_map:
	sid = id_map[sid]
	if not sid:
	sid = f"__pos_{len(out[c])}"
	t = d.get("teds")
	s = d.get("teds_s")
	if t is None and s is None:
	continue
	out[c][sid] = (t, s)
	return out


	def mean(vals):
	vals = [v for v in vals if v is not None]
	return statistics.fmean(vals) if vals else None


	# n 大的时候 bootstrap 会慢到没法用(10k x 9.4万 = 9.4 亿次抽样),
	# 而均值差的抽样分布在大样本下就是正态的。分界: n <= BOOT_MAX 用真 bootstrap,
	# 更大的用正态近似(同样的 1.96 倍标准误), 差可以忽略。
	BOOT_MAX = 8000
	import numpy as np


	def _boot_ci(arrs, paired=False, n=BOOT, seed=SEED):
	"""arrs: [a, b] 或配对差值数组。返回 (mean_diff, lo, hi)。"""
	if paired:
	d = np.asarray(arrs, dtype=np.float64)
	m = float(d.mean())
	if len(d) > BOOT_MAX:
	se = float(d.std(ddof=1)) / np.sqrt(len(d))
	return m, m - 1.96 * se, m + 1.96 * se
	rng = np.random.default_rng(seed)
	idx = rng.integers(0, len(d), size=(n, len(d)))
	means = d[idx].mean(axis=1)
	return m, float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5))
	a = np.asarray(arrs[0], dtype=np.float64)
	b = np.asarray(arrs[1], dtype=np.float64)
	m = float(a.mean() - b.mean())
	if max(len(a), len(b)) > BOOT_MAX:
	se = float(np.sqrt(a.var(ddof=1) / len(a) + b.var(ddof=1) / len(b)))
	return m, m - 1.96 * se, m + 1.96 * se
	rng = np.random.default_rng(seed)
	ia = rng.integers(0, len(a), size=(n, len(a)))
	ib = rng.integers(0, len(b), size=(n, len(b)))
	means = a[ia].mean(axis=1) - b[ib].mean(axis=1)
	return m, float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5))


	def boot_unpaired(a, b):
	if not a or not b:
	return None, None, None
	return _boot_ci([a, b], paired=False)


	def boot_paired(d):
	if not d:
	return None, None, None
	return _boot_ci(d, paired=True)


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("--a", required=True, help="候选 run 的 tag")
	ap.add_argument("--b", default="orig_full", help="基线 run 的 tag")
	ap.add_argument("--out", default=None)
	ap.add_argument("--min-n", type=int, default=1)
	ap.add_argument("--id-map", default=f"{V5}/data/pack_id_map.json")
	a = ap.parse_args()

	id_map = {}
	if os.path.exists(a.id_map):
	id_map = json.load(open(a.id_map))
	print(f"[id-map] {len(id_map)} 条定位符映射（用于按样本配对）")
	A = load(a.a, id_map)
	B = load(a.b, id_map)
	cohorts = sorted(set(A) \| set(B))
	print(f"A={a.a} B={a.b} cohorts={len(cohorts)}\n")

	rows = []
	for c in cohorts:
	da, db = A.get(c, {}), B.get(c, {})
	common = sorted(set(da) & set(db))
	paired = [(da[s][1], db[s][1]) for s in common if da[s][1] is not None and db[s][1] is not None]
	va = [v[1] for v in da.values() if v[1] is not None]
	vb = [v[1] for v in db.values() if v[1] is not None]
	if len(va) < a.min_n or len(vb) < a.min_n:
	continue
	ma, mb = mean(va), mean(vb)
	if paired and len(paired) >= 0.5 * min(len(va), len(vb)):
	d, lo, hi = boot_paired([p[0] - p[1] for p in paired])
	kind = "paired"
	npair = len(paired)
	# 关键(2026-10-21 修): 配对时 A/B 的均值必须都取同一批 id,
	# 否则 A(小样本 pilot)的均值和 B(全量)的均值是两个不同总体,
	# Δ 里混进了 A 子集的抽样噪声 -> 分母写 n_b=183706 但 A 只有 2500 条。
	ma = mean([p[0] for p in paired])
	mb = mean([p[1] for p in paired])
	else:
	d, lo, hi = boot_unpaired(va, vb)
	kind = "unpaired"
	npair = 0
	rows.append({
	"cohort": c, "n_a": len(va), "n_b": len(vb), "npair": npair,
	"teds_s_a": round(ma, 4), "teds_s_b": round(mb, 4),
	"delta": round(ma - mb, 4),
	"ci_lo": round(float(lo), 4), "ci_hi": round(float(hi), 4), "ci_kind": kind,
	"sig": bool((lo > 0) or (hi < 0)),
	})

	# 全量合计（按样本数加权，也就是所有样本的池化均值差）
	all_a = [v[1] for c in A for v in A[c].values() if v[1] is not None]
	all_b = [v[1] for c in B for v in B[c].values() if v[1] is not None]
	d, lo, hi = boot_unpaired(all_a, all_b)
	total = {
	"n_a": len(all_a), "n_b": len(all_b),
	"teds_s_a": round(mean(all_a), 5), "teds_s_b": round(mean(all_b), 5),
	"delta": round(mean(all_a) - mean(all_b), 5),
	"ci_lo": round(lo, 5), "ci_hi": round(hi, 5),
	}
	# 配对合计(2026-10-21 补): 同一批 sample_id 上 A−B 的均值。
	# 上面的 delta 是"A 的样本集均值 − B 的样本集均值", 当 A 是 pilot 小样本、
	# B 是全量时, 这个差值里混着 A 的抽样噪声(2500 条约 ±0.004),
	# 会让"退化了多少"被系统性夸大/缩小。配对差没有这个问题。
	paired_all = []
	for c in cohorts:
	da, db = A.get(c, {}), B.get(c, {})
	for s in set(da) & set(db):
	if da[s][1] is not None and db[s][1] is not None:
	paired_all.append((da[s][1], db[s][1]))
	if paired_all:
	diffs = [p[0] - p[1] for p in paired_all]
	_d, plo, phi = boot_paired(diffs)
	total["npair"] = len(paired_all)
	total["teds_s_a_paired"] = round(mean([p[0] for p in paired_all]), 5)
	total["teds_s_b_paired"] = round(mean([p[1] for p in paired_all]), 5)
	total["delta_paired"] = round(mean(diffs), 5)
	total["ci_lo_paired"] = round(float(plo), 5)
	total["ci_hi_paired"] = round(float(phi), 5)
	total["sig_paired"] = bool((plo > 0) or (phi < 0))
	# 按 cohort 加权（每个 cohort 等权，跟「17 源里涨跌几个」这种口径一致）
	if rows:
	total["delta_cohort_mean"] = round(statistics.fmean(r["delta"] for r in rows), 5)

	print(f"{'cohort':22s} {'n_a':>7s} {'n_b':>7s} {'A TEDS-S':>9s} {'B TEDS-S':>9s} "
	f"{'Δ':>8s} {'95%CI':>18s} 显著")
	for r in sorted(rows, key=lambda x: x["delta"]):
	print(f"{r['cohort']:22s} {r['n_a']:7d} {r['n_b']:7d} {r['teds_s_a']:9.4f} "
	f"{r['teds_s_b']:9.4f} {r['delta']:+8.4f} "
	f"[{r['ci_lo']:+.4f},{r['ci_hi']:+.4f}] {r['ci_kind'][:3]} "
	f"{'YES' if r['sig'] else ''}")
	print(f"\n合计(按样本): A {total['teds_s_a']} B {total['teds_s_b']} "
	f"Δ {total['delta']:+.5f} 95%CI [{total['ci_lo']:+.5f},{total['ci_hi']:+.5f}]")
	if "delta_paired" in total:
	print(f"合计(配对同 id, n={total['npair']}): A {total['teds_s_a_paired']} "
	f"B {total['teds_s_b_paired']} Δ {total['delta_paired']:+.5f} "
	f"95%CI [{total['ci_lo_paired']:+.5f},{total['ci_hi_paired']:+.5f}]"
	f"{' 显著' if total['sig_paired'] else ''}")
	if "delta_cohort_mean" in total:
	print(f"合计(每 cohort 等权): Δ {total['delta_cohort_mean']:+.5f}")
	n_sig = sum(1 for r in rows if r["sig"])
	print(f"显著变好的 cohort: {sum(1 for r in rows if r['sig'] and r['delta'] > 0)} / "
	f"显著变差的: {sum(1 for r in rows if r['sig'] and r['delta'] < 0)} / 共 {len(rows)}")

	out = a.out or f"{V5}/reports/compare_{a.a}_vs_{a.b}.json"
	with open(out, "w", encoding="utf-8") as f:
	json.dump({"a": a.a, "b": a.b, "total": total, "cohorts": rows}, f,
	ensure_ascii=False, indent=2)
	print(f"\n写出 {out}")


	if __name__ == "__main__":
	main()