What the networks learn: machine learning at the noise floor

Between 24 January and 4 February 2023, JWST imaged a patch of the ecliptic at three epochs, looking for trans-Neptunian objects (TNOs) far fainter than any ground-based telescope can reach. Marielle Eduardo, Anastasia Morgan, Wesley Fraser and their colleagues shift-and-stacked the images along trial orbits and produced more than a million candidate detections. A three-network ResNet ensemble cut those to about 50,000, at a cost of about 0.2 mag in depth. Without that cut the search would have been unmanageable. Then the team did something unusual. Wherever two accepted epochs already pinned down an orbit, they searched the third epoch’s rejected candidates. Two new TNOs appeared, JPB01 and JPB05, at magnitudes 26.5–27. The detections the network had thrown away had signal-to-noise ratios of 51 and 40. They were flawless to the eye. Every implanted synthetic TNO in the same brightness range had passed the same network (Eduardo et al. 2026).

The authors’ explanation is that the network had learned something about the implants that real objects did not share, most likely a slightly different point-spread function (PSF). This chapter is about the general version of that story. Machine learning (ML) has made faint moving-object surveys practicable, mostly by doing something unglamorous: rejecting enormous numbers of artefacts so that humans and orbit fitters can look at the rest. It is also beginning to do something more ambitious, proposing candidates directly from image sequences without enumerating every velocity. The first job is mature and well measured. The second has been demonstrated, and every demonstration so far reports a loss of depth relative to the physical search it competes with. Understanding why requires being precise about what the physical search computes, what a network can and cannot add, and what the published numbers actually measure.

The physical search itself is the subject of Chapter 17 (shift-and-stack and KBMOD), Chapter 20 and Chapter 21. Upstream real/bogus classification of single detections is introduced in Chapter 10, and streak detection in Chapter 11. The TESS application is told in more detail in Chapter 23.

Five jobs for a network

The phrase “ML found asteroids” hides at least five different interventions, with different inputs, outputs and standards of success.

The first row is mature. The last is an opportunity. Keeping them apart requires two ledgers. One is scientific selection: which objects are lost, including those lost before any network sees them. The other is computational expenditure: extraction, filtering, training, data transfer and confirmation. A classifier can save weeks of astronomer time without touching the GPU search that dominates the compute bill. Conversely, a shallower independent detector can add real discoveries simply by failing differently from the established pipeline.

The statistic that ML must beat

What the physical search computes

For exposure $i$ and pixel $p$, write the calibrated image as

where $B$ is the static scene and sky, $F$ a reference flux, $a_i$ the conversion to counts in exposure $i$, $P_i$ the pixel-integrated PSF (including trailing during the exposure), and $x_i(\theta)$ the projected position on trajectory $\theta$. Stack the residual pixels into a vector $d$ and the unit-flux source model into $s_\theta$. With known noise covariance $C$, the Gaussian log-likelihood ratio is

The best flux is $\hat F=\Psi_\theta/\Phi_\theta$ and the signed SNR is $\nu_\theta=\Psi_\theta/\sqrt{\Phi_\theta}$. With independent pixels, $\Psi$ and $\Phi$ separate into per-exposure images, the PSF-weighted image and its information, which KBMOD computes once and then samples along each trajectory (Whidden et al. 2019). For $N$ equal exposures the SNR grows as $\sqrt N$, a gain of $\Delta m=1.25\log_{10}N$ magnitudes. With 100 exposures that is 2.5 mag.

This is the baseline. Any learned method has to be compared with it, and with a good implementation of it. KBMOD’s 2019 paper reports searching about $10^{10}$ trajectories through stacks of 10–15 images of $4{\rm K}\times4{\rm K}$ pixels in under a minute on a consumer GPU, because it never re-renders shifted images. A neural method that beats a slow literal shift-and-add loop has beaten the wrong opponent.

What “optimal” does and does not mean

The Neyman–Pearson lemma says that the likelihood ratio is the most powerful test for a specified signal. For a fixed trajectory and flux, in Gaussian noise, the matched filter is therefore optimal, and nothing can see more. But the real problem has an unknown trajectory and flux. The optimal test then averages the likelihood ratio over a prior,

whereas a search that takes the maximum score over a discrete bank approximates a generalised likelihood-ratio test. So a network can outperform a particular max-over-bank rule without violating any theorem. It can also do better than a Gaussian likelihood when the real noise is not Gaussian, which in difference images it often is not. Jingkai Yan and colleagues made the first point concrete: they built networks that implement a matched-filter bank exactly at initialisation and then trained them to improve the composite decision (Yan et al. 2021). Their theorem is about what a network can represent. Writing every template correlation as a neuron does not by itself reduce the arithmetic.

The constraint that does bind is the data-processing inequality. For any deterministic compression $z=f(d)$ of the data,

where $p_0$ and $p_1$ are the distributions under noise only and under signal. Processing cannot increase the information that distinguishes the hypotheses. A learned denoiser can make a downstream imperfect procedure work better, but the denoised image cannot contain more evidence than the pixels it came from. A network that takes a per-pixel maximum over time, or tokenises only the bright pixels, throws away evidence that no later stage can recover. Exact rescoring later helps only the proposals that survived.

Scores are not significances

A classifier with threshold $s_*$ has recall $r$ (the fraction of real objects kept) and false-positive rate $q$. If real objects are a fraction $\pi$ of what it sees, the purity of its output is

This is why balanced test-set precision means little in a real candidate stream. As an illustration, with $\pi=10^{-4}$, $r=0.97$ and $q=0.01$, purity is about 0.96%: almost everything the “97% accurate” classifier keeps is still bogus. Maggie Lieu and colleagues plotted purity against completeness for several assumed abundances for exactly this reason (Lieu et al. 2019).

At the search level the relevant quantity is the number of false alarms across all trials. For $M$ independent Gaussian tests and threshold $z$, the expected number of exceedances is $M\bar\Phi(z)$. With $M=10^{10}$, a $5\sigma$ threshold gives about 2,867 crossings, and keeping the expected count at 0.01 needs about $7.03\sigma$. These are independent-trial estimates; adjacent trajectories are correlated and artefacts have heavier tails. A neural search that never exposes its template bank still examines many opportunities for a false detection. A network output of 0.99 is neither a significance nor a calibrated probability under a new prevalence. The DEEP team describes its CNN cutoff, correctly, as a user-defined selection rather than a likelihood (Smotherman et al. 2023).

Two more statistical facts recur below. If a test sees zero false positives in $n$ independent negatives, the one-sided 95% upper bound on the false-positive rate is about $3/n$, not zero. And completeness through a pipeline is a product of conditional probabilities,

for proposal generation $G$, vetting $V$, linking $L$ and confirmation $Q$. A vetter’s “95% retention” is one factor of this product, conditional on everything before it. Multiplying averaged stage recalls as if they were independent is generally wrong.

A short history

Catalogue cleaning before deep learning

The motivation predates convolutional networks. Artefacts create accidental alignments, and linking cost grows rapidly with detection density (Chapter 12). Hsing-Wen Lin, Ying-Tung Chen and collaborators built a real/bogus filter for the Subaru Hyper Suprime-Cam survey from 47 existing catalogue measurements, using stationary repeat detections as positive examples and flagged detections as negatives (Lin et al. 2017). A random forest of 160 trees reached about 96% true-positive rate at 1% false-positive rate. Two warnings were already present. Stationary sources are convenient labels but imperfect stand-ins for trailed asteroids, and the paper left streak-shaped sources untested. On a different observing run the true-positive rate at 5% false-positive rate fell from about 99% to 97% until the forest was retrained.

Euclid simulations and the first CNNs

Lieu, Luca Conversi, Bruno Altieri and Benoît Carry circulated the first influential CNN study in 2018. It was a pre-launch Euclid simulation, not a discovery. Pretrained image classifiers were asked to separate Solar System objects from stars, galaxies and cosmic rays, with the multiple dithered exposures fed in as colour channels so that a mover changes position from channel to channel. The small MobileNet beat larger networks. Binary accuracy rose from 0.935 with one exposure to 0.956 with the temporal channels, and slow movers below about 10 arcsec/hour were the hard case, with roughly half missed (Lieu et al. 2019).

ZTF and DeepStreaks

At Palomar, the Zwicky Transient Facility (ZTF) inherited a streak detector, ZStreak, from the earlier Palomar Transient Factory. Its first near-Earth asteroid (NEA) discovery was 2018 CL on 5 February 2018, and it reported 45 confirmed NEAs over 232 observable nights that year (Ye et al. 2019). The bottleneck was human review of the streaks it found. ZStreak’s original random forest still passed far too many.

Tracklets, stacks and DEEP

ATLAS moved the decision up a level. Amandin Chyba Rabeendran and Larry Denneau’s system scores each of four cutouts with a ResNet18 into eight classes, and a small network judges the 32 scores together as a tracklet. It kept about 99.6% of real tracklets with a 15% false-positive rate and cut human inspection by about 90% (Chyba Rabeendran & Denneau 2021).

At the University of Washington, Hayden Smotherman and colleagues combined KBMOD’s GPU trajectory search with difference imaging, robust rejection of corrupted light-curve points inside the GPU kernel, and a ResNet50 classifier of coadded stamps (Smotherman et al. 2021). Their application found 75 unidentified moving objects and 24 known ones. The robust in-kernel filter, which raised the number of trajectories retained per starting pixel from four to eight, was not machine learning. Attributing the whole pipeline’s gains to deep learning would misidentify where the algorithmic progress was. The DECam Ecliptic Exploration Project (DEEP) then made this architecture part of a deep TNO survey, and Fraser’s 2024 chapter recorded the practical experience of training stack classifiers for CLASSY, the New Horizons Subaru search and JWST (Fraser 2024).

Vetting after integration

The dominant pattern in deep moving-object surveys is: integrate physically first, then let a network clean up. It deserves a close look, because its successes and its costs are both well measured.

What a stack classifier sees

KBMOD-style searches compute the likelihood for each trajectory, keep the best few per starting pixel, and make a small coadded stamp along each surviving trajectory. A real source appears as a compact PSF at the centre. Noise and artefacts appear as something else: a subtraction residual of a star, a cosmic ray caught in one frame, a smear. A CNN is very good at telling these apart. Smotherman’s network used $21\times21$ coadds and trained on synthetic sources added to real backgrounds as positives, with negatives from physically implausible search directions roughly perpendicular to the ecliptic. It reached about 96% test accuracy, and with a trajectory SNR above 15 and a CNN score above 0.75 there were generally fewer than ten candidates per CCD for a human to inspect.

Fraser’s CLASSY ensemble used $43\times43$ mean-stack stamps and three independently initialised residual-network branches, averaged. Its key methodological choice was to model implant PSFs from the actual images, propagate them along simulated orbits, insert them into the individual exposures, and rerun KBMOD. The positives therefore went through the same subtraction and trajectory selection as real objects would. Networks were trained separately for each facility because their images differed.

A held-out CLASSY night gives unusually complete bookkeeping. KBMOD returned 94,722 candidates, including 2,088 implants and about 70 real bodies. The CNN kept 3,628, about a 25-fold reduction, at a cost of about 0.1–0.2 mag in depth. Joint network and human selection kept 3,359, including 2,016 implants and the ~70 real objects. About 1,200 remaining false candidates, mostly at the faint noise boundary, were removed by linking across nights. Human review could cost another ~0.2 mag on some nights. The held-out stamp test, meanwhile, had reported 98.7% precision and 99.4% recall. Both statements are true. They measure different things.

DEEP’s own multi-year pipeline reported a median of 576 seconds per CCD for a stack of order 100 images on an NVIDIA A40, including loading, search, filtering and stamp generation, and about 282 hours in total (Smotherman et al. 2023). It used reverse-direction searches to characterise bogus candidates, a trajectory threshold above 7 and a CNN score above 0.5, raising thresholds to 10 in 51 of 1,680 searches where candidates overflowed. Humans, blinded to search direction, rejected about half the post-CNN list. In 2026 the Hyrax framework provided reproducible training and deployment for DEEP vetting: on $21\times21$ stamps it removed 72.2% of the input set, leaving 87,490, while keeping 95.2% of the inserted objects expected to pass the filter (Ghosh et al. 2026). The narrower denominator matters: this is conditional vetting performance, not survey completeness.

The Amdahl limit of vetting

Vetting operates on $K$ survivors at cost $O(K\,C_{\rm net})$. The physical search before it costs $O(PVE)$ for $P$ starting positions, $V$ velocities and $E$ exposures. Smotherman’s search used 512 velocity steps and 256 angle steps per starting position, of order $10^{12}$ trajectories for a $2{\rm K}\times4{\rm K}$ stack. Making the classifier faster, or making it reject more, does not remove that loop. If stack scanning takes 90% of the runtime, eliminating everything after it gives a total speedup of $1/0.9\simeq1.11$. Vetting saves human time and orbit-fitting time, which is often what limits a survey in practice. It does not make the search cheaper.

When the simulation is wrong

JWST’s rescue of JPB01 and JPB05 is the most instructive failure in the literature, because it was found and documented. The rejected epochs were bright, not marginal, and the implants at that brightness had all passed. A network can latch onto a simulation defect that only becomes visible at high SNR. The team could rescue the objects only because two accepted epochs had already narrowed the orbit enough to make searching the rejected candidates feasible; doing so for the whole search would have been infeasible. And they could not simply add the rescued faint objects to the population analysis, because the implant-derived efficiency assumed the original ResNet cut (Eduardo et al. 2026). The final end-to-end selection curve was

for its stated single-epoch selection, where $m_0$ is the magnitude at half the bright-end efficiency, not exactly 50% completeness. The combined characterised sample of 20 three-epoch and seven two-epoch discoveries reached F150W2 = 28.8 at 40% efficiency over 0.05 square degrees.

Proposals from single images

A second line of work asks networks to find streaks that conventional extractors miss. Fast near-Earth objects trail within each exposure, and a long trail spreads the same photons over more sky noise. The optimal streak statistic depends on $\sum_pT_i^2(p)$ for the trailed template $T_i$, not on total flux alone. A streak detector can recover sensitivity lost by a point-source detector but cannot remove that physical penalty. The right comparator is a PSF-broadened matched streak filter, which the fast Radon transform of Nir, Zackay and Ofek makes cheap (Nir et al. 2018; Chapter 11).

Franklin Wang, Jian Ge and Kevin Willis trained on synthetic streaks and searched archival ZTF images with a more permissive proposal stage. They reported six new asteroid candidates over four nights at $V\approx19.0$–20.3, moving 6.8–24 degrees per day. Most lacked follow-up; one was linked across nights and designated 2019 LH27 (Wang, Ge & Willis 2022). Belén Irureta-Goyena and colleagues went further toward segmentation: a CNN produces a streak probability map, contour fitting gives endpoints, and a physical fit on the original image refines them (Irureta-Goyena et al. 2025). On a comparison set containing 317 scanner-accepted streaks, their mixed-training model recovered 252 and produced 949 verified streaks in all, 697 more than the scanners had, with 14 false positives among 963 predictions. “Verified streak” includes spacecraft-like trails that morphology cannot distinguish, so these are not 697 new NEAs. The division of labour, with a network to localise and a physical model to measure, is the right one.

For Euclid, Mikko Pöntinen, Mikael Granvik and colleagues combined a sliding-window CNN for streak fragments, a recurrent network to join fragments within an exposure, and gradient-boosted trees to link across exposures (Pöntinen et al. 2023). Purity before linking was only 6.4%; after linking it was 95.4%, with 59.1% clean completeness for objects in at least two exposures. The local detector can afford to be permissive because temporal consistency restores purity later. Its claimed 0.25–0.5 mag advantage is over the StreakDet software on simulations, not over an optimal matched filter.

Attention mechanisms have entered too. Masato Shibukawa and colleagues fed a CNN with convolutional block attention the intermediate products of a JAXA median-stacking search at depths of 4 to 32 frames, so that it could check whether a candidate persists consistently across partial stacks (Shibukawa et al. 2025). On an independent night it reached 98.87% accuracy and an F1 of 99.35%. A two-threshold policy (accept above 0.41, reject below 0.25, send the middle to humans) left 0.63% of the manual task. That is triage of candidates from an existing motion search, not a reduction in search compute or a demonstrated gain in depth.

Not every headline survives inspection. ICC-BiFormer, a sparse-attention transformer trained on synthetic streaks in real ZTF backgrounds, reports 99.88% accuracy, a 75.36% true-positive rate and a 2.67% false-positive rate in the same table (Guo, Liu & Yang 2024). Under standard definitions, accuracy is a weighted average of the true-positive rate and the specificity (here 97.33%), so it cannot exceed both. The three numbers cannot describe one confusion matrix. They may refer to different operating points, or contain an error; the paper does not say. Either way the accuracy figure is not evidence of completeness.

Searching without a velocity bank

The most ambitious recent work tries to avoid enumerating trajectories at all. Two 2026 papers take quite different routes.

YOSO: compress time, detect trails, stack locally

Nitya Pandey, César Fuentes, Pedro Bernardinelli and collaborators’ You Only Stack Once (YOSO) starts from registered difference images (Pandey et al. 2026). A moving PSF crossing a fixed pixel makes a short bump in that pixel’s light curve. YOSO filters each pixel’s time series with a Gaussian and keeps the maximum:

Every pixel the source crossed lights up, so $J$ contains a trail along the object’s path. A YOLOv8-L object detector finds trails in $512\times512$ tiles of $J$. Each box suggests orientations for a small local shift-and-stack search, refined by the stacked source’s compactness, ellipticity, flux and centring. “Only stack once” thus describes the global proposal step; physical stacking is still done locally.

The physics of the filter is simple. For PSF dispersion $\sigma_P$, angular speed $v$ and cadence $\Delta t$, the bump lasts $\sigma_t=\sigma_P/(v\,\Delta t)$ frames, independent of direction. That is why one temporal filter can stand in for every direction of motion at a given speed. The paper adopted a seven-image filter width for 3 arcsec/hour, 1.2-arcsec seeing, 0.2637-arcsec pixels and a 140-second cadence. Its printed width equation uses the FWHM where a Gaussian dispersion would enter; the printed expression gives about 10.3 images and the dispersion form about 4.4. A replication should use the implemented seven.

The detector was fine-tuned on 16,000 tiles with more than 68,420 simulated objects at 3–5 arcsec/hour and $19<VR<27$, taking about 46 hours on a Tesla T4. Inference takes under 11 ms per tile, a figure that excludes subtraction, filtering and local refinement. Validation precision and recall were 0.80 and 0.71. The cost structure is $O(PEk_t)$ for the temporal filter over $P$ pixels, $E$ epochs and kernel length $k_t$, then tiled inference, then $O(KVE_{\rm local})$ refinement in small neighbourhoods. The global velocity factor has gone, and so has the ordering information that coherent integration uses: the maximum over time keeps where the source passed but discards when, and discards every negative fluctuation along the way.

On four DEEP field-nights previously searched with KBMOD, YOSO recovered 45 of 73 previously reported TNOs and found 11 additional single-night TNO candidates. It also reported 216 nearer objects at 10–60 arcsec/hour and 27 faster ones; these are single-night candidates without orbits. Its limits were shallower on every field.

The text reports a mean deficit of about 0.88 mag. The table’s four differences average 0.75 mag; the paper does not explain the weighting. The limits refer to a 25% recovery reference and should not be called $m_{50}$. A 0.88 mag deficit means a source must be $10^{0.352}\simeq2.25$ times brighter, and recovering it by integrating longer in the background-limited regime would need about $2.25^2\simeq5.1$ times the exposure. That is the scale of the price for skipping the velocity loop. The 11 new candidates are real value: two imperfect pipelines with different masking and selection find different objects. They do not show that YOSO is more complete.

W-Net: segment the cube

Brian Powell, Jorge Martinez-Palomera, Amy Tuson, Christina Hedges and colleagues took the other route: let a network look at the whole space–time cube (Powell et al. 2026). Their W-Net stacks two three-dimensional U-Nets that remove backgrounds and label moving-source voxels in $64\times64\times64$ cubes of TESS full-frame images, each window spanning 32 hours at the 30-minute cadence. A learned adaptive normalisation, a weighted sum of logistic functions, stretches the faint flux range. Labels come from projecting known asteroid ephemerides onto the images. Models trained on one hemisphere were applied to the other.

“Trajectory-agnostic” means no explicit velocity enumeration. It does not mean cheap. Inference over about 490 million heavily overlapping cubes across 26 sectors took about 6,000 GPU-hours, four GPUs per sector for about 2.5 days each, on an accelerator the paper does not name. A single sector–camera–CCD cube is about 50 GB. Nor does it mean equal completeness over all trajectories: sources faster than about 300 arcsec/hour were recognised less well, a reminder that the training distribution is still a bank, just an implicit one. The quantitative results are pixel-level. At labelled-pixel precision of 10%, 30% and 50%, the interpolated $V_{50}$ was 21.10, 20.82 and 19.61. Labels miss unknown asteroids, so some “false positives” may be real, and the paper stops short of a discovery catalogue. Chapter 23 places this in the TESS context.

Learned proposals and early rejection

The approach most compatible with the noise floor is not to make the final decision with a network, but to let a network decide where an exact likelihood should be evaluated. If a proposal stage costs $C_0$ and keeps a fraction $q$ of a baseline bank costing $C_B$, the speedup is

and for a cascade of stages with costs $c_1,\dots,c_L$ and unconditional survival probabilities $r_1,\dots,r_{L-1}$ the expected cost is $E[C]=c_1+r_1c_2+\dots+r_{L-1}c_L$. These are identities, not forecasts. The binding constraint is recall: the probability of accepting a real source is the probability it was proposed times the probability it is accepted given that, so an exact final likelihood cannot repair a source excluded upstream.

Adding the untouched part of the pipeline gives the full ceiling. If a fraction $f$ of runtime is unaffected, the screen costs a fraction $a$ of the old scoring work, and it keeps a fraction $q$,

With $f=0.03$, $a=0.005$ and $q=0.03$, the total speedup is about 15.6. With $f=0.05$, $a=0.02$ and $q=0.08$, it is about 6.9. If a tenth of the runtime is untouched, no proposal network can deliver tenfold. These are illustrative numbers. The point is that the ledger should be measured before the network is designed.

There is a controlled demonstration of learned rejection, though not in astronomy imaging. Yan and colleagues trained a hierarchical detection network for gravitational-wave signals injected at SNR 9 into LIGO noise, optimising both detection error and expected computation (Yan et al. 2022). A two-layer model used 79% less computation than the compared matched-filter implementation at equal false-positive and false-negative rates of 0.2%. That is a count of inner products, not a GPU wall-time measurement for an optical survey, but it shows that learned cascades can cut average work at a fixed operating point in a controlled experiment. A 2026 gravitational-wave study that restricts template banks with a network estimated 98.39% recovery with a 70.50% reduction in matched-filter work at its overlap setting, a count-only upper bound of about 3.4 times before inference and bookkeeping (Verma et al. 2026). Its recovery is post hoc parameter coverage, not measured detection efficiency.

Inference with simulators

Machine learning also enters planet searches upstream of the pixels, in deciding where to look. Simulation-based inference (SBI) uses a simulator to infer parameters when the likelihood is intractable. The framework, laid out by Kyle Cranmer, Johann Brehmer and Gilles Louppe, includes neural estimators of the likelihood, of the likelihood ratio, and of the posterior (Cranmer, Brehmer & Louppe 2020). Neural posterior estimation, for example, trains a conditional density $q_\phi(\theta\mid y)$ on simulated pairs by minimising $-E\log q_\phi(\theta\mid y)$.

The relevant Planet Nine milestone is not neural. Michael Brown and Konstantin Batygin ran 121 N-body configurations with 16,800–64,900 test particles each, turned them into a likelihood surface for the observed distant Kuiper belt objects with a Gaussian-process emulator, and explored it with MCMC (Brown & Batygin 2021). Their posterior gave a mass of $6.2^{+2.2}_{-1.3}$ Earth masses, a semimajor axis of $380^{+140}_{-80}$ au and an inclination of $16\pm5^\circ$, conditional on the model and its selection functions. Running a simulator, or injecting synthetic asteroids, does not by itself make an analysis neural SBI. At this simulation count, choosing the next simulation well may matter more than replacing the Gaussian process with a network. A neural density estimator becomes attractive if the parameter space grows to include the primordial disk, migration history and survey selection. The evidence for and against Planet Nine is in Chapter 8.

For orbits, a June 2026 study trained a conditional normalising flow with a transformer encoder to initialise orbit fits from angles-only observations, in a restricted family of simulated cislunar halo orbits, from 4,119 noisy arcs generated from ten underlying orbits (Litteri & Vasile 2026). It improved fit initialisation over a naive start. It does not establish calibrated posteriors for small-body orbits in general, and since noisy examples share underlying arcs across the split, an independence test by orbit would be stronger. A useful hybrid for sparse asteroid arcs would sample states from a flow, propagate them with a tested integrator, and reweight by the exact astrometric likelihood. Weights correct density errors only where the flow has support; a missed mode stays missed. An October 2026 study of diffusion models for spacecraft trajectories gives the warning in the other direction: all its generators remained easily distinguishable from a shifted target population, with classifier AUC of 0.991–0.998 (Ramadan et al. 2026). The same failure could bias injected training populations.

Anomalies and foundation models

Searching for something nobody has modelled is the natural home of unsupervised learning. The SNAD team applied isolation forests and other outlier detectors to 42 light-curve features of more than 2.25 million ZTF objects and investigated the 277 top outliers by hand: 188 were bogus, 66 previously reported, and 23 uncatalogued objects of potential interest. Some of the bogus variability came from asteroids passing over stars (Malanchev et al. 2021). The first harvest of an anomaly search is usually the instrument.

Foundation models make reusable representations plausible. AstroCLIP aligns galaxy images and spectra contrastively; its image pretraining used 16 H100 GPUs for about 48 hours (Parker et al. 2024). AION-1 extends masked multimodal learning to more than 200 million observations, with models from about 300 million to 3.1 billion parameters; the largest trained on 288 H100s for 3.5 days (Parker et al. 2025). Neither paper reports a moving-object result. A static-sky embedding can recognise artefacts and background morphology, but it cannot restore an asteroid erased by static coaddition, and invariances learned for galaxies may suppress exactly the small positional changes that encode motion. A temporal model needs timestamps, observer position, variances and masks, and full self-attention over $Q$ space–time tokens costs $O(Q^2d)$ per layer, which rules out naive whole-survey video transformers. AION-1’s authors note that its generative outputs need not be calibrated posteriors; for detection they should be treated as hypotheses, tested against the original pixels.

Generalisation and evaluation

Cross-instrument transfer is not solved. NEO-BENCH assembled 8,376 images from five sources, including Hubble trails, a meteor network and several streak datasets, and measured how detectors trained on some sources perform on a held-out one (He & Yao 2026). Localisation fell in 13 of 20 method–source transfers. For a YOLO26L detector, F1 dropped from 0.775 to 0.676 on StreakMind and from 0.692 to 0.382 on Hubble. The labels are generic streaks, including satellites and meteors, and some sources have few or no negative images, so the benchmark tests localisation more than detection sensitivity. Its point stands: a model’s accuracy on its own survey says little about the next one. Models trained elsewhere will have to be revalidated on Rubin’s own images before they are trusted there (Chapter 15).

Good evaluation is itself an algorithmic component. Split by physical object or observing block first, then augment, because adjacent tiles, augmented copies and repeat appearances of one asteroid leak across random splits. Inject into individual calibrated exposures, with the same noise, PSF variation, trailing and subtraction as real objects, and run the complete pipeline. Choose thresholds on calibration blocks only. On final blocks report completeness as a function of flux, rate, direction, footprint and conditions; false unique candidates per square degree per night; and total wall time, GPU time, memory, I/O and training cost, all at a matched false-alarm rate. Most published ML papers do not yet provide the area and unique-candidate accounting needed to reconstruct a false-alarm rate per area, so their false-positive rates remain conditional rates.

An honest comparison with matched filtering

The table collects every system in this chapter for which a sensitivity cost or a compute claim is reported, together with what it was compared against. It does not rank them; the metrics are incompatible, and that is the main finding.

Three conclusions follow. First, every learned stage placed after physical integration has a measured, modest cost, typically 0.1–0.2 mag, and a large benefit in workload. That is a good trade for most surveys, and it is why every deep TNO search now uses one. Second, the one learned system that replaces the global velocity search and is compared directly with a matched filter on the same images, YOSO, is 0.75–0.9 mag shallower than the matched filter on the same images, which in exposure time is a factor of about four to five. Its plausible cause is the representation, not the network: the maximum over time discards evidence that the matched filter keeps. Third, no paper examined here compares an ML search with an optimised physical search on the same exposures, the same hardware, the same parameter coverage and the same final false-alarm budget. The only controlled equal-error comparison with a matched filter is in gravitational waves, and it counts operations rather than time.

Where the room is

The limits here sort cleanly. Photon and sky noise, light lost to trailing, missing sky coverage and the range degeneracy of a short arc are physical or observational limits, and no network removes them. A classifier cannot infer a unique orbit when the measurements do not constrain it; a strong population prior can improve average decisions and suppress exactly the rare body a search hopes to find. Search-volume penalties and uncertain backgrounds are statistical limits, where learning can help by modelling nuisances better than a Gaussian likelihood. Repeated sums, overwide banks, orbit fitting on obvious junk, inefficient I/O and human review of recognisable artefacts are engineering costs. ML has already cut the last two dramatically.

The open opportunity at the noise floor is in the middle: learning where to spend exact work. The opportunities are specific.

1. Proposals on sufficient statistics. Feed a small network the signed segment sums that a hierarchical search builds anyway, and let it choose orbit cells for exact scoring. Benchmark it against analytic gates and sequential tests from Chapter 21 and Chapter 38, which may give most of the gain without training.

2. Repair YOSO’s representation. Replace one temporal width and an irreversible maximum with a small bank of duration filters plus compact timing information, so a downstream network can propose tracks while keeping more than one possible passage time. Measure depth recovered per added byte and operation.

3. Recover vetting losses. The CLASSY and JWST penalties of 0.1–0.2 mag are a measurable target. PSF-conditioned nuisance models, joint science/template/difference inputs, calibrated abstention, and an archive of rejected candidates for constrained rescue could keep the artefact suppression and win back depth.

4. Spend GPU arithmetic where it is shared. Trajectory gathers are memory-bound; network inference is compute-bound. Replacing one with the other helps only after charging the extra data movement and any lost sensitivity. The good targets are shared convolutional features, batched stamp classification, batched exact refinements and trajectory families that form reusable linear operators (Chapter 39, Chapter 40). For repeated searches, training must amortise: $N(T_{\rm old}-T_{\rm new})>T_{\rm train}$ in one consistent resource unit.

5. Choose simulations, not just emulators. For Planet Nine and similar population inferences, sequential selection of N-body runs to resolve likelihood ridges and model disagreements may be worth more than a faster posterior network. Report empirical coverage, not only a posterior.

Above all, the field needs one frozen benchmark: identical exposures with hidden injected orbits, including rare trajectories withheld from training; an optimised physical search and the ML alternatives on the same hardware; and final recall versus magnitude and motion, false accepted tracks per area and time, linking success and complete cost, all at the same operating point. Until then, a learned method’s speed should be quoted with its depth, and its depth with its comparator. Chapter 42 ranks this against the other routes to faster discovery.

References

1. Brown, M. E., Batygin, K. (2021). The Orbit of Planet Nine. AJ. arXiv:2108.09868
2. Chyba Rabeendran, A., Denneau, L. (2021). A Two-Stage Deep Learning Detection Classifier for the ATLAS Asteroid Survey. PASP 133, 034501. arXiv:2101.08912
3. Cranmer, K., Brehmer, J., Louppe, G. (2020). The frontier of simulation-based inference. PNAS. arXiv:1911.01429
4. Duev, D. A., Mahabal, A., Ye, Q., Tirumala, K. et al. (2019). DeepStreaks: identifying fast-moving objects in the Zwicky Transient Facility data with deep learning. MNRAS 486, 4158. arXiv:1904.05920
5. Eduardo, M. R., Morgan, A. N., Fraser, W. C., Trilling, D. E. et al. (2026). The Luminosity Function of Ultra-Faint Trans-Neptunian Objects Detected by JWST. AJ. arXiv:2609.09044
6. Fraser, W. C. (2024). Detecting Moving Objects With Machine Learning. In Machine Learning for Small Bodies in the Solar System. arXiv:2405.06148
7. Ghosh, A., Oldag, D., Tauraso, M., Connolly, A. J. et al. (2026). Hyrax: An Extensible Framework for Rapid ML Experimentation and Unsupervised Discovery in the Era of Rubin, Roman, and Euclid. arXiv preprint. arXiv:2605.18959
8. Guo, Y., Liu, Y., Yang, R. (2024). ICC-BiFormer: A Deep-Learning Model for Near-Earth Asteroid Detection via Image Compression and Local Feature Extraction. Electronics 13, 2092. doi:10.3390/electronics13112092
9. He, J., Yao, J. (2026). NEO-BENCH: A New Multi-Source Benchmark for Generalizable Astronomical Streak Detection. arXiv preprint. arXiv:2609.06774
10. Irureta-Goyena, B. Y., Helou, G., Kneib, J.-P., Masci, F. et al. (2025). Deep learning to improve the discovery of near-Earth asteroids in the Zwicky Transient Facility. PASP 137, 054503. arXiv:2504.11918
11. Lieu, M., Conversi, L., Altieri, B., Carry, B. (2019). Detecting Solar system objects with convolutional neural networks. MNRAS 485, 5831. arXiv:1807.10912
12. Lin, H.-W., Chen, Y.-T., Wang, J.-H., Wang, S.-Y. et al. (2017). Machine Learning Based Real Bogus System for HSC-SSP Moving Object Detecting Pipeline. arXiv preprint. arXiv:1704.06413
13. Litteri, W., Vasile, M. (2026). Physics-informed Conditional Normalizing Flows for Angles-only Cislunar Orbit Determination. arXiv preprint. arXiv:2606.30936
14. Malanchev, K. L., Pruzhinskaya, M. V., Korolev, V. S. et al. (2021). Anomaly detection in the Zwicky Transient Facility DR3. MNRAS. arXiv:2012.01419
15. Nir, G., Zackay, B., Ofek, E. O. (2018). Optimal and Efficient Streak Detection in Astronomical Images. AJ 156, 229. arXiv:1806.04204
16. Pandey, N., Fuentes, C., Bernardinelli, P., Frías, V. et al. (2026). You Only Stack Once (YOSO): A Motion-Filtered, Deep-Learning Framework for Detecting Faint Moving Sources. AJ. arXiv:2605.06913
17. Parker, L., Lanusse, F., Golkar, S. et al. (2024). AstroCLIP: A Cross-Modal Foundation Model for Galaxies. arXiv preprint (expanded version). arXiv:2310.03024
18. Parker, L., Lanusse, F., Shen, J. et al. (2025). AION-1: Omnimodal Foundation Model for Astronomical Sciences. arXiv preprint. arXiv:2510.17960
19. Pöntinen, M., Granvik, M., Nucita, A. A., Conversi, L. et al. (2023). Euclid: Identification of asteroid streaks in simulated images using deep learning. A&A 679, A135. arXiv:2310.03845
20. Powell, B. P., Martinez-Palomera, J., Tuson, A., Hedges, C. et al. (2026). Trajectory-Agnostic Asteroid Detection in TESS with Deep Learning. arXiv preprint. arXiv:2605.12391
21. Ramadan, O., Siavoshian, S., Saeed, A. K. et al. (2026). Constrained Diffusion for Data-Scarce Orbital Monte Carlo in Constellation Tasking. arXiv preprint. arXiv:2610.09323
22. Shibukawa, M., Yoshida, F., Yanagisawa, T., Ito, T. et al. (2025). Moving object detection from multi-depth images with an attention-enhanced CNN. arXiv preprint. arXiv:2512.05415
23. Smotherman, H., Connolly, A. J., Kalmbach, J. B., Portillo, S. K. N. et al. (2021). Sifting Through the Static: Moving Object Detection in Difference Images. AJ 162, 245. arXiv:2109.03296
24. Smotherman, H., Bernardinelli, P. H., Portillo, S. K. N., Connolly, A. J. et al. (2023). The DECam Ecliptic Exploration Project (DEEP) VI: first multi-year observations of trans-Neptunian objects. arXiv preprint. arXiv:2310.03678
25. Verma, C., Reza, A., Gaur, G. et al. (2026). Neural Network–Guided Parameter-Space Constraints for Gravitational-Wave Searches from Binary Black Holes. arXiv preprint. arXiv:2609.28031
26. Wang, F., Ge, J., Willis, K. (2022). Discovering Faint and High Apparent Motion Rate Near-Earth Asteroids Using A Deep Learning Program. MNRAS 516, 5785. arXiv:2208.09098
27. Whidden, P. J., Kalmbach, J. B., Connolly, A. J. et al. (2019). Fast Algorithms for Slow Moving Asteroids: Constraints on the Distribution of Kuiper Belt Objects. AJ 157, 119. arXiv:1901.02492
28. Yan, J., Avagyan, M., Colgan, R. E. et al. (2021). Generalized Approach to Matched Filtering using Neural Networks. arXiv preprint. arXiv:2104.03961
29. Yan, J., Colgan, R., Wright, J. et al. (2022). Boosting the Efficiency of Parametric Detection with Hierarchical Neural Networks. arXiv preprint. arXiv:2207.11583
30. Ye, Q., Masci, F. J., Lin, H. W., Bolin, B. et al. (2019). Toward Efficient Detection of Small Near-Earth Asteroids Using the Zwicky Transient Facility (ZTF). PASP. arXiv:1904.09645