Delete src/analysis/wow_pack.py

src/analysis/wow_pack.py

@@ -1,605 +0,0 @@
-# Wow Pack — Sections 3–5 (CT-map, SIMS, Discovery Frontier, Uplifts)
-
-# %%
-import json, os, re, math, warnings, pathlib as p
-from collections import defaultdict
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-RES = p.Path("results"); RES.mkdir(exist_ok=True, parents=True)
-
-def _read_json(path):
-    path = p.Path(path)
-    if not path.exists():
-        warnings.warn(f"Missing file: {path}")
-        return {}
-    with open(path, "r") as f:
-        return json.load(f)
-
-def _to_df_like(obj):
-    """Try to coerce nested dicts into a tidy DataFrame [transporter, stress, value]."""
-    if not obj:
-        return pd.DataFrame(columns=["transporter","stress","value"])
-    # case A: {stress: {transporter: val}}
-    if isinstance(obj, dict):
-        # detect orientation by peeking at first value
-        first_key = next(iter(obj))
-        first_val = obj[first_key]
-        if isinstance(first_val, dict):  # nested dict
-            # decide which level is stress vs transporter by heuristic
-            k_outer = str(first_key).lower()
-            if any(s in k_outer for s in ["ethanol","oxid","osmotic","nacl","h2o2","stress"]):
-                rows=[]
-                for stress, inner in obj.items():
-                    for tr,val in inner.items():
-                        rows.append((str(tr), str(stress), float(val)))
-                return pd.DataFrame(rows, columns=["transporter","stress","value"])
-            else:  # likely transporter->stress
-                rows=[]
-                for tr, inner in obj.items():
-                    for stress,val in inner.items():
-                        rows.append((str(tr), str(stress), float(val)))
-                return pd.DataFrame(rows, columns=["transporter","stress","value"])
-        # case B: flat dict of {transporter: val}
-        else:
-            rows=[(str(k), "pooled", float(v)) for k,v in obj.items()]
-            return pd.DataFrame(rows, columns=["transporter","stress","value"])
-    # fallback
-    return pd.DataFrame(obj)
-
-def _errbar(ax, x0, x1, y, color="k", lw=1):
-    ax.plot([x0,x1],[y,y], color=color, lw=lw)
-
-def _save(fig, path, dpi=300, tight=True):
-    path = RES / path
-    if tight: plt.tight_layout()
-    fig.savefig(path, dpi=dpi)
-    print("✅ saved:", path)
-
-# Load artifacts (be flexible with names)
-snap3   = _read_json(RES/"causal_section3_snapshot.json")
-rob3    = _read_json(RES/"causal_section3_robustness.json")
-al4     = _read_json(RES/"al_section4_snapshot.json")
-al4b    = _read_json(RES/"al_section4_snapshot (1).json")  # optional new run name
-transfer= _read_json(RES/"section5_transfer_snapshot.json")
-
-# Try multiple handles for AL snapshot
-if not al4 and al4b: al4 = al4b
-
-# Peek what we have
-for name, obj in dict(s3=snap3, rob=rob3, al=al4, trans=transfer).items():
-    print(name, "keys:", ([] if not obj else list(obj.keys()))[:8])
-
-# --- Patch the leaf parser to accept list/tuple/dict leaves ---
-import math, numpy as np, pandas as pd
-
-def _leaf_to_float(v):
-    """Extract a numeric point estimate from various leaf formats."""
-    # direct number
-    if isinstance(v, (int, float, np.integer, np.floating)):
-        return float(v)
-
-    # list/tuple: try first numeric entry (e.g., [ATE, lo, hi])
-    if isinstance(v, (list, tuple)):
-        for x in v:
-            if isinstance(x, (int, float, np.integer, np.floating)):
-                return float(x)
-        return np.nan
-
-    # dict: look for common keys, else first numeric value
-    if isinstance(v, dict):
-        for k in ["ATE", "ate", "value", "mean", "point", "point_est", "point_estimate"]:
-            if k in v and isinstance(v[k], (int, float, np.integer, np.floating)):
-                return float(v[k])
-        for x in v.values():
-            if isinstance(x, (int, float, np.integer, np.floating)):
-                return float(x)
-            if isinstance(x, (list, tuple)) and len(x) > 0 and isinstance(x[0], (int, float, np.integer, np.floating)):
-                return float(x[0])
-        return np.nan
-
-    # anything else
-    return np.nan
-
-def _to_df_like(obj):
-    """Coerce nested dicts into tidy DF [transporter, stress, value] using _leaf_to_float."""
-    if not obj:
-        return pd.DataFrame(columns=["transporter","stress","value"])
-
-    # nested dictionaries
-    if isinstance(obj, dict):
-        first_key = next(iter(obj))
-        first_val = obj[first_key]
-
-        # case: {outer: {inner: leaf}}
-        if isinstance(first_val, dict):
-            # guess orientation by outer key name
-            k_outer = str(first_key).lower()
-            rows=[]
-            if any(s in k_outer for s in ["ethanol","oxid","osmotic","nacl","kcl","stress","h2o2"]):
-                # outer = stress
-                for stress, inner in obj.items():
-                    for tr, leaf in inner.items():
-                        val = _leaf_to_float(leaf)
-                        if not (val is None or math.isnan(val)):
-                            rows.append((str(tr), str(stress), float(val)))
-            else:
-                # outer = transporter
-                for tr, inner in obj.items():
-                    for stress, leaf in inner.items():
-                        val = _leaf_to_float(leaf)
-                        if not (val is None or math.isnan(val)):
-                            rows.append((str(tr), str(stress), float(val)))
-            return pd.DataFrame(rows, columns=["transporter","stress","value"])
-
-        # case: flat {transporter: leaf}
-        else:
-            rows=[]
-            for tr, leaf in obj.items():
-                val = _leaf_to_float(leaf)
-                if not (val is None or math.isnan(val)):
-                    rows.append((str(tr), "pooled", float(val)))
-            return pd.DataFrame(rows, columns=["transporter","stress","value"])
-
-    # fallback
-    return pd.DataFrame(obj)
-
-print("✅ Robust parser installed. Re-run the CT-map/SIMS cells.")
-
-# %%
-# Try common locations for stress-specific ATEs in Section 3 snapshot
-# Heuristics to find a nested dict of [stress][transporter] -> effect OR [transporter][stress]
-candidates = []
-for k,v in (snap3 or {}).items():
-    if isinstance(v, dict):
-        # look for 2-level dict with numeric leaves
-        try:
-            inner = next(iter(v.values()))
-            if isinstance(inner, dict):
-                numeric_leaf = next(iter(inner.values()))
-                float(numeric_leaf)
-                candidates.append((k, v))
-        except Exception:
-            pass
-
-if not candidates:
-    warnings.warn("Could not auto-locate stress-wise effects in Section 3 snapshot.")
-    stress_df = pd.DataFrame(columns=["transporter","stress","value"])
-else:
-    key, nested = candidates[0]
-    print(f"Using stress-effect block: '{key}'")
-    stress_df = _to_df_like(nested)
-
-# Normalize stress names a bit
-def _norm_s(s):
-    s=str(s).lower()
-    if "eth" in s: return "ethanol"
-    if "h2o2" in s or "oxi" in s: return "oxidative"
-    if "osm" in s or "nacl" in s or "kcl" in s or "salt" in s: return "osmotic"
-    return s
-stress_df["stress"] = stress_df["stress"].map(_norm_s)
-stress_df = stress_df[~stress_df["stress"].isin(["pooled",""])]
-
-# Pivot to matrix (transporters × stresses)
-ct_mat = stress_df.pivot_table(index="transporter", columns="stress", values="value", aggfunc="mean").fillna(0.0)
-ct_mat = ct_mat.reindex(sorted(ct_mat.index), axis=0)
-ct_mat = ct_mat.reindex(sorted(ct_mat.columns), axis=1)
-
-# ---- CT-Map Heatmap ----
-plt.figure(figsize=(max(6,0.16*ct_mat.shape[0]), 2.4))
-sns.heatmap(ct_mat.T, cmap="coolwarm", center=0, cbar_kws={"label":"ATE (high→low expr)"}, linewidths=0.2, linecolor="w")
-plt.title("CT-Map — Causal transportability across stresses")
-plt.xlabel("Transporter"); plt.ylabel("Stress")
-_save(plt.gcf(), "fig_ct_map.png")
-
-# ---- Top drivers (mean absolute effect across stresses) ----
-top = ct_mat.abs().mean(axis=1).sort_values(ascending=False).rename("mean_abs_ATE")
-top_tbl = top.reset_index().rename(columns={"index":"transporter"})
-top_tbl.to_csv(RES/"ct_map_top_drivers.csv", index=False)
-print(top_tbl.head(10))
-
-# %%
-# SIMS = |mean CATE across stresses| / (SD across stresses + eps)
-eps = 1e-8
-mu = ct_mat.mean(axis=1)
-sd = ct_mat.std(axis=1)
-sims = (mu.abs() / (sd + eps)).rename("SIMS")
-
-sims_tbl = (
-    pd.DataFrame(dict(transporter=sims.index, SIMS=sims.values, mean_effect=mu.values, sd=sd.values))
-    .sort_values("SIMS", ascending=False)
-)
-sims_tbl.to_csv(RES/"table_SIMS.csv", index=False)
-
-fig, ax = plt.subplots(figsize=(6, max(3.5, 0.35*len(sims_tbl))))
-sns.barplot(data=sims_tbl, y="transporter", x="SIMS", color="steelblue", ax=ax, orient="h")
-ax.set_title("SIMS — stress-invariant mechanism score")
-ax.set_xlabel("|mean CATE| / SD across stresses")
-_save(fig, "fig_SIMS_waterfall.png")
-sims_tbl.head(10)
-
-# %%
-def _extract_al_curves(blob):
-    """
-    Expect something like:
-      {"strategy": {"frac": [...], "auprc": [...]}, ...}
-    or a list of dicts with keys 'strategy','frac','auprc'
-    """
-    if not blob: return {}
-    out = {}
-    # form 1: dict of strategies
-    for k,v in blob.items():
-        if isinstance(v, dict) and {"frac","auprc"} <= set(v.keys()):
-            out[k] = pd.DataFrame(dict(frac=v["frac"], auprc=v["auprc"]))
-    # form 2: list of records
-    if not out and isinstance(blob, list):
-        for rec in blob:
-            if isinstance(rec, dict) and {"strategy","frac","auprc"} <= set(rec.keys()):
-                out.setdefault(rec["strategy"], pd.DataFrame(columns=["frac","auprc"]))
-                out[rec["strategy"]] = pd.DataFrame(dict(frac=rec["frac"], auprc=rec["auprc"]))
-    return out
-
-al_curves = _extract_al_curves(al4)
-
-if not al_curves:
-    warnings.warn("Could not parse AL curves from Section 4 snapshot.")
-else:
-    # plot frontier
-    fig, ax = plt.subplots(figsize=(8,5))
-    palette = dict(random="#8c8c8c")
-    for k,df in al_curves.items():
-        df = df.sort_values("frac")
-        ax.plot(df["frac"], df["auprc"], label=k)
-    ax.set_title("Interventional Discovery Frontier (AUPRC vs label fraction)")
-    ax.set_xlabel("Labeled fraction of pool"); ax.set_ylabel("AUPRC (held-out)")
-    ax.legend()
-    _save(fig, "fig_discovery_frontier.png")
-
-    # compute integrated gain vs random
-    def _auc(df):
-        df=df.sort_values("frac")
-        return np.trapz(df["auprc"].to_numpy(), df["frac"].to_numpy())
-    if "random" not in al_curves:
-        warnings.warn("No 'random' baseline present; gains will be relative to min curve.")
-        base_key = sorted(al_curves.keys())[0]
-    else:
-        base_key = "random"
-    base_auc = _auc(al_curves[base_key])
-
-    gains=[]
-    for k,df in al_curves.items():
-        g = _auc(df)/max(base_auc,1e-12)
-        gains.append((k,g))
-    gains_tbl = pd.DataFrame(gains, columns=["strategy","gain_vs_random"]).sort_values("gain_vs_random", ascending=False)
-    gains_tbl.to_csv(RES/"table_discovery_gains.csv", index=False)
-
-    fig, ax = plt.subplots(figsize=(6,3.2))
-    sns.barplot(data=gains_tbl[gains_tbl["strategy"]!=base_key], x="strategy", y="gain_vs_random", ax=ax)
-    ax.axhline(1.0, color="k", ls="--", lw=1)
-    ax.set_ylabel("Efficiency gain vs random (AUC ratio)")
-    ax.set_title("Label-efficiency gains")
-    _save(fig, "fig_discovery_gain_bars.png")
-
-    display(gains_tbl)
-
-
-# %%
-# Choose top K stable (high SIMS) transporters
-K = min(5, max(1, len(sims_tbl)))
-top_sims = sims_tbl.head(K)["transporter"].tolist()
-
-for tr in top_sims:
-    ser = ct_mat.loc[tr].dropna()
-    fig, ax = plt.subplots(figsize=(4.5,3.2))
-    sns.barplot(x=ser.index, y=ser.values, ax=ax, color="steelblue")
-    ax.axhline(0, color="k", lw=1)
-    ax.set_title(f"Counterfactual uplift — {tr}\n(high vs low expression by stress)")
-    ax.set_ylabel("ATE"); ax.set_xlabel("")
-    _save(fig, f"fig_uplift_{re.sub(r'[^A-Za-z0-9]+','_',tr)}.png")
-
-
-# %%
-manifest = {
-    "ct_map": {
-        "figure": str(RES/"fig_ct_map.png"),
-        "top_drivers_csv": str(RES/"ct_map_top_drivers.csv"),
-    },
-    "SIMS": {
-        "waterfall": str(RES/"fig_SIMS_waterfall.png"),
-        "table": str(RES/"table_SIMS.csv"),
-        "definition": "|mean CATE across stresses| / (SD across stresses + 1e-8)"
-    },
-    "discovery_frontier": {
-        "frontier_fig": str(RES/"fig_discovery_frontier.png"),
-        "gain_bars_fig": str(RES/"fig_discovery_gain_bars.png"),
-        "gains_table": str(RES/"table_discovery_gains.csv")
-    },
-    "uplifts": sorted([str(x) for x in RES.glob("fig_uplift_*.png")]),
-    "notes": "Figures computed from Section 3 stress-specific ATEs and Section 4 AL curves; transfer analysis not required here."
-}
-with open(RES/"wow_pack_manifest.json","w") as f:
-    json.dump(manifest, f, indent=2)
-print("✅ wrote:", RES/"wow_pack_manifest.json")
-for k,v in manifest.items():
-    print(k, "→", (list(v)[:3] if isinstance(v, dict) else f"{len(v)} files"))
-
-
-# %% Patch: robust AL curves parser + gain stats + zip refresh
-import json, numpy as np, pandas as pd, pathlib as p, zipfile
-
-RES = p.Path("results"); RES.mkdir(parents=True, exist_ok=True)
-ALP = RES/"al_section4_snapshot.json"
-
-def _safe_json(path):
-    try: return json.load(open(path))
-    except Exception: return {}
-
-AL = _safe_json(ALP)
-
-def normalize_curves(AL):
-    """
-    Returns dict: {strategy: {"fracs":[...], "auprc":[...]}}
-    Accepts shapes like:
-      - {"curves":{"uncertainty":{"fracs":[...],"auprc":[...]}, ...}}
-      - {"curves":[{"strategy":"uncertainty","fracs":[...],"auprc":[...]}, ...]}
-      - {"curves":{"uncertainty":[{"frac":0.2,"auprc":...}, ...]}, ...}
-      - {"curves":[{"strategy":"uncertainty","frac":0.2,"auprc":...}, ...]}  (point-wise list)
-    """
-    curves = AL.get("curves", {})
-    out = {}
-
-    # Case A: dict of strategies
-    if isinstance(curves, dict):
-        for strat, obj in curves.items():
-            # A1: direct arrays
-            if isinstance(obj, dict) and ("fracs" in obj) and ("auprc" in obj):
-                out[strat] = {"fracs": list(map(float, obj["fracs"])),
-                              "auprc": list(map(float, obj["auprc"]))}
-            # A2: list of points
-            elif isinstance(obj, list):
-                fr, au = [], []
-                for pt in obj:
-                    if isinstance(pt, dict):
-                        f = pt.get("frac", pt.get("fracs"))
-                        a = pt.get("auprc", pt.get("AUPRC", pt.get("aupr")))
-                        if f is not None and a is not None:
-                            fr.append(float(f)); au.append(float(a))
-                if fr and au: out[strat] = {"fracs": fr, "auprc": au}
-
-    # Case B: list at top level
-    if not out and isinstance(curves, list):
-        # B1: series-per-item
-        tmp = {}
-        for item in curves:
-            if isinstance(item, dict) and ("strategy" in item):
-                if "fracs" in item and "auprc" in item:
-                    tmp[item["strategy"]] = {"fracs": list(map(float, item["fracs"])),
-                                             "auprc": list(map(float, item["auprc"]))}
-        if tmp: out = tmp
-        else:
-            # B2: point-wise items
-            from collections import defaultdict
-            acc = defaultdict(lambda: {"fracs": [], "auprc": []})
-            for pt in curves:
-                if isinstance(pt, dict) and ("strategy" in pt):
-                    f = pt.get("frac", pt.get("fracs")); a = pt.get("auprc", pt.get("AUPRC"))
-                    if f is not None and a is not None:
-                        acc[pt["strategy"]]["fracs"].append(float(f))
-                        acc[pt["strategy"]]["auprc"].append(float(a))
-            out = dict(acc)
-
-    return out
-
-curves = normalize_curves(AL)
-if not curves:
-    raise SystemExit("Could not parse AL curves; inspect results/al_section4_snapshot.json")
-
-if "random" not in curves:
-    # Fall back: pick the first strategy as baseline (shouldn't happen in our runs)
-    base_name = next(iter(curves))
-else:
-    base_name = "random"
-
-FR = np.array(curves[base_name]["fracs"], float)
-base = np.array(curves[base_name]["auprc"], float)
-
-def series(name):
-    fr = np.array(curves[name]["fracs"], float)
-    au = np.array(curves[name]["auprc"], float)
-    # align by truncation to the shared prefix length
-    n = min(len(FR), len(fr), len(base))
-    return au[:n], base[:n]
-
-def gain_ratio(name):
-    au, b = series(name)
-    return au / (b + 1e-12)
-
-# Bootstrap mean gain vs baseline across checkpoints
-B = 2000
-rng = np.random.default_rng(7)
-records = []
-for strat in [s for s in curves.keys() if s != base_name]:
-    G = gain_ratio(strat)
-    n = len(G)
-    boots = [G[rng.integers(0, n, n)].mean() for _ in range(B)]
-    boots = np.array(boots, float)
-    mean = float(G.mean())
-    lo, hi = np.percentile(boots, [2.5, 97.5])
-    records.append({"strategy": strat, "mean_gain": mean, "ci_low": float(lo), "ci_high": float(hi)})
-
-gains_df = pd.DataFrame(records).sort_values("mean_gain", ascending=False)
-out_csv = RES/"gains_table.csv"
-gains_df.to_csv(out_csv, index=False)
-
-# Refresh the ZIP if it exists
-zip_path = RES/"wow_camera_ready.zip"
-if zip_path.exists():
-    with zipfile.ZipFile(zip_path, "a", compression=zipfile.ZIP_DEFLATED) as z:
-        z.write(out_csv, arcname="tables/gains_table.csv")
-
-print("✅ Rebuilt gains with bootstrap CIs.")
-print(gains_df)
-print("Saved:", out_csv, "| ZIP updated:", zip_path.exists())
-
-import json, os, zipfile, re
-import numpy as np, pandas as pd, matplotlib.pyplot as plt, seaborn as sns
-from pathlib import Path
-
-RES = Path("results"); RES.mkdir(exist_ok=True, parents=True)
-cand = sorted(RES.glob("al_section4_snapshot*.json"), key=os.path.getmtime)
-if not cand: raise FileNotFoundError("No results/al_section4_snapshot*.json found.")
-AL_PATH = cand[-1]
-al = json.load(open(AL_PATH))
-raw_curves = al.get("curves")
-if raw_curves is None: raise ValueError("al['curves'] missing.")
-
-# ---------- helpers ----------
-def _find_key(d, want):
-    """find a key in dict d that matches 'frac' or 'auprc' loosely (case-insensitive substr)."""
-    want = want.lower()
-    for k in d.keys():
-        lk = k.lower()
-        if want == "frac":
-            if ("frac" in lk) or ("label" in lk) or (lk in {"f","x"}):
-                return k
-        if want == "auprc":
-            if ("auprc" in lk) or ("pr" in lk) or ("average_precision" in lk) or (lk in {"ap","y"}):
-                return k
-    return None
-
-def _to_pairs(obj):
-    """Return Nx2 array of [frac, auprc] from many formats."""
-    # list/tuple?
-    if isinstance(obj, (list, tuple)) and len(obj)>0:
-        # list of pairs
-        if isinstance(obj[0], (list, tuple)) and len(obj[0])==2:
-            return np.asarray(obj, dtype=float)
-        # list of dict points (keys may vary)
-        if isinstance(obj[0], dict):
-            fr, ap = [], []
-            for d in obj:
-                if not isinstance(d, dict): raise TypeError("Mixed list; expected dict points.")
-                kf = _find_key(d, "frac"); ka = _find_key(d, "auprc")
-                if kf is None or ka is None:
-                    # if the dict has only two numeric values, take them in sorted key order
-                    nums = [v for v in d.values() if np.isscalar(v) or (isinstance(v,(list,tuple)) and len(v)==1)]
-                    if len(nums)>=2:
-                        fr.append(float(np.asarray(list(d.values())[0]).squeeze()))
-                        ap.append(float(np.asarray(list(d.values())[1]).squeeze()))
-                        continue
-                    raise ValueError("Point dict missing frac/auprc-like keys.")
-                fr.append(float(np.asarray(d[kf]).squeeze()))
-                ap.append(float(np.asarray(d[ka]).squeeze()))
-            return np.column_stack([fr, ap])
-    # dict-of-lists columns?
-    if isinstance(obj, dict):
-        kf = _find_key(obj, "frac"); ka = _find_key(obj, "auprc")
-        if kf and ka and isinstance(obj[kf], (list, tuple)) and isinstance(obj[ka], (list, tuple)):
-            fr = np.asarray(obj[kf], dtype=float).ravel()
-            ap = np.asarray(obj[ka], dtype=float).ravel()
-            return np.column_stack([fr, ap])
-        # dict with nested 'points'
-        if "points" in obj:
-            return _to_pairs(obj["points"])
-    raise TypeError("Unrecognized curve format.")
-
-def _normalize_one(v):
-    """Return {'fracs':..., 'auprc':...} sorted by fracs."""
-    # direct dict with fracs/auprc keys (any naming)
-    if isinstance(v, dict):
-        try:
-            arr = _to_pairs(v)
-        except Exception:
-            # maybe explicit arrays under fracs/auprc aliases
-            kf = _find_key(v, "frac"); ka = _find_key(v, "auprc")
-            if kf and ka:
-                arr = np.column_stack([np.asarray(v[kf], float).ravel(),
-                                       np.asarray(v[ka], float).ravel()])
-            else:
-                raise
-    else:
-        arr = _to_pairs(v)
-    arr = arr[np.argsort(arr[:,0])]
-    return {"fracs": arr[:,0], "auprc": arr[:,1]}
-
-def normalize_curves(curves_raw):
-    out = {}
-    if isinstance(curves_raw, dict):
-        for k,v in curves_raw.items():
-            out[str(k)] = _normalize_one(v)
-        return out
-    if isinstance(curves_raw, list):
-        for item in curves_raw:
-            if isinstance(item, dict):
-                name = item.get("strategy") or item.get("name") or item.get("label") or f"strategy_{len(out)}"
-                payload = {kk: vv for kk,vv in item.items() if kk not in {"strategy","name","label"}}
-                out[str(name)] = _normalize_one(payload if payload else item)
-        if out: return out
-    raise ValueError("Unrecognized al['curves'] structure.")
-
-# ---------- normalize & union grid ----------
-curves = normalize_curves(raw_curves)
-grid = sorted({float(x) for v in curves.values() for x in np.asarray(v["fracs"], float)})
-FR = np.asarray(grid, float)
-
-tidy = []
-for strat, v in curves.items():
-    f = np.asarray(v["fracs"], float); a = np.asarray(v["auprc"], float)
-    # dedup on f
-    u, idx = np.unique(np.round(f,8), return_index=True)
-    f2 = f[np.sort(idx)]; a2 = a[np.sort(idx)]
-    a_interp = np.interp(FR, f2, a2)
-    for fr, ap in zip(FR, a_interp):
-        tidy.append({"strategy": strat, "frac_labeled": float(fr), "auprc": float(ap)})
-curves_df = pd.DataFrame(tidy)
-curves_df.to_csv(RES/"al_curves_merged.csv", index=False)
-
-# ---------- gains vs random (bootstrap CI) ----------
-if "random" not in curves_df["strategy"].unique():
-    raise ValueError("Random baseline missing.")
-
-base = curves_df[curves_df.strategy=="random"].set_index("frac_labeled")["auprc"]
-def boot_ci(v, B=5000, seed=123):
-    rng = np.random.default_rng(seed); v=np.asarray(v,float)
-    boots = rng.choice(v, size=(B,len(v)), replace=True).mean(1)
-    lo,hi = np.percentile(boots,[2.5,97.5]); return float(v.mean()), float(lo), float(hi)
-
-rows=[]
-for strat in sorted(set(curves_df.strategy)-{"random"}):
-    a = curves_df[curves_df.strategy==strat].set_index("frac_labeled")["auprc"].reindex(base.index)
-    mask = base>0
-    gains = (a[mask]/base[mask]).dropna().values
-    if gains.size==0: continue
-    mean,lo,hi = boot_ci(gains)
-    rows.append({"strategy":strat,"mean_gain":mean,"ci_low":lo,"ci_high":hi})
-gains_df = pd.DataFrame(rows).sort_values("mean_gain", ascending=False)
-gains_df.to_csv(RES/"gains_table.csv", index=False)
-print("✅ Parsed and merged curves. Gains:")
-print(gains_df)
-
-# ---------- figures ----------
-plt.figure(figsize=(7.4,4.8))
-sns.lineplot(data=curves_df, x="frac_labeled", y="auprc", hue="strategy", marker="o")
-plt.xlabel("Labeled fraction"); plt.ylabel("Validation AUPRC")
-plt.title("Active Learning Efficiency Frontier"); plt.grid(alpha=0.3); plt.tight_layout()
-frontier_png = RES/"fig_AL_frontier.png"; plt.savefig(frontier_png, dpi=300); plt.show()
-
-plt.figure(figsize=(6.8,4.6))
-order = gains_df["strategy"].tolist()
-ax = sns.barplot(data=gains_df, x="strategy", y="mean_gain", order=order)
-for i,r in enumerate(gains_df.itertuples(index=False)):
-    ax.plot([i,i],[r.ci_low,r.ci_high], color="k", lw=1.2)
-plt.axhline(1.0, color="k", ls="--", lw=1, alpha=0.6)
-plt.ylabel("Gain vs. random (AUPRC ratio)")
-plt.title("Active Learning Gain (mean ± 95% CI)"); plt.tight_layout()
-gains_png = RES/"fig_AL_gains.png"; plt.savefig(gains_png, dpi=300); plt.show()
-
-# ---------- zip ----------
-zip_path = RES/"wow_camera_ready.zip"
-with zipfile.ZipFile(zip_path, "a" if zip_path.exists() else "w", zipfile.ZIP_DEFLATED) as zf:
-    for f in [frontier_png, gains_png, RES/"al_curves_merged.csv", RES/"gains_table.csv", AL_PATH]:
-        zf.write(f, arcname=f.name)
-print("📦 Updated:", zip_path.name)