#!/usr/bin/env python3 """ Part 2 -- Small deep-learning analogue on CIFAR-10 (configurable architecture). Self-distillation protocol (paper Appendix A / Fig 6a): t=0 : teacher on size-n subset, fraction eta of labels corrupted (symmetric noise). t>=1: fresh student trained FROM SCRATCH on a DISJOINT subset with HARD pseudo-labels from the previous iterate. K iterations; test acc/error/agreement/confidence measured each round. Architectures (all small vs ResNet-50's ~25M params): small : 3 conv blocks (32,64,128) + GAP ~0.1M params (too weak: below denoising threshold) medium : 4 conv blocks (64,128,256,512)+GAP ~2.5M params (crosses the denoising threshold) """ import os, json, time os.environ.setdefault("OPENBLAS_NUM_THREADS", "1") import numpy as np import torch import torch.nn as nn import torch.nn.functional as F BASE = "/workspace/scratch/research" MDL = f"{BASE}/models" TRAJ = f"{BASE}/trajectories" FIG = f"{BASE}/figures" ASSETS = "/workspace/output/assets" for d in (MDL, TRAJ, FIG, ASSETS): os.makedirs(d, exist_ok=True) DEVICE = "cuda" if torch.cuda.is_available() else "cpu" MEAN = torch.tensor((0.4914, 0.4822, 0.4465), device=DEVICE).view(1, 3, 1, 1) STD = torch.tensor((0.2470, 0.2435, 0.2616), device=DEVICE).view(1, 3, 1, 1) def conv_block(ci, co): return nn.Sequential(nn.Conv2d(ci, co, 3, padding=1), nn.BatchNorm2d(co), nn.ReLU(inplace=True)) class SmallCNN(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( conv_block(3, 32), nn.MaxPool2d(2), conv_block(32, 64), nn.MaxPool2d(2), conv_block(64, 128), nn.MaxPool2d(2), nn.AdaptiveAvgPool2d(1)) self.classifier = nn.Linear(128, num_classes) def forward(self, x): return self.classifier(self.features(x).flatten(1)) class MediumCNN(nn.Module): """4 conv blocks (64,128,256,512) + GAP + linear. ~2.5M params.""" def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( conv_block(3, 64), nn.MaxPool2d(2), # 16x16 conv_block(64, 128), nn.MaxPool2d(2), # 8x8 conv_block(128, 256), nn.MaxPool2d(2), # 4x4 conv_block(256, 512), nn.AdaptiveAvgPool2d(1)) self.classifier = nn.Linear(512, num_classes) def forward(self, x): return self.classifier(self.features(x).flatten(1)) def build_model(arch): return SmallCNN() if arch == "small" else MediumCNN() def normalize(x): return (x - MEAN) / STD def augment(x, gen): B, dev = x.shape[0], x.device x = F.pad(x, (4, 4, 4, 4), mode="reflect").permute(0, 2, 3, 1) ij = torch.randint(0, 9, (B, 2), generator=gen).to(dev) ar = torch.arange(32, device=dev) b = torch.arange(B, device=dev)[:, None, None] rows = (ij[:, 0:1] + ar)[:, :, None] cols = (ij[:, 1:2] + ar)[:, None, :] out = x[b, rows, cols].permute(0, 3, 1, 2) flip = torch.rand(B, generator=gen).to(dev) < 0.5 out[flip] = torch.flip(out[flip], dims=[3]) return out def train_model(arch, images, labels, epochs, seed, batch=256, lr=0.1): torch.manual_seed(seed) gen = torch.Generator().manual_seed(seed) model = build_model(arch).to(DEVICE) opt = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4, nesterov=True) sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs) N = images.shape[0] model.train() for ep in range(epochs): perm = torch.randperm(N, generator=gen) for s in range(0, N, batch): idx = perm[s:s + batch] xb = normalize(augment(images[idx].to(DEVICE), gen)) yb = labels[idx].to(DEVICE) opt.zero_grad() F.cross_entropy(model(xb), yb).backward() opt.step() sched.step() return model @torch.no_grad() def predict_logits(model, images, batch=1000): model.eval() outs = [] for s in range(0, images.shape[0], batch): outs.append(model(normalize(images[s:s + batch].to(DEVICE)))) return torch.cat(outs) @torch.no_grad() def evaluate(model, test_x, test_y, prev_pred=None): logits = predict_logits(model, test_x) pred = logits.argmax(1).cpu() acc = 100.0 * (pred == test_y).float().mean().item() conf = float(logits.softmax(1).max(1).values.mean().item()) agree = None if prev_pred is not None: agree = 100.0 * (pred == prev_pred).float().mean().item() return dict(test_acc=acc, test_error=100.0 - acc, mean_conf=conf, agreement_with_prev=agree, pred=pred) def load_cifar(): from datasets import load_dataset ds = load_dataset("uoft-cs/cifar10") def to_tensors(split): imgs = ds[split]["img"] arr = np.stack([np.asarray(im, dtype=np.float32) for im in imgs]) / 255.0 arr = np.transpose(arr, (0, 3, 1, 2)) return torch.from_numpy(arr), torch.tensor(ds[split]["label"], dtype=torch.long) return to_tensors("train"), to_tensors("test") def run_eta(eta, n, K, epochs, arch, train_x, train_y, test_x, test_y, seed=0, save_models=False, tag=""): rng = np.random.default_rng(seed) Ntr = train_x.shape[0] perm = rng.permutation(Ntr) subsets = [perm[t * n:(t + 1) * n] for t in range(K + 1)] records = [] prev_pred = None for t in range(K + 1): idx = subsets[t] xt = train_x[idx].clone() if t == 0: yt = train_y[idx].clone() ncorrupt = int(round(eta * len(yt))) ci = rng.choice(len(yt), size=ncorrupt, replace=False) yt[ci] = torch.tensor(rng.integers(0, 10, size=ncorrupt), dtype=torch.long) label_src = f"true+{eta:.2f} symmetric noise" else: yt = predict_logits(model, xt).argmax(1).cpu() label_src = f"hard pseudo-labels from iterate {t-1}" t0 = time.time() model = train_model(arch, xt, yt, epochs, seed=seed * 100 + t) res = evaluate(model, test_x, test_y, prev_pred) res.update(dict(t=t, eta=eta, n=n, K=K, epochs=epochs, arch=arch, seed=seed, label_source=label_src, subset=t, time_s=round(time.time() - t0, 1))) if save_models: path = f"{MDL}/iter_{tag}_t{t}.pth" torch.save({"state_dict": model.state_dict(), "config": {"t": t, "eta": eta, "n": n, "epochs": epochs, "arch": arch, "seed": seed, "label_source": label_src}}, path) prev_pred = res.pop("pred") records.append(res) print(f" [{tag} eta={eta} {arch}] t={t}: acc={res['test_acc']:.2f}% " f"err={res['test_error']:.2f}% conf={res['mean_conf']:.3f} " f"agree={res['agreement_with_prev']} ({res['time_s']}s)", flush=True) with open(f"{TRAJ}/cifar_trajectory.json", "w") as f: json.dump({"config": {"etas_seen": [r['eta'] for r in records], "n": n, "K": K, "epochs": epochs, "arch": arch}, "records": records}, f, indent=2) return records def main(): import argparse ap = argparse.ArgumentParser() ap.add_argument("--n", type=int, default=5000) ap.add_argument("--K", type=int, default=8) ap.add_argument("--epochs", type=int, default=50) ap.add_argument("--etas", type=str, default="0.4") ap.add_argument("--arch", type=str, default="medium") ap.add_argument("--seed", type=int, default=0) args = ap.parse_args() print(f"device={DEVICE} torch={torch.__version__} args={vars(args)}", flush=True) nparam = sum(p.numel() for p in build_model(args.arch).parameters()) print(f"arch={args.arch} params={nparam/1e6:.2f}M", flush=True) (train_x, train_y), (test_x, test_y) = load_cifar() print(f"train {tuple(train_x.shape)} test {tuple(test_x.shape)}", flush=True) etas = [float(e) for e in args.etas.split(",")] all_records = [] for ei, eta in enumerate(etas): tag = f"{args.arch}_eta{eta}".replace(".", "p") recs = run_eta(eta, args.n, args.K, args.epochs, args.arch, train_x, train_y, test_x, test_y, seed=args.seed, save_models=True, tag=tag) all_records.extend(recs) import pandas as pd df = pd.DataFrame(all_records) df.to_csv(f"{TRAJ}/cifar_trajectory.csv", index=False) with open(f"{TRAJ}/cifar_trajectory.json", "w") as f: json.dump({"config": vars(args), "device": DEVICE, "torch_version": torch.__version__, "records": all_records}, f, indent=2) import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt plt.rcParams.update({"font.size": 12, "axes.linewidth": 1.3, "axes.spines.top": False, "axes.spines.right": False}) palette = {0.5: "#B279A2", 0.4: "#E45756", 0.3: "#F58518", 0.2: "#4C78A8"} fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4.4)) for eta in etas: sub = df[df.eta == eta].sort_values("t") c = palette.get(eta, "#54A24B") ax1.plot(sub.t, sub.test_error, "-o", color=c, lw=2.2, ms=6, mfc="white", mew=1.2, label=f"\u03b7={eta}") ax2.plot(sub.t, sub.mean_conf, "-o", color=c, lw=2.2, ms=6, mfc="white", mew=1.2, label=f"\u03b7={eta}") tstar = int(sub.test_error.values.argmin()) ax1.scatter([sub.t.values[tstar]], [sub.test_error.values[tstar]], marker="*", s=260, color=c, edgecolor="k", zorder=6) ax1.set_xlabel("self-training generation t"); ax1.set_ylabel("test error (%)") ax1.set_title(f"CIFAR-10 test error ({args.arch}, {nparam/1e6:.1f}M)"); ax1.legend(frameon=False); ax1.grid(alpha=0.2) ax2.set_xlabel("self-training generation t"); ax2.set_ylabel("mean top-1 confidence") ax2.set_title("Calibration (confidence) drift"); ax2.legend(frameon=False); ax2.grid(alpha=0.2) fig.tight_layout() fig.savefig(f"{FIG}/cifar_trajectory.png", dpi=170, bbox_inches="tight") fig.savefig(f"{ASSETS}/cifar_trajectory.png", dpi=170, bbox_inches="tight") plt.close(fig) print("\n=== U-shape diagnostic ===", flush=True) for eta in etas: sub = df[df.eta == eta].sort_values("t") errs = sub.test_error.values tstar = int(errs.argmin()) shape = ("U-shaped" if 0 < tstar < args.K else ("monotone-decreasing" if tstar == args.K else "monotone-increasing")) depth = errs.max() - errs.min() print(f" eta={eta}: errs={[round(e,2) for e in errs]} t*={tstar} " f"depth={depth:.2f}% -> {shape}", flush=True) print("\nDONE", flush=True) if __name__ == "__main__": main()