Upload folder using huggingface_hub

harness/README.md

@@ -41,3 +41,11 @@ only the naming head, not the segmenter.
 
 `DATASET_SPEC.md` records the sufficiency analysis and the label-QC audit
 trail (including the snow-on-clouds failure and its fix).
+
+## 4. Name (query-time captioning head)
+- `concept_head.py tag1 [tag2 ...]` — 22-dim deterministic token features
+  (log-area, roundness, solidity, eccentricity, log-Hu, per-band mean/std,
+  NDVI) -> 2-layer MLP over taxonomy concepts, trained on the SAM 3.1 labels,
+  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.

harness/concept_head.py

@@ -0,0 +1,99 @@
+"""Stage 3 prototype: the naming head. Deterministic token features ->
+taxonomy concept, trained on the SAM 3.1 INFERRED labels in cp500/hyperkd-rs.
+
+Features per sample (all computable at query time without any big model):
+shape (log-area, perimeter^2/area roundness, solidity, eccentricity, 7 log-Hu)
++ spectral (mean/std of r,g,b,nir inside the mask + NDVI mean) = 22 dims.
+Head: 2-layer MLP, single-label over the concepts seen in training spots
+(each sample's highest-score label wins; nuisance and domain concepts mix).
+
+Temporal holdout: last 2 scenes of each spot are val.
+Usage: python concept_head.py tag1 tag2 ...
+"""
+import pathlib, sys, collections
+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); np.random.seed(0)
+HERE = pathlib.Path(__file__).parent
+TAGS = [a for a in sys.argv[1:] if not a.startswith("--")]
+
+def feats(mask, ms):
+    m8 = (mask > 0).astype(np.uint8)
+    a = m8.sum()
+    cs, _ = cv2.findContours(m8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    big = max(cs, key=cv2.contourArea)
+    per = cv2.arcLength(big, True)
+    hull = cv2.convexHull(big)
+    sol = cv2.contourArea(big) / max(cv2.contourArea(hull), 1)
+    rnd = 4 * np.pi * a / max(per * per, 1)
+    if len(big) >= 5:
+        (_, _), (MA, ma), _ = cv2.fitEllipse(big)
+        ecc = ma / max(MA, 1e-3)
+    else:
+        ecc = 1.0
+    hu = cv2.HuMoments(cv2.moments(m8)).flatten()
+    hu = np.sign(hu) * np.log1p(np.abs(hu) * 1e7)
+    # spectral: mask is 256-grid, multispec is 160-grid
+    m160 = cv2.resize(m8, (160, 160), interpolation=cv2.INTER_NEAREST) > 0
+    px = ms[m160]
+    if len(px) == 0: px = ms.reshape(-1, 4)
+    mu, sd = px.mean(0), px.std(0)
+    ndvi = ((px[:, 3] - px[:, 0]) / np.clip(px[:, 3] + px[:, 0], 1e-3, None)).mean()
+    return np.concatenate([[np.log1p(a), rnd, sol, ecc], hu, mu, sd, [ndvi]]).astype(np.float32)
+
+X_tr, y_tr, X_va, y_va, names = [], [], [], [], {}
+for tag in TAGS:
+    sh = np.load(HERE / f"shard_{tag}.npz")
+    lf = hf_hub_download("cp500/hyperkd-rs", f"labels/labels_{tag}.npz", repo_type="dataset")
+    lb = np.load(lf)
+    sl, cn = lb["sample_labels"], lb["concepts"]
+    best = {}
+    for i, ci, sc, iou in sl:
+        i = int(i)
+        if i not in best or sc > best[i][1]: best[i] = (str(cn[int(ci)]), sc)
+    cut = len(sh["images"]) - 2
+    for i, (cname, _) in best.items():
+        r = sh["samples"][i]; si = int(r[0]); ch = int(r[6]); mi = int(r[3 + ch])
+        if mi < 0: continue
+        ci = names.setdefault(cname, len(names))
+        f = feats(sh["masks"][mi], sh["multispec"][si].astype(np.float32))
+        (X_tr if si < cut else X_va).append(f)
+        (y_tr if si < cut else y_va).append(ci)
+    print(f"{tag}: {len(best)} labelled samples")
+X_tr, X_va = np.stack(X_tr), np.stack(X_va)
+mu, sd = X_tr.mean(0), X_tr.std(0) + 1e-6
+X_tr, X_va = (X_tr - mu) / sd, (X_va - mu) / sd
+y_tr, y_va = np.array(y_tr), np.array(y_va)
+K = len(names)
+print(f"{len(X_tr)} train / {len(X_va)} val, {K} concepts")
+
+m = torch.nn.Sequential(torch.nn.Linear(X_tr.shape[1], 128), torch.nn.ReLU(),
+                        torch.nn.Linear(128, 128), torch.nn.ReLU(),
+                        torch.nn.Linear(128, K))
+opt = torch.optim.Adam(m.parameters(), 1e-3)
+Xt, yt = torch.tensor(X_tr), torch.tensor(y_tr)
+Xv, yv = torch.tensor(X_va), torch.tensor(y_va)
+for ep in range(300):
+    idx = torch.randperm(len(Xt))[:512]
+    loss = F.cross_entropy(m(Xt[idx]), yt[idx])
+    opt.zero_grad(); loss.backward(); opt.step()
+with torch.no_grad():
+    pr = m(Xv).argmax(1)
+    acc = (pr == yv).float().mean().item()
+    # majority-class baseline
+    base = collections.Counter(y_tr.tolist()).most_common(1)[0][1] / len(y_tr)
+    maj = (yv == collections.Counter(y_tr.tolist()).most_common(1)[0][0]).float().mean().item()
+print(f"val top-1 {acc:.3f} vs majority-class {maj:.3f} ({K} classes)")
+inv = {v: k for k, v in names.items()}
+with torch.no_grad():
+    for ci in range(K):
+        sel = yv == ci
+        if sel.sum() < 5: continue
+        a = (pr[sel] == ci).float().mean().item()
+        print(f"  {inv[ci].split('/')[-1][:34]:36s} n={int(sel.sum()):4d} recall {a:.2f}")
+torch.save(dict(state=m.state_dict(), mu=mu, sd=sd, names=names), HERE / "concept_head.pt")
+print("-> concept_head.pt")

harness/label_shards.py

@@ -49,7 +49,8 @@ def label_tag(tag):
     sh = np.load(fp)
     images, samples, masks = sh["images"], sh["samples"], sh["masks"]
     months = [int(str(d)[5:7]) for d in sh["dates"]]
-    cons = concepts_for(MAN[tag])
+    base = tag[:-3] if tag.endswith("_ev") else tag   # event shards share the spot
+    cons = concepts_for(MAN[base])
     names = [c[0] for c in cons]
     sample_labels = []            # (sample_idx, concept_idx, score, iou)
     clouds = np.zeros((len(images), 256, 256), np.uint8)
@@ -62,7 +63,7 @@ def label_tag(tag):
             # one processor per threshold value used in this domain
             states = {}
             for ci, (name, vis, thr) in enumerate(cons):
-                if name.endswith("/snow cover") and not snow_possible(LAT[tag], months[si]):
+                if name.endswith("/snow cover") and not snow_possible(LAT[base], months[si]):
                     continue
                 proc = states.get(thr)
                 if proc is None: