exp002 shipped: guidepost-with-a-pulse (address inert beside text, live alone +0.0287; redesign = complementarity)

README.md

@@ -71,7 +71,7 @@ resolution) so gaps live in a narrow band — the paired design is load-bearing.
 | exp000_baselines | zero-shot baseline wall (above) | **shipped** |
 | exp000b_natural | natural-paradigm wall: format specialization is a double dissociation; SDXL core tops the NL wall | **shipped (candidate, s0)** |
 | 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 |
+| exp002_sd15_addrcond | addr-cond 4-arm causal: **GUIDEPOST with a pulse** — inert beside full text (real≈deranged), but the address ALONE steers (+0.029); redesign = complementarity | **shipped (candidate, s0)** |
 | 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 |

exp002_sd15_addrcond/README.md

@@ -0,0 +1,45 @@
+# exp002_sd15_addrcond — the frozen aleph address in the cond stream (CANDIDATE, s0)
+
+**Question.** Does the canonical byte-trigram aleph address (caption →
+byte-trigram render → frozen `geolip-aleph-void`, `aleph_byte_trigram_tied_
+hard_K64`, logits mean-pooled → [32,128] — the exact sdxl-qwen-phase0 recipe)
+carry usable scene information into the SD15-Lune predictive path?
+
+**Design.** AlephCondAdapter(768): 32 extra cond positions appended after the
+227-token json encoding; everything zero-init (exact-zero tokens at init);
+toggle = LENGTH (the masked-append path measured non-bit-exact in the substrate
+gates, 9.03e-04 — fallback adopted, never silent). Trained 2000 steps (adapter
+only: proj + pos table + gate; pure Adam wd=0; CFG dropout zeroes text+addr
+TOGETHER per the sdxl-aleph precedent). Judged post-train on exp000's exact 24
+rows, paired seeds, 4 address arms at fixed real-text cond, plus an
+address-only pair at zeroed text.
+
+**Results** (`results.json`):
+
+| gauge | value | reading |
+|---|---|---|
+| presence offset (zero-tokens vs no-append, at init) | −0.0001 val-MSE | appended exact-zeros are free |
+| real − deranged (text present) | **−0.0009** | address adds nothing beyond the text |
+| real − no_append (text present) | −0.0068 | appending ≈ neutral-to-slightly-worse |
+| noise − deranged | −0.0086 | specificity control behaves |
+| **addr-only: real − noise (text ZEROED)** | **+0.0287** | the address ALONE steers the UNet |
+| gate trajectory | 0.047 → 0.0597 (grew) | trunk opted in |
+| val flow-MSE (trained, appended) | 0.5211 vs 0.5224 no-append | mild improvement |
+
+**Verdict (preregistered): GUIDEPOST — with a pulse.** The prereg honest-
+negative fires: in the presence of full json text, the appended address is
+marginally inert (real ≈ deranged), so scaling this configuration is not
+justified. But the address-only channel is live (+0.0287 over a noise-address
+floor after just 2k adapter steps), the gate grew, and val improved — the
+address is *redundant in context*, not dead. Redesign target =
+**complementarity**: inject the address where the text is not (reduced-text
+regimes, σ-gated injection per exp003's sigma-register finding, or a stream
+the text encoding doesn't reach) rather than alongside a text encoding of the
+same caption.
+
+**Consistency note.** This is the adapter-scale echo of the SDXL-aleph
+Phase-1 reading (projection weight statistically > 0, formation unproven) —
+now with a causal 4-arm control behind it.
+
+**Caveats.** Single seed; n=24 judged rows; 2k steps; one injection site
+(cond append). Cost ≈ 1.0 GPU-h. Checkpoint: `addrcond_s0.pt`.

exp002_sd15_addrcond/addrcond_s0.pt

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

exp002_sd15_addrcond/dexp002_sd15_addrcond.py

@@ -0,0 +1,345 @@
+"""dexp002_sd15_addrcond.py — exp002: the frozen aleph address into the SD15
+cond stream (Tier A), 4-arm causal control.
+
+Address = THE CANONICAL RECIPE (repos/geolip-sd-trainer.md, verified in
+geolip_sd_trainer/data/aleph.py): caption -> byte-trigram render -> frozen
+AbstractPhil/geolip-aleph-void (aleph_byte_trigram_tied_hard_K64) ->
+aleph_logits mean over patches -> [32,128] in [-1,1]. Same recipe as
+sdxl-qwen-phase0's aleph_address column — comparable by construction.
+
+Adapter: AlephCondAdapter(768) — 32 extra cond positions appended after
+encode_clip_225's 227; everything zero-init => exact-zero tokens at init.
+TOGGLE = LENGTH (G5 verdict: encoder_attention_mask not bit-exact, 9.03e-04);
+the PRESENCE OFFSET (append-exact-zeros vs no-append) is MEASURED at init on
+paired val-MSE and ledgered — never silent.
+
+Training: adapter params only (addr_proj + pos_table + gate), pure Adam wd=0,
+trainer-verbatim flow objective; CFG dropout zeroes TEXT AND ADDR TOGETHER
+(the sdxl-aleph precedent, so CFG stays clean at judge time).
+
+Judged arms (post-train, text cond FIXED real, paired seeds, n=24 exp000 rows):
+  addr_real / addr_deranged / addr_noise / no_append  -> round-trip CLIP-L.
+  Plus the addr-only pair: text ZEROED, {addr_real vs addr_noise} — what the
+  address alone carries.
+Prereg (charter): real-vs-deranged gap > 0; real vs no_append positive;
+noise ~ deranged (specificity). Honest negative: real ~ no_append =>
+guidepost verdict — redesign before scale (Law 2 pressure point: the text
+cond already parameterizes the scene; the address must add marginal signal).
+
+Pod: bash pod2/run_exp002.sh   (installs geolip-svae if missing)
+"""
+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 AlephCondAdapter, derangement
+from d1_lune_sampler import encode_clip_225, flow_sample, decode
+from d1_substrate import 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, SEED = 0.18215, 2.5, 0
+N_TRAIN, N_VAL, N_JUDGE = 4096, 256, 24
+BATCH, LR, CFG_DROPOUT = 16, 1e-3, 0.1
+STEPS = int(os.environ.get("DEXP2_STEPS", "2000"))
+DATA_DIR = ("/workspace/data/dexp002" if os.path.isdir("/workspace")
+            else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                              "dexp002"))
+DEXP1_DIR = ("/workspace/data/dexp001" if os.path.isdir("/workspace")
+             else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                               "dexp001"))
+CKPT_DIR = ("/workspace/ckpts2/dexp002" if os.path.isdir("/workspace")
+            else DATA_DIR)
+
+
+# ── the canonical address encoder (copy semantics; repo not edited) ─────────
+
+class Addr:
+    def __init__(self, device="cuda"):
+        from geolip_svae import load_model
+        self.model, self.mcfg = load_model(
+            hf_version="aleph_byte_trigram_tied_hard_K64",
+            repo_id="AbstractPhil/geolip-aleph-void", device=device)
+        self.model.eval()
+        self.model.requires_grad_(False)
+        self.device = device
+        self._pdtype = next(self.model.parameters()).dtype
+        g = self.mcfg if isinstance(self.mcfg, dict) else {}
+        self.patch_size = int(getattr(self.model, "patch_size",
+                                      g.get("patch_size", 2)))
+        self.channels = int(getattr(self.model, "channels",
+                                    g.get("channels", 3)))
+        self.img_size = int(g.get("img_size", 64))
+
+    @torch.no_grad()
+    def encode(self, captions, bs=64):
+        from geolip_svae.inference.text import text_to_image
+        outs = []
+        for i in range(0, len(captions), bs):
+            imgs = torch.stack([
+                text_to_image(c, self.img_size, self.patch_size, "space",
+                              self.channels)
+                for c in captions[i:i + bs]]).to(self.device, self._pdtype)
+            svd = self.model(imgs)["svd"]
+            outs.append(svd["aleph_logits"].mean(dim=1).float().cpu())
+        return torch.cat(outs)                     # (B, 32, 128) in [-1,1]
+
+
+def _iter_prompts(need):
+    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")
+        for r in pq.read_table(path, columns=["json_prompt"]).to_pylist():
+            jp = r["json_prompt"]
+            yield jp if isinstance(jp, str) else json.dumps(jp)
+            got += 1
+            if got >= need:
+                return
+
+
+def build_addr_cache(device):
+    f = os.path.join(DATA_DIR, "addr.pt")
+    if os.path.exists(f):
+        print(f"[addr] exists: {f}")
+        return f
+    os.makedirs(DATA_DIR, exist_ok=True)
+    enc = Addr(device)
+    prompts = list(_iter_prompts(N_TRAIN + N_VAL))
+    addr = enc.encode(prompts)
+    assert addr.shape == (N_TRAIN + N_VAL, 32, 128), addr.shape
+    torch.save({"addr": addr[:N_TRAIN], "val_addr": addr[N_TRAIN:]}, f)
+    print(f"[addr] built {f}: {addr.shape}, range "
+          f"[{addr.min():.3f},{addr.max():.3f}]", flush=True)
+    del enc
+    torch.cuda.empty_cache()
+    return f
+
+
+# ── objective (trainer-verbatim; text+addr dropped TOGETHER) ────────────────
+
+def flow_loss(unet, adapter, lat, ehs, addr, gen, device):
+    bsz = lat.shape[0]
+    tokens = adapter.tokens(addr)                       # (B, 32, 768), grads
+    cond = torch.cat([ehs, tokens], dim=1)              # (B, 259, 768)
+    drop = torch.rand(bsz, generator=gen, device=device) < CFG_DROPOUT
+    cond = cond * (~drop)[:, None, None]                # text+addr together
+    s = torch.rand(bsz, generator=gen, device=device)
+    s = (SHIFT * s) / (1 + (SHIFT - 1) * s)
+    s4 = s[:, None, None, None]
+    noise = torch.randn(lat.shape, generator=gen, device=device)
+    pred = unet(noise * s4 + lat * (1 - s4), s * 1000, cond,
+                return_dict=False)[0]
+    return F.mse_loss(pred, noise - lat)
+
+
+@torch.no_grad()
+def val_mse(unet, cache, cond_fn, device):
+    tot = []
+    for i in range(0, N_VAL, 32):
+        lat = cache["val_lat"][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]
+        cond = cond_fn(i)
+        pred = unet(noise * s4 + lat * (1 - s4), s * 1000, cond,
+                    return_dict=False)[0]
+        tot += ((pred - (noise - lat)) ** 2).mean(dim=(1, 2, 3)).tolist()
+    return sum(tot) / len(tot)
+
+
+def run(device="cuda"):
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    os.makedirs(CKPT_DIR, exist_ok=True)
+    import numpy as np
+    from PIL import Image
+    from diffusers import UNet2DConditionModel, AutoencoderKL
+    from transformers import (CLIPTextModel, CLIPTokenizer, CLIPModel,
+                              CLIPProcessor)
+
+    with ledger_run("dexp002 addr cache", budget_h=0.5):
+        build_addr_cache(device)
+    assert os.path.exists(os.path.join(DEXP1_DIR, "cache.pt")), \
+        "dexp001 latent cache required (shared rows) — run dexp001 first"
+    cache = torch.load(os.path.join(DEXP1_DIR, "cache.pt"),
+                       map_location="cpu", weights_only=True)
+    ac = torch.load(os.path.join(DATA_DIR, "addr.pt"), map_location="cpu",
+                    weights_only=True)
+
+    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()
+    adapter = AlephCondAdapter(768).to(device).float()
+    adapter.assert_zero_init()
+
+    # presence-offset gauge at init (G5 fallback, MEASURED never silent)
+    def cond_plain(i):
+        return cache["val_ehs"][i:i + 32].to(device)
+
+    def cond_append(i):
+        e = cache["val_ehs"][i:i + 32].to(device)
+        a = ac["val_addr"][i:i + 32].to(device)
+        return torch.cat([e, adapter.tokens(a)], dim=1)
+
+    results = {"config": {"steps": STEPS, "batch": BATCH, "lr": LR,
+                          "seed": SEED, "recipe":
+                          "aleph_byte_trigram_tied_hard_K64 logits mean"}}
+    with ledger_run("dexp002 presence offset", budget_h=0.2) as h:
+        v_plain = val_mse(unet, cache, cond_plain, device)
+        v_zeros = val_mse(unet, cache, cond_append, device)
+        results["presence_offset"] = {
+            "val_no_append": round(v_plain, 6),
+            "val_append_zero_tokens": round(v_zeros, 6),
+            "delta": round(v_zeros - v_plain, 6)}
+        h["verdict"] = f"offset {v_zeros - v_plain:+.6f}"
+
+    # train the adapter
+    with ledger_run("dexp002 addr-cond train s0", budget_h=1.5) as h:
+        gen = torch.Generator(device=device).manual_seed(SEED + 42)
+        idx_gen = torch.Generator().manual_seed(SEED + 7)
+        params = list(adapter.parameters())
+        opt = torch.optim.Adam(params, lr=LR, weight_decay=0.0)
+        adapter.train()
+        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_gen)
+            loss = flow_loss(unet, adapter, cache["lat"][sel].to(device),
+                             cache["ehs"][sel].to(device),
+                             ac["addr"][sel].to(device), gen, device)
+            loss.backward()
+            opt.step()
+            opt.zero_grad(set_to_none=True)
+            if step == 50 or step % 500 == 0:
+                print(f"[addrcond] step {step}: loss {loss.item():.4f} | "
+                      f"{(time.time() - t0) / step:.2f}s/step | gate "
+                      f"{torch.sigmoid(adapter.gate).item():.4f} | peak "
+                      f"{torch.cuda.max_memory_allocated() / 2**30:.1f}GB",
+                      flush=True)
+        adapter.eval()
+        torch.save(adapter.state_dict(),
+                   os.path.join(CKPT_DIR, "addrcond_s0.pt"))
+        results["train"] = {
+            "s_per_step": round((time.time() - t0) / STEPS, 3),
+            "gate_final": round(torch.sigmoid(adapter.gate).item(), 5),
+            "pos_table_norm": round(adapter.pos_table.norm().item(), 4),
+            "proj_w_norm": round(adapter.addr_proj.weight.norm().item(), 4)}
+        results["val_trained_append"] = round(
+            val_mse(unet, cache, cond_append, device), 6)
+        h["verdict"] = f"gate {results['train']['gate_final']}"
+
+    # judged arms (round-trip on the exp000 rows)
+    with ledger_run("dexp002 judged arms", budget_h=0.8) as h:
+        from d1_exp000_baselines import load_rows, judge_selftest
+        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]
+        with torch.no_grad():
+            ehs = encode_clip_225(prompts, tok, te, device)
+        enc = Addr(device)
+        addr_real = enc.encode(prompts).to(device)
+        del enc
+        torch.cuda.empty_cache()
+        perm = derangement(N_JUDGE, seed=1234)
+        gn = torch.Generator().manual_seed(SEED + 5)
+        addr_arms = {
+            "addr_real": addr_real,
+            "addr_deranged": addr_real[perm.to(addr_real.device)],
+            "addr_noise": (torch.rand(addr_real.shape, generator=gn) * 2
+                           - 1).to(device),
+            "no_append": None,
+        }
+        orig = torch.cat([
+            feat(Image.open(io.BytesIO(r["image_bytes"])).convert("RGB"))
+            for r in rows])
+
+        @torch.no_grad()
+        def judge(text_cond, addr):
+            if addr is None:
+                cond = text_cond
+            else:
+                cond = torch.cat([text_cond, adapter.tokens(addr)], dim=1)
+            cos = []
+            for i in range(0, N_JUDGE, 6):
+                latg = flow_sample(unet, cond[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]
+                fs = torch.cat([feat(p) for p in pil])
+                cos += (fs * orig[i:i + 6]).sum(-1).tolist()
+            return round(sum(cos) / len(cos), 4)
+
+        arms = {k: judge(ehs, a) for k, a in addr_arms.items()}
+        zero_text = torch.zeros_like(ehs)
+        addr_only = {"real": judge(zero_text, addr_real),
+                     "noise": judge(zero_text, addr_arms["addr_noise"])}
+        results["arms"] = arms
+        results["addr_only_text_zeroed"] = addr_only
+        results["verdict"] = {
+            "real_minus_deranged": round(arms["addr_real"]
+                                         - arms["addr_deranged"], 4),
+            "real_minus_no_append": round(arms["addr_real"]
+                                          - arms["no_append"], 4),
+            "noise_vs_deranged": round(arms["addr_noise"]
+                                       - arms["addr_deranged"], 4),
+            "addr_only_real_minus_noise": round(addr_only["real"]
+                                                - addr_only["noise"], 4),
+            "note": "prereg: real>deranged, real>no_append, noise~deranged; "
+                    "real~no_append => guidepost. 1-seed CANDIDATE.",
+        }
+        h["verdict"] = json.dumps(results["verdict"])
+
+    with open(os.path.join(DATA_DIR, "results.json"), "w") as f:
+        json.dump(results, f, indent=2)
+    note(f"dexp002: {json.dumps(results['verdict'])}")
+    print(json.dumps(results, indent=2))
+    burn_down()
+    return results
+
+
+def smoke():
+    a = AlephCondAdapter(768)
+    a.assert_zero_init()
+    x = torch.randn(2, 32, 128)
+    assert a.tokens(x).abs().max().item() == 0.0
+    p = derangement(N_JUDGE, seed=1234)
+    assert not (p == torch.arange(N_JUDGE)).any()
+    print("dexp002 smoke PASSED (parse + adapter zeros; GPU run is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp002_sd15_addrcond/results.json

@@ -0,0 +1,38 @@
+{
+  "config": {
+    "steps": 2000,
+    "batch": 16,
+    "lr": 0.001,
+    "seed": 0,
+    "recipe": "aleph_byte_trigram_tied_hard_K64 logits mean"
+  },
+  "presence_offset": {
+    "val_no_append": 0.52241,
+    "val_append_zero_tokens": 0.52229,
+    "delta": -0.000121
+  },
+  "train": {
+    "s_per_step": 1.661,
+    "gate_final": 0.05971,
+    "pos_table_norm": 33.2072,
+    "proj_w_norm": 32.5641
+  },
+  "val_trained_append": 0.521105,
+  "arms": {
+    "addr_real": 0.747,
+    "addr_deranged": 0.7479,
+    "addr_noise": 0.7393,
+    "no_append": 0.7538
+  },
+  "addr_only_text_zeroed": {
+    "real": 0.5706,
+    "noise": 0.5419
+  },
+  "verdict": {
+    "real_minus_deranged": -0.0009,
+    "real_minus_no_append": -0.0068,
+    "noise_vs_deranged": -0.0086,
+    "addr_only_real_minus_noise": 0.0287,
+    "note": "prereg: real>deranged, real>no_append, noise~deranged; real~no_append => guidepost. 1-seed CANDIDATE."
+  }
+}