| """Criterion validity: do TCB verdicts predict downstream task behavior? |
| |
| Pre-committed design (declared before seeing results): run the full nine-model panel on two |
| downstream tasks disjoint from the benchmark, with the same final-line answer+confidence |
| elicitation, and test whether TCB accuracy and TCB calibration error predict downstream |
| accuracy and calibration error (Spearman rank correlation over the nine models), and whether |
| the models passing a TCB admission gate (accuracy >= 0.90 and ECE-5 <= 0.05) outperform the |
| models failing it downstream. |
| |
| Downstream task A (annotation): SST-2 sentiment, the canonical crowdsourcing annotation task |
| family; the first 100 validation sentences, asked as "Is the sentiment positive?" (gold = label). |
| Downstream task B (computable QA): the 54-item computable-gold battery released with the |
| companion reporting-standard paper (six domains; every gold label re-derivable by execution). |
| |
| Outputs: data/tcb_criterion_trials.json (per-trial) and data/tcb_criterion.json (summary). |
| Requires the model endpoint (VLLM_API_KEY); analysis of the shipped outputs is offline. |
| """ |
| import json, re, sys, pathlib, math |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from collections import defaultdict |
|
|
| HERE = pathlib.Path(__file__).resolve().parent |
| ROOT = next(p for p in [HERE] + list(HERE.parents) if (p / "_common").is_dir()) |
| sys.path.insert(0, str(ROOT)) |
| from _common.llm_client import LLMClient, ClientConfig |
| from tcb_parsing import parse, chat_parsed |
|
|
| CACHE = HERE / ".." / "data" / "llm_cache" |
| OUT_TRIALS = HERE / ".." / "data" / "tcb_criterion_trials.json" |
| OUT_SUMMARY = HERE / ".." / "data" / "tcb_criterion.json" |
| PANEL_RESULTS = ROOT / "papers" / "P070_qualification_by_calibration" / "data" / "tcb_v03_results.json" |
| BATTERY = ROOT / "papers" / "P065_wisdom_of_the_model_crowd" / "data" / "complementary_battery.json" |
|
|
| MODELS = ["glm-5.1-fp8", "deepseek-v4-pro", "gemma-4-31b", "gptoss-120b", "leanstral-2603", |
| "qwen3-omni-30b-a3b", "qwen3.6-35b-a3b-fp8", "qwen3.6-27b-fp8", "qwen3.5-9b"] |
| PROMPT = "Answer Yes/No and confidence 0-100. ON THE LAST LINE ONLY: ANSWER: Yes|No | CONF: <0-100>" |
| MAX_TOKENS = 512 |
| GATE_ACC, GATE_ECE = 0.90, 0.05 |
|
|
|
|
| def sst2_items(n=100): |
| from datasets import load_dataset |
| ds = load_dataset("stanfordnlp/sst2", split="validation") |
| out = [] |
| for i in range(n): |
| ex = ds[i] |
| q = ("Is the sentiment of the following movie review positive?\n\n" |
| f"Review: {ex['sentence'].strip()}") |
| out.append((f"sst{i}", q, "Yes" if ex["label"] == 1 else "No")) |
| return out |
|
|
| def battery_items(): |
| bench = json.load(open(BATTERY)) |
| return [(it["id"], it["q"], it["truth"]) for it in bench["items"]] |
|
|
| def ece(rows, nb=5): |
| bins = defaultdict(list) |
| for c, cf in rows: |
| p = cf / 100; k = min(nb - 1, int(p * nb)); bins[k].append((c, cf)) |
| n = len(rows); e = 0.0 |
| for rs in bins.values(): |
| mc = sum(cf / 100 for _, cf in rs) / len(rs); ma = sum(c for c, _ in rs) / len(rs) |
| e += len(rs) / n * abs(mc - ma) |
| return e |
|
|
| def spearman(xs, ys): |
| def rank(v): |
| order = sorted(range(len(v)), key=lambda i: v[i]) |
| r = [0.0] * len(v); i = 0 |
| while i < len(order): |
| j = i |
| while j + 1 < len(order) and v[order[j + 1]] == v[order[i]]: |
| j += 1 |
| avg = (i + j) / 2 + 1 |
| for k in range(i, j + 1): |
| r[order[k]] = avg |
| i = j + 1 |
| return r |
| rx, ry = rank(xs), rank(ys) |
| mx, my = sum(rx) / len(rx), sum(ry) / len(ry) |
| num = sum((a - mx) * (b - my) for a, b in zip(rx, ry)) |
| den = math.sqrt(sum((a - mx) ** 2 for a in rx) * sum((b - my) ** 2 for b in ry)) |
| return num / den if den else float("nan") |
|
|
| def main(): |
| cli = LLMClient(ClientConfig(cache_dir=CACHE)) |
| tasks = {"sst2": sst2_items(), "battery": battery_items()} |
| jobs = [] |
| for task, items in tasks.items(): |
| for m in MODELS: |
| seed = 10000000 if task == "sst2" else 8000000 |
| for (iid, q, truth) in items: |
| jobs.append((task, m, iid, q, truth, seed)); seed += 10 |
| print(f"[criterion] {len(jobs)} calls " |
| f"({len(MODELS)} models x ({len(tasks['sst2'])} sst2 + {len(tasks['battery'])} battery))", flush=True) |
|
|
| trials = [] |
| done = 0 |
| with ThreadPoolExecutor(max_workers=64) as ex: |
| fut = {} |
| for (task, m, iid, q, truth, seed) in jobs: |
| fut[ex.submit(chat_parsed, cli, m, PROMPT, q, seed, |
| MAX_TOKENS)] = (task, m, iid, truth) |
| for f in as_completed(fut): |
| task, m, iid, truth = fut[f] |
| try: |
| ans, conf, _s, conf_stated_v, _raw = f.result() |
| conf = conf if (conf_stated_v or conf is None) else None |
| except Exception: |
| ans, conf = None, None |
| trials.append({"task": task, "model": m, "id": iid, "truth": truth, "answer": ans, |
| "conf": conf, "conf_stated": int(conf is not None), |
| "correct": (int(ans == truth) if ans is not None else None)}) |
| done += 1 |
| if done % 200 == 0: |
| print(f"[criterion] {done}/{len(jobs)}", flush=True) |
| json.dump(trials, open(OUT_TRIALS, "w"), indent=1) |
|
|
| panel = json.load(open(PANEL_RESULTS))["per_model"] |
| tcb_acc = {m: panel[m]["accuracy"] for m in MODELS} |
| tcb_ece = {m: panel[m]["ece5"] for m in MODELS} |
| passes = [m for m in MODELS if tcb_acc[m] >= GATE_ACC and tcb_ece[m] <= GATE_ECE] |
| fails = [m for m in MODELS if m not in passes] |
|
|
| summary = {"gate": {"accuracy_min": GATE_ACC, "ece5_max": GATE_ECE, |
| "pass": passes, "fail": fails}, "per_task": {}} |
| for task in tasks: |
| rows_by = defaultdict(list) |
| for r in trials: |
| if r["task"] == task and r["answer"] is not None: |
| rows_by[r["model"]].append((r["correct"], r["conf"] if r["conf"] is not None else 50)) |
| accs = {m: sum(c for c, _ in rows_by[m]) / len(rows_by[m]) for m in MODELS} |
| eces = {m: ece(rows_by[m]) for m in MODELS} |
| rho_acc = spearman([tcb_acc[m] for m in MODELS], [accs[m] for m in MODELS]) |
| rho_ece = spearman([tcb_ece[m] for m in MODELS], [eces[m] for m in MODELS]) |
| gp = sum(accs[m] for m in passes) / len(passes) |
| gf = sum(accs[m] for m in fails) / len(fails) |
| gpe = sum(eces[m] for m in passes) / len(passes) |
| gfe = sum(eces[m] for m in fails) / len(fails) |
| summary["per_task"][task] = { |
| "n_items": len(tasks[task]), |
| "per_model": {m: {"n": len(rows_by[m]), "accuracy": round(accs[m], 4), |
| "ece5": round(eces[m], 4)} for m in MODELS}, |
| "spearman_tcbacc_vs_acc": round(rho_acc, 3), |
| "spearman_tcbece_vs_ece": round(rho_ece, 3), |
| "gate_pass_mean_acc": round(gp, 4), "gate_fail_mean_acc": round(gf, 4), |
| "gate_pass_mean_ece": round(gpe, 4), "gate_fail_mean_ece": round(gfe, 4), |
| "pass_min_acc": round(min(accs[m] for m in passes), 4), |
| "fail_max_acc": round(max(accs[m] for m in fails), 4), |
| } |
| print(f"\n[{task}] rho(acc)={rho_acc:.3f} rho(ece)={rho_ece:.3f} " |
| f"pass acc {gp:.3f} vs fail acc {gf:.3f} | pass ece {gpe:.3f} vs fail ece {gfe:.3f}", flush=True) |
| for m in MODELS: |
| print(f" {m:22s} n={len(rows_by[m]):3d} acc={accs[m]:.3f} ece={eces[m]:.3f}", flush=True) |
| json.dump(summary, open(OUT_SUMMARY, "w"), indent=2) |
| print(f"\n[criterion] wrote {OUT_TRIALS} and {OUT_SUMMARY}", flush=True) |
|
|
| if __name__ == "__main__": |
| main() |
|
|
