#!/usr/bin/env python3 """Publish the full RoboRACE work to Hugging Face (token from the HF_TOKEN environment variable only). HF_TOKEN=... python scripts/publish_hf.py [--dry-run] Creates / updates datasets//RoboRACE-Bench everything: code, docs, tests, cached agent outputs, leaderboards, figures, videos and the 1,100 SO-101 camera renders (image viewer config) spaces//RoboRACE static showcase page (hf_space/index.html) with playing videos Not uploaded: third-party assets (MuJoCo Menagerie meshes, PlotNeuralNet, ERQA / PlanBench source data: they are public under their own terms; scripts/fetch_assets.sh downloads them), secrets, virtualenvs. """ import argparse import json import os import re import shutil import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] OWNER = "Nabidnur" DS = f"{OWNER}/RoboRACE-Bench" SPACE = f"{OWNER}/RoboRACE" GH = "https://github.com/Hisernberg/robotics" RES = f"https://huggingface.co/datasets/{DS}/resolve/main" BLOB = f"https://huggingface.co/datasets/{DS}/blob/main" STAGE = Path(os.environ.get("HF_STAGE", str(ROOT / ".hf_stage"))) CODE = ["src", "scripts", "tests", "docs", "results", "media", "models", "kaggle", "requirements.txt", "pyproject.toml", ".env.example", ".gitattributes"] def card_yaml(): return """--- pretty_name: RoboRACE-Bench license: other license_name: roborace-mixed license_link: https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/blob/main/LICENSES.md language: - en task_categories: - robotics - visual-question-answering - image-classification tags: - robotics - multi-agent - byzantine-robustness - truth-inference - vlm - llm-agents - so-101 - mujoco - erqa - planbench - cosmos-reason size_categories: - 1K str: """GitHub README -> HF card body: absolute URLs, video players, dataset-specific sections.""" body = readme # absolute URLs for media (resolve) and documents (blob) body = re.sub(r'(src|href)="(media/[^"]+)"', lambda m: f'{m.group(1)}="{RES}/{m.group(2)}"', body) tree = f"https://huggingface.co/datasets/{DS}/tree/main" body = re.sub(r'\]\((media/[^)]+)\)', lambda m: f"]({(RES if '.' in m.group(1).rsplit('/', 1)[-1] else tree)}/{m.group(1)})", body) body = re.sub(r'(href)="((?:results|docs)/[^"]+)"', lambda m: f'{m.group(1)}="{BLOB}/{m.group(2)}"', body) body = re.sub(r'\]\(((?:results|docs)/[^)#]+)(#[^)]*)?\)', lambda m: f"]({BLOB}/{m.group(1)}{m.group(2) or ''})", body) # the headline links line: point code links to GitHub, keep the rest hf_intro = f""" > **This is the Hugging Face home of RoboRACE.** It holds the complete, detailed work: code, the cached outputs of every > agent (VLMs, LLMs, simulated robots), per-cell benchmark results, leaderboards, figures, videos and the 1,100 SO-101 > camera renders for each of two robot arms. Code is mirrored on GitHub: [{GH.replace('https://', '')}]({GH}). Showcase page: [Space · {SPACE}](https://huggingface.co/spaces/{SPACE}) · interactive: [Space · liar playground](https://huggingface.co/spaces/{OWNER}/RoboRACE-Playground) · model: [{OWNER}/RoboRACE-Net](https://huggingface.co/{OWNER}/RoboRACE-Net). ## Videos

SO-101 camera swarm: three physics rollouts, five Cosmos-Reason2 camera agents, honest swarm vs 3-of-5 liars.

Byzantine rendezvous: 12 robots, 4 colluding liars — DeGroot vs W-MSR vs RACE-C + W-MSR.

PlanBench LLM-Modulo: a real cached LLM plan is rejected by the exact simulator and repaired.

Maze swarm (Track D): three of six robots invert their map reports — majority map vs RACE map.

Franka Panda camera swarm: the cross-embodiment replication.

Track A0 (first iteration): procedural scenes judged by the same camera swarm.
## What is in this repository | path | content | |---|---| | `data/so101/{{hist,eval}}//.png` | 220 SO-101 episodes × 5 cameras (448×448), with per-split `metadata.jsonl` | | `viewer//*.parquet` | Parquet copies behind the dataset viewer; **`so101_views`** embeds every image with its task, physics label, failure mode and Cosmos score | | `data/so101/episodes.jsonl` | per-episode metadata: task, family (put / stack), scripted mode, **physics ground truth**, final object pose | | `results/so101/vlm_scores.jsonl` | Cosmos-Reason2-2B P(success) for every (episode, camera) — config **`so101_vlm_scores`** | | `data/panda/...`, `results/panda/vlm_scores.jsonl` | the same for the **Franka Panda** replication (220 episodes × 5 cameras) — configs **`panda_views`**, **`panda_vlm_scores`** | | `data/*_holdout/...`, `results/*_holdout/vlm_scores.jsonl`, `results/holdout/FREEZE.json` | the **hold-out**: 170 new episodes per arm, evaluated only after the recorded freeze commit — configs **`so101_holdout_views`**, **`panda_holdout_views`** and the matching `*_vlm_scores` | | `models/racenet`, `models/racenet_m` | weights of both models (**RACE-Net-V**, **RACE-Net-M**) and every candidate checkpoint | | `results/trackD/rows.json` | Track D maze swarm: SPL and success of every fusion rule in every (maze, attack, liar-count) cell — config **`trackD_maze_results`** | | `results/maze_llm/.jsonl` | LLM agents on text mazes: every attempt, validator feedback, repair count — config **`maze_llm_agents`** | | `models/racenet/` | RACE-Net weights (safetensors), config and training log; also at [Nabidnur/RoboRACE-Net](https://huggingface.co/Nabidnur/RoboRACE-Net) | | `results/kaggle/` | independent replication run on Kaggle CPU (log + comparison) | | `results/erqa/cosmos_r2_2b*.jsonl` | ERQA: full option distributions for all 400 questions at ≤448² and ≤768² px — config **`erqa_cosmos_reason2_2b`** | | `results/erqa/.jsonl` | ERQA answers + raw replies of hosted VLM agents (Gemini, Qwen, Gemma, Gemini Robotics-ER) — config **`erqa_hosted_agents`** | | `results/planbench/.jsonl` | PlanBench Blocksworld: every attempt, parsed plan, validator verdict, repair count — config **`planbench_agents`** | | `results/trackC/answers.jsonl` | Track C: zero-shot / engineered / saboteur answers of 4 LLMs — config **`trackC_llm_planners`** | | `results/*/rows.json`, `results/leaderboard.json`, `results/LEADERBOARD.md` | per-cell results of every method under every attack and receiver; bootstrap-ranked leaderboards | | `media/` | figures, architecture diagrams (Raschka style + PlotNeuralNet), videos (MP4 + GIF) | | `src/`, `scripts/`, `tests/`, `docs/` | the full code base, protocol ([BENCHMARK]({BLOB}/docs/BENCHMARK.md)) and research plan ([PLAN]({BLOB}/docs/PLAN.md)) | ```python from datasets import load_dataset views = load_dataset("{DS}", "so101_views", split="evaluation") # images + labels scores = load_dataset("{DS}", "so101_vlm_scores", split="train") # Cosmos-Reason2 P(success) per camera erqa = load_dataset("{DS}", "erqa_cosmos_reason2_2b", split="px448") plans = load_dataset("{DS}", "planbench_agents", split="train") ``` Re-run every number on a CPU from this repository: ```bash huggingface-cli download {DS} --repo-type dataset --local-dir RoboRACE-Bench && cd RoboRACE-Bench pip install -r requirements.txt && python scripts/run_benchmark.py --reuse-tracks && python scripts/make_figures.py ``` """ # insert after the closing of the hero block i = body.index("") + len("") body = body[:i] + "\n" + hf_intro + body[i:] body = body.replace("This README is generated by scripts/make_readme.py", "This card is generated by scripts/publish_hf.py from the GitHub README, which is generated by scripts/make_readme.py") return body LICENSES = f"""# Licenses RoboRACE-Bench mixes original work with third-party material. Each part keeps its own terms. | component | terms | |---|---| | Original code, cached agent outputs, results, figures, videos, SO-101 renders (this repository) | © the repository owner. A formal open-source license has not been chosen yet; until then, use for research and evaluation with attribution to [{GH}]({GH}) and this dataset. | | `src/robotics/swarm/race.py` (RACE v3.1 port) | MIT, from `Nabidnur/gemma4-race-pack` / `Nabidnur/liars-are-information` | | SO-101 robot model used to render `data/so101` | MuJoCo Menagerie `robotstudio_so101`, Apache-2.0 (not redistributed here) | | ERQA questions / images | Gemini Robotics team, via `FlagEval/ERQA`; **not redistributed** — only question ids and model answers are stored | | PlanBench instances | Valmeekam et al., MIT; **not redistributed** — only instance ids, model plans and verdicts are stored | | Cosmos-Reason2-2B outputs | produced with `nvidia/Cosmos-Reason2-2B` under the NVIDIA Open Model License | | Hosted-model outputs (Gemini, Qwen, Gemma, gpt-oss) | produced through the providers' APIs; subject to the respective providers' terms | """ ROBOTS = [r for r in ("so101", "panda", "so101_holdout", "panda_holdout") if (ROOT / f"data/{r}/episodes.jsonl").exists() and (ROOT / f"results/{r}/vlm_scores.jsonl").exists()] def so101_metadata(): for robot in ROBOTS: eps = {e["seed"]: e for e in map(json.loads, open(ROOT / f"data/{robot}/episodes.jsonl"))} scores = {} for r in map(json.loads, open(ROOT / f"results/{robot}/vlm_scores.jsonl")): scores[(r["scene"], r["camera"])] = r["p"] for split in ("hist", "eval"): with open(STAGE / f"data/{robot}/{split}/metadata.jsonl", "w") as f: for seed, e in sorted(eps.items()): if e["split"] != split: continue for cam in ("front", "left", "right", "back", "top"): f.write(json.dumps({"file_name": f"{seed}/{cam}.png", "robot": robot, "seed": seed, "camera": cam, "task": e["task"], "family": e["family"], "scripted_mode": e["mode"], "success_physics": e["success"], "cosmos_p_success": scores.get((seed, cam))}) + "\n") def viewer_parquet(): """One loader for every viewer config: Parquet (the `datasets` library infers a single builder per repo, so mixing an image folder with JSONL configs breaks the JSONL ones). Originals stay in results/ and data/.""" from datasets import Dataset, Image, load_dataset v = STAGE / "viewer" for robot in ROBOTS: for split, name in (("hist", "history"), ("eval", "evaluation")): rows = [json.loads(line) for line in open(STAGE / f"data/{robot}/{split}/metadata.jsonl")] for r in rows: # embed the PNG bytes (to_parquet would otherwise store local paths) fn = r.pop("file_name") r["image"] = {"bytes": (STAGE / f"data/{robot}/{split}/{fn}").read_bytes(), "path": fn.replace("/", "_")} ds = Dataset.from_list(rows).cast_column("image", Image()) (v / f"{robot}_views").mkdir(parents=True, exist_ok=True) ds.to_parquet(str(v / f"{robot}_views" / f"{name}.parquet")) jsonl = { "so101_vlm_scores/train": ["results/so101/vlm_scores.jsonl"], "erqa_cosmos_reason2_2b/px448": ["results/erqa/cosmos_r2_2b.jsonl"], "erqa_cosmos_reason2_2b/px768": ["results/erqa/cosmos_r2_2b_768px.jsonl"], "erqa_hosted_agents/test": sorted(str(p.relative_to(STAGE)) for p in (STAGE / "results/erqa").glob("*.jsonl") if not p.name.startswith("cosmos_r2_2b")), "planbench_agents/train": sorted(str(p.relative_to(STAGE)) for p in (STAGE / "results/planbench").glob("*.jsonl")), "trackC_llm_planners/train": ["results/trackC/answers.jsonl"], "trackA0_procedural_scores/train": ["results/trackA/vlm_scores.jsonl"], "panda_vlm_scores/train": ["results/panda/vlm_scores.jsonl"], "so101_holdout_vlm_scores/train": ["results/so101_holdout/vlm_scores.jsonl"], "panda_holdout_vlm_scores/train": ["results/panda_holdout/vlm_scores.jsonl"], "trackD_maze_results/train": ["results/trackD/rows.json"], "maze_llm_agents/train": sorted(str(p.relative_to(STAGE)) for p in (STAGE / "results/maze_llm").glob("*.jsonl")), } jsonl = {k: f for k, f in jsonl.items() if f and all((STAGE / x).exists() for x in f)} for key, files in jsonl.items(): ds = load_dataset("json", data_files=[str(STAGE / f) for f in files], split="train") (v / key.split("/")[0]).mkdir(parents=True, exist_ok=True) ds.to_parquet(str(v / f"{key}.parquet")) print(f"viewer/{key}.parquet {len(ds)} rows") def stage(): if STAGE.exists(): shutil.rmtree(STAGE) STAGE.mkdir(parents=True) for item in CODE: src = ROOT / item if src.is_dir(): shutil.copytree(src, STAGE / item, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.pal.png")) elif src.exists(): shutil.copy2(src, STAGE / item) for robot in ROBOTS: shutil.copytree(ROOT / f"data/{robot}", STAGE / f"data/{robot}") so101_metadata() viewer_parquet() (STAGE / "README.md").write_text(card_yaml() + hf_body((ROOT / "README.md").read_text())) (STAGE / "LICENSES.md").write_text(LICENSES) n = sum(1 for _ in STAGE.rglob("*") if _.is_file()) size = sum(p.stat().st_size for p in STAGE.rglob("*") if p.is_file()) / 1e6 print(f"staged {n} files, {size:.1f} MB in {STAGE}") def publish_space(api, token): sys.path.insert(0, str(Path(__file__).resolve().parent)) from make_space import build sp = build(STAGE.parent / (STAGE.name + "_space")) api.create_repo(SPACE, repo_type="space", space_sdk="static", exist_ok=True, token=token) api.upload_folder(repo_id=SPACE, repo_type="space", folder_path=str(sp), token=token, commit_message="RoboRACE showcase page") MODEL = f"{OWNER}/RoboRACE-Net" PLAY = f"{OWNER}/RoboRACE-Playground" MODEL_M = f"{OWNER}/RoboRACE-Net-M" sys.path.insert(0, str(Path(__file__).resolve().parent)) import racenet_report # noqa: E402 def model_card(): lb = json.loads((ROOT / "results/leaderboard.json").read_text()) cfg = json.loads((ROOT / "models/racenet/config.json").read_text()) log = json.loads((ROOT / "models/racenet/training_log.json").read_text()) net = "race_net (new, learned)" def g(track, m, key="mean_acc"): r = next((r for r in lb.get(track, []) if r["method"] == m), None) return f"{100 * r[key]:.1f}" if r else "–" rows = "\n".join(f"| {lab} | {g('A0', m)} | {g('A', m)} | {g('AP', m)} | {g('A', m, 'majority_liars')} | {g('AP', m, 'majority_liars')} |" for lab, m in (("majority vote", "majority"), ("Dawid–Skene (crowd-kit)", "DS (crowd-kit)"), ("receiver alone", "receiver_only"), ("RACE online (EM)", "race_online (new)"), ("RACE-S online (EM)", "race_s_online (new)"), ("**RACE-Net (this model)**", net), ("labelled stacker (reference)", "REF stack_lr (labelled)"))) metrics = "\n".join(f""" - task: {{type: other, name: Label-free swarm fusion under attack}} dataset: {{name: RoboRACE-Bench {nm}, type: {DS}, config: {cfgn}, split: evaluation}} metrics: - {{type: accuracy, value: {g(tr, net)}, name: mean accuracy over all attack cells}}""" for tr, nm, cfgn in (("A", "Track A SO-101", "so101_vlm_scores"), ("AP", "Track A-Panda", "panda_vlm_scores")) if g(tr, net) != "–") return f"""--- license: other license_name: roborace-mixed license_link: https://huggingface.co/datasets/{DS}/blob/main/LICENSES.md library_name: pytorch pipeline_tag: other tags: [robotics, multi-agent, byzantine-robustness, truth-inference, set-transformer, in-context-learning, roborace] datasets: [{DS}] model-index: - name: RACE-Net results: {metrics} --- # RACE-Net — amortized receiver-anchored truth inference **A {cfg['n_params']:,}-parameter axial set transformer that fuses the reports of a swarm of agents when some of them lie.** Part of [RoboRACE](https://huggingface.co/datasets/{DS}) · [showcase Space](https://huggingface.co/spaces/{SPACE}) · code: [{GH.replace('https://', '')}]({GH})

## What it does A robot (the *receiver*) gets, for each of T recent episodes, a score in [0, 1] from each of J agents (for example P(task succeeded) from J camera + VLM pairs). Some agents may be inverted, stuck, random, colluding or replicated. RACE-Net reads the whole unlabelled window at once and returns the log-odds of success for every episode. It assumes only one thing: **the receiver's own column is honest** (the anchor of [RACE](https://huggingface.co/spaces/Nabidnur/liars-are-information-demo)). Consistent liars are not discarded: their reports are effectively inverted and used. - **Input:** `P` with shape `[T, J]`, any T and J (the model has no positional encodings; it is permutation-equivariant over episodes and peers). - **Pre-processing:** per-agent rank → probit within the window (label-free, invariant to any monotone miscalibration). - **Blocks ({cfg['layers']}×):** attention across agents within an episode → attention across episodes within an agent → MLP (d = {cfg['d']}, {cfg['heads']} heads). - **Output:** one logit per episode; decide `> 0`. ## Use ```python import sys, numpy as np from huggingface_hub import snapshot_download d = snapshot_download("{MODEL}"); sys.path.insert(0, d) import racenet P = np.random.rand(100, 5) # [episodes, agents] scores in [0, 1]; column `own` is the receiver log_odds, thr = racenet.race_net(None, P, own=0, path=d) success = log_odds > thr ``` Runs on CPU in a few milliseconds per window. Dependencies: `torch`, `numpy`, `safetensors`. ## Training Synthetic swarms only (`racenet.sample_batch`): heterogeneous agent skill, correlated honest errors, yes-bias, and an attack zoo with up to J−1 liars. **No benchmark data, labels or agent outputs were used.** {cfg['training']['steps']:,} AdamW steps, batch {cfg['training']['batch']}, one-cycle LR {cfg['training']['lr']}, CPU only. Held-out synthetic accuracy at the end: {100 * log[-1]['val_acc_synthetic']:.1f}%. ## Evaluation (zero-shot on real VLM camera swarms) Agents are five cameras scored by Cosmos-Reason2-2B; ground truth is the final physics state of a simulated robot arm. Each cell is one (attack, liar count, liar subset, receiver); numbers are mean accuracy in %. | method (label-free unless noted) | A0 procedural (development) | SO-101 (test) | Franka Panda (fresh test) | SO-101, liars ≥ 50% | Panda, liars ≥ 50% | |---|---:|---:|---:|---:|---:| {rows}

{racenet_report.selection_md()} ## Scaling study {racenet_report.scaling_md("racenet_scaling.png")} ## Limitations - It matches the EM-based methods but does not beat the best of them (RACE-S online) on the real camera swarms (see the table). - Trained on a hand-written simulator of swarms. Where real agent errors differ from it, the EM-based RACE-S can be better. - The receiver must be honest and better than chance; with a very weak receiver and a liar majority no label-free method can identify the truth. - Fits on the current window (transductive); a sleeper that changes behaviour inside the window is treated as one mixed channel. - Binary truth only. Evaluated in simulation with one VLM behind all cameras. ## Files `model.safetensors` · `config.json` · `training_log.json` · `selection.json` + `candidates/` (all three checkpoints) · `racenet.py` (model, synthetic generators, inference) · `train_racenet.py` · `select_racenet.py` · `racenet_analysis.py` + `analysis.json` (scaling study) """ def publish_model(api, token): md = STAGE.parent / (STAGE.name + "_model") if md.exists(): shutil.rmtree(md) md.mkdir(parents=True) for f in ("model.safetensors", "config.json", "training_log.json"): shutil.copy2(ROOT / "models/racenet" / f, md / f) shutil.copy2(ROOT / "src/robotics/swarm/racenet.py", md / "racenet.py") shutil.copy2(ROOT / "scripts/train_racenet.py", md / "train_racenet.py") pkg = md / "robotics/swarm" # minimal package so that the EM experts can be imported pkg.mkdir(parents=True) (md / "robotics/__init__.py").write_text("") (pkg / "__init__.py").write_text("") for f in ("racenet.py", "fusion.py", "race.py"): shutil.copy2(ROOT / "src/robotics/swarm" / f, pkg / f) shutil.copy2(ROOT / "media/architecture/racenet.png", md / "racenet_architecture.png") shutil.copy2(ROOT / "media/figures/racenet.png", md / "racenet_results.png") for src, dst in (("models/racenet/selection.json", "selection.json"), ("media/figures/racenet_scaling.png", "racenet_scaling.png"), ("results/racenet/analysis.json", "analysis.json"), ("scripts/racenet_analysis.py", "racenet_analysis.py"), ("scripts/select_racenet.py", "select_racenet.py")): if (ROOT / src).exists(): shutil.copy2(ROOT / src, md / dst) if (ROOT / "models/racenet/candidates").exists(): shutil.copytree(ROOT / "models/racenet/candidates", md / "candidates") (md / "README.md").write_text(model_card()) api.create_repo(MODEL, repo_type="model", exist_ok=True, token=token) api.upload_folder(repo_id=MODEL, repo_type="model", folder_path=str(md), token=token, commit_message="RACE-Net weights, card and code") print("model:", f"https://huggingface.co/{MODEL}") def model_card_m(): lb = json.loads((ROOT / "results/leaderboard.json").read_text()) cfg = json.loads((ROOT / "models/racenet_m/config.json").read_text()) log = json.loads((ROOT / "models/racenet_m/training_log.json").read_text()) D = {r["method"]: r for r in lb.get("D", [])} succ = lb.get("D_success", {}) names = {"race_net_m + reach-repair": "**RACE-Net-M + reachability repair (this model)**", "race_net_m": "**RACE-Net-M (this model)**", "race_map": "race_map (hand-written Bayesian rule, ours)", "wmsr_trim": "W-MSR-style trimming (LeBlanc et al. 2013; F known)", "reputation": "beta-reputation (Jøsang & Ismail 2002)", "eigentrust": "EigenTrust (Kamvar et al. 2003)", "dawid_skene": "Dawid–Skene (1979), unanchored", "solo": "no communication", "trust_all": "naive map merging", "majority": "per-cell majority", "REF oracle": "*oracle that knows the liars (reference)*"} rows = "\n".join(f"| {('%d' % r['rank']) if 'rank' in r else '–'} | {names.get(m, m)} | {100 * r['mean_acc']:.1f} | {100 * r['clean']:.1f} | " f"{100 * r['minority_liars']:.1f} | {100 * r['majority_liars']:.1f} | {100 * succ.get(m, float('nan')):.1f} |" for m, r in D.items()) ab = json.loads((ROOT / "results/racenet_m/ablation.json").read_text()) ab_rows = "\n".join(f"| {r['model']} | {100 * r['val_cell_acc']:.1f} | {100 * r['by_liars']['3'][0]:.1f} | {100 * r['by_liars']['5'][0]:.1f} |" for r in ab["rows"]) b0 = ab["rows"][0] net = D.get("race_net_m + reach-repair", {}).get("mean_acc") metrics = f""" - task: {{type: other, name: Byzantine-robust map fusion}} dataset: {{name: RoboRACE-Bench Track D, type: {DS}, config: trackD_maze_results, split: train}} metrics: - {{type: spl, value: {100 * net:.1f}, name: mean SPL x100 over 500 cells}}""" if net else "" return f"""--- license: other license_name: roborace-mixed license_link: https://huggingface.co/datasets/{DS}/blob/main/LICENSES.md library_name: pytorch pipeline_tag: other tags: [robotics, multi-agent, byzantine-robustness, map-fusion, truth-inference, set-transformer, roborace] datasets: [{DS}] model-index: - name: RACE-Net-M results: {metrics} --- # RACE-Net-M — receiver-anchored channel estimation for map fusion **A {cfg['n_params']:,}-parameter model that fuses the map reports of a robot swarm when some robots lie.** Part of [RoboRACE](https://huggingface.co/datasets/{DS}) · sibling model for camera swarms: [RACE-Net-V](https://huggingface.co/{MODEL}) · [showcase Space](https://huggingface.co/spaces/{SPACE}) · code: [{GH.replace('https://', '')}]({GH})

## What it does Robots explore an unknown map and broadcast what they sensed (cell is *free* / *wall*). Some robots corrupt their broadcasts: they invert everything, invent walls or openings, answer at random, turn bad later, or collude. A receiving robot has to decide which cells are walls. RACE-Net-M returns the log-odds of *wall* for every reported cell. It assumes one thing only: **the receiver's own sensor is right**. 1. **Anchored counts.** Each peer's claims are compared with the cells the receiver sensed itself (claim × truth, recent and old claims apart). 2. **Peer transformer.** A small transformer across peers turns the counts into a channel embedding per peer. 3. **Signed read-out.** Each kind of claim gets a signed evidence value: a reliable peer is trusted, a consistent liar is *inverted and used*, a random one is ignored. Reputation systems can only discard a liar. 4. **Refinement ({cfg['rounds']} rounds).** Each peer is also checked against the belief of all the *other* peers on cells the receiver has not sensed (leave-one-out), so a robot can verify a peer it never overlapped with through a peer it already trusts. Peers and cells are sets (no positions): any map size and any swarm size. ## Use ```python import sys, numpy as np from huggingface_hub import snapshot_download d = snapshot_download("{MODEL_M}"); sys.path.insert(0, d) import racenet_m # own [H, W] the receiver's own observations: -1 unknown, 0 free, 1 wall # claims [n, H, W] latest broadcast of every robot (same coding); stamp [n, H, W] time of that broadcast log_odds = racenet_m.wall_logodds(own, claims, stamp, i=0, t=now, path=d) # i = index of the receiver wall = log_odds > 2.0 # threshold chosen on development mazes ``` About 2 ms per call on one CPU core. Dependencies: `torch`, `numpy`, `safetensors`. ## Training {cfg['training']['snapshots']:,} snapshots from simulated maze swarms (maze seeds {cfg['training']['train_seeds'][0]}–{cfg['training']['train_seeds'][1]}) in which liars follow **random two-coin channels with an optional change point** (`racenet_m.sample_channels`). The benchmark's attack names never appear in training, and the colluding ring attack is outside that family. {cfg['training']['steps']:,} AdamW steps on a CPU ({log[-1]['minutes']:.0f} min including the simulation). Benchmark mazes (seeds 1000–1019) and tuning mazes (seeds 0–39) are disjoint from training and validation mazes. ## Evaluation: RoboRACE Track D Six robots, 20 fresh mazes × 25 conditions (6 attacks × 1–4 liars, plus the clean case) = 500 cells. Score = SPL ×100 (success weighted by path length) of the honest robots. Ranks are medians over 2,000 bootstrap resamples of cells. | rank | fusion rule | mean SPL | no liars | liars < 50% | liars ≥ 50% | goal reached % | |---:|---|---:|---:|---:|---:|---:| {rows}

Belief quality on held-out mazes (accuracy on cells a peer reported and the receiver has not sensed): | model | all | 3 of 5 peers lie | 5 of 5 peers lie | |---|---:|---:|---:| | race_map (hand-written Bayesian rule) | {100 * b0['val_cell_acc_bma']:.1f} | {100 * b0['by_liars']['3'][1]:.1f} | {100 * b0['by_liars']['5'][1]:.1f} | {ab_rows} ## Limitations - **Collusion on a few cells.** A bloc that is honest everywhere except around the goal looks reliable until a robot gets there; the reachability repair recovers part of the loss, the oracle is still better. - One simulator (grid mazes, exact 8-neighbour sensing, six robots). Not tested on real robots or noisy sensors. - Claims are assumed conditionally independent given the truth; the model has no notion of where a peer was when it made a claim. ## Files `model.safetensors` · `config.json` · `training_log.json` · `ablation.json` · `racenet_m.py` (model, training distribution, inference) · `train_racenet_m.py` · `trackD.py` (the benchmark, baselines and planner) """ def publish_model_m(api, token): md = STAGE.parent / (STAGE.name + "_model_m") if md.exists(): shutil.rmtree(md) md.mkdir(parents=True) for f in ("model.safetensors", "config.json", "training_log.json"): shutil.copy2(ROOT / "models/racenet_m" / f, md / f) for src, dst in (("src/robotics/swarm/racenet_m.py", "racenet_m.py"), ("scripts/train_racenet_m.py", "train_racenet_m.py"), ("src/robotics/bench/trackD.py", "trackD.py"), ("results/racenet_m/ablation.json", "ablation.json"), ("media/architecture/racenet_m.png", "racenet_m_architecture.png"), ("media/figures/trackD_vs_liars.png", "trackD_vs_liars.png")): shutil.copy2(ROOT / src, md / dst) (md / "README.md").write_text(model_card_m()) api.create_repo(MODEL_M, repo_type="model", exist_ok=True, token=token) api.upload_folder(repo_id=MODEL_M, repo_type="model", folder_path=str(md), token=token, commit_message="RACE-Net-M weights, card and code") print("model:", f"https://huggingface.co/{MODEL_M}") def publish_playground(api, token): sys.path.insert(0, str(Path(__file__).resolve().parent)) from make_playground import build sp = build(STAGE.parent / (STAGE.name + "_play")) api.create_repo(PLAY, repo_type="space", space_sdk="static", exist_ok=True, token=token) api.upload_folder(repo_id=PLAY, repo_type="space", folder_path=str(sp), token=token, commit_message="RoboRACE liar playground") print("playground:", f"https://huggingface.co/spaces/{PLAY}") def main(): ap = argparse.ArgumentParser() ap.add_argument("--model-only", action="store_true") ap.add_argument("--playground-only", action="store_true") ap.add_argument("--dry-run", action="store_true") ap.add_argument("--skip-space", action="store_true") ap.add_argument("--space-only", action="store_true") a = ap.parse_args() if a.model_only or a.playground_only: from huggingface_hub import HfApi (publish_model if a.model_only else publish_playground)(HfApi(), os.environ["HF_TOKEN"]) return if a.space_only: from huggingface_hub import HfApi publish_space(HfApi(), os.environ["HF_TOKEN"]) print("space:", f"https://huggingface.co/spaces/{SPACE}") return stage() if a.dry_run: return token = os.environ.get("HF_TOKEN") if not token: sys.exit("set HF_TOKEN") from huggingface_hub import HfApi api = HfApi() api.create_repo(DS, repo_type="dataset", exist_ok=True, token=token) api.upload_folder(repo_id=DS, repo_type="dataset", folder_path=str(STAGE), token=token, commit_message="RoboRACE: code, cached agent outputs, results, media, SO-101 renders") print("dataset:", f"https://huggingface.co/datasets/{DS}") if not a.skip_space: publish_space(api, token) print("space:", f"https://huggingface.co/spaces/{SPACE}") if (ROOT / "models/racenet/model.safetensors").exists(): publish_model(api, token) if (ROOT / "models/racenet_m/model.safetensors").exists(): publish_model_m(api, token) publish_playground(api, token) if __name__ == "__main__": main()