RoboRACE-Bench / scripts /train_racenet.py
Nabidnur's picture
RACE-Net-V: EM-refinement variant (advisor inputs)
76d6c8b verified
Raw History Blame Contribute Delete
4.39 kB
#!/usr/bin/env python3
"""Train RACE-Net on synthetic swarms only (CPU). No benchmark data is touched.
python scripts/train_racenet.py [--steps 6000] [--threads 4]
Writes models/racenet/{model.safetensors, config.json, training_log.json}.
Validation = fresh synthetic swarms (fixed seed), reported next to an online RACE-S baseline on the same windows.
"""
import argparse
import json
import sys
import time
from pathlib import Path
import numpy as np
import torch
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
from robotics.swarm import racenet # noqa: E402
def synthetic_val(net, n_batches=30, seed=10_000, gen="v1", advisors=()):
rng = np.random.default_rng(seed)
acc, n = 0.0, 0
net.eval()
with torch.inference_mode():
for _ in range(n_batches):
z, adv, y = racenet.batch_tensors(rng, 16, gen, advisors)
acc += float(((net(z, adv) > 0) == (y > 0.5)).float().mean())
n += 1
net.train()
return acc / n
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--steps", type=int, default=6000)
ap.add_argument("--batch", type=int, default=24)
ap.add_argument("--lr", type=float, default=2e-3)
ap.add_argument("--threads", type=int, default=4)
ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--gen", default="v1", choices=sorted(racenet.GENERATORS), help="synthetic-swarm generator")
ap.add_argument("--advisors", default="", help="comma-separated EM experts given as inputs, e.g. race_s,race")
ap.add_argument("--d", type=int, default=racenet.CONFIG["d"])
ap.add_argument("--layers", type=int, default=racenet.CONFIG["layers"])
ap.add_argument("--out", default="models/racenet")
a = ap.parse_args()
torch.set_num_threads(a.threads)
torch.manual_seed(a.seed)
rng = np.random.default_rng(a.seed)
arch = {**racenet.CONFIG, "d": a.d, "layers": a.layers}
advisors = tuple(x for x in a.advisors.split(",") if x)
net = racenet.RaceNet(**arch, advisors=len(advisors))
n_params = sum(p.numel() for p in net.parameters())
opt = torch.optim.AdamW(net.parameters(), lr=a.lr, weight_decay=0.01)
sched = torch.optim.lr_scheduler.OneCycleLR(opt, max_lr=a.lr, total_steps=a.steps, pct_start=0.05)
log, t0, run = [], time.time(), 0.0
for step in range(1, a.steps + 1):
z, adv, y = racenet.batch_tensors(rng, a.batch, a.gen, advisors, drop=0.15)
loss = torch.nn.functional.binary_cross_entropy_with_logits(net(z, adv), y)
opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(net.parameters(), 1.0)
opt.step()
sched.step()
run = 0.98 * run + 0.02 * loss.item() if step > 1 else loss.item()
if step % 500 == 0 or step == a.steps:
val = synthetic_val(net, gen=a.gen, advisors=advisors)
log.append({"step": step, "train_bce": round(run, 4), "val_acc_synthetic": round(val, 4),
"minutes": round((time.time() - t0) / 60, 1)})
print(log[-1], flush=True)
out = Path(a.out)
out.mkdir(parents=True, exist_ok=True)
from safetensors.torch import save_file
save_file(net.state_dict(), str(out / "model.safetensors"))
(out / "config.json").write_text(json.dumps({**arch, "advisors": list(advisors), "n_params": n_params, "architecture": "RaceNet (axial set transformer)",
"input": "rank-Gaussianized swarm reports [T episodes, J agents], receiver first",
"output": "log-odds of success per episode",
"training": {"data": "synthetic swarms only (robotics.swarm.racenet.sample_batch)",
"generator": a.gen, **racenet.GENERATORS[a.gen],
"steps": a.steps, "batch": a.batch, "lr": a.lr, "seed": a.seed},
"final_val_acc": {g: round(synthetic_val(net, gen=g, advisors=advisors), 4) for g in sorted(racenet.GENERATORS)}},
indent=1))
(out / "training_log.json").write_text(json.dumps(log, indent=1))
print("saved", out, "params", n_params)
if __name__ == "__main__":
main()