File size: 4,621 Bytes
e488ce7 | 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 | #!/usr/bin/env python3
"""Unit test for H3 True Clock's density-corrected RoPE t-grid.
python tests/test_true_clock.py
Synthetic, no GPU, no files, no comfy. Checks the four properties the
corrected grid has to have to be telling the model the truth:
1. WORLD DURATION: the per-token spans sum to
len(holds) * 5/3 RoPE units, i.e. the clip occupies its world
duration and not its dilated one — including the 17k+5 snap tail,
whose padding frames are extra copies of the LAST world frame and
so cost no extra world time,
2. MONOTONE: the t-grid (exclusive cumsum) is non-decreasing, in fact
strictly increasing — no frame ever goes backwards in time,
3. IDENTITY: holds all 1 reproduces the stock grid
5/3 * (1,4,4,4,4) exactly, so the node is a no-op when nothing was
dilated (default-off in the truest sense),
4. TAIL: the snap pad is folded into the last hold and the resulting
map is what H3TimeSmear itself would have used.
Exit code 0 = pass.
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(HERE))
import importlib.util
spec = importlib.util.spec_from_file_location(
"mainodes_motion", os.path.join(os.path.dirname(HERE), "motion.py"))
motion = importlib.util.module_from_spec(spec)
spec.loader.exec_module(motion)
R = motion.ROPE_UNITS_PER_FRAME
FAILS = []
def check(name, ok, detail):
print((" PASS " if ok else " FAIL ") + name + " " + detail)
if not ok:
FAILS.append(name)
def stock_spans(t_lat):
return [R * (1, 4, 4, 4, 4)[k % 5] for k in range(t_lat)]
CASES = [
("uniform x4, 39 world frames", [4] * 39),
("uniform x4, 61 world frames (pads)", [4] * 61),
("uniform x2, 243 world frames", [2] * 243),
("heal243 shape: holds 4 on 132-150", [4 if 132 <= f <= 150 else 1
for f in range(243)]),
("ramped map, mixed 1/2/3/4", [1, 1, 2, 3, 4, 4, 4, 3, 2, 1] * 9),
("single hot frame", [1] * 100 + [8] + [1] * 41),
]
print("1) world duration: sum(spans) == world_frames * 5/3")
for name, holds in CASES:
spans = motion.true_clock_spans(holds)
want = len(holds) * R
got = sum(spans)
check(name, abs(got - want) < 1e-9,
"sum={:.9f} want={:.9f} (world={} dilated={} tokens={})".format(
got, want, len(holds), sum(motion._snap_holds(holds)), len(spans)))
print("2) monotone: t-grid non-decreasing (and strictly increasing)")
for name, holds in CASES:
g = motion.true_clock_grid(holds)
d = [b - a for a, b in zip(g, g[1:])]
check(name, min(d) > 0, "origin={:.6f} min step={:.6f} max step={:.6f}".format(
g[0], min(d), max(d)))
print("3) identity: holds all-1 reproduces the stock grid")
for length in (39, 141, 243):
spans = motion.true_clock_spans([1] * length)
want = stock_spans((length - 5) // 17 * 5 + 2)
check("length {}".format(length), spans == want,
"tokens={} first5={} stock_first5={}".format(
len(spans), [round(s, 6) for s in spans[:5]],
[round(s, 6) for s in want[:5]]))
print("4) snap tail: pad folded into the last hold, sums land on 17k+5")
for name, holds in CASES:
snapped = motion._snap_holds(holds)
L = sum(snapped)
legal = (L - 5) % 17 == 0 and L >= 39
pad = L - sum(holds)
same_head = snapped[:-1] == [int(h) for h in holds[:-1]]
idem = motion._snap_holds(snapped) == snapped
check(name, legal and same_head and idem,
"dilated={} pad={} last_hold {}->{} idempotent={}".format(
L, pad, holds[-1], snapped[-1], idem))
print("5) tail time accounting: last world frame gets exactly 5/3 units")
holds = [4] * 61 # 244 -> snaps to 260, pad 16 in hold[-1]
snapped = motion._snap_holds(holds)
spans = motion.true_clock_spans(holds)
tail_frames = snapped[-1]
check("uniform x4, 61 frames", abs(sum(spans) - 61 * R) < 1e-9,
"last hold={} (4 real + {} pad), total={:.9f} == 61*5/3={:.9f}".format(
tail_frames, tail_frames - 4, sum(spans), 61 * R))
print("6) sanity: dilated clip is SHORTER on the RoPE axis than stock")
holds = [4] * 61
spans = motion.true_clock_spans(holds)
stock = sum(stock_spans(len(spans)))
check("uniform x4, 61 frames", sum(spans) < stock,
"true={:.4f} stock={:.4f} ratio={:.4f} (expect ~1/4)".format(
sum(spans), stock, sum(spans) / stock))
print()
if FAILS:
print("FAILED: " + ", ".join(FAILS))
sys.exit(1)
print("all true-clock checks passed")
|