Upload folder using huggingface_hub

src/analyze_results.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Reproduce the paper's results table and significance tests from data/scaling_v8.csv.
+Run from the repository root:  python src/analyze_results.py
+"""
+import csv, statistics as st, math
+from collections import defaultdict
+
+g = defaultdict(lambda: defaultdict(list))
+with open("data/scaling_v8.csv") as f:
+    for r in csv.DictReader(f):
+        g[r["size"]][r["variant"]].append(float(r["val_loss"]))
+
+def welch_t(a, b):
+    if len(a) < 2 or len(b) < 2:
+        return None
+    m1, m2 = st.mean(a), st.mean(b)
+    v1, v2 = st.variance(a), st.variance(b)
+    n1, n2 = len(a), len(b)
+    se = math.sqrt(v1/n1 + v2/n2)
+    return (m2 - m1) / se if se else float("inf")
+
+print(f"{'size':6s}{'Review':>9s}{'Highway':>9s}{'Standard':>10s}{'Rev-Hwy':>10s}{'Rev-Std':>10s}{'t(Hwy)':>9s}{'t(Std)':>9s}")
+for sz in ["60M", "150M", "320M", "590M", "1B"]:
+    rv, hw, sd = g[sz]["review_neutral"], g[sz]["highway"], g[sz]["standard"]
+    rm, hm, sm = st.mean(rv), st.mean(hw), st.mean(sd)
+    th, ts = welch_t(rv, hw), welch_t(rv, sd)
+    fh = f"{th:.2f}" if th is not None else "n/a"
+    fs = f"{ts:.2f}" if ts is not None else "n/a"
+    print(f"{sz:6s}{rm:9.4f}{hm:9.4f}{sm:10.4f}{hm-rm:+10.4f}{sm-rm:+10.4f}{fh:>9s}{fs:>9s}")
+print("\nPositive gap favours Review. |t| > ~2.8 (3 seeds) indicates p < 0.05.")
+print("Review significantly beats both baselines at 590M; the 1B gap is larger but a trend.")

src/make_emergence_figure.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Regenerate the emergence-at-scale figure (paper Figure 2) from data/scaling_v8.csv.
+Run from the repository root:  python src/make_emergence_figure.py
+"""
+import csv, statistics as st, math, matplotlib
+matplotlib.use("Agg"); import matplotlib.pyplot as plt
+from collections import defaultdict
+g = defaultdict(lambda: defaultdict(list)); pg = defaultdict(lambda: defaultdict(list))
+with open("data/scaling_v8.csv") as f:
+    for r in csv.DictReader(f):
+        g[r["size"]][r["variant"]].append(float(r["val_loss"]))
+        pg[r["size"]][r["variant"]].append(float(r["params_M"]))
+sizes = ["60M","150M","320M","590M","1B"]
+px = [st.mean(pg[s]["review_neutral"]) for s in sizes]
+def gap_se(base, sz):
+    rv, bl = g[sz]["review_neutral"], g[sz][base]
+    gap = st.mean(bl) - st.mean(rv)
+    se = math.sqrt(st.variance(rv)/len(rv) + st.variance(bl)/len(bl))
+    return gap, se, abs(gap/se) > 2.6
+fig, ax = plt.subplots(figsize=(8,5.2))
+for base,col,mk,lab in [("highway","#8e44ad","s","vs Highway gate (param-matched)"),
+                        ("standard","#444","o","vs Standard residual (param-matched)")]:
+    gaps=[];ses=[];sig=[]
+    for s in sizes:
+        gp,se,si=gap_se(base,s); gaps.append(gp);ses.append(se);sig.append(si)
+    ax.errorbar(px,gaps,yerr=ses,marker=mk,color=col,lw=2,ms=8,capsize=4,label=lab)
+    for x,y,si in zip(px,gaps,sig):
+        if si: ax.annotate("*",(x,y),textcoords="offset points",xytext=(0,8),fontsize=18,color=col,ha="center")
+ax.axhline(0,color="#aaa",lw=1.2,ls="--")
+ax.set_xscale("log"); ax.set_xlabel("parameters (millions, log scale)")
+ax.set_ylabel("Review's advantage  (baseline loss - Review loss)")
+ax.set_title("Review Residuals: the benefit emerges with scale")
+ax.set_xticks(px); ax.set_xticklabels(sizes); ax.grid(alpha=.25); ax.legend(loc="upper left")
+plt.tight_layout(); plt.savefig("paper/emergence_curve.png",dpi=150)
+print("wrote paper/emergence_curve.png")

src/run_on_runpod.ipynb

@@ -0,0 +1,92 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Combined: confirm scale trend + test plain standard residual\n",
+    "\n",
+    "Preloads your v6 results, then runs **22 new models** to answer both open questions in one go:\n",
+    "1. **Scale trend** \u2014 adds 2 more seeds at 590M & 1B for Review and Highway (n=1 -> n=3).\n",
+    "2. **Plain standard residual** \u2014 a parameter-matched standard model at every size.\n",
+    "\n",
+    "Biggest-first, so the decisive 1B/590M numbers land first. ~$55-70, ~9-11 h on B200. Resumable \u2014 if you want to\n",
+    "stop after the big sizes, you'll already have the scale-trend answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# CELL 1 \u2014 write runner + preload v6 results (so it only runs the 22 new models)\n",
+    "import base64\n",
+    "open(\"run_scaling.py\",\"wb\").write(base64.b64decode(\"#!/usr/bin/env python3
# Review Residuals scaling sweep — RESILIENT, RESUMABLE, disconnect-proof.
# Run on the pod:   nohup python run_scaling.py > scaling.log 2>&1 &
# Watch progress:   tail -f scaling.log
# It resumes automatically: any run already in scaling_partial.csv is skipped.
# Each run is launched in its OWN subprocess, so even a hard crash on one model
# only loses that one model — the sweep keeps going.

import os, sys, csv, time, math, subprocess
os.environ["PYTORCH_CUDA_ALLOC_CONF"]="expandable_segments:True"
CSV="scaling_v8.csv"

# ---- the scaling ladder (identical to the notebook) ----
SIZES=[
  dict(name="1B",   d=1536, L=24, h=16, steps=6000, seeds=[0,1,2]),
  dict(name="590M", d=1280, L=20, h=20, steps=7000, seeds=[0,1,2]),
  dict(name="320M", d=1024, L=16, h=16, steps=8000, seeds=[0,1]),
  dict(name="150M", d=768,  L=12, h=12, steps=8000, seeds=[0,1,2]),
  dict(name="60M",  d=512,  L=8,  h=8,  steps=8000, seeds=[0,1,2]),
]
VARIANTS=["review_neutral","highway","standard"]
# AttnRes is ~8x slower than the others; only run it at the small sizes as anchors.
ATTNRES_SIZES=[]   # no attnres in the recipe-fixed sweep
BLOCK=256; BATCH=64; LR=2e-4; WARMUP=500; N_TEXT=400000   # lower LR + warmup (fixes large-scale divergence)
FIELDS=["size","variant","seed","params_M","steps","val_loss","ece","minutes"]

def done_set():
    s=set()
    if os.path.exists(CSV):
        with open(CSV) as f:
            for r in csv.DictReader(f):
                s.add((r["size"],r["variant"],int(r["seed"])))
    return s

def append_row(row):
    new = not os.path.exists(CSV)
    with open(CSV,"a",newline="") as f:
        w=csv.DictWriter(f,fieldnames=FIELDS)
        if new: w.writeheader()
        w.writerow(row)

# ============================================================ ORCHESTRATOR
def orchestrate():
    print("[orch] installing deps...",flush=True)
    subprocess.run([sys.executable,"-m","pip","install","-q","datasets","transformers","accelerate","matplotlib","pandas"])
    done=done_set()
    plan=[]
    for SZ in SIZES:
        for v in VARIANTS:
            if v=="attnres_plus":
                if SZ["name"] not in ATTNRES_SIZES: continue
                seeds = SZ["seeds"] if SZ["name"]=="60M" else [0]
            else:
                seeds = SZ["seeds"]
            for sd in seeds: plan.append((SZ,v,sd))
    todo=[(SZ,v,sd) for (SZ,v,sd) in plan if (SZ["name"],v,sd) not in done]
    print(f"[orch] {len(done)} runs already done, {len(todo)} to go",flush=True)
    t0=time.time()
    for SZ,v,sd in todo:
        tag=f"{SZ['name']}/{v}/seed{sd}"
        print(f"\n[orch] === launching {tag} (elapsed {(time.time()-t0)/3600:.2f}h) ===",flush=True)
        # isolate each run in a fresh process: a hard crash here cannot kill the sweep
        rc=subprocess.call([sys.executable, os.path.abspath(__file__), "--worker", SZ["name"], v, str(sd)])
        if rc!=0:
            print(f"[orch] !! {tag} exited with code {rc} (logged as failure, continuing)",flush=True)
        else:
            print(f"[orch] ok {tag}",flush=True)
    print(f"\n[orch] SWEEP COMPLETE in {(time.time()-t0)/3600:.2f}h. Results in {CSV}.",flush=True)
    try:
        make_plot()
    except Exception as e:
        print("[orch] plot skipped:",e,flush=True)

# ============================================================ WORKER (one run)
def worker(size_name,variant,seed):
    import math, numpy as np, torch, torch.nn as nn, torch.nn.functional as F
    from datasets import load_dataset; from transformers import GPT2TokenizerFast
    torch.set_float32_matmul_precision("high"); torch.backends.cuda.matmul.allow_tf32=True; torch.backends.cudnn.allow_tf32=True
    device="cuda" if torch.cuda.is_available() else "cpu"; assert device=="cuda","need GPU"
    SZ=[s for s in SIZES if s["name"]==size_name][0]
    tok=GPT2TokenizerFast.from_pretrained("gpt2"); VOCAB=tok.vocab_size

    class RMSNorm(nn.Module):
        def __init__(s,d): super().__init__(); s.g=nn.Parameter(torch.ones(d))
        def forward(s,x): return x*torch.rsqrt(x.pow(2).mean(-1,keepdim=True)+1e-5)*s.g
    class Attn(nn.Module):
        def __init__(s,d,h,block): super().__init__(); s.h=h; s.qkv=nn.Linear(d,3*d); s.proj=nn.Linear(d,d)
        def forward(s,x):
            B,T,d=x.shape; q,k,v=s.qkv(x).split(d,2)
            q=q.view(B,T,s.h,d//s.h).transpose(1,2); k=k.view(B,T,s.h,d//s.h).transpose(1,2); v=v.view(B,T,s.h,d//s.h).transpose(1,2)
            return s.proj(F.scaled_dot_product_attention(q,k,v,is_causal=True).transpose(1,2).reshape(B,T,d))
    class MLP(nn.Module):
        def __init__(s,d): super().__init__(); s.f1=nn.Linear(d,4*d); s.f2=nn.Linear(4*d,d)
        def forward(s,x): return s.f2(F.gelu(s.f1(x)))
    def is_attnres(v): return v in ("attnres","attnres_plus")
    class GPT(nn.Module):
        def __init__(s,variant,d,n_layer,n_head,block,vocab):
            super().__init__(); s.variant=variant
            s.tok=nn.Embedding(vocab,d); s.pos=nn.Embedding(block,d); s.norms=nn.ModuleList(); s.subs=nn.ModuleList()
            for i in range(2*n_layer):
                s.norms.append(RMSNorm(d)); s.subs.append(Attn(d,n_head,block) if i%2==0 else MLP(d))
            nS=2*n_layer
            if variant=="highway": s.gate=nn.ModuleList([nn.Linear(d,d) for _ in range(nS)])
            if variant=="review_neutral":
                s.rgate=nn.ModuleList([nn.Linear(2*d,d) for _ in range(nS)])
                for g in s.rgate: nn.init.zeros_(g.weight); nn.init.zeros_(g.bias)
            if variant=="layerscale": s.ls=nn.ParameterList([nn.Parameter(torch.ones(d)*0.1) for _ in range(nS)])
            if variant=="rezero":     s.rez=nn.ParameterList([nn.Parameter(torch.zeros(1)) for _ in range(nS)])
            if is_attnres(variant): s.dq=nn.Parameter(torch.randn(nS+1,d)*0.02); s.dk=nn.Linear(d,d,bias=False)
            s.lnf=RMSNorm(d); s.head=nn.Linear(d,vocab,bias=False); s.head.weight=s.tok.weight
            # --- GPT-2 / nanoGPT initialization (stable deep training) ---
            def _gpt2(mod):
                if isinstance(mod,nn.Linear):
                    nn.init.normal_(mod.weight,mean=0.0,std=0.02)
                    if mod.bias is not None: nn.init.zeros_(mod.bias)
                elif isinstance(mod,nn.Embedding):
                    nn.init.normal_(mod.weight,mean=0.0,std=0.02)
            s.apply(_gpt2)
            # scale residual-projection outputs by 1/sqrt(2*n_layer)  <-- the key deep-stability fix
            for _n,_p in s.named_parameters():
                if _n.endswith("proj.weight") or _n.endswith("f2.weight"):
                    nn.init.normal_(_p,mean=0.0,std=0.02/math.sqrt(2*n_layer))
            # keep the review gate neutral (must stay zero for r=0.5 start)
            if variant=="review_neutral":
                for g in s.rgate: nn.init.zeros_(g.weight); nn.init.zeros_(g.bias)
        def _rms(s,x): return x*torch.rsqrt(x.pow(2).mean(-1,keepdim=True)+1e-5)
        def _depth_attn(s,M,qi):
            K=s._rms(s.dk(M)); a=(K*qi.view(1,1,1,-1)).sum(-1).softmax(-1).unsqueeze(-1); return (a*M).sum(2)
        def forward(s,idx,targets=None):
            B,T=idx.shape; x0=s.tok(idx)+s.pos(torch.arange(T,device=idx.device))[None]
            if is_attnres(s.variant):
                mem=[x0]
                for i,(nrm,sub) in enumerate(zip(s.norms,s.subs)):
                    mem.append(sub(nrm(s._depth_attn(torch.stack(mem,2),s.dq[i]))))
                h=s._depth_attn(torch.stack(mem,2),s.dq[-1])
            else:
                h=x0
                for i,(nrm,sub) in enumerate(zip(s.norms,s.subs)):
                    u=sub(nrm(h))
                    if s.variant=="highway": g=torch.sigmoid(s.gate[i](h)); h=h+g*u            # additive (identity preserved)
                    elif s.variant=="review_neutral": r=torch.sigmoid(s.rgate[i](torch.cat([s._rms(h),s._rms(u)],-1))); h=h+r*u   # additive (identity preserved)
                    elif s.variant=="layerscale": h=h+s.ls[i]*u
                    elif s.variant=="rezero": h=h+s.rez[i]*u
                    else: h=h+u
            logits=s.head(s.lnf(h))
            loss=F.cross_entropy(logits.view(-1,logits.size(-1)),targets.view(-1)) if targets is not None else None
            return logits,loss

    def attnres_width(SZ):
        def est(var,d,L,h):
            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
            if var=="review_neutral": p+=nS*(2*d*d+d)
            elif var=="attnres_plus": p+=(nS+1)*d+d*d
            return p
        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
        while est("attnres_plus",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
        return d
    def highway_width(SZ):
        def est(var,d,L,h):
            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
            if var=="review_neutral": p+=nS*(2*d*d+d)
            elif var=="highway": p+=nS*(d*d+d)
            return p
        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
        while est("highway",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
        return d
    def standard_width(SZ):
        def est(var,d,L,h):
            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
            if var=="review_neutral": p+=nS*(2*d*d+d)
            return p
        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
        while est("standard",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
        return d

    def load_data():
        texts=load_dataset("roneneldan/TinyStories", split=f"train[:{N_TEXT}]")["text"]
        ids=[]
        for i in range(0,len(texts),2000):
            for e in tok(texts[i:i+2000])["input_ids"]: ids.extend(e); ids.append(tok.eos_token_id)
        data=np.array(ids,dtype=np.uint16); sp=int(len(data)*0.97)
        return torch.from_numpy(data[:sp].astype(np.int64)), torch.from_numpy(data[sp:].astype(np.int64))
    def get_batch(t,B,T):
        ix=np.random.randint(0,len(t)-T-1,size=B)
        x=torch.stack([t[i:i+T] for i in ix]); y=torch.stack([t[i+1:i+1+T] for i in ix])
        return x.to(device,non_blocking=True), y.to(device,non_blocking=True)
    @torch.no_grad()
    def evaluate(model,val_t,B,n=80):
        model.eval(); L=[]; C=[]; K=[]
        for _ in range(n):
            x,y=get_batch(val_t,B,BLOCK); lo,l=model(x,y); L.append(l.item())
            p=lo.softmax(-1); c,pr=p.max(-1); C.append(c.flatten().cpu().numpy()); K.append((pr==y).flatten().cpu().numpy())
        C=np.concatenate(C); K=np.concatenate(K).astype(float); e=np.linspace(0,1,16); ece=0
        for i in range(15):
            m=(C>e[i])&(C<=e[i+1])
            if m.sum(): ece+=m.sum()/len(C)*abs(K[m].mean()-C[m].mean())
        return float(np.mean(L)),float(ece)

    print(f"[worker] {size_name} {variant} seed{seed} on {torch.cuda.get_device_name(0)}",flush=True)
    train_t,val_t=load_data()
    d = highway_width(SZ) if variant=="highway" else (standard_width(SZ) if variant=="standard" else SZ["d"])  # param-match baselines UP
    batch=BATCH
    for attempt in range(4):
        try:
            torch.manual_seed(seed); np.random.seed(seed)
            m=GPT(variant,d,SZ["L"],SZ["h"],BLOCK,VOCAB).to(device)
            P=sum(p.numel() for p in m.parameters())/1e6
            opt=torch.optim.AdamW(m.parameters(),lr=LR,weight_decay=0.1,betas=(0.9,0.95))
            def _lrlam(step, T=SZ["steps"], W=WARMUP):
                if step < W: return (step+1)/W                       # linear warmup
                prog=(step-W)/max(1,(T-W)); return 0.1+0.9*0.5*(1+math.cos(math.pi*min(1.0,prog)))  # cosine to 10%
            sch=torch.optim.lr_scheduler.LambdaLR(opt,_lrlam); t0=time.time()
            for step in range(SZ["steps"]):
                x,y=get_batch(train_t,batch,BLOCK); _,loss=m(x,y)
                opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(m.parameters(),1.0); opt.step(); sch.step()
                if step%1000==0: print(f"    step {step}/{SZ['steps']} loss {loss.item():.3f}",flush=True)
            vl,ece=evaluate(m,val_t,batch); mins=(time.time()-t0)/60
            append_row(dict(size=size_name,variant=variant,seed=seed,params_M=round(P,2),
                            steps=SZ["steps"],val_loss=round(vl,4),ece=round(ece,4),minutes=round(mins,1)))
            print(f"[worker] DONE {size_name} {variant} seed{seed} {P:.1f}M val {vl:.4f} ece {ece:.4f} {mins:.1f}min",flush=True)
            return 0
        except RuntimeError as ex:
            if "out of memory" in str(ex).lower() and batch>8:
                torch.cuda.empty_cache(); batch//=2
                print(f"[worker] OOM -> retry at batch {batch}",flush=True)
            else:
                raise
    return 1

# ============================================================ PLOT
def make_plot():
    import pandas as pd, matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
    df=pd.read_csv(CSV)
    df=df[df["val_loss"]<4.5]   # drop diverged runs from the plot
    agg=df.groupby(["size","variant"]).agg(params_M=("params_M","mean"),val_loss=("val_loss","mean")).reset_index()
    order=[s["name"] for s in SIZES]; agg["o"]=agg["size"].map({n:i for i,n in enumerate(order)}); agg=agg.sort_values("o")
    col={'review_neutral':'#27ae60','attnres_plus':'#8e44ad','highway':'#999'}
    mk={'review_neutral':'o','attnres_plus':'s','highway':'^'}
    fig,ax=plt.subplots(figsize=(8,5.4))
    for v in VARIANTS:
        s=agg[agg.variant==v].sort_values("params_M")
        if len(s): ax.plot(s["params_M"],s["val_loss"],marker=mk[v],color=col[v],lw=2,ms=8,label=v)
    ax.set_xscale("log"); ax.set_xlabel("parameters (millions, log scale)")
    ax.set_ylabel("validation loss  (lower = better)")
    ax.set_title("Review Residuals scaling — loss vs parameters (TinyStories)")
    ax.grid(alpha=.3,which="both"); ax.legend()
    plt.tight_layout(); plt.savefig("scaling_result.png",dpi=140)
    print("[plot] wrote scaling_result.png",flush=True)

if __name__=="__main__":
    if len(sys.argv)>1 and sys.argv[1]=="--worker":
        sys.exit(worker(sys.argv[2], sys.argv[3], int(sys.argv[4])))
    else:
        orchestrate()
\"))\n",
+    "open(\"scaling_v8.csv\",\"wb\").write(base64.b64decode(\"c2l6ZSx2YXJpYW50LHNlZWQscGFyYW1zX00sc3RlcHMsdmFsX2xvc3MsZWNlLG1pbnV0ZXMNCjYwTSxyZXZpZXdfbmV1dHJhbCwwLDU5LjQ3LDgwMDAsMS43MDE2LDAuMDA4Nyw2LjkNCjYwTSxyZXZpZXdfbmV1dHJhbCwxLDU5LjQ3LDgwMDAsMS42ODY2LDAuMDA4MSw2LjkNCjYwTSxyZXZpZXdfbmV1dHJhbCwyLDU5LjQ3LDgwMDAsMS42NzkxLDAuMDA4Nyw2LjkNCjYwTSxoaWdod2F5LDAsNjAuNjgsODAwMCwxLjY5OCwwLjAwNzgsNy4zDQo2ME0saGlnaHdheSwxLDYwLjY4LDgwMDAsMS42OTM4LDAuMDA4MSw3LjMNCjYwTSxoaWdod2F5LDIsNjAuNjgsODAwMCwxLjY4NTIsMC4wMDkzLDcuMw0KMTUwTSxyZXZpZXdfbmV1dHJhbCwwLDE1Mi4xNiw4MDAwLDEuNTY0MiwwLjAxNTUsMTIuNg0KMTUwTSxyZXZpZXdfbmV1dHJhbCwxLDE1Mi4xNiw4MDAwLDEuNTU3NiwwLjAxMzgsMTIuNg0KMTUwTSxyZXZpZXdfbmV1dHJhbCwyLDE1Mi4xNiw4MDAwLDEuNTUxLDAuMDE1LDEyLjYNCjE1ME0saGlnaHdheSwwLDE1My4yMSw4MDAwLDEuNTcxMywwLjAxMjQsMTMuNA0KMTUwTSxoaWdod2F5LDEsMTUzLjIxLDgwMDAsMS41NjE0LDAuMDEzOSwxMy40DQoxNTBNLGhpZ2h3YXksMiwxNTMuMjEsODAwMCwxLjU1NDksMC4wMTQxLDEzLjQNCjMyME0scmV2aWV3X25ldXRyYWwsMCwzMjAuMzcsODAwMCwxLjUwNjUsMC4wMjA1LDIwLjkNCjMyME0scmV2aWV3X25ldXRyYWwsMSwzMjAuMzcsODAwMCwxLjQ5MzcsMC4wMTkzLDIxLjANCjMyME0saGlnaHdheSwwLDMyOS4wMSw4MDAwLDEuNTA5LDAuMDE4NSwyMi44DQozMjBNLGhpZ2h3YXksMSwzMjkuMDEsODAwMCwxLjQ5OTMsMC4wMTc2LDIyLjgNCjU5ME0scmV2aWV3X25ldXRyYWwsMCw1ODkuMjgsNzAwMCwxLjQ4MTIsMC4wMjI2LDI5LjENCjU5ME0saGlnaHdheSwwLDYwMy4zLDcwMDAsMS40OTAzLDAuMDE5OSwzMi43DQoxQixyZXZpZXdfbmV1dHJhbCwwLDk4NC4wNCw2MDAwLDEuNDc4NywwLjAyMTcsMzcuMQ0KMUIsaGlnaHdheSwwLDk5Ni4zLDYwMDAsMS40OTUxLDAuMDE4OSwzNi44DQo=\"))\n",
+    "print(\"wrote run_scaling.py + preloaded scaling_v8.csv (v6 results); 22 new runs to go\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# CELL 2 \u2014 launch\n",
+    "import subprocess, sys, time\n",
+    "a=subprocess.run([\"pgrep\",\"-f\",\"run_scaling.py\"],capture_output=True,text=True).stdout.strip()\n",
+    "if a: print(\"already running\")\n",
+    "else:\n",
+    "    p=subprocess.Popen([sys.executable,\"run_scaling.py\"],stdout=open(\"scaling.log\",\"a\"),stderr=subprocess.STDOUT,start_new_session=True)\n",
+    "    print(\"LAUNCHED PID\",p.pid); time.sleep(3); print(open(\"scaling.log\").read()[-500:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# CELL 3 \u2014 CHECK (re-run anytime): 3-way summary per size\n",
+    "import os,csv,subprocess\n",
+    "from collections import defaultdict\n",
+    "a=subprocess.run([\"pgrep\",\"-f\",\"run_scaling.py\"],capture_output=True,text=True).stdout.strip()\n",
+    "print(\"STATUS:\", \"RUNNING \u2705\" if a else \"not running\")\n",
+    "print(\"=\"*64)\n",
+    "if os.path.exists(\"scaling_v8.csv\"):\n",
+    "    rows=list(csv.DictReader(open(\"scaling_v8.csv\")))\n",
+    "    print(f\"total rows: {len(rows)} (42 = all done)\")\n",
+    "    g=defaultdict(lambda: defaultdict(list))\n",
+    "    for r in rows: g[r[\"size\"]][r[\"variant\"]].append(float(r[\"val_loss\"]))\n",
+    "    for sz in [\"60M\",\"150M\",\"320M\",\"590M\",\"1B\"]:\n",
+    "        d=g[sz]\n",
+    "        def m(v): xs=d.get(v,[]); return f\"{sum(xs)/len(xs):.4f}({len(xs)}s)\" if xs else \"  --  \"\n",
+    "        print(f\"  {sz:5s} Review {m('review_neutral')}  Highway {m('highway')}  Standard {m('standard')}\")\n",
+    "print(\"=\"*64,\"\\n\",open(\"scaling.log\").read()[-800:] if os.path.exists(\"scaling.log\") else \"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Done = 42 total rows\n",
+    "Send me `scaling_v8.csv`. I'll run the full stats: Review vs Highway (multi-seed at 590M/1B now), and Review vs\n",
+    "the param-matched plain standard residual across the whole curve. That settles both questions."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

src/train.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Review Residuals --- training and evaluation for the paper
+"An Update-Conditioned Residual Gate Whose Advantage Emerges at Scale" (Kramer, 2026).
+
+Trains, from scratch on TinyStories, three identity-preserving (additive) residual variants:
+  - review_neutral : update scaled by a gate conditioned on BOTH state and proposed update  (ours)
+  - highway        : update scaled by a gate conditioned on the state only  (param-matched up)
+  - standard       : plain residual, update added with coefficient 1        (param-matched up)
+across five model sizes (60M-1B). Resumable; writes per-run validation losses to scaling_v8.csv.
+Requires a CUDA GPU (80GB for the 590M/1B sizes). See README.md to reproduce.
+"""
+
+#!/usr/bin/env python3
+# Review Residuals scaling sweep — RESILIENT, RESUMABLE, disconnect-proof.
+# Run on the pod:   nohup python run_scaling.py > scaling.log 2>&1 &
+# Watch progress:   tail -f scaling.log
+# It resumes automatically: any run already in scaling_partial.csv is skipped.
+# Each run is launched in its OWN subprocess, so even a hard crash on one model
+# only loses that one model — the sweep keeps going.
+
+import os, sys, csv, time, math, subprocess
+os.environ["PYTORCH_CUDA_ALLOC_CONF"]="expandable_segments:True"
+CSV="scaling_v8.csv"
+
+# ---- the scaling ladder (identical to the notebook) ----
+SIZES=[
+  dict(name="1B",   d=1536, L=24, h=16, steps=6000, seeds=[0,1,2]),
+  dict(name="590M", d=1280, L=20, h=20, steps=7000, seeds=[0,1,2]),
+  dict(name="320M", d=1024, L=16, h=16, steps=8000, seeds=[0,1]),
+  dict(name="150M", d=768,  L=12, h=12, steps=8000, seeds=[0,1,2]),
+  dict(name="60M",  d=512,  L=8,  h=8,  steps=8000, seeds=[0,1,2]),
+]
+VARIANTS=["review_neutral","highway","standard"]
+# AttnRes is ~8x slower than the others; only run it at the small sizes as anchors.
+ATTNRES_SIZES=[]   # no attnres in the recipe-fixed sweep
+BLOCK=256; BATCH=64; LR=2e-4; WARMUP=500; N_TEXT=400000   # lower LR + warmup (fixes large-scale divergence)
+FIELDS=["size","variant","seed","params_M","steps","val_loss","ece","minutes"]
+
+def done_set():
+    s=set()
+    if os.path.exists(CSV):
+        with open(CSV) as f:
+            for r in csv.DictReader(f):
+                s.add((r["size"],r["variant"],int(r["seed"])))
+    return s
+
+def append_row(row):
+    new = not os.path.exists(CSV)
+    with open(CSV,"a",newline="") as f:
+        w=csv.DictWriter(f,fieldnames=FIELDS)
+        if new: w.writeheader()
+        w.writerow(row)
+
+# ============================================================ ORCHESTRATOR
+def orchestrate():
+    print("[orch] installing deps...",flush=True)
+    subprocess.run([sys.executable,"-m","pip","install","-q","datasets","transformers","accelerate","matplotlib","pandas"])
+    done=done_set()
+    plan=[]
+    for SZ in SIZES:
+        for v in VARIANTS:
+            if v=="attnres_plus":
+                if SZ["name"] not in ATTNRES_SIZES: continue
+                seeds = SZ["seeds"] if SZ["name"]=="60M" else [0]
+            else:
+                seeds = SZ["seeds"]
+            for sd in seeds: plan.append((SZ,v,sd))
+    todo=[(SZ,v,sd) for (SZ,v,sd) in plan if (SZ["name"],v,sd) not in done]
+    print(f"[orch] {len(done)} runs already done, {len(todo)} to go",flush=True)
+    t0=time.time()
+    for SZ,v,sd in todo:
+        tag=f"{SZ['name']}/{v}/seed{sd}"
+        print(f"\n[orch] === launching {tag} (elapsed {(time.time()-t0)/3600:.2f}h) ===",flush=True)
+        # isolate each run in a fresh process: a hard crash here cannot kill the sweep
+        rc=subprocess.call([sys.executable, os.path.abspath(__file__), "--worker", SZ["name"], v, str(sd)])
+        if rc!=0:
+            print(f"[orch] !! {tag} exited with code {rc} (logged as failure, continuing)",flush=True)
+        else:
+            print(f"[orch] ok {tag}",flush=True)
+    print(f"\n[orch] SWEEP COMPLETE in {(time.time()-t0)/3600:.2f}h. Results in {CSV}.",flush=True)
+    try:
+        make_plot()
+    except Exception as e:
+        print("[orch] plot skipped:",e,flush=True)
+
+# ============================================================ WORKER (one run)
+def worker(size_name,variant,seed):
+    import math, numpy as np, torch, torch.nn as nn, torch.nn.functional as F
+    from datasets import load_dataset; from transformers import GPT2TokenizerFast
+    torch.set_float32_matmul_precision("high"); torch.backends.cuda.matmul.allow_tf32=True; torch.backends.cudnn.allow_tf32=True
+    device="cuda" if torch.cuda.is_available() else "cpu"; assert device=="cuda","need GPU"
+    SZ=[s for s in SIZES if s["name"]==size_name][0]
+    tok=GPT2TokenizerFast.from_pretrained("gpt2"); VOCAB=tok.vocab_size
+
+    class RMSNorm(nn.Module):
+        def __init__(s,d): super().__init__(); s.g=nn.Parameter(torch.ones(d))
+        def forward(s,x): return x*torch.rsqrt(x.pow(2).mean(-1,keepdim=True)+1e-5)*s.g
+    class Attn(nn.Module):
+        def __init__(s,d,h,block): super().__init__(); s.h=h; s.qkv=nn.Linear(d,3*d); s.proj=nn.Linear(d,d)
+        def forward(s,x):
+            B,T,d=x.shape; q,k,v=s.qkv(x).split(d,2)
+            q=q.view(B,T,s.h,d//s.h).transpose(1,2); k=k.view(B,T,s.h,d//s.h).transpose(1,2); v=v.view(B,T,s.h,d//s.h).transpose(1,2)
+            return s.proj(F.scaled_dot_product_attention(q,k,v,is_causal=True).transpose(1,2).reshape(B,T,d))
+    class MLP(nn.Module):
+        def __init__(s,d): super().__init__(); s.f1=nn.Linear(d,4*d); s.f2=nn.Linear(4*d,d)
+        def forward(s,x): return s.f2(F.gelu(s.f1(x)))
+    def is_attnres(v): return v in ("attnres","attnres_plus")
+    class GPT(nn.Module):
+        def __init__(s,variant,d,n_layer,n_head,block,vocab):
+            super().__init__(); s.variant=variant
+            s.tok=nn.Embedding(vocab,d); s.pos=nn.Embedding(block,d); s.norms=nn.ModuleList(); s.subs=nn.ModuleList()
+            for i in range(2*n_layer):
+                s.norms.append(RMSNorm(d)); s.subs.append(Attn(d,n_head,block) if i%2==0 else MLP(d))
+            nS=2*n_layer
+            if variant=="highway": s.gate=nn.ModuleList([nn.Linear(d,d) for _ in range(nS)])
+            if variant=="review_neutral":
+                s.rgate=nn.ModuleList([nn.Linear(2*d,d) for _ in range(nS)])
+                for g in s.rgate: nn.init.zeros_(g.weight); nn.init.zeros_(g.bias)
+            if variant=="layerscale": s.ls=nn.ParameterList([nn.Parameter(torch.ones(d)*0.1) for _ in range(nS)])
+            if variant=="rezero":     s.rez=nn.ParameterList([nn.Parameter(torch.zeros(1)) for _ in range(nS)])
+            if is_attnres(variant): s.dq=nn.Parameter(torch.randn(nS+1,d)*0.02); s.dk=nn.Linear(d,d,bias=False)
+            s.lnf=RMSNorm(d); s.head=nn.Linear(d,vocab,bias=False); s.head.weight=s.tok.weight
+            # --- GPT-2 / nanoGPT initialization (stable deep training) ---
+            def _gpt2(mod):
+                if isinstance(mod,nn.Linear):
+                    nn.init.normal_(mod.weight,mean=0.0,std=0.02)
+                    if mod.bias is not None: nn.init.zeros_(mod.bias)
+                elif isinstance(mod,nn.Embedding):
+                    nn.init.normal_(mod.weight,mean=0.0,std=0.02)
+            s.apply(_gpt2)
+            # scale residual-projection outputs by 1/sqrt(2*n_layer)  <-- the key deep-stability fix
+            for _n,_p in s.named_parameters():
+                if _n.endswith("proj.weight") or _n.endswith("f2.weight"):
+                    nn.init.normal_(_p,mean=0.0,std=0.02/math.sqrt(2*n_layer))
+            # keep the review gate neutral (must stay zero for r=0.5 start)
+            if variant=="review_neutral":
+                for g in s.rgate: nn.init.zeros_(g.weight); nn.init.zeros_(g.bias)
+        def _rms(s,x): return x*torch.rsqrt(x.pow(2).mean(-1,keepdim=True)+1e-5)
+        def _depth_attn(s,M,qi):
+            K=s._rms(s.dk(M)); a=(K*qi.view(1,1,1,-1)).sum(-1).softmax(-1).unsqueeze(-1); return (a*M).sum(2)
+        def forward(s,idx,targets=None):
+            B,T=idx.shape; x0=s.tok(idx)+s.pos(torch.arange(T,device=idx.device))[None]
+            if is_attnres(s.variant):
+                mem=[x0]
+                for i,(nrm,sub) in enumerate(zip(s.norms,s.subs)):
+                    mem.append(sub(nrm(s._depth_attn(torch.stack(mem,2),s.dq[i]))))
+                h=s._depth_attn(torch.stack(mem,2),s.dq[-1])
+            else:
+                h=x0
+                for i,(nrm,sub) in enumerate(zip(s.norms,s.subs)):
+                    u=sub(nrm(h))
+                    if s.variant=="highway": g=torch.sigmoid(s.gate[i](h)); h=h+g*u            # additive (identity preserved)
+                    elif s.variant=="review_neutral": r=torch.sigmoid(s.rgate[i](torch.cat([s._rms(h),s._rms(u)],-1))); h=h+r*u   # additive (identity preserved)
+                    elif s.variant=="layerscale": h=h+s.ls[i]*u
+                    elif s.variant=="rezero": h=h+s.rez[i]*u
+                    else: h=h+u
+            logits=s.head(s.lnf(h))
+            loss=F.cross_entropy(logits.view(-1,logits.size(-1)),targets.view(-1)) if targets is not None else None
+            return logits,loss
+
+    def attnres_width(SZ):
+        def est(var,d,L,h):
+            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
+            if var=="review_neutral": p+=nS*(2*d*d+d)
+            elif var=="attnres_plus": p+=(nS+1)*d+d*d
+            return p
+        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
+        while est("attnres_plus",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
+        return d
+    def highway_width(SZ):
+        def est(var,d,L,h):
+            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
+            if var=="review_neutral": p+=nS*(2*d*d+d)
+            elif var=="highway": p+=nS*(d*d+d)
+            return p
+        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
+        while est("highway",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
+        return d
+    def standard_width(SZ):
+        def est(var,d,L,h):
+            nS=2*L; p=VOCAB*d+BLOCK*d+nS*d+L*(4*d*d+4*d)+L*(8*d*d+5*d)+d
+            if var=="review_neutral": p+=nS*(2*d*d+d)
+            return p
+        base=est("review_neutral",SZ["d"],SZ["L"],SZ["h"]); d=SZ["d"]
+        while est("standard",d,SZ["L"],SZ["h"])<base: d+=SZ["h"]
+        return d
+
+    def load_data():
+        texts=load_dataset("roneneldan/TinyStories", split=f"train[:{N_TEXT}]")["text"]
+        ids=[]
+        for i in range(0,len(texts),2000):
+            for e in tok(texts[i:i+2000])["input_ids"]: ids.extend(e); ids.append(tok.eos_token_id)
+        data=np.array(ids,dtype=np.uint16); sp=int(len(data)*0.97)
+        return torch.from_numpy(data[:sp].astype(np.int64)), torch.from_numpy(data[sp:].astype(np.int64))
+    def get_batch(t,B,T):
+        ix=np.random.randint(0,len(t)-T-1,size=B)
+        x=torch.stack([t[i:i+T] for i in ix]); y=torch.stack([t[i+1:i+1+T] for i in ix])
+        return x.to(device,non_blocking=True), y.to(device,non_blocking=True)
+    @torch.no_grad()
+    def evaluate(model,val_t,B,n=80):
+        model.eval(); L=[]; C=[]; K=[]
+        for _ in range(n):
+            x,y=get_batch(val_t,B,BLOCK); lo,l=model(x,y); L.append(l.item())
+            p=lo.softmax(-1); c,pr=p.max(-1); C.append(c.flatten().cpu().numpy()); K.append((pr==y).flatten().cpu().numpy())
+        C=np.concatenate(C); K=np.concatenate(K).astype(float); e=np.linspace(0,1,16); ece=0
+        for i in range(15):
+            m=(C>e[i])&(C<=e[i+1])
+            if m.sum(): ece+=m.sum()/len(C)*abs(K[m].mean()-C[m].mean())
+        return float(np.mean(L)),float(ece)
+
+    print(f"[worker] {size_name} {variant} seed{seed} on {torch.cuda.get_device_name(0)}",flush=True)
+    train_t,val_t=load_data()
+    d = highway_width(SZ) if variant=="highway" else (standard_width(SZ) if variant=="standard" else SZ["d"])  # param-match baselines UP
+    batch=BATCH
+    for attempt in range(4):
+        try:
+            torch.manual_seed(seed); np.random.seed(seed)
+            m=GPT(variant,d,SZ["L"],SZ["h"],BLOCK,VOCAB).to(device)
+            P=sum(p.numel() for p in m.parameters())/1e6
+            opt=torch.optim.AdamW(m.parameters(),lr=LR,weight_decay=0.1,betas=(0.9,0.95))
+            def _lrlam(step, T=SZ["steps"], W=WARMUP):
+                if step < W: return (step+1)/W                       # linear warmup
+                prog=(step-W)/max(1,(T-W)); return 0.1+0.9*0.5*(1+math.cos(math.pi*min(1.0,prog)))  # cosine to 10%
+            sch=torch.optim.lr_scheduler.LambdaLR(opt,_lrlam); t0=time.time()
+            for step in range(SZ["steps"]):
+                x,y=get_batch(train_t,batch,BLOCK); _,loss=m(x,y)
+                opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(m.parameters(),1.0); opt.step(); sch.step()
+                if step%1000==0: print(f"    step {step}/{SZ['steps']} loss {loss.item():.3f}",flush=True)
+            vl,ece=evaluate(m,val_t,batch); mins=(time.time()-t0)/60
+            append_row(dict(size=size_name,variant=variant,seed=seed,params_M=round(P,2),
+                            steps=SZ["steps"],val_loss=round(vl,4),ece=round(ece,4),minutes=round(mins,1)))
+            print(f"[worker] DONE {size_name} {variant} seed{seed} {P:.1f}M val {vl:.4f} ece {ece:.4f} {mins:.1f}min",flush=True)
+            return 0
+        except RuntimeError as ex:
+            if "out of memory" in str(ex).lower() and batch>8:
+                torch.cuda.empty_cache(); batch//=2
+                print(f"[worker] OOM -> retry at batch {batch}",flush=True)
+            else:
+                raise
+    return 1
+
+# ============================================================ PLOT
+def make_plot():
+    import pandas as pd, matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
+    df=pd.read_csv(CSV)
+    df=df[df["val_loss"]<4.5]   # drop diverged runs from the plot
+    agg=df.groupby(["size","variant"]).agg(params_M=("params_M","mean"),val_loss=("val_loss","mean")).reset_index()
+    order=[s["name"] for s in SIZES]; agg["o"]=agg["size"].map({n:i for i,n in enumerate(order)}); agg=agg.sort_values("o")
+    col={'review_neutral':'#27ae60','attnres_plus':'#8e44ad','highway':'#999'}
+    mk={'review_neutral':'o','attnres_plus':'s','highway':'^'}
+    fig,ax=plt.subplots(figsize=(8,5.4))
+    for v in VARIANTS:
+        s=agg[agg.variant==v].sort_values("params_M")
+        if len(s): ax.plot(s["params_M"],s["val_loss"],marker=mk[v],color=col[v],lw=2,ms=8,label=v)
+    ax.set_xscale("log"); ax.set_xlabel("parameters (millions, log scale)")
+    ax.set_ylabel("validation loss  (lower = better)")
+    ax.set_title("Review Residuals scaling — loss vs parameters (TinyStories)")
+    ax.grid(alpha=.3,which="both"); ax.legend()
+    plt.tight_layout(); plt.savefig("scaling_result.png",dpi=140)
+    print("[plot] wrote scaling_result.png",flush=True)
+
+if __name__=="__main__":
+    if len(sys.argv)>1 and sys.argv[1]=="--worker":
+        sys.exit(worker(sys.argv[2], sys.argv[3], int(sys.argv[4])))
+    else:
+        orchestrate()