exp011a shipped: real data pays adapters 2-3x more; structure replicates; blob targets built (schema lesson disclosed)

README.md

@@ -76,6 +76,7 @@ resolution) so gaps live in a narrow band — the paired design is load-bearing.
 | exp003_sigma_registers | register probe: **sigma is the ONLY live axis** — caption/type/cond all compress to ≤0; ordering prereg MISS with design consequences | **shipped (candidate, s0)** |
 | exp004_anima_relay | relays on the 2B DiT via diffusion-pipe (bf16 per dtype law) | staged |
 | exp005_sdxl_tree4a | the SDXL capacity battery (guidepost/scaffold/skeleton) | designed |
+| exp011a_fused_multiband | multiband on REAL fused data: **adapters pay 2-3x more; structural story replicates (3/3 surgical, monolith edge persists); blob targets built 100% after a schema lesson** | **shipped (candidate, s0; s1 running)** |
 | exp010_controller | **StepGatedSampler ships**: controller lifts grounding +0.089 over frozen; monotonic lesion ladder; HIGH lesion 14x LP-dominant (coarse-to-fine confirmed in image space); eps-trained HIGH band concentrates (diversity = open training goal) | **shipped (candidate)** |
 | exp009_bandroles | role objectives: **directional hit 4/4 but noise-adjacent — frequency reweighting too collinear; needs qualitatively different supervision + generation-side gauges (exp010)** | **shipped (2 seeds + rejudge)** |
 | exp008_multiband | band-ASSIGNED experts: **mechanism certifies — 3/3 surgical band lesions (50-200x), HIGH-noise band expert wins its band (label-corrected); uniform objective doesn't pay (roles enter exp009)** | **shipped (candidate, s0; s1 running)** |

exp011_fused_multiband/README.md

@@ -0,0 +1,43 @@
+# exp011a_fused_multiband — the multiband mechanism on REAL DATA
+# (+ the segmentation blob-target cache) — CANDIDATE s0; s1 running
+
+**Questions.** (1) Does real fused data (multi-entity photos, natural
+captions) change the band economics that uniform synthetic data couldn't pay
+for? (2) Build the segmentation blob targets for the HIGH-band blobbing role
+(loss design held for review — new mechanism, pacing law).
+
+**Design.** qwen-deepfashion-fused, 4352 rows (dataset audit gates enforced;
+all rows passed), caption_joycaption at nl77, same certified beds as exp008
+(multiband3 vs mono48, uniform eps objective, 3000 steps, pure Adam wd=0).
+
+**Results** (`results.json`):
+
+| arm | overall val | band0 (LOW) | band1 (MID) | band2 (HIGH) |
+|---|---|---|---|---|
+| frozen | 0.142435 | 0.293931 | 0.071764 | 0.010422 |
+| multiband3 | 0.135215 (−5.1%) | 0.280633 | 0.066728 | **0.009562** |
+| monolith r48 | **0.134184 (−5.8%)** | **0.278893** | **0.065772** | 0.009564 |
+
+Lesions: 3/3 surgical, with LARGER asymmetries than synthetic (band0 own
+0.0130 vs 0.000062 cross — 200×).
+
+**Findings (candidate, s0).**
+1. **Real data pays adapters 2–3× more** than synthetic (−5.1/−5.8% vs
+   −2.2/−2.4% in exp008) — the richer distribution has more for small
+   adapters to learn.
+2. **The structural story replicates on real data**: surgical band
+   specialists, monolith edge persists under a uniform objective, HIGH-band
+   own-band win reappears at a hair (0.009562 vs 0.009564).
+3. **Blob targets: built, verified, cached** — after a schema lesson: the
+   first rasterizer pass returned 100% EMPTY (fused_json polygons are FLAT
+   [x1,y1,...] lists in a declared `coord_space`, not the assumed pair-list
+   NORM_0_1000; the emptiness counter caught it — silent-zero discipline).
+   Corrected rasterizer: 100% non-empty, mean occupancy 0.293, coord_space
+   norm_0_1000 confirmed on every row. `fix_blob_targets.py` in-package.
+
+**Next.** The blob LOSS (how coarse occupancy couples to the HIGH band's
+x0-estimate) goes to the 8am design review with targets ready. s1
+replication of this bed lands ~07:30Z.
+
+**Caveats.** s0; 4352 rows single dataset; blob maps unused in this
+training (uniform objective by design). Cost ≈ 2.9 GPU-h incl. cache.

exp011_fused_multiband/dexp011_fused_multiband.py

@@ -0,0 +1,331 @@
+"""dexp011_fused_multiband.py — exp011a: multiband on REAL FUSED DATA
+(+ the blob-target cache for the 8am blob-loss design review).
+
+Two jobs (stage plan phase 4 prep, D2 from the reconstruction brief):
+  1. Does REAL data (qwen-deepfashion-fused: real photos, joycaption NL,
+     multi-entity scenes) change the band economics that synthetic
+     single-object data couldn't pay for? Same certified beds (multiband3 vs
+     mono48, uniform objective), new substrate data, exp010 battery after.
+  2. Build the SEGMENTATION BLOB TARGETS: fused_json entities[].mask.polygon
+     (NORM_0_1000) rasterized to the 64x64 latent grid, cached per row.
+     The blob LOSS mechanism is DELIBERATELY NOT implemented tonight —
+     it is a new mechanism and goes to Phil's 8am review with targets ready
+     (pacing law: don't step into something unprepared).
+
+Data gates: rows filtered on the dataset's own audit columns when present
+(age_audit/audit approved-only; counts printed; empty result fails LOUDLY —
+never silently train on people data past an available gate).
+
+Pod: bash pod2/run_exp011.sh
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+import time
+
+sys.path[:0] = ["pod2", "."]
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from pod_ledger import ledger_run, note, burn_down
+from d1_substrate import MEM_FRACTION
+from dexp006_sd15core_relay import make_schedule, add_noise, encode_nl77
+from dexp008_multiband import (MultibandDelta, MonoDelta, band_weights,
+                               band_of, attach, load_unet, N_BANDS)
+
+DATASET = "AbstractPhil/qwen-deepfashion-fused"
+SD_BASE = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+VAE_SCALE = 0.18215
+N_TRAIN, N_VAL = 4096, 256
+BATCH = int(os.environ.get("DEXP11_BATCH", "16"))
+STEPS = int(os.environ.get("DEXP11_STEPS", "3000"))
+SEED = int(os.environ.get("DEXP11_SEED", "0"))
+LR, CFG_DROPOUT = 1e-3, 0.1
+DATA_DIR = ("/workspace/data/dexp011" if os.path.isdir("/workspace")
+            else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                              "dexp011"))
+CKPT_DIR = ("/workspace/ckpts2/dexp011" if os.path.isdir("/workspace")
+            else DATA_DIR)
+
+
+def rasterize_blob(fused_json_str: str, size: int = 64) -> np.ndarray:
+    """Entity mask polygons (NORM_0_1000) -> union occupancy on the latent
+    grid. Returns (size, size) float32 in [0,1]. Rows without polygons
+    return zeros (counted by the caller)."""
+    from PIL import Image, ImageDraw
+    try:
+        fj = json.loads(fused_json_str)
+    except Exception:
+        return np.zeros((size, size), dtype=np.float32)
+    img = Image.new("L", (size, size), 0)
+    draw = ImageDraw.Draw(img)
+    n = 0
+    for ent in (fj.get("entities") or []):
+        mask = ent.get("mask") or {}
+        poly = mask.get("polygon") or []
+        if len(poly) >= 3:
+            pts = [(p[0] / 1000.0 * (size - 1), p[1] / 1000.0 * (size - 1))
+                   for p in poly if isinstance(p, (list, tuple))
+                   and len(p) >= 2]
+            if len(pts) >= 3:
+                draw.polygon(pts, fill=255)
+                n += 1
+    arr = np.asarray(img, dtype=np.float32) / 255.0
+    return arr
+
+
+def _iter_fused(need: int):
+    from huggingface_hub import HfApi, hf_hub_download
+    import pyarrow.parquet as pq
+    api = HfApi()
+    files = sorted(f for f in api.list_repo_files(DATASET, repo_type="dataset")
+                   if f.endswith(".parquet"))
+    got, kept, gated = 0, 0, 0
+    cols_printed = False
+    for fname in files:
+        path = hf_hub_download(DATASET, fname, repo_type="dataset")
+        tbl = pq.read_table(path)
+        if not cols_printed:
+            print(f"[fused] columns: {tbl.column_names}", flush=True)
+            cols_printed = True
+        for r in tbl.to_pylist():
+            got += 1
+            gate_vals = [str(r.get(c)) for c in ("age_audit", "audit")
+                         if c in r and r.get(c) is not None]
+            if gate_vals and not any(("approved" in v.lower()
+                                      or "pass" in v.lower())
+                                     for v in gate_vals):
+                gated += 1
+                continue
+            kept += 1
+            yield r
+            if kept >= need:
+                print(f"[fused] kept {kept} / seen {got} (gated out {gated})",
+                      flush=True)
+                return
+    raise AssertionError(
+        f"exhausted dataset with only {kept} gated rows of {got} seen — "
+        f"inspect gate columns before proceeding")
+
+
+def build_cache(device="cuda"):
+    cache_f = os.path.join(DATA_DIR, "cache.pt")
+    if os.path.exists(cache_f):
+        print(f"[cache] exists: {cache_f}")
+        return cache_f
+    os.makedirs(DATA_DIR, exist_ok=True)
+    from PIL import Image
+    from diffusers import AutoencoderKL
+    from transformers import CLIPTextModel, CLIPTokenizer
+    vae = AutoencoderKL.from_pretrained(
+        SD_BASE, subfolder="vae", torch_dtype=torch.float32).to(device).eval()
+    tok = CLIPTokenizer.from_pretrained(SD_BASE, subfolder="tokenizer")
+    te = CLIPTextModel.from_pretrained(
+        SD_BASE, subfolder="text_encoder",
+        torch_dtype=torch.float32).to(device).eval()
+    g = torch.Generator(device=device).manual_seed(SEED)
+    lat, ehs, blobs, jpegs = [], [], [], []
+    buf_img, buf_txt = [], []
+    n_blob_empty = 0
+
+    @torch.no_grad()
+    def flush():
+        if not buf_img:
+            return
+        px = torch.stack(buf_img).to(device)
+        lat.append((vae.encode(px).latent_dist.sample(generator=g)
+                    * VAE_SCALE).cpu())
+        ehs.append(encode_nl77(buf_txt, tok, te, device).cpu())
+        buf_img.clear()
+        buf_txt.clear()
+
+    n = 0
+    for r in _iter_fused(N_TRAIN + N_VAL):
+        img = r["image"]
+        img = img.get("bytes") if isinstance(img, dict) else img
+        im = Image.open(io.BytesIO(img)).convert("RGB").resize((512, 512))
+        buf_img.append(torch.from_numpy(np.asarray(im)).float()
+                       .permute(2, 0, 1) / 127.5 - 1.0)
+        cap = r.get("caption_joycaption") or r.get("prompt_fused") or ""
+        buf_txt.append(str(cap))
+        b = rasterize_blob(str(r.get("fused_json", "")))
+        if b.max() == 0:
+            n_blob_empty += 1
+        blobs.append(torch.from_numpy(b))
+        if n < 24:
+            jpegs.append(img)
+        n += 1
+        if len(buf_img) == 16:
+            flush()
+            if n % 512 == 0:
+                print(f"[cache] {n}/{N_TRAIN + N_VAL} "
+                      f"(blob-empty {n_blob_empty})", flush=True)
+    flush()
+    lat, ehs = torch.cat(lat), torch.cat(ehs)
+    blobs = torch.stack(blobs)
+    gv = torch.Generator().manual_seed(SEED + 1)
+    torch.save({"lat": lat[:N_TRAIN], "ehs": ehs[:N_TRAIN],
+                "blob": blobs[:N_TRAIN],
+                "val_lat": lat[N_TRAIN:], "val_ehs": ehs[N_TRAIN:],
+                "val_blob": blobs[N_TRAIN:],
+                "val_noise": torch.randn(N_VAL, 4, 64, 64, generator=gv),
+                "val_t": torch.randint(0, 1000, (N_VAL,), generator=gv),
+                "judge_jpegs": jpegs,
+                "blob_empty_count": n_blob_empty}, cache_f)
+    print(f"[cache] built: {N_TRAIN}+{N_VAL} rows, blob-empty {n_blob_empty}",
+          flush=True)
+    del vae, te
+    torch.cuda.empty_cache()
+    return cache_f
+
+
+def run(device="cuda"):
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    os.makedirs(CKPT_DIR, exist_ok=True)
+    acp = make_schedule(device)
+    with ledger_run("dexp011 fused cache + blob targets", budget_h=1.5):
+        build_cache(device)
+    cache = torch.load(os.path.join(DATA_DIR, "cache.pt"),
+                       map_location="cpu", weights_only=True)
+
+    def set_w(wraps, s01):
+        w = band_weights(s01)
+        for wr in wraps:
+            wr.w_bands = w
+
+    def loss_of(unet, wraps, lat, ehs, gen):
+        bsz = lat.shape[0]
+        drop = torch.rand(bsz, generator=gen, device=device) < CFG_DROPOUT
+        ehs = ehs.clone()
+        ehs[drop] = 0
+        t = torch.randint(0, 1000, (bsz,), generator=gen, device=device)
+        set_w(wraps, t.float() / 1000.0)
+        noise = torch.randn(lat.shape, generator=gen, device=device)
+        pred = unet(add_noise(lat, noise, t, acp), t, ehs,
+                    return_dict=False)[0]
+        return F.mse_loss(pred, noise)
+
+    @torch.no_grad()
+    def val(unet, wraps):
+        tot, per_band = [], {0: [], 1: [], 2: []}
+        for i in range(0, N_VAL, 32):
+            lat = cache["val_lat"][i:i + 32].to(device)
+            ehs = cache["val_ehs"][i:i + 32].to(device)
+            noise = cache["val_noise"][i:i + 32].to(device)
+            t = cache["val_t"][i:i + 32].to(device)
+            set_w(wraps, t.float() / 1000.0)
+            pred = unet(add_noise(lat, noise, t, acp), t, ehs,
+                        return_dict=False)[0]
+            mse = ((pred - noise) ** 2).mean(dim=(1, 2, 3))
+            tot += mse.tolist()
+            for j, tv in enumerate((t.float() / 1000.0).tolist()):
+                per_band[band_of(tv)].append(mse[j].item())
+        return (sum(tot) / len(tot),
+                {f"band{b}": round(sum(v) / max(len(v), 1), 6)
+                 for b, v in per_band.items()})
+
+    def train(unet, wraps, params, label):
+        opt = torch.optim.Adam(params, lr=LR, weight_decay=0.0)
+        gen = torch.Generator(device=device).manual_seed(SEED + 42)
+        idx = torch.Generator().manual_seed(SEED + 7)
+        t0 = time.time()
+        for step in range(1, STEPS + 1):
+            sel = torch.randint(0, N_TRAIN, (BATCH,), generator=idx)
+            loss = loss_of(unet, wraps, cache["lat"][sel].to(device),
+                           cache["ehs"][sel].to(device), gen)
+            loss.backward()
+            opt.step()
+            opt.zero_grad(set_to_none=True)
+            if step == 50 or step % 500 == 0:
+                print(f"[{label}] step {step}: loss {loss.item():.4f} | "
+                      f"{(time.time() - t0) / step:.2f}s/step", flush=True)
+        return round((time.time() - t0) / STEPS, 3)
+
+    results = {"config": {"dataset": DATASET, "steps": STEPS, "batch": BATCH,
+                          "seed": SEED, "cond": "caption_joycaption nl77",
+                          "blob_empty": int(cache["blob_empty_count"])}}
+    with ledger_run("dexp011 frozen", budget_h=0.2) as h:
+        unet = load_unet(device)
+        v, pb = val(unet, [])
+        results["frozen"] = {"val": v, "per_band": pb}
+        del unet
+        torch.cuda.empty_cache()
+        h["verdict"] = f"val {v:.5f}"
+
+    for label, mk, r_note in (("multiband3", lambda d: MultibandDelta(d),
+                               "3 band experts"),
+                              ("monolith", lambda d: MonoDelta(d), "r48")):
+        with ledger_run(f"dexp011 {label} s{SEED}", budget_h=2.5) as h:
+            unet = load_unet(device)
+            mods, wraps = attach(unet, mk)
+            n_params = sum(p.numel() for p in mods.parameters())
+            spd = train(unet, wraps, mods.parameters(), label)
+            v, pb = val(unet, wraps)
+            entry = {"n_params": n_params, "val": v, "per_band": pb,
+                     "s_per_step": spd}
+            if label == "multiband3":
+                lesions = {}
+                for b in range(N_BANDS):
+                    for m in mods:
+                        m.band_enabled[b] = False
+                    _, pb_les = val(unet, wraps)
+                    lesions[f"lesion_band{b}"] = pb_les
+                    for m in mods:
+                        m.band_enabled[b] = True
+                entry["lesions"] = lesions
+            torch.save({"mods": [m.state_dict() for m in mods]},
+                       os.path.join(CKPT_DIR, f"{label}_s{SEED}.pt"))
+            results[label] = entry
+            del unet, mods
+            torch.cuda.empty_cache()
+            h["verdict"] = f"val {v:.5f}"
+
+    mb, mo = results["multiband3"], results["monolith"]
+    lesion_sur = {}
+    for b in range(N_BANDS):
+        les = mb["lesions"][f"lesion_band{b}"]
+        own = les[f"band{b}"] - mb["per_band"][f"band{b}"]
+        oth = sum(les[f"band{o}"] - mb["per_band"][f"band{o}"]
+                  for o in range(N_BANDS) if o != b) / (N_BANDS - 1)
+        lesion_sur[f"band{b}"] = {"own": round(own, 6),
+                                  "other": round(oth, 6),
+                                  "surgical": own > 3 * abs(oth) and own > 0}
+    results["verdict"] = {
+        "mb_vs_mono": "multiband" if mb["val"] <= mo["val"] else "monolith",
+        "per_band_wins": {b: mb["per_band"][b] < mo["per_band"][b]
+                          for b in ("band0", "band1", "band2")},
+        "lesions": lesion_sur,
+        "note": "REAL fused data (D2); blob targets cached for the 8am "
+                "blob-loss design review; 1-seed CANDIDATE",
+    }
+    with open(os.path.join(DATA_DIR, "results.json" if SEED == 0
+                           else f"results_s{SEED}.json"), "w") as f:
+        json.dump(results, f, indent=2)
+    note(f"dexp011: {json.dumps(results['verdict']['mb_vs_mono'])}")
+    print(json.dumps(results["verdict"], indent=2))
+    burn_down()
+    return results
+
+
+def smoke():
+    fj = json.dumps({"entities": [
+        {"mask": {"polygon": [[100, 100], [900, 100], [900, 900],
+                              [100, 900]]}},
+        {"mask": {"polygon": [[0, 0], [200, 0], [100, 200]]}}]})
+    b = rasterize_blob(fj)
+    assert b.shape == (64, 64) and 0.5 < b.mean() < 0.9, b.mean()
+    assert rasterize_blob("not json").max() == 0
+    assert rasterize_blob(json.dumps({"entities": []})).max() == 0
+    print("dexp011 smoke PASSED (blob rasterizer; GPU run is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp011_fused_multiband/fix_blob_targets.py

@@ -0,0 +1,88 @@
+"""fix_blob_targets.py — rebuild exp011's blob targets with the CORRECT
+fused_json schema (diagnosed 2026-07-18: polygon is a FLAT [x1,y1,x2,y2,...]
+list, and coordinates live in the declared coord_space with image_size — not
+the assumed NORM_0_1000 pair-list). Row order replicates _iter_fused exactly
+(same files, same gates); patches blob/val_blob into the existing cache.
+LOUD assert: >50% of rows must produce non-empty blobs. CPU-only.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+sys.path[:0] = ["pod2", "."]
+
+import numpy as np
+import torch
+
+from dexp011_fused_multiband import _iter_fused, N_TRAIN, N_VAL, DATA_DIR
+
+
+def rasterize_v2(fused_json_str: str, size: int = 64) -> np.ndarray:
+    from PIL import Image, ImageDraw
+    try:
+        fj = json.loads(fused_json_str)
+    except Exception:
+        return np.zeros((size, size), dtype=np.float32)
+    cs = str(fj.get("coord_space", "")).lower()
+    im_size = fj.get("image_size")
+    if isinstance(im_size, (list, tuple)) and len(im_size) >= 2:
+        W, H = float(im_size[0]) or None, float(im_size[1]) or None
+    elif isinstance(im_size, dict):
+        W = float(im_size.get("width") or im_size.get("w") or 0) or None
+        H = float(im_size.get("height") or im_size.get("h") or 0) or None
+    else:
+        W = H = None
+    img = Image.new("L", (size, size), 0)
+    draw = ImageDraw.Draw(img)
+    for ent in (fj.get("entities") or []):
+        poly = (ent.get("mask") or {}).get("polygon") or []
+        if len(poly) >= 6 and all(isinstance(v, (int, float))
+                                  for v in poly[:6]):
+            xs, ys = poly[0::2], poly[1::2]
+            if "1000" in cs or (max(xs + ys) <= 1000 and W is None):
+                sx = sy = 1.0 / 1000.0
+            elif W and H:
+                sx, sy = 1.0 / W, 1.0 / H
+            else:
+                m = max(max(xs), max(ys), 1.0)
+                sx = sy = 1.0 / m
+            pts = [(min(max(x * sx, 0), 1) * (size - 1),
+                    min(max(y * sy, 0), 1) * (size - 1))
+                   for x, y in zip(xs, ys)]
+            if len(pts) >= 3:
+                draw.polygon(pts, fill=255)
+    return np.asarray(img, dtype=np.float32) / 255.0
+
+
+def main():
+    blobs, n_empty, cs_seen = [], 0, {}
+    for r in _iter_fused(N_TRAIN + N_VAL):
+        s = str(r.get("fused_json", ""))
+        b = rasterize_v2(s)
+        if b.max() == 0:
+            n_empty += 1
+        try:
+            cs = json.loads(s).get("coord_space", "?")
+            cs_seen[str(cs)] = cs_seen.get(str(cs), 0) + 1
+        except Exception:
+            pass
+        blobs.append(torch.from_numpy(b))
+    blobs = torch.stack(blobs)
+    frac = 1 - n_empty / len(blobs)
+    print(f"[fix_blob] non-empty {frac:.1%} (empty {n_empty}/{len(blobs)}); "
+          f"coord_spaces {cs_seen}; mean occupancy "
+          f"{blobs.mean().item():.3f}", flush=True)
+    assert frac > 0.5, f"still mostly empty ({frac:.1%}) — schema wrong again"
+    f = os.path.join(DATA_DIR, "cache.pt")
+    cache = torch.load(f, map_location="cpu", weights_only=True)
+    cache["blob"] = blobs[:N_TRAIN]
+    cache["val_blob"] = blobs[N_TRAIN:]
+    cache["blob_empty_count"] = n_empty
+    torch.save(cache, f)
+    print(f"[fix_blob] cache patched: {f}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

exp011_fused_multiband/results.json

@@ -0,0 +1,81 @@
+{
+  "config": {
+    "dataset": "AbstractPhil/qwen-deepfashion-fused",
+    "steps": 3000,
+    "batch": 16,
+    "seed": 0,
+    "cond": "caption_joycaption nl77",
+    "blob_empty": 4352
+  },
+  "frozen": {
+    "val": 0.14243539798007987,
+    "per_band": {
+      "band0": 0.293931,
+      "band1": 0.071764,
+      "band2": 0.010422
+    }
+  },
+  "multiband3": {
+    "n_params": 1235568,
+    "val": 0.1352152533709159,
+    "per_band": {
+      "band0": 0.280633,
+      "band1": 0.066728,
+      "band2": 0.009562
+    },
+    "s_per_step": 1.688,
+    "lesions": {
+      "lesion_band0": {
+        "band0": 0.293597,
+        "band1": 0.066852,
+        "band2": 0.009562
+      },
+      "lesion_band1": {
+        "band0": 0.280774,
+        "band1": 0.071368,
+        "band2": 0.00964
+      },
+      "lesion_band2": {
+        "band0": 0.280633,
+        "band1": 0.066757,
+        "band2": 0.010283
+      }
+    }
+  },
+  "monolith": {
+    "n_params": 1210576,
+    "val": 0.1341835820844608,
+    "per_band": {
+      "band0": 0.278893,
+      "band1": 0.065772,
+      "band2": 0.009564
+    },
+    "s_per_step": 1.654
+  },
+  "verdict": {
+    "mb_vs_mono": "monolith",
+    "per_band_wins": {
+      "band0": false,
+      "band1": false,
+      "band2": true
+    },
+    "lesions": {
+      "band0": {
+        "own": 0.012964,
+        "other": 6.2e-05,
+        "surgical": true
+      },
+      "band1": {
+        "own": 0.00464,
+        "other": 0.00011,
+        "surgical": true
+      },
+      "band2": {
+        "own": 0.000721,
+        "other": 1.5e-05,
+        "surgical": true
+      }
+    },
+    "note": "REAL fused data (D2); blob targets cached for the 8am blob-loss design review; 1-seed CANDIDATE"
+  }
+}