scripts/exp02_neural.py

#!/usr/bin/env python3
"""exp02_neural — reduced-scale neural verification of Claims 4, 5, 6.

Real CIFAR-100 + CIFAR-100N (UCSC-REAL, human noisy labels), SmallCNN, CPU.
Optimizers: SGD, SAM (Foret et al. 2021), fSGLD (Eq 5). See specs/exp02_neural.md.
CPU only, torch/joblib. See BLOCKERS.md for the reduced-scale rationale.
"""
import os

for _v in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS", "NUMEXPR_NUM_THREADS"):
    os.environ.setdefault(_v, "1")

import argparse
import hashlib
import json
import math
import pickle
import sys
import tarfile
import time
import urllib.request

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from joblib import Parallel, delayed

ROOT = os.path.dirname(os.path.abspath(__file__))
BASE = os.path.dirname(ROOT)
WORK_DIR = os.path.join(BASE, "work")
DATA_DIR = os.path.join(WORK_DIR, "data")
RESULTS_DIR = os.path.join(BASE, "results")

CIFAR100_URL = "https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz"
CIFAR100_MD5 = "eb9058c3a382ffc7106e4002c42a8d85"
CIFAR100N_URL = "https://github.com/UCSC-REAL/cifar-10-100n/raw/main/data/CIFAR-100_human.pt"

MEAN = np.array([0.5071, 0.4865, 0.4409], dtype=np.float32)
STD = np.array([0.2673, 0.2564, 0.2762], dtype=np.float32)

BETA = 1e8
ETA_FSGLD = 0.1
SIGMA_FSGLD = BETA ** (-(1 + ETA_FSGLD) / 4.0)
WD = 5e-4
RHO_SAM = 0.05
BASE_LR = 0.1
FT_LR = 0.02
BATCH = 128


def log(msg):
    print(msg, file=sys.stderr, flush=True)


# ------------------------------------------------------------------------- data
def _md5(path):
    h = hashlib.md5()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()


def _download(url, path):
    log(f"[data] downloading {url} -> {path}")
    tmp = path + ".part"
    urllib.request.urlretrieve(url, tmp)
    os.replace(tmp, path)


def load_cifar100(provenance):
    os.makedirs(DATA_DIR, exist_ok=True)
    tar_path = os.path.join(DATA_DIR, "cifar-100-python.tar.gz")
    if not os.path.exists(tar_path) or _md5(tar_path) != CIFAR100_MD5:
        _download(CIFAR100_URL, tar_path)
    md5ok = _md5(tar_path) == CIFAR100_MD5
    log(f"[data] cifar100 tarball md5_ok={md5ok} sha256={hashlib.sha256(open(tar_path,'rb').read()).hexdigest()}")

    with tarfile.open(tar_path, "r:gz") as tf:
        train_raw = pickle.load(tf.extractfile("cifar-100-python/train"), encoding="latin1")
        test_raw = pickle.load(tf.extractfile("cifar-100-python/test"), encoding="latin1")

    train_data = np.asarray(train_raw["data"], dtype=np.uint8)
    test_data = np.asarray(test_raw["data"], dtype=np.uint8)
    train_fine = np.asarray(train_raw["fine_labels"], dtype=np.int64)
    test_fine = np.asarray(test_raw["fine_labels"], dtype=np.int64)

    struct_ok = (
        train_data.shape == (50000, 3072)
        and test_data.shape == (10000, 3072)
        and len(np.unique(train_fine)) == 100
        and train_data.min() >= 0 and train_data.max() <= 255
    )
    provenance["cifar100_sha256_ok"] = bool(md5ok and struct_ok)
    provenance["n_train"] = int(train_data.shape[0])
    provenance["n_test"] = int(test_data.shape[0])
    log(f"[data] cifar100 struct_ok={struct_ok} n_train={train_data.shape[0]} n_test={test_data.shape[0]}")
    return train_data, train_fine, test_data, test_fine


def load_cifar100n(provenance):
    os.makedirs(DATA_DIR, exist_ok=True)
    pt_path = os.path.join(DATA_DIR, "CIFAR-100_human.pt")
    if not os.path.exists(pt_path):
        _download(CIFAR100N_URL, pt_path)
    d = torch.load(pt_path, weights_only=False)
    noisy = np.asarray(d["noisy_label"], dtype=np.int64)
    clean = np.asarray(d["clean_label"], dtype=np.int64)
    provenance["cifar100n_len"] = int(len(noisy))
    noise_rate = float(np.mean(noisy != clean))
    provenance["cifar100n_noise_rate"] = noise_rate
    log(f"[data] cifar100n len={len(noisy)} noise_rate={noise_rate:.4f}")
    return noisy, clean


def preprocess(data_u8):
    imgs = data_u8.reshape(-1, 3, 32, 32).astype(np.float32) / 255.0
    imgs = (imgs - MEAN.reshape(1, 3, 1, 1)) / STD.reshape(1, 3, 1, 1)
    return imgs.astype(np.float32)


def get_subset_indices(n_subset, seed_tag):
    path = os.path.join(WORK_DIR, f"exp02_subset_indices_{seed_tag}_{n_subset}.npy")
    if os.path.exists(path):
        return np.load(path)
    idx = np.random.default_rng(0).choice(50000, n_subset, replace=False)
    np.save(path, idx)
    return idx


# ------------------------------------------------------------------------- augmentation
def augment_batch(x_np):
    # x_np: (B,3,32,32) float32, pad=4 random crop + random horizontal flip
    B = x_np.shape[0]
    padded = np.pad(x_np, ((0, 0), (0, 0), (4, 4), (4, 4)), mode="reflect")
    out = np.empty_like(x_np)
    for i in range(B):
        top = np.random.randint(0, 9)
        left = np.random.randint(0, 9)
        crop = padded[i, :, top:top + 32, left:left + 32]
        if np.random.rand() < 0.5:
            crop = crop[:, :, ::-1]
        out[i] = crop
    return np.ascontiguousarray(out)


# ------------------------------------------------------------------------- model
class SmallCNN(nn.Module):
    def __init__(self, n_classes=100):
        super().__init__()
        self.c1 = nn.Conv2d(3, 32, 3, padding=1)
        self.b1 = nn.BatchNorm2d(32)
        self.c2 = nn.Conv2d(32, 64, 3, padding=1)
        self.b2 = nn.BatchNorm2d(64)
        self.c3 = nn.Conv2d(64, 128, 3, padding=1)
        self.b3 = nn.BatchNorm2d(128)
        self.c4 = nn.Conv2d(128, 128, 3, padding=1)
        self.b4 = nn.BatchNorm2d(128)
        self.pool = nn.MaxPool2d(2)
        self.gap = nn.AdaptiveAvgPool2d(4)
        self.fc1 = nn.Linear(128 * 16, 256)
        self.fc2 = nn.Linear(256, n_classes)

    def forward(self, x):
        x = F.relu(self.b1(self.c1(x)))
        x = self.pool(F.relu(self.b2(self.c2(x))))
        x = self.pool(F.relu(self.b3(self.c3(x))))
        x = F.relu(self.b4(self.c4(x)))
        x = self.gap(x).flatten(1)
        x = F.relu(self.fc1(x))
        return self.fc2(x)


# ------------------------------------------------------------------------- optimizers
def lr_at(epoch, base_lr, milestones):
    lr = base_lr
    for m in milestones:
        if epoch >= m:
            lr *= 0.1
    return lr


def sgd_step(model, opt, xb, yb):
    opt.zero_grad()
    out = model(xb)
    loss = F.cross_entropy(out, yb)
    loss.backward()
    opt.step()
    return loss.item(), 1


def sam_step(model, opt, xb, yb, rho):
    # first pass: compute grad at theta
    opt.zero_grad()
    out = model(xb)
    loss1 = F.cross_entropy(out, yb)
    loss1.backward()
    params = [p for p in model.parameters() if p.grad is not None]
    with torch.no_grad():
        grad_norm = torch.norm(torch.stack([p.grad.norm(2) for p in params])) + 1e-12
        eps_list = []
        for p in params:
            e = p.grad * (rho / grad_norm)
            p.add_(e)
            eps_list.append(e)
    # second pass: grad at theta+eps, used for the real update
    opt.zero_grad()
    out2 = model(xb)
    loss2 = F.cross_entropy(out2, yb)
    loss2.backward()
    with torch.no_grad():
        for p, e in zip(params, eps_list):
            p.sub_(e)
    opt.step()
    return loss1.item(), 2


def fsgld_step(model, params, lam, sigma, beta, wd, xb, yb):
    with torch.no_grad():
        eps_list = [torch.randn_like(p) * sigma for p in params]
        for p, e in zip(params, eps_list):
            p.add_(e)
    for p in params:
        if p.grad is not None:
            p.grad = None
    out = model(xb)
    loss = F.cross_entropy(out, yb)
    loss.backward()
    with torch.no_grad():
        for p, e in zip(params, eps_list):
            p.sub_(e)
        for p in params:
            g = p.grad + wd * p
            xi = torch.randn_like(p)
            p.add_(-lam * g + math.sqrt(2 * lam / beta) * xi)
    return loss.item(), 1


# ------------------------------------------------------------------------- train / eval
def make_optimizer(name, model):
    if name == "SGD":
        return torch.optim.SGD(model.parameters(), lr=BASE_LR, momentum=0.9, weight_decay=WD)
    if name == "SAM":
        return torch.optim.SGD(model.parameters(), lr=BASE_LR, momentum=0.9, weight_decay=WD)
    return None


def set_lr(opt, lr):
    for g in opt.param_groups:
        g["lr"] = lr


def run_epochs(model, optimizer_name, train_x, train_y, epochs, milestones, base_lr,
                batch_size, measure_timing=False, warmup_steps=10, timing_steps=50):
    n = train_x.shape[0]
    torch_opt = make_optimizer(optimizer_name, model) if optimizer_name in ("SGD", "SAM") else None
    params = [p for p in model.parameters()]
    s_per_iter = None
    all_times = []
    step_times = []
    last_loss = None
    global_step = 0
    for epoch in range(epochs):
        lr = lr_at(epoch, base_lr, milestones)
        if torch_opt is not None:
            set_lr(torch_opt, lr)
        perm = np.random.permutation(n)
        model.train()
        for start in range(0, n, batch_size):
            idx = perm[start:start + batch_size]
            xb_np = augment_batch(train_x[idx])
            xb = torch.from_numpy(xb_np)
            yb = torch.from_numpy(train_y[idx])
            t0 = time.time() if measure_timing else None
            if optimizer_name == "SGD":
                loss, _ = sgd_step(model, torch_opt, xb, yb)
            elif optimizer_name == "SAM":
                loss, _ = sam_step(model, torch_opt, xb, yb, RHO_SAM)
            else:
                loss, _ = fsgld_step(model, params, lr, SIGMA_FSGLD, BETA, WD, xb, yb)
            if measure_timing:
                dt = time.time() - t0
                global_step += 1
                all_times.append(dt)
                if global_step > warmup_steps and len(step_times) < timing_steps:
                    step_times.append(dt)
            last_loss = loss
    if measure_timing and not step_times:
        step_times = all_times  # run too short to clear warmup; fall back to all steps
    if measure_timing and step_times:
        s_per_iter = float(np.mean(step_times))
    return last_loss, s_per_iter


@torch.no_grad()
def evaluate(model, test_x, test_y, batch_size=256):
    model.eval()
    correct = 0
    n = test_x.shape[0]
    for start in range(0, n, batch_size):
        xb = torch.from_numpy(test_x[start:start + batch_size])
        yb = torch.from_numpy(test_y[start:start + batch_size])
        out = model(xb)
        pred = out.argmax(1)
        correct += (pred == yb).sum().item()
    return correct / n


# ------------------------------------------------------------------------- flatness
def hvp(loss, params, v):
    grads = torch.autograd.grad(loss, params, create_graph=True)
    flat_grad = torch.cat([g.reshape(-1) for g in grads])
    flat_v = torch.cat([vi.reshape(-1) for vi in v])
    gv = (flat_grad * flat_v).sum()
    hv = torch.autograd.grad(gv, params, retain_graph=True)
    return [h.detach() for h in hv]


def compute_flatness(model, x_batch, y_batch, m_hutch, top_iters, tol=1e-4):
    model.eval()
    params = [p for p in model.parameters() if p.requires_grad]
    x = torch.from_numpy(x_batch)
    y = torch.from_numpy(y_batch)

    def get_loss():
        out = model(x)
        return F.cross_entropy(out, y)

    # Hutchinson trace
    traces = []
    for _ in range(m_hutch):
        v = [torch.randint(0, 2, p.shape, dtype=torch.float32) * 2 - 1 for p in params]
        loss = get_loss()
        hv = hvp(loss, params, v)
        t = sum((vi * hi).sum().item() for vi, hi in zip(v, hv))
        traces.append(t)
    hess_trace = float(np.mean(traces))

    # power iteration for top eigenvalue
    v = [torch.randn_like(p) for p in params]
    norm = math.sqrt(sum((vi ** 2).sum().item() for vi in v))
    v = [vi / norm for vi in v]
    lam_prev = 0.0
    lam_top = 0.0
    for it in range(top_iters):
        loss = get_loss()
        hv = hvp(loss, params, v)
        norm = math.sqrt(sum((hi ** 2).sum().item() for hi in hv))
        if norm < 1e-12:
            break
        v = [hi / norm for hi in hv]
        loss = get_loss()
        hv2 = hvp(loss, params, v)
        lam_top = sum((vi * hi).sum().item() for vi, hi in zip(v, hv2))
        if abs(lam_top - lam_prev) < tol:
            lam_prev = lam_top
            break
        lam_prev = lam_top
    return hess_trace, float(lam_top)


# ------------------------------------------------------------------------- checkpointed units
def ckpt_path(prefix, name):
    return os.path.join(WORK_DIR, f"{prefix}_{name}.json")


def load_ckpt(path):
    with open(path) as f:
        return json.load(f)


def save_ckpt(path, obj):
    tmp = path + ".tmp"
    with open(tmp, "w") as f:
        json.dump(obj, f)
    os.replace(tmp, path)


def scratch_unit(prefix, optimizer_name, seed, train_x, train_y, test_x, test_y, epochs, milestones,
                  warmup_steps=10, timing_steps=50):
    path = ckpt_path(prefix, f"scratch_{optimizer_name}_{seed}")
    if os.path.exists(path):
        log(f"[scratch] skip existing {optimizer_name} seed={seed}")
        return load_ckpt(path)
    torch.set_num_threads(1)
    torch.manual_seed(seed)
    np.random.seed(seed)
    t0 = time.time()
    model = SmallCNN()
    last_loss, s_per_iter = run_epochs(model, optimizer_name, train_x, train_y, epochs, milestones,
                                        BASE_LR, BATCH, measure_timing=True,
                                        warmup_steps=warmup_steps, timing_steps=timing_steps)
    test_acc = evaluate(model, test_x, test_y)
    model_path = os.path.join(WORK_DIR, f"{prefix}_scratchmodel_{optimizer_name}_{seed}.pt")
    torch.save(model.state_dict(), model_path)
    row = {"optimizer": optimizer_name, "seed": seed, "test_acc": test_acc,
           "train_loss": last_loss, "s_per_iter": s_per_iter}
    save_ckpt(path, row)
    log(f"[scratch] {optimizer_name} seed={seed} acc={test_acc:.4f} s_per_iter={s_per_iter:.4f} wall={time.time()-t0:.1f}s")
    return row


def ablation_unit(prefix, eta, seed, train_x, train_y, test_x, test_y, epochs, milestones):
    tag = f"{eta:.3f}".replace("-", "m")
    path = ckpt_path(prefix, f"ablation_eta{tag}_{seed}")
    if os.path.exists(path):
        log(f"[ablation] skip existing eta={eta} seed={seed}")
        return load_ckpt(path)
    torch.set_num_threads(1)
    torch.manual_seed(seed)
    np.random.seed(seed)
    t0 = time.time()
    sigma = BETA ** (-(1 + eta) / 4.0)
    model = SmallCNN()
    params = [p for p in model.parameters()]

    n = train_x.shape[0]
    for epoch in range(epochs):
        lam = lr_at(epoch, BASE_LR, milestones)
        perm = np.random.permutation(n)
        model.train()
        for start in range(0, n, BATCH):
            idx = perm[start:start + BATCH]
            xb = torch.from_numpy(augment_batch(train_x[idx]))
            yb = torch.from_numpy(train_y[idx])
            fsgld_step(model, params, lam, sigma, BETA, WD, xb, yb)
    test_acc = evaluate(model, test_x, test_y)
    row = {"eta": eta, "seed": seed, "test_acc": test_acc}
    save_ckpt(path, row)
    log(f"[ablation] eta={eta} seed={seed} acc={test_acc:.4f} wall={time.time()-t0:.1f}s")
    return row


def pretrain_unit(prefix, seed, train_x, clean_y, epochs, milestones):
    path = os.path.join(WORK_DIR, f"{prefix}_pretrain_seed{seed}.pt")
    if os.path.exists(path):
        log(f"[pretrain] skip existing seed={seed}")
        return path
    torch.set_num_threads(1)
    torch.manual_seed(seed)
    np.random.seed(seed)
    t0 = time.time()
    model = SmallCNN()
    run_epochs(model, "SGD", train_x, clean_y, epochs, milestones, BASE_LR, BATCH)
    torch.save(model.state_dict(), path)
    log(f"[pretrain] seed={seed} wall={time.time()-t0:.1f}s")
    return path


def finetune_unit(prefix, optimizer_name, seed, pretrain_path, train_x, noisy_y, test_x, test_y,
                   epochs, milestones):
    path = ckpt_path(prefix, f"finetune_{optimizer_name}_{seed}")
    if os.path.exists(path):
        log(f"[finetune] skip existing {optimizer_name} seed={seed}")
        return load_ckpt(path)
    torch.set_num_threads(1)
    torch.manual_seed(seed + 1000)
    np.random.seed(seed + 1000)
    t0 = time.time()
    model = SmallCNN()
    model.load_state_dict(torch.load(pretrain_path))
    run_epochs(model, optimizer_name, train_x, noisy_y, epochs, milestones, FT_LR, BATCH)
    test_acc = evaluate(model, test_x, test_y)
    row = {"optimizer": optimizer_name, "seed": seed, "test_acc": test_acc}
    save_ckpt(path, row)
    log(f"[finetune] {optimizer_name} seed={seed} acc={test_acc:.4f} wall={time.time()-t0:.1f}s")
    return row


def flatness_unit(prefix, optimizer_name, model_path, x_batch, y_batch, m_hutch, top_iters):
    path = ckpt_path(prefix, f"flatness_{optimizer_name}")
    if os.path.exists(path):
        log(f"[flatness] skip existing {optimizer_name}")
        return load_ckpt(path)
    torch.set_num_threads(1)
    t0 = time.time()
    model = SmallCNN()
    model.load_state_dict(torch.load(model_path))
    hess_trace, lam_top = compute_flatness(model, x_batch, y_batch, m_hutch, top_iters)
    row = {"optimizer": optimizer_name, "hess_trace": hess_trace, "lambda_top": lam_top}
    save_ckpt(path, row)
    log(f"[flatness] {optimizer_name} trace={hess_trace:.4f} lam_top={lam_top:.4f} wall={time.time()-t0:.1f}s")
    return row


# ------------------------------------------------------------------------- main
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--toy", action="store_true")
    args = parser.parse_args()
    toy = args.toy

    os.makedirs(WORK_DIR, exist_ok=True)
    os.makedirs(RESULTS_DIR, exist_ok=True)
    job_cores = int(os.environ.get("JOB_CORES", 4))
    prefix = "exp02_toy" if toy else "exp02"

    t_start = time.time()

    provenance = {}
    train_u8, train_fine, test_u8, test_fine = load_cifar100(provenance)
    noisy_label, clean_label = load_cifar100n(provenance)

    seeds = [0, 1] if toy else [0, 1, 2]
    n_subset = 400 if toy else 15000
    epochs_scratch = 2 if toy else 30
    epochs_ft = 2 if toy else 15
    epochs_pretrain = 2 if toy else 15
    milestones_scratch = [1] if toy else [15, 25]
    milestones_ft = [1] if toy else [10]
    m_hutch = 4 if toy else 100
    top_iters = 5 if toy else 100
    flat_batch = 100 if toy else 2000
    warmup_steps = 1 if toy else 10
    timing_steps = 3 if toy else 50
    etas = [-0.5, 0.1, 0.5, 0.9, 1.5]

    subset_tag = "toy" if toy else "full"
    sub_idx = get_subset_indices(n_subset, subset_tag)
    train_x_all = preprocess(train_u8)
    test_x_all = preprocess(test_u8)
    train_x = train_x_all[sub_idx]
    train_noisy_y = noisy_label[sub_idx].astype(np.int64)
    train_clean_y = clean_label[sub_idx].astype(np.int64)
    test_x = test_x_all
    test_y = test_fine.astype(np.int64)

    # ---- scratch (Claims 4, 6b) ----
    scratch_jobs = [(opt, s) for opt in ("SGD", "SAM", "fSGLD") for s in seeds]
    scratch_rows = Parallel(n_jobs=job_cores)(
        delayed(scratch_unit)(prefix, opt, s, train_x, train_noisy_y, test_x, test_y,
                               epochs_scratch, milestones_scratch,
                               warmup_steps=warmup_steps, timing_steps=timing_steps)
        for opt, s in scratch_jobs
    )

    def summarize(rows, key="test_acc"):
        accs = [r[key] for r in rows]
        return {"acc_mean": float(np.mean(accs)), "acc_std": float(np.std(accs))}

    scratch_summary = {}
    for opt in ("SGD", "SAM", "fSGLD"):
        rows = [r for r in scratch_rows if r["optimizer"] == opt]
        s = summarize(rows)
        s["s_per_iter"] = float(np.mean([r["s_per_iter"] for r in rows]))
        scratch_summary[opt] = s

    efficiency = {
        "sam_over_fsgld_s_per_iter": scratch_summary["SAM"]["s_per_iter"] / scratch_summary["fSGLD"]["s_per_iter"],
        "sam_over_sgd": scratch_summary["SAM"]["s_per_iter"] / scratch_summary["SGD"]["s_per_iter"],
        "fsgld_over_sgd": scratch_summary["fSGLD"]["s_per_iter"] / scratch_summary["SGD"]["s_per_iter"],
    }

    # ---- ablation (Claim 6a) ----
    ablation_jobs = [(eta, s) for eta in etas for s in seeds]
    ablation_rows = Parallel(n_jobs=job_cores)(
        delayed(ablation_unit)(prefix, eta, s, train_x, train_noisy_y, test_x, test_y,
                                epochs_scratch, milestones_scratch)
        for eta, s in ablation_jobs
    )
    ablation_summary = []
    for eta in etas:
        rows = [r for r in ablation_rows if abs(r["eta"] - eta) < 1e-9]
        s = summarize(rows)
        s["eta"] = eta
        ablation_summary.append(s)

    # ---- fine-tuning (Claim 5) ----
    Parallel(n_jobs=job_cores)(
        delayed(pretrain_unit)(prefix, s, train_x, train_clean_y, epochs_pretrain, milestones_scratch)
        for s in seeds
    )

    ft_jobs = [(opt, s) for opt in ("SGD", "SAM", "fSGLD") for s in seeds]
    finetune_rows = Parallel(n_jobs=job_cores)(
        delayed(finetune_unit)(prefix, opt, s,
                                os.path.join(WORK_DIR, f"{prefix}_pretrain_seed{s}.pt"),
                                train_x, train_noisy_y, test_x, test_y, epochs_ft, milestones_ft)
        for opt, s in ft_jobs
    )
    finetune_summary = {}
    for opt in ("SGD", "SAM", "fSGLD"):
        rows = [r for r in finetune_rows if r["optimizer"] == opt]
        finetune_summary[opt] = summarize(rows)

    # ---- flatness (Claim 6b), seed-0 scratch models, fixed clean batch ----
    flat_idx = np.random.default_rng(0).choice(train_x.shape[0], min(flat_batch, train_x.shape[0]), replace=False)
    flat_x = train_x[flat_idx]
    flat_y = train_clean_y[flat_idx]
    flatness_rows = Parallel(n_jobs=job_cores)(
        delayed(flatness_unit)(prefix, opt,
                                os.path.join(WORK_DIR, f"{prefix}_scratchmodel_{opt}_0.pt"),
                                flat_x, flat_y, m_hutch, top_iters)
        for opt in ("SGD", "SAM", "fSGLD")
    )

    results = {
        "scratch": scratch_rows,
        "scratch_summary": scratch_summary,
        "efficiency": efficiency,
        "ablation": ablation_rows,
        "ablation_summary": ablation_summary,
        "finetune": finetune_rows,
        "finetune_summary": finetune_summary,
        "flatness": flatness_rows,
        "provenance": provenance,
        "meta": {
            "scale": ("REDUCED/toy: SmallCNN 0.5M params, tiny subset, few epochs, CPU; see BLOCKERS.md"
                      if toy else
                      "REDUCED: SmallCNN 0.5M params, 15k subset, 30 epochs, CPU; see BLOCKERS.md"),
            "beta": BETA, "eta": ETA_FSGLD, "sigma": SIGMA_FSGLD,
            "n_seeds": len(seeds), "epochs_scratch": epochs_scratch,
        },
    }

    out_path = os.path.join(RESULTS_DIR, "exp02.json")
    with open(out_path, "w") as f:
        json.dump(results, f, indent=2)

    print(f"exp02_neural: {'TOY' if toy else 'FULL'} run complete in {time.time()-t_start:.2f}s")
    print(f"  scratch: SGD={scratch_summary['SGD']['acc_mean']:.4f} "
          f"SAM={scratch_summary['SAM']['acc_mean']:.4f} fSGLD={scratch_summary['fSGLD']['acc_mean']:.4f}")
    print(f"  s_per_iter: SGD={scratch_summary['SGD']['s_per_iter']:.4f} "
          f"SAM={scratch_summary['SAM']['s_per_iter']:.4f} fSGLD={scratch_summary['fSGLD']['s_per_iter']:.4f}")
    print(f"  efficiency: {efficiency}")
    print(f"  finetune: SGD={finetune_summary['SGD']['acc_mean']:.4f} "
          f"SAM={finetune_summary['SAM']['acc_mean']:.4f} fSGLD={finetune_summary['fSGLD']['acc_mean']:.4f}")
    print(f"  provenance: {provenance}")
    print(f"  results -> {out_path}")


if __name__ == "__main__":
    main()