scripts/analyze_gd.py

"""Analysis + figures for the squared-loss GD trajectories (Claims 3 and 4).

Theorem 4.1:  ||theta_t - theta*||^2 <= C (1 - eta alpha)^{t - tbar},  tbar <= C log d / eta.
Section 4:    phase 1 = angle reduction + norm growth (O(log d / eta) steps),
              phase 2 = geometric refinement.
"""

from __future__ import annotations

import glob
import json
import math
import os

import numpy as np
import pandas as pd
import plotly.graph_objects as go

from analyze import PALETTE, _c, linfit, write_fig, thresholds_fig

RES = "results"


def load(prefix):
    t = pd.read_csv(f"{RES}/{prefix}_traj.csv")
    s = pd.read_csv(f"{RES}/{prefix}_summary.csv")
    return t, s


def mean_traj(t):
    return (t.groupby(["d", "step"])[["sq_overlap", "norm", "dist2", "loss"]]
             .mean().reset_index())


def first_cross(steps, vals, target, above=True):
    steps, vals = np.asarray(steps), np.asarray(vals)
    m = vals >= target if above else vals <= target
    return float(steps[np.argmax(m)]) if m.any() else np.nan


def traj_fig(mt, ycol, title, ytitle, logy=False, hline=None):
    dims = sorted(mt["d"].unique())
    fig = go.Figure()
    for i, d in enumerate(dims):
        s = mt[mt["d"] == d]
        fig.add_trace(go.Scatter(x=s["step"], y=s[ycol], mode="lines", name=f"d={d}",
                                 line=dict(color=_c(i, len(dims)), width=2)))
    if hline is not None:
        fig.add_hline(y=hline, line_dash="dot", line_color="#888")
    fig.update_layout(title=title, xaxis_title="GD step t", yaxis_title=ytitle,
                      template="plotly_white", height=460)
    if logy:
        fig.update_yaxes(type="log")
    return fig


def phase_table(t, eta, targets=(0.9,)):
    rows = []
    for (d, seed), g in t.groupby(["d", "seed"]):
        g = g.sort_values("step")
        st, ov, nr, d2 = (g["step"].values, g["sq_overlap"].values,
                          g["norm"].values, g["dist2"].values)
        t_angle = first_cross(st, ov, 0.9)
        t_norm = first_cross(st, nr, 0.25)
        tbar = np.nanmax([t_angle, t_norm])
        rate = np.nan
        if np.isfinite(tbar):
            m = (st >= tbar) & (d2 > 1e-11) & (d2 < 1e2)
            if m.sum() >= 5:
                b, a = np.polyfit(st[m], np.log(d2[m]), 1)
                rate = float(b)
        rows.append(dict(d=int(d), seed=int(seed), t_angle=t_angle, t_norm=t_norm,
                         tbar=tbar, log_rate_per_step=rate,
                         rho=math.exp(rate) if np.isfinite(rate) else np.nan,
                         alpha_implied=(1 - math.exp(rate)) / eta
                         if np.isfinite(rate) else np.nan,
                         t_star_angle_pred=3 * math.log(d) / math.log(1 + 1.99 * eta)))
    return pd.DataFrame(rows)


def main():
    out = {}
    targets = [0.1, 0.2, 0.3, 0.4, 0.5]

    # ------------------------------------------------ main run: r0 = d^-2 ----
    t, s = load("gd_trunc_r2")
    eta = float(s["eta"].iloc[0])
    mt = mean_traj(t)
    mt.to_csv(f"{RES}/agg_gd_trunc_r2.csv", index=False)
    write_fig(traj_fig(mt, "sq_overlap",
                       "Squared-loss full-batch GD — overlap vs steps (truncated σ, M=8, δ=10)",
                       "Squared overlap ⟨θ*, θ̂⟩²"), "gd_overlap")
    write_fig(traj_fig(mt, "norm",
                       "Squared-loss full-batch GD — ‖θ_t‖ vs steps (truncated σ, M=8, δ=10)",
                       "‖θ_t‖", hline=1.0), "gd_norm")
    write_fig(traj_fig(mt, "dist2",
                       "Strong recovery: ‖θ_t − θ*‖² vs steps (truncated σ, M=8, δ=10)",
                       "‖θ_t − θ*‖²", logy=True), "gd_dist2")

    thr = []
    for d in sorted(mt["d"].unique()):
        g = mt[mt["d"] == d].sort_values("step")
        for tg in targets:
            thr.append(dict(target=tg, d=int(d), logd=math.log(d),
                            value=first_cross(g["step"], g["sq_overlap"], tg)))
    tdf = pd.DataFrame(thr)
    tdf.to_csv(f"{RES}/gd_time_thresholds.csv", index=False)
    write_fig(thresholds_fig(thr, "Iteration complexity vs log d — full-batch GD, squared loss",
                             ytitle="GD steps T to reach target overlap"), "gd_T_vs_logd")
    out["T_vs_logd_fits"] = [
        dict(target=tg, **linfit(tdf[tdf["target"] == tg]["logd"],
                                 tdf[tdf["target"] == tg]["value"]))
        for tg in targets]

    ph = phase_table(t, eta)
    ph.to_csv(f"{RES}/gd_phases.csv", index=False)
    phm = ph.groupby("d").median(numeric_only=True).reset_index()
    phm["logd"] = np.log(phm["d"])
    out["eta"] = eta
    out["phases_median"] = phm.to_dict("records")
    out["tbar_vs_logd"] = linfit(phm["logd"], phm["tbar"])
    out["alpha_implied"] = dict(median=float(phm["alpha_implied"].median()),
                                min=float(phm["alpha_implied"].min()),
                                max=float(phm["alpha_implied"].max()))
    out["final"] = s.groupby("d")[["final_dist2", "final_sq_overlap", "final_norm",
                                   "final_loss"]].median().reset_index().to_dict("records")

    # phase figure: two-phase decomposition for one dimension
    dsel = 1024 if 1024 in set(mt["d"]) else sorted(mt["d"])[-1]
    g = mt[mt["d"] == dsel].sort_values("step")
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=g["step"], y=g["norm"], name="‖θ_t‖",
                             line=dict(color=PALETTE[1], width=2)))
    fig.add_trace(go.Scatter(x=g["step"], y=g["sq_overlap"], name="⟨θ*, θ̂⟩²",
                             line=dict(color=PALETTE[5], width=2)))
    fig.add_trace(go.Scatter(x=g["step"], y=g["dist2"], name="‖θ_t − θ*‖²",
                             line=dict(color=PALETTE[3], width=2, dash="dot"),
                             yaxis="y2"))
    tb = float(phm[phm["d"] == dsel]["tbar"].iloc[0])
    fig.add_vline(x=tb, line_dash="dash", line_color="#444",
                  annotation_text=f"t̄ ≈ {tb:.0f}", annotation_position="top")
    fig.update_layout(
        title=f"Two-phase trajectory (d={dsel}): angle reduction + norm growth, then geometric refinement",
        xaxis_title="GD step t", yaxis_title="overlap² / ‖θ_t‖",
        yaxis2=dict(title="‖θ_t − θ*‖²", overlaying="y", side="right", type="log"),
        template="plotly_white", height=470)
    write_fig(fig, "gd_two_phase")

    # ------------------------------------------------ r0 = d^-15 (Theorem) --
    if os.path.exists(f"{RES}/gd_trunc_r15_traj.csv"):
        t15, s15 = load("gd_trunc_r15")
        mt15 = mean_traj(t15)
        mt15.to_csv(f"{RES}/agg_gd_trunc_r15.csv", index=False)
        write_fig(traj_fig(mt15, "norm",
                           "Theorem 4.1 initialisation r₀ = d⁻¹⁵ — norm growth",
                           "‖θ_t‖", logy=True), "gd_norm_r15")
        thr15 = []
        for d in sorted(mt15["d"].unique()):
            g = mt15[mt15["d"] == d].sort_values("step")
            for tg in targets:
                thr15.append(dict(target=tg, d=int(d), logd=math.log(d),
                                  value=first_cross(g["step"], g["sq_overlap"], tg)))
        write_fig(thresholds_fig(thr15, "Iteration complexity vs log d — r₀ = d⁻¹⁵",
                                 ytitle="GD steps T to reach target overlap"),
                  "gd_T_vs_logd_r15")
        pd.DataFrame(thr15).to_csv(f"{RES}/gd_time_thresholds_r15.csv", index=False)
        out["r15_T_vs_logd_fits"] = [
            dict(target=tg, **linfit([r["logd"] for r in thr15 if r["target"] == tg],
                                     [r["value"] for r in thr15 if r["target"] == tg]))
            for tg in targets]
        ph15 = phase_table(t15, float(s15["eta"].iloc[0]))
        ph15.to_csv(f"{RES}/gd_phases_r15.csv", index=False)
        out["r15_phases_median"] = (ph15.groupby("d").median(numeric_only=True)
                                    .reset_index().to_dict("records"))
        out["r15_final"] = s15.groupby("d")[["final_dist2", "final_sq_overlap"]] \
            .median().reset_index().to_dict("records")

    # ------------------------------------------------ eta scaling (Claim 4) --
    eta_rows = []
    for path in sorted(glob.glob(f"{RES}/gd_trunc_eta*_summary.csv")) + \
            [f"{RES}/gd_trunc_r2_summary.csv"]:
        pre = path.replace("_summary.csv", "").split("/")[-1]
        tt, ss = load(pre)
        e = float(ss["eta"].iloc[0])
        p = phase_table(tt, e).groupby("d").median(numeric_only=True).reset_index()
        for r in p.itertuples():
            eta_rows.append(dict(eta=e, d=int(r.d), tbar=r.tbar,
                                 tbar_times_eta=r.tbar * e,
                                 alpha_implied=r.alpha_implied))
    if eta_rows:
        edf = pd.DataFrame(eta_rows)
        edf.to_csv(f"{RES}/gd_eta_scaling.csv", index=False)
        fig = go.Figure()
        for i, d in enumerate(sorted(edf["d"].unique())):
            s2 = edf[edf["d"] == d].sort_values("eta")
            fig.add_trace(go.Scatter(x=1 / s2["eta"], y=s2["tbar"], mode="lines+markers",
                                     name=f"d={d}", line=dict(color=_c(i, edf["d"].nunique()))))
        fig.update_layout(title="Phase-1 length t̄ scales as 1/η (fixed d, δ=10)",
                          xaxis_title="1/η", yaxis_title="t̄ (steps)",
                          template="plotly_white", height=440)
        write_fig(fig, "gd_tbar_vs_eta")
        out["eta_scaling"] = edf.to_dict("records")

    # ------------------------------------------------ control: quadratic ----
    if os.path.exists(f"{RES}/gd_quad_r2_summary.csv"):
        _, sq = load("gd_quad_r2")
        out["control_quad_final"] = (sq.groupby("d")[["final_dist2", "final_sq_overlap",
                                                      "final_norm", "final_loss"]]
                                     .median().reset_index().to_dict("records"))
        cmp_rows = []
        for act, dfx in (("trunc", s), ("quad", sq)):
            for r in (dfx.groupby("d")[["final_dist2"]].median().reset_index()).itertuples():
                cmp_rows.append(dict(act=act, d=int(r.d), final_dist2=float(r.final_dist2)))
        cdf = pd.DataFrame(cmp_rows)
        fig = go.Figure()
        for i, act in enumerate(["trunc", "quad"]):
            s2 = cdf[cdf["act"] == act].sort_values("d")
            fig.add_trace(go.Bar(x=[str(int(v)) for v in s2["d"]], y=s2["final_dist2"],
                                 name={"trunc": "truncated σ (Thm 4.1)",
                                       "quad": "untruncated σ(z)=z² (control)"}[act],
                                 marker_color=PALETTE[1 if act == "trunc" else 5]))
        fig.update_layout(title="Strong recovery control: final ‖θ_T − θ*‖² at δ=10, T=6000",
                          xaxis_title="d", yaxis_title="‖θ_T − θ*‖²", yaxis_type="log",
                          template="plotly_white", height=440, barmode="group")
        write_fig(fig, "gd_control_quad")
        cdf.to_csv(f"{RES}/gd_control_quad.csv", index=False)

    with open(f"{RES}/gd_analysis_summary.json", "w") as f:
        json.dump(out, f, indent=2, default=float)
    print(json.dumps({k: v for k, v in out.items()
                      if k in ("eta", "T_vs_logd_fits", "tbar_vs_logd", "alpha_implied",
                               "phases_median", "final")}, indent=2, default=float))


if __name__ == "__main__":
    main()