Upload folder using huggingface_hub

harness/README.md

@@ -49,3 +49,11 @@ trail (including the snow-on-clouds failure and its fix).
   temporal holdout. Prototype: 70.2% top-1 vs 38.6% majority baseline over
   24 concepts. Captions are assembled from EXACT facts + this head's
   INFERRED concept (scored), never generated free-form.
+
+## 3b. Fine-tune the teacher itself (the one that won)
+- `finetune_sam21.py tag1 ... [--steps N]` (GPU) — SAM 2.1 base-plus decoder
+  + prompt encoder fine-tuned on point -> consensus-mask pairs, encoder frozen
+  with fp16 embedding cache. Held-out IoU 0.365 (zero-shot) -> **0.565**.
+  Checkpoint: https://huggingface.co/cp500/sam21-hyperkd-rs
+  Compare the PicoSAM3 distill (stage 3): plateaus at 0.178 — capacity, not
+  supervision, was the binding constraint at that size.

harness/finetune_sam21.py

@@ -0,0 +1,117 @@
+"""Fine-tune SAM 2.1 hiera-base-plus mask decoder on HyperKD-RS consensus
+targets. Encoder frozen; image embeddings precomputed once per scene and
+cached, so training is decoder-only and fits a T4.
+
+Point prompt -> target mask (track consensus where available), BCE+Dice on
+the 256x256 low-res logits. Temporal holdout: last 2 scenes per shard = val.
+
+Usage: HF_TOKEN=... python finetune_sam21.py tag1 tag2 ... [--steps N]
+Outputs: sam21_hyperkd_decoder.pt (decoder+prompt-encoder state), metrics log.
+"""
+import os, sys, random, pathlib
+import numpy as np
+import cv2
+import torch
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+
+torch.manual_seed(0); random.seed(0); np.random.seed(0)
+DEV = "cuda"
+STEPS = int(sys.argv[sys.argv.index("--steps") + 1]) if "--steps" in sys.argv else 4000
+_skip = {sys.argv[sys.argv.index("--steps") + 1]} if "--steps" in sys.argv else set()
+TAGS = [a for a in sys.argv[1:] if not a.startswith("--") and a not in _skip]
+REPO = "cp500/hyperkd-rs"
+
+from sam2.build_sam import build_sam2
+from sam2.sam2_image_predictor import SAM2ImagePredictor
+sam = build_sam2("configs/sam2.1/sam2.1_hiera_b+.yaml",
+                 os.path.expanduser("~/sam2/checkpoints/sam2.1_hiera_base_plus.pt"),
+                 device=DEV)
+pred = SAM2ImagePredictor(sam)
+for p in sam.image_encoder.parameters(): p.requires_grad = False
+trainable = list(sam.sam_mask_decoder.parameters()) + list(sam.sam_prompt_encoder.parameters())
+opt = torch.optim.AdamW([p for p in trainable if p.requires_grad], lr=1e-5)
+print(f"trainable params: {sum(p.numel() for p in trainable if p.requires_grad)/1e6:.2f}M")
+
+# ---- load shards, precompute embeddings ----
+train_pairs, val_pairs, scene_feats = [], [], []
+for tag in TAGS:
+    fp = hf_hub_download(REPO, f"shards/shard_{tag}.npz", repo_type="dataset")
+    sh = np.load(fp)
+    IM, SAMP, MK = sh["images"], sh["samples"], sh["masks"]
+    cut = len(IM) - 2
+    local = {}
+    for si in range(len(IM)):
+        img = cv2.resize(IM[si], (1024, 1024), interpolation=cv2.INTER_CUBIC)
+        with torch.inference_mode():
+            pred.set_image(img)
+        local[si] = len(scene_feats)
+        scene_feats.append({   # fp16 cache on the A10G (~10 GB of its 24 GB)
+            "embed": pred._features["image_embed"].half().clone(),
+            "hr": [f.half().clone() for f in pred._features["high_res_feats"]]})
+    for r in SAMP:
+        si, tgt = int(r[0]), int(r[9])
+        if tgt < 0: continue
+        m = MK[tgt]
+        if m.sum() < 15: continue
+        pair = (local[si], float(r[1]), float(r[2]), tgt, fp)
+        (train_pairs if si < cut else val_pairs).append((local[si], r[1], r[2], m))
+    print(f"{tag}: cached {len(IM)} embeddings; totals {len(train_pairs)} train / {len(val_pairs)} val", flush=True)
+
+def run_decoder(feat, cx, cy, train=True):
+    pts = torch.tensor([[[cx / 800 * 1024, cy / 800 * 1024]]], dtype=torch.float32, device=DEV)
+    lbl = torch.ones((1, 1), dtype=torch.int32, device=DEV)
+    emb = feat["embed"].to(DEV, torch.float32)
+    hr = [f.to(DEV, torch.float32) for f in feat["hr"]]
+    ctx = torch.enable_grad() if train else torch.inference_mode()
+    with ctx:
+        sparse, dense = sam.sam_prompt_encoder(points=(pts, lbl), boxes=None, masks=None)
+        lowres, iou_pred, _, _ = sam.sam_mask_decoder(
+            image_embeddings=emb,
+            image_pe=sam.sam_prompt_encoder.get_dense_pe(),
+            sparse_prompt_embeddings=sparse,
+            dense_prompt_embeddings=dense,
+            multimask_output=True,
+            repeat_image=False,
+            high_res_features=hr)
+    return lowres, iou_pred   # (1,3,256,256)
+
+def dice(p, t):
+    p = torch.sigmoid(p)
+    return 1 - (2 * (p * t).sum() + 1) / ((p + t).sum() + 1)
+
+def val_iou(n=400):
+    ious = []
+    for fi, cx, cy, m in random.sample(val_pairs, min(n, len(val_pairs))):
+        lowres, iou_pred = run_decoder(scene_feats[fi], cx, cy, train=False)
+        bi = int(iou_pred[0].argmax())
+        pm = (lowres[0, bi] > 0).cpu().numpy()
+        t = m > 0
+        ious.append((pm & t).sum() / max((pm | t).sum(), 1))
+    return float(np.mean(ious))
+
+print(f"zero-shot val IoU (argmax-iou head): {val_iou():.3f}", flush=True)
+best = 0
+for step in range(STEPS):
+    fi, cx, cy, m = random.choice(train_pairs)
+    lowres, iou_pred = run_decoder(scene_feats[fi], cx, cy, train=True)
+    T = torch.tensor(m, dtype=torch.float32, device=DEV)[None]
+    # supervise the best-matching head (SAM's multimask training rule)
+    with torch.no_grad():
+        ious = [( (lowres[0, j] > 0).float() * T ).sum() /
+                torch.clamp(((lowres[0, j] > 0).float() + T).clamp(max=1).sum(), min=1)
+                for j in range(3)]
+        bj = int(np.argmax([float(v) for v in ious]))
+    L = F.binary_cross_entropy_with_logits(lowres[0, bj][None], T) + dice(lowres[0, bj][None], T)
+    L = L + F.mse_loss(iou_pred[0, bj], ious[bj].detach())
+    opt.zero_grad(); L.backward(); opt.step()
+    if step % 500 == 499:
+        vi = val_iou()
+        print(f"step {step+1}: loss {L.item():.3f}  val IoU {vi:.3f}", flush=True)
+        if vi > best:
+            best = vi
+            torch.save({"decoder": sam.sam_mask_decoder.state_dict(),
+                        "prompt": sam.sam_prompt_encoder.state_dict()},
+                       os.path.expanduser("~/sam21_hyperkd_decoder.pt"))
+print(f"best val IoU {best:.3f} -> ~/sam21_hyperkd_decoder.pt", flush=True)
+print("FINETUNE_DONE")