Datasets:
Download scripts/train_racenet.py from Nabidnur/RoboRACE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 4.39 kB
-
https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/scripts/train_racenet.py
- Command line
-
hf download hf://datasets/Nabidnur/RoboRACE-Bench/scripts/train_racenet.py
-
curl -L -o train_racenet.py https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/scripts/train_racenet.py
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() | |