Upload cat_budget_ablation.py with huggingface_hub

cat_budget_ablation.py

@@ -0,0 +1,341 @@
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.distributions import Bernoulli
+from joblib import Parallel, delayed
+from matplotlib import pyplot as plt
+from tqdm import tqdm
+from tueplots import bundles
+
+bundles.icml2024()
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+sys.path.append(str(PROJECT_ROOT.parent))
+from utils import (
+    cat_beta_1pl,
+    cat_beta_2pl,
+    cat_binary_1pl,
+    cat_binary_2pl,
+    beta_nll,
+    calibrate_1pl_theta,
+)
+
+MAX_BUDGET = 100
+N_TEST_MODELS = 5
+RNG_SEED = 0
+DATA_ROOT = PROJECT_ROOT / "data"
+RESULTS_ROOT = PROJECT_ROOT / "results"
+DEVICE = "cpu"
+LOAD_PLOT_DATA = False
+INIT_FRAC = 0
+ONLY_PLOT_BETA_1PL = True
+PLOT_METRIC = "mae"
+NROWS = 2
+NCOLS = 5
+
+CONFIGS = (
+    {
+        "label": "beta 1pl",
+        "loss_kind": "beta",
+        "irt_model": "1pl",
+        "input_file": "4_prob_matrix_calibrated.parquet",
+        "color": "#1f77b4",
+        "linestyle": "-",
+        "cat_fn": cat_beta_1pl,
+    },
+    {
+        "label": "beta 2pl",
+        "loss_kind": "beta",
+        "irt_model": "2pl",
+        "input_file": "4_prob_matrix_calibrated_2pl.parquet",
+        "color": "#1f77b4",
+        "linestyle": "--",
+        "cat_fn": cat_beta_2pl,
+    },
+    {
+        "label": "binary 1pl",
+        "loss_kind": "binary",
+        "irt_model": "1pl",
+        "input_file": "4_binary_matrix_calibrated.parquet",
+        "color": "#d62728",
+        "linestyle": "-",
+        "cat_fn": cat_binary_1pl,
+    },
+    {
+        "label": "binary 2pl",
+        "loss_kind": "binary",
+        "irt_model": "2pl",
+        "input_file": "4_binary_matrix_calibrated_2pl.parquet",
+        "color": "#d62728",
+        "linestyle": "--",
+        "cat_fn": cat_binary_2pl,
+    },
+)
+
+
+def cat_theta_trace(
+    ys: np.ndarray,
+    zs: np.ndarray,
+    cat_fn,
+    device: str,
+    max_budget: int,
+    init_frac: float,
+    discris: np.ndarray | None = None,
+) -> np.ndarray:
+    ys_t = torch.tensor(ys, dtype=torch.float32)
+    zs_t = torch.tensor(zs, dtype=torch.float32)
+    if discris is None:
+        raw_trace = np.asarray(
+            cat_fn(ys_t, zs_t, device, budget=max_budget, init_frac=init_frac),
+            dtype=np.float32,
+        )
+    else:
+        discris_t = torch.tensor(discris, dtype=torch.float32)
+        raw_trace = np.asarray(
+            cat_fn(ys_t, discris_t, zs_t, device, budget=max_budget, init_frac=init_frac),
+            dtype=np.float32,
+        )
+
+    return raw_trace
+
+
+def calibrate_2pl_theta(
+    resmat: torch.Tensor,
+    zs: torch.Tensor,
+    alphas: torch.Tensor,
+    device: str,
+    loss_kind: str,
+    max_iter: int = 100,
+    lr_theta: float = 0.1,
+    phi: float = 10.0,
+    clamp_eps: float = 1e-6,
+) -> np.ndarray:
+    resmat = resmat.to(device)
+    zs = zs.to(device)
+    alphas = alphas.to(device)
+    n_test_takers = resmat.shape[0]
+    thetas = torch.randn(n_test_takers, device=device, requires_grad=True)
+    optimizer = torch.optim.AdamW([thetas], lr=lr_theta)
+    phi_tensor = torch.tensor(phi, device=device)
+
+    if loss_kind == "beta":
+        def compute_loss(y, mu, mask):
+            y = y.clamp(clamp_eps, 1 - clamp_eps)
+            return beta_nll(y[mask], mu[mask], phi_tensor).mean()
+    elif loss_kind == "binary":
+        def compute_loss(y, mu, mask):
+            return -Bernoulli(probs=mu[mask]).log_prob(y[mask]).mean()
+    else:
+        raise ValueError(f"Unknown loss_kind: {loss_kind}")
+
+    for _ in range(max_iter):
+        optimizer.zero_grad()
+        mask = ~torch.isnan(resmat)
+        mu = torch.sigmoid(alphas[None, :] * (thetas[:, None] + zs[None, :]))
+        loss = compute_loss(resmat, mu, mask)
+        loss.backward()
+        optimizer.step()
+
+    thetas = thetas.detach()
+    return thetas.cpu().numpy()
+
+
+def estimate_full_theta(
+    ys: np.ndarray,
+    zs: np.ndarray,
+    loss_kind: str,
+    irt_model: str,
+    device: str,
+    alphas: np.ndarray | None = None,
+) -> np.ndarray:
+    ys_t = torch.tensor(ys, dtype=torch.float32)
+    zs_t = torch.tensor(zs, dtype=torch.float32)
+    if irt_model == "1pl":
+        return calibrate_1pl_theta(
+            resmat=ys_t,
+            device=device,
+            zs=zs_t,
+            loss_kind=loss_kind,
+        )
+
+    else:
+        return calibrate_2pl_theta(
+            resmat=ys_t,
+            zs=zs_t,
+            alphas=torch.tensor(alphas, dtype=torch.float32),
+            device=device,
+            loss_kind=loss_kind,
+        )
+
+if __name__ == "__main__":
+    n_cpus = int(os.cpu_count() * 0.8)
+    rng = np.random.default_rng(RNG_SEED)
+    results_dir = RESULTS_ROOT / "cat_budget_ablation"
+    results_dir.mkdir(parents=True, exist_ok=True)
+    csv_path = results_dir / "cat_budget_ablation_mae.csv"
+
+    if LOAD_PLOT_DATA:
+        results_df = pd.read_csv(csv_path)
+        shared_benches = sorted(results_df["bench_name"].unique().tolist())
+    else:
+        config_data = {}
+        shared_benches = None
+        for cfg_idx, cfg in enumerate(CONFIGS):
+            df = pd.read_parquet(DATA_ROOT / cfg["input_file"])
+            test_df = df[df.index.get_level_values("model_split") == "test"].copy()
+            
+            if cfg_idx == 0:
+                shared_benches = sorted(
+                    test_df.columns.get_level_values("bench_name").map(
+                        lambda b: "mmlu" if b.startswith("mmlu") else b
+                    ).unique().tolist()
+                )
+            config_data[cfg["label"]] = {
+                "test_df": test_df,
+                "bench_names": test_df.columns.get_level_values("bench_name").map(
+                    lambda b: "mmlu" if b.startswith("mmlu") else b
+                ).to_numpy(),
+            }
+
+        records = []
+        for cfg in CONFIGS:
+            label = cfg["label"]
+            test_df = config_data[label]["test_df"]
+            ys = test_df.to_numpy(dtype=np.float32)
+            bench_names = config_data[label]["bench_names"]
+            zs = test_df.columns.get_level_values("difficulty").to_numpy(dtype=np.float32)
+            if cfg["irt_model"] == "2pl":
+                alphas = test_df.columns.get_level_values("discrimination").to_numpy(dtype=np.float32)
+            else: 
+                alphas = None
+
+            for bench in tqdm(shared_benches, desc=label):
+                bench_mask = bench_names == bench
+                bench_ys = ys[:, bench_mask]
+                bench_zs = zs[bench_mask]
+                bench_alphas = alphas[bench_mask] if alphas is not None else None
+
+                gt_thetas = estimate_full_theta(
+                    ys=bench_ys,
+                    zs=bench_zs,
+                    loss_kind=cfg["loss_kind"],
+                    irt_model=cfg["irt_model"],
+                    alphas=bench_alphas,
+                    device=DEVICE,
+                )
+                theta_order = np.argsort(gt_thetas)
+                n_select = min(N_TEST_MODELS, theta_order.size)
+                selected_positions = np.linspace(0, theta_order.size - 1, num=n_select, dtype=int)
+                selected_model_idxs = theta_order[selected_positions]
+                bench_ys = bench_ys[selected_model_idxs]
+                gt_thetas = gt_thetas[selected_model_idxs]
+
+                traces = np.asarray(
+                    Parallel(n_jobs=n_cpus)(
+                        delayed(cat_theta_trace)(
+                            ys=bench_ys[i],
+                            zs=bench_zs,
+                            discris=bench_alphas,
+                            cat_fn=cfg["cat_fn"],
+                            device=DEVICE,
+                            max_budget=MAX_BUDGET,
+                            init_frac=INIT_FRAC,
+                        )
+                        for i in range(bench_ys.shape[0])
+                    ),
+                    dtype=np.float32,
+                )
+                errors = traces - gt_thetas[:, None]
+                mae_by_budget = np.abs(errors).mean(axis=0)
+                mse_by_budget = np.square(errors).mean(axis=0)
+
+                for budget, (mae, mse) in enumerate(zip(mae_by_budget, mse_by_budget), start=1):
+                    records.append(
+                        {
+                            "bench_name": bench,
+                            "loss_kind": cfg["loss_kind"],
+                            "irt_model": cfg["irt_model"],
+                            "budget": budget,
+                            "mae": float(mae),
+                            "mse": float(mse),
+                        }
+                    )
+
+        results_df = pd.DataFrame.from_records(records)
+        results_df.to_csv(csv_path, index=False)
+
+    with plt.rc_context(bundles.icml2024(usetex=True, family="serif")):
+        fig, axes = plt.subplots(
+            nrows=NROWS,
+            ncols=NCOLS,
+            figsize=(18, 6.8),
+            sharex=True,
+            sharey=False,
+        )
+        axes = np.atleast_1d(axes).ravel()
+        plot_configs = (
+            [cfg for cfg in CONFIGS if cfg["loss_kind"] == "beta" and cfg["irt_model"] == "1pl"]
+            if ONLY_PLOT_BETA_1PL
+            else list(CONFIGS)
+        )
+        for i_ax, (ax, bench) in enumerate(zip(axes, shared_benches)):
+            bench_df = results_df[results_df["bench_name"] == bench]
+            for cfg in plot_configs:
+                cfg_df = bench_df[
+                    (bench_df["loss_kind"] == cfg["loss_kind"])
+                    & (bench_df["irt_model"] == cfg["irt_model"])
+                ]
+                ax.plot(
+                    cfg_df["budget"],
+                    cfg_df[PLOT_METRIC],
+                    label=None if ONLY_PLOT_BETA_1PL else cfg["label"],
+                    color=cfg["color"],
+                    linestyle=cfg["linestyle"],
+                    linewidth=2.4,
+                    alpha=0.8,
+                )
+            plot_df = bench_df[
+                (bench_df["loss_kind"] == "beta") & (bench_df["irt_model"] == "1pl")
+            ] if ONLY_PLOT_BETA_1PL else bench_df
+            if ONLY_PLOT_BETA_1PL:
+                bench_max = plot_df[PLOT_METRIC].max()
+                ax.set_ylim(0, bench_max * 1.12 if bench_max > 0 else 1.0)
+            else:
+                positive_metric = plot_df.loc[plot_df[PLOT_METRIC] > 0, PLOT_METRIC]
+                bench_min = positive_metric.min()
+                bench_max = positive_metric.max()
+                ax.set_yscale("log")
+                ax.set_ylim(bench_min / 1.2, bench_max * 1.12)
+            ax.set_xlim(1, MAX_BUDGET)
+            ax.axvline(50, color="black", linestyle="--", linewidth=1.2, alpha=0.9)
+            ax.set_title(bench, fontsize=18, pad=10)
+            if i_ax < NCOLS:
+                ax.set_xlabel("")
+            else:
+                ax.set_xlabel("Budget", fontsize=16)
+            if i_ax % NCOLS == 0:
+                ax.set_ylabel(PLOT_METRIC.upper(), fontsize=16)
+            else:
+                ax.set_ylabel("")
+            ax.tick_params(axis="both", labelsize=14)
+            ax.spines["top"].set_visible(False)
+            ax.spines["right"].set_visible(False)
+            ax.margins(x=0.01)
+        if not ONLY_PLOT_BETA_1PL:
+            handles, labels = axes[0].get_legend_handles_labels()
+            fig.legend(
+                handles,
+                labels,
+                loc="upper center",
+                ncol=4,
+                frameon=False,
+                fontsize=15,
+                bbox_to_anchor=(0.5, 1.03),
+            )
+        fig.tight_layout(rect=(0, 0, 1, 0.92), w_pad=1.2, h_pad=1.4)
+        fig.savefig(results_dir / "cat_budget_ablation.png", dpi=300, bbox_inches="tight")
+        plt.close(fig)