"""Render the prompt-prefix injection figure (paper fig 10). This is the paper's new headline result: training-free prefix injection beats training-based QLoRA restoration. The figure is designed to make that claim read in under 2 seconds. """ import argparse import glob import json import os import re import sys import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) mpl.rcParams.update({ "font.family": "sans-serif", "font.sans-serif": ["Inter", "Helvetica Neue", "Arial", "DejaVu Sans"], "font.size": 9, "axes.labelsize": 10, "xtick.labelsize": 8.5, "ytick.labelsize": 8.5, "legend.fontsize": 8, "legend.frameon": False, "figure.dpi": 200, "savefig.dpi": 400, "savefig.bbox": "tight", "pdf.fonttype": 42, "ps.fonttype": 42, "axes.linewidth": 0.7, "axes.spines.top": False, "axes.spines.right": False, }) PRIMARY = "#C03A2B" # deep red for the headline series QLORA_C = "#2E7D32" # green for QLoRA comparator FP16_C = "#333333" # dark grey BASE_C = "#888888" # light grey def _bootstrap(jsonl_path, n_boot=5000): if not os.path.exists(jsonl_path): return None v = [] with open(jsonl_path) as f: for line in f: t = json.loads(line) v.append(1.0 if t.get("is_correct_final") else 0.0) if not v: return None v = np.array(v) rng = np.random.default_rng(0) s = np.empty(n_boot) for i in range(n_boot): idx = rng.integers(0, len(v), size=len(v)) s[i] = v[idx].mean() return float(v.mean()), float(np.percentile(s, 2.5)), float(np.percentile(s, 97.5)) def main(): parser = argparse.ArgumentParser() parser.add_argument("--sweep-root", required=True) parser.add_argument("--model", required=True) parser.add_argument("--quant", required=True) parser.add_argument("--benchmark", required=True) parser.add_argument("--metrics", required=True) parser.add_argument("--segmented", default="results/segmented") parser.add_argument("--output", required=True) args = parser.parse_args() ks, means, los, his = [], [], [], [] for entry in sorted(os.listdir(args.sweep_root)): m = re.match(r"k(\d+)$", entry) if not m: continue k = int(m.group(1)) diag = os.path.join(args.sweep_root, entry, "diagnosis", f"{args.benchmark}_run0.jsonl") ci = _bootstrap(diag) if ci is None: continue ks.append(k); means.append(ci[0] * 100); los.append(ci[1] * 100); his.append(ci[2] * 100) if not ks: print("No prefix-injection data found.") return idx = np.argsort(ks) ks = [ks[i] for i in idx]; means = [means[i] for i in idx] los = [los[i] for i in idx]; his = [his[i] for i in idx] base_path = os.path.join(args.metrics, f"{args.model}_{args.quant}_{args.benchmark}_run0_metrics.json") base_acc = json.load(open(base_path))["accuracy"] * 100 if os.path.exists(base_path) else None from eval_accuracy import accuracy as _lv_acc fp16_jsonl = os.path.join(args.segmented, "fp16", args.model, f"{args.benchmark}_run0.jsonl") fp16_v = _lv_acc(fp16_jsonl, args.benchmark) fp16_acc = fp16_v * 100 if fp16_v else None rest_path = os.path.join(args.metrics, f"{args.model}_{args.quant}_restored_{args.benchmark}_run0_metrics.json") rest_acc = json.load(open(rest_path))["accuracy"] * 100 if os.path.exists(rest_path) else None # ---------- Figure ---------- # Taller than the default to leave room for a 2-row legend below the # x-axis without squeezing the headline plot. fig, ax = plt.subplots(figsize=(5.8, 3.9)) # Shade the quantization gap: from quantized baseline up to FP16. if base_acc is not None and fp16_acc is not None: ax.axhspan(base_acc, fp16_acc, color="#EDEDED", alpha=1.0, zorder=0, label="_gap") # CI whiskers + markers + line for the prefix series. for x, m, lo, hi in zip(ks, means, los, his): ax.plot([x, x], [lo, hi], color=PRIMARY, linewidth=1.4, alpha=0.5, zorder=2, solid_capstyle="butt") ax.plot(ks, means, "-", color=PRIMARY, linewidth=2.4, zorder=3, label="Prompt-prefix injection (ours, training-free)") ax.plot(ks, means, "o", color=PRIMARY, markersize=7, markeredgecolor="white", markeredgewidth=1.3, zorder=4) # Reference lines — drawn after the shading, before the headline series. if base_acc is not None: ax.axhline(base_acc, color=BASE_C, linestyle=(0, (5, 3)), linewidth=1.0, zorder=1, label=f"Quantized baseline ({base_acc:.1f}%)") if rest_acc is not None: ax.axhline(rest_acc, color=QLORA_C, linestyle=(0, (3, 2)), linewidth=1.2, zorder=1, label=f"QLoRA restored ({rest_acc:.1f}%)") if fp16_acc is not None: ax.axhline(fp16_acc, color=FP16_C, linestyle=(0, (1, 2)), linewidth=1.0, zorder=1, label=f"FP16 ({fp16_acc:.1f}%)") # Value labels above points (not below — below collides with lines/labels). for x, m, hi in zip(ks, means, his): ax.annotate(f"{m:.1f}", xy=(x, m), xytext=(0, 10), textcoords="offset points", ha="center", va="bottom", fontsize=9, color=PRIMARY, fontweight="bold") # Callout — placed in the top-left empty space, above the headline line's # rising arm, so it doesn't collide with the legend or the QLoRA ref line. if rest_acc is not None: crossover_k = None; crossover_m = None for x, m in zip(ks, means): if m >= rest_acc: crossover_k = x; crossover_m = m break if crossover_k is not None: # Anchor text at upper-left of the plot area (well away from the # legend which sits lower-right below). ax.annotate( "matches QLoRA here\n(zero training)", xy=(crossover_k, crossover_m), xytext=(0.02, 0.78), textcoords="axes fraction", fontsize=8.5, color=QLORA_C, ha="left", va="top", arrowprops=dict(arrowstyle="->", color=QLORA_C, lw=0.8, shrinkA=2, shrinkB=4, connectionstyle="arc3,rad=0.25"), ) ax.set_xticks(ks) ax.set_xlabel(r"$k$ — number of FP16 reference steps injected into the prompt", labelpad=4) ax.set_ylabel("Accuracy (%)") ax.yaxis.grid(True, linewidth=0.4, color="#DDDDDD") ax.set_axisbelow(True) # Y range — anchor so "gap" band is visible but headline series has room. ys = means + los + his + [v for v in (base_acc, fp16_acc, rest_acc) if v is not None] ax.set_ylim(min(ys) - 3.5, max(ys) + 6) # Quiet top-right metadata stamp (no inline title). pretty_quant = {"awq_w4": "AWQ w4", "gptq_w4": "GPTQ w4", "bnb_nf4_w4": "BnB NF4"}.get(args.quant, args.quant) ax.text(1.0, 1.02, f"{args.model} · {pretty_quant} · {args.benchmark}", transform=ax.transAxes, ha="right", va="bottom", fontsize=8, color="#555555") # Legend as a dedicated strip below the x-axis label (not overlapping it). handles, labels = ax.get_legend_handles_labels() pairs = [(h, l) for h, l in zip(handles, labels) if l != "_gap"] if pairs: fig.legend([p[0] for p in pairs], [p[1] for p in pairs], loc="lower center", bbox_to_anchor=(0.5, 0.01), ncol=2, handlelength=2.4, handletextpad=0.6, columnspacing=1.8, labelspacing=0.5) # Reserve bottom space explicitly so the legend doesn't crash into the # x-axis label. Must be manual — constrained_layout doesn't know about # a fig.legend added after axis creation. fig.subplots_adjust(bottom=0.28, top=0.92, left=0.12, right=0.97) os.makedirs(os.path.dirname(args.output), exist_ok=True) fig.savefig(args.output) plt.close(fig) print(f" Paper fig 10 (prefix injection) saved: {args.output}") if __name__ == "__main__": main()