exp001 shipped (relay certifies: beats frozen + matched LoRA, bit-exact post-train toggle; candidate s0) + README refresh (epred cores primary, nl77 congruency)

README.md

@@ -19,9 +19,14 @@ geolip program.
 
 | variant | trunk | trainer path |
 |---|---|---|
-| SD15-Lune rectified flow | `AbstractPhil/sd15-flow-lune-json-prompt` ckpt-2500 (+ base lune, json-vit) | custom beds (this repo, `substrate/`) |
+| **SD1.5 core (epred) — primary** | `stable-diffusion-v1-5/stable-diffusion-v1-5`, epsilon objective, natural 77-token prompting | custom beds (this repo, `substrate/`) |
+| **SDXL core (epred) — primary** | `stabilityai/stable-diffusion-xl-base-1.0` | after SD1.5-core certifies; plus the geolip-sdxl-aleph read-only capacity battery |
+| SD15-Lune rectified flow (undertrained exemplar; cheap flow testbed) | `AbstractPhil/sd15-flow-lune-json-prompt` ckpt-2500 (+ base lune, json-vit) | custom beds (this repo, `substrate/`) |
 | Anima / Cosmos-Predict2 2B DiT | `circlestone-labs/Anima` (NC weights — all derived checkpoints NC) | `AbstractEyes/diffusion-pipe` branch `feat/aleph-adapter` |
-| SDXL | `AbstractPhil/geolip-sdxl-aleph` phase-1 ckpts | read-only capacity battery first |
+
+**Prompting congruency:** judged work carries BOTH the json-225 chunked
+encoding and standard 77-token plain-English prompting (congruency to the
+natural paradigm).
 
 Sampler of record (Lune family): rectified flow, `v = noise − x0`, Euler on the
 **SHIFT=2.5-warped** sigma grid `σ = 2.5u/(1+1.5u)`, `VAE_SCALE 0.18215`. Text
@@ -64,11 +69,13 @@ resolution) so gaps live in a narrow band — the paired design is load-bearing.
 | exp | question | status |
 |---|---|---|
 | exp000_baselines | zero-shot baseline wall (above) | **shipped** |
-| exp001_sd15_relay | relay-all16 vs matched LoRA-r32 vs frozen, paired val flow-MSE + round-trip | running |
-| exp002_sd15_addrcond | frozen byte-trigram aleph address into the cond stream — 4-arm causal | staged |
-| exp003_sigma_registers | sign-code separations: what is a diffusion "register"? | staged |
-| exp004_anima_relay | relays on the 2B DiT via diffusion-pipe (bf16-matched) | staged |
+| exp000b_natural | natural-paradigm extension: nl77 arms + core epred SD15/SDXL stock-pipeline baselines | running |
+| exp001_sd15_relay | relay-all16 vs matched LoRA-r32 vs frozen: **relay beats both; LoRA lands below frozen; post-train toggle bit-exact** | **shipped (candidate, s0)** |
+| exp002_sd15_addrcond | frozen byte-trigram aleph address into the cond stream — 4-arm causal | running |
+| exp003_sigma_registers | sign-code separations: what is a diffusion "register"? (+prompt77 register) | running |
+| 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 |
+| exp006_sd15core_relay | relay vs LoRA on the CORE EPRED SD1.5 (epsilon objective, natural cond) | running |
 
 Code for each experiment ships in its folder with `results.json` from the run
 ledger. Substrate modules in `substrate/`.

exp001_sd15_relay/README.md

@@ -0,0 +1,55 @@
+# exp001_sd15_relay — relay machinery certification on SD15-Lune (CANDIDATE, s0)
+
+**Question.** Does the certified text-line relay recipe (per-block RelayPatch2D:
+multi-slot closed-form aleph read → SquaredReLU patchwork, zero-init out
+weight+bias, gate init −3.0, bit-exact toggle) carry to a diffusion trunk, and
+does it beat a parameter-matched LoRA under the identical objective?
+
+**Design.** Frozen `sd15-flow-lune-json-prompt` ckpt-2500 UNet (fp32 — adapter
+dtype matches trunk dtype per the line's dtype law). Three arms on one shared
+cache (4096 train / 256 val rows of `synthetic-object-relations-json`, latents
++ 225-token json conditioning, identical across arms):
+
+| arm | trainable | notes |
+|---|---|---|
+| frozen | 0 | reference, re-measured in-run |
+| relay_all16 | 3,227,568 | all 16 BasicTransformerBlocks |
+| lora_r32 | 3,182,592 | cross-attn q/k/v/out, rank 32 (param ratio 1.014) |
+
+Objective = the json trainer verbatim (σ~U(0,1) → SHIFT-2.5 warp,
+x_t = noise·σ′ + latents·(1−σ′), v-target MSE, 10% CFG dropout). Both trained
+arms: 3000 steps, batch 16, **pure Adam wd=0**, gradient checkpointing.
+Val = paired flow-MSE on FIXED per-row (noise, σ), fp32, with per-σ-band
+breakdown. Round-trip judge = exp000's exact 24 rows and machinery.
+
+**Results** (`results.json`):
+
+| arm | val flow-MSE | Δ vs frozen | round-trip gap (exp000 base: +0.2099) |
+|---|---|---|---|
+| frozen | 0.52241 | — | — |
+| **relay_all16** | **0.51796** | **−0.85%** | **+0.2052** (preserved) |
+| lora_r32 | 0.52503 | **+0.50% (worse)** | +0.1694 (degraded) |
+
+- **Preregistration HIT:** relay ≥ matched LoRA on paired val flow-MSE — and
+  the LoRA arm landed *below frozen* while degrading conditional grounding by
+  ~0.04; the relay improved val-MSE while preserving grounding.
+- **Toggle law held post-train, bit-exact:** relays-disabled val reproduces the
+  frozen row to 16 decimals (in-bed assert).
+- **Gate telemetry:** mean 0.0432 (init 0.0474 → mild shrink, the v35
+  gate-shrink direction), range 0.031–0.060 — sits just **above** the LM-line
+  0.012–0.03 gate band. Prereg P3 near-miss → the band's scope does not simply
+  extend to diffusion relays at 3k steps; scope finding, not a failure.
+- σ-band breakdown: relay improves all four bands; largest gain at high σ
+  (band0 0.55996 → 0.55319).
+
+**Honest caveats.** Single seed (CANDIDATE); 3k-step short-train — this is a
+*machinery certification*, not a capability claim; deltas are ~1% of val MSE;
+the LoRA control uses one standard placement (cross-attn q/k/v/out) at one
+rank; round-trip n=24. Cost: relay 1.87 s/step, LoRA 1.68 s/step, ~11GB peak
+each; whole experiment ≈ 3.1 GPU-h on an RTX 6000 Ada (incl. an OOM'd first
+attempt at batch 32 without checkpointing — the frozen trunk still retains its
+full activation graph for adapter gradients; batch 16 + checkpointing is the
+recorded recipe).
+
+**Checkpoints.** `relay_all16_s0.pt` (dims rebuild from the state dict;
+`aleph_diffusion_core.load_relay_stack`), `lora_r32_s0/` (PEFT).

exp001_sd15_relay/dexp001_sd15_relay.py

@@ -0,0 +1,390 @@
+"""dexp001_sd15_relay.py — exp001: SD15-Lune relay machinery certification.
+
+Arms (all fp32 trunk, identical cached data, identical paired val):
+  frozen     — re-measured reference (never inherited).
+  relay_all16— RelayPatch2D on all 16 BasicTransformerBlocks (adapters-only
+               train; pure Adam wd=0; zero-init W+b; gate -3.0).
+  lora_r32   — matched-param control: PEFT LoRA on cross-attn (attn2
+               q/k/v/out), rank 32 (param count printed + compared).
+
+Objective = the trainer of record VERBATIM (sd15_flow_lune_json_trainer.py:
+310-335): s~U(0,1) -> s'=2.5s/(1+1.5s), t=s'*1000, x_t = noise*s' +
+latents*(1-s'), v = noise - latents, per-sample MSE, CFG dropout 0.1
+(embeddings zeroed). latents = vae_sample * 0.18215 (cached once, all arms
+identical).
+
+Judged (fp32, paired):
+  1) val flow-MSE on 256 held-out rows with FIXED per-row (noise, sigma).
+  2) round-trip CLIP-L cond-vs-SHUFFLED gap on the SAME 24 tail rows as
+     exp000 (baseline wall: json_ckpt2500 +0.2099).
+  3) P-TOGGLE post-train: relays disabled == frozen val-MSE bit-exact.
+  4) gate telemetry per sigma band (0.012-0.03 band prereg — first non-LM test).
+
+Preregistration (charter 2026-07-16): relay >= lora on paired val-MSE at
+matched params; parity gates green incl. post-train; gate means vs the band.
+Honest negative: lora wins -> Tier B demoted to candidate, Tier A leads.
+
+Pod: python3 pod2/dexp001_sd15_relay.py --run [--steps 3000]
+"""
+from __future__ import annotations
+
+import io
+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 aleph_diffusion_core import (derangement, gate_stats, save_relay_stack,
+                                  sigma_band, SIGMA_BANDS)
+from d1_lune_sampler import encode_clip_225, flow_sample, decode
+from d1_substrate import attach_relays, enumerate_sd15_sites, MEM_FRACTION
+
+DATASET = "AbstractPhil/synthetic-object-relations-json"
+SD_BASE = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+SD_REPO = "AbstractPhil/sd15-flow-lune-json-prompt"
+SD_SUB = "checkpoint-00002500/unet"
+VAE_SCALE, SHIFT = 0.18215, 2.5
+N_TRAIN, N_VAL, N_JUDGE = 4096, 256, 24
+# batch 32 no-checkpointing OOM'd the 43.6GB cap (2026-07-16 19:35Z — the
+# frozen trunk still retains its FULL activation graph for relay grads);
+# checkpointing default-on rider now honored in load_unet()
+BATCH, LR, CFG_DROPOUT = int(os.environ.get("DEXP1_BATCH", "16")), 1e-3, 0.1
+STEPS = int(os.environ.get("DEXP1_STEPS", "3000"))
+SEED = 0
+DATA_DIR = ("/workspace/data/dexp001" if os.path.isdir("/workspace")
+            else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                              "dexp001"))
+CKPT_DIR = ("/workspace/ckpts2/dexp001" if os.path.isdir("/workspace")
+            else DATA_DIR)
+
+
+# ── stage 0: cache (latents + text embeds, once; all arms share) ────────────
+
+def _iter_rows(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 = 0
+    for fname in files:
+        path = hf_hub_download(DATASET, fname, repo_type="dataset")
+        tbl = pq.read_table(path, columns=None)
+        for r in tbl.to_pylist():
+            yield fname, r
+            got += 1
+            if got >= need:
+                return
+
+
+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} (DATA_ROOT pinned — never move)")
+        return cache_f
+    os.makedirs(DATA_DIR, exist_ok=True)
+    from PIL import Image
+    import numpy as np
+    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 = [], []
+    buf_img, buf_txt = [], []
+
+    @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_clip_225(buf_txt, tok, te, device).cpu())
+        buf_img.clear()
+        buf_txt.clear()
+
+    n = 0
+    for fname, r in _iter_rows(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))
+        arr = torch.from_numpy(np.asarray(im)).float() / 127.5 - 1.0
+        buf_img.append(arr.permute(2, 0, 1))
+        jp = r["json_prompt"]
+        buf_txt.append(jp if isinstance(jp, str) else json.dumps(jp))
+        n += 1
+        if len(buf_img) == 16:
+            flush()
+            if n % 512 == 0:
+                print(f"[cache] {n}/{N_TRAIN + N_VAL}", flush=True)
+    flush()
+    lat, ehs = torch.cat(lat), torch.cat(ehs)
+    gv = torch.Generator().manual_seed(SEED + 1)
+    val_noise = torch.randn(N_VAL, 4, 64, 64, generator=gv)
+    u = torch.linspace(0.02, 0.98, N_VAL)
+    val_sigma = (SHIFT * u) / (1 + (SHIFT - 1) * u)
+    torch.save({"lat": lat[:N_TRAIN], "ehs": ehs[:N_TRAIN],
+                "val_lat": lat[N_TRAIN:], "val_ehs": ehs[N_TRAIN:],
+                "val_noise": val_noise, "val_sigma": val_sigma,
+                "data_root": DATA_DIR}, cache_f)
+    print(f"[cache] built {cache_f}: train {N_TRAIN}, val {N_VAL}", flush=True)
+    del vae, te
+    torch.cuda.empty_cache()
+    return cache_f
+
+
+# ── the objective (trainer-verbatim) ─────────────────────────────────────────
+
+def flow_loss(unet, lat, ehs, gen, device):
+    bsz = lat.shape[0]
+    drop = torch.rand(bsz, generator=gen, device=device) < CFG_DROPOUT
+    ehs = ehs.clone()
+    ehs[drop] = 0
+    s = torch.rand(bsz, generator=gen, device=device)
+    s = (SHIFT * s) / (1 + (SHIFT - 1) * s)
+    t = s * 1000
+    s4 = s[:, None, None, None]
+    noise = torch.randn(lat.shape, generator=gen, device=device)
+    noisy = noise * s4 + lat * (1 - s4)
+    target = noise - lat
+    pred = unet(noisy, t, ehs, return_dict=False)[0]
+    return F.mse_loss(pred, target)
+
+
+@torch.no_grad()
+def val_mse(unet, cache, device):
+    """Paired: FIXED per-row (noise, sigma); fp32; per-band breakdown."""
+    tot, per_band = [], {i: [] for i in range(len(SIGMA_BANDS))}
+    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)
+        s = cache["val_sigma"][i:i + 32].to(device)
+        s4 = s[:, None, None, None]
+        pred = unet(noise * s4 + lat * (1 - s4), s * 1000, ehs,
+                    return_dict=False)[0]
+        mse = ((pred - (noise - lat)) ** 2).mean(dim=(1, 2, 3))
+        tot += mse.tolist()
+        for j, sv in enumerate(s.tolist()):
+            per_band[sigma_band(sv)].append(mse[j].item())
+    return {"mean": sum(tot) / len(tot),
+            "per_band": {f"band{k}": round(sum(v) / max(len(v), 1), 5)
+                         for k, v in per_band.items()}}
+
+
+# ── round-trip judge (exp000-identical rows + machinery) ────────────────────
+
+@torch.no_grad()
+def round_trip(unet, device):
+    from d1_exp000_baselines import load_rows, judge_selftest
+    from PIL import Image
+    import numpy as np
+    from transformers import (CLIPTextModel, CLIPTokenizer, CLIPModel,
+                              CLIPProcessor)
+    from diffusers import AutoencoderKL
+    rows = load_rows(N_JUDGE)
+    tok = CLIPTokenizer.from_pretrained(SD_BASE, subfolder="tokenizer")
+    te = CLIPTextModel.from_pretrained(
+        SD_BASE, subfolder="text_encoder",
+        torch_dtype=torch.float32).to(device).eval()
+    vae = AutoencoderKL.from_pretrained(
+        SD_BASE, subfolder="vae", torch_dtype=torch.float32).to(device).eval()
+    clip = CLIPModel.from_pretrained(
+        "openai/clip-vit-large-patch14",
+        torch_dtype=torch.float32).to(device).eval()
+    cproc = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
+    feat = judge_selftest(clip, cproc, device)
+    prompts = [r["json_prompt"] for r in rows]
+    perm = derangement(len(prompts), seed=1234)
+    orig = torch.cat([
+        feat(Image.open(io.BytesIO(r["image_bytes"])).convert("RGB"))
+        for r in rows])
+    out = {}
+    for arm, ps in (("cond", prompts),
+                    ("shuffled", [prompts[i] for i in perm.tolist()])):
+        ehs = encode_clip_225(ps, tok, te, device)
+        cos = []
+        for i in range(0, len(ps), 6):
+            latg = flow_sample(unet, ehs[i:i + 6], n_steps=30, guidance=6.0,
+                               seed=1234 + i, device=device)
+            imgs = decode(vae, latg)
+            pil = [Image.fromarray((im * 255).astype(np.uint8))
+                   for im in imgs]
+            f = torch.cat([feat(p) for p in pil])
+            cos += (f * orig[i:i + 6]).sum(-1).tolist()
+        out[arm] = round(sum(cos) / len(cos), 4)
+    out["cond_minus_shuffled"] = round(out["cond"] - out["shuffled"], 4)
+    del te, vae, clip
+    torch.cuda.empty_cache()
+    return out
+
+
+# ── arms ─────────────────────────���───────────────────────────────────────────
+
+def load_unet(device):
+    from diffusers import UNet2DConditionModel
+    unet = UNet2DConditionModel.from_pretrained(
+        SD_REPO, subfolder=SD_SUB, torch_dtype=torch.float32).to(device)
+    unet.requires_grad_(False)
+    unet.eval()
+    unet.enable_gradient_checkpointing()      # rider: default-on (OOM-earned)
+    return unet
+
+
+def train_loop(unet, params, cache, device, label):
+    opt = torch.optim.Adam(params, lr=LR, weight_decay=0.0)   # pure Adam law
+    gen = torch.Generator(device=device).manual_seed(SEED + 42)
+    idx_gen = torch.Generator().manual_seed(SEED + 7)
+    torch.cuda.reset_peak_memory_stats()
+    t0, losses = time.time(), []
+    for step in range(1, STEPS + 1):
+        sel = torch.randint(0, N_TRAIN, (BATCH,), generator=idx_gen)
+        lat = cache["lat"][sel].to(device)
+        ehs = cache["ehs"][sel].to(device)
+        loss = flow_loss(unet, lat, ehs, gen, device)
+        loss.backward()
+        opt.step()
+        opt.zero_grad(set_to_none=True)
+        losses.append(loss.item())
+        if step == 50 or step % 500 == 0:
+            print(f"[{label}] step {step}: loss {loss.item():.4f} | "
+                  f"{(time.time() - t0) / step:.2f}s/step | "
+                  f"peak {torch.cuda.max_memory_allocated() / 2**30:.1f}GB",
+                  flush=True)
+    return {"steps": STEPS, "final_loss_ma50":
+            round(sum(losses[-50:]) / 50, 5),
+            "s_per_step": round((time.time() - t0) / STEPS, 3),
+            "peak_mem_gb":
+            round(torch.cuda.max_memory_allocated() / 2**30, 2)}
+
+
+def arm_frozen(cache, device):
+    unet = load_unet(device)
+    r = {"val": val_mse(unet, cache, device)}
+    del unet
+    torch.cuda.empty_cache()
+    return r
+
+
+def arm_relay(cache, device):
+    unet = load_unet(device)
+    relays, names = attach_relays(unet)
+    n_params = sum(p.numel() for p in relays.parameters())
+    print(f"[relay] {len(relays)} sites, {n_params:,} trainable", flush=True)
+    for rl in relays:
+        rl.train()
+    stats = train_loop(unet, relays.parameters(), cache, device, "relay")
+    for rl in relays:
+        rl.eval()
+    v_on = val_mse(unet, cache, device)
+    for rl in relays:                                   # P-TOGGLE post-train
+        rl.enabled = False
+    v_off = val_mse(unet, cache, device)
+    for rl in relays:
+        rl.enabled = True
+    os.makedirs(CKPT_DIR, exist_ok=True)
+    save_relay_stack(relays, os.path.join(CKPT_DIR, "relay_all16_s0.pt"))
+    rt = round_trip(unet, device)
+    res = {"n_params": n_params, "train": stats, "val": v_on,
+           "val_toggled_off": v_off, "gates": gate_stats(relays),
+           "round_trip": rt}
+    del unet, relays
+    torch.cuda.empty_cache()
+    return res
+
+
+def arm_lora(cache, device):
+    from peft import LoraConfig, get_peft_model
+    unet = load_unet(device)
+    targets = [n for n, m in unet.named_modules()
+               if isinstance(m, torch.nn.Linear) and "attn2" in n
+               and n.split(".")[-1] in ("to_q", "to_k", "to_v")
+               or (isinstance(m, torch.nn.Linear) and "attn2" in n
+                   and n.endswith("to_out.0"))]
+    cfg = LoraConfig(r=32, lora_alpha=32, target_modules=targets,
+                     lora_dropout=0.0)
+    unet = get_peft_model(unet, cfg)
+    params = [p for p in unet.parameters() if p.requires_grad]
+    n_params = sum(p.numel() for p in params)
+    print(f"[lora] r=32 on {len(targets)} linears, {n_params:,} trainable",
+          flush=True)
+    unet.train()
+    stats = train_loop(unet, params, cache, device, "lora")
+    unet.eval()
+    v = val_mse(unet, cache, device)
+    unet.save_pretrained(os.path.join(CKPT_DIR, "lora_r32_s0"))
+    rt = round_trip(unet, device)
+    res = {"n_params": n_params, "train": stats, "val": v, "round_trip": rt}
+    del unet
+    torch.cuda.empty_cache()
+    return res
+
+
+def run(device="cuda"):
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    results = {"config": {"steps": STEPS, "batch": BATCH, "lr": LR,
+                          "n_train": N_TRAIN, "n_val": N_VAL, "seed": SEED,
+                          "optimizer": "torch.optim.Adam wd=0"}}
+    with ledger_run("dexp001 cache build", budget_h=0.5):
+        build_cache(device)
+    cache = torch.load(os.path.join(DATA_DIR, "cache.pt"),
+                       map_location="cpu", weights_only=True)
+    with ledger_run("dexp001 frozen reference", budget_h=0.2) as h:
+        results["frozen"] = arm_frozen(cache, device)
+        h["verdict"] = f"val {results['frozen']['val']['mean']:.5f}"
+    with ledger_run("dexp001 relay_all16 s0", budget_h=2.0) as h:
+        results["relay_all16"] = arm_relay(cache, device)
+        # P-TOGGLE assert: toggled-off == frozen (bit-exact val path)
+        d = abs(results["relay_all16"]["val_toggled_off"]["mean"]
+                - results["frozen"]["val"]["mean"])
+        assert d < 1e-9, f"post-train toggle parity broken: {d}"
+        h["verdict"] = (f"val {results['relay_all16']['val']['mean']:.5f} "
+                        f"rt {results['relay_all16']['round_trip']['cond_minus_shuffled']:+.4f}")
+    with ledger_run("dexp001 lora_r32 s0", budget_h=2.0) as h:
+        results["lora_r32"] = arm_lora(cache, device)
+        h["verdict"] = (f"val {results['lora_r32']['val']['mean']:.5f} "
+                        f"rt {results['lora_r32']['round_trip']['cond_minus_shuffled']:+.4f}")
+
+    rv = results["relay_all16"]["val"]["mean"]
+    lv = results["lora_r32"]["val"]["mean"]
+    fv = results["frozen"]["val"]["mean"]
+    results["verdict"] = {
+        "relay_beats_frozen": rv < fv,
+        "relay_vs_lora": "relay" if rv <= lv else "lora",
+        "param_ratio": round(results["relay_all16"]["n_params"]
+                             / results["lora_r32"]["n_params"], 3),
+        "note": "prereg: relay >= lora at matched params; 1-seed CANDIDATE",
+    }
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(os.path.join(DATA_DIR, "results.json"), "w") as f:
+        json.dump(results, f, indent=2)
+    note(f"dexp001 verdict: {json.dumps(results['verdict'])}")
+    print(json.dumps(results["verdict"], indent=2))
+    burn_down()
+    return results
+
+
+def smoke():
+    assert STEPS > 0 and N_TRAIN > N_VAL
+    p = derangement(N_JUDGE, seed=1234)
+    assert not (p == torch.arange(N_JUDGE)).any()
+    print("dexp001 smoke PASSED (parse; GPU run is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp001_sd15_relay/lora_r32_s0/README.md

@@ -0,0 +1,204 @@
+---
+base_model: AbstractPhil/sd15-flow-lune-json-prompt
+library_name: peft
+tags:
+- lora
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.19.1

exp001_sd15_relay/lora_r32_s0/adapter_config.json

@@ -0,0 +1,48 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "UNet2DConditionModel",
+    "parent_library": "diffusers.models.unets.unet_2d_condition"
+  },
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.19.1",
+  "qalora_group_size": 16,
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "attn2.to_q",
+    "attn2.to_out.0",
+    "attn2.to_v",
+    "attn2.to_k"
+  ],
+  "target_parameters": null,
+  "task_type": null,
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

exp001_sd15_relay/lora_r32_s0/adapter_model.safetensors

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

exp001_sd15_relay/relay_all16_s0.pt

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

exp001_sd15_relay/results.json

@@ -0,0 +1,88 @@
+{
+  "config": {
+    "steps": 3000,
+    "batch": 16,
+    "lr": 0.001,
+    "n_train": 4096,
+    "n_val": 256,
+    "seed": 0,
+    "optimizer": "torch.optim.Adam wd=0"
+  },
+  "frozen": {
+    "val": {
+      "mean": 0.5224103183136322,
+      "per_band": {
+        "band0": 0.55996,
+        "band1": 0.49406,
+        "band2": 0.43805,
+        "band3": 0.57615
+      }
+    }
+  },
+  "relay_all16": {
+    "n_params": 3227568,
+    "train": {
+      "steps": 3000,
+      "final_loss_ma50": 0.51463,
+      "s_per_step": 1.866,
+      "peak_mem_gb": 11.19
+    },
+    "val": {
+      "mean": 0.5179595574736595,
+      "per_band": {
+        "band0": 0.55319,
+        "band1": 0.49076,
+        "band2": 0.43648,
+        "band3": 0.57401
+      }
+    },
+    "val_toggled_off": {
+      "mean": 0.5224103183136322,
+      "per_band": {
+        "band0": 0.55996,
+        "band1": 0.49406,
+        "band2": 0.43805,
+        "band3": 0.57615
+      }
+    },
+    "gates": {
+      "gate_mean": 0.0432,
+      "gate_min": 0.03114,
+      "gate_max": 0.06005
+    },
+    "round_trip": {
+      "cond": 0.7614,
+      "shuffled": 0.5562,
+      "cond_minus_shuffled": 0.2052
+    }
+  },
+  "lora_r32": {
+    "n_params": 3182592,
+    "train": {
+      "steps": 3000,
+      "final_loss_ma50": 0.51787,
+      "s_per_step": 1.682,
+      "peak_mem_gb": 10.1
+    },
+    "val": {
+      "mean": 0.5250325485831127,
+      "per_band": {
+        "band0": 0.56475,
+        "band1": 0.49516,
+        "band2": 0.43908,
+        "band3": 0.57589
+      }
+    },
+    "round_trip": {
+      "cond": 0.7208,
+      "shuffled": 0.5514,
+      "cond_minus_shuffled": 0.1694
+    }
+  },
+  "verdict": {
+    "relay_beats_frozen": true,
+    "relay_vs_lora": "relay",
+    "param_ratio": 1.014,
+    "note": "prereg: relay >= lora at matched params; 1-seed CANDIDATE"
+  }
+}