RoboRACE-Net-M / README.md
Nabidnur's picture
RACE-Net-M weights, card and code
18ade57 verified
|
Raw History Blame Contribute Delete
6.01 kB
---
license: other
license_name: roborace-mixed
license_link: https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/blob/main/LICENSES.md
library_name: pytorch
pipeline_tag: other
tags: [robotics, multi-agent, byzantine-robustness, map-fusion, truth-inference, set-transformer, roborace]
datasets: [Nabidnur/RoboRACE-Bench]
model-index:
- name: RACE-Net-M
results:
- task: {type: other, name: Byzantine-robust map fusion}
dataset: {name: RoboRACE-Bench Track D, type: Nabidnur/RoboRACE-Bench, config: trackD_maze_results, split: train}
metrics:
- {type: spl, value: 70.2, name: mean SPL x100 over 500 cells}
---
# RACE-Net-M — receiver-anchored channel estimation for map fusion
**A 44,837-parameter model that fuses the map reports of a robot swarm when some robots lie.**
Part of [RoboRACE](https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench) · sibling model for camera swarms: [RACE-Net-V](https://huggingface.co/Nabidnur/RoboRACE-Net) ·
[showcase Space](https://huggingface.co/spaces/Nabidnur/RoboRACE) · code: [github.com/Hisernberg/robotics](https://github.com/Hisernberg/robotics)
<p align="center"><img src="racenet_m_architecture.png" width="640"></p>
## 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 (3 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("Nabidnur/RoboRACE-Net-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
45,361 snapshots from simulated maze swarms (maze seeds 5000–7399) 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. 4,000 AdamW steps on a CPU (8 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 % |
|---:|---|---:|---:|---:|---:|---:|
| 1 | **RACE-Net-M + reachability repair (this model)** | 70.2 | 76.8 | 73.1 | 66.8 | 97.8 |
| 2 | **RACE-Net-M (this model)** | 69.8 | 76.8 | 72.6 | 66.4 | 97.4 |
| 3 | race_map (hand-written Bayesian rule, ours) | 66.2 | 76.8 | 69.7 | 61.8 | 94.2 |
| 4 | W-MSR-style trimming (LeBlanc et al. 2013; F known) | 64.1 | 76.8 | 65.6 | 61.5 | 96.5 |
| 5 | beta-reputation (Jøsang & Ismail 2002) | 63.8 | 76.8 | 67.9 | 58.5 | 91.9 |
| 6 | EigenTrust (Kamvar et al. 2003) | 63.0 | 75.0 | 66.8 | 58.2 | 91.8 |
| 7 | Dawid–Skene (1979), unanchored | 62.0 | 76.3 | 67.4 | 55.5 | 90.1 |
| 8 | no communication | 61.6 | 61.5 | 62.0 | 61.2 | 95.2 |
| 9 | naive map merging | 56.7 | 76.8 | 59.9 | 51.7 | 83.8 |
| 10 | per-cell majority | 55.7 | 76.8 | 61.5 | 48.1 | 82.1 |
| – | *oracle that knows the liars (reference)* | 71.3 | 76.8 | 74.5 | 67.5 | 98.2 |
<p align="center"><img src="trackD_vs_liars.png" width="900"></p>
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) | 90.1 | 82.7 | 72.9 |
| rounds = 1 (no refinement) | 91.8 | 85.7 | 76.1 |
| rounds = 2 | 92.2 | 86.4 | 77.4 |
| rounds = 3 (released) | 92.3 | 86.7 | 77.6 |
| rounds = 3, second seed | 92.3 | 86.7 | 77.6 |
## 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)