File size: 5,684 Bytes
f12bc67 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | """Held-out intervals are actually held out, and the guard is not decorative.
Before this, every motherboard episode was `split: train` — the release had no
held-out data at all, and the probe set's start frames were training frames.
The failure this guards against leaves no trace. A training window starting
shortly before a held-out interval still contains its frames; the metric just
comes out better and nothing says why. So the checks below enumerate ACTUAL
window starts rather than reasoning about the intervals.
python scripts/test_splits.py
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
from react_paths import release_root # noqa: E402
import numpy as np # noqa: E402
RESULTS: list[tuple[bool, str, str]] = []
REL = release_root("motherboard")
def check(ok: bool, name: str, evidence: str) -> None:
RESULTS.append((bool(ok), name, evidence))
def main() -> int:
from twm.splits import (assert_window_fits, build_splits, forbidden_starts,
test_starts)
eps = [json.loads(l) for l in (REL / "episodes.jsonl").read_text().splitlines() if l.strip()]
bad = json.loads((REL / "bad_frames.json").read_text())["episodes"]
S = build_splits(eps, bad, seed=0)
W = S["max_train_window"]
# 1 — NO TRAIN WINDOW TOUCHES A TEST FRAME. Enumerated, not argued.
leaks, n_win = [], 0
for e in eps:
key, N = e["episode"], e["n_frames"]
info = S["episodes"][key]
test = np.zeros(N, bool)
for a, b in info["test"]:
test[a:b + 1] = True
forb = forbidden_starts(S, key, W)
for s in range(0, N - W + 1):
if any(lo <= s <= hi for lo, hi in forb):
continue
n_win += 1
if test[s:s + W].any():
leaks.append(f"{key}: window at {s}")
if len(leaks) > 3:
break
check(not leaks, "no admissible train window contains a held-out frame",
f"{n_win} train windows of {W} frames enumerated across "
f"{len(eps)} episodes, 0 touch a test interval"
+ (f"; leaks {leaks[:3]}" if leaks else ""))
# 2 — AND THE GUARD IS LOAD-BEARING. Shrinking it to the interval alone
# must produce leaks, or the guard was never doing anything.
naive = []
for e in eps[:6]:
key, N = e["episode"], e["n_frames"]
info = S["episodes"][key]
if info["whole"]:
continue
test = np.zeros(N, bool)
for a, b in info["test"]:
test[a:b + 1] = True
for s in range(0, N - W + 1):
if any(a <= s <= b for a, b in info["test"]): # interval only
continue
if test[s:s + W].any():
naive.append(s)
check(len(naive) > 0, "the guard is load-bearing, not decorative",
f"excluding only the intervals (no guard) leaks {len(naive)} windows "
f"in the first 6 episodes; with the guard it is 0")
# 3 — a too-long window is REFUSED, not silently allowed
try:
assert_window_fits(S, S["guard_frames"] + 2)
raised = False
except ValueError:
raised = True
ok_small = True
try:
assert_window_fits(S, W)
except ValueError:
ok_small = False
check(raised and ok_small, "a window longer than the guard is refused",
f"span {W} accepted, span {S['guard_frames']+2} raises")
# 4 — deterministic, and it moves when the seed does
a = build_splits(eps, bad, seed=0)
b = build_splits(eps, bad, seed=1)
same = a["episodes"] == S["episodes"]
diff = sum(1 for k in a["episodes"]
if a["episodes"][k]["test"] != b["episodes"][k]["test"])
check(same and diff > len(eps) // 2,
"the split is reproducible and seed-dependent",
f"seed 0 reproduces exactly; seed 1 moves {diff}/{len(eps)} episodes")
# 5 — no test interval sits on known-bad frames
onbad = []
for e in eps:
key, N = e["episode"], e["n_frames"]
if S["episodes"][key]["whole"]:
continue
m = np.zeros(N, bool)
for k in ("intensity_spikes", "pose_teleports_L", "pose_teleports_R",
"ot_loss_L", "ot_loss_R"):
for x, y in bad.get(key, {}).get(k, []):
m[max(0, x):min(N, y + 1)] = True
for x, y in S["episodes"][key]["test"]:
if m[x:y + 1].any():
onbad.append(f"{key}[{x},{y}]")
check(not onbad, "held-out intervals avoid known-bad frames",
f"{S['stats']['n_test_intervals']} intervals, none on flagged "
f"dropouts" + (f"; {onbad[:2]}" if onbad else ""))
# 6 — the numbers the docstring quotes are the numbers it produces
st = S["stats"]
check(0.10 <= st["test_fraction"] <= 0.15 and st["n_test_intervals"] > 100,
"the split holds out a usable fraction",
f"test {st['test_fraction']*100:.1f}% guard "
f"{st['guard_fraction']*100:.1f}% train "
f"{(1-st['test_fraction']-st['guard_fraction'])*100:.1f}% over "
f"{st['n_test_intervals']} intervals + {st['n_whole_test_episodes']} "
f"whole episodes")
w = max(len(x) for _, x, _ in RESULTS)
print()
for ok, name, ev in RESULTS:
print(f" [{'ok' if ok else 'FAIL'}] {name:<{w}} {ev}")
n = sum(not ok for ok, _, _ in RESULTS)
print(f"\nsplits: {len(RESULTS)} checks, {n} failing")
return 1 if n else 0
if __name__ == "__main__":
raise SystemExit(main())
|