Everything we tried: Experiment model designs

59 model designs, one figure per experiment — a technical drawing of what one camera frame goes through, from pixels to (lat, lon, confidence). Every figure was drawn and locked before that experiment trained, alongside a falsifiable hypothesis, so what you compare is the design as proposed, not redrawn to match a result already known. Newest first, grouped by evaluation era: the lineage was wiped at each era boundary, so no design descends from one in an earlier band — several late figures are early ideas tried again once the measurement could recognise them. Kept and reverted alike; click any figure to enlarge, or open its full record in the research log.

Who designed these. Not me. An autonomous loop of coding agents designs, trains and scores one pre-registered experiment at a time, keeping only what measurably helps; this site is its lab notebook. Every figure below is an agent's own proposal, drawn before it was allowed to train.

The scope they were working in. The project currently runs a deliberately narrowed configuration: one locale (Berlin), raw daytime imagery only, no synthetic low-light simulation — trading the full spec's four areas and six lighting conditions for faster rounds while the loop searches for an architecture worth generalizing back out. Designs from the earlier eras below were built against that wider problem, which is part of why they look heavier.

INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen 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 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

59 proposals · 23 kept · 4 of 5 eras drawn · newest first · updated 2026-08-01 14:57 UTC

Era 5Mission scoreoptimised mission score — (1 - usable) + false · asked over viewpoint holdout, daytime only, Berlin only
Fig. 5.5 Decode-consistent training targets: bilinear tent cell labels + residual offset against the model's own pooled centroid kept at the time — re-scored today: mission score 0.040
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×328²×160160-dGAPFC → 2,970 cell logitssoftmaxprobability field55×54 map cells · 128 m each3×3 pooled centroidmass-weighted balance point of the winning cell + 8 neighbourswithin-cell offsettanh · ½ cellfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= pooled mass over the whole 3×3 blockmay abstain instead of guessingsoft cross-entropy vs a bilinear tent over the 4 nearest cell centres — border views taught the split their decode producesoffset target = the residual the pooled centroid leaves (±½ cell), not the position that centroid already encodesdeployed graph byte-identical to Fig. 4 — only the training targets changed

In plain words. The model learns Berlin as a grid of tiles, like a giant bingo card. Until now, a photo taken straddling two tiles was taught 'you are in tile A, full stop' -- even though a nearly identical photo one step left would be taught 'tile B, full stop'. That is confusing teaching, and the model wasted effort memorizing an invisible boundary instead of the city. Now we teach it honestly: 'you are 60% in A, 40% in B', matching where the camera really stands. And the little aim-correction step at the end used to re-add information the averaging already provided, overshooting the target; now it is taught to fix only whatever small error actually remains.

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

Fig. 5.4 Local belief pooling decode: confidence = softmax mass on the 3x3 cell neighborhood, fix = its mass-weighted centroid kept at the time — re-scored today: mission score 0.090
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×328²×160160-dGAPFC → 2,970 cell logitssoftmaxprobability field55×54 map cells · 128 m each3×3 pooled centroidmass-weighted balance point of the winning cell + 8 neighbourswithin-cell offsettanh · ½ cellfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= pooled mass over the whole 3×3 blockmay abstain instead of guessingcross-entropy on the one true cell + smooth-L1 offset — unchanged from Fig. 3full-lattice coverage, fresh rotations, cosine LR — byte-identical to Fig. 3; only the deployed decode moved

In plain words. The model localizes by picking which 128-metre map tile it is over, like answering a multiple-choice question, and it only speaks up when one answer gets enough of its vote. But when the drone flies near the border between two tiles, the model honestly splits its vote between them — and then stays silent, even though both answers point at the same street corner. That silence was most of our remaining score. Now neighbouring tiles get to pool their votes: if the belief lands in one tight cluster on the map, we place the fix at the cluster's balance point and speak up; if it is scattered across the city, we stay silent exactly as before.

architecture · from-scratch · changed: Local belief pooling, Confidence gate · 2026-07-31 · commit 7958b03d · full experiment record →

Fig. 5.3 Full-lattice coverage training for the map-cell classifier: every epoch is a complete pass over all 72,712 vantages kept at the time — re-scored today: mission score 0.183
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×328²×160160-dGAPFC → 2,970 cell logitssoftmaxprobability field55×54 map cells · 128 m eachargmax over 2,970 cellsone winning cell → its centre, nudged by the offsetwithin-cell offsettanh · ½ cellfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= softmax mass on the winning cellmay abstain instead of guessingcross-entropy + offset loss unchanged — but every epoch is now one FULL pass over all 72,712 lattice positions581,696 views, ~196 per cell (12× Fig. 2) · fresh rotation per position per epoch · cosine LR 1e-3 → 1e-4architecture restored verbatim from Fig. 2 — the training schedule is the change

In plain words. Last time we gave the model a multiple-choice map of Berlin — 3,000 tiles, point to the right one — but we only let it study for 84 seconds, and it never even saw most of the city. It answered every question with a shrug. This experiment changes nothing about the model itself; we just run the full study session: show it every spot in Berlin, eight times over, from different angles each time — about 20 minutes instead of 84 seconds. A student who has actually walked every street can start answering with confidence instead of shrugging.

training · from-scratch · changed: Feature extractor, Map-cell classifier, Within-cell offset, Confidence gate, Training signal · 2026-07-31 · commit 014a6196 · full experiment record →

Fig. 5.2 Map-cell classification decode: pick 1 of ~3,000 128 m tiles, confidence = softmax mass gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×328²×160160-dGAPFC → 2,970 cell logitssoftmaxprobability field55×54 map cells · 128 m eachargmax over 2,970 cellsone winning cell → its centre, nudged by the offsetwithin-cell offsettanh · ½ cellfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= softmax mass on the winning cellmay abstain instead of guessingcross-entropy on the true cell (label smoothing 0.05) + smooth-L1 on the within-cell offset6,000 of the 72,712 lattice positions redrawn each epoch with fresh headings — 48,000 views for 2,970 cells (~16 each)

In plain words. The old model answered 'where is this photo?' by guessing two GPS numbers directly — and when unsure, that kind of guess drifts toward the middle of the map, which is confidently wrong almost everywhere. The new model works like a mail sorter instead: Berlin is cut into about 3,000 postcode-sized tiles, and the model picks which tile the photo belongs to, then fine-tunes the spot inside it. The tiles are sized so that naming the right tile already counts as a good fix. Best of all, a multiple-choice answer comes with built-in honesty: if the model's belief is smeared across many tiles, its top choice scores low and the drone simply says 'not sure' and waits for the next frame — which is far safer than pointing at the wrong street with full confidence.

architecture · from-scratch · changed: Feature extractor, Map-cell classifier, Within-cell offset, Confidence gate, Training signal · 2026-07-31 · commit 9011afe6 · full experiment record →

Fig. 5.1 Baseline seed: current model/ code, no design agent kept at the time — re-scored today: mission score 2.001
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 3sigmoidone shot — no map structurefrozen contract(lat, lon, confidence)position fix + confidencemean-squared error on (u, v)the whole map supervises one number pairBCE ×0.1 on confidencetarget: error < half the map extentstarting line — the harness's own code, no design agent involved

In plain words. This row is the starting line, not an idea being tested. The naive starting model is trained and measured so there is a real number on the board. It turns out to be the worst possible result -- confidently wrong on every single frame -- which is exactly what the new score is designed to expose.

other · from-scratch · 2026-07-31 · commit 92d1f12e · full experiment record →

Era 4Viewpoint holdoutoptimised worst-case geometric-mean error (m) · asked over viewpoint holdout, daytime only, Berlin only
Fig. 4.4 Re-implementation of lost experiment 2 — classify-then-refine: 32x32 map-cell softmax + within-cell offset replaces direct coordinate regression kept at the time — re-scored today: mission score 1.840
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 1,024 cell logits + 1 confidencesoftmaxprobability field1,024 map cells · 32×32 · 217 m eachargmax over 1,024 cellsone winning cell → its centre, nudged by its own offsetwithin-cell offsetFC 128 → 1,024×(du,dv) · tanh ±½ cellfrozen contract(lat, lon, confidence)position fix + confidenceBCE ×0.1 on confidencethe baseline's free sigmoid, untouchedcross-entropy on the true cell + MSE on its own offsetteacher-forced; trunk, data and 8-epoch budget unchangeddrawn identically on purpose — a faithful rebuild of the experiment whose source a bad metric deleted

In plain words. An earlier experiment taught the model to answer a multiple-choice question — which of 1024 map squares is this photo from? — before pointing at the exact spot inside the winning square. That version genuinely found 8% of places within 100 meters, but our old scorecard was broken: it graded models on a statistic that favored playing it safe near the map's center, so the multiple-choice model was wrongly judged worse and its code was deleted. The scorecard is fixed now, and this experiment simply rebuilds that deleted model from its saved blueprint, so the research can continue from the best design we actually found.

architecture · from-scratch · changed: Map-cell classifier, Within-cell refiner, Position output · 2026-07-31 · commit c0f3cd4e · full experiment record →

Fig. 4.3 Coverage over repetition: spend the same 48k-step budget on ~48k fresh-rotated distinct vantages instead of 6000 static crops replayed 8x discarded at the time — re-scored today: mission score 1.995
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 3sigmoidone shot — no map structurefrozen contract(lat, lon, confidence)position fix + confidenceevery presentation is now a different vantage at a fresh heading~48,000 distinct lattice positions streamed at the same 48,000 gradient stepsloss unchangedMSE on (u, v) + BCE ×0.1 on confidencethe graph is the baseline's, untouched — the data diet is the whole experiment

In plain words. This model is supposed to memorize what every part of Berlin looks like from above, like a taxi driver memorizing a city. But it turns out we were only ever showing it 8% of the flashcards — the same 6,000 photos over and over, always held at the same angle — and then quizzing it on the whole city. We didn't give it more study time; we made every flashcard in the same study session a new place, held at a new angle. Same effort, spent on seeing the whole city once instead of a small corner eight times.

training · from-scratch · changed: Training signal · 2026-07-31 · commit f74a8666 · full experiment record →

Fig. 4.2 Classify-then-refine: 32x32 map-cell softmax + within-cell offset replaces direct coordinate regression kept at the time — re-scored today: mission score 1.840
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 1,024 cell logits + 1 confidencesoftmaxprobability field1,024 map cells · 32×32 · 217 m eachargmax over 1,024 cellsone winning cell → its centre, nudged by its own offsetwithin-cell offsetFC 128 → 1,024×(du,dv) · tanh ±½ cellfrozen contract(lat, lon, confidence)position fix + confidenceBCE ×0.1 on confidencethe baseline's free sigmoid, untouchedcross-entropy on the true cell + MSE on its own offsetteacher-forced; trunk, data and 8-epoch budget unchanged

In plain words. The old model had to blurt out exact GPS coordinates in one shot, like being asked to point at a city map blindfolded — and when unsure, the math of its training pushes it to hedge toward the middle of the map, which is precisely wrong everywhere. The new model answers a multiple-choice question first: the map is divided into a 32-by-32 checkerboard of roughly 200-meter squares, and it picks which square the photo is from. Then a second small step points to the exact spot inside that square. Multiple choice can't hedge — you can't answer 'somewhere between Tegel and Tempelhof' by picking a spot in the middle — so being unsure no longer drags every guess toward the map's center.

architecture · from-scratch · changed: Map-cell classifier, Within-cell refiner, Position output · 2026-07-31 · commit 4affa746 · full experiment record →

Fig. 4.1 Baseline seed on the corrected viewpoint-holdout split kept at the time — re-scored today: mission score 2.000
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 3sigmoidone shot — no map structurefrozen contract(lat, lon, confidence)position fix + confidencemean-squared error on (u, v)the whole map supervises one number pairBCE ×0.1 on confidencetarget: error < half the map extentstarting line - the same naive baseline, re-measured on the corrected viewpoint holdout

In plain words. We found that the exam had been unfair in a way nobody noticed: the model was studying one set of streets and then being tested exclusively on different streets it had never been allowed to see. Now it studies the whole city and gets tested on the same city photographed from angles and positions it never studied from -- which is exactly what a drone flying overhead would actually do. This row is the naive starting model re-measured on that fair exam.

other · from-scratch · 2026-07-31 · commit 8bdcc185 · full experiment record →

Era 3Berlin onlyoptimised worst-case median error (m), target 100 m · asked over region holdout, daytime only, Berlin only
Fig. 3.5 Per-epoch position resampling: expose all ~45k Berlin train vantages instead of a frozen 6k subset no score on today's ruler
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 4,096 cell logitssoftmaxprobability field4,096 map cells · 64×64 · 108 m eachsoft-argmax over 4,096 cellsevery cell centre, weighted by its probabilityfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= heaviest 5×5-cell block of beliefmay abstain instead of guessingloss, head and schedule all unchanged — what moves is which 6,000 positions each pass is built fromre-drawn at random from all ~45,000 mapped vantages before every pass, instead of one frozen 6,000 draw reused 96 timesdeployed graph byte-identical to the experiment above it — only the training diet changed

In plain words. The model has been studying the same 6,000 flashcards over and over — 96 study sessions with the exact same deck — when the full deck of Berlin views actually has 45,000 cards. We now deal a fresh random hand of 6,000 cards before every study session. Same total study time, same brain, but by the end it has seen essentially every card in the deck a few times instead of 13% of them dozens of times. Seeing far more of Berlin should make it much better at telling apart neighborhoods that look confusingly similar.

training · from-scratch · changed: Training signal · 2026-07-31 · commit 0ede8d45 · full experiment record →

Fig. 3.4 Hierarchical decode: 16x16 coarse-cell classification + per-cell continuous offset regression from a layout-preserving descriptor discarded at the time — re-scored today: mission score 1.653
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×1284×4×32 descriptor1×1 conv 128→32 · 2×2 poolFC 512 → 256 cell logitssoftmaxprobability field256 map cells · 16×16 · 434 m eachposterior-weighted blendevery cell's centre plus its own pointer, averaged by beliefper-cell pointerFC 512 → 256×(du,dv) · tanh ±¾ cellfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= heaviest 2×2-cell block of beliefmay abstain instead of guessingsoft-label cross-entropy over the 256 coarse cells (σ = ½ cell) + MSE on the true cell's pointer + MSE on the blended (u, v)same 96-pass, fresh-heading schedule as the champion — the loss now grades 256 big squares and teaches a pointer inside eachthe descriptor moves with the decode: a pooled texture bag cannot say WHERE in a cell the frame sits

In plain words. The old model had to answer 'which of 4096 tiny map squares is this photo from?' -- but the exam is deliberately held on patches of Berlin the model never studied, and with 4096 choices it had only ever seen one or two examples of each. Worse, squares inside the exam patches never appeared in study material at all, so the model literally learned to never answer them. The new model first picks one of 256 much bigger neighborhoods -- big enough that every one was at least partly studied -- and then points to a spot inside it, the way you'd say 'that's Kreuzberg, near the top-left corner of the park'. Pointing is a smooth skill that transfers into the unstudied patches, where memorizing tiny squares could not.

architecture · from-scratch · changed: Feature extractor, Map-grid classifier, Coordinate + confidence readout, Training signal · 2026-07-31 · commit f625d8d7 · full experiment record →

Fig. 3.3 Re-land the validated 64x64 grid-classification head with a convergence-scale training budget (x12 epochs, cosine LR, fresh per-epoch rotations) kept at the time — re-scored today: mission score 1.556
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 4,096 cell logitssoftmaxprobability field4,096 map cells · 64×64 · 108 m eachsoft-argmax over 4,096 cellsevery cell centre, weighted by its probabilityfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= heaviest 5×5-cell block of beliefmay abstain instead of guessingsame cross-entropy and same soft labels — the study budget is the change: 96 passes, not 8cosine LR 1e-3 → 1e-5 · every crop re-drawn at a fresh random heading before every passthe head is restored verbatim from the gated-out experiment above it — only the training schedule is new

In plain words. The last experiment changed the model's job from 'blurt out GPS numbers' to 'point at the right square on a 64x64 checkerboard of Berlin' - and it genuinely got 3.6x more accurate. But it was disqualified by a fairness rule: it was only sure enough to give an answer on 1 in 10 photos, and the rules demand an answer on at least 1 in 5. The catch: it had only been allowed to study for 33 seconds. This experiment brings the same model back and lets it actually study - about 100 passes through the material instead of 8, with every aerial photo shown at a fresh random rotation each pass so it learns places rather than memorizing exact pictures. A model that has properly studied is both more accurate and more confident, which should clear the 'too unsure to answer' disqualification.

training · from-scratch · changed: Map-grid classifier, Coordinate + confidence readout, Training signal · 2026-07-31 · commit bea8a408 · full experiment record →

Fig. 3.2 Reparameterize localization as 64x64 map-grid classification with in-graph soft-argmax gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 4,096 cell logitssoftmaxprobability field4,096 map cells · 64×64 · 108 m eachsoft-argmax over 4,096 cellsevery cell centre, weighted by its probabilityfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1= heaviest 5×5-cell block of beliefmay abstain instead of guessingcross-entropy against Gaussian-smoothed cell labels (σ = 1 cell) + a small L2 on the soft-argmax coordinate6,000 crops, one frozen rotation each, 8 epochs — the same budget the naive baseline was givengated FAIL — confident on only 10.8% of frames, under the harness's 20% coverage floor

In plain words. The old model had to blurt out map coordinates directly, like guessing GPS numbers. When a model like that is unsure, naming the middle of the map minimizes its average penalty - so it learned exactly that and nothing else (its error matches a dead-center guess almost to the meter). The new model instead treats Berlin as a 64x64 checkerboard and answers a multiple-choice question: 'which square am I looking over?' - then fine-tunes the answer by averaging the best-scoring neighboring squares. Multiple choice gives no credit for hedging toward the middle, so the model is forced to actually recognize places, and its confidence becomes honest: it is literally how much probability it puts on one small neighborhood of the map.

architecture · from-scratch · changed: Map-grid classifier, Coordinate + confidence readout, Training signal · 2026-07-31 · commit d9805aa2 · full experiment record →

Fig. 3.1 Baseline seed: original TinyLocNet, fresh berlin-slim lineage kept at the time — re-scored today: mission score 1.996
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone daytime framefrozen contractconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×128128-d vectorglobal avg poolFC 128 → 3sigmoidone shot — no map structurefrozen contract(lat, lon, confidence)position fix + confidencemean-squared error on (u, v)the whole map supervises one number pairBCE ×0.1 on confidencetarget: error < half the map extentstarting line — the harness's own code re-run on Berlin alone, no design agent involved

In plain words. This row isn't a new idea being tested -- it's the starting line. The original, deliberately naive tiny CNN from the project's very first bootstrap gets retrained from scratch on Berlin's daytime-only imagery, with no design agent involved, just to prove the pipeline still works end-to-end after today's changes and to get a real number on the board. Everything after this row is a genuine attempt to beat it.

other · from-scratch · 2026-07-31 · commit 28f2ebe1 · full experiment record →

Era 2Four areas, six lighting bucketsoptimised worst-case median error (m), target 20 m · asked over region holdout, 6 lighting buckets, 4 areas
Fig. 2.62 Fire-module SqueezeNet1.1 trunk + FiLM-conditioned single field + D4 symmetry + adaptive-sharpening decode (forced pivot, mobilenet_v3_small banned) gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contract×8 exact-pixel views (D4)rotations + mirror, shared weightsSqueezeNet1.1 Fire trunkstem + 4 fire blocks (BSD-3)mobilenet_v3_small banned this round63²×647²×384lumFiLM (γ, β) MLPmodulates feature map384-d descriptorGAP, D4-pooled avg1-ch layout1×1 squeeze, 49-d flatsingle Linear → 1,024gate + dual head deletedprobability field32×32 cells over the mapadaptive-β commitfrozen contract(lat, lon, confidence)position fix + confidenceβ = f(entropy, peak)learned per-example sharpeningconfidence 0–1384-d GAP + adaptive β + peak/entropy/gapGaussian-CE vs cell target (unchanged)σ = 1.5 cells over the 32×32 fieldL2 on decoded (u, v)expected-coordinate loss — now also trains the β gaugeconfidence BCE ×0.3 (unchanged loss)same hit-radius target, new head inputs

In plain words. The model's 'eyes' have been the same borrowed eyes for 35 rounds, and the last 25 experiments all tried rearranging what happens AFTER the eyes without touching them -- none of it worked. This round we're not allowed to reuse those eyes at all, so we swap in a different pretrained set that sees the world through wider, richer 'glances' (8x more detail per glance) instead of trying to build new eyes from scratch, which has failed every single time it's been tried. Everything downstream is rebuilt to match: instead of two separate 'day expert' and 'night expert' sub-brains voting on the answer, there's now one brain that just retunes itself based on how bright the photo is; instead of checking the view from 4 rotated angles, we now also check its mirror image, since aerial photos really do look the same flipped left-right; and instead of always squinting at the guess-map by the same fixed amount before committing to an answer, the model now decides per-photo how hard to squint based on how confusing that particular map looks.

architecture · pretrained:squeezenet1_1 IMAGENET1K_V1 features[0..10] (torchvision, BSD-3) · changed: Feature extractor, Symmetry ensemble, Lighting-conditioned field head, Decode, Confidence, Training signal · 2026-07-30 · commit 0041192d · full experiment record →

Fig. 2.61 Quantization-freed capacity: from-scratch depthwise-separable trunk + unified single-head field, weights trained for int8 export gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contract×4 crop rotations (C4)0/90/180/270°, shared weightsdepthwise-separable trunkfrom-scratch, 4× wider64²×648²×320320-d descriptorGAP, C4-pooled avgunified FC → 1600 logitsQATLinear, weight fake-quantprobability field40×40 cells, finer than prior 32×32sharpen β=3 → soft-argmaxover the finer 1,600-cell gridfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1peak/entropy/gap of new fieldweight fake-quant every stepround(w/scale)·scale — straight-through gradint8 export, post-trainingdynamic quantization — 1 B/weight, real roundingGaussian-CE vs cell target (unchanged)σ = 1.5 cells, now over the 40×40 fieldL2 on decoded (u, v)expected-coordinate loss, unchangedconfidence BCE ×0.3unchanged hit-radius target

In plain words. Every recent attempt to swap out the one part of the model we're now required to remove made things worse, and the pattern points at a simple reason: the replacement parts were always smaller and cheaper than the piece they replaced, because the model has to fit in a fixed 4-megabyte file. This experiment tries a trick borrowed from how phones shrink apps: train the model's numbers to already sit on a coarse, round grid (like rounding every price to the nearest dollar instead of the nearest cent), so that when we later squeeze those numbers down to take a quarter of the storage space each, almost nothing is lost. That squeeze buys back enough room to build a genuinely bigger, single-focus model instead of the small or split-up replacements that kept losing.

architecture · from-scratch · changed: Feature extractor, Rotation fan, Location field, Decode, Confidence, Training signal, Deployment export · 2026-07-30 · commit 9421cc39 · full experiment record →

Fig. 2.60 Corrected exp-38 retry: fixed illumination-invariant channel + from-scratch trunk + cross-lighting consistency loss, gate deleted discarded at the time — re-scored today: mission score 1.681
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — NEVER FLY128²×3camera frameone night exposurefrozen contractillumination-invariant channellog-luminance − own Gaussian blur (fixed math, no gradient)concat128²×4 input×4 crop rotations (C4)0°/90°/180°/270°, shared weightsfrom-scratch conv encoderConv 3×3 s2 ×4 · BN+ReLU — pretrained trunk banned this round128²×48²×128128-d descriptorGAP, C4-pooled avgunified FC → 1024 logitsgate + dark-expert head deletedprobability field32×32 cells, same layout-code concatsharpen β=3 → soft-argmaxdecode mechanism unchangedfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1peak/entropy/gap of new fieldsame recipe, no gate-derived inputs leftlighting-partner cropsame spot & heading, other buckettrain-onlyshared trunkf partner2nd forward passL2 consistency loss ×0.1 (new)same spot, 2 lighting buckets → match descriptorswatch: across-location variance must stay healthyGaussian-CE vs cell target (unchanged)σ = 1.5 cells, same GRID_K=32 fieldL2 on decoded (u, v) (unchanged)confidence BCE ×0.3 (unchanged loss)same hit-radius target, new field inputs

In plain words. Every recent experiment has tried a different way for the model to guess a location, or a different pretrained starting brain for it, and all of them lost to the current champion. This time we try something the project noticed early but never actually got to test properly: give the model a second, cleaned-up version of the photo, computed by simple non-learned math, that strips out roughly how bright the whole scene is and keeps mostly the sharp edges and shapes -- like handing it a rough charcoal sketch alongside the color photo. Buildings and roads look the same in that sketch whether it's noon or midnight; only the color photo changes drastically. We also add a training rule that nudges the model's internal summary of 'what this place looks like' to stay the same whether the photo was rendered as daytime or nighttime, since it's the same physical spot either way.

architecture · from-scratch · changed: Illumination-invariant channel, Feature extractor, Rotation fan, Location field, Confidence, Training data, Training procedure, Training signal · 2026-07-30 · commit 4add0860 · full experiment record →

Fig. 2.59 Independently-trained day/night specialist twins with a trunk-free brightness dispatcher discarded at the time — re-scored today: mission score 1.581
INFERENCE PATH — WHAT FLIES (both specialists always run; the gate blends, never branches)TRAINING — THREE PHASES, NEVER JOINT128²×3camera frameone of 6 lighting bucketsfrozen contractday-specialist trunkfrom-scratch · day buckets onlyday field + decode16×16 grid, soft-argmaxday (u,v,conf)3 pixel statsmean · spread · dark%MLP(8)no trunk, no featuresgate gday-like ↔ night-likedispatchernight-specialist trunkindependent copy, own weights · night buckets onlynight field + decode16×16 grid, soft-argmaxnight (u,v,conf)blendg·day + (1−g)·nightconf nudged down when g is unsurefrozen contract(lat, lon, confidence)position fix + confidencephase 1 — day trunk+field+decode+conffresh optimizer · Gaussian-CE + L2 + 0.3× conf BCE, day buckets onlyphase 2 — night trunk+field+decode+confseparate fresh optimizer · same loss · zero gradient crosses into phase 1phase 3 — freeze both specialiststrain only the gate (~40 params) · Huber/L2 + 0.3× conf BCE, all 6 bucketsconfusability sampler runs twice, independentlyday draw and night draw never mix

In plain words. Instead of one brain trying to memorize the city in both daylight and pitch darkness at once, we build two smaller, separate brains -- one that only ever studies daytime photos, one that only ever studies night photos -- trained completely apart so neither one's lessons get diluted by the other's. A tiny doorman glances at how bright the incoming photo is and decides which brain should answer. We're testing whether the old one-brain-does-everything setup was quietly making both jobs a little worse than they could be on their own.

architecture · from-scratch · changed: Dispatcher, Day-specialist trunk, Day-specialist field + decode, Night-specialist trunk, Night-specialist field + decode, Blend, Training data, Training procedure, Training signal · 2026-07-23 · commit efa8f69b · full experiment record →

Fig. 2.43 Joint reconstruction-canonicalization trunk: a from-scratch encoder that must repaint the clean daytime crop, trained alongside localization every step gated fail — reverted
INFERENCE PATH — WHAT FLIESTRAINING SIGNALS — JOINT EVERY STEP, NEVER FLY128²×3camera frameone of 6 lighting bucketsfrozen contractrotation fan4× C4 views, shared netconvolutional encoderConv 3×3, stride 2 ×4 · BN + ReLU64²×168²×64layout summaryspatial code + texture avgFC → 1024 logitssingle unified scorerprobability field32×32 field, gate removedsoft-argmax decodereads one unified field, sharpening unchangedfrozen contract(lat, lon, confidence)position fix + confidenceconfidence 0–1peak / entropy / gap+ raw crop brightness (new)may abstain instead of guessingreconstruction decoderConvTranspose 4×4 ×4 — reads row 0, un-rotated8²×6464²×16repainted crop128²×3, sigmoiddiscarded before exportreference.tif twinsame cx, cy, angleclean daytime, any bucketL1 pixel-reconstruction loss, weight 1.0every crop, every bucket, every step — not a pretrain phaseGaussian-CE on field + L2 on (u,v) + BCE on confidenceloss formula itself unchanged — only the field it grades is unified nowone shared LR (1e-3) for all paramsfrom-scratch trunk — no pretrained-feature 10× discount to protect

In plain words. Instead of starting the drone's 'eye' with a pretrained network that learned to recognize everyday objects like dogs and cars (which never had to learn to tell one street from another), we make it learn a new party trick from scratch: given a photo taken at dawn, dusk, or pitch-black night, it has to repaint what that same spot looks like in clean daylight. To repaint convincingly it has to actually remember fine details -- building shapes, road layouts -- not just a vague impression, which is exactly the kind of detail needed to tell two similar-looking neighborhoods apart. We tried a similar from-scratch idea last round (a matching game instead of repainting) and it didn't help; repainting is a stricter test that shouldn't let the network cheat by getting lazy.

architecture · from-scratch · changed: Rotation fan, Feature extractor, Layout summary, Lighting gate, Probability map, Decode, Confidence, Training data, Training signal, Training schedule · 2026-07-22 · commit 498f9a89 · full experiment record →

Fig. 2.42 Domain-native contrastive pretraining replaces the ImageNet trunk (corrected re-attempt) discarded at the time — re-scored today: mission score 1.836
INFERENCE PATH — WHAT FLIESPHASE 0 — SELF-SUPERVISED PRETRAINING (TRAIN SPLIT ONLY, RUNS FIRST)PHASE 2 — SUPERVISED TRAINING (UNCHANGED LOSS FORMULA, NEW SCHEDULE)128²×3camera frameone night exposurefrozen contractC4 rotation fanshared net, feeds SSL viewsfrom-scratch conv trunk4× conv3×3 s2 + BN + ReLU, no ImageNet weights128²×38²×64layout summaryspatial code + texture avgFC → 1024 logitssingle unified scorerprobability field32×32 field, gate removedsoft-argmax decodeanswer = Σ probability · cell-centerconfidence 0–1peak/entropy/gap + brightness (new)may abstain instead of guessingfrozen contract(lat, lon, confidence)position fix + confidenceview Alighting/heading draw 1view Blighting/heading draw 2same physical location — uniform random draw, 128 locs/stepshared trunksame weights as aboveproj head64→128→64, L2-norm in losssame place → pull togetherother batch places → push apartNT-Xent (InfoNCE)temperature 0.1, batch 128schedule: 150 contrastive steps (3×50), 128 locs/step, then usual supervised epochs (count unchanged)trunk LR gap to head relaxed 10× → 2× (5e-4 vs 1e-3) — pretrained trunk needs less protectionGaussian-CE on field + L2 on decoded (u,v) — loss formula itself unchangedconfusability-weighted sampler (exp 35) still feeds THIS stage only, not pretraining

In plain words. The model's 'eyes' were borrowed from a network trained to recognize everyday objects like cats and cars -- it was never taught that a rooftop at noon and the same rooftop at midnight are the same place, or that two different-looking places are different. This experiment throws that borrowed trunk away and grows a brand-new one from scratch, first playing a 'same place or different place?' matching game using nothing but the map images this project already generates in every lighting condition, before it ever tries to pinpoint a location. It's a bit like teaching someone to recognize your street by showing them photos of it at dawn and at midnight side by side, instead of handing them a general photo-classification textbook and hoping street-recognition falls out.

architecture · from-scratch · changed: Rotation fan, Feature extractor, Layout summary, Lighting gate, Probability map, Decode, Confidence, Training data, Training signal, Training schedule · 2026-07-22 · commit fed7c60a · full experiment record →

Fig. 2.41 Domain-native contrastive pretraining replaces the ImageNet trunk rejected — never trained
INFERENCE PATH — WHAT FLIESPHASE 0 — SELF-SUPERVISED PRETRAINING (TRAIN SPLIT ONLY, RUNS FIRST)PHASE 2 — SUPERVISED TRAINING (UNCHANGED LOSS FORMULA, NEW SCHEDULE)128²×3camera frameone night exposurefrozen contractC4 rotation fanshared net, feeds SSL viewsfrom-scratch conv trunk4× conv3×3 s2 + BN + GELU, no ImageNet weights128²×38²×64layout summaryspatial code + texture avgFC → 1024 logitssingle unified scorerprobability field32×32 field, gate removedlearned βsoftplus, init 3.0soft-argmax decodeanswer = Σ probability · cell-centerconfidence 0–1peak/entropy/gap + brightness (new)may abstain instead of guessingfrozen contract(lat, lon, confidence)position fix + confidenceview Alighting/heading draw 1view Blighting/heading draw 2same physical location — confusability-weighted sampler (exp 35)shared trunksame weights as aboveproj head64→64→32, L2-normsame place → pull togetherother batch places → push apartNT-Xent (InfoNCE)temperature 0.15, batch 128schedule: 3 SSL epochs (cosine→0), then 24 supervised epochs (count unchanged)trunk/head LR ratio relaxed 10× → 3.3× (3e-4 vs 1e-3) — domain prior needs less protectionGaussian-CE on field + L2 on decoded (u,v) — loss formula itself unchangedsame confusability-weighted sampler (exp 35) feeds this stage too

In plain words. Every past attempt to fix the model's map-reading skill tinkered with the scorer that ranks candidate locations, but always fed it the same raw description of the photo -- one originally learned for recognizing everyday objects like cats and cars, never for telling one street block apart from a lookalike block across town. This experiment throws that borrowed description out and teaches the model to describe photos from scratch, using a game where it has to recognize that a daytime and a nighttime photo of the SAME spot are 'the same' while a photo of a different spot is 'different' -- practiced over and over using the free synthetic renders we already generate. Only after it gets good at that game does it move on to learning actual GPS coordinates. We also removed a day/night switch that was patched in earlier to work around the old description's blind spot in the dark, since the new description is trained to already see through lighting changes on its own.

architecture · from-scratch (from-scratch trunk architecture, self-supervised NT-Xent pretraining generated entirely from the frozen relight pipeline's own domain data -- no external weights, no ImageNet, no torchvision pretrained checkpoint) · changed: Rotation fan, Feature extractor, Layout summary, Lighting gate, Probability map, Decode, Confidence, Training data, Training signal, Training schedule · 2026-07-22 · commit c0fda62e · full experiment record →

Fig. 2.40 Coarse-to-fine geolocalization: a shared conv field ranks the region, a shared local head regresses the offset discarded at the time — re-scored today: mission score 1.738
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 →

Fig. 2.39 Coordinate-generated map field: replace 1,024 free-parameter cell templates with a shared position-conditioned embedding generator discarded at the time — re-scored today: mission score 1.503
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. 2.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. 2.37 Multi-hypothesis coordinate regression replaces the 1024-cell field discarded at the time — re-scored today: mission score 1.643
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. 2.36 Hardest-impostor margin hinge, retested on the confusability-weighted champion discarded at the time — re-scored today: mission score 1.601
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. 2.35 Confusability-weighted location sampling: oversample look-alike cell pairs, not just more places kept at the time — re-scored today: mission score 1.588
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. 2.34 Hardest-impostor margin loss: the field must outrank its best lookalike, not just light up the truth 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. 2.33 Sensor-sharpness nuisance randomization: per-crop PSF/resampling jitter breaks the blur-texture shortcut 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. 2.32 Risk-controlled abstention: six per-lighting-regime thresholds calibrated on never-trained fenced blocks discarded at the time — re-scored today: mission score 1.438
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. 2.31 Neural-map correlation field: localization becomes sliding-window matching of a crop fingerprint against a learned 32 m map raster discarded at the time — re-scored today: mission score 1.771
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. 2.30 Supervised lighting dispatcher: day/dusk/night specialist field heads replace the two-expert blend, int8-paid discarded at the time — re-scored today: mission score 1.696
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. 2.29 Stride-8 fine-layout tap: the field scorer reads an 8-m-resolution mid-trunk snapshot, int8-paid discarded at the time — re-scored today: mission score 1.618
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. 2.28 Rerun, never scored: unseen-ground confidence calibration + reinstated 3x trunk (iter 7 died on a full disk before training) discarded at the time — re-scored today: mission score 1.568
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. 2.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. 2.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. 2.25 Convergence-scaled training: 3× optimizer steps with cosine LR decay under the kept fresh-draw sampler kept at the time — re-scored today: mission score 1.623
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. 2.24 Daytime-redraw auxiliary, rerun: exp 23 was OOM-killed mid-harness, never scored — retest it with a memory-lean epoch sampler discarded at the time — re-scored today: mission score 1.678
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. 2.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. 2.22 Train-only per-patch place supervision: every feature cell places its own patch, the flying decode is untouched discarded at the time — re-scored today: mission score 1.696
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. 2.20 Per-epoch training-set resampling: a fresh 6,000-location draw per bucket every epoch replaces the one frozen 36k-crop tensor kept at the time — re-scored today: mission score 1.683
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. 2.19 Off-site distractor patching: half the training crops carry a pasted block of terrain from elsewhere, labels unchanged discarded at the time — re-scored today: mission score 1.633
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. 2.18 Dense per-patch field voting: 64 local place votes with learned fusion replace the global 1024-way template head discarded at the time — re-scored today: mission score 1.623
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. 2.17 Nuisance-randomized training renders: each bucket's training crops drawn from three seeded realizations of the frozen relighting sim kept at the time — re-scored today: mission score 1.753
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. 2.16 C4 rotation-vote field: average field logits over the crop's four 90° turns kept at the time — re-scored today: mission score 1.701
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. 2.15 Selective prediction: field-shape confidence head with per-bucket calibrated abstention kept at the time — re-scored today: mission score 1.681
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. 2.14 Peak-commit decode: β-sharpened softmax replaces mean-of-map soft-argmax kept at the time — re-scored today: mission score 1.971
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. 2.12 Luminance-gated dark-expert field head blended with the existing layout head kept at the time — re-scored today: mission score 1.996
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. 2.11 ImageNet-pretrained MobileNetV3-Small trunk replaces the from-scratch encoder kept at the time — re-scored today: mission score 1.986
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. 2.10 Layout-aware field head: squeezed 8×8 spatial code ⊕ GAP replaces GAP-only head input kept at the time — re-scored today: mission score 1.996
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. 2.9 Cross-lighting contrastive pairs: NT-Xent metric learning on the place descriptor discarded at the time — re-scored today: mission score 1.996
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. 2.8 Deployment-envelope residual encoder: 4.2× capacity (232k → 973k params), 11 conv layers with skips discarded at the time — re-scored today: mission score 1.961
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. 2.7 Scale training coverage 7.5x: 6,000 of ~45k available train locations per bucket (was 800) kept at the time — re-scored today: mission score 1.986
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. 2.6 Per-epoch rotation resampling replaces the one-shot frozen training tensor discarded at the time — re-scored today: mission score 1.981
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. 2.5 Hierarchical coarse-to-fine supervision of the probability field via probability pooling discarded at the time — re-scored today: mission score 1.991
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. 2.4 ACE-style dense per-patch scene-coordinate regression replaces global map-cell probability field discarded at the time — re-scored today: mission score 2.001
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. 2.3 Argmax-anchored local soft-argmax decode replaces global expected-coordinate discarded at the time — re-scored today: mission score 1.971
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. 2.2 DSNT-style spatial probability field over the map replaces direct (u,v) regression kept at the time — re-scored today: mission score 2.001
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. 2.1 Starting baseline — naive TinyLocNet, from-scratch, frozen pipeline v1 kept at the time — re-scored today: mission score 1.991
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 →

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