|
Download README.md from Nabidnur/RoboRACE-Net-M: direct link, hf CLI and curl.
- Browser
- Download file 6.01 kB
-
https://huggingface.co/Nabidnur/RoboRACE-Net-M/resolve/main/README.md
- Command line
-
hf download hf://Nabidnur/RoboRACE-Net-M/README.md
-
curl -L -o README.md https://huggingface.co/Nabidnur/RoboRACE-Net-M/resolve/main/README.md
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) | |