exp000b shipped: natural-paradigm wall (format-specialization double dissociation; epred cores strong zero-shot carriers)

README.md

@@ -69,7 +69,7 @@ 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** |
-| exp000b_natural | natural-paradigm extension: nl77 arms + core epred SD15/SDXL stock-pipeline baselines | running |
+| 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 |
 | exp003_sigma_registers | sign-code separations: what is a diffusion "register"? (+prompt77 register) | running |

exp000b_natural/README.md

@@ -0,0 +1,38 @@
+# exp000b_natural — the natural-paradigm baseline extension (amendment to exp000)
+
+**Directive.** Judged work carries standard 77-token plain-English prompting
+alongside the json-225 encoding (congruency to the natural paradigm), and the
+core epred variants of SD1.5/SDXL join the wall as primary reference points.
+
+**Design.** Same judge, same 24 held-out rows, same paired derangement design
+as exp000 (which remains immutable). New arms: the Lune family conditioned on
+the NL `prompt` column via a STANDARD single 77-token CLIP encode (flow
+sampler unchanged); the stock cores via their standard pipelines (epsilon
+prediction, shipped schedulers, fp16 inference; judge features fp32).
+SDXL generates at 1024 (CLIP judge resizes to 224 — resolution asymmetry noted).
+
+**Results** (`results.json`; exp000 json-225 rows quoted for contrast):
+
+| arm | cond | shuffled | gap | contrast (exp000, json-225) |
+|---|---|---|---|---|
+| sdxl_epred_core (Euler, g=5.0) | 0.7398 | 0.5269 | **+0.2129** | — |
+| base_lune @ nl77 | 0.7540 | 0.5497 | **+0.2043** | +0.1075 on json |
+| sd15_epred_core (PNDM, g=7.5) | 0.7267 | 0.5458 | **+0.1809** | — |
+| json_ckpt2500 @ nl77 | 0.7210 | 0.5519 | **+0.1691** | +0.2099 on json |
+
+**Findings (candidate, s0, n=24).**
+1. **Conditioning-format specialization is a double dissociation**: the base
+   lune nearly doubles its grounding on natural prompts (+0.1075 → +0.2043)
+   while the json finetune loses ground there (+0.2099 → +0.1691). Training
+   format moves grounding toward the trained format and away from the other.
+2. **The core epred models are strong natural-paradigm carriers zero-shot** —
+   SDXL core tops this wall; only json_vit's in-domain +0.2504 (exp000)
+   exceeds it anywhere. Supports treating the epred cores as the primary
+   adapter substrates.
+3. Shuffled floors sit 0.53–0.56 across all arms — the derangement control is
+   stable across objectives, samplers, and resolutions.
+
+**Caveats.** n=24, single seed bank; guidance/scheduler differ across arms by
+design (each model judged under its own native regime — this wall compares
+*models in their natural operating points*, not a controlled single-knob
+sweep); SDXL resolution asymmetry as noted. GPU cost ≈ 8 minutes.

exp000b_natural/d1_exp000b_natural.py

@@ -0,0 +1,192 @@
+"""d1_exp000b_natural.py — exp000b: the NATURAL-PARADIGM baseline extension.
+
+Phil directive 2026-07-16 (post-crash wake): (1) judged work needs standard
+77-token plain-English prompting ALONGSIDE the json-225 encoding — congruency
+to the natural paradigm; (2) the CORE EPRED variants of SD1.5 and SDXL are the
+most powerful elements (Lune = an undertrained exemplar) and join the wall.
+
+Amendment to exp000 (original rows immutable on the hub). Same judge, same 24
+rows, same paired derangement design. New arms:
+  A. lune family x nl77 — plain-English `prompt` column, STANDARD single
+     77-token CLIP encode (the natural conditioning shape), same flow sampler.
+  B. sd15_epred_core — stock stable-diffusion-v1-5 via the standard
+     StableDiffusionPipeline (epsilon-pred, stock scheduler, 77-token NL) —
+     the natural paradigm itself as a baseline.
+  C. sdxl_epred_core — stock stable-diffusion-xl-base-1.0 via the standard
+     StableDiffusionXLPipeline (epred, dual encoder, 1024px; judge resizes to
+     CLIP's 224 — resolution asymmetry NOTED).
+
+Pod: bash pod2/run_exp000b.sh
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+
+sys.path[:0] = ["pod2", "."]
+
+import torch
+
+from pod_ledger import ledger_run, note
+from aleph_diffusion_core import derangement
+from d1_lune_sampler import encode_clip_225, flow_sample, decode
+
+DATASET = "AbstractPhil/synthetic-object-relations-json"
+SD_BASE = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+SDXL_BASE = "stabilityai/stable-diffusion-xl-base-1.0"
+LUNE_MODELS = [
+    ("json_ckpt2500", "AbstractPhil/sd15-flow-lune-json-prompt",
+     "checkpoint-00002500/unet"),
+    ("base_lune", "AbstractPhil/sd15-flow-lune-flux",
+     "flux_t2_6_pose_t4_6_port_t1_4/checkpoint-00018765/unet"),
+]
+N, STEPS, GUIDANCE, SEED = 24, 30, 6.0, 1234
+OUT_DIR = ("/workspace/data/dexp000b" if os.path.isdir("/workspace")
+           else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                             "dexp000b"))
+
+
+def encode_nl77(prompts, tokenizer, text_encoder, device):
+    """STANDARD single-77 CLIP encode — the natural conditioning shape."""
+    ids = tokenizer(prompts, padding="max_length",
+                    max_length=tokenizer.model_max_length, truncation=True,
+                    return_tensors="pt").input_ids.to(device)
+    return text_encoder(ids)[0]                       # [B, 77, 768]
+
+
+def load_rows(n=N):
+    from d1_exp000_baselines import load_rows as _lr
+    rows = _lr(n)
+    # exp000's loader carries json cond cols; re-read the NL `prompt` column
+    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"))
+    path = hf_hub_download(DATASET, files[-1], repo_type="dataset")
+    tbl = pq.read_table(path, columns=["prompt"])
+    nl = [r["prompt"] for r in
+          tbl.slice(max(0, tbl.num_rows - n), n).to_pylist()]
+    for r, p in zip(rows, nl):
+        r["prompt"] = p if isinstance(p, str) else json.dumps(p)
+    return rows
+
+
+def run(device="cuda"):
+    os.makedirs(OUT_DIR, exist_ok=True)
+    import numpy as np
+    from PIL import Image
+    from diffusers import (UNet2DConditionModel, AutoencoderKL,
+                           StableDiffusionPipeline, StableDiffusionXLPipeline)
+    from transformers import (CLIPTextModel, CLIPTokenizer, CLIPModel,
+                              CLIPProcessor)
+    from d1_exp000_baselines import judge_selftest
+
+    rows = load_rows()
+    nl_prompts = [r["prompt"] for r in rows]
+    perm = derangement(N, seed=SEED)
+    nl_shuffled = [nl_prompts[i] for i in perm.tolist()]
+
+    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)
+    orig = torch.cat([
+        feat(Image.open(io.BytesIO(r["image_bytes"])).convert("RGB"))
+        for r in rows])
+
+    def cos_of(pils, sl):
+        f = torch.cat([feat(p) for p in pils])
+        return (f * orig[sl]).sum(-1).tolist()
+
+    results = {"n": N, "seed": SEED, "amendment_of": "exp000_baselines",
+               "models": {}}
+
+    # A. lune family, nl77 arms (natural prompt, standard encode, flow sampler)
+    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()
+    with torch.no_grad():
+        ehs_c = encode_nl77(nl_prompts, tok, te, device)
+        ehs_s = encode_nl77(nl_shuffled, tok, te, device)
+    for label, repo, sub in LUNE_MODELS:
+        with ledger_run(f"dexp000b {label} nl77", budget_h=0.5) as h:
+            unet = UNet2DConditionModel.from_pretrained(
+                repo, subfolder=sub, torch_dtype=torch.float16).to(device)
+            unet.eval()
+            arms = {}
+            for arm, ehs in (("cond", ehs_c), ("shuffled", ehs_s)):
+                cos = []
+                for i in range(0, N, 6):
+                    lat = flow_sample(unet, ehs[i:i + 6].half(),
+                                      n_steps=STEPS, guidance=GUIDANCE,
+                                      seed=SEED + i, device=device)
+                    imgs = decode(vae, lat.float())
+                    pil = [Image.fromarray((im * 255).astype(np.uint8))
+                           for im in imgs]
+                    cos += cos_of(pil, slice(i, i + len(pil)))
+                arms[arm] = round(sum(cos) / len(cos), 4)
+            gap = round(arms["cond"] - arms["shuffled"], 4)
+            results["models"][f"{label}_nl77"] = {**arms,
+                                                  "cond_minus_shuffled": gap}
+            h["verdict"] = f"nl77 gap {gap:+.4f}"
+            del unet
+            torch.cuda.empty_cache()
+
+    # B/C. the CORE EPRED baselines via standard pipelines (the paradigm)
+    def pipe_arm(label, mk_pipe, size):
+        with ledger_run(f"dexp000b {label}", budget_h=0.7) as h:
+            pipe = mk_pipe()
+            arms = {}
+            for arm, ps in (("cond", nl_prompts), ("shuffled", nl_shuffled)):
+                cos = []
+                for i in range(0, N, 4):
+                    g = torch.Generator(device=device).manual_seed(SEED + i)
+                    out = pipe(ps[i:i + 4], num_inference_steps=STEPS,
+                               generator=g, height=size, width=size)
+                    cos += cos_of(out.images, slice(i, i + len(out.images)))
+                arms[arm] = round(sum(cos) / len(cos), 4)
+            gap = round(arms["cond"] - arms["shuffled"], 4)
+            results["models"][label] = {
+                **arms, "cond_minus_shuffled": gap,
+                "scheduler": type(pipe.scheduler).__name__,
+                "guidance": pipe._guidance_scale
+                if hasattr(pipe, "_guidance_scale") else "default"}
+            h["verdict"] = f"gap {gap:+.4f}"
+            del pipe
+            torch.cuda.empty_cache()
+
+    pipe_arm("sd15_epred_core",
+             lambda: StableDiffusionPipeline.from_pretrained(
+                 SD_BASE, torch_dtype=torch.float16,
+                 safety_checker=None).to(device), 512)
+    pipe_arm("sdxl_epred_core",
+             lambda: StableDiffusionXLPipeline.from_pretrained(
+                 SDXL_BASE, torch_dtype=torch.float16,
+                 variant="fp16").to(device), 1024)
+
+    with open(os.path.join(OUT_DIR, "results.json"), "w") as f:
+        json.dump(results, f, indent=2)
+    note("dexp000b: " + json.dumps(
+        {k: v["cond_minus_shuffled"] for k, v in results["models"].items()}))
+    print(json.dumps(results, indent=2))
+    return results
+
+
+def smoke():
+    p = derangement(N, seed=SEED)
+    assert not (p == torch.arange(N)).any()
+    print("dexp000b smoke PASSED (parse; GPU run is pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp000b_natural/results.json

@@ -0,0 +1,31 @@
+{
+  "n": 24,
+  "seed": 1234,
+  "amendment_of": "exp000_baselines",
+  "models": {
+    "json_ckpt2500_nl77": {
+      "cond": 0.721,
+      "shuffled": 0.5519,
+      "cond_minus_shuffled": 0.1691
+    },
+    "base_lune_nl77": {
+      "cond": 0.754,
+      "shuffled": 0.5497,
+      "cond_minus_shuffled": 0.2043
+    },
+    "sd15_epred_core": {
+      "cond": 0.7267,
+      "shuffled": 0.5458,
+      "cond_minus_shuffled": 0.1809,
+      "scheduler": "PNDMScheduler",
+      "guidance": 7.5
+    },
+    "sdxl_epred_core": {
+      "cond": 0.7398,
+      "shuffled": 0.5269,
+      "cond_minus_shuffled": 0.2129,
+      "scheduler": "EulerDiscreteScheduler",
+      "guidance": 5.0
+    }
+  }
+}