simcheongi / tests /test_package.py
koreashin's picture
코드 추가: 추론·학습·LoRA 어댑터 (simcheongi 패키지, 문서, 예제, 시험)
025ab09 verified
Raw History Blame Contribute Delete
12.6 kB
#!/usr/bin/env python
"""CPU self-tests of the package with a TINY randomly initialised model (no download; ~1-3 min on CPU).
python tests/test_package.py (or: pytest -q tests/test_package.py)
1 save_pretrained -> load_model round trip: identical tensors and identical plans
2 loss decreases when over-fitting 2 fixed batches (12 AdamW steps)
3 LoRA: adapter at init == base output bit for bit; only 'lora.*' parameters train (base tensors unchanged);
save_adapter -> load_adapter reproduces the trained output; merge() == adapter output (fp32 rounding) and the merged
model has exactly the base keys
4 geometry: route_ahead / command rules / ego history on a straight and a curved route
5 data: make_fake_dataset -> BCDataset item shapes, policy.plan on raw inputs
6 RequestBuilder input rules (model-free): any increasing clock (epoch seconds, negative origin) gives the same
arrays, a clock relative to now raises, wrapped yaw == unwrapped yaw, a route that starts far behind the robot warns
and still gives the route ahead of the robot, a short moving history warns, train / eval hash splits agree
"""
import copy
import json
import math
import os
import sys
import tempfile
import warnings
import numpy as np
import torch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from simcheongi import configs as C # noqa: E402
from simcheongi import data as Dt # noqa: E402
from simcheongi import geometry as G # noqa: E402
from simcheongi import hub, lora # noqa: E402
from simcheongi import losses as LS # noqa: E402
from simcheongi import model as M # noqa: E402
from simcheongi.car_mode import CarStudent # noqa: E402
from simcheongi.policy import RequestBuilder, SimcheongiPolicy # noqa: E402
torch.set_num_threads(min(8, os.cpu_count() or 1))
TMP = tempfile.mkdtemp(prefix="simcheongi_test_")
def tiny_dir():
d = os.path.join(TMP, "tiny_model")
if not os.path.exists(os.path.join(d, "model.safetensors")):
torch.manual_seed(0)
cfg = C.tiny("M100")
m = CarStudent(cfg)
with torch.no_grad(): # non-zero adaLN so the planner reads the scene
for pl in m.planner.layers:
pl.adaln_modulation[1].weight.normal_(0, 0.02)
base = {"format": hub.FORMAT, "name": "tiny-test"}
hub.save_pretrained(m, d, base)
return d
def plan_of(model, b, seed=7):
with torch.no_grad():
sc = model.scene(b, route_mode="route")
noise = torch.randn(b["cur"].shape[0], C.N_FUT, 3, generator=torch.Generator().manual_seed(seed))
return model.sample(sc, b, noise=noise)
def test_roundtrip():
d = tiny_dir()
m1 = hub.load_model(d)
d2 = os.path.join(TMP, "tiny_model_copy")
hub.save_pretrained(m1, d2)
m2 = hub.load_model(d2)
s1, s2 = m1.state_dict(), m2.state_dict()
assert sorted(s1) == sorted(s2) and all(torch.equal(s1[k], s2[k]) for k in s1)
b = Dt.fake_batch(2, seed=1)
assert torch.equal(plan_of(m1, b), plan_of(m2, b))
assert hub.sha256_file(os.path.join(d, "model.safetensors")) == hub.sha256_file(os.path.join(d2, "model.safetensors"))
def test_loss_decreases():
M.set_matmul_precision()
torch.manual_seed(0)
m = hub.load_model(tiny_dir(), eval_mode=False)
m.train()
batches = [Dt.fake_batch(2, seed=s) for s in (3, 4)]
before = np.mean([LS.fixed_loss(m, b) for b in batches])
opt = torch.optim.AdamW([p for p in m.parameters() if p.requires_grad], lr=3e-4)
for i in range(12):
loss, _ = LS.compute_loss(m, batches[i % 2])
opt.zero_grad()
loss.backward()
opt.step()
after = np.mean([LS.fixed_loss(m, b) for b in batches])
print(f" fixed loss {before:.4f} -> {after:.4f}")
assert after < before
def test_lora():
M.set_matmul_precision()
d = tiny_dir()
base = hub.load_model(d)
m = hub.load_model(d)
b = Dt.fake_batch(2, seed=5)
ref = plan_of(base, b)
meta = lora.attach(m, rank=4, alpha=8, freeze_base=False) # same requires_grad state as `base`
assert meta["n_targets"] > 0
assert torch.equal(plan_of(m, b), ref), "adapter at init must equal the base bit for bit"
lora.detach(m)
assert sorted(m.state_dict()) == sorted(base.state_dict())
meta = lora.attach(m, rank=4, alpha=8, freeze_base=True)
tr = [n for n, p in m.named_parameters() if p.requires_grad]
assert tr and all(n.startswith("lora.") for n in tr)
b0 = {k: v.clone() for k, v in lora.base_state_dict(m).items()}
m.train()
opt = torch.optim.AdamW([p for p in m.parameters() if p.requires_grad], lr=1e-3)
for i in range(4):
loss, _ = LS.compute_loss(m, Dt.fake_batch(2, seed=10 + i))
opt.zero_grad()
loss.backward()
opt.step()
m.eval()
assert all(torch.equal(b0[k], v) for k, v in lora.base_state_dict(m).items()), "base weights must not change"
out = plan_of(m, b)
assert not torch.equal(out, ref)
ad = os.path.join(TMP, "adapter")
lora.save_adapter(m, ad)
m2 = hub.load_model(d)
lora.load_adapter(m2, ad, freeze_base=True)
assert torch.equal(plan_of(m2, b), out), "load_adapter must reproduce the trained adapter"
lora.merge(m2)
assert sorted(m2.state_dict()) == sorted(base.state_dict())
diff = float((plan_of(m2, b) - out).abs().max())
print(f" merge max |diff| {diff:.2e} m")
assert diff < 1e-3
def test_geometry():
route = np.c_[np.linspace(0, 20, 81), np.zeros(81)]
ts = np.round(np.arange(0, 2.01, 0.1), 1)
H = np.c_[ts, 0.3 * ts, np.zeros_like(ts), np.zeros_like(ts)]
Hp, v, w, a = G.pad_and_rates(H)
assert len(Hp) == 31 and abs(v[-1] - 0.3) < 1e-9
hist = G.ego_request(Hp, v[-1], a)
assert hist["history"].shape == (16, 3) and np.allclose(hist["history"][-1], 0)
assert abs(hist["ego_velocity"][0] - 0.3) < 1e-6
r = G.Route(route)
s, _ = r.project(0.6, 0.0, -1e9, 1.0)
c0, c1 = G.nav_command(r, s, hist)
assert (c0, c1) == ("straight", "straight")
ra, rv = G.route_ahead(r, s, 0.6, 0.0, 0.0)
assert ra.shape == (41, 2) and rv.all() and abs(ra[-1, 0] - 10.0) < 1e-5
th = np.linspace(0, math.pi / 2, 60) # left quarter circle, radius 3 m
rl = G.Route(np.c_[3 * np.sin(th), 3 - 3 * np.cos(th)])
c0, c1 = G.nav_command(rl, 0.0, hist)
assert c1 == "left", (c0, c1)
hr = G.hist_rig(Hp, v, w)
assert hr.shape == (16, 6) and abs(hr[-1, 1]) < 1e-12 and abs(hr[0, 0] + 1.5) < 1e-9
def test_data_and_policy():
root = Dt.make_fake_dataset(os.path.join(TMP, "fake_bc"), n_eps=2, n_dec=4, val_eps=1)
ds = Dt.BCDataset(root, split="train")
it = ds[1]
assert tuple(it["cur"].shape) == (3, 704, 1280) and tuple(it["hist"].shape) == (3, 3, 288, 544)
assert tuple(it["lidar"].shape) == (2, 360) and tuple(it["plan"].shape) == (50, 3)
b = Dt.collate([ds[0], ds[1]])
m = hub.load_model(tiny_dir())
with torch.no_grad():
loss, parts = LS.compute_loss(m, b)
assert torch.isfinite(loss)
pol = SimcheongiPolicy(m, device="cpu")
frames = [np.full((720, 1280, 3), 100 + 10 * k, np.uint8) for k in range(4)]
ts = np.round(np.arange(0, 2.01, 0.1), 1)
H = np.c_[ts, 0.3 * np.maximum(0.0, ts - 0.3), np.zeros_like(ts), np.zeros_like(ts)] # drive start: at rest first
lid = np.zeros(400, np.float32)
out = pol.plan(frames, lid, H, np.c_[np.linspace(0, 20, 81), np.zeros(81)])
assert out.trajectory.shape == (50, 3) and np.isfinite(out.trajectory).all()
out2 = pol.plan(frames, lid, H, None, command="left", session="no_route")
assert out2.command_used == "left"
def _drive(heading=0.0, n=60, v=0.4, x0=0.0, y0=0.0):
"""10 Hz pose rows (t from 0, x, y, yaw unwrapped): standing 0.3 s, then v m/s along `heading` with a heading wobble."""
rows = []
for k in range(n):
s = v * 0.1 * max(0, k - 3)
yaw = heading + 0.05 * math.sin(0.3 * k)
rows.append((round(0.1 * k, 1), x0 + s * math.cos(heading) - 0.02 * math.sin(0.2 * k) * math.sin(heading),
y0 + s * math.sin(heading) + 0.02 * math.sin(0.2 * k) * math.cos(heading), yaw))
return np.asarray(rows)
def _route(heading=0.0, back=1.0, length=30.0, x0=0.0, y0=0.0):
s = np.linspace(-back, length, int(round((length + back) / 0.25)) + 1)
return np.c_[x0 + s * math.cos(heading), y0 + s * math.sin(heading)]
KEYS6 = ("history", "history_velocity", "history_acceleration", "x_hist_rig", "x_route_ahead", "x_route_ahead_valid",
"x_cmd_c1")
def _builds(H_all, route, times=(1.5, 2.0, 2.5, 3.5, 5.0), off=0.0, wrap=False, rows=None):
rb, out = RequestBuilder(), []
lid = np.zeros(400, np.float32)
for t in times:
k = int(round(t / 0.1))
H = H_all[: k + 1].copy() if rows is None else H_all[max(0, k + 1 - rows): k + 1].copy()
H[:, 0] += off
if wrap:
H[:, 3] = np.mod(H[:, 3] + math.pi, 2 * math.pi) - math.pi
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
_, a, _ = rb.build(None, lid, H, route, session="s")
out.append((a, [str(x.message) for x in w]))
return out
def _maxdiff(A, B):
return max(float(np.abs(np.asarray(a[k], np.float64) - np.asarray(b[k], np.float64)).max())
for (a, _), (b, _) in zip(A, B) for k in KEYS6)
def test_request_builder_rules():
H, route = _drive(), _route()
ref = _builds(H, route)
assert not any(w for _, w in ref), [w for _, w in ref]
assert [list(a["x_frame_ticks"]) for a, _ in ref][:2] == [[0, 5, 10, 15], [5, 10, 15, 20]]
for off in (-50.0, 37.3, 1763540000.0): # any increasing clock: same arrays, shifted ticks
o = _builds(H, route, off=off)
assert _maxdiff(ref, o) < 1e-5, (off, _maxdiff(ref, o))
d = round(off / 0.1)
assert all(list(np.asarray(b["x_frame_ticks"]) - d) == list(a["x_frame_ticks"]) for (a, _), (b, _) in zip(ref, o))
rb = RequestBuilder() # clock relative to now: rejected
lid = np.zeros(400, np.float32)
for i, t in enumerate((2.0, 2.5)):
Hr = H[: int(round(t / 0.1)) + 1].copy()
Hr[:, 0] -= Hr[-1, 0]
if i == 0:
rb.build(None, lid, Hr, route, session="rel")
else:
try:
rb.build(None, lid, Hr, route, session="rel")
raise AssertionError("relative clock must raise")
except ValueError:
pass
Hp, rp = _drive(heading=math.pi), _route(heading=math.pi) # heading crosses +-pi: wrapped yaw == unwrapped
a_un, a_wr = _builds(Hp, rp), _builds(Hp, rp, wrap=True)
assert np.ptp(np.mod(Hp[:, 3] + math.pi, 2 * math.pi)) > math.pi # the wrapped input really jumps
assert _maxdiff(a_un, a_wr) < 1e-9, _maxdiff(a_un, a_wr)
far = _route(back=30.0) # route starting 30 m behind the robot
o = _builds(H, far, times=(2.0, 2.5))
assert o[0][1] and "route starts" in o[0][1][0], o[0][1]
assert _maxdiff(ref[1:2], o[:1]) < 1e-6, _maxdiff(ref[1:2], o[:1]) # = the route cut at the robot
o = _builds(H, route, times=(3.0,), rows=16) # short window while moving: warned
assert any("padded as STANDING STILL" in w for w in o[0][1]), o[0][1]
o = _builds(H, route, times=(4.0,), rows=31) # >= 31 rows: no warning
assert not o[0][1], o[0][1]
ids = [f"ep{i:04d}" for i in range(200)] # train.py and eval_offline.py: the same val split
from simcheongi import training as TR # noqa: PLC0415
a = TR.build_parser().parse_args(["--data", "x", "--out", "y", "--val-frac", "0.1", "--seed", "123"])
assert a.split_seed == 0
va = {i for i in ids if Dt.hash_split(i, a.val_frac, a.split_seed) == "val"}
assert va and va == {i for i in ids if Dt.hash_split(i, 0.1, 0) == "val"}
if __name__ == "__main__":
tests = [test_roundtrip, test_loss_decreases, test_lora, test_geometry, test_data_and_policy,
test_request_builder_rules]
ok = True
for t in tests:
try:
t()
print(f"PASS {t.__name__}", flush=True)
except Exception as e: # noqa: BLE001
ok = False
print(f"FAIL {t.__name__}: {type(e).__name__}: {e}", flush=True)
import traceback
traceback.print_exc()
print("ALL OK" if ok else "SOME FAILED")
sys.exit(0 if ok else 1)