Datasets:
Download scripts/make_architecture.py from Nabidnur/RoboRACE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 23.5 kB
-
https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/scripts/make_architecture.py
- Command line
-
hf download hf://datasets/Nabidnur/RoboRACE-Bench/scripts/make_architecture.py
-
curl -L -o make_architecture.py https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/scripts/make_architecture.py
23.5 kB
| #!/usr/bin/env python3 | |
| """Architecture diagrams in the style of Sebastian Raschka's LLM architecture figures | |
| (grey outer container, coloured repeated block with an "N x" badge, white component boxes, | |
| residual "+" nodes, thin leader lines to side annotations). Numbers come from the real | |
| checkpoint config / safetensors header, not from memory. | |
| media/architecture/cosmos_reason2_verifier.png Cosmos-Reason2-2B (Qwen3-VL) as our success verifier | |
| media/architecture/race_s.png RACE-S fusion model | |
| media/architecture/roborace_system.png full system across the three tracks | |
| """ | |
| from pathlib import Path | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt # noqa: E402 | |
| from matplotlib.patches import Circle, FancyArrowPatch, FancyBboxPatch # noqa: E402 | |
| OUT = Path("media/architecture") | |
| OUT.mkdir(parents=True, exist_ok=True) | |
| GREY_BG, GREY_EDGE = "#ececec", "#b5b5b5" | |
| INK = "#1f2937" | |
| TEAL, TEAL_BG = "#0f766e", "#b9e3dc" | |
| BLUE, BLUE_BG = "#1d4ed8", "#cddcff" | |
| AMBER, AMBER_BG = "#b45309", "#fde3b8" | |
| ROSE, ROSE_BG = "#be123c", "#fbd0da" | |
| VIOLET_BG = "#e4dafc" | |
| plt.rcParams.update({"font.family": "DejaVu Sans", "savefig.bbox": "tight", "figure.dpi": 170}) | |
| def box(ax, x, y, w, h, text="", fc="white", ec=INK, lw=1.2, r=0.012, fs=9, bold=False, color=INK, z=3, ls="-"): | |
| ax.add_patch(FancyBboxPatch((x, y), w, h, boxstyle=f"round,pad=0,rounding_size={r}", fc=fc, ec=ec, lw=lw, | |
| zorder=z, ls=ls)) | |
| if text: | |
| ax.text(x + w / 2, y + h / 2, text, ha="center", va="center", fontsize=fs, color=color, zorder=z + 1, | |
| fontweight="bold" if bold else None) | |
| def arrow(ax, x0, y0, x1, y1, color=INK, lw=1.2, z=2, style="-|>", ms=9, ls="-"): | |
| ax.add_patch(FancyArrowPatch((x0, y0), (x1, y1), arrowstyle=style, mutation_scale=ms, color=color, lw=lw, | |
| zorder=z, linestyle=ls, shrinkA=0, shrinkB=0)) | |
| def plus(ax, x, y, r=0.011): | |
| ax.add_patch(Circle((x, y), r, fc="white", ec=INK, lw=1.1, zorder=4)) | |
| ax.text(x, y - 0.001, "+", ha="center", va="center", fontsize=10, zorder=5) | |
| def note(ax, x_from, y_from, x_txt, y_txt, text, color=INK, fs=8, ha="left"): | |
| ax.plot([x_from, x_txt - (0.006 if ha == "left" else -0.006)], [y_from, y_txt], color=color, lw=0.7, zorder=1) | |
| ax.text(x_txt, y_txt, text, fontsize=fs, color=color, va="center", ha=ha, zorder=5) | |
| def canvas(w=11, h=12.5): | |
| fig = plt.figure(figsize=(w, h)) | |
| ax = fig.add_axes([0, 0, 1, 1]) | |
| ax.set_xlim(0, 1) | |
| ax.set_ylim(0, 1) | |
| ax.axis("off") | |
| return fig, ax | |
| # ============================================================== Cosmos-Reason2-2B verifier | |
| def cosmos(): | |
| fig, ax = canvas(11.5, 11.6) | |
| ax.set_ylim(0, 0.905) | |
| ax.text(0.5, 0.89, "Cosmos-Reason2 2B · as RoboRACE's success verifier", ha="center", fontsize=16, | |
| fontweight="bold", color=TEAL) | |
| ax.text(0.5, 0.872, "Qwen3-VL architecture · 2.44 B parameters (counted from the safetensors header) · runs on 4 CPU cores", | |
| ha="center", fontsize=9, color="#4b5563") | |
| # ---------------- LLM decoder container | |
| X0, W = 0.40, 0.30 | |
| box(ax, X0 - 0.03, 0.07, W + 0.06, 0.78, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| # input / embedding | |
| box(ax, X0 + 0.04, 0.085, W - 0.08, 0.035, "Tokenized text + image tokens", fs=8.5) | |
| arrow(ax, X0 + W / 2, 0.12, X0 + W / 2, 0.145) | |
| box(ax, X0 + 0.02, 0.145, W - 0.04, 0.04, "Token embedding layer", fc="#f3f4f6", fs=9) | |
| note(ax, X0 + W - 0.02, 0.165, 0.80, 0.165, "Vocabulary size: 151,936\nEmbedding dim: 2,048 (311 M params)", fs=8) | |
| arrow(ax, X0 + W / 2, 0.185, X0 + W / 2, 0.215) | |
| # repeated transformer block | |
| BY, BH = 0.215, 0.405 | |
| box(ax, X0, BY, W, BH, fc=TEAL_BG, ec=TEAL, lw=1.6, r=0.02, z=1) | |
| ax.text(X0 + W + 0.008, BY + BH - 0.02, "28×", fontsize=15, fontweight="bold", color=TEAL) | |
| cx = X0 + W / 2 | |
| y = BY + 0.025 | |
| comps = [("RMSNorm 1", "#ffffff", 0.035), ("Grouped-query attention\n+ QK-norm · interleaved M-RoPE", "#ffffff", 0.07), | |
| (None, None, 0.0), ("RMSNorm 2", "#ffffff", 0.035), ("Feed forward (SwiGLU)", "#ffffff", 0.05), (None, None, 0.0)] | |
| ys = {} | |
| arrow(ax, cx, BY, cx, y) | |
| for i, (name, fc, h) in enumerate(comps): | |
| if name is None: | |
| plus(ax, cx, y + 0.012) | |
| ys[f"plus{i}"] = y + 0.012 | |
| arrow(ax, cx, y + 0.023, cx, y + 0.05) | |
| y += 0.05 | |
| continue | |
| box(ax, X0 + 0.035, y, W - 0.07, h, name, fs=8.6) | |
| ys[name] = (y, h) | |
| arrow(ax, cx, y + h, cx, y + h + 0.02) | |
| y += h + 0.02 | |
| # residual skips | |
| for top_key, bottom_y in (("plus2", BY + 0.012), ("plus5", ys["plus2"] + 0.02)): | |
| ty = ys[top_key] | |
| ax.plot([cx, X0 + 0.018, X0 + 0.018, cx - 0.011], [bottom_y, bottom_y, ty, ty], color=INK, lw=1.0, zorder=2) | |
| # attention details | |
| ay, ah = ys["Grouped-query attention\n+ QK-norm · interleaved M-RoPE"] | |
| note(ax, X0 + W - 0.035, ay + ah / 2, 0.80, ay + ah / 2 + 0.035, | |
| "16 query heads · 8 key/value groups\nhead dim 128 · RoPE θ = 5,000,000\nM-RoPE sections (t, h, w) = (24, 20, 20)\n" | |
| "context 262,144 tokens", fs=8) | |
| fy, fh = ys["Feed forward (SwiGLU)"] | |
| note(ax, X0 + W - 0.035, fy + fh / 2, 0.80, fy + fh / 2 - 0.01, "SiLU-gated 2,048 → 6,144 → 2,048", fs=8) | |
| note(ax, X0 + W, BY + 0.06, 0.80, BY + 0.05, "28 decoder layers = 1,409 M params", fs=8, color=TEAL) | |
| # top: final norm + head | |
| arrow(ax, cx, BY + BH, cx, BY + BH + 0.025) | |
| box(ax, X0 + 0.035, BY + BH + 0.025, W - 0.07, 0.035, "Final RMSNorm", fs=9) | |
| arrow(ax, cx, BY + BH + 0.06, cx, BY + BH + 0.085) | |
| box(ax, X0 + 0.02, BY + BH + 0.085, W - 0.04, 0.04, "Linear output layer (2,048 → 151,936)", fc="#f3f4f6", fs=8.6) | |
| note(ax, X0 + W - 0.02, BY + BH + 0.105, 0.80, BY + BH + 0.112, "untied in this checkpoint (311 M)", fs=8) | |
| arrow(ax, cx, BY + BH + 0.125, cx, BY + BH + 0.15, color=AMBER, lw=1.6) | |
| # our head | |
| hy = BY + BH + 0.15 | |
| box(ax, X0 - 0.025, hy, W + 0.05, 0.06, "", fc=AMBER_BG, ec=AMBER, lw=1.5) | |
| ax.text(cx, hy + 0.04, "RoboRACE verifier head (no training)", ha="center", fontsize=9, fontweight="bold", color=AMBER) | |
| ax.text(cx, hy + 0.017, "P(success) = σ( logsumexp ℓ[yes-tokens] − logsumexp ℓ[no-tokens] )\n" | |
| "one forward pass · 1.4 s / view on CPU", ha="center", fontsize=7.2, color=AMBER, va="center") | |
| note(ax, X0 + W + 0.025, hy + 0.03, 0.80, hy + 0.03, "→ ACL / rank-Gauss calibration\n→ RACE-S fusion across cameras", | |
| color=AMBER, fs=8) | |
| # ---------------- vision encoder (left) | |
| VX, VW = 0.05, 0.25 | |
| box(ax, VX - 0.02, 0.10, VW + 0.04, 0.53, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| ax.text(VX + VW / 2, 0.615, "Vision encoder (ViT)", ha="center", fontsize=11, fontweight="bold", color=BLUE) | |
| box(ax, VX + 0.02, 0.115, VW - 0.04, 0.035, "Camera view (≤ 448×448)", fs=8.5) | |
| arrow(ax, VX + VW / 2, 0.15, VX + VW / 2, 0.17) | |
| box(ax, VX + 0.01, 0.17, VW - 0.02, 0.045, "Patch embedding\n16×16 px × 2 frames → 1,024", fs=8) | |
| arrow(ax, VX + VW / 2, 0.215, VX + VW / 2, 0.24) | |
| box(ax, VX, 0.24, VW, 0.24, fc=BLUE_BG, ec=BLUE, lw=1.6, r=0.02, z=1) | |
| ax.text(VX + VW - 0.045, 0.488, "24×", fontsize=13, fontweight="bold", color=BLUE) | |
| box(ax, VX + 0.025, 0.255, VW - 0.05, 0.03, "LayerNorm", fs=8) | |
| box(ax, VX + 0.025, 0.30, VW - 0.05, 0.045, "Multi-head self-attention\n16 heads · 2-D RoPE", fs=8) | |
| box(ax, VX + 0.025, 0.36, VW - 0.05, 0.03, "LayerNorm", fs=8) | |
| box(ax, VX + 0.025, 0.405, VW - 0.05, 0.045, "MLP (GELU-tanh)\n1,024 → 4,096 → 1,024", fs=8) | |
| for y0, y1 in ((0.285, 0.30), (0.345, 0.36), (0.39, 0.405)): | |
| arrow(ax, VX + VW / 2, y0, VX + VW / 2, y1) | |
| ax.text(VX + VW / 2, 0.233, "302 M params", fontsize=7.5, color=BLUE, ha="center", va="top") | |
| arrow(ax, VX + VW / 2, 0.48, VX + VW / 2, 0.51) | |
| box(ax, VX + 0.01, 0.51, VW - 0.02, 0.05, "2×2 patch merger MLP\n4×1,024 → 2,048 (one token / 32 px)", fs=8) | |
| gx = 0.345 # routing channel between the two columns | |
| ax.plot([VX + VW - 0.01, gx, gx], [0.535, 0.535, 0.1025], color=BLUE, lw=1.5, zorder=2) | |
| arrow(ax, gx, 0.1025, X0 + 0.04, 0.1025, color=BLUE, lw=1.5) # image tokens into the input sequence | |
| ax.text(gx - 0.008, 0.62, "image tokens\n(≈196 per view)", fontsize=8, color=BLUE, ha="center") | |
| # deepstack | |
| for k, yy in enumerate((0.31, 0.37, 0.43)): | |
| arrow(ax, VX + VW - 0.005, yy, X0, 0.25 + 0.04 * k, color=BLUE, lw=0.9, ls=(0, (3, 2)), ms=7) | |
| ax.text(VX + VW / 2, 0.075, "dashed = DeepStack: ViT layers 5, 11, 17 are\nadded to the first LLM layers (merger + DeepStack 101 M)", | |
| fontsize=7.5, color=BLUE, ha="center") | |
| # legend / provenance | |
| ax.text(0.03, 0.03, "Config: nvidia/Cosmos-Reason2-2B config.json · parameter counts from model.safetensors header · " | |
| "style after S. Raschka's LLM architecture figures", fontsize=7.2, color="#6b7280") | |
| fig.savefig(OUT / "cosmos_reason2_verifier.png") | |
| plt.close(fig) | |
| # ============================================================== RACE-S | |
| def race_s(): | |
| fig, ax = canvas(12, 7.2) | |
| ax.text(0.5, 0.965, "RACE-S · score-level Receiver-Anchored Channel Estimation", ha="center", fontsize=15, | |
| fontweight="bold", color=TEAL) | |
| ax.text(0.5, 0.925, "label-free · per episode cost O(J) after fitting · fit cost O(T·J·iters)", ha="center", | |
| fontsize=9, color="#4b5563") | |
| # agents column | |
| names = ["front (receiver)", "left", "right", "back", "top"] | |
| cols = [TEAL_BG, BLUE_BG, ROSE_BG, ROSE_BG, BLUE_BG] | |
| for i, (n, c) in enumerate(zip(names, cols)): | |
| y = 0.74 - i * 0.13 | |
| box(ax, 0.02, y, 0.13, 0.08, f"camera agent\n{n}", fc=c, fs=8.2) | |
| box(ax, 0.17, y + 0.015, 0.07, 0.05, "VLM\np_j(t)", fs=8) | |
| arrow(ax, 0.15, y + 0.04, 0.17, y + 0.04) | |
| arrow(ax, 0.24, y + 0.04, 0.29, 0.44 + (2 - i) * 0.03) | |
| # calibration | |
| box(ax, 0.29, 0.30, 0.12, 0.30, "", fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| box(ax, 0.30, 0.47, 0.10, 0.08, "rank-Gauss\nz = Φ⁻¹(F̂_j(p))", fs=8) | |
| box(ax, 0.30, 0.34, 0.10, 0.08, "clone\ntempering\nw_j = 1/|group|", fs=7.8) | |
| ax.text(0.35, 0.31, "per-agent, label-free", fontsize=7, ha="center", color="#6b7280") | |
| arrow(ax, 0.41, 0.45, 0.46, 0.45) | |
| # EM core | |
| box(ax, 0.46, 0.18, 0.30, 0.58, fc=TEAL_BG, ec=TEAL, lw=1.6, r=0.02, z=0) | |
| ax.text(0.61, 0.735, "anchored EM", fontsize=11, fontweight="bold", color=TEAL, ha="center") | |
| box(ax, 0.48, 0.60, 0.26, 0.08, "latent truth y ∈ {−1,+1}\nz_j | y ~ N(b_j + s_j·y, v_j)", fs=8.4) | |
| box(ax, 0.48, 0.47, 0.26, 0.09, "E-step\nr_t = σ( Σ_j w_j·2s_j(z_tj − b_j)/v_j + log π )\ninit: from the receiver only", fs=7.8) | |
| box(ax, 0.48, 0.33, 0.26, 0.10, "M-step + RACE priors\ns_own ≥ 0.5 (receiver ≥ 75% acc.)\npeers: s_j ← soft-thr(s_j, 1·SE_j)", fs=7.8) | |
| box(ax, 0.48, 0.20, 0.26, 0.09, "signed weights λ_j = 2 w_j s_j / v_j\n> 0 trust · < 0 INVERT · ≈ 0 discard", fs=7.8, | |
| fc=AMBER_BG, ec=AMBER) | |
| arrow(ax, 0.61, 0.47, 0.61, 0.43) | |
| arrow(ax, 0.61, 0.33, 0.61, 0.29) | |
| ax.annotate("", xy=(0.745, 0.52), xytext=(0.745, 0.38), arrowprops=dict(arrowstyle="-|>", color=TEAL, lw=1.2, | |
| connectionstyle="arc3,rad=-0.5")) | |
| ax.text(0.77, 0.45, "iterate\nto conv.", fontsize=7.5, color=TEAL) | |
| # output | |
| arrow(ax, 0.76, 0.245, 0.81, 0.245) | |
| box(ax, 0.81, 0.19, 0.17, 0.11, "fused log-odds\nŷ = Σ_j λ_j (z_j − b_j)\ndecision: ŷ > 0", fs=8.2) | |
| box(ax, 0.81, 0.48, 0.17, 0.2, "online variant\n(sleeper defence):\nfit on the most recent\nunlabelled window\ninstead of a stale\nhistory", fs=8, fc=VIOLET_BG, | |
| ec="#6d28d9") | |
| ax.text(0.02, 0.06, "Identification: without the anchor, EM is symmetric in y ↔ −y and liar majorities flip it (Dawid–Skene " | |
| "failure). Pinning the receiver's loading positive breaks the symmetry, so coherent liars receive negative weight " | |
| "and their reports are inverted and reused.", fontsize=8, color=INK, wrap=True) | |
| fig.savefig(OUT / "race_s.png") | |
| plt.close(fig) | |
| # ============================================================== system | |
| def system(): | |
| fig, ax = canvas(13, 7.6) | |
| ax.text(0.5, 0.965, "RoboRACE system · three agent swarms, one receiver-anchored principle", ha="center", | |
| fontsize=15, fontweight="bold", color=INK) | |
| lanes = [("Track A · perception", 0.66, TEAL_BG, TEAL, | |
| ["SO-101 / tabletop\nrollout (MuJoCo)", "5 cameras ×\nCosmos-Reason2-2B", "attack zoo\n(7 attacks)", | |
| "ACL / rank-Gauss\ncalibration", "RACE-S (online)", "success / failure\n→ retry or replan"]), | |
| ("Track B · control", 0.40, BLUE_BG, BLUE, | |
| ["12 robots,\nk-NN radio graph", "noisy target\nmeasurements", "Byzantine robots\n(6 attacks)", | |
| "channel estimates\nbias_ij, var_ij", "RACE-C gate +\nW-MSR consensus", "rendezvous at\ntarget"]), | |
| ("Track C · language", 0.14, AMBER_BG, AMBER, | |
| ["instruction +\nscene", "4 LLM planners\n(+ saboteurs)", "spec + few-shot\nprompting", "symbolic validator\n(grounding / VAL)", | |
| "repair loop\n(LLM-Modulo)", "RACE vote over\ncanonical plans"])] | |
| for title, y, bg, ec, steps in lanes: | |
| box(ax, 0.02, y - 0.02, 0.96, 0.22, fc=bg, ec=ec, lw=1.4, r=0.02, z=0) | |
| ax.text(0.03, y + 0.175, title, fontsize=11, fontweight="bold", color=ec) | |
| for i, s in enumerate(steps): | |
| x = 0.04 + i * 0.158 | |
| box(ax, x, y + 0.01, 0.135, 0.13, s, fs=8.4) | |
| if i < len(steps) - 1: | |
| arrow(ax, x + 0.135, y + 0.075, x + 0.158, y + 0.075) | |
| ax.text(0.5, 0.06, "Benchmarks: RoboRACE-Bench (A/B/C, bootstrap-ranked) · ERQA (embodied reasoning, 400 Q) · " | |
| "PlanBench Blocksworld (plan generation, VAL-equivalent validator)", ha="center", fontsize=9, color="#4b5563") | |
| fig.savefig(OUT / "roborace_system.png") | |
| plt.close(fig) | |
| # ============================================================== RACE-Net | |
| def racenet(): | |
| fig, ax = canvas(10.5, 11.5) | |
| ax.set_ylim(0, 0.955) | |
| ax.text(0.5, 0.93, "RACE-Net-V 0.2M · amortized receiver-anchored truth inference", ha="center", fontsize=15, | |
| fontweight="bold", color="#6d28d9") | |
| ax.text(0.5, 0.91, "verification model (pick-and-place camera swarm) · axial set transformer · 213,889 parameters · synthetic training only, CPU", | |
| ha="center", fontsize=9, color="#4b5563") | |
| X0, W = 0.33, 0.34 | |
| cx = X0 + W / 2 | |
| box(ax, X0 - 0.03, 0.05, W + 0.06, 0.825, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| box(ax, X0 + 0.01, 0.065, W - 0.02, 0.045, "Window of unlabelled swarm reports\nT episodes × J agents (receiver = column 0)", fs=8.2) | |
| note(ax, X0 + W - 0.01, 0.087, 0.74, 0.087, "any T and J (no positional encodings):\npermutation-equivariant over episodes and peers", fs=8) | |
| arrow(ax, cx, 0.11, cx, 0.13) | |
| box(ax, X0 + 0.03, 0.13, W - 0.06, 0.035, "Rank-Gauss per agent (label-free)", fc="#f3f4f6", fs=8.6) | |
| note(ax, X0 + W - 0.03, 0.147, 0.74, 0.147, "z = Φ⁻¹(rank / T): invariant to any monotone\nmiscalibration of an agent's scores", fs=8) | |
| arrow(ax, cx, 0.165, cx, 0.185) | |
| box(ax, X0 + 0.02, 0.185, W - 0.04, 0.045, "Token embedding MLP [z, tanh 2z, z²−1] → 64\n+ receiver embedding on column 0", fc="#f3f4f6", fs=8.2) | |
| note(ax, X0 + W - 0.02, 0.207, 0.74, 0.207, "the receiver flag is the anchor:\nthe only agent assumed honest", fs=8, color="#6d28d9") | |
| arrow(ax, cx, 0.23, cx, 0.26) | |
| BY, BH = 0.26, 0.425 | |
| box(ax, X0, BY, W, BH, fc=VIOLET_BG, ec="#6d28d9", lw=1.6, r=0.02, z=1) | |
| ax.text(X0 + W + 0.008, BY + BH - 0.022, "4×", fontsize=15, fontweight="bold", color="#6d28d9") | |
| y = BY + 0.02 | |
| arrow(ax, cx, BY, cx, y) | |
| plus_y = [] | |
| start = BY + 0.008 | |
| for norm, name, h in (("LayerNorm 1", "Row attention across AGENTS\n(within one episode · 4 heads)", 0.055), | |
| ("LayerNorm 2", "Column attention across EPISODES\n(within one agent · 4 heads)", 0.055), | |
| ("LayerNorm 3", "Feed forward (GELU) 64 → 128 → 64", 0.04)): | |
| box(ax, X0 + 0.05, y, W - 0.10, 0.026, norm, fs=7.8) | |
| arrow(ax, cx, y + 0.026, cx, y + 0.038) | |
| box(ax, X0 + 0.035, y + 0.038, W - 0.07, h, name, fs=8.2) | |
| py = y + 0.038 + h + 0.022 | |
| arrow(ax, cx, y + 0.038 + h, cx, py - 0.011) | |
| plus(ax, cx, py) | |
| ax.plot([cx, X0 + 0.016, X0 + 0.016, cx - 0.011], [start, start, py, py], color=INK, lw=1.0, zorder=2) | |
| plus_y.append(py) | |
| start = py + 0.014 | |
| arrow(ax, cx, py + 0.011, cx, py + 0.028) | |
| y = py + 0.028 | |
| note(ax, X0 + W - 0.035, BY + 0.085, 0.74, BY + 0.085, "who agrees with whom right now", fs=8) | |
| note(ax, X0 + W - 0.035, BY + 0.215, 0.74, BY + 0.215, "in-context channel estimation: how each\nagent's stream relates to the others over\nthe window (trust · invert · ignore)", fs=8) | |
| arrow(ax, cx, BY + BH, cx, BY + BH + 0.02) | |
| box(ax, X0 + 0.05, BY + BH + 0.02, W - 0.10, 0.03, "Final LayerNorm", fs=8.6) | |
| arrow(ax, cx, BY + BH + 0.05, cx, BY + BH + 0.07) | |
| box(ax, X0 + 0.02, BY + BH + 0.07, W - 0.04, 0.045, "Readout MLP on [receiver token, mean over agents]\n128 → 64 → 1", fc="#f3f4f6", fs=8.2) | |
| arrow(ax, cx, BY + BH + 0.115, cx, BY + BH + 0.135, color=AMBER, lw=1.6) | |
| box(ax, X0 - 0.01, BY + BH + 0.135, W + 0.02, 0.04, "log-odds of task success for every episode", fc=AMBER_BG, ec=AMBER, lw=1.5, fs=9, | |
| bold=True, color=AMBER) | |
| # left: where it sits | |
| box(ax, 0.02, 0.30, 0.22, 0.30, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| ax.text(0.13, 0.575, "replaces", ha="center", fontsize=10, fontweight="bold", color=INK) | |
| box(ax, 0.035, 0.47, 0.19, 0.08, "RACE / RACE-S:\nhand-specified latent-truth\nmodel + EM per window", fs=7.8) | |
| box(ax, 0.035, 0.34, 0.19, 0.10, "RACE-Net:\none forward pass that has\nLEARNED the inference\nfrom simulated swarms", fs=7.8, fc=VIOLET_BG, ec="#6d28d9") | |
| arrow(ax, 0.13, 0.47, 0.13, 0.44) | |
| ax.text(0.03, 0.02, "Training: synthetic swarms only (heterogeneous skill, correlated honest errors, attack zoo with up to J−1 liars). " | |
| "No benchmark data, labels or agent outputs.", fontsize=7.2, color="#6b7280") | |
| fig.savefig(OUT / "racenet.png") | |
| plt.close(fig) | |
| def racenet_m(): | |
| fig, ax = canvas(11.5, 11.5) | |
| ax.set_ylim(0, 0.955) | |
| TEAL_ = "#0f766e" | |
| ax.text(0.5, 0.93, "RACE-Net-M 45K · receiver-anchored channel estimation on a map", ha="center", fontsize=15, | |
| fontweight="bold", color=TEAL_) | |
| ax.text(0.5, 0.91, "map-fusion model (maze swarm) · anchored channel encoder + peer transformer + signed read-out · 44,837 parameters · CPU", | |
| ha="center", fontsize=9, color="#4b5563") | |
| X0, W, NX = 0.25, 0.42, 0.715 | |
| cx = X0 + W / 2 | |
| box(ax, X0 - 0.02, 0.05, W + 0.04, 0.825, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| box(ax, X0 + 0.02, 0.065, W - 0.04, 0.055, "Peer broadcasts: P peers × N cells\nclaim ∈ {none, free, wall}, recent / old flag\n+ the receiver's own sensed cells", fs=8) | |
| note(ax, X0 + W - 0.02, 0.092, NX, 0.092, "peers and cells are sets (no positions):\nany map size, any swarm size", fs=8) | |
| arrow(ax, cx, 0.12, cx, 0.145) | |
| box(ax, X0 + 0.02, 0.145, W - 0.04, 0.055, "Anchored counts per peer: claim × truth\non cells the receiver SENSED ITSELF\n(recent and old claims counted separately)", fc="#f3f4f6", fs=8) | |
| note(ax, X0 + W - 0.02, 0.172, NX, 0.172, "the anchor: the receiver's own sensor is\nthe only trusted evidence\n(no labels, no majority)", fs=8, color=TEAL_) | |
| arrow(ax, cx, 0.20, cx, 0.235) | |
| BY, BH = 0.235, 0.46 | |
| box(ax, X0, BY, W, BH, fc="#d9f0ec", ec=TEAL_, lw=1.6, r=0.02, z=1) | |
| ax.text(X0 + 0.012, BY + BH - 0.03, "3 refinement rounds", fontsize=9, fontweight="bold", color=TEAL_) | |
| y = BY + 0.02 | |
| arrow(ax, cx, BY, cx, y) | |
| mids = [] | |
| blocks = (("Soft counts per peer on cells the receiver has NOT sensed:\nclaim × current belief of all the OTHER peers", 0.055), | |
| ("Channel embedding MLP (36 → 48) + round embedding\ninput: hard counts, soft counts, coverage", 0.055), | |
| ("Transformer across PEERS\n2 layers · 4 heads · pre-norm", 0.055), | |
| ("Signed read-out (48 → 4): evidence of 'wall'\nfor {free, wall} × {old, recent} claims", 0.055), | |
| ("Cell log-odds = bias + Σ over peers of the evidence\nof what each peer claimed about the cell", 0.055)) | |
| for k, (name, h) in enumerate(blocks): | |
| box(ax, X0 + 0.045, y, W - 0.07, h, name, fs=7.9) | |
| mids.append(y + h / 2) | |
| if k < len(blocks) - 1: | |
| arrow(ax, cx + 0.01, y + h, cx + 0.01, y + h + 0.022) | |
| y += h + 0.022 | |
| # feedback loop on the left edge of the block: cell log-odds -> soft counts of the next round | |
| lx = X0 + 0.02 | |
| ax.plot([X0 + 0.045, lx, lx], [mids[-1], mids[-1], mids[0]], color=TEAL_, lw=1.4, zorder=4) | |
| arrow(ax, lx, mids[0], X0 + 0.045, mids[0], color=TEAL_, lw=1.4) | |
| for k, (txt, col) in enumerate((("leave-one-out feedback: a peer is checked against\nwhat everybody else implies, so a robot can verify a\npeer it never met through a peer it already trusts", TEAL_), | |
| ("in-context channel estimation, as in RACE-Net-V:\nhow does this peer's stream relate to the anchor", INK), | |
| ("the estimate of one peer depends on the others\n(who else is reliable, who repeats whom)", INK), | |
| ("signed: a reliable peer is trusted, a consistent liar\nis INVERTED and used, a random one is ignored", TEAL_), | |
| ("claims are conditionally independent given the\ntruth: evidence adds up over peers", INK))): | |
| note(ax, X0 + W - 0.025, mids[k], NX, mids[k], txt, fs=8, color=col) | |
| arrow(ax, cx, y - 0.022, cx, BY + BH + 0.03, color=AMBER, lw=1.6) | |
| box(ax, X0 + 0.03, BY + BH + 0.03, W - 0.06, 0.04, "log-odds that each reported cell is a wall", fc=AMBER_BG, ec=AMBER, lw=1.5, fs=9, bold=True, color=AMBER) | |
| arrow(ax, cx, BY + BH + 0.07, cx, BY + BH + 0.095) | |
| box(ax, X0 + 0.02, BY + BH + 0.095, W - 0.04, 0.05, "Planner: block a cell above 2 log-odds. If the goal then looks walled off,\nun-believe only the claims that enclose it (reachability repair)", fc="#f3f4f6", fs=7.8) | |
| box(ax, 0.01, 0.30, 0.20, 0.30, fc=GREY_BG, ec=GREY_EDGE, r=0.02, z=0) | |
| ax.text(0.11, 0.575, "replaces", ha="center", fontsize=10, fontweight="bold", color=INK) | |
| box(ax, 0.02, 0.47, 0.18, 0.08, "race_map:\nhand-written Bayesian\nmodel averaging over\n49 channel types", fs=7.6) | |
| box(ax, 0.02, 0.34, 0.18, 0.10, "RACE-Net-M:\nthe channel estimator\nis LEARNED from\nsimulated swarms", fs=7.6, fc="#d9f0ec", ec=TEAL_) | |
| arrow(ax, 0.11, 0.47, 0.11, 0.44) | |
| ax.text(0.03, 0.02, "Training: maze swarms with random two-coin liars and change points only. The benchmark's attack names never appear in training; " | |
| "the colluding ring attack is outside that family.", fontsize=7.2, color="#6b7280") | |
| fig.savefig(OUT / "racenet_m.png") | |
| plt.close(fig) | |
| if __name__ == "__main__": | |
| racenet() | |
| racenet_m() | |
| cosmos() | |
| race_s() | |
| system() | |
| print(sorted(p.name for p in OUT.iterdir())) | |