Create experiment_4_multigenerational_autograd.py

experiment_2/experiment_4_multigenerational_autograd.py

@@ -0,0 +1,702 @@
+# ============================================================================
+# MULTI-GENERATIONAL GEOMETRIC EVOLUTION
+#
+# Generation 0: 2 founders (Raw Adam + Geometric)
+#   → GPA consensus → 3 offspring
+#
+# Generation 1: 3 offspring + 1 new founder = 4 ancestors
+#   → GPA consensus → 4 offspring
+#
+# Generation 2: 4 offspring + 1 new founder = 5 ancestors
+#   → GPA consensus → final descendant
+#
+# Each generation inherits consensus geometry from all ancestors.
+# Procrustes alignment finds the shared geometric center across
+# increasingly diverse lineages. The final descendant carries
+# the distilled agreement of all 5 independent training runs.
+# ============================================================================
+
+import math
+import gc
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+print("=" * 65)
+print("MULTI-GENERATIONAL GEOMETRIC EVOLUTION")
+print("=" * 65)
+print(f"  Device: {DEVICE}")
+
+
+# ══════════════════════════════════════════════════════════════════
+# GEOMETRIC PRIMITIVES
+# ══════════════════════════════════════════════════════════════════
+
+def tangential_projection(grad, embedding):
+    emb_n = F.normalize(embedding.detach().float(), dim=-1)
+    grad_f = grad.float()
+    radial = (grad_f * emb_n).sum(dim=-1, keepdim=True) * emb_n
+    return (grad_f - radial).to(grad.dtype), radial.to(grad.dtype)
+
+def cayley_menger_vol2(pts):
+    pts = pts.float()
+    diff = pts.unsqueeze(-2) - pts.unsqueeze(-3)
+    d2 = (diff * diff).sum(-1)
+    B, V, _ = d2.shape
+    cm = torch.zeros(B, V+1, V+1, device=d2.device, dtype=torch.float32)
+    cm[:, 0, 1:] = 1; cm[:, 1:, 0] = 1; cm[:, 1:, 1:] = d2
+    s = (-1.0)**V; f = math.factorial(V-1)
+    return s / ((2.0**(V-1)) * f*f) * torch.linalg.det(cm)
+
+def cv_loss(emb, target=0.2, n_samples=16):
+    B = emb.shape[0]
+    if B < 5: return torch.tensor(0.0, device=emb.device)
+    vols = []
+    for _ in range(n_samples):
+        idx = torch.randperm(B, device=emb.device)[:5]
+        v2 = cayley_menger_vol2(emb[idx].unsqueeze(0))
+        vols.append(torch.sqrt(F.relu(v2[0]) + 1e-12))
+    stacked = torch.stack(vols)
+    cv = stacked.std() / (stacked.mean() + 1e-8)
+    return (cv - target).abs()
+
+@torch.no_grad()
+def cv_metric(emb, n_samples=200):
+    B = emb.shape[0]
+    if B < 5: return 0.0
+    emb_f = emb.detach().float()
+    vols = []
+    for _ in range(n_samples):
+        idx = torch.randperm(B, device=emb.device)[:5]
+        v2 = cayley_menger_vol2(emb_f[idx].unsqueeze(0))
+        v = torch.sqrt(F.relu(v2[0]) + 1e-12).item()
+        if v > 0: vols.append(v)
+    if len(vols) < 10: return 0.0
+    a = torch.tensor(vols)
+    return float(a.std() / (a.mean() + 1e-8))
+
+def anchor_spread_loss(anchors):
+    a_n = F.normalize(anchors, dim=-1)
+    sim = a_n @ a_n.T - torch.diag(torch.ones(anchors.shape[0], device=anchors.device))
+    return sim.pow(2).mean()
+
+def anchor_entropy_loss(emb, anchors, sharpness=10.0):
+    a_n = F.normalize(anchors, dim=-1)
+    probs = F.softmax(emb @ a_n.T * sharpness, dim=-1)
+    return -(probs * (probs + 1e-12).log()).sum(-1).mean()
+
+def anchor_ortho_loss(anchors):
+    a_n = F.normalize(anchors, dim=-1)
+    gram = a_n @ a_n.T
+    N = anchors.shape[0]
+    mask = ~torch.eye(N, dtype=bool, device=anchors.device)
+    return gram[mask].pow(2).mean()
+
+def infonce(a, b, temperature=0.07):
+    a = F.normalize(a, dim=-1); b = F.normalize(b, dim=-1)
+    logits = (a @ b.T) / temperature
+    labels = torch.arange(logits.shape[0], device=logits.device)
+    loss = (F.cross_entropy(logits, labels) + F.cross_entropy(logits.T, labels)) / 2
+    with torch.no_grad():
+        acc = (logits.argmax(-1) == labels).float().mean().item()
+    return loss, acc
+
+class EmbeddingAutograd(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, embedding, anchors, tang, sep):
+        ctx.save_for_backward(embedding, anchors)
+        ctx.tang = tang; ctx.sep = sep
+        return x
+    @staticmethod
+    def backward(ctx, grad_output):
+        embedding, anchors = ctx.saved_tensors
+        emb_n = F.normalize(embedding.detach().float(), dim=-1)
+        anchors_n = F.normalize(anchors.detach().float(), dim=-1)
+        grad_f = grad_output.float()
+        tang_grad, norm_grad = tangential_projection(grad_f, emb_n)
+        corrected = tang_grad + (1.0 - ctx.tang) * norm_grad
+        if ctx.sep > 0:
+            cos_to = emb_n @ anchors_n.T
+            nearest = anchors_n[cos_to.argmax(dim=-1)]
+            toward = (corrected * nearest).sum(dim=-1, keepdim=True)
+            collapse = toward * nearest
+            corrected = corrected - ctx.sep * (toward > 0).float() * collapse
+        return corrected.to(grad_output.dtype), None, None, None, None
+
+
+# ══════════════════════════════════════════════════════════════════
+# PROCRUSTES (GPA for N models)
+# ══════════════════════════════════════════════════════════════════
+
+def symmetric_inv_sqrt(cov, eps=1e-6):
+    evals, evecs = torch.linalg.eigh(cov)
+    evals = torch.clamp(evals, min=eps)
+    return evecs @ torch.diag(evals.rsqrt()) @ evecs.T
+
+def procrustes_align(source, target, n_align=10000):
+    N = min(n_align, source.shape[0], target.shape[0])
+    S = source[:N].float(); T = target[:N].float()
+    s_mean = S.mean(0, keepdim=True); t_mean = T.mean(0, keepdim=True)
+    Sc = S - s_mean; Tc = T - t_mean; Ns = Sc.shape[0]
+    s_cov = (Sc.T @ Sc) / max(Ns - 1, 1)
+    t_cov = (Tc.T @ Tc) / max(Ns - 1, 1)
+    s_whiten = symmetric_inv_sqrt(s_cov)
+    t_whiten = symmetric_inv_sqrt(t_cov)
+    Sc_w = F.normalize(Sc @ s_whiten, dim=-1)
+    Tc_w = F.normalize(Tc @ t_whiten, dim=-1)
+    U, _, Vt = torch.linalg.svd(Tc_w.T @ Sc_w, full_matrices=False)
+    R = U @ Vt
+    return {"rotation": R, "source_mean": s_mean.squeeze(0), "source_whitener": s_whiten}
+
+def apply_align(emb, info):
+    x = emb.float() - info["source_mean"]
+    return x @ info["source_whitener"] @ info["rotation"].T
+
+def gpa_consensus(embeddings_list, n_iters=15):
+    """Generalized Procrustes Analysis for N embedding sets."""
+    N_models = len(embeddings_list)
+    current = {i: e.float() for i, e in enumerate(embeddings_list)}
+
+    for gpa_iter in range(n_iters):
+        mean_shape = sum(current[i] for i in range(N_models)) / N_models
+        total_delta = 0.0
+        new_current = {}
+        for i in range(N_models):
+            info = procrustes_align(current[i], mean_shape)
+            new_current[i] = apply_align(current[i], info)
+            total_delta += (new_current[i] - current[i]).pow(2).mean().item()
+        current = new_current
+        if total_delta < 1e-8:
+            break
+
+    mean_shape = sum(current[i] for i in range(N_models)) / N_models
+    consensus = F.normalize(mean_shape, dim=-1)
+
+    # Per-model alignment quality
+    cos_scores = []
+    for i in range(N_models):
+        c = F.cosine_similarity(consensus[:2000],
+            F.normalize(current[i][:2000], dim=-1), dim=-1).mean().item()
+        cos_scores.append(c)
+
+    return consensus, cos_scores
+
+
+# ══════════════════════════════════════════════════════════════════
+# MODEL
+# ══════════════════════════════════════════════════════════════════
+
+class Constellation(nn.Module):
+    def __init__(self, n_anchors=30, d_embed=768, init_anchors=None):
+        super().__init__()
+        self.n_anchors = n_anchors
+        if init_anchors is not None:
+            self.anchors = nn.Parameter(init_anchors.clone())
+        else:
+            self.anchors = nn.Parameter(F.normalize(torch.randn(n_anchors, d_embed), dim=-1))
+        self.register_buffer("rigidity", torch.zeros(n_anchors))
+        self.register_buffer("visit_count", torch.zeros(n_anchors))
+
+    def triangulate(self, emb):
+        a_n = F.normalize(self.anchors, dim=-1)
+        cos = emb @ a_n.T
+        return 1.0 - cos, cos.argmax(dim=-1)
+
+    @torch.no_grad()
+    def update_rigidity(self, tri_dist):
+        nearest = tri_dist.argmin(dim=-1)
+        for i in range(self.n_anchors):
+            mask = nearest == i
+            if mask.sum() < 5: continue
+            self.visit_count[i] += mask.sum().float()
+            spread = tri_dist[mask].std(dim=0).mean()
+            alpha = min(0.1, 10.0 / (self.visit_count[i] + 1))
+            self.rigidity[i] = (1-alpha)*self.rigidity[i] + alpha/(spread+0.01)
+
+class Patchwork(nn.Module):
+    def __init__(self, n_anchors=30, n_compartments=6, d_comp=64):
+        super().__init__()
+        self.n_compartments = n_compartments
+        assignments = torch.arange(n_anchors) % n_compartments
+        self.register_buffer("assignments", assignments)
+        self.compartments = nn.ModuleList()
+        for k in range(n_compartments):
+            n_k = (assignments == k).sum().item()
+            self.compartments.append(nn.Sequential(
+                nn.Linear(n_k, d_comp*2), nn.GELU(),
+                nn.Linear(d_comp*2, d_comp), nn.LayerNorm(d_comp)))
+    def forward(self, tri):
+        return torch.cat([self.compartments[k](tri[:, self.assignments==k])
+                         for k in range(self.n_compartments)], dim=-1)
+
+class PatchworkClassifier(nn.Module):
+    def __init__(self, n_classes=30, n_anchors=30, d_embed=768,
+                 n_comp=6, d_comp=64, d_hid=256, init_anchors=None):
+        super().__init__()
+        self.backbone = nn.Sequential(
+            nn.Conv2d(1,32,3,padding=1), nn.GELU(), nn.MaxPool2d(2),
+            nn.Conv2d(32,64,3,padding=1), nn.GELU(), nn.MaxPool2d(2),
+            nn.Conv2d(64,128,3,padding=1), nn.GELU(), nn.AdaptiveAvgPool2d(1))
+        self.embed_proj = nn.Sequential(nn.Linear(128, d_embed), nn.LayerNorm(d_embed))
+        self.constellation = Constellation(n_anchors, d_embed, init_anchors)
+        self.patchwork = Patchwork(n_anchors, n_comp, d_comp)
+        self.mlp = nn.Sequential(
+            nn.Linear(n_comp*d_comp, d_hid), nn.GELU(), nn.LayerNorm(d_hid),
+            nn.Linear(d_hid, d_hid), nn.GELU(), nn.LayerNorm(d_hid),
+            nn.Linear(d_hid, n_classes))
+
+    def forward(self, x):
+        feat = self.backbone(x).flatten(1)
+        emb = F.normalize(self.embed_proj(feat), dim=-1)
+        tri, nearest = self.constellation.triangulate(emb)
+        return self.mlp(self.patchwork(tri)), emb, tri, nearest
+
+    def encode(self, x):
+        return F.normalize(self.embed_proj(self.backbone(x).flatten(1)), dim=-1)
+
+
+# ══════════════════════════════════════════════════════════════════
+# SHAPE RENDERERS (compact)
+# ══════════════════════════════════════════════════════════════════
+
+def _d(img,x0,y0,x1,y1,t=1):
+    n=max(int(max(abs(x1-x0),abs(y1-y0))*2),1);sz=img.shape[0]
+    for s in np.linspace(0,1,n):
+        px,py=int(x0+s*(x1-x0)),int(y0+s*(y1-y0))
+        for dx in range(-t,t+1):
+            for dy in range(-t,t+1):
+                nx,ny=px+dx,py+dy
+                if 0<=nx<sz and 0<=ny<sz: img[ny,nx]=1.0
+
+def rpoly(nv,sz=32,p=0.15):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy,r=sz/2,sz/2,sz*0.35
+    a=np.linspace(0,2*np.pi,nv,endpoint=False)+np.random.uniform(0,2*np.pi)
+    ri=r*(1+np.random.normal(0,p,nv))
+    pts=[(cx+ri[i]*np.cos(a[i]),cy+ri[i]*np.sin(a[i])) for i in range(nv)]
+    for i in range(nv): _d(img,*pts[i],*pts[(i+1)%nv])
+    return img
+
+def rstar(np_,sz=32,p=0.12):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2;ro,ri_=sz*0.38,sz*0.15
+    a=np.linspace(0,2*np.pi,np_*2,endpoint=False)+np.random.uniform(0,2*np.pi)
+    pts=[(cx+(ro if i%2==0 else ri_)*(1+np.random.normal(0,p))*np.cos(a[i]),
+          cy+(ro if i%2==0 else ri_)*(1+np.random.normal(0,p))*np.sin(a[i])) for i in range(len(a))]
+    for i in range(len(pts)): _d(img,*pts[i],*pts[(i+1)%len(pts)])
+    return img
+
+def rcross(sz=32,p=0.15):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy,arm=sz/2,sz/2,sz*0.3
+    for ab in [0,np.pi/2,np.pi,3*np.pi/2]:
+        a=ab+np.random.normal(0,p*0.3);r=arm*(1+np.random.normal(0,p))
+        _d(img,cx,cy,cx+r*np.cos(a),cy+r*np.sin(a),2)
+    return img
+
+def rspiral(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2
+    for t in np.linspace(0,5*np.pi,200):
+        r=sz*0.015*t*(1+np.random.normal(0,p*0.3));x,y=int(cx+r*np.cos(t)),int(cy+r*np.sin(t))
+        if 0<=x<sz and 0<=y<sz: img[y,x]=1.0
+    return img
+
+def rwave(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);f=2+np.random.normal(0,0.3);amp=sz*0.15*(1+np.random.normal(0,p))
+    for x in range(sz):
+        y=int(sz/2+amp*np.sin(2*np.pi*f*x/sz))
+        if 0<=y<sz: img[y,x]=1.0
+    return img
+
+def rheart(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz*0.45;s=sz*0.017*(1+np.random.normal(0,p))
+    for t in np.linspace(0,2*np.pi,300):
+        x=16*np.sin(t)**3;y=-(13*np.cos(t)-5*np.cos(2*t)-2*np.cos(3*t)-np.cos(4*t))
+        ix,iy=int(cx+x*s),int(cy+y*s)
+        if 0<=ix<sz and 0<=iy<sz: img[iy,ix]=1.0
+    return img
+
+def rcrescent(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy,r=sz/2,sz/2,sz*0.35;r2=r*0.7;off=r*0.3
+    for a in np.linspace(0,2*np.pi,300):
+        x1,y1=cx+r*np.cos(a),cy+r*np.sin(a)
+        if math.sqrt((x1-cx-off)**2+(y1-cy)**2)>=r2*0.9:
+            if 0<=int(x1)<sz and 0<=int(y1)<sz: img[int(y1),int(x1)]=1.0
+    return img
+
+def rellipse(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2
+    a,b=sz*0.38*(1+np.random.normal(0,p)),sz*0.22*(1+np.random.normal(0,p));rot=np.random.uniform(0,np.pi)
+    for t in np.linspace(0,2*np.pi,200):
+        x,y=a*np.cos(t),b*np.sin(t);ix,iy=int(cx+x*np.cos(rot)-y*np.sin(rot)),int(cy+x*np.sin(rot)+y*np.cos(rot))
+        if 0<=ix<sz and 0<=iy<sz: img[iy,ix]=1.0
+    return img
+
+def rring(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2
+    r1,r2=sz*0.35*(1+np.random.normal(0,p)),sz*0.22*(1+np.random.normal(0,p))
+    for a in np.linspace(0,2*np.pi,300):
+        for r in [r1,r2]:
+            x,y=int(cx+r*np.cos(a)),int(cy+r*np.sin(a))
+            if 0<=x<sz and 0<=y<sz: img[y,x]=1.0
+    return img
+
+def rarrow(sz=32,p=0.12):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2
+    l=sz*0.35*(1+np.random.normal(0,p));h=l*0.35;a=np.random.uniform(0,2*np.pi)
+    x1,y1=cx-l*np.cos(a),cy-l*np.sin(a);x2,y2=cx+l*np.cos(a),cy+l*np.sin(a)
+    _d(img,x1,y1,x2,y2)
+    for da in [0.7,-0.7]: _d(img,x2,y2,x2-h*np.cos(a+da),y2-h*np.sin(a+da))
+    return img
+
+def rchevron(sz=32,p=0.12):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy=sz/2,sz/2
+    w,h=sz*0.3*(1+np.random.normal(0,p)),sz*0.25*(1+np.random.normal(0,p))
+    _d(img,cx-w,cy+h,cx,cy-h);_d(img,cx,cy-h,cx+w,cy+h)
+    return img
+
+def rsemicirc(sz=32,p=0.1):
+    img=np.zeros((sz,sz),dtype=np.float32);cx,cy,r=sz/2,sz*0.6,sz*0.35
+    for a in np.linspace(np.pi,2*np.pi,150):
+        x,y=int(cx+r*np.cos(a)),int(cy+r*np.sin(a))
+        if 0<=x<sz and 0<=y<sz: img[y,x]=1.0
+    _d(img,cx-r,cy,cx+r,cy)
+    return img
+
+def gen_one(c,sz=32):
+    R = [lambda: rpoly(3,sz,0.20), lambda: rpoly(4,sz,0.12), lambda: rpoly(5,sz,0.15),
+         lambda: rpoly(6,sz,0.10), lambda: rpoly(7,sz,0.10), lambda: rpoly(8,sz,0.08),
+         lambda: rpoly(9,sz,0.08), lambda: rpoly(10,sz,0.07), lambda: rpoly(12,sz,0.06),
+         lambda: rpoly(32,sz,0.03), lambda: rellipse(sz), lambda: rspiral(sz),
+         lambda: rwave(sz), lambda: rcrescent(sz), lambda: rstar(3,sz),
+         lambda: rstar(4,sz), lambda: rstar(5,sz), lambda: rstar(6,sz),
+         lambda: rstar(7,sz), lambda: rstar(8,sz), lambda: rcross(sz),
+         lambda: rpoly(4,sz,0.10), lambda: rarrow(sz), lambda: rheart(sz),
+         lambda: rring(sz), lambda: rsemicirc(sz), lambda: rpoly(4,sz,0.15),
+         lambda: rpoly(4,sz,0.18), lambda: rpoly(4,sz,0.10), lambda: rchevron(sz)]
+    return R[c]()
+
+def gen_data(n_per=500, sz=32):
+    imgs, labels = [], []
+    for _ in range(n_per):
+        for c in range(30):
+            imgs.append(gen_one(c, sz)); labels.append(c)
+    imgs = torch.tensor(np.array(imgs)).unsqueeze(1)
+    labels = torch.tensor(labels, dtype=torch.long)
+    perm = torch.randperm(len(labels))
+    return imgs[perm], labels[perm]
+
+TYPES = {"polygon": list(range(9)), "curve": list(range(9,14)),
+         "star": list(range(14,20)), "structure": list(range(20,30))}
+
+def eval_model(model, imgs, labels):
+    model.eval()
+    with torch.no_grad():
+        vl, ve, _, _ = model(imgs)
+        acc = (vl.argmax(-1) == labels).float().mean().item()
+        cv = cv_metric(ve)
+        ta = {}
+        for tname, tids in TYPES.items():
+            tmask = torch.zeros(len(labels), dtype=bool, device=imgs.device)
+            for tid in tids: tmask |= (labels == tid)
+            if tmask.sum() > 0:
+                ta[tname] = (vl.argmax(-1)[tmask] == labels[tmask]).float().mean().item()
+    return acc, cv, ta
+
+
+# ══════════════════════════════════════════════════════════════════
+# TRAINING CONFIGS (variation = different geometric losses)
+# ══════════════════════════════════════════════════════════════════
+
+CONFIGS = {
+    "raw":      {"use_ag": False, "tang": 0,    "sep": 0,   "cv_w": 0,     "spr": 0,    "ort": 0,    "ent": 0},
+    "geo_a":    {"use_ag": True,  "tang": 0.01, "sep": 1.0, "cv_w": 0.001, "spr": 1e-3, "ort": 1e-3, "ent": 0},
+    "geo_b":    {"use_ag": True,  "tang": 0.01, "sep": 1.0, "cv_w": 0.001, "spr": 0,    "ort": 0,    "ent": 1e-4},
+    "geo_c":    {"use_ag": True,  "tang": 0.01, "sep": 0.5, "cv_w": 0.001, "spr": 5e-4, "ort": 5e-4, "ent": 5e-5},
+    "new_raw":  {"use_ag": False, "tang": 0,    "sep": 0,   "cv_w": 0,     "spr": 0,    "ort": 0,    "ent": 0},
+    "new_geo":  {"use_ag": True,  "tang": 0.01, "sep": 0.8, "cv_w": 0.001, "spr": 1e-3, "ort": 0,    "ent": 1e-4},
+}
+
+
+def train_model(model, train_imgs, train_labels, cfg, epochs=30, tag=""):
+    """Train with specified config."""
+    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
+    BATCH = 256; n_train = len(train_labels)
+    for epoch in range(epochs):
+        model.train()
+        perm = torch.randperm(n_train, device=DEVICE)
+        tc, n = 0, 0
+        for i in range(0, n_train, BATCH):
+            idx = perm[i:i+BATCH]
+            if len(idx) < 4: continue
+            logits, emb, tri, nearest = model(train_imgs[idx])
+            labels = train_labels[idx]
+            anchors = model.constellation.anchors
+            if cfg["use_ag"] and (cfg["tang"] > 0 or cfg["sep"] > 0):
+                emb_g = EmbeddingAutograd.apply(emb, emb, anchors, cfg["tang"], cfg["sep"])
+                tri_g, _ = model.constellation.triangulate(emb_g)
+                logits = model.mlp(model.patchwork(tri_g))
+            l = F.cross_entropy(logits, labels)
+            lg = torch.tensor(0.0, device=DEVICE)
+            if cfg["cv_w"] > 0: lg = lg + cfg["cv_w"] * cv_loss(emb)
+            if cfg["spr"] > 0: lg = lg + cfg["spr"] * anchor_spread_loss(anchors)
+            if cfg["ort"] > 0: lg = lg + cfg["ort"] * anchor_ortho_loss(anchors)
+            if cfg["ent"] > 0: lg = lg + cfg["ent"] * anchor_entropy_loss(emb, anchors)
+            (l + lg).backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            opt.step(); opt.zero_grad(set_to_none=True)
+            model.constellation.update_rigidity(tri.detach())
+            tc += (logits.argmax(-1) == labels).sum().item(); n += 1
+        if (epoch+1) % 10 == 0 or epoch == 0:
+            acc, cv, ta = eval_model(model, val_imgs, val_labels)
+            ta_s = " ".join(f"{t}={a:.2f}" for t, a in ta.items())
+            print(f"  {tag}E{epoch+1:2d}: t={tc/n_train:.3f} v={acc:.3f} cv={cv:.4f} [{ta_s}]")
+
+
+def train_distilled(model, train_imgs, train_labels, consensus, cfg, epochs=30, tag=""):
+    """Train with consensus distillation + task loss."""
+    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
+    BATCH = 256; n_train = len(train_labels)
+    for epoch in range(epochs):
+        model.train()
+        perm = torch.randperm(n_train, device=DEVICE)
+        tc, n = 0, 0
+        for i in range(0, n_train, BATCH):
+            idx = perm[i:i+BATCH]
+            if len(idx) < 4: continue
+            logits, emb, tri, nearest = model(train_imgs[idx])
+            labels = train_labels[idx]; tgt = consensus[idx]
+            anchors = model.constellation.anchors
+            if cfg["use_ag"] and (cfg["tang"] > 0 or cfg["sep"] > 0):
+                emb_g = EmbeddingAutograd.apply(emb, emb, anchors, cfg["tang"], cfg["sep"])
+                tri_g, _ = model.constellation.triangulate(emb_g)
+                logits = model.mlp(model.patchwork(tri_g))
+            l_cls = F.cross_entropy(logits, labels)
+            l_nce, _ = infonce(emb, tgt)
+            l_mse = F.mse_loss(emb, tgt)
+            lg = torch.tensor(0.0, device=DEVICE)
+            if cfg["cv_w"] > 0: lg = lg + cfg["cv_w"] * cv_loss(emb)
+            if cfg["ent"] > 0: lg = lg + cfg["ent"] * anchor_entropy_loss(emb, anchors)
+            loss = l_cls + 0.5 * l_nce + 0.5 * l_mse + lg
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            opt.step(); opt.zero_grad(set_to_none=True)
+            model.constellation.update_rigidity(tri.detach())
+            tc += (logits.argmax(-1) == labels).sum().item(); n += 1
+        if (epoch+1) % 10 == 0 or epoch == 0:
+            acc, cv, ta = eval_model(model, val_imgs, val_labels)
+            cos = F.cosine_similarity(
+                model.encode(val_imgs[:1000]), consensus[:1000].to(DEVICE), dim=-1).mean().item()
+            ta_s = " ".join(f"{t}={a:.2f}" for t, a in ta.items())
+            print(f"  {tag}E{epoch+1:2d}: t={tc/n_train:.3f} v={acc:.3f} cos={cos:.3f} cv={cv:.4f} [{ta_s}]")
+
+
+# ══════════════════════════════════════════════════════════════════
+# GENERATE DATA
+# ══════════════════════════════════════════════════════════════════
+
+print(f"\n  Generating data...")
+torch.manual_seed(42); np.random.seed(42)
+train_imgs, train_labels = gen_data(n_per=500)
+val_imgs, val_labels = gen_data(n_per=100)
+train_imgs, train_labels = train_imgs.to(DEVICE), train_labels.to(DEVICE)
+val_imgs, val_labels = val_imgs.to(DEVICE), val_labels.to(DEVICE)
+n_train, n_val = len(train_labels), len(val_labels)
+print(f"  Train: {n_train:,}  Val: {n_val:,}")
+
+all_results = {}
+
+
+# ══════════════════════════════════════════════════════════════════
+# GENERATION 0: FOUNDERS
+# ══════════════════════════════════════════════════════════════════
+
+print(f"\n{'='*65}")
+print("GENERATION 0: FOUNDERS (2 independent models)")
+print(f"{'='*65}")
+
+founders = {}
+for name, cfg_key in [("F0_raw", "raw"), ("F0_geo", "geo_a")]:
+    print(f"\n  ── {name} ──")
+    torch.manual_seed(hash(name) % 2**32)
+    m = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768).to(DEVICE)
+    train_model(m, train_imgs, train_labels, CONFIGS[cfg_key], epochs=30, tag=f"[{name}] ")
+    founders[name] = m
+    acc, cv, ta = eval_model(m, val_imgs, val_labels)
+    all_results[name] = {"acc": acc, "cv": cv, "types": ta, "gen": 0}
+    print(f"  → {name}: val={acc:.3f}")
+
+
+# ══════════════════════════════════════════════════════════════════
+# GENERATION 1: 3 OFFSPRING FROM 2 FOUNDERS
+# ════════════════════════���═════════════════════════════════════════
+
+print(f"\n{'='*65}")
+print("GENERATION 1: 3 OFFSPRING from 2 founders")
+print(f"{'='*65}")
+
+# Extract + GPA
+print(f"\n  Extracting founder embeddings...")
+founder_embs = {}
+for name, m in founders.items():
+    m.eval()
+    with torch.no_grad():
+        founder_embs[name] = m.encode(train_imgs)
+
+consensus_g1, cos_g1 = gpa_consensus(list(founder_embs.values()))
+consensus_cv_g1 = cv_metric(consensus_g1[:2000])
+print(f"  GPA consensus: CV={consensus_cv_g1:.4f}, cos={cos_g1}")
+
+# Per-class centroids as anchors
+anchors_g1 = F.normalize(torch.stack([
+    consensus_g1[train_labels == c].mean(0) for c in range(30)]), dim=-1)
+
+gen1 = {}
+for i, cfg_key in enumerate(["geo_a", "geo_b", "geo_c"]):
+    name = f"G1_{i}"
+    print(f"\n  ── {name} ({cfg_key}) ──")
+    torch.manual_seed(hash(name) % 2**32)
+    m = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768,
+                            init_anchors=anchors_g1).to(DEVICE)
+    train_distilled(m, train_imgs, train_labels, consensus_g1, CONFIGS[cfg_key],
+                    epochs=30, tag=f"[{name}] ")
+    gen1[name] = m
+    acc, cv, ta = eval_model(m, val_imgs, val_labels)
+    all_results[name] = {"acc": acc, "cv": cv, "types": ta, "gen": 1}
+    print(f"  → {name}: val={acc:.3f}")
+
+# Free founders
+del founders; gc.collect(); torch.cuda.empty_cache()
+
+
+# ══════════════════════════════════════════════════════════════════
+# GENERATION 2: 4 OFFSPRING FROM 3 G1 + 1 NEW FOUNDER
+# ══════════════════════════════════════════════════════════════════
+
+print(f"\n{'='*65}")
+print("GENERATION 2: 4 OFFSPRING from 3 G1 + 1 new founder")
+print(f"{'='*65}")
+
+# Train new founder
+print(f"\n  ── New founder ──")
+torch.manual_seed(hash("new_raw_g2") % 2**32)
+new_founder = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768).to(DEVICE)
+train_model(new_founder, train_imgs, train_labels, CONFIGS["new_raw"], epochs=30,
+            tag="[NEW] ")
+acc_nf, _, _ = eval_model(new_founder, val_imgs, val_labels)
+all_results["F1_new"] = {"acc": acc_nf, "cv": 0, "types": {}, "gen": 1}
+
+# Extract all G1 + new founder
+print(f"\n  Extracting G1 + new founder...")
+g2_embs = {}
+for name, m in gen1.items():
+    m.eval()
+    with torch.no_grad():
+        g2_embs[name] = m.encode(train_imgs)
+new_founder.eval()
+with torch.no_grad():
+    g2_embs["new"] = new_founder.encode(train_imgs)
+
+consensus_g2, cos_g2 = gpa_consensus(list(g2_embs.values()))
+consensus_cv_g2 = cv_metric(consensus_g2[:2000])
+print(f"  GPA consensus (4 models): CV={consensus_cv_g2:.4f}, cos={cos_g2}")
+
+anchors_g2 = F.normalize(torch.stack([
+    consensus_g2[train_labels == c].mean(0) for c in range(30)]), dim=-1)
+
+gen2 = {}
+for i, cfg_key in enumerate(["geo_a", "geo_b", "geo_c", "new_geo"]):
+    name = f"G2_{i}"
+    print(f"\n  ── {name} ({cfg_key}) ──")
+    torch.manual_seed(hash(name) % 2**32)
+    m = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768,
+                            init_anchors=anchors_g2).to(DEVICE)
+    train_distilled(m, train_imgs, train_labels, consensus_g2, CONFIGS[cfg_key],
+                    epochs=30, tag=f"[{name}] ")
+    gen2[name] = m
+    acc, cv, ta = eval_model(m, val_imgs, val_labels)
+    all_results[name] = {"acc": acc, "cv": cv, "types": ta, "gen": 2}
+    print(f"  → {name}: val={acc:.3f}")
+
+del gen1, new_founder; gc.collect(); torch.cuda.empty_cache()
+
+
+# ══════════════════════════════════════════════════════════════════
+# GENERATION 3: FINAL DESCENDANT FROM 4 G2 + 1 NEW FOUNDER
+# ══════════════════════════════════════════════════════════════════
+
+print(f"\n{'='*65}")
+print("GENERATION 3: FINAL DESCENDANT from 4 G2 + 1 new founder")
+print(f"{'='*65}")
+
+# New founder
+print(f"\n  ── New founder ──")
+torch.manual_seed(hash("new_geo_g3") % 2**32)
+new_founder2 = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768).to(DEVICE)
+train_model(new_founder2, train_imgs, train_labels, CONFIGS["new_geo"], epochs=30,
+            tag="[NEW2] ")
+acc_nf2, _, _ = eval_model(new_founder2, val_imgs, val_labels)
+all_results["F2_new"] = {"acc": acc_nf2, "cv": 0, "types": {}, "gen": 2}
+
+# Extract all G2 + new founder
+print(f"\n  Extracting G2 + new founder...")
+g3_embs = {}
+for name, m in gen2.items():
+    m.eval()
+    with torch.no_grad():
+        g3_embs[name] = m.encode(train_imgs)
+new_founder2.eval()
+with torch.no_grad():
+    g3_embs["new2"] = new_founder2.encode(train_imgs)
+
+consensus_g3, cos_g3 = gpa_consensus(list(g3_embs.values()))
+consensus_cv_g3 = cv_metric(consensus_g3[:2000])
+print(f"  GPA consensus (5 models): CV={consensus_cv_g3:.4f}, cos={cos_g3}")
+
+anchors_g3 = F.normalize(torch.stack([
+    consensus_g3[train_labels == c].mean(0) for c in range(30)]), dim=-1)
+
+# Final descendant — best config
+print(f"\n  ── FINAL DESCENDANT ──")
+torch.manual_seed(42)
+final = PatchworkClassifier(n_classes=30, n_anchors=30, d_embed=768,
+                            init_anchors=anchors_g3).to(DEVICE)
+train_distilled(final, train_imgs, train_labels, consensus_g3, CONFIGS["geo_b"],
+                epochs=30, tag="[FINAL] ")
+acc_f, cv_f, ta_f = eval_model(final, val_imgs, val_labels)
+all_results["FINAL"] = {"acc": acc_f, "cv": cv_f, "types": ta_f, "gen": 3}
+
+
+# ══════════════════════════════════════════════════════════════════
+# EVOLUTION SUMMARY
+# ══════════════════════════════════════════════════════════════════
+
+print(f"\n\n{'='*65}")
+print("EVOLUTION SUMMARY")
+print(f"{'='*65}")
+
+print(f"\n  {'Model':<12} {'Gen':>3} {'v_acc':>6} {'cv':>7} "
+      f"{'poly':>5} {'curve':>5} {'star':>5} {'struct':>5}")
+print(f"  {'-'*55}")
+
+for name in sorted(all_results.keys(), key=lambda x: (all_results[x]["gen"], x)):
+    r = all_results[name]
+    ta = r.get("types", {})
+    print(f"  {name:<12} {r['gen']:>3} {r['acc']:>6.3f} {r['cv']:>7.4f} "
+          f"{ta.get('polygon',0):>5.2f} {ta.get('curve',0):>5.2f} "
+          f"{ta.get('star',0):>5.2f} {ta.get('structure',0):>5.2f}")
+
+# Generation averages
+print(f"\n  Per-generation averages:")
+for gen in range(4):
+    gen_accs = [r["acc"] for r in all_results.values() if r["gen"] == gen]
+    if gen_accs:
+        print(f"    Gen {gen}: mean_acc={np.mean(gen_accs):.3f} "
+              f"best={max(gen_accs):.3f} n={len(gen_accs)}")
+
+print(f"\n  Consensus CV progression: "
+      f"G1={consensus_cv_g1:.4f} → G2={consensus_cv_g2:.4f} → G3={consensus_cv_g3:.4f}")
+
+print(f"\n{'='*65}")
+print("DONE")
+print(f"{'='*65}")