Datasets:
Tasks:
Question Answering
Modalities:
Image
Formats:
imagefolder
Languages:
English
Size:
< 1K
License:
Download scripts/make_figures.py from thenaivekid/reasoning-models-cannot-budget-their-thinking: direct link, hf CLI and curl.
- Browser
- Download file 17.2 kB
-
https://huggingface.co/datasets/thenaivekid/reasoning-models-cannot-budget-their-thinking/resolve/main/scripts/make_figures.py
- Command line
-
hf download hf://datasets/thenaivekid/reasoning-models-cannot-budget-their-thinking/scripts/make_figures.py
-
curl -L -o make_figures.py https://huggingface.co/datasets/thenaivekid/reasoning-models-cannot-budget-their-thinking/resolve/main/scripts/make_figures.py
17.2 kB
| """Compute all metrics and figures for the report from ../data only. | |
| Usage: python scripts/make_figures.py -> ../figures/*.png and ../figures/metrics.json | |
| """ | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| HERE = Path(__file__).resolve().parent.parent | |
| DATA, FIG = HERE / "data", HERE / "figures" | |
| FIG.mkdir(exist_ok=True) | |
| for old in FIG.glob("*.png"): | |
| old.unlink() | |
| BUDGETS = [10, 20, 30, 40, 50, 80, 100, 150, 200, 300, 500, 800, 1200, 2000, 4000, 8000] | |
| MODELS = ["Llama-3.2-3B", "Qwen2.5-Math-1.5B"] | |
| COL = {"Llama-3.2-3B": "#1f77b4", "Qwen2.5-Math-1.5B": "#ff7f0e", "Qwen3-4B-Thinking": "#2ca02c", "Qwen3-30B-A3B": "#7f7f7f", "Qwen3-235B": "#17becf"} | |
| M = {} | |
| def wilson(k, n, z=1.96): | |
| if n == 0: return (np.nan, np.nan) | |
| p = k / n; d = 1 + z * z / n; c = p + z * z / (2 * n); h = z * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) | |
| return ((c - h) / d, (c + h) / d) | |
| def flip_stats(A): | |
| """A: (n, 16) graded scores, NaN where a budget was not run.""" | |
| n_b = A.shape[1] | |
| ever = np.nanmax(np.where(np.isnan(A), -1, A), axis=1) >= 1.0 | |
| perfect_flip = np.zeros(len(A), bool); hard_flip = np.zeros(len(A), bool) | |
| first_off = []; surv = np.zeros(n_b); cnt = np.zeros(n_b) | |
| for i in np.where(ever)[0]: | |
| row = A[i]; valid = ~np.isnan(row) | |
| fs = int(np.argmax((row >= 1.0) & valid)) | |
| later = row[fs + 1:]; lv = ~np.isnan(later) | |
| if lv.any(): | |
| perfect_flip[i] = np.any(later[lv] < 1.0); hard_flip[i] = np.any(later[lv] <= 0.0) | |
| idx = np.where(lv & (later < 1.0))[0] | |
| if len(idx): first_off.append(int(idx[0]) + 1) | |
| alive = True | |
| for k in range(1, n_b - fs): | |
| v = row[fs + k] | |
| if np.isnan(v): continue | |
| alive = alive and v >= 1.0; surv[k] += alive; cnt[k] += 1 | |
| fo = np.array(first_off) | |
| return dict(n_ever_solved=int(ever.sum()), perfect_flip_pct=round(100 * perfect_flip[ever].mean(), 1), | |
| hard_flip_pct=round(100 * hard_flip[ever].mean(), 1), | |
| pct_first_flip_at_next_level=round(100 * (fo == 1).mean(), 1) if len(fo) else None, | |
| survival_by_offset=[1.0] + [round(float(surv[k] / cnt[k]), 3) if cnt[k] else None for k in range(1, n_b)]) | |
| def oracle_vs_fixed(A, bud): | |
| """Oracle = per query, cheapest budget that is fully correct (else the cheapest budget, scored 0).""" | |
| full = (np.nan_to_num(A, nan=-1) >= 1.0) | |
| per_b = full.mean(axis=0) * 100 | |
| valid = ~np.all(np.isnan(A), axis=0) | |
| bi = int(np.nanargmax(np.where(valid, per_b, -1))) | |
| ever = full.any(axis=1) | |
| first = np.argmax(full, axis=1) | |
| oracle_cost = np.where(ever, np.array(bud)[first], bud[0]).mean() | |
| solved_at_best = full[:, bi] | |
| cheaper = np.array([full[i, :bi].any() for i in range(len(A))]) | |
| return dict(best_fixed_budget=int(bud[bi]), best_fixed_fully_correct_pct=round(float(per_b[bi]), 1), | |
| oracle_fully_correct_pct=round(float(ever.mean() * 100), 1), | |
| oracle_mean_tokens=round(float(oracle_cost)), best_fixed_tokens=int(bud[bi]), | |
| pct_of_best_fixed_solves_already_solved_cheaper=round(float(cheaper[solved_at_best].mean() * 100), 1), | |
| pct_all_queries_right_cheaper_but_wrong_at_best_fixed=round(float((cheaper & ~solved_at_best).mean() * 100), 1), | |
| fixed_curve={int(b): round(float(p), 2) for b, p, v in zip(bud, per_b, valid) if v}) | |
| # ============================================================ R2-Bench small models | |
| sc = pd.read_parquet(DATA / "r2bench_small_models_scores_by_budget.parquet") | |
| cols = [f"score@{b}" for b in BUDGETS] | |
| M["r2bench"] = {} | |
| fig, ax = plt.subplots(1, 3, figsize=(15, 4)) | |
| for m in MODELS: | |
| d = sc[sc.model == m]; A = d[cols].to_numpy(dtype=float) | |
| valid = ~np.all(np.isnan(A), axis=0); bv = np.array(BUDGETS)[valid] | |
| perfect = np.nanmean(A >= 1.0, axis=0)[valid] * 100 | |
| graded = np.nanmean(A, axis=0)[valid] * 100 | |
| closed = np.maximum.accumulate(np.nan_to_num(A, nan=-1) >= 1.0, axis=1).mean(axis=0)[valid] * 100 | |
| fs = flip_stats(A) | |
| fs.update(perfect_rate_by_budget={int(b): round(float(p), 2) for b, p in zip(bv, perfect)}, | |
| mean_graded_by_budget={int(b): round(float(g), 2) for b, g in zip(bv, graded)}, | |
| closure_inflation_pp_by_budget={int(b): round(float(c - p), 1) for b, c, p in zip(bv, closed, perfect)}, | |
| peak_budget=int(bv[np.argmax(perfect)])) | |
| drops = [(bv[i], bv[j], perfect[i] - perfect[j]) for i in range(len(bv)) for j in range(i + 1, len(bv))] | |
| f, t, pp = max(drops, key=lambda x: x[2]); fs["max_aggregate_drop"] = {"from": int(f), "to": int(t), "pp": round(float(pp), 2)} | |
| fs["oracle_vs_fixed"] = oracle_vs_fixed(A, BUDGETS) | |
| # by question type | |
| fs["by_qtype"] = {} | |
| for qt in sorted(d.qtype.unique()): | |
| Aq = d.loc[d.qtype == qt, cols].to_numpy(dtype=float) | |
| if len(Aq) < 50: continue | |
| q = flip_stats(Aq); q["n_queries"] = int(len(Aq)); q.pop("survival_by_offset") | |
| q["oracle_vs_fixed"] = {k: v for k, v in oracle_vs_fixed(Aq, BUDGETS).items() if k != "fixed_curve"} | |
| fs["by_qtype"][qt] = q | |
| M["r2bench"][m] = fs | |
| ax[0].plot(bv, perfect, "o-", color=COL[m], label=m); ax[0].plot(bv, closed, "--", color=COL[m], alpha=.5) | |
| ax[1].plot(bv, graded, "o-", color=COL[m], label=m) | |
| ax[2].plot(bv, closed - perfect, "o-", color=COL[m], label=m) | |
| ax[0].set_title("Fully-correct rate (%)\nsolid = at that budget, dashed = 'solved at any budget <= x'", fontsize=9) | |
| ax[1].set_title("Mean graded score (%)", fontsize=10) | |
| ax[2].set_title("Gap between the two (pp): what a pass@budget\nleaderboard overstates", fontsize=9) | |
| for a in ax: | |
| a.set_xscale("log"); a.set_xlabel("response budget (words in prompt; hard cap = budget+10 tokens)", fontsize=8); a.grid(alpha=.3); a.legend(fontsize=8) | |
| fig.suptitle("R2-Bench, 30,968 queries, single sample per cell", fontsize=11) | |
| fig.tight_layout(); fig.savefig(FIG / "fig1_accuracy_vs_budget.png", dpi=150); plt.close(fig) | |
| # flips | |
| fig, ax = plt.subplots(figsize=(6.5, 4)) | |
| for m in MODELS: | |
| sv = M["r2bench"][m]["survival_by_offset"] | |
| ax.plot(range(len(sv)), [v if v is not None else np.nan for v in sv], "o-", color=COL[m], label=f"{m} (hard flip {M['r2bench'][m]['hard_flip_pct']}%)") | |
| ax.set_xlabel("budget levels above the first budget that solved it"); ax.set_ylabel("P(still fully correct)"); ax.set_ylim(0, 1.02) | |
| ax.set_title("Survival of a correct answer as budget grows (single sample per cell: upper bound on flipping)", fontsize=9); ax.grid(alpha=.3); ax.legend(fontsize=8) | |
| fig.tight_layout(); fig.savefig(FIG / "fig2_flips.png", dpi=150); plt.close(fig) | |
| # raster, Llama | |
| A = sc.loc[sc.model == "Llama-3.2-3B", cols].to_numpy(dtype=float) | |
| ever = np.nanmax(np.nan_to_num(A, nan=-1), axis=1) >= 1 | |
| rng = np.random.default_rng(0); idx = rng.choice(np.where(ever)[0], 120, replace=False); sub = A[idx] | |
| order = np.argsort(np.argmax(sub >= 1, axis=1)) | |
| fig, ax = plt.subplots(figsize=(8, 7)) | |
| im = ax.imshow(sub[order], aspect="auto", cmap="RdYlGn", vmin=0, vmax=1, interpolation="nearest") | |
| ax.set_xticks(range(16)); ax.set_xticklabels(BUDGETS, rotation=60, fontsize=8); ax.set_xlabel("budget"); ax.set_ylabel("120 random queries Llama-3.2-3B solves at least once (sorted by first solve)") | |
| ax.set_title("Llama-3.2-3B: correctness is not monotone in budget (green = 1.0, red = 0.0)\nrows sorted by first solve, so the left edge is construction; the red to its right is the finding", fontsize=9) | |
| fig.colorbar(im, ax=ax, label="graded score"); fig.tight_layout(); fig.savefig(FIG / "fig3_llama3b_raster.png", dpi=150); plt.close(fig) | |
| # oracle vs fixed: cost-accuracy pareto | |
| fig, ax = plt.subplots(figsize=(7, 4.5)) | |
| for m in MODELS: | |
| o = M["r2bench"][m]["oracle_vs_fixed"] | |
| xs = list(o["fixed_curve"].keys()); ys = list(o["fixed_curve"].values()) | |
| ax.plot(xs, ys, "o-", color=COL[m], label=f"{m}: fixed budget") | |
| ax.scatter([o["oracle_mean_tokens"]], [o["oracle_fully_correct_pct"]], marker="*", s=250, color=COL[m], edgecolor="k", zorder=5, label=f"{m}: per-query cheapest correct budget (oracle)") | |
| ax.annotate("", xy=(o["oracle_mean_tokens"], o["oracle_fully_correct_pct"]), xytext=(o["best_fixed_budget"], o["best_fixed_fully_correct_pct"]), arrowprops=dict(arrowstyle="->", color=COL[m], lw=1.2, ls="--")) | |
| ax.set_xscale("log"); ax.set_xlabel("mean budget spent per query (tokens)"); ax.set_ylabel("fully-correct rate (%)"); ax.grid(alpha=.3); ax.legend(fontsize=7, loc="lower right"); ax.set_ylim(0, 62) | |
| ax.set_title("What knowing how long to think is worth: fixed budgets vs. per-query oracle\n(oracle is an n=1 upper bound; see report)", fontsize=9) | |
| fig.tight_layout(); fig.savefig(FIG / "fig4_oracle_vs_fixed.png", dpi=150); plt.close(fig) | |
| # ============================================================ obedience (Llama only) | |
| ob = pd.read_parquet(DATA / "r2bench_budget_obedience_compact.parquet") | |
| M["obedience"] = {} | |
| fig, ax = plt.subplots(1, 3, figsize=(13, 3.8)) | |
| for i, b in enumerate((50, 200, 800)): | |
| d = ob[(ob.model == "Llama-3.2-3B") & (ob.budget_words == b)] | |
| M["obedience"][f"Llama-3.2-3B@{b}"] = dict(n=int(len(d)), mean_tokens=round(float(d.actual_token_count.mean()), 1), median_tokens=float(d.actual_token_count.median()), | |
| frac_hit_cap=round(float(d.hit_cap.mean()), 3), frac_at_most_N_tokens=round(float((d.actual_token_count <= b).mean()), 3), | |
| frac_at_most_1p3N_tokens=round(float((d.actual_token_count <= 1.3 * b).mean()), 3), | |
| frac_under_15_tokens=round(float((d.actual_token_count < 15).mean()), 3), | |
| mean_score=round(float(d.correctness_score.mean()), 3), perfect_rate=round(float((d.correctness_score >= 1).mean()), 3)) | |
| ax[i].hist(d.actual_token_count, bins=40, color=COL["Llama-3.2-3B"], range=(0, b + 20)) | |
| ax[i].axvline(b, color="k", ls="--", lw=1); ax[i].set_title(f'prompt: "strict budget of {b} words" | {100*d.hit_cap.mean():.0f}% hit the hard cap', fontsize=9); ax[i].set_xlabel("tokens actually generated") | |
| fig.suptitle("Llama-3.2-3B: a budget stated in the prompt is obeyed only when it is already slack (the spike near 10 tokens = bare MCQ letter answers)", fontsize=10) | |
| fig.tight_layout(); fig.savefig(FIG / "fig5_budget_obedience.png", dpi=150); plt.close(fig) | |
| # ============================================================ natural length vs difficulty (Llama, 8k cap, no budget sentence) | |
| H = json.load(open(DATA / "r2bench_llama3b_length_vs_hardness.json"))["Llama-3.2-3B"] | |
| M["length_vs_difficulty_llama3b"] = dict(mean_tokens_by_n_models_solving=H["mean_tokens_by_hardness"], cv=H["cv_by_hardness"], | |
| kendall_tau_len_vs_n_models_solving=H["kendall_tau_len_vs_hardness"], | |
| mean_min_budget_by_n_models_solving=H["mean_minbudget_by_hardness"], mean_overspend_tokens=H["mean_overspend_tokens"]) | |
| fig, ax = plt.subplots(figsize=(7, 4)) | |
| xs = np.arange(11); mt = np.array(H["mean_tokens_by_hardness"]); mb = np.array([np.nan if v is None else v for v in H["mean_minbudget_by_hardness"]]) | |
| sd = np.array(H["std_tokens_by_hardness"]); n = np.array(H["n_by_hardness"]); se = sd / np.sqrt(n) | |
| ax.errorbar(xs, mt, yerr=se, fmt="o-", capsize=3, color=COL["Llama-3.2-3B"], label=f"tokens spent at the slack 8000-word level (mean ± s.e., n={int(n.sum()):,})") | |
| ax.plot(xs, mb, "s--", color="k", alpha=.7, label="cheapest budget that gets it fully right") | |
| ax.set_xlabel("number of the 10 reference models that solve the query (0 = hardest, 10 = easiest)", fontsize=9) | |
| ax.set_ylabel("tokens (mean)"); ax.grid(alpha=.3); ax.legend(fontsize=8) | |
| ax.set_title(f"Llama-3.2-3B spends about the same on the hardest and the easiest questions\n(Kendall tau length vs. ease = {H['kendall_tau_len_vs_hardness']:+.2f}; within-level CV {min(H['cv_by_hardness']):.1f}-{max(H['cv_by_hardness']):.1f})", fontsize=9); fig.subplots_adjust(bottom=0.18) | |
| fig.tight_layout(); fig.savefig(FIG / "fig6_length_vs_difficulty.png", dpi=150); plt.close(fig) | |
| # ============================================================ Qwen3-4B-Thinking on GPQA-Diamond | |
| g = pd.read_json(DATA / "gpqa_diamond_qwen3_4b_thinking_per_question.jsonl", lines=True) | |
| c, w = g[g.correct].gen_tokens, g[~g.correct].gen_tokens | |
| g["q"] = pd.qcut(g.gen_tokens, 5) | |
| byq = g.groupby("q", observed=True).correct.agg(["sum", "size"]) | |
| from itertools import product | |
| auc = float(np.mean([(a < b) + 0.5 * (a == b) for a, b in product(c.to_numpy(), w.to_numpy())])) | |
| M["gpqa_qwen3_4b"] = dict(n=int(len(g)), accuracy=round(float(g.correct.mean()), 3), | |
| tokens_correct=dict(mean=round(float(c.mean())), median=float(c.median()), p10=round(float(c.quantile(.1))), p90=round(float(c.quantile(.9)))), | |
| tokens_wrong=dict(mean=round(float(w.mean())), median=float(w.median()), p10=round(float(w.quantile(.1))), p90=round(float(w.quantile(.9)))), | |
| wrong_costs_pct_more_tokens=round(float(100 * (w.mean() / c.mean() - 1)), 1), | |
| cv_across_questions=round(float(g.gen_tokens.std() / g.gen_tokens.mean()), 3), max_tokens=int(g.gen_tokens.max()), | |
| auc_shorter_is_correct=round(auc, 3), | |
| accuracy_by_length_quintile={f"{int(i.left)}-{int(i.right)}": dict(acc=round(float(r["sum"] / r["size"]), 3), n=int(r["size"]), ci95=[round(v, 3) for v in wilson(r["sum"], r["size"])]) for i, r in byq.iterrows()}) | |
| ec = json.load(open(DATA / "qwen3_4b_phase0_early_commit.json")) | |
| ks = [r["k"] for r in ec["rows"]]; acc = [r["A_k_accuracy"] for r in ec["rows"]]; stab = [r["stability_rate"] for r in ec["rows"]] | |
| M["gpqa_qwen3_4b"]["early_commit"] = {str(k): dict(acc_forced_answer=round(a, 3), agrees_with_own_final_answer=round(s, 3)) for k, a, s in zip(ks, acc, stab)} | |
| M["gpqa_qwen3_4b"]["early_commit"]["full"] = dict(acc_forced_answer=round(ec["a_base_acc"], 3), mean_tokens=8651) | |
| # chance agreement with the final answer if the early pick were independent of it: sum_p p_final(l)^2 ~ use marginal of final preds | |
| pf = g.pred.value_counts(normalize=True); M["gpqa_qwen3_4b"]["early_commit"]["chance_agreement_if_independent"] = round(float((pf ** 2).sum()), 3) | |
| sc_j = json.load(open(DATA / "qwen3_4b_phase0_sc.json")); M["gpqa_qwen3_4b"]["self_consistency_raw"] = sc_j | |
| fig, ax = plt.subplots(1, 3, figsize=(14, 4)) | |
| ax[0].hist([c, w], bins=25, label=[f"correct (n={len(c)}, mean {c.mean():.0f})", f"wrong (n={len(w)}, mean {w.mean():.0f})"], color=["#2ca02c", "#d62728"], alpha=.7) | |
| ax[0].set_xlabel("tokens generated (thinking + answer; cap 32,768 never hit)"); ax[0].set_title("Qwen3-4B-Thinking, GPQA-Diamond:\nthe answers that cost most are the wrong ones", fontsize=9); ax[0].legend(fontsize=8) | |
| qi = np.arange(len(byq)); accs = byq["sum"] / byq["size"]; ci = np.array([wilson(r["sum"], r["size"]) for _, r in byq.iterrows()]) | |
| ax[1].bar(qi, accs, color="#2ca02c", yerr=[accs - ci[:, 0], ci[:, 1] - accs], capsize=3) | |
| ax[1].set_xticks(qi); ax[1].set_xticklabels([f"{int(i.left/1000)}-{int(i.right/1000)}k" for i in byq.index], fontsize=8); ax[1].set_xlabel("trace length quintile"); ax[1].set_ylabel("accuracy (95% CI)"); ax[1].set_ylim(0, 1); ax[1].set_title("Accuracy by trace-length quintile (n≈40 each)", fontsize=9) | |
| xs = np.arange(len(ks) + 1) | |
| ax[2].bar(xs - .2, acc + [ec["a_base_acc"]], .4, label="accuracy when forced to answer at k", color="#2ca02c") | |
| ax[2].bar(xs[:-1] + .2, stab, .4, label="forced answer == its own final answer", color="grey") | |
| ax[2].axhline(0.25, color="k", ls=":", lw=1); ax[2].text(2.45, 0.265, "chance (4-way) for both bars", fontsize=7) | |
| ax[2].set_xticks(xs); ax[2].set_xticklabels([f"k={k}" for k in ks] + ["full\n(~8.7k)"]); ax[2].set_ylim(0, 1); ax[2].legend(fontsize=7) | |
| ax[2].set_title("Stop thinking at k tokens, inject </think> and force an answer", fontsize=9) | |
| fig.tight_layout(w_pad=1.5); fig.savefig(FIG / "fig7_qwen3_4b_gpqa.png", dpi=150); plt.close(fig) | |
| mm = json.load(open(DATA / "qwen3_4b_mmlu_pro_cascade.json")) | |
| M["mmlu_pro_qwen3_4b"] = dict(n=mm["n"], accuracy_4b=mm["a_accuracy"], mean_tokens_4b=mm["mean_a_gen_tokens"], accuracy_30b_a3b=mm["b_accuracy"], mean_tokens_30b_a3b=mm["mean_b_gen_tokens"], | |
| pct_more_tokens_4b_vs_30b=round(100 * (mm["mean_a_gen_tokens"] / mm["mean_b_gen_tokens"] - 1), 1), a_only_router_auc=round(mm["a_only_router_auc"], 3)) | |
| # ============================================================ transfer: larger reference models, same benchmark | |
| lg = pd.read_parquet(DATA / "r2bench_large_reference_scores_by_budget.parquet") | |
| M["transfer_large_models"] = {} | |
| for m in sorted(lg.model.unique()): | |
| A = lg.loc[lg.model == m, cols].to_numpy(dtype=float); f = flip_stats(A); f.pop("survival_by_offset") | |
| f["oracle_vs_fixed"] = {k: v for k, v in oracle_vs_fixed(A, BUDGETS).items() if k != "fixed_curve"} | |
| M["transfer_large_models"][m] = f | |
| json.dump(M, open(FIG / "metrics.json", "w"), indent=1, default=str) | |
| print(json.dumps({k: v for k, v in M.items()}, indent=1, default=str)[:6000]) | |