liveexperiments are running around the clock on a RunPod Secure Cloud pod — one RTX 4090 (24 GB) at $0.69/hr — every result lands on this page automatically as the loop commits it
Alexis Rondeau · an autonomous research project

Everything we tried: Experiment model designs

Every model design the research loop has proposed, one figure per experiment — a proper technical drawing of the computation one camera frame takes through the network, from pixels to (lat, lon, confidence). Kept and reverted alike, so you can see exactly what each experiment tried and compare designs side by side.

This is where you can actually follow the search: read one figure and you understand that experiment's design; read them in order and you watch the architecture evolve, one focused change at a time. Every figure is drawn and locked in before training runs, alongside a falsifiable hypothesis and a predicted outcome — so what you're comparing across experiments is the design as proposed, not a diagram redrawn after the fact to match a result already known. One shared visual contract across every proposal (tensors drawn as tensors, operations as operations, no labeled boxes) is what makes them directly comparable, figure to figure.

Read top to bottom to watch the design evolve: a kept proposal (ink rule, left) becomes the trunk the next experiment branches from; a discarded one — trained, scored, reverted — stays on the record at the same standard, dead branches included. Each caption is the experiment's own pre-registered plain-words explanation; click through for the full hypothesis, method, and scoreboard in the research log. (Figures 1–6 predate the loop — bootstrap-era designs pre-registered as text, drawn to this standard after the fact; from experiment 7 on, every figure is the headless agent's own, drawn before training ran.)

INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractthe experiment goes herearchitecture · feature extraction · decode · confidence — the agent may redraw all of iteach figure below is one proposal for the inside of this boxwhatever fills the box must export to one ONNX file ≤ 4 MiB and answer in ≤ 250 msfrozen contract(lat, lon, confidence)position fix + confidencelosses · supervision targets · samplersscaffolding that shapes the weights during training — torn down before flight, never in the exported model

The shape every figure on this page shares. The gray endpoints are the harness's frozen contract — one low-light camera crop in, one (lat, lon, confidence) answer out — and the dashed box is the entire search space: each experiment below is one way of filling it. The ochre lane underneath holds the training signals: the losses, targets and samplers that shape the weights during training and are torn down before flight — they never board the aircraft.

frozen contract — harness endpoints the design under test what this experiment changed training-only — never flies

38 proposals · 13 kept · updated 2026-07-22 21:47 UTC

Fig. 1 Starting baseline — naive TinyLocNet, from-scratch, frozen pipeline v1 kept — new best, 3.22 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 3sigmoidone shotfrozen contract(lat, lon, confidence)position fix + confidencemean-squared error on (u, v)the whole map supervises one number pairBCE ×0.1 on confidencestarting design — nothing changed yet

In plain words. The deliberately-dumb starting point. A tiny neural network looks at a single 128 m square of aerial photo and, in one shot, blurts out two numbers: how far across and how far up the map that view belongs. With so little capacity and training it effectively learns to always point near the middle of the map, which is why its guesses are ~3.2 km off. Its only job is to be the reference every later experiment must beat.

architecture · from-scratch · 2026-07-20 · commit b47d44a8 · full experiment record →

Fig. 2 DSNT-style spatial probability field over the map replaces direct (u,v) regression kept — new best, 2.49 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingcross-entropy: match a Gaussian bump on the true cellσ = 1.5 cells — every cell gets a hotter/colder gradientL2 on the decoded (u, v)

In plain words. Instead of blurting out one guess, the network now lays a 32×32 grid of cells over the map and gives each cell a score for “the photo probably came from here” — a heat map of suspicion. Its answer is the balance point (weighted average) of that heat map. Training became much more informative — every cell is told individually whether it should have been hotter or colder — and the error improved from ~3.2 km to ~2.5 km. Remaining weakness: averaging a spread-out heat map drags answers toward the middle of the map.

architecture · from-scratch · changed: Probability map, Decode, Training signal · 2026-07-20 · commit ff65590e · full experiment record →

Fig. 3 Argmax-anchored local soft-argmax decode replaces global expected-coordinate discarded — 2.94 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapargmax → 5×5 window soft-argmaxcommit to the hottest cell, refine locallyfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingcross-entropy vs Gaussian cell target (unchanged)L2 on the WINDOWED decodetrain on exactly what flies

In plain words. An attempted fix for experiment 2's “dragged toward the middle” problem. Rather than averaging the whole heat map, the model first commits to the single hottest cell, then fine-tunes its answer using only the 5×5 neighborhood around it — decide roughly where first, then refine locally. It backfired: the hottest cell is apparently often wrong (the heat maps are still too scattered), so committing to it made the error worse (~2.9 km vs ~2.5 km) and the change was reverted.

architecture · from-scratch · changed: Decode · 2026-07-20 · commit ff65590e · full experiment record →

Fig. 4 ACE-style dense per-patch scene-coordinate regression replaces global map-cell probability field discarded — 2.56 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128dilated conv 3×3, d2~95 px context per cell64 per-patch coordinates1×1 conv + σ (8×8×2)mean of 64 answersone committee answer from 64 votesfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingsmooth-L1: each patch vs its OWN true coordinatecrop center + rotated offset → 64× denser supervision

In plain words. Rather than one verdict per photo, the network was made to answer 64 times per photo: the image is split into an 8×8 grid of patches, and each patch must separately name the map coordinate of the ground it shows (the training data knows the right answer for every patch). The final position is the average of those 64 mini-answers. The hope: 64× more feedback per photo forces the network to learn which ground textures give away a location. It scored slightly worse than the heat-map approach (~2.56 km vs ~2.49 km), so it was reverted.

architecture · from-scratch · changed: Per-patch coordinates, Decode, Training signal · 2026-07-20 · commit 7d02e02d · full experiment record →

Fig. 5 Hierarchical coarse-to-fine supervision of the probability field via probability pooling discarded — 2.52 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingsum-pool the SAME field to 16², 8², 4² — Gaussian-CE at every scalecoarse cells collect 10–40 positives each and steer the fine field (+ L2 on decode, unchanged)

In plain words. The model localizes by painting a heat map over a 32x32 grid of the area — but we only have enough training photos to give most grid squares zero examples, so the heat map never learned to commit and stayed lukewarm everywhere. The fix is to grade the same heat map at several zoom levels at once: first 'did you put the heat in the right quarter of the map?', then the right sixteenth, and so on down to the fine grid. Coarse questions have plenty of examples to learn from, and getting them right automatically steers the fine answer — like learning an address by first nailing the district, then the street, then the house.

loss · from-scratch · changed: Training signal · 2026-07-20 · commit 7d02e02d · full experiment record →

Fig. 6 Per-epoch rotation resampling replaces the one-shot frozen training tensor discarded — 2.51 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingcrop rotations re-drawn EVERY epochfresh views of the same places each pass, not one frozen tensor reused 8×Gaussian-CE + L2 (unchanged)

In plain words. Until now the model studied each training photo from one fixed compass direction only -- like memorizing your neighborhood while always facing north, then being quizzed while facing random directions. Unsurprisingly, it froze on the quiz. Now, every time it re-reads its study deck, every photo is re-dealt at a new random rotation, so the only way to get good grades in practice is to recognize places no matter which way it is facing -- which is exactly what the real quiz (and a real drone) demands.

augmentation · from-scratch · changed: Training signal · 2026-07-20 · commit de614d47 · full experiment record →

Fig. 7 Scale training coverage 7.5x: 6,000 of ~45k available train locations per bucket (was 800) pivot kept — new best, 2.33 km
Camera frame1 of 6 lighting renders128×128×364²×1632²×3216²×648²×128Feature extractor4 strided conv blocks · ~230k params128-d embeddingglobal average pool128 → 1024probability field32×32 map cells · ~220 m/cellsoft-argmaxexpected coordinate over cell centers(lat, lon, confidence)position + confidenceu,v ∈ [0,1] map coords → lat, lonconf head (linear + sigmoid)training onlywas: 800 places/bucketnow: 6,000 places/bucketof ~45,000 available×7.5 coverage — every map cell now trainedin every lighting bucket; ~4,500 steps (was 600)Gaussian-CE on smoothed cell target + coord L2 + conf BCE (unchanged)one static crop per place at one random heading (unchanged, per exp-6)

In plain words. The model has been studying flashcards covering only about 2% of the map — most neighborhoods were never shown to it at all, in any lighting. The last four experiments all tried smarter study techniques and none helped, which suggests the problem was never the technique: you can't recognize a place you've never seen. This experiment changes nothing about the model or how it learns — it just hands it 7.5 times more flashcards, enough that every part of the map appears in the deck under every lighting condition. Training takes a few minutes longer per area, which was affordable all along.

training · from-scratch · changed: Training signal · 2026-07-20 · commit 76c45e3c · full experiment record →

Fig. 8 Deployment-envelope residual encoder: 4.2× capacity (232k → 973k params), 11 conv layers with skips discarded — 2.43 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contract+++residual encoder — 11 conv layersstem + 3 stride-2 stages, each ending in a residual block~973k params, 4.2× the old 4-conv stack3.7 of the 4.0 MiB flight-memory budget (was 0.9)64²×328²×160160-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingGaussian-CE + L2 + conf BCE (unchanged)same lessons, same 36k crops, same 8 epochs — only the student grew

In plain words. Until now the model was a tiny four-layer network trying to memorize what every corner of a 7 km-wide city looks like — like sketching an entire city map on a sticky note. Recent experiments kept changing how we teach it (better lessons, more flashcards) and nothing broke through, because the student's notebook was simply full: it scored almost equally badly in bright daylight and at night, the classic sign of a model too small for its task rather than a task too hard. The flight computer actually has room for a model four times bigger than the one we've been flying. This experiment keeps the lessons exactly the same and only swaps in a deeper, four-times-larger network — built with 'residual' shortcuts, a standard trick that keeps deep networks easy to train — so it finally has enough room to write the whole map down.

architecture · from-scratch · changed: Feature extractor · 2026-07-20 · commit 76c45e3c · full experiment record →

Fig. 9 Cross-lighting contrastive pairs: NT-Xent metric learning on the place descriptor discarded — 2.34 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-dGAPFC → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessing=same placetraining batches become PAIRS — same place, two lighting renders, two headingsone shared 6,000-location set across all 6 renders · 32 places × 2 views per stepNT-Xent: pull the pair together, push 62 others apart64-d projection of the descriptor · τ 0.2 · head never fliesGaussian-CE + L2 + conf BCE — unchanged

In plain words. The model has been describing every photo so vaguely that different places end up with nearly identical descriptions — like describing every street as 'houses and a road'. We now train it flash-card style: each round it gets two photos of the exact same spot — say one at noon and one at night, turned to different compass headings — and is graded on giving both the same description, while its descriptions of the 62 other places in the round must stay clearly different. That pressure forces it to notice what makes each place unique, which is exactly what pointing to the right spot on the map requires.

loss · from-scratch · changed: Training signal · 2026-07-20 · commit 76c45e3c · full experiment record →

Fig. 10 Layout-aware field head: squeezed 8×8 spatial code ⊕ GAP replaces GAP-only head input kept — new best, 2.30 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×1281×1 conv → 8²×8 layout codekeeps what sits WHERE in the crop128-d GAPtexture average — as before512 ⊕ 128 = 640FC 640 → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingGaussian-CE + decode L2 + conf BCE — all unchangedtraining recipe identical to kept exp 7; only the head's input changedred = this experiment: the field head reads an 8×8 layout code ⊕ texture average

In plain words. Until now the model summarized each aerial photo as a recipe list — 'this much road, this much rooftop, this much trees' — with no memory of where anything sat in the picture. Two different neighborhoods with the same mix of ingredients looked identical to it, which may be why it kept guessing near the middle of the map. This experiment adds a second, position-preserving summary — roads on the left, courtyard in the middle, park at the top — and lets the location-guessing layer read both summaries. Places are arrangements, not ingredient lists, so keeping the arrangement should finally let it tell lookalike districts apart.

architecture · from-scratch · changed: Layout summary, Probability map · 2026-07-20 · commit ff271753 · full experiment record →

Fig. 11 ImageNet-pretrained MobileNetV3-Small trunk replaces the from-scratch encoder kept — new best, 2.01 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractMobileNetV3-Small encoder — ImageNet-pretrainedstem + 8 inverted-residual blocks · depthwise conv + squeeze-excite64²×168²×481×1 conv → 8²×8 layout codekeeps what sits WHERE in the crop48-d GAPtexture average — as before512 ⊕ 48 = 560FC 560 → 1024 logitssoftmaxprobability field32×32 cells over the mapsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingtrunk weights arrive from ImageNet (1.2M real photos) — not randomfine-tuned gently: trunk lr 1e-4 · fresh heads lr 1e-3 · BSD-3 licensedGaussian-CE + decode L2 + conf BCE — all unchangedhead, decode and training recipe identical to kept exp 10red = this experiment: an ImageNet-pretrained trunk replaces the from-scratch encoder

In plain words. Until now the model's 'eyes' started out completely blind: they had to learn to see edges, corners and textures using only pictures of the one training area -- like learning to read from a single book. This experiment swaps in eyes that were already trained on 1.2 million everyday photographs, so they arrive knowing how to see, and we only gently retune them to our night-time aerial views. Everything after the eyes -- the part that guesses the position on the map -- stays exactly the same. If the guesses were bad because the eyes were weak, this should help a lot; if not, we have learned the eyes were never the problem.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) · changed: Feature extractor · 2026-07-21 · commit d69862d9 · full experiment record →

Fig. 12 Luminance-gated dark-expert field head blended with the existing layout head kept — new best, 1.86 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractMobileNetV3-Small trunkImageNet-pretrained · stem + 8 inverted-residual blocks (exp 11, unchanged)128²×38²×48layout code1×1 conv, unchanged8²×848-d GAPunchanged∑/nraw-pixel mean brightnesslighting gatetiny MLP → sigmoidg ∈ [0,1]bright headFC 560→1024dark head — NEWFC 48→1024, GAP-onlyblend(1−g)b + g·dprobability field32×32 cells, unchangedsoft-argmax over ALL cellsanswer = Σ probability · cell-centerfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingcross-entropy + decode L2 (unchanged)gate + dark head train on the SAME lossesno lighting label — g learns from brightness ⊕ GAPred = this experiment: gated dark-expert head blended with the existing layout head

In plain words. The last experiment gave the model 'eyes' that already knew how to see from a million daytime photos, and it worked -- but only for well-lit shots. At night, that same borrowed vision is guessing worse, because those eyes never really learned what a dark, sparsely-lit scene looks like. This experiment adds a second, smaller decision-maker that only looks at the crop's overall texture (not its detailed layout, which is mostly invisible in the dark anyway), plus a tiny 'how dark is this shot?' switch that blends the two decision-makers' guesses. In bright shots the switch leans on the original, more detailed guesser; in dark shots it leans on the simpler one built for low light. Nothing about the camera or the final answer changes -- just how the guess gets made inside.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3); new dark head + gate are from-scratch · changed: Lighting gate, Probability map · 2026-07-21 · commit fe745eb4 · full experiment record →

Fig. 14 Peak-commit decode: β-sharpened softmax replaces mean-of-map soft-argmax kept — new best, 1.64 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLYred = this experiment: β-sharpened peak-commit decode replaces mean-of-map averaging128²×3camera frameone night exposurefrozen contractMobileNetV3-Small trunkImageNet-pretrained · stem + 8 inverted-residual blocks, unchanged128²×38²×48layout code1×1 conv, unchanged8²×848-d GAPunchanged∑/nraw-pixel mean brightnesslighting gatetiny MLP → σ, unchangedg ∈ [0,1]bright headFC 560→1024dark headFC 48→1024 · GAP-only, unchangedblend(1−g)·b + g·dprobability field32×32 cellsβ·logitssharpened field — NEWsoftmax(β·logits), β = 3peaks boosted, hedging suppressedsoft-argmax over the sharpened fieldcommits to the dominant peakfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingGaussian-CE on the unsharpened field (unchanged)the field keeps learning calibrated evidenceL2 on the SHARPENED decodethe loss now grades the committed answer that flies

In plain words. The model draws a heat map of 'where might this photo be?' over the whole city, then has to give one answer. Until now it answered with the average of every warm spot at once — like aiming a dart at the average of three boards you suspect, which lands you in the wall between them. We now turn up the contrast on the heat map first, so the strongest hotspot dominates and the faint background noise vanishes, and the model answers at that hotspot. It is also graded during training on this committed answer, so it learns to put its hotspot in the right place rather than hedging toward the middle of the map.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3 — unchanged from exp 11) · changed: Decode, Training signal · 2026-07-21 · commit d2a0a2b9 · full experiment record →

Fig. 15 Selective prediction: field-shape confidence head with per-bucket calibrated abstention kept — new best, 1.37 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLYred = this experiment: field-shape confidence + calibrated abstention — unsure crops return no fix128²×3camera frameone night exposurefrozen contractMobileNetV3-Small trunkImageNet-pretrained · stem + 8 inverted-residual blocks, unchanged128²×38²×48layout code1×1 conv, unchanged8²×848-d GAPunchanged∑/nraw-pixel mean brightnesslighting gatetiny MLP → σ, unchangedg ∈ [0,1]bright headFC 560→1024dark headFC 48→1024 · GAP-only, unchangedblend(1−g)·b + g·dprobability field32×32 cellsβ·logitssharpened fieldsoftmax(β·logits)β = 3 — unchangedsoft-argmax over the sharpened fieldcommits to the dominant peak — unchangedfrozen contract(lat, lon, confidence)position fix + confidenceGaussian-CE on the field + L2 on the committed decodeboth unchanged — localization trains exactly as beforepeak massentropymode−mean gap0.3confidence head — learns when to abstaintiny MLP on field shape · calibrated to the frozen 0.3 barbelow the bar → no fix, coast on last estimateconfidence BCE — did the committed fix land within ~350 m?detached head — cannot disturb localizationper-bucket threshold calibration≥40% keep a fix in every lighting bucket

In plain words. Until now the drone's navigator shouted out a position guess for every single photo, even the hopeless ones, and those wild guesses dragged its accuracy score down. This change teaches it to look at its own heat map of candidate locations and notice the difference between one crisp hotspot (sure) and a washed-out smear of weak maybes (not sure) — and in the unsure case to say 'no fix this time', letting the drone coast on its last known position for a few extra seconds, which the mission profile explicitly allows. The scoring rules have always worked this way — only answers it commits to count, as long as it doesn't stay silent too often — so we tuned it to keep answering at least 40% of the time in every lighting condition, double the required minimum.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) · changed: Confidence, Training signal · 2026-07-21 · commit f3b87247 · full experiment record →

Fig. 16 C4 rotation-vote field: average field logits over the crop's four 90° turns kept — new best, 1.09 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of six lighting rendersfrozen contractrotation fan0°·90°·180°·270° — exact pixel turnsshared weights ×4MobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map's shape (unchanged)may abstaininvariance by construction, not by dataexp 6 taught headings by example — reverted; this builds them inGaussian-CE + decode L2 + conf BCE — all unchangedthe losses now grade the voted answer — train what flies

In plain words. A drone photo can be taken facing any direction, but during practice the model only ever saw each place from one direction — so at test time it often fails to recognize a spot simply because the picture is turned. The fix: show the model every photo four times — spun by 0°, 90°, 180° and 270° — and let the four looks vote on where the drone is. A wrong guess that only appears at one spin gets outvoted; the right answer keeps winning at every spin. Same brain, four glances, one vote.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (unchanged from exp 11) · changed: Rotation fan, Probability map · 2026-07-21 · commit 5c5373df · full experiment record →

Fig. 17 Nuisance-randomized training renders: each bucket's training crops drawn from three seeded realizations of the frozen relighting sim kept — new best, 1.05 km
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of six lighting rendersfrozen contractrotation fan0°·90°·180°·270° — exact pixel turnsshared weights ×4MobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map's shape (unchanged)may abstainGaussian-CE + decode L2 + conf BCE — all unchangedthe losses now grade the voted answer — train what fliesseed₀= the eval renderseed₁fresh dice rollseed₂fresh dice rolleach training crop is drawn from one of three seeded realizationsnuisance-randomized training rendersthe frozen relight sim rolls dice for sensor noise + lamp thinning; the stored night render freezes ONE roll,≈ half that image's content (mean |Δpx| 29/255 between rolls vs 6/255 at midday; render mean 60/255)→ the 1024-way head memorizes roll-specific texture that cannot transfer to held-out locations.Training now draws each bucket's crops from three seeded rolls (⅓ each), so only the seed-stablestructure — roads, buildings, where the lit areas sit — stays discriminative between locations.eval renders, model, losses, decode, calibration: all unchanged — train-time only

In plain words. The model learns night navigation from simulated night photos, and the simulator rolls dice for two things: the grainy sensor static, and which streetlights and lit windows happen to be on. Until now, every practice photo of a place used one single dice roll, frozen forever — so the model could ace practice by memorizing the static, like recognizing a photocopy by its smudges instead of reading it. On new places the smudges are different, and it gets lost exactly where the picture is mostly smudge: at night. Now the practice photos come from three different dice rolls of the same city, so the only thing worth memorizing is what is actually there — the roads, the buildings, and where the lit areas sit.

relighting · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) · changed: Training data · 2026-07-21 · commit 95b4c3a0 · full experiment record →

Fig. 18 Dense per-patch field voting: 64 local place votes with learned fusion replace the global 1024-way template head discarded — 1.14 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of six lighting rendersfrozen contractrotation fan0°·90°·180°·270°shared weights ×4MobileNetV3-Small trunkImageNet init (BSD-3)8²×48 ×4patch votersevery cell = one voter64 per-patch field votesshared 1×1 MLP 48→128→1024 — one field per patch⋯ ×64 votes, each × learned weight wᵖ (softmax over patches)voted probability fieldweighted blend of 64 patch votesmean over 4 turns (unchanged)β-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map's shape (unchanged)may abstaindense per-patch supervision — 64 graded answers per cropeach patch's vote is graded against a Gaussian bump on the map cell of ITS OWN ground content,computed exactly at train time as crop center + R(heading)·patch offset — a place can no longer berecognized by one whole-crop gestalt: all 64 voters must independently know where their ground sitsprobe, midday, matched headings: train-crop median 267–400 m vs held-out 708–1153 m — the global template head memorizes but does not generalizefused-field Gaussian-CE + decode L2 + conf BCE — unchanged · three-realization training renders (exp 17) — unchanged · calibration unchanged

In plain words. Until now the model looked at the whole photo at once and asked 'which spot in the city does this whole picture remind me of?' -- like recognizing a street from a single glance. Our measurement shows it does that three times better on places it studied than on the gaps in between, which is exactly where it gets tested. Now each of 64 small tiles of the photo votes independently -- 'my little piece of ground belongs THERE' -- and a learned referee counts trustworthy tiles more heavily before merging the votes. Even over unfamiliar ground, a few tiles usually catch a road or building the model does know, and those few good votes can carry the answer.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) -- unchanged from exp 11 · changed: Patch voters, Vote fusion, Training signal · 2026-07-21 · commit 48e17da6 · full experiment record →

Fig. 19 Off-site distractor patching: half the training crops carry a pasted block of terrain from elsewhere, labels unchanged discarded — 1.24 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centrehalf of each bucket’s training crops are patched before batchingcrop from elsewheresame lighting bucketlift a 48–96 px blockpatched training croplabel: still the true centreoff-site distractor patching — p = 0.5, training onlyeval crops sit on never-trained blocks: the centre terrain is always unfamiliar, familiar terrainpokes in from an edge (~76% of eval crops contain some trained pixels). The probe behind exp 18:train-split crops localize to 267–400 m, eval-split to 708–1153 m — a ~3× structural gap, in every bucket.Training crops were always 100% familiar, so the whole-crop head never practised partial recognition;patched crops force it to answer from the content consistent with one place and down-weight the rest.

In plain words. When the drone flies over ground the model never studied, most of the picture is new to it -- but a corner usually shows land it does know. Until now, every practice picture the model ever saw was 100% familiar ground, so it never learned what to do with a half-strange view: one odd patch throws off its whole answer. We now sabotage half of the practice pictures by pasting in a square from somewhere else in the same city, while keeping the answer key unchanged. To keep scoring well, the model must learn to base its answer on the parts of the picture that fit together and shrug off the parts that don't -- like solving a jigsaw with a few pieces from the wrong box mixed in.

augmentation · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged from exp 11 · changed: Training data · 2026-07-21 · commit d5080d5d · full experiment record →

Fig. 20 Per-epoch training-set resampling: a fresh 6,000-location draw per bucket every epoch replaces the one frozen 36k-crop tensor kept — new best, 839.1 m
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centreepoch 1epoch 2… epoch 8a fresh draw of 6,000 locations per bucket, every epochevery epoch, training restarts on a freshly drawn set of placesper-epoch location resampling — same training budget, 8× the places seenthe last kept model studied the SAME 36,000 crops for all 8 epochs — same places, same headings,same simulator rolls — so memorizing each crop was the easiest way down the training loss.Now every epoch redraws its 6,000 locations per bucket (fresh headings and render mix): ~30k of the45k train places get seen, each only ~1–2×. Memorizing single crops stops paying; only cues thattransfer between places do — the skill an eval crop over never-trained terrain actually demands.

In plain words. Until now the model studied the exact same 36,000 flashcards eight times over, so it started remembering individual cards instead of learning to read terrain. Cards it had memorized it could place well, but over ground it had never studied -- which is exactly what the test uses -- it was three times worse. Now it gets a brand-new deck drawn from the whole training area on every pass: same study time, eight times more distinct places, each seen only once or twice. Remembering single cards stops working, so the only strategy that pays off is learning what actually makes a place recognizable -- the skill it needs over terrain it has never seen.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) -- unchanged from exp 11 · changed: Training data · 2026-07-21 · commit cac6ec61 · full experiment record →

Fig. 22 Train-only per-patch place supervision: every feature cell places its own patch, the flying decode is untouched discarded — 1.13 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centreepoch 1epoch 2… epoch 8a fresh draw of 6,000 locations per bucket, every epochevery epoch, training restarts on a freshly drawn set of placeskept from exp 20 — unchangedtrunk feature grid 8²×48identity turn · read before pooling64 per-patch map fields — 3 of 64 shownone shared 1×1 conv 48→1024 · training-only, deleted before exportNEW — per-patch place supervisionevery feature cell must place ITS OWN16 m patch of ground on the map, gradedby a Gaussian bump at that patch's truespot = crop centre + rotated cell offset.64 graded answers per crop instead of 1.The flying network is untouched — theaux head never ships.

In plain words. Until now the model got one graded question per practice photo: 'where is the CENTER of this photo on the map?' A student can pass that test by memorizing whole photos -- which fails on parts of the city held back from practice. Now, during practice only, every small tile of the photo also gets its own graded question: 'where does THIS tile sit on the map?' -- 64 grades per photo instead of one. To score well the network must learn what roads, buildings and field edges actually look like from above, knowledge that transfers to never-practiced places. On the real flight nothing changes: the extra quiz machinery is thrown away before takeoff and the aircraft carries exactly the same network as before.

loss · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Training signal · 2026-07-21 · commit 9df5c839 · full experiment record →

Fig. 23 Daytime-redraw auxiliary: a throwaway decoder must reconstruct the clean daytime crop from the encoder's features gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centreepoch 1epoch 2… epoch 8a fresh draw of 6,000 locations per bucket, every epochevery epoch, training restarts on a freshly drawn set of placeskept from exp 20 — unchangedtrunk feature grid 8²×48identity turn · read before pooling16²32²64²throwaway upsampling decoder8²→64² · ~55k params · never exported64²×3redrawn daytime viewfrom features alone64²×3daytime reference cropsame spot & heading, free from simL1 ×0.3NEW — daytime-redraw auxiliaryfrom its own features, the netmust redraw this spot in cleandaylight; all six renders shareone daytime answer, so seeingthrough grain and darkness is thecheapest fit — decoder never flies

In plain words. The network learns to recognize places from noisy night photos. We gave it one extra practice exercise: from its internal impression of a scene, it must also sketch what that exact spot looks like in clean daylight — like a student proving they truly saw through the darkness by redrawing the street in daytime colors. The sketching module is thrown away before anything flies, so the aircraft carries nothing extra. What remains is a network whose mental image of the ground ignores darkness and sensor grain — and if its inner picture is always the daytime one, recognizing the place gets easier in every lighting condition at once.

loss · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) · changed: Training signal · 2026-07-21 · commit adfc8b91 · full experiment record →

Fig. 24 Daytime-redraw auxiliary, rerun: exp 23 was OOM-killed mid-harness, never scored — retest it with a memory-lean epoch sampler discarded — 915.7 m, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centreepoch 1epoch 2… epoch 8a fresh draw of 6,000 locations per bucket, every epochevery epoch, training restarts on a freshly drawn set of placeskept from exp 20 — unchangedtrunk feature grid 8²×48identity turn · read before pooling16²32²64²throwaway upsampling decoder8²→64² · ~55k params · never exported64²×3redrawn daytime viewfrom features alone64²×3daytime reference cropsame spot & heading, free from simL1 ×0.3NEW — daytime-redraw auxiliaryfrom its own features, the netmust redraw this spot in cleandaylight; all six renders shareone daytime answer, so seeingthrough grain and darkness is thecheapest fit — decoder never flies

In plain words. Last iteration we designed a promising exercise for the network: from its internal impression of a dark, noisy night photo, it must also sketch what that exact spot looks like in clean daylight — like a student proving they truly saw through the darkness by redrawing the street in daytime colors. The sketching module is thrown away before anything flies, so the aircraft carries nothing extra. But the experiment never actually ran: the training computer ran out of memory and the operating system silently killed one of the four training jobs, so the scoreboard recorded a bogus worst-possible number. This iteration re-runs the exact same exercise after fixing the memory waste (the training data was being copied twice for no reason) — now the whole thing uses LESS memory than the setup that has worked for weeks, and the idea finally gets its fair test.

loss · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) · changed: Training signal · 2026-07-21 · commit 5794e840 · full experiment record →

Fig. 25 Convergence-scaled training: 3× optimizer steps with cosine LR decay under the kept fresh-draw sampler kept — new best, 797.9 m
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3 · ~1 m/pxcamera frameone of six lighting rendersfrozen contractshared weights ×4rotation fan0°·90°·180°·270° — exact pixel turnsMobileNetV3-Small trunkImageNet init (BSD-3) · gently fine-tuned8²×48 ×41024 logits ×4four field mapssame gated two-expert head reads each turn32×32 cellsvoted probability fieldmean of four logit maps = geometric-mean voteβ-sharpened soft-argmaxcommits to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the voted map’s shape (unchanged)may abstainposition + confidence losses — all unchangedGaussian-CE + decode L2 + conf BCE — still graded at the true centreepoch 1epoch 2… epoch 24a fresh draw of 6,000 locations per bucket, every epochevery epoch, training restarts on a freshly drawn set of placesLRbefore: constant LR, hard stop at epoch 8now: cosine glide to zero across a 3× longer runconvergence-scaled training — 3× the steps, annealed to zeroThe fresh-draw sampler (kept, left) made memorizing crops useless — but theschedule still stops at 8 passes, loss still falling, LR never lowered.A probe shows pure underfit: train crops now localize no better thaneval crops (~1 km both). This run trains 24 fresh-draw passes with theLR gliding down a cosine — the same sampler, finally trained to converge.

In plain words. The previous improvement gave the model fresh flashcards every study pass so it could no longer cram answers — but we kept ringing the end-of-class bell at the same early time, set back when cramming made classes short. Its grades were still climbing when the bell rang. This experiment simply lets it study three times longer, and — like slowing down smoothly before parking — makes each learning step gentler toward the end so what it learned settles in place. The model that flies is completely unchanged; only the length and pacing of school changes.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Training schedule · 2026-07-21 · commit 7f8a2986 · full experiment record →

Fig. 26 Deployment-envelope capacity scaling: 3× pretrained trunk depth paid for by int8 FC-head storage gated fail — reverted
Camera frame128²×3, ~1 m/pxfrozen contractRotation fanfour 90° turns×4stem + early64²×16mid blocks16²×24blocks 4–88²×48blocks 9–10 — newdilated — 8²×96layout code608-dint8 FC store — newquantized at export · ~7 m effectσlighting gateProbability map32×32 cells, C4 voteDecodesharpened balance pointConfidenceabstains on smeared maps(lat, lon,confidence)frozen contracttraining-only lane — unchanged: Gaussian-CE map target · committed-coord L2 · conf BCE · 24 fresh-draw epochs, cosine LR → 0

In plain words. Last round we gave the model three times longer to study and it finished everything it could hold — yet scores barely moved. That means its brain is full: it isn't failing to study, it's out of room. The drone's flight computer caps the model file at 4 MB and we were already near the cap, but we found that the biggest part of the file — a huge table of connection strengths — works just as well stored as cheap 1-byte numbers instead of exact 4-byte ones (we measured: answers move by ~7 meters on errors of ~700). The space that trick frees pays for a three-times-bigger image-understanding brain, borrowed from the same well-trained library the model already uses.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..10] (torchvision, BSD-3) · changed: Feature extractor, Probability map · 2026-07-21 · commit 4fb65e2a · full experiment record →

Fig. 27 Unseen-ground confidence calibration unlocks the reinstated 3×-capacity trunk gated fail — reverted
Camera frame128²×3, ~1 m/pxfrozen contractRotation fanfour 90° turns×4stem + early64²×16mid blocks16²×24blocks 4–88²×48blocks 9–10 — reinstateddilated — 8²×96layout code608-dint8 FC store — reinstatedquantized at export · ~7 m effectσlighting gateProbability map32×32 cells, C4 voteDecodesharpened balance pointConfidenceabstains on smeared maps(lat, lon,confidence)frozen contractabstain bar set on held-back ground — new~10% of train blocks never enter a training draw;the bar is tuned on ground as unseen as the exam'straining-only lane — losses and schedule unchanged: Gaussian-CE map target · committed-coord L2 · conf BCE · 24 fresh-draw epochs, cosine LR → 0

In plain words. Last round we gave the model a bigger brain and its guesses genuinely got better — but the result was thrown out on a technicality. The model is allowed to say 'no fix' when unsure, and the rules demand it answers at least 20% of the time. We tune its shyness bar using places from its own training tour, and the bigger brain became so much more confident about places it had already visited than about new ones that the bar landed wildly wrong for new ground: it went nearly silent on the exam. The fix is to fence off a slice of the map the model never gets to study and tune the shyness bar there — on ground exactly as unfamiliar as the exam's. Same bigger brain, bar set honestly.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..10] (torchvision, BSD-3) · changed: Feature extractor, Probability map, Confidence, Training data · 2026-07-21 · commit cc3faa2c · full experiment record →

Fig. 28 Rerun, never scored: unseen-ground confidence calibration + reinstated 3x trunk (iter 7 died on a full disk before training) discarded — 1.06 km, reverted
Camera frame128²×3, ~1 m/pxfrozen contractRotation fanfour 90° turns×4stem + early64²×16mid blocks16²×24blocks 4–88²×48blocks 9–10 — reinstateddilated — 8²×96layout code608-dint8 FC store — reinstatedquantized at export · ~7 m effectσlighting gateProbability map32×32 cells, C4 voteDecodesharpened balance pointConfidenceabstains on smeared maps(lat, lon,confidence)frozen contractabstain bar set on held-back ground — new~10% of train blocks never enter a training draw;the bar is tuned on ground as unseen as the exam'straining-only lane — losses and schedule unchanged: Gaussian-CE map target · committed-coord L2 · conf BCE · 24 fresh-draw epochs, cosine LR → 0

In plain words. Two rounds ago we gave the model a bigger brain and its guesses genuinely got better — but the result was thrown out on a technicality: the bar for when the model may say 'no fix, not sure' was tuned on places it had already visited, and the bigger brain is so much more confident on visited ground that the bar landed wildly wrong for new ground — it went nearly silent on the exam. Last round we designed the honest fix — fence off a slice of the map the model never studies and tune the bar there — but the computer's hard drive filled up before training even began, so that experiment was marked 'failed' without ever actually running. The disk problem is fixed; this round simply runs the same experiment for real.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..10] (torchvision, BSD-3) · changed: Feature extractor, Probability map, Confidence, Training data · 2026-07-22 · commit 83bf925a · full experiment record →

Fig. 29 Stride-8 fine-layout tap: the field scorer reads an 8-m-resolution mid-trunk snapshot, int8-paid discarded — 798.5 m, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of 6 lighting rendersfrozen contractC4 rotation fan4 turns, logits averaged64²×168²×4816²×24MobileNetV3-Small trunkImageNet-pretrained blocks 0–8 — unchanged1×1 conv 24 → 4 ch · flatten → 1,024-dGAP · 1×1 layout squeezecrop summary — 1,584-d48-d GAP + 512-d 8×8 layout (as before)+ 1,024-d stride-8 fine code — newnight gate blends a 48-d dark scorer per crop (unchanged)FC 1,584 → 1,024 logitsweight tables fly int8 — measured ±7 mprobability field32×32 cells · C4 logit vote (unchanged)β-sharpened soft-argmaxcommit to the dominant mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads its own field shapeGaussian-CE (σ=1.5 cells) + decode-L2 + conf-BCE — unchangedtraining procedure unchanged — 24 fresh-draw epochs, cosine LR → 0

In plain words. Before guessing where it is, the model boils each camera frame down to a short summary — like describing a neighborhood in 560 numbers, where each number can only talk about 16-metre-wide squares. At that coarseness, two similar districts blur together, and our last three experiments proved that a bigger brain and longer studying don't help — the tell-apart detail was already thrown away before the guessing stage ever saw it. This experiment keeps everything else identical but lets the guesser also look at a sharper, earlier snapshot from inside the network, where building edges and narrow roads are still visible at roughly 8-metre precision. To keep the file small enough for the drone's tiny computer, the guesser's bulky lookup tables are stored as compact 1-byte numbers — a trick we measured beforehand to be harmless.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Layout summary, Probability map · 2026-07-22 · commit 7e6fb3ea · full experiment record →

Fig. 30 Supervised lighting dispatcher: day/dusk/night specialist field heads replace the two-expert blend, int8-paid pivot discarded — 808.2 m, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of 6 rendersfrozen contractC4 rotation fan4 turns, logits voted64²×168²×48MobileNetV3-Small trunkImageNet-pretrained, blocks 0–88×8 layout squeeze1×1 conv → 512-dGAP 48-d560-d560-d descriptor48 texture ⊕ 512 layoutday specialistFC 560 → 1,024 eachdusk specialistnight specialist× w₁× w₂× w₃lighting dispatchersoftmax → w₁,w₂,w₃crop brightnessprobability field32×32 cells · C4 logit voteβ-sharpened soft-argmaxcommits to the dominant modefrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1may abstain instead of guessingcross-entropy on the routing weights vs the TRUE lighting bucketbuckets group as day / dusk / night — the labels are free at train timespecialists' FC weights ride int8 in the exported ONNXexport-only pack — ~7 m cost measured (exps 26/29); 3 full heads fit the 4 MiB gateGaussian-CE + decode L2 + conf BCE — unchangedtraining data & schedule also unchanged (24 fresh-draw passes)

In plain words. The model recognizes places by comparing what it sees against a big internal catalog of how every map cell looks. Until now one shared catalog had to describe each place at noon AND at midnight — like one photo album trying to cover both — so every entry was a blurry compromise, and the model coped in the dark mostly by refusing to answer. We split it into three catalogs — day, dusk, night — and added a tiny receptionist that checks how bright the frame is and hands the image to the right catalog. During practice the receptionist is simply told the real time of day, so it can't learn the routing wrong. Three catalogs would normally be too heavy for the drone's tiny computer, so they're stored in a compact 1-byte number format we measured earlier to be essentially harmless.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — trunk unchanged; the three specialist heads and the dispatcher are fresh-initialized · changed: Lighting dispatcher, Probability map, Training signal · 2026-07-22 · commit 92404766 · full experiment record →

Fig. 31 Neural-map correlation field: localization becomes sliding-window matching of a crop fingerprint against a learned 32 m map raster pivot discarded — 846.1 m, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone of 6 rendersfrozen contractrotation fan4 turns, voted at the field64²×168²×48MobileNetV3-Small trunkpretrained, gently fine-tuned4×4×8crop fingerprint1×1 conv + 2×2 pool · each tap = 32 m of groundbright/dark variants blended by the kept gateslide across the map8 ch × ~217×~213learned neural map32 m per cell · lives in the weightsmatch-score field~45,000 positions · softmax32 m pitch — was 217 msharpened soft-argmaxcommit to the hottest mode (unchanged)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1reads the map's shape — may abstainGaussian-CE + decode L2 + conf BCE — unchangedsame σ (≈330 m tolerance) in map units, graded on the ~45k-position fieldtraining data, sampler & 24-epoch cosine schedule unchanged

In plain words. Until now the model answered 'where am I?' by comparing one overall impression of the camera frame against about a thousand memorized district flashcards -- and in a city full of lookalike districts, overall impressions collide. Now the model instead paints its own miniature map of the whole area into its weights while training. In flight it turns the camera frame into a small 4x4 fingerprint tile and slides that tile across its painted map to find where the pattern truly lines up, the way you find where a puzzle piece belongs. Because the whole arrangement inside the fingerprint has to line up -- not just the general vibe -- two neighborhoods that merely feel similar no longer fool it, and the answer grid becomes about seven times finer in each direction.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (trunk unchanged); neural map + kernel heads from scratch · changed: Crop fingerprint, Probability map · 2026-07-22 · commit 1ee201ff · full experiment record →

Fig. 32 Risk-controlled abstention: six per-lighting-regime thresholds calibrated on never-trained fenced blocks pivot discarded — 1.08 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING-TIME CALIBRATION — NEVER FLIES128²×3camera frameone of 6 lighting rendersfrozen contractrotation fanfour 90° turnsMobileNetV3-Small trunkpretrained, 9 blocks8²×48crop descriptor512-d layout + 48-d GAPprobability field32×32 cells · two experts · C4 voteβ-sharpened decode — balance point of the hottest modefrozen contract(lat, lon, confidence)position fix + confidencefield-shape statisticspeak · entropy · decode gapself-trust score z− regime abstention bar (interpolated)confidence 0–1conf < 0.3 → 'no fix' (must answer ≥20%)frame brightnesssix regime anchorsabstention bar per regime, blended by frame brightnessfenced calibration blocks~10% of train blocks by stable hash — excluded from everytraining draw, same halo rule as eval blocks (grey);errors are measurable there, terrain is honestly unseenmedian errorq* ≥ 0.26keep rateper-regime operating pointeach lighting regime's keep rate picked at the low pointof its fenced risk–coverage curve (floor 0.32) — the sixthresholds become the anchor row above

In plain words. The model already grades its own guesses and is allowed to answer 'no fix' on frames it can't place — like a student who may skip questions on a test that only grades the questions they answer, as long as they attempt at least 1 in 5. Until now the skip rule was one global bar, tuned on map areas the model had already flown over in training — so how picky it actually was at night versus midday, in Berlin versus Frankfurt, was essentially accidental. We now rope off a slice of the map the model never trains on, measure there — separately for each lighting condition — how accuracy trades against how often it answers, and bake six lighting-specific bars into the model (it senses the lighting from the frame's brightness). A telling detail from the forensics: the last four 'failed' experiments were actually answering MORE questions than the champion at similar accuracy — they lost on a technicality of where their bar happened to land, which this change fixes for every future round too.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Confidence, Training data · 2026-07-22 · commit 4871a8c7 · full experiment record →

Fig. 33 Sensor-sharpness nuisance randomization: per-crop PSF/resampling jitter breaks the blur-texture shortcut pivot gated fail — reverted
Camera frame128²×3 · ~1 m/pxfrozen contractC4 rotation fan4 exact 90° turns4×128²×364²×1616²×248²×48MobileNetV3-Small trunkpretrained, gently fine-tunedGAP 48layout 512lighting gatebrightness-blended pair of scorersσprobability field32×32 cells, C4-vote averagedcommitted decodeβ-sharpened soft-argmax (unchanged)conf: field-shape hit predictor(lat, lon, confidence)frozen contracttraining-only — never fliescrispas todaydefocusedNEW — per-crop sharpness roll¼ pin-sharp (no resample) · ½ extra defocus σ∈U(0.4,1.4) pxfresh 6,000-place draw per bucket per epoch (kept · rd 20)3 seeded relight realizations per bucket (kept · rd 17)24 passes · cosine LR glide to zero (kept · rd 25)Gaussian-bump CE + coord L2 + conf BCE

In plain words. When a computer rotates a photo, the result comes out a tiny bit softer — like a photocopy of a photocopy. Nearly every training picture we generate goes through one such rotation, so they all share that same subtle softness, and the model quietly learned to lean on it as a crutch: when we handed it a perfectly sharp picture, its guesses got twice as bad — even though softness says nothing about WHERE the picture was taken. This round we make the crutch useless: during training, some pictures now arrive pin-sharp and others extra blurry, completely at random, so the only cue that reliably pays off is the actual arrangement of streets and buildings. It's like training a wine taster with the bottles wrapped in paper: hide the label and they have to learn the taste.

augmentation · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (unchanged from champion) · changed: Training data · 2026-07-22 · commit 0aaab0f5 · full experiment record →

Fig. 34 Hardest-impostor margin loss: the field must outrank its best lookalike, not just light up the truth pivot gated fail — reverted
Camera frame128²×3 · ~1 m/pxfrozen contractC4 rotation fan4 exact 90° turns4×128²×364²×1616²×248²×48MobileNetV3-Small trunkpretrained, gently fine-tunedGAP 48layout 512lighting gatebrightness-blended pair of scorersσprobability field32×32 cells, C4-vote averagedcommitted decodeβ-sharpened soft-argmax (unchanged)conf: field-shape hit predictor(lat, lon, confidence)frozen contracttraining-only — never fliesfresh 6,000-place draw per bucket per epoch (kept · rd 20)3 seeded relight realizations per bucket (kept · rd 17)24 passes · cosine LR glide to zero (kept · rd 25)Gaussian-bump CE + coord L2 + conf BCE (kept · unchanged)NEW — hardest-impostor margin · λ 0.5best-scoring cell outside the 7×7 ring around truthmust trail the 3×3 truth block by ≥ 1.0 logittruth 3×3hardest impostor

In plain words. The model scores 1,024 map tiles for each camera frame and we fly toward the highest-scoring one. Until now training only rewarded giving the right tile a decent score — like a teacher handing out partial credit but never checking who came FIRST. Measurements show the right tile usually makes the model's top-20 list, yet almost never ranks #1: some lookalike district across town keeps beating it. The new rule is a police-lineup rule: on every training example, find the one impostor tile the model currently likes best and demand the true tile's neighborhood beat it by a clear gap. The specific impostor that keeps winning gets pushed down, the truth pushed up.

loss · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Training signal · 2026-07-22 · commit bfbca30d · full experiment record →

Fig. 35 Confusability-weighted location sampling: oversample look-alike cell pairs, not just more places pivot kept — new best, 743.1 m current design
Camera frame128²×3 · ~1 m/pxfrozen contractC4 rotation fan4 exact 90° turns4×128²×364²×1616²×248²×48MobileNetV3-Small trunkpretrained, gently fine-tunedGAP 48layout 512lighting gatebrightness-blended pair of scorersσprobability field32×32 cells, C4-vote averagedcommitted decodeβ-sharpened soft-argmax (unchanged)conf: field-shape hit predictor(lat, lon, confidence)frozen contracttraining-only — never fliescell-descriptor mapfrom reference.tif, offline, once per areaNEW — confusability-weighted samplingfar, look-alike cells drawn ~2x more often per epochhalf the draw stays uniform — full-map coverage keptstill 6,000 places/bucket/epoch, fresh-drawn (rd 20 · reweighted only)3 seeded relight realizations per bucket (kept · rd 17)24 passes · cosine LR glide to zero (kept · rd 25)Gaussian-bump CE + coord L2 + conf BCE (kept · unchanged)

In plain words. The model has to recognize 1,024 map tiles from a single photo, and we already know its biggest problem: some far-away tile that just happens to look similar often beats the true tile in the ranking. Until now, training showed the model every tile equally often, whether or not it has a lookalike twin somewhere else on the map. This experiment changes nothing about the model or the grading -- only which practice photos get shown more often. Before training starts, we compare the average color and texture of every tile against every other (a one-time, cheap lookup from the daytime map image itself) and flag pairs of far-apart tiles that look alike. During training, places with a lookalike twin get shown about twice as often as places that look nothing like anywhere else -- half the practice still covers the whole map evenly, so nothing is forgotten, but the confusing pairs get extra practice specifically at telling themselves apart.

training · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Training data · 2026-07-22 · commit 3750ddb6 · full experiment record →

Fig. 36 Hardest-impostor margin hinge, retested on the confusability-weighted champion discarded — 754.2 m, reverted
Camera frame128²×3 · ~1 m/pxfrozen contractC4 rotation fan4 exact 90° turns4×128²×364²×1616²×248²×48MobileNetV3-Small trunkpretrained, gently fine-tunedGAP 48layout 512lighting gatebrightness-blended pair of scorersσprobability field32×32 cells, C4-vote averagedcommitted decodeβ-sharpened soft-argmax (unchanged)conf: field-shape hit predictor(lat, lon, confidence)frozen contracttraining-only — never fliescell-descriptor mapfrom reference.tif, offline, once per areaconfusability-weighted samplingfar, look-alike cells drawn ~2x more often per epochhalf the draw stays uniform — full coverage kept (kept · rd 35)still 6,000 places/bucket/epoch, fresh-drawn (rd 20 · reweighted only)3 seeded relight realizations per bucket (kept · rd 17)24 passes · cosine LR glide to zero (kept · rd 25)+ hardest-impostor margin hinge on C4-voted logits (NEW)hardest-impostor margin hinges_neg (Cheb>3) pushed below s_pos (Cheb≤1)

In plain words. Right now the model's best two guesses for ‘where is this’ are often a real place and a look-alike place somewhere else on the map, and it only barely favors the real one. Last round we made it practice more on exactly those confusing pairs; this round we also change how hard it gets corrected when it still ranks a look-alike above the truth. Instead of a gentle nudge spread thinly over the whole map, it now gets a direct penalty aimed specifically at its single worst rival guess, every time, until the true spot clearly wins.

loss · pretrained:mobilenet_v3_small · changed: Training signal · 2026-07-22 · commit 3ee64311 · full experiment record →

Fig. 37 Multi-hypothesis coordinate regression replaces the 1024-cell field discarded — 1.10 km, reverted
Camera frame128²×3 · ~1 m/pxfrozen contractC4 rotation fan4 exact 90° turns4×128²×364²×1616²×248²×48MobileNetV3-Small trunkpretrained, gently fine-tunedGAP 48layout 512Multi-hypothesis head8 learned points, softmax weightno separate expert4-view weighted voteweight-argmax point per heading, softmax-blendedconf: 4-view agreement × winning weight(lat, lon, confidence)frozen contracttraining-only — never fliescell-descriptor mapfrom reference.tif, offline, once per areaconfusability-weighted samplingfar, look-alike cells drawn ~2x more often per epochhalf the draw stays uniform — full coverage kept (kept · rd 35)still 6,000 places/bucket/epoch, fresh-drawn (rd 20 · reweighted only)3 seeded relight realizations per bucket (kept · rd 17)24 passes · cosine LR glide to zero (kept · rd 25)+ winner-take-all: nearest of 8 hyps gets the L2 grad, others ε=0.05 (NEW)weight head trained by cross-entropy vs. the nearest-hypothesis index (8-way, not 1024-way)winner-take-all regressionnearest hyp wins the gradient; rest share ε=0.05

In plain words. For twenty-some rounds straight, the model has guessed your location the same way: score 1,024 fixed map tiles and pick whichever one scores highest -- like a multiple-choice test with 1,024 options. We measured that the right tile is in the model's own top-20 guesses most of the time, but wins outright only 2% of the time -- so the model roughly knows the neighborhood but keeps losing the final vote to a lookalike tile. This round throws out the fixed 1,024-tile menu and lets the model instead point to 8 of its own candidate spots anywhere on the map, then simply picks whichever one it's most sure about -- like narrowing that multiple-choice test from 1,024 options down to 8, which should be a much easier pick. Each of the four camera headings picks its own best spot, and the four picks get blended by how confident each heading was.

architecture · pretrained:mobilenet_v3_small · changed: Multi-hypothesis head, 4-view weighted vote, Confidence, Training signal · 2026-07-22 · commit 5a6771be · full experiment record →

Fig. 38 Illumination-invariant retinex channel joins raw RGB from the pixel level through the trunk rejected — never trained
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contract6-ch inputRGB ⊕ retinexillumination-invariant channellog(I) − large-σ Gaussian blur, fixedRotation fan4×90° turns, 6chMobileNetV3-Small trunk (9 blocks)pretrained · stem widened, rest frozen64²×68²×48stem re-init 3→6chRGB weights kept + 0.1× copy48-d GAPtexture avg, unchangedlayout squeeze1×1 conv, 8ch512-d layout codeNEW: L2-norm per cellprobability mapgated 2-expert blend, unchangedβ-sharpened decodeC4-voted, unchangedfrozen contract(lat, lon, confidence)position fix + confidenceconfidence: field-shape gauge, unchangedtraining data: confusability draw (kept, exp 35) + NEW per-crop sharpness jitter50% chance Gaussian blur (σ 0.3–1.5px) else unsharp-mask — the blur-riding shortcut can no longer carry location signaltraining schedule: NEW 5%-of-steps linear warm-up before the exp-25 cosine decayprotects the freshly re-initialized stem weights from early large gradientstraining signal: Gaussian-CE + coord L2 + conf BCEunchanged

In plain words. Every version of this model so far has looked at the photo exactly as the camera sees it -- raw colors and brightness. But the same street can look totally different depending on how dark it is or how many lights are on, and we've measured that the model's mental fingerprint of a place gets thrown off by that brightness noise, not just by the actual layout of streets and buildings. This experiment hands the model a second picture alongside the first: a version mathematically flattened to remove slow brightness changes and keep only the sharp local edges -- like squinting to ignore how sunny or dim it is and see only shapes. Both pictures are fed in together from the very first layer, so the network can lean on the shape-only picture whenever plain color is confounded by lighting. We also sprinkle a bit of random blur or sharpening onto training photos so the model can't cheat by reading blur artifacts as if they were a location clue.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8], stem conv expanded 3->6 input channels (RGB weights copied verbatim + 0.1x-scaled duplicate for the 3 new channels), all other pretrained blocks loaded strict and unchanged · changed: Rotation fan, Feature extractor, Layout summary, Training data, Training schedule · 2026-07-22 · commit 898d8cb5 · full experiment record →

Fig. 39 Coordinate-generated map field: replace 1,024 free-parameter cell templates with a shared position-conditioned embedding generator discarded — 1.10 km, reverted
INFERENCE PATH — WHAT FLIES128²×3Camera frameone of 6 lighting rendersfrozen contract4×128²×3Rotation fanvotes the new similarity map64²×168²×48Feature extractorMobileNetV3-Small, +NEW stride-8 tap16²×24skip GAP · 24-dNEW tapGAP 48 + layout 512kept descriptor pairCrop embedding64-d, L2-normalized — NEWlighting FiLMγ,β from brightness+GAPProbability mapcosine sim. × cells, C4-avgFourier(u, v)shared 2-layer MLP generates all 1,024cell embeddings — not 1,024 free rowsDecodeβ-sharpened soft-argmax (kept form)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1peak-vs-2nd-peak margin — NEWtraining-only — never fliesGaussian-bump CE on the temperature-scaled cosine-simfield (kept CE form; logits are bounded sim × learned scale, not raw FC output)+ coord L2 + conf BCE (kept, unchanged math) — training data/schedule belowkept, unchanged: confusability-weighted location sampler (rd 35)kept, unchanged: 3 seeded relight realizations per bucket (rd 17)kept, unchanged: 24-pass fresh-draw epochs, cosine LR glide to zero (rd 25)removed: dark-expert head + brightness gate (rd 12) — folded into FiLM above

In plain words. For 38 rounds the model has picked a location by keeping a giant multiple-choice answer sheet: 1,024 separate, totally independent answers, one per map tile, that it must learn from scratch with no help from each other. That's like memorizing 1,024 unrelated flashcards instead of learning a map. This experiment throws the flashcards away and replaces them with a tiny function that GENERATES an answer for any tile just from its map coordinates -- so learning about one tile automatically improves nearby and similar tiles too, instead of each one starting from zero. The photo still gets turned into its own compact fingerprint, and the guess is just 'which generated tile-fingerprint looks most like mine' -- same idea as before, just with a far smaller, far smarter answer sheet.

architecture · pretrained:mobilenet_v3_small IMAGENET1K_V1 features[0..8] (torchvision, BSD-3) — unchanged · changed: Rotation fan, Feature extractor, Lighting conditioning, Crop embedding, Probability map, Decode, Confidence, Training signal · 2026-07-22 · commit 898d8cb5 · full experiment record →

Fig. 40 Coarse-to-fine geolocalization: a shared conv field ranks the region, a shared local head regresses the offset pivot discarded — 1.01 km, reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractrotation fan×4 turns, C4 votefeature extractorMobileNetV3-S, 2 taps↓ stride-8 tap feeds the fine field belowcoarse localization field8×8 cells ≈875 m, shared 1×1 convfine offset fieldper-cell (Δu,Δv,logσ), ONE shared headdecodeβ-sharpened mean of (cell center + own offset)frozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1peak/entropy shape + fine field's own logσ — may abstaincoarse Gaussian-CE over 8×8 cells (was 32×32)gradient now shared through ~100 conv weights, not 1,024 free rows+ fine offset Huber loss, gathered at the TRUE cell onlyunimodal regression — coarse stage already picked the place+ L2 on final decode + conf BCEtraining data: confusability sampler (exp 35)recomputed at the new 8×8 granularityschedule: 2-epoch warmup, fresh offset head

In plain words. Every past attempt asked one system to do two hard jobs at once: figure out roughly WHERE a photo was taken among 1,024 tiny map tiles, AND pinpoint the exact spot -- in a single step. The diagnosis says the 'which tile' part is the part that keeps failing (the model narrows it down but usually doesn't pick the right one out of many similar-looking tiles). So this experiment splits the job in two: first, a much simpler 64-tile guess (roomier tiles, easier to get right, and computed straight off the camera model's own picture-shaped map instead of a giant independent answer sheet). Second, a small dedicated helper then nudges that guess to the exact spot within the winning tile -- a much easier fine-tuning problem once you already know the neighborhood. It's like first picking the right city block, then a second glance to find the exact doorway, instead of trying to name the doorway out of a thousand candidates in one look.

architecture · pretrained:mobilenet_v3_small (unchanged from exp 11 onward) · changed: Rotation fan, Feature extractor, Coarse localization field, Lighting gate, Fine offset field, Decode, Confidence, Training data, Training signal, Training schedule · 2026-07-22 · commit 9880938d · full experiment record →

scroll to zoom · drag to pan · double-click to reset
view on GitHub