diff --git a/results/REGIMES.json b/results/REGIMES.json index ebd4c4d..8929afa 100644 --- a/results/REGIMES.json +++ b/results/REGIMES.json @@ -42,9 +42,9 @@ "hidden": 5376, "workspace_band": null, "kv_share_start": "none found in config (no num_kv_shared_layers key printed \u2014 verify in scan; if truly absent, all entrances structurally live)", - "jbar": "pending (H100 pipeline v4)", - "scan": "pending", - "status": "probe passed; jbar scan running on H100 (2026-07-15 late)" + "jbar": "bucket:results-lens/jbar_31b.pt (256/256 prompts)", + "scan": "results/exp4_31b.log (regimes_31b.pt reconstructed via parse_regimes_log.py; scan's own save hit the results/-CWD bug)", + "status": "mapped 2026-07-16, PROVISIONAL: E2B-style mid-depth workspace signature ABSENT (like E4B). Persistence+content bump sits EARLY instead \u2014 L7-16 (persist 0.30-0.49 peak L14, content 0.76-0.97, sensor/motor ~0). Sensor is two-lobed: L26-40 (peak 0.17@L26) and L49-56 (~0.12). Motor essentially absent until the final layer (0.06-0.07 L50-56, 0.20@L59). Ignition cross-check (in-log): commitment pinned hard through L38, collapses to ~0 at L42-46, becomes write-responsive at L54-58 (sign flips with w>=0.5 on all three pairs). Early persist zone vs late write-responsiveness disagree \u2014 no single band supported yet; needs jbar-side analysis before any band is entered." }, "google/gemma-4-26B-A4B-it": { "revision": "01e5b3ee840d3a9e0b0b493c593e85398a30ef75", diff --git a/results/exp4_31b.log b/results/exp4_31b.log new file mode 100644 index 0000000..30b3655 --- /dev/null +++ b/results/exp4_31b.log @@ -0,0 +1,124 @@ + Loading weights: 0%| | 0/1188 [00:00 + main() + File "/workspace/jspace/scripts/exp4_regimes.py", line 137, in main + torch.save({"sensor": sensor, "motor": motor, "persist": persist, + File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 1003, in save + with _open_zipfile_writer(f) as opened_zipfile: + ^^^^^^^^^^^^^^^^^^^^^^^ + File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 865, in _open_zipfile_writer + return container(name_or_buffer) # type: ignore[arg-type] + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/venv/main/lib/python3.12/site-packages/torch/serialization.py", line 829, in __init__ + torch._C.PyTorchFileWriter( +RuntimeError: Parent directory results does not exist. diff --git a/results/regimes_31b.pt b/results/regimes_31b.pt new file mode 100644 index 0000000..ddc6b35 Binary files /dev/null and b/results/regimes_31b.pt differ diff --git a/results/regimes_all_models.png b/results/regimes_all_models.png index 370854f..833772c 100644 Binary files a/results/regimes_all_models.png and b/results/regimes_all_models.png differ diff --git a/scripts/exp4_regimes.py b/scripts/exp4_regimes.py index a0a2be9..e04008a 100644 --- a/scripts/exp4_regimes.py +++ b/scripts/exp4_regimes.py @@ -134,8 +134,21 @@ def main(): for l in range(2, len(sensor), 4): print(f"{w1}/{w2:<9} L{l:>2} | " + " ".join(f"{curves[wi, l]:+.2f}" for wi in range(5))) + if len(sys.argv) > 2: + out = Path(sys.argv[2]) + elif len(sys.argv) > 1: + # default: save next to the input jbar (that dir is what node + # sidecars sync; CWD-relative "results/" has crashed 3 scans) + ckp = Path(sys.argv[1]) + out = ckp.parent / ckp.name.replace("jbar", "regimes") + if out == ckp: + out = RES / "regimes.pt" + else: + out = RES / "regimes.pt" + out.parent.mkdir(parents=True, exist_ok=True) torch.save({"sensor": sensor, "motor": motor, "persist": persist, - "content": content, "ignition": ign}, RES / "regimes.pt") + "content": content, "ignition": ign}, out) + print("saved", out) if __name__ == "__main__": diff --git a/scripts/parse_regimes_log.py b/scripts/parse_regimes_log.py new file mode 100644 index 0000000..654d3a4 --- /dev/null +++ b/scripts/parse_regimes_log.py @@ -0,0 +1,44 @@ +"""Reconstruct regimes_*.pt from an exp4_*.log printed table (the scan's +torch.save crashes on its CWD-relative "results/" path — known bug; the +printed table is the durable artifact). Generalizes parse_e4b_regimes.py. + +Usage: parse_regimes_log.py LOG OUT [--layers N] [--note TEXT] +""" +import argparse +import re + +import torch + +ap = argparse.ArgumentParser() +ap.add_argument("log") +ap.add_argument("out") +ap.add_argument("--layers", type=int, default=None, + help="assert this many table rows were parsed") +ap.add_argument("--note", default=None, + help="provenance note stored in the tensor dict") +args = ap.parse_args() + +sensor, motor, persist, content = [], [], [], [] +pat = re.compile( + r"^L\s*(\d+) \| ([\d.]+)\s*#* *\| ([\d.]+)\s*#* *\| ([\d.]+) \| ([\d.]+)") +for line in open(args.log): + m = pat.match(line.strip()) + if m: + i, s, mo, p, c = m.groups() + assert int(i) == len(sensor), f"non-contiguous row L{i}" + sensor.append(float(s)) + motor.append(float(mo)) + persist.append(float(p)) + content.append(float(c)) +if args.layers is not None: + assert len(sensor) == args.layers, len(sensor) +note = args.note or f"reconstructed from {args.log}" +torch.save({"sensor": torch.tensor(sensor), "motor": torch.tensor(motor), + "persist": torch.tensor(persist), + "content": torch.tensor(content), "note": note}, args.out) +print(f"saved {len(sensor)} layers -> {args.out}") +print("sensor peak: L%d = %.2f" % (sensor.index(max(sensor)), max(sensor))) +print("persist peak: L%d = %.2f" % (persist.index(max(persist)), + max(persist))) +print("motor >=0.1 from: L%s" % next( + (i for i, v in enumerate(motor) if v >= 0.1), "never"))