Update analyze_weights.py

analyze_weights.py

@@ -19,6 +19,10 @@ CKPT = "checkpoints/geolip_core_best.pt"
 OUT_DIR = "analysis_out"
 BATCH = 256
 
+# ── HuggingFace push ──
+HF_REPO_ID = "AbstractPhil/geolip-constellation-core"
+HF_PUSH = True
+
 CIFAR_MEAN = (0.4914, 0.4822, 0.4465)
 CIFAR_STD = (0.2470, 0.2435, 0.2616)
 
@@ -98,14 +102,108 @@ labels = torch.cat(all_labels)
 preds = torch.cat(all_preds)
 logits = torch.cat(all_logits)
 
-anchors = model.constellation.anchors.detach().float().cpu()
-anchors_n = F.normalize(anchors, dim=-1)
-n_anchors = anchors.shape[0]
 embs_n = F.normalize(embs, dim=-1)
-
 val_acc = (preds == labels).float().mean().item() * 100
 print(f"  Val accuracy: {val_acc:.1f}%")
 print(f"  Embeddings: {embs.shape}")
+
+# ══════════════════════════════════════════════════════════════════
+# ANCHOR PUSH — drag anchors to where the data lives
+# ══════════════════════════════════════════════════════════════════
+
+N_PUSH_STEPS = 30
+PUSH_LR = 0.5
+
+print(f"\n  Pushing anchors toward CLASS centroids ({N_PUSH_STEPS} steps, lr={PUSH_LR})...")
+
+# Before stats
+anchors_before = model.constellation.anchors.detach().float().cpu().clone()
+anch_n_before = F.normalize(anchors_before, dim=-1)
+cos_before = (embs_n @ anch_n_before.T).max(dim=1).values.mean().item()
+print(f"    Before: mean nearest_cos = {cos_before:.4f}")
+
+# Push using class centroids
+emb_device = embs.to(DEVICE)
+lbl_device = labels.to(DEVICE)
+
+if hasattr(model, 'push_anchors_to_centroids'):
+    for step in range(N_PUSH_STEPS):
+        moved = model.push_anchors_to_centroids(emb_device, lbl_device, lr=PUSH_LR)
+        if (step + 1) % 10 == 0:
+            an_tmp = F.normalize(model.constellation.anchors.detach().float().cpu(), dim=-1)
+            c_tmp = (embs_n @ an_tmp.T).max(dim=1).values.mean().item()
+            print(f"    Step {step+1:3d}: nearest_cos = {c_tmp:.4f}, moved = {moved}")
+else:
+    # Inline class-centroid push
+    with torch.no_grad():
+        anchors_param = model.constellation.anchors.data
+        emb_dev = F.normalize(emb_device, dim=-1)
+
+        # Compute class centroids once
+        classes = lbl_device.unique()
+        n_cls = classes.shape[0]
+        centroids = []
+        for c in classes:
+            mask = lbl_device == c
+            centroids.append(F.normalize(emb_dev[mask].mean(0, keepdim=True), dim=-1))
+        centroids = torch.cat(centroids, dim=0)  # (C, D)
+
+        # Assign anchors to classes round-robin
+        n_a = anchors_param.shape[0]
+        anchors_per_class = n_a // n_cls
+
+        for step in range(N_PUSH_STEPS):
+            an = F.normalize(anchors_param, dim=-1)
+            cos_ac = an @ centroids.T  # (A, C)
+
+            # Greedy assign
+            assigned = torch.full((n_a,), -1, dtype=torch.long, device=DEVICE)
+            cls_count = torch.zeros(n_cls, dtype=torch.long, device=DEVICE)
+            _, flat_idx = cos_ac.flatten().sort(descending=True)
+            for idx in flat_idx:
+                a = (idx // n_cls).item()
+                c_idx = (idx % n_cls).item()
+                if assigned[a] >= 0: continue
+                if cls_count[c_idx] >= anchors_per_class + 1: continue
+                assigned[a] = c_idx
+                cls_count[c_idx] += 1
+                if (assigned >= 0).all(): break
+            unassigned = (assigned < 0).nonzero(as_tuple=True)[0]
+            if len(unassigned) > 0:
+                assigned[unassigned] = (an[unassigned] @ centroids.T).argmax(dim=1)
+
+            # Push each anchor toward its class centroid
+            for a in range(n_a):
+                target = centroids[assigned[a].item()]
+                rank = (assigned[:a] == assigned[a]).sum().item()
+                if rank > 0:
+                    noise = torch.randn_like(target) * 0.05
+                    noise = noise - (noise * target).sum() * target
+                    target = F.normalize((target + noise).unsqueeze(0), dim=-1).squeeze(0)
+                anchors_param[a] = F.normalize(
+                    (an[a] + PUSH_LR * (target - an[a])).unsqueeze(0), dim=-1).squeeze(0)
+
+            if (step + 1) % 10 == 0:
+                an_tmp = F.normalize(anchors_param, dim=-1)
+                c_tmp = (emb_dev @ an_tmp.T).max(dim=1).values.mean().item()
+                print(f"    Step {step+1:3d}: nearest_cos = {c_tmp:.4f}")
+
+# After stats
+anchors = model.constellation.anchors.detach().float().cpu()
+anchors_n = F.normalize(anchors, dim=-1)
+n_anchors = anchors.shape[0]
+
+cos_after = (embs_n @ anchors_n.T).max(dim=1).values.mean().item()
+drift = (F.normalize(anchors_before, dim=-1) - anchors_n).norm(dim=-1).mean().item()
+print(f"    After:  mean nearest_cos = {cos_after:.4f} (Δ={cos_after - cos_before:+.4f})")
+print(f"    Anchor drift: {drift:.4f}")
+
+# Re-triangulate with pushed anchors
+with torch.no_grad():
+    new_cos = embs_n @ anchors_n.T
+    tris = 1.0 - new_cos
+    nearest = new_cos.argmax(dim=1)
+
 print(f"  Anchors: {anchors.shape}")
 
 # ══════════════════════════════════════════════════════════════════
@@ -329,13 +427,102 @@ if HAS_PLT:
             '#e6194b', '#3cb44b', '#4363d8', '#f58231', '#911eb4',
             '#42d4f4', '#f032e6', '#bfef45', '#469990', '#dcbeff']
     else:
-        cmap = plt.cm.get_cmap('tab20', min(N_CLASSES, 20))
-        CLASS_COLORS = [matplotlib.colors.rgb2hex(cmap(i % 20)) for i in range(N_CLASSES)]
+        # Vibrant HSV spiral — 100 distinct saturated colors
+        import colorsys
+        CLASS_COLORS = []
+        for i in range(N_CLASSES):
+            # Golden angle rotation for max hue separation
+            hue = (i * 0.618033988749895) % 1.0
+            # Alternate saturation/value for neighboring hues
+            sat = 0.75 + 0.25 * (i % 3) / 2
+            val = 0.85 + 0.15 * ((i + 1) % 2)
+            r, g, b = colorsys.hsv_to_rgb(hue, sat, val)
+            CLASS_COLORS.append(f'#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}')
+
+    # Dark theme for all plots — makes colors pop
+    plt.style.use('dark_background')
+    plt.rcParams.update({
+        'figure.facecolor': '#1a1a2e',
+        'axes.facecolor': '#16213e',
+        'axes.edgecolor': '#444466',
+        'axes.labelcolor': '#e0e0e0',
+        'text.color': '#e0e0e0',
+        'xtick.color': '#aaaacc',
+        'ytick.color': '#aaaacc',
+        'grid.color': '#333355',
+        'legend.facecolor': '#1a1a2e',
+        'legend.edgecolor': '#444466',
+    })
 
     print(f"\n{'='*70}")
     print("VISUALIZATIONS")
     print(f"{'='*70}")
 
+    def save_fig(filename, dpi=200):
+        plt.savefig(f'{OUT_DIR}/{filename}', dpi=dpi)
+
+    # ── Sphere grid helpers ──
+    def draw_sphere_grid_2d(ax, radius, n_meridians=24):
+        """Draw sphere reference grid — UNMISSABLE."""
+        print(f"    >>> DRAWING 2D GRID: radius={radius:.4f}, lw=5, white+cyan")
+        theta = np.linspace(0, 2 * np.pi, 500)
+        xr = radius * np.cos(theta)
+        yr = radius * np.sin(theta)
+
+        # Cyan glow (fat, behind)
+        ax.plot(xr, yr, color='#00e5ff', alpha=0.6, lw=9, zorder=49)
+        # White ring on top
+        ax.plot(xr, yr, color='white', alpha=1.0, lw=5, zorder=50,
+                solid_capstyle='round')
+
+        # Inner rings — dashed cyan, thick
+        for frac in [0.5, 0.75]:
+            ax.plot(frac * xr, frac * yr,
+                    color='#00e5ff', alpha=0.5, lw=2, linestyle='--', zorder=50)
+
+        # Meridian ticks — chunky white
+        for i in range(n_meridians):
+            a = 2 * np.pi * i / n_meridians
+            r0, r1 = radius * 0.92, radius * 1.08
+            ax.plot([r0*np.cos(a), r1*np.cos(a)],
+                    [r0*np.sin(a), r1*np.sin(a)],
+                    color='white', alpha=0.8, lw=2, zorder=50)
+
+        # Crosshairs
+        s = radius * 1.15
+        ax.plot([-s, s], [0, 0], color='#00e5ff', alpha=0.3, lw=1.5, zorder=49)
+        ax.plot([0, 0], [-s, s], color='#00e5ff', alpha=0.3, lw=1.5, zorder=49)
+
+        # Text label proving it rendered
+        ax.text(radius * 0.72, radius * 0.72, f'r={radius:.2f}',
+                color='#00e5ff', fontsize=10, fontweight='bold',
+                alpha=0.9, zorder=51)
+
+    def draw_sphere_grid_3d(ax, radius, n_lines=16):
+        """Draw a wireframe sphere in 3D PCA space — THICK."""
+        print(f"    >>> DRAWING 3D WIREFRAME: radius={radius:.4f}, lw=1.2+3")
+        theta = np.linspace(0, 2 * np.pi, 80)
+        phi = np.linspace(0, np.pi, 40)
+
+        # Latitude rings
+        for p in np.linspace(0, np.pi, n_lines + 1)[1:-1]:
+            r = radius * np.sin(p)
+            z = radius * np.cos(p)
+            ax.plot(r * np.cos(theta), r * np.sin(theta),
+                    z * np.ones_like(theta),
+                    color='white', alpha=0.4, lw=1.2)
+
+        # Longitude meridians
+        for t in np.linspace(0, 2 * np.pi, n_lines, endpoint=False):
+            x = radius * np.sin(phi) * np.cos(t)
+            y = radius * np.sin(phi) * np.sin(t)
+            z = radius * np.cos(phi)
+            ax.plot(x, y, z, color='white', alpha=0.4, lw=1.2)
+
+        # Equator — bright cyan, extra thick
+        ax.plot(radius * np.cos(theta), radius * np.sin(theta),
+                np.zeros_like(theta), color='#00e5ff', alpha=0.9, lw=3)
+
     # PCA basis
     embs_c = embs_n[:5000] - embs_n[:5000].mean(0, keepdim=True)
     _, _, Vt = torch.linalg.svd(embs_c, full_matrices=False)
@@ -345,6 +532,24 @@ if HAS_PLT:
     anch_3d = (anchors_n @ Vt[:3].T).numpy()
     proj_labels = labels.numpy()
 
+    # Compute sphere radius from projected data
+    emb_radii_2d = np.sqrt(proj_2d[:5000, 0]**2 + proj_2d[:5000, 1]**2)
+    sphere_r_2d = np.percentile(emb_radii_2d, 95)
+
+    emb_radii_3d = np.sqrt((proj_3d[:3000]**2).sum(axis=1))
+    sphere_r_3d = np.percentile(emb_radii_3d, 95)
+
+    # Sanity: if projections are tiny, use data range instead
+    data_range_2d = max(np.abs(proj_2d[:5000]).max(), np.abs(anch_2d).max())
+    data_range_3d = max(np.abs(proj_3d[:3000]).max(), np.abs(anch_3d).max())
+    if sphere_r_2d < 0.01:
+        sphere_r_2d = data_range_2d * 0.9
+    if sphere_r_3d < 0.01:
+        sphere_r_3d = data_range_3d * 0.9
+
+    print(f"  Sphere radius (2D): {sphere_r_2d:.4f}  (3D): {sphere_r_3d:.4f}")
+    print(f"  Data range   (2D): {data_range_2d:.4f}  (3D): {data_range_3d:.4f}")
+
     # ── [1] PCA embedding space ──
     print("  [1/8] PCA projection...")
     fig, ax = plt.subplots(1, 1, figsize=(12, 10))
@@ -353,18 +558,21 @@ if HAS_PLT:
         if mask.sum() == 0: continue
         lbl = CLASS_NAMES[c] if N_CLASSES <= 20 else None
         ax.scatter(proj_2d[:5000][mask, 0], proj_2d[:5000][mask, 1],
-                   c=CLASS_COLORS[c], s=4, alpha=0.3, label=lbl)
+                   c=CLASS_COLORS[c], s=4, alpha=0.5, label=lbl, zorder=2)
     ax.scatter(anch_2d[:, 0], anch_2d[:, 1],
-               c='black', s=60, marker='*', zorder=5, label='anchors')
+               c='#FFD700', s=60, marker='*', edgecolors='white', linewidths=0.3, zorder=5, label='anchors')
+    # Grid drawn LAST — on top of everything
+    draw_sphere_grid_2d(ax, sphere_r_2d)
     if N_CLASSES <= 20:
         ax.legend(fontsize=7, markerscale=2, loc='upper right', ncol=2)
     ax.set_title(f'GeoLIP Core — PCA Embedding Space ({ds_name})\n'
                  f'val={val_acc:.1f}% | {total_params:,} params | '
                  f'CV={v_cv:.4f} | {n_active}/{n_anchors} anchors', fontsize=11)
     ax.set_xlabel('PC1'); ax.set_ylabel('PC2')
-    ax.grid(True, alpha=0.2)
+    ax.set_aspect('equal')
+    ax.grid(True, alpha=0.15, color='#555577')
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/01_pca_embedding_space.png', dpi=200)
+    save_fig('01_pca_embedding_space.png')
     plt.close()
 
     # ── [2] Triangulation connections ──
@@ -375,14 +583,14 @@ if HAS_PLT:
         a_idx = nearest[i].item()
         ax.plot([proj_2d[i, 0], anch_2d[a_idx, 0]],
                 [proj_2d[i, 1], anch_2d[a_idx, 1]],
-                c=CLASS_COLORS[labels[i].item()], alpha=0.06, linewidth=0.4)
+                c=CLASS_COLORS[labels[i].item()], alpha=0.1, linewidth=0.5)
     for c in range(N_CLASSES):
         mask = proj_labels[:5000] == c
         if mask.sum() == 0: continue
         ax.scatter(proj_2d[:5000][mask, 0], proj_2d[:5000][mask, 1],
-                   c=CLASS_COLORS[c], s=3, alpha=0.25)
+                   c=CLASS_COLORS[c], s=5, alpha=0.4, zorder=2)
     ax.scatter(anch_2d[:, 0], anch_2d[:, 1],
-               c='black', s=80, marker='*', zorder=5)
+               c='#FFD700', s=80, marker='*', edgecolors='white', linewidths=0.3, zorder=5)
     if n_anchors <= 128:
         for a in range(n_anchors):
             a_mask = nearest == a
@@ -392,11 +600,16 @@ if HAS_PLT:
                             fontsize=4, ha='center', va='center',
                             color='white', fontweight='bold',
                             bbox=dict(boxstyle='round,pad=0.1',
-                                      fc=CLASS_COLORS[dom_class], alpha=0.7))
+                                      fc=CLASS_COLORS[dom_class],
+                                      ec='#FFD700', linewidth=0.5,
+                                      alpha=0.85))
+    # Grid drawn LAST
+    draw_sphere_grid_2d(ax, sphere_r_2d)
     ax.set_title(f'Triangulation: Image → Nearest Anchor ({ds_name})', fontsize=11)
-    ax.grid(True, alpha=0.2)
+    ax.set_aspect('equal')
+    ax.grid(True, alpha=0.15, color='#555577')
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/02_triangulation_connections.png', dpi=200)
+    save_fig('02_triangulation_connections.png')
     plt.close()
 
     # ── [3] 3D sphere ──
@@ -409,16 +622,25 @@ if HAS_PLT:
         if mask.sum() == 0: continue
         ax.scatter(proj_3d[:n_3d][mask, 0], proj_3d[:n_3d][mask, 1],
                    proj_3d[:n_3d][mask, 2],
-                   c=CLASS_COLORS[c], s=3, alpha=0.25,
+                   c=CLASS_COLORS[c], s=5, alpha=0.4,
                    label=CLASS_NAMES[c] if N_CLASSES <= 20 else None)
     ax.scatter(anch_3d[:, 0], anch_3d[:, 1], anch_3d[:, 2],
-               c='black', s=40, marker='*', zorder=5)
+               c='#FFD700', s=40, marker='*', edgecolors='white', linewidths=0.3, zorder=5)
+    # Wireframe drawn AFTER data — 3D has no zorder, draw order is render order
+    draw_sphere_grid_3d(ax, sphere_r_3d)
     if N_CLASSES <= 20:
         ax.legend(fontsize=6, markerscale=2, loc='upper left', ncol=2)
     ax.set_title(f'3D PCA — Constellation on the Sphere\n'
                  f'{n_anchors} anchors, {N_CLASSES} classes', fontsize=11)
+    try:
+        ax.set_box_aspect([1, 1, 1])
+    except AttributeError:
+        pass  # older matplotlib
+    ax.xaxis.pane.fill = False
+    ax.yaxis.pane.fill = False
+    ax.zaxis.pane.fill = False
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/03_3d_sphere.png', dpi=200)
+    save_fig('03_3d_sphere.png')
     plt.close()
 
     # ── [4] Anchor-Class heatmap ──
@@ -436,7 +658,7 @@ if HAS_PLT:
 
     h = max(6, N_CLASSES * 0.12)
     fig, ax = plt.subplots(1, 1, figsize=(16, h))
-    im = ax.imshow(assign_sorted.numpy(), aspect='auto', cmap='YlOrRd')
+    im = ax.imshow(assign_sorted.numpy(), aspect='auto', cmap='inferno')
     if N_CLASSES <= 30:
         ax.set_yticks(range(N_CLASSES))
         ax.set_yticklabels(CLASS_NAMES, fontsize=max(4, 9 - N_CLASSES // 15))
@@ -444,7 +666,7 @@ if HAS_PLT:
     ax.set_title(f'Class → Anchor Assignment ({ds_name})', fontsize=11)
     plt.colorbar(im, ax=ax, shrink=0.8)
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/04_anchor_class_heatmap.png', dpi=200)
+    save_fig('04_anchor_class_heatmap.png')
     plt.close()
 
     # ── [5] Triangulation profiles ──
@@ -475,7 +697,7 @@ if HAS_PLT:
     tag = "all classes" if N_CLASSES <= 10 else "5 worst + 5 best"
     plt.suptitle(f'Triangulation Fingerprints ({tag})', fontsize=12)
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/05_triangulation_profiles.png', dpi=200)
+    save_fig('05_triangulation_profiles.png')
     plt.close()
 
     # ── [6] Anchor utilization ──
@@ -484,11 +706,11 @@ if HAS_PLT:
 
     sorted_counts, _ = counts.sort(descending=True)
     ax1.bar(range(n_anchors), sorted_counts.numpy(),
-            color=['#2196F3' if c > 0 else '#F44336' for c in sorted_counts], width=1.0)
+            color=['#00BCD4' if c > 0 else '#FF5252' for c in sorted_counts], width=1.0)
     ax1.set_xlabel('Anchor (sorted)')
     ax1.set_ylabel('Assigned samples')
     ax1.set_title(f'Anchor Utilization ({n_active}/{n_anchors} active)')
-    ax1.axhline(y=len(labels) / n_anchors, color='gray', linestyle='--', alpha=0.5)
+    ax1.axhline(y=len(labels) / n_anchors, color='#888899', linestyle='--', alpha=0.5)
 
     # Per-class anchor entropy
     entropies = []
@@ -508,7 +730,7 @@ if HAS_PLT:
         ax2.set_yticklabels(CLASS_NAMES, fontsize=8)
         ax2.set_xlabel('Anchor assignment entropy')
     else:
-        ax2.hist(entropies, bins=30, color='steelblue', edgecolor='white')
+        ax2.hist(entropies, bins=30, color='#00BCD4', edgecolor='#333355')
         ax2.set_xlabel('Anchor assignment entropy')
         ax2.set_ylabel('Number of classes')
 
@@ -518,7 +740,7 @@ if HAS_PLT:
     gini = (1 - 2 * cum.sum() / (len(c_sorted) * c_sorted.sum() + 1e-8)).item()
     ax2.set_title(f'Anchor Spread (Gini={gini:.3f})')
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/06_anchor_utilization.png', dpi=200)
+    save_fig('06_anchor_utilization.png')
     plt.close()
 
     # ── [7] Patchwork compartment responses ──
@@ -551,7 +773,7 @@ if HAS_PLT:
                 class_labels_show.append(CLASS_NAMES[c])
         if not class_means: continue
         class_means = np.stack(class_means)
-        ax.imshow(class_means, aspect='auto', cmap='viridis')
+        ax.imshow(class_means, aspect='auto', cmap='plasma')
         ax.set_yticks(range(len(class_labels_show)))
         ax.set_yticklabels(class_labels_show, fontsize=6)
         ax.set_title(f'Comp {k}', fontsize=9)
@@ -559,7 +781,7 @@ if HAS_PLT:
         axes_flat[k].set_visible(False)
     plt.suptitle('Patchwork Compartment Responses by Class', fontsize=12)
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/07_patchwork_compartments.png', dpi=200)
+    save_fig('07_patchwork_compartments.png')
     plt.close()
 
     # ── [8] Confusion matrix ──
@@ -571,26 +793,26 @@ if HAS_PLT:
 
     if N_CLASSES <= 20:
         fig, ax = plt.subplots(1, 1, figsize=(8, 7))
-        im = ax.imshow(conf_pct.numpy(), cmap='Blues', vmin=0, vmax=100)
+        im = ax.imshow(conf_pct.numpy(), cmap='magma', vmin=0, vmax=100)
         for i in range(N_CLASSES):
             for j in range(N_CLASSES):
                 v = conf_pct[i, j].item()
                 ax.text(j, i, f'{v:.0f}', ha='center', va='center',
                         fontsize=max(4, 8 - N_CLASSES // 5),
-                        color='white' if v > 50 else 'black')
+                        color='black' if v > 60 else '#e0e0e0')
         ax.set_xticks(range(N_CLASSES))
         ax.set_yticks(range(N_CLASSES))
         ax.set_xticklabels(CLASS_NAMES, rotation=45, ha='right', fontsize=7)
         ax.set_yticklabels(CLASS_NAMES, fontsize=7)
     else:
         fig, ax = plt.subplots(1, 1, figsize=(14, 12))
-        im = ax.imshow(conf_pct.numpy(), cmap='Blues', vmin=0, vmax=100)
+        im = ax.imshow(conf_pct.numpy(), cmap='magma', vmin=0, vmax=100)
         ax.set_xlabel('Predicted class')
         ax.set_ylabel('True class')
     ax.set_title(f'Confusion Matrix — {val_acc:.1f}% ({ds_name})', fontsize=11)
     plt.colorbar(im, ax=ax, shrink=0.8)
     plt.tight_layout()
-    plt.savefig(f'{OUT_DIR}/08_confusion_matrix.png', dpi=200)
+    save_fig('08_confusion_matrix.png')
     plt.close()
 
     print(f"\n  ✓ All 8 visualizations saved to {OUT_DIR}/")
@@ -633,4 +855,19 @@ else:
 
 print(f"\n{'='*70}")
 print("ANALYSIS COMPLETE")
-print(f"{'='*70}")
+print(f"{'='*70}")
+
+# ══════════════════════════════════════════════════════════════════
+# PUSH IMAGES TO HUGGINGFACE
+# ══════════════════════════════════════════════════════════════════
+
+if HF_PUSH:
+    from huggingface_hub import upload_folder
+    print(f"\n  Uploading {OUT_DIR}/ → {HF_REPO_ID}/analysis/ ...")
+    upload_folder(
+        repo_id=HF_REPO_ID,
+        folder_path=OUT_DIR,
+        path_in_repo="analysis",
+        commit_message=f"Analysis: val={val_acc:.1f}% CV={v_cv:.4f} {n_active}/{n_anchors} anchors",
+    )
+    print(f"  ✓ Done: https://huggingface.co/{HF_REPO_ID}/tree/main/analysis")