#!/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()))