exp009 shipped (2 seeds + reference rejudge): role reweighting directionally consistent but negligible - instrument + supervision upgrades queued (exp010/exp011)

README.md

@@ -75,6 +75,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 |
+| 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)** |
 | exp006_sd15core_relay | CORE EPRED certification: **relay beats frozen (−2.5%) and matched LoRA 2-for-2; grounding gained (+0.036) where LoRA traded it; gates GROW on the core** | **shipped (candidate, s0)** |
 | exp007_amoe_lora | AMoE v1 vs monolith falsifier: **falsifier fires — uniform pressure ⇒ flat usage, dispatch pays nothing (Tree-1b law on diffusion); machinery green; next = structural band assignment** | **shipped (candidate, s0)** |

exp009_bandroles/README.md

@@ -0,0 +1,42 @@
+# exp009_bandroles — role objectives on the multiband mechanism (2 seeds + rejudge)
+
+**Question.** Does role-differentiated training pressure (the stage's band-role
+map as loss weighting) buy what the uniform objective couldn't (exp008,
+2-seed)? Roles as implemented: LOW-noise band +λ·HP-residual MSE (fine
+detail), HIGH-noise band +λ·LP-residual MSE (coarse structure), MID standard;
+λ=0.5; same crossfade windows route the pressure.
+
+**Instrument note (confessed).** As first run, the reference arms lacked the
+role gauges (P1 unmeasurable) — `dexp009_rejudge.py` post-hoc gauges the
+exp008 checkpoints and frozen row under identical math (amendment pattern;
+originals preserved).
+
+**Results** (both seeds; gauges: lower is better):
+
+| arm | HP gauge (LOW band) s0/s1 | LP gauge (HIGH band) s0/s1 | common val s0/s1 |
+|---|---|---|---|
+| frozen | 0.220686 | 0.001755 | 0.124788 |
+| uniform mb3 (exp008) | 0.215756 / 0.215718 | 0.001640 / 0.001643 | 0.122004 / 0.121970 |
+| **roles mb3** | **0.215649 / 0.215629** | **0.001638 / 0.001640** | 0.121994 / 0.121984 |
+| monolith r48 | **0.215291 / 0.215304** | 0.001644 / 0.001645 | 0.121736 / 0.121745 |
+
+| prereg | outcome |
+|---|---|
+| P1 role gauges move vs uniform | **DIRECTIONAL HIT 4/4** (both gauges, both seeds) — but margins 0.05–0.2%, noise-adjacent; monolith still wins the HP gauge outright |
+| P2 common gauge undegraded | HIT (identical to uniform within 5th decimal) |
+| P3 toggle bit-exact | HIT both seeds |
+| P4 lesions surgical | HIT both seeds (asymmetries match exp008) |
+
+**Verdict (2-seed, honest).** Frequency-reweighted role pressure produces a
+CONSISTENT but ECONOMICALLY NEGLIGIBLE movement — HP/LP weighting of the same
+epsilon target is nearly collinear with the base objective and does not
+constitute a genuinely different task. Two consequences for the stage:
+1. Role differentiation needs QUALITATIVELY different supervision per band
+   (segmentation-mask blobbing for HIGH, diversity pressure, semantic
+   targets) — the exp011+ territory and the AMOE docket.
+2. The eps-MSE gauge family may be the limiting INSTRUMENT: what band experts
+   do at generation time is not necessarily visible in per-step eps error.
+   exp010 (step-gated controller + generation-side band-lesion battery,
+   judged in image space) is the instrument upgrade and runs next.
+
+**Cost.** ~2.6 GPU-h/seed + 0.02h rejudge. Checkpoints: `roles_s{0,1}.pt`.

exp009_bandroles/dexp009_bandroles.py

@@ -0,0 +1,227 @@
+"""dexp009_bandroles.py — exp009: BAND-ROLE OBJECTIVES on the certified
+multiband mechanism (stage plan phase 2; gated on exp008 P4 — HIT 3/3).
+
+Phil's role map becomes TRAINING PRESSURE (the exp008 verdict: specialists
+exist, but a uniform objective doesn't pay — the roles must):
+  LOW  (fidelity/detail):   + lambda * MSE on the HIGH-PASS residual
+                            (HP = x − avgpool3(x)) — finer-detail pressure.
+  MID  (continuity):        standard eps MSE (unchanged).
+  HIGH (diversity/blob):    + lambda * MSE on the LOW-PASS residual
+                            (LP = avgpool7(x)) — coarse-structure pressure.
+Per-sample loss = sum_b w_b(s01) * loss_b — the same crossfade windows route
+role pressure to the right expert. JUDGING stays on the COMMON gauge
+(plain eps MSE, per band) for comparability with exp008's uniform-objective
+multiband (the control) + monolith; role-aligned gauges (HP-MSE on LOW,
+LP-MSE on HIGH) reported alongside.
+
+Prereg: P1 role-trained beats uniform-trained multiband in band0 on the LP
+gauge AND band2 on the HP gauge (role pressure moves role-aligned quality);
+P2 common-gauge own-band val not degraded >0.5% vs uniform multiband;
+P3 toggle bit-exact; P4 lesions stay surgical. 1-seed candidate first.
+
+Pod: bash pod2/run_exp009.sh   [DEXP9_SEED=0 DEXP9_LAMBDA=0.5]
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+
+sys.path[:0] = ["pod2", "."]
+
+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
+from dexp008_multiband import (MultibandDelta, band_weights, band_of, attach,
+                               load_unet, BAND_EDGES, N_BANDS, RANK,
+                               N_TRAIN, N_VAL)
+
+BATCH = int(os.environ.get("DEXP9_BATCH", "16"))
+STEPS = int(os.environ.get("DEXP9_STEPS", "3000"))
+SEED = int(os.environ.get("DEXP9_SEED", "0"))
+LAM = float(os.environ.get("DEXP9_LAMBDA", "0.5"))
+LR, CFG_DROPOUT = 1e-3, 0.1
+DATA_DIR = ("/workspace/data/dexp009" if os.path.isdir("/workspace")
+            else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                              "dexp009"))
+DEXP6_DIR = ("/workspace/data/dexp006" if os.path.isdir("/workspace")
+             else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                               "dexp006"))
+DEXP8_DIR = ("/workspace/data/dexp008" if os.path.isdir("/workspace")
+             else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                               "dexp008"))
+CKPT_DIR = ("/workspace/ckpts2/dexp009" if os.path.isdir("/workspace")
+            else DATA_DIR)
+
+
+def hp(x):
+    """High-pass: x − avgpool3(x) (finer-detail component)."""
+    return x - F.avg_pool2d(x, 3, stride=1, padding=1)
+
+
+def lp(x):
+    """Low-pass: avgpool7 (coarse structure)."""
+    return F.avg_pool2d(x, 7, stride=1, padding=3)
+
+
+def role_losses(pred, target):
+    """Per-sample (B,) losses for each band role."""
+    base = ((pred - target) ** 2).mean(dim=(1, 2, 3))
+    low = base + LAM * ((hp(pred) - hp(target)) ** 2).mean(dim=(1, 2, 3))
+    high = base + LAM * ((lp(pred) - lp(target)) ** 2).mean(dim=(1, 2, 3))
+    return low, base, high                       # LOW, MID, HIGH roles
+
+
+def run(device="cuda"):
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    os.makedirs(CKPT_DIR, exist_ok=True)
+    os.makedirs(DATA_DIR, exist_ok=True)
+    acp = make_schedule(device)
+    cache = torch.load(os.path.join(DEXP6_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
+        return 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)
+        w = set_w(wraps, t.float() / 1000.0)          # (B, 3)
+        noise = torch.randn(lat.shape, generator=gen, device=device)
+        pred = unet(add_noise(lat, noise, t, acp), t, ehs,
+                    return_dict=False)[0]
+        l_low, l_mid, l_high = role_losses(pred, noise)
+        return (w[:, 0] * l_low + w[:, 1] * l_mid + w[:, 2] * l_high).mean()
+
+    @torch.no_grad()
+    def val(unet, wraps):
+        """Common gauge (plain eps MSE per band) + role-aligned gauges."""
+        tot = []
+        per_band = {0: [], 1: [], 2: []}
+        role_g = {"high_band_lp": [], "low_band_hp": []}
+        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))
+            lp_mse = ((lp(pred) - lp(noise)) ** 2).mean(dim=(1, 2, 3))
+            hp_mse = ((hp(pred) - hp(noise)) ** 2).mean(dim=(1, 2, 3))
+            tot += mse.tolist()
+            for j, tv in enumerate((t.float() / 1000.0).tolist()):
+                b = band_of(tv)
+                per_band[b].append(mse[j].item())
+                if b == 2:                      # HIGH-noise rows
+                    role_g["high_band_lp"].append(lp_mse[j].item())
+                if b == 0:                      # LOW-noise rows
+                    role_g["low_band_hp"].append(hp_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()},
+                {"high_band_lp_gauge": round(sum(role_g["high_band_lp"])
+                                         / max(len(role_g["high_band_lp"]), 1), 6),
+                 "low_band_hp_gauge": round(sum(role_g["low_band_hp"])
+                                         / max(len(role_g["low_band_hp"]), 1), 6)})
+
+    # Band ordering (band_of): band0 = LOW noise (s01<=.35, late steps,
+    # fidelity role, +HP) | band1 = MID | band2 = HIGH noise (early steps,
+    # diversity/blob role, +LP).
+
+    results = {"config": {"lambda": LAM, "rank": RANK, "steps": STEPS,
+                          "batch": BATCH, "seed": SEED,
+                          "edges": BAND_EDGES,
+                          "roles": "band0 LOW +HP | band1 MID std | "
+                                   "band2 HIGH +LP"}}
+
+    with ledger_run(f"dexp009 roles s{SEED}", budget_h=2.5) as h:
+        unet = load_unet(device)
+        mods, wraps = attach(unet, lambda d: MultibandDelta(d))
+        for m in mods:
+            m.assert_zero_init()
+        n_params = sum(p.numel() for p in mods.parameters())
+        opt = torch.optim.Adam(mods.parameters(), lr=LR, weight_decay=0.0)
+        gen = torch.Generator(device=device).manual_seed(SEED + 42)
+        idx = torch.Generator().manual_seed(SEED + 7)
+        torch.cuda.reset_peak_memory_stats()
+        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"[roles] step {step}: loss {loss.item():.4f} | "
+                      f"{(time.time() - t0) / step:.2f}s/step | peak "
+                      f"{torch.cuda.max_memory_allocated() / 2**30:.1f}GB",
+                      flush=True)
+        v, pb, rg = val(unet, wraps)
+        for m in mods:
+            m.enabled = False
+        v_off, _, _ = val(unet, wraps)
+        for m in mods:
+            m.enabled = True
+        # lesions (P4 carry-over)
+        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
+        torch.save({"mods": [m.state_dict() for m in mods]},
+                   os.path.join(CKPT_DIR, f"roles_s{SEED}.pt"))
+        results["roles"] = {"n_params": n_params, "val": v, "per_band": pb,
+                            "role_gauges": rg, "val_toggled_off": v_off,
+                            "lesions": lesions}
+        del unet, mods
+        torch.cuda.empty_cache()
+        h["verdict"] = f"val {v:.5f} rg {rg}"
+
+    # compare against exp008's uniform-objective multiband (the control)
+    ref_f = os.path.join(DEXP8_DIR, "results.json")
+    if os.path.exists(ref_f):
+        ref = json.load(open(ref_f))
+        results["reference_uniform_mb3"] = {
+            "val": ref["multiband3"]["val"],
+            "per_band": ref["multiband3"]["per_band"]}
+        results["reference_frozen"] = ref["frozen"]
+    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"dexp009: {json.dumps(results['roles']['role_gauges'])}")
+    print(json.dumps({k: v for k, v in results.items()
+                      if k != "config"}, indent=2)[:2000])
+    burn_down()
+    return results
+
+
+def smoke():
+    x = torch.randn(2, 4, 16, 16)
+    assert hp(x).shape == x.shape and lp(x).shape == x.shape
+    assert torch.allclose(hp(x) + F.avg_pool2d(x, 3, 1, 1), x, atol=1e-6)
+    l, m_, h_ = role_losses(x, torch.zeros_like(x))
+    assert l.shape == (2,) and (l >= m_).all() and (h_ >= m_).all()
+    print("dexp009 smoke PASSED (hp/lp filters + role losses; GPU is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp009_bandroles/dexp009_rejudge.py

@@ -0,0 +1,126 @@
+"""dexp009_rejudge.py — amendment: role gauges for the REFERENCE arms.
+
+Instrument gap (confessed): the exp009 bed computed HP/LP role gauges only on
+the roles arm; the uniform-multiband reference (exp008 ckpt) and frozen row
+never got them, leaving prereg P1 unmeasurable as-run. This rejudge loads
+the exp008 checkpoints and computes the identical gauges — amendment rows,
+originals preserved (the runner-1 rejudge pattern).
+
+Pod: python3 pod2/dexp009_rejudge.py --run [--seed 0]
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+sys.path[:0] = ["pod2", "."]
+
+import torch
+
+from pod_ledger import ledger_run, note
+from d1_substrate import MEM_FRACTION
+from dexp006_sd15core_relay import make_schedule
+from dexp008_multiband import MultibandDelta, MonoDelta, attach, load_unet
+import dexp009_bandroles as bed9
+
+DEXP8_CKPT = ("/workspace/ckpts2/dexp008" if os.path.isdir("/workspace")
+              else "./data/dexp008")
+DATA_DIR = bed9.DATA_DIR
+
+
+def run(device="cuda", seed=0):
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    acp = make_schedule(device)
+    bed9_cache = torch.load(os.path.join(bed9.DEXP6_DIR, "cache.pt"),
+                            map_location="cpu", weights_only=True)
+    # reuse bed9's val by injecting its module-level cache reference
+    out = {}
+
+    def gauge(mods_loader, label):
+        unet = load_unet(device)
+        wraps = []
+        if mods_loader is not None:
+            mods, wraps = attach(unet, mods_loader["mk"])
+            sds = mods_loader["sds"]
+            for m, sd in zip(mods, sds):
+                m.load_state_dict(sd, strict=True)
+        # bind bed9.val's closure requirements
+        v, pb, rg = _val(unet, wraps, bed9_cache, acp, device)
+        out[label] = {"val": round(v, 6), "per_band": pb, "role_gauges": rg}
+        print(f"[rejudge] {label}: {rg} (val {v:.6f})", flush=True)
+        del unet
+        torch.cuda.empty_cache()
+
+    with ledger_run(f"dexp009 rejudge refs s{seed}", budget_h=0.3) as h:
+        gauge(None, "frozen")
+        ck = torch.load(os.path.join(DEXP8_CKPT, f"mb3_s{seed}.pt"),
+                        map_location="cpu", weights_only=True)
+        gauge({"mk": lambda d: MultibandDelta(d), "sds": ck["mods"]},
+              "uniform_mb3")
+        ck = torch.load(os.path.join(DEXP8_CKPT, f"mono48_s{seed}.pt"),
+                        map_location="cpu", weights_only=True)
+        gauge({"mk": lambda d: MonoDelta(d), "sds": ck["mods"]},
+              "monolith")
+        h["verdict"] = "refs gauged"
+
+    path = os.path.join(DATA_DIR, f"rejudge_refs_s{seed}.json")
+    with open(path, "w") as f:
+        json.dump(out, f, indent=2)
+    note(f"dexp009 rejudge: {json.dumps({k: v['role_gauges'] for k, v in out.items()})}")
+    return out
+
+
+def _val(unet, wraps, cache, acp, device):
+    """exp009's val, standalone (identical math)."""
+    import torch.nn.functional as F
+    from dexp008_multiband import band_weights, band_of
+    from dexp009_bandroles import hp, lp
+    from dexp006_sd15core_relay import add_noise
+    N_VAL = bed9.N_VAL
+    tot, per_band = [], {0: [], 1: [], 2: []}
+    role_g = {"high_band_lp": [], "low_band_hp": []}
+    with torch.no_grad():
+        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)
+            w = band_weights(t.float() / 1000.0)
+            for wr in wraps:
+                wr.w_bands = w
+            pred = unet(add_noise(lat, noise, t, acp), t, ehs,
+                        return_dict=False)[0]
+            mse = ((pred - noise) ** 2).mean(dim=(1, 2, 3))
+            lpm = ((lp(pred) - lp(noise)) ** 2).mean(dim=(1, 2, 3))
+            hpm = ((hp(pred) - hp(noise)) ** 2).mean(dim=(1, 2, 3))
+            tot += mse.tolist()
+            for j, tv in enumerate((t.float() / 1000.0).tolist()):
+                b = band_of(tv)
+                per_band[b].append(mse[j].item())
+                if b == 2:
+                    role_g["high_band_lp"].append(lpm[j].item())
+                if b == 0:
+                    role_g["low_band_hp"].append(hpm[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()},
+            {"high_band_lp_gauge": round(sum(role_g["high_band_lp"])
+                                         / max(len(role_g["high_band_lp"]), 1), 6),
+             "low_band_hp_gauge": round(sum(role_g["low_band_hp"])
+                                        / max(len(role_g["low_band_hp"]), 1), 6)})
+
+
+def smoke():
+    assert callable(_val) and os.path.basename(DEXP8_CKPT)
+    print("dexp009_rejudge smoke PASSED (parse; GPU run is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        seed = 0
+        if "--seed" in sys.argv:
+            seed = int(sys.argv[sys.argv.index("--seed") + 1])
+        run(seed=seed)
+    else:
+        smoke()

exp009_bandroles/rejudge_refs_s0.json

@@ -0,0 +1,38 @@
+{
+  "frozen": {
+    "val": 0.124788,
+    "per_band": {
+      "band0": 0.256406,
+      "band1": 0.064227,
+      "band2": 0.008726
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001755,
+      "low_band_hp_gauge": 0.220686
+    }
+  },
+  "uniform_mb3": {
+    "val": 0.122004,
+    "per_band": {
+      "band0": 0.250432,
+      "band1": 0.063046,
+      "band2": 0.008534
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.00164,
+      "low_band_hp_gauge": 0.215756
+    }
+  },
+  "monolith": {
+    "val": 0.121736,
+    "per_band": {
+      "band0": 0.249881,
+      "band1": 0.062896,
+      "band2": 0.008539
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001644,
+      "low_band_hp_gauge": 0.215291
+    }
+  }
+}

exp009_bandroles/rejudge_refs_s1.json

@@ -0,0 +1,38 @@
+{
+  "frozen": {
+    "val": 0.124788,
+    "per_band": {
+      "band0": 0.256406,
+      "band1": 0.064227,
+      "band2": 0.008726
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001755,
+      "low_band_hp_gauge": 0.220686
+    }
+  },
+  "uniform_mb3": {
+    "val": 0.12197,
+    "per_band": {
+      "band0": 0.250386,
+      "band1": 0.062999,
+      "band2": 0.008543
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001643,
+      "low_band_hp_gauge": 0.215718
+    }
+  },
+  "monolith": {
+    "val": 0.121745,
+    "per_band": {
+      "band0": 0.249925,
+      "band1": 0.062876,
+      "band2": 0.008538
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001645,
+      "low_band_hp_gauge": 0.215304
+    }
+  }
+}

exp009_bandroles/results.json

@@ -0,0 +1,66 @@
+{
+  "config": {
+    "lambda": 0.5,
+    "rank": 16,
+    "steps": 3000,
+    "batch": 16,
+    "seed": 0,
+    "edges": [
+      0.35,
+      0.75
+    ],
+    "roles": "band0 LOW +HP | band1 MID std | band2 HIGH +LP"
+  },
+  "roles": {
+    "n_params": 1235568,
+    "val": 0.12199406854688277,
+    "per_band": {
+      "band0": 0.250405,
+      "band1": 0.063047,
+      "band2": 0.008536
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.001638,
+      "low_band_hp_gauge": 0.215649
+    },
+    "val_toggled_off": 0.1247876692286809,
+    "lesions": {
+      "lesion_band0": {
+        "band0": 0.25634,
+        "band1": 0.063105,
+        "band2": 0.008536
+      },
+      "lesion_band1": {
+        "band0": 0.250423,
+        "band1": 0.064084,
+        "band2": 0.008546
+      },
+      "lesion_band2": {
+        "band0": 0.250405,
+        "band1": 0.063054,
+        "band2": 0.008691
+      }
+    }
+  },
+  "reference_uniform_mb3": {
+    "val": 0.12200367445166194,
+    "per_band": {
+      "band0": 0.250432,
+      "band1": 0.063046,
+      "band2": 0.008534
+    }
+  },
+  "reference_frozen": {
+    "val": 0.1247876692286809,
+    "per_band": {
+      "band0": 0.256406,
+      "band1": 0.064227,
+      "band2": 0.008726
+    },
+    "band_n": {
+      "band0_n": 98,
+      "band1_n": 98,
+      "band2_n": 60
+    }
+  }
+}

exp009_bandroles/results_s1.json

@@ -0,0 +1,66 @@
+{
+  "config": {
+    "lambda": 0.5,
+    "rank": 16,
+    "steps": 3000,
+    "batch": 16,
+    "seed": 1,
+    "edges": [
+      0.35,
+      0.75
+    ],
+    "roles": "band0 LOW +HP | band1 MID std | band2 HIGH +LP"
+  },
+  "roles": {
+    "n_params": 1235568,
+    "val": 0.12197124349131627,
+    "per_band": {
+      "band0": 0.250387,
+      "band1": 0.063004,
+      "band2": 0.008538
+    },
+    "role_gauges": {
+      "high_band_lp_gauge": 0.00164,
+      "low_band_hp_gauge": 0.215629
+    },
+    "val_toggled_off": 0.1247876692286809,
+    "lesions": {
+      "lesion_band0": {
+        "band0": 0.256343,
+        "band1": 0.063064,
+        "band2": 0.008538
+      },
+      "lesion_band1": {
+        "band0": 0.250401,
+        "band1": 0.064081,
+        "band2": 0.008548
+      },
+      "lesion_band2": {
+        "band0": 0.250387,
+        "band1": 0.063011,
+        "band2": 0.008691
+      }
+    }
+  },
+  "reference_uniform_mb3": {
+    "val": 0.12200367445166194,
+    "per_band": {
+      "band0": 0.250432,
+      "band1": 0.063046,
+      "band2": 0.008534
+    }
+  },
+  "reference_frozen": {
+    "val": 0.1247876692286809,
+    "per_band": {
+      "band0": 0.256406,
+      "band1": 0.064227,
+      "band2": 0.008726
+    },
+    "band_n": {
+      "band0_n": 98,
+      "band1_n": 98,
+      "band2_n": 60
+    }
+  }
+}

exp009_bandroles/roles_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6d7e4aa71cc797fec438edf8e5794139c1658bf817409d2d91f9cab9fc33155
+size 4994597