scripts/p24_flops_plot.py

"""p24_flops_plot.py — Analytical active MLP FLOPs per token vs depth for P24 variants.

No model is trained or even run. FLOPs are computed analytically from layer
dimensions. Forward + backward = 6 × matmul params (Chinchilla convention).

Usage (from repo root, with venv active):
    python -m scripts.p24_flops_plot [--out p24_flops.png] [--rs 4] [--min-select 128]
"""
import argparse
import math
import sys
import os

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from scripts._sweep_utils import model_dims

# ── depths and palette ─────────────────────────────────────────────────────────
DEPTHS = [2, 3, 4, 6, 8, 12, 16, 20]

PALETTE = {
    "Dense":         "#6C63FF",
    "SlicedWeight":  "#00C9A7",
    "FoldedMod":     "#FF6B6B",
    "SequenceGated": "#FFD166",
}
MARKERS = {
    "Dense":         "o",
    "SlicedWeight":  "s",
    "FoldedMod":     "^",
    "SequenceGated": "D",
}
LINESTYLES = {
    "Dense":         "-",
    "SlicedWeight":  "-",
    "FoldedMod":     "--",
    "SequenceGated": "--",
}

# ── FLOPs helpers ──────────────────────────────────────────────────────────────

def dense_mlp_flops(C: int, n_layers: int) -> int:
    """Forward+backward matmul FLOPs for all MLP layers of a dense model.
    Uses Chinchilla convention: 6 × params = 2 × fwd × (in×out) × 3 dirs.
    Per layer: c_fc (C→4C) + c_proj (4C→C) = 2 × C × 4C + 2 × 4C × C = 16 C²
    ×3 (fwd+bwd) = 48 C² per layer.
    """
    per_layer = 6 * (C * 4 * C + 4 * C * C)   # 6 × (fwd) = fwd+bwd
    return per_layer * n_layers


def sliced_mlp_flops(C: int, n_layers: int, rs: int, min_select: int) -> int:
    """SlicedWeight: selects n_sel columns of the weight per token.
    c_fc:   in=C,   out=4C  →  n_sel_fc  = min(C,   max(min_select, C   // rs))
    c_proj: in=4C,  out=C   →  n_sel_proj = min(4C, max(min_select, 4C  // rs))
    Active matmul: n_sel_fc × 4C  +  n_sel_proj × C  per token per layer.
    """
    n_sel_fc   = min(C,      max(min_select, C   // rs))
    n_sel_proj = min(4 * C,  max(min_select, 4*C // rs))
    per_layer = 6 * (n_sel_fc * 4 * C + n_sel_proj * C)
    return per_layer * n_layers


def folded_mlp_flops(C: int, n_layers: int, rs: int, min_folded: int) -> int:
    """FoldedMod: folds in_features by effective_R, weight is (out, folded_dim).
    folded_dim_raw = in // rs
    if folded_dim_raw < min_folded: effective_R = max(1, in // min_folded)
    else:                           effective_R = rs
    folded_dim = in // effective_R     (≥ 1, ≤ in)
    Active matmul: folded_dim × out  per token.
    """
    def folded(in_f: int) -> int:
        raw = max(1, in_f // rs)
        eff_r = (max(1, in_f // min_folded) if raw < min_folded else rs)
        return max(1, in_f // eff_r)

    fd_fc   = folded(C)        # c_fc folded dim (operates on C, outputs 4C)
    fd_proj = folded(4 * C)    # c_proj folded dim (operates on 4C, outputs C)
    per_layer = 6 * (fd_fc * 4 * C + fd_proj * C)
    return per_layer * n_layers


def seqgated_mlp_flops(C: int, n_layers: int, T: int = 2048) -> int:
    """SequenceGatedLinear: dense weight + amortised gate projection.
    weight is identical to dense (C→4C and 4C→C).
    Gate proj: c_fc gate  = Linear(C,   C)   computed once per sequence → C²/T per token
              c_proj gate = Linear(4C, 4C)   computed once per sequence → 16C²/T per token
    For T=2048 this is negligible vs 16C² dense, but we include it for accuracy.
    """
    dense   = 6 * (C * 4 * C + 4 * C * C)
    # gate projections are amortised over T tokens
    gate_fc   = int(6 * C * C / T)        # (C → C) gate for c_fc, per token
    gate_proj = int(6 * 4*C * 4*C / T)    # (4C → 4C) gate for c_proj, per token
    per_layer = dense + gate_fc + gate_proj
    return per_layer * n_layers


# ── main ───────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--out",           default="p24_active_flops.png")
    parser.add_argument("--rs",            type=int, default=4,
                        help="Reduction scale for SlicedWeight and FoldedMod")
    parser.add_argument("--min-select",    type=int, default=128,
                        help="min_select floor for SlicedWeight")
    parser.add_argument("--min-folded",    type=int, default=128,
                        help="min_folded_dim floor for FoldedMod")
    parser.add_argument("--seq-len",       type=int, default=2048,
                        help="Sequence length (for SequenceGated gate amortisation)")
    args = parser.parse_args()

    rs, min_s, min_fd, T = args.rs, args.min_select, args.min_folded, args.seq_len

    print(f"Analytical P24 MLP FLOPs (Chinchilla ×6)")
    print(f"  RS={rs}  min_select={min_s}  min_folded={min_fd}  seq_len={T}")
    print(f"{'Depth':>6}  {'n_embd':>7}  {'Dense':>12}  {'Sliced':>12}  {'Folded':>12}  {'SeqGated':>12}  {'Sliced%':>8}  {'Folded%':>8}")

    data = {v: [] for v in PALETTE}
    x_labels = []

    for depth in DEPTHS:
        _, _, C, _ = model_dims(depth)
        x_labels.append(f"d{depth}\n(C={C})")

        d = dense_mlp_flops(C, depth)
        s = sliced_mlp_flops(C, depth, rs, min_s)
        f = folded_mlp_flops(C, depth, rs, min_fd)
        g = seqgated_mlp_flops(C, depth, T)

        data["Dense"].append(d)
        data["SlicedWeight"].append(s)
        data["FoldedMod"].append(f)
        data["SequenceGated"].append(g)

        print(f"{depth:>6}  {C:>7}  {d:>12,}  {s:>12,}  {f:>12,}  {g:>12,}  "
              f"{100*s/d:>7.1f}%  {100*f/d:>7.1f}%")

    # ── plot ───────────────────────────────────────────────────────────────────
    fig, (ax_main, ax_pct) = plt.subplots(
        2, 1, figsize=(14, 10),
        gridspec_kw={"height_ratios": [3, 1]},
    )
    fig.patch.set_facecolor("#0F1117")
    for ax in (ax_main, ax_pct):
        ax.set_facecolor("#161B22")
        ax.spines[:].set_color("#30363D")
        ax.tick_params(colors="#8B949E", labelsize=9)

    x = np.arange(len(DEPTHS))

    # — top panel: absolute FLOPs ———————————————————————————————————————————
    for variant, flops_list in data.items():
        fl = np.array(flops_list, dtype=float)
        is_dashed = LINESTYLES[variant] == "--"
        ax_main.plot(
            x, fl,
            marker=MARKERS[variant],
            linestyle=LINESTYLES[variant],
            color=PALETTE[variant],
            linewidth=2.5,
            markersize=8,
            markerfacecolor="none" if is_dashed else PALETTE[variant],
            markeredgecolor=PALETTE[variant] if is_dashed else "white",
            markeredgewidth=1.2 if is_dashed else 0.8,
            label=variant,
            zorder=3,
        )
        # annotate last point
        ax_main.annotate(
            f"{fl[-1]/1e9:.2f}G",
            xy=(x[-1], fl[-1]),
            xytext=(7, 0),
            textcoords="offset points",
            color=PALETTE[variant],
            fontsize=8.5,
            va="center",
            fontweight="bold",
        )

    # shade saving vs dense
    dense_arr = np.array(data["Dense"], dtype=float)
    best = np.minimum(np.array(data["SlicedWeight"]), np.array(data["FoldedMod"])).astype(float)
    ax_main.fill_between(x, best, dense_arr, color="#6C63FF", alpha=0.07, zorder=1)

    ax_main.set_xticks(x)
    ax_main.set_xticklabels(x_labels, color="#C9D1D9", fontsize=8.5)
    ax_main.yaxis.set_major_formatter(
        ticker.FuncFormatter(lambda v, _: f"{v/1e9:.1f}G"))
    ax_main.set_ylabel("MLP FLOPs / token (fwd+bwd)", color="#C9D1D9",
                        fontsize=11, labelpad=8)
    ax_main.grid(axis="y", color="#21262D", linewidth=0.8, zorder=0)
    ax_main.grid(axis="x", color="#21262D", linewidth=0.4, zorder=0)
    ax_main.tick_params(axis='y', colors="#8B949E")

    legend = ax_main.legend(
        loc="upper left",
        framealpha=0.25,
        facecolor="#21262D",
        edgecolor="#30363D",
        labelcolor="#C9D1D9",
        fontsize=11,
    )

    ax_main.set_title(
        f"P24 Variants — Active MLP FLOPs vs Depth  "
        f"(RS={rs}, min_select={min_s}, min_folded={min_fd})",
        color="#E6EDF3",
        fontsize=13,
        fontweight="bold",
        pad=14,
    )

    # — bottom panel: % of dense ———————————————————————————————————————————
    for variant, flops_list in data.items():
        if variant == "Dense":
            continue
        pct = 100 * np.array(flops_list) / dense_arr
        is_dashed = LINESTYLES[variant] == "--"
        ax_pct.plot(
            x, pct,
            marker=MARKERS[variant],
            linestyle=LINESTYLES[variant],
            color=PALETTE[variant],
            linewidth=2,
            markersize=6,
            markerfacecolor="none" if is_dashed else PALETTE[variant],
            markeredgecolor=PALETTE[variant] if is_dashed else "white",
            markeredgewidth=1.0 if is_dashed else 0.6,
            label=variant,
            zorder=3,
        )

    ax_pct.axhline(100, color=PALETTE["Dense"], linewidth=1.2,
                   linestyle="--", alpha=0.6, label="Dense (100%)")
    ax_pct.set_xticks(x)
    ax_pct.set_xticklabels(x_labels, color="#C9D1D9", fontsize=8.5)
    ax_pct.yaxis.set_major_formatter(ticker.FuncFormatter(lambda v, _: f"{v:.0f}%"))
    ax_pct.set_ylabel("% of Dense FLOPs", color="#C9D1D9", fontsize=10, labelpad=8)
    ax_pct.set_xlabel("Model Depth  (n_embd)", color="#C9D1D9", fontsize=11, labelpad=8)
    ax_pct.grid(axis="y", color="#21262D", linewidth=0.8, zorder=0)
    ax_pct.grid(axis="x", color="#21262D", linewidth=0.4, zorder=0)
    ax_pct.tick_params(axis='y', colors="#8B949E")
    ax_pct.legend(loc="upper left", framealpha=0.2, facecolor="#21262D",
                  edgecolor="#30363D", labelcolor="#C9D1D9", fontsize=9)

    # footer
    footer = (
        f"SlicedWeight RS={rs}: selects max({min_s}, C//RS) input dims/token  │  "
        f"FoldedMod RS={rs}: folds to max({min_fd}, C//RS) dims  │  "
        "SequenceGated: dense weight + amortised gate (≈ Dense)  │  "
        "MLP only (FFN path); attn FLOPs excluded"
    )
    fig.text(0.5, 0.005, footer, ha="center", color="#6E7681", fontsize=7.5)

    plt.tight_layout(rect=[0, 0.025, 1, 1])
    plt.savefig(args.out, dpi=150, bbox_inches="tight",
                facecolor=fig.get_facecolor())
    print(f"\n✓ Saved: {args.out}")


if __name__ == "__main__":
    main()