""" run_repro.py ============ Reproduces the linear-theory claims of arXiv:2602.02908 ("A Random Matrix Theory Perspective on the Consistency of Diffusion Models") and validates each analytic deterministic-equivalence (DE) prediction against a Monte-Carlo (MC) ground truth computed by resampling finite datasets. Outputs (written to ./outputs/): * claimC*_*.csv raw numbers behind every figure * claimC*_*.png the reproduced figure * results_summary.json / results_summary.md agreement metrics for the logbook Run: python run_repro.py # default config python run_repro.py --config configs/repro.yaml """ from __future__ import annotations import argparse, json, os, time import numpy as np import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import rmt_diffusion as rmt OUT = os.path.join(os.path.dirname(__file__), "outputs") os.makedirs(OUT, exist_ok=True) def _save_csv(name, header, rows): import csv with open(os.path.join(OUT, name), "w", newline="") as f: w = csv.writer(f) w.writerow(header) w.writerows(rows) def combined_mc(eigs, sigma2, n, R, x_vec, rng): """One pass over R dataset realizations, accumulating: diag_mean/diag_var -> E[u_k^T M u_k], Var[.] (shrinkage along PC, Fig 2C) resp_var -> Var[u_k^T M x] for fixed x (anisotropy, Fig 3B) total_var -> sum_ij Var[M_ij] (global scaling, Fig 3D) """ d = eigs.shape[0]; I = np.eye(d) diag = np.empty((R, d)); resp = np.empty((R, d)) # Welford for full-matrix variance (memory-light) mean_M = np.zeros((d, d)); M2 = np.zeros((d, d)) for r in range(R): C = rmt.sample_empirical_cov(eigs, n, rng) M = C @ np.linalg.solve(C + sigma2 * I, I) diag[r] = np.diag(M) resp[r] = M @ x_vec delta = M - mean_M; mean_M += delta / (r + 1); M2 += delta * (M - mean_M) total_var = float((M2 / (R - 1)).sum()) return diag.mean(0), diag.var(0, ddof=1), resp.var(0, ddof=1), total_var def main(): ap = argparse.ArgumentParser() ap.add_argument("--config", default=None) args = ap.parse_args() cfg = dict(d=180, alpha=1.0, seed=0, c1_sigma2=list(np.logspace(-2, 1, 12)), c1_ns=[100, 400, 2000], c1_R=70, shr_sigma2=0.1, shr_n=300, shr_R=500, aniso_n=2000, aniso_R=900, scale_ns=[100, 200, 400, 800, 1600, 3200], scale_sigma2=0.1, scale_R=250, sqrt_ns=[200, 1000], sqrt_R=250) if args.config: import yaml loaded = yaml.safe_load(open(args.config)) or {} cfg.update({k: v for k, v in loaded.items() if v is not None}) if cfg.get("c1_sigma2") is None: cfg["c1_sigma2"] = list(np.logspace(-2, 1, 12)) rng = np.random.default_rng(cfg["seed"]) d, alpha = cfg["d"], cfg["alpha"] eigs = rmt.power_law_spectrum(d, alpha=alpha) summary = {"paper": "arXiv:2602.02908", "d": d, "alpha": alpha, "seed": cfg["seed"], "spectrum": "power-law lambda_k = k^-alpha (natural-image-like)"} t0 = time.time() # ---------------------------------------------------------------- C1: kappa map + DE print("C1: renormalized noise scale kappa(sigma^2) [Eq. 4 / Fig 2B]") plt.figure(figsize=(6, 4.2)) c1_rows = [] de_mc_relerr = [] for n in cfg["c1_ns"]: gamma = d / n s2 = np.array(cfg["c1_sigma2"]) kap = np.array([rmt.solve_kappa(x, eigs, gamma) for x in s2]) plt.plot(s2, kap, marker="o", ms=3, label=f"n={n} (gamma={gamma:.2f})") # DE-vs-MC validation of the trace resolvent identity at each sigma^2 for xi, ki in zip(s2, kap): de = rmt._normalized_trace_resolvent(eigs, ki) mc = rmt.mc_trace_resolvent(eigs, float(xi), n, R=cfg["c1_R"], rng=rng) de_mc_relerr.append(abs(de - mc) / mc) c1_rows.append([n, gamma, xi, ki, de, mc]) plt.plot(cfg["c1_sigma2"], cfg["c1_sigma2"], "k--", lw=1, label="identity (infinite data)") plt.xscale("log"); plt.yscale("log"); plt.xlabel(r"$\sigma^2$"); plt.ylabel(r"$\kappa(\sigma^2)$") plt.title("C1 Renormalized noise scale (finite data push $\\kappa \\geq \\sigma^2$)") plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC1_kappa.png"), dpi=130) plt.close() _save_csv("claimC1_kappa.csv", ["n", "gamma", "sigma2", "kappa", "trace_DE", "trace_MC"], c1_rows) summary["C1_trace_DE_vs_MC_median_relerr"] = float(np.median(de_mc_relerr)) summary["C1_kappa_ge_sigma2_always"] = bool(all(r[3] >= r[2] - 1e-9 for r in c1_rows)) # ---------------------------------------------------- C2/C3: shrinkage along PC (Fig 2C) print("C2/C3: expected shrinkage along PCs + overshrinkage [Result 4.1 / Fig 2C]") s2 = cfg["shr_sigma2"]; n = cfg["shr_n"] x_probe = rng.standard_normal(d) * np.sqrt(eigs + s2) # a generic noised sample diag_mean, diag_var, resp_var, total_var = combined_mc(eigs, s2, n, cfg["shr_R"], x_probe, rng) kappa, renorm, naive = rmt.predict_shrinkage_along_pc(eigs, s2, d / n) # agreement between MC diagonal shrinkage and the DE (renormalized) prediction shr_relerr = np.median(np.abs(diag_mean - renorm) / np.abs(renorm)) shr_relerr_naive = np.median(np.abs(diag_mean - naive) / np.abs(naive)) plt.figure(figsize=(6, 4.2)) order = np.argsort(eigs) plt.plot(eigs[order], naive[order], "g--", lw=1.5, label=r"naive $\lambda/(\lambda+\sigma^2)$ (infinite data)") plt.plot(eigs[order], renorm[order], "b-", lw=1.5, label=r"DE $\lambda/(\lambda+\kappa)$ (finite-data theory)") plt.plot(eigs[order], diag_mean[order], "r.", ms=5, label="MC empirical denoiser") plt.xscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$"); plt.ylabel("shrinkage factor") plt.title(f"C3 Overshrinkage of low modes ($\\kappa$={kappa:.3f} > $\\sigma^2$={s2})") plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC3_shrinkage.png"), dpi=130) plt.close() _save_csv("claimC3_shrinkage.csv", ["lambda_k", "MC_shrinkage", "DE_renorm", "naive_pop"], [[eigs[k], diag_mean[k], renorm[k], naive[k]] for k in range(d)]) summary["C3_kappa"] = float(kappa) summary["C3_shrinkage_MC_vs_DE_median_relerr"] = float(shr_relerr) summary["C3_shrinkage_MC_vs_naive_median_relerr"] = float(shr_relerr_naive) # ------------------------------------------------------- C4: anisotropy variance (Fig 3B) print("C4: anisotropy of denoiser variance chi(lambda,kappa) [Result 4.2 / Fig 3B]") n = cfg["aniso_n"] x_probe2 = rng.standard_normal(d) * np.sqrt(eigs + s2) _, _, resp_var2, _ = combined_mc(eigs, s2, n, cfg["aniso_R"], x_probe2, rng) kappa4, var_pred, chi, inhom, peak_val = rmt.predict_denoiser_variance_along_pc(eigs, s2, n, x_probe2) # shape agreement (correlation) and peak-location check corr = float(np.corrcoef(resp_var2, var_pred)[0, 1]) k_peak_mc = int(np.argmax(resp_var2)); k_peak_th = int(np.argmax(chi)) lam_peak_mc, lam_peak_th = float(eigs[k_peak_mc]), float(eigs[k_peak_th]) plt.figure(figsize=(6, 4.2)) plt.plot(eigs, var_pred, "b-", lw=1.5, label="DE prediction (Result 4.2)") plt.plot(eigs, resp_var2, "r.", ms=5, label="MC variance across data splits") plt.axvline(kappa4, color="k", ls=":", lw=1, label=r"$\lambda=\kappa$ (predicted peak)") plt.xscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$") plt.ylabel(r"Var$[u_k^\top D^*_{\hat\Sigma}(x)]$") plt.title("C4 Anisotropy: variance peaks where $\\lambda_k \\approx \\kappa$") plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC4_anisotropy.png"), dpi=130) plt.close() _save_csv("claimC4_anisotropy.csv", ["lambda_k", "MC_var", "DE_var", "chi"], [[eigs[k], resp_var2[k], var_pred[k], chi[k]] for k in range(d)]) summary["C4_kappa"] = float(kappa4) summary["C4_shape_corr_MC_vs_DE"] = corr summary["C4_peak_lambda_MC"] = lam_peak_mc summary["C4_peak_lambda_theory_eq_kappa"] = lam_peak_th summary["C4_peak_matches_kappa"] = bool(abs(np.log(lam_peak_mc) - np.log(kappa4)) < 0.5) # --------------------------------------------------------- C5: global 1/n scaling (Fig 3D) print("C5: global scaling of consistency ~ 1/n [Fig 3D]") ns = cfg["scale_ns"]; tv = [] for nn in ns: _, _, _, total = combined_mc(eigs, cfg["scale_sigma2"], nn, cfg["scale_R"], x_probe, rng) tv.append(total) tv = np.array(tv); ns_a = np.array(ns, float) # fit slope of log(total_var) vs log(n) on the large-n half (renormalization-free regime) half = len(ns) // 2 slope = float(np.polyfit(np.log(ns_a[half:]), np.log(tv[half:]), 1)[0]) plt.figure(figsize=(6, 4.2)) plt.plot(ns_a, tv, "ro-", ms=4, label="MC total denoiser variance") plt.plot(ns_a, tv[half] * (ns_a / ns_a[half]) ** (-1.0), "k--", lw=1, label=r"$\propto 1/n$ reference") plt.xscale("log"); plt.yscale("log"); plt.xlabel("dataset size n"); plt.ylabel("total variance") plt.title(f"C5 Consistency improves as ~1/n (fitted slope={slope:.2f})") plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC5_scaling.png"), dpi=130) plt.close() _save_csv("claimC5_scaling.csv", ["n", "total_variance"], [[ns[i], tv[i]] for i in range(len(ns))]) summary["C5_large_n_loglog_slope"] = slope summary["C5_slope_near_minus1"] = bool(abs(slope + 1.0) < 0.15) # ------------------------------------------------ C6: sampling-map overshrinkage + # DETERMINISTIC-EQUIVALENCE for the EXPECTATION of Sigma_hat^{1/2} (Result 5.1 / Fig 4A) print("C6: sampling-map sqrt-covariance overshrinkage + DE expectation [Result 5.1 / Fig 4A]") plt.figure(figsize=(6, 4.2)) ideal = np.sqrt(eigs) # ideal infinite-data sampling-map scaling c6_rows = [] order = np.argsort(eigs) plt.plot(eigs[order], ideal[order], "k-", lw=1.5, label=r"ideal $\sqrt{\lambda_k}$ (infinite data)") c6_de_relerr = [] for nn in cfg["sqrt_ns"]: mc_scale = rmt.mc_sqrt_cov_scaling(eigs, nn, cfg["sqrt_R"], rng) de_scale = rmt.predict_sqrt_cov_scaling(eigs, nn)[1] # DE prediction (Result 5.1) rel = np.abs(de_scale - mc_scale) / np.abs(mc_scale) c6_de_relerr.append(float(np.median(rel))) p = plt.plot(eigs[order], mc_scale[order], ".", ms=4, label=f"MC, n={nn}")[0] plt.plot(eigs[order], de_scale[order], "-", lw=1.0, color=p.get_color(), label=f"DE, n={nn}") for k in range(d): c6_rows.append([nn, eigs[k], ideal[k], mc_scale[k], de_scale[k]]) plt.xscale("log"); plt.yscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$") plt.ylabel(r"$u_k^\top \hat\Sigma^{1/2} u_k$") plt.title("C6 Sampling-map expectation: DE vs MC (overshrinks $\\sqrt{\\lambda_k}$ at low modes)") plt.legend(fontsize=7, ncol=2); plt.tight_layout() plt.savefig(os.path.join(OUT, "claimC6_sqrtcov.png"), dpi=130) plt.close() _save_csv("claimC6_sqrtcov.csv", ["n", "lambda_k", "ideal_sqrt", "MC_scale", "DE_scale"], c6_rows) mc_small = rmt.mc_sqrt_cov_scaling(eigs, cfg["sqrt_ns"][0], cfg["sqrt_R"], rng) low = order[d // 2:] summary["C6_low_mode_overshrink_ratio_small_n"] = float(np.mean(mc_small[low] / ideal[low])) summary["C6_sqrtmap_expectation_DE_vs_MC_median_relerr"] = float(np.median(c6_de_relerr)) # ------------------------------------------------ C7: sampling-map VARIANCE over # trajectories: anisotropy + 1/n decay (Result 5.2) print("C7: sampling-map variance over trajectories [Result 5.2]") ns_var = cfg["scale_ns"] tot_var, c7_rows = [], [] for nn in ns_var: v = rmt.mc_sqrtmap_variance(eigs, nn, cfg["sqrt_R"], rng) tot_var.append(float(v.sum())) for k in range(d): c7_rows.append([nn, eigs[k], v[k], rmt.predict_sqrtmap_variance(eigs, nn)[k]]) tot_var = np.array(tot_var) var_slope = float(np.polyfit(np.log(ns_var), np.log(tot_var), 1)[0]) # per-mode DE check at a mid n (leading-order lambda_k/(2n)); anisotropy corr n_mid = ns_var[len(ns_var) // 2] v_mid = rmt.mc_sqrtmap_variance(eigs, n_mid, cfg["sqrt_R"], rng) de_mid = rmt.predict_sqrtmap_variance(eigs, n_mid) top = order[:40] # well-estimated (high-variance) modes var_relerr = float(np.median(np.abs(v_mid[top] - de_mid[top]) / de_mid[top])) aniso_corr = float(np.corrcoef(np.log(v_mid[:60]), np.log(eigs[:60]))[0, 1]) plt.figure(figsize=(6, 4.2)) plt.loglog(ns_var, tot_var, "o-", label=f"MC total sampling-map variance (slope {var_slope:.2f})") plt.loglog(ns_var, tot_var[0] * ns_var[0] / np.array(ns_var), "k--", label=r"$1/n$ reference") plt.xlabel("dataset size $n$"); plt.ylabel(r"$\sum_k \mathrm{Var}[u_k^\top\hat\Sigma^{1/2}u_k]$") plt.title("C7 Sampling-map (trajectory) variance decays as $1/n$ [Result 5.2]") plt.legend(fontsize=8); plt.tight_layout() plt.savefig(os.path.join(OUT, "claimC7_sqrtmap_variance.png"), dpi=130) plt.close() _save_csv("claimC7_sqrtmap_variance.csv", ["n", "lambda_k", "MC_var", "DE_var_leading"], c7_rows) summary["C7_sqrtmap_variance_loglog_slope"] = var_slope summary["C7_sqrtmap_variance_anisotropy_corr"] = aniso_corr summary["C7_sqrtmap_variance_DE_vs_MC_median_relerr_topmodes"] = var_relerr # ------------------------------------------------ F1: linear-diffusion SPLIT CONSISTENCY # two non-overlapping splits -> similar samples from the same seed (Fig 1) print("F1: linear-diffusion consistency across non-overlapping data splits [Fig 1]") ns_con = cfg["scale_ns"] n_seeds = cfg.get("consistency_seeds", 400) cos_list, dev_list, f1_rows = [], [], [] for nn in ns_con: c, d2 = rmt.mc_split_consistency(eigs, nn, n_seeds, rng) cos_list.append(c); dev_list.append(d2) f1_rows.append([nn, c, d2]) dev_slope = float(np.polyfit(np.log(ns_con), np.log(dev_list), 1)[0]) fig, ax1 = plt.subplots(figsize=(6, 4.2)) ax1.semilogx(ns_con, cos_list, "o-", color="C0") ax1.set_xlabel("dataset size $n$ per split") ax1.set_ylabel("mean cross-split cosine similarity", color="C0") ax1.tick_params(axis="y", labelcolor="C0"); ax1.set_ylim(0.6, 1.02) ax2 = ax1.twinx() ax2.loglog(ns_con, dev_list, "s--", color="C3") ax2.set_ylabel(r"rel. squared deviation $\|x_A-x_B\|^2/\|x_A\|\|x_B\|$", color="C3") ax2.tick_params(axis="y", labelcolor="C3") ax1.set_title(f"F1 Non-overlapping splits generate similar samples (deviation $\\sim n^{{{dev_slope:.2f}}}$)") fig.tight_layout(); plt.savefig(os.path.join(OUT, "claimF1_split_consistency.png"), dpi=130) plt.close() _save_csv("claimF1_split_consistency.csv", ["n", "mean_cosine", "mean_rel_sq_deviation"], f1_rows) summary["F1_cosine_small_n"] = float(cos_list[0]) summary["F1_cosine_large_n"] = float(cos_list[-1]) summary["F1_deviation_loglog_slope"] = dev_slope summary["runtime_sec"] = round(time.time() - t0, 1) json.dump(summary, open(os.path.join(OUT, "results_summary.json"), "w"), indent=2) # human-readable summary with open(os.path.join(OUT, "results_summary.md"), "w") as f: f.write("# Reproduction results — arXiv:2602.02908 (linear theory)\n\n") f.write(f"Population: d={d}, power-law spectrum (alpha={alpha}); seed={cfg['seed']}; " f"runtime {summary['runtime_sec']}s on CPU.\n\n") f.write("| Claim | Check | Result |\n|---|---|---|\n") f.write(f"| C1 | kappa >= sigma^2 always | {summary['C1_kappa_ge_sigma2_always']} |\n") f.write(f"| C1 | trace-resolvent DE vs MC (median rel.err) | {summary['C1_trace_DE_vs_MC_median_relerr']:.2%} |\n") f.write(f"| C3 | MC shrinkage vs DE-renormalized (median rel.err) | {summary['C3_shrinkage_MC_vs_DE_median_relerr']:.2%} |\n") f.write(f"| C3 | MC shrinkage vs naive population (median rel.err) | {summary['C3_shrinkage_MC_vs_naive_median_relerr']:.2%} |\n") f.write(f"| C4 | anisotropy shape corr (MC vs DE) | {summary['C4_shape_corr_MC_vs_DE']:.3f} |\n") f.write(f"| C4 | variance peak at lambda≈kappa | MC λ={summary['C4_peak_lambda_MC']:.3f} vs κ={summary['C4_kappa']:.3f} ({summary['C4_peak_matches_kappa']}) |\n") f.write(f"| C5 | large-n log-log slope (≈ -1) | {summary['C5_large_n_loglog_slope']:.2f} |\n") f.write(f"| C6 | low-mode sqrt-cov ratio < 1 (overshrink), small n | {summary['C6_low_mode_overshrink_ratio_small_n']:.3f} |\n") f.write(f"| C6 | sampling-map expectation DE vs MC (Result 5.1, median rel.err) | {summary['C6_sqrtmap_expectation_DE_vs_MC_median_relerr']:.2%} |\n") f.write(f"| C7 | sampling-map trajectory variance 1/n slope (Result 5.2) | {summary['C7_sqrtmap_variance_loglog_slope']:.2f} |\n") f.write(f"| C7 | sampling-map variance anisotropy corr (Var vs lambda) | {summary['C7_sqrtmap_variance_anisotropy_corr']:.3f} |\n") f.write(f"| F1 | cross-split sample cosine, n={cfg['scale_ns'][0]} -> {cfg['scale_ns'][-1]} (Fig 1) | {summary['F1_cosine_small_n']:.3f} -> {summary['F1_cosine_large_n']:.3f} |\n") f.write(f"| F1 | cross-split deviation 1/n slope (consistency improves) | {summary['F1_deviation_loglog_slope']:.2f} |\n") print("\n=== SUMMARY ===") print(open(os.path.join(OUT, "results_summary.md")).read()) if __name__ == "__main__": main()