Earth-observation satellites capture far more data than they can send to the ground. One operational estimate puts the fraction actually downlinked at about 2% (Earth+). The best current fix is to send compressed intermediate features of a neural network instead of pixels, and let the ground station run the rest of the network. This works well, but the compressed stream is dense. Its size is controlled indirectly, by a training-time trade-off weight, so a model trained for one bitrate cannot be made to fit exactly into the few hundred kilobits a particular ground-station pass allows. We propose a different encoding. On board, each spatial location's feature vector is written as a short list of "atoms" drawn from a learned dictionary, and the satellite sends only the atom indices and their values. The network is trained with a penalty that directly counts how many atoms are active (an $L_0$ penalty), rather than the usual penalty on their total size. Because of this, the value of each kept atom stays at full size rather than being shrunk toward zero.
The payoff is operational rather than only a better rate curve. A single trained model can be tuned at deployment time to hit any exact per-pass budget. It does this with one scalar threshold shift, computed in linear time across the whole image swath. The ground-side decoder is a plain sum of dictionary atoms, so it cannot invent texture that was never sent. The core bet is that direct $L_0$ training, unlike shrinkage-based or top-$k$ training, yields codes that degrade gracefully when this threshold is moved far from its training value. If that bet fails, the idea reduces to a worse entropy coder, and the experiments are designed to show quickly whether it does.
Core Claim
Sparse autoencoders are networks that rewrite a vector as a sparse combination of dictionary directions. Those trained with JumpReLU, an activation that outputs zero below a learned per-feature threshold and the unchanged input above it, reach better reconstruction-versus-sparsity trade-offs than Gated and TopK sparse autoencoders on Gemma 2 9B activations. They avoid the magnitude shrinkage of $L_1$ training, cost one elementwise comparison at inference, and produce few dead features (Jumping Ahead). That work only studies language-model interpretability on servers.
Our claim is that the same mechanism, applied to the shallow convolutional features a satellite would otherwise send densely, gives three properties at once. The first is task accuracy on the ground within the "lossless" margin of <1% mAP drop that FOOL uses, at comparable bitrate. The second is exact compliance with an arbitrary per-pass bit budget from one model, over at least a 4× range of budgets. The third is a non-generative ground decoder, so reconstructions carry no hallucinated content.
The second property is the new one. The hypothesis behind it is that $L_0$-trained codes keep calibrated, unshrunk magnitudes, so raising the threshold drops the weakest atoms without distorting the survivors. In $L_1$-trained codes, shrinkage is baked into every surviving value.
Research Program
The onboard encoder is a lightweight student network in the style of FOOL's shallow bottleneck injection. It produces a feature map that mimics an early layer of a frozen detection or classification teacher. At every spatial location, a 1×1 JumpReLU encoder maps the $C$-dimensional feature to $M$ dictionary coefficients $a_{i}$, with learned thresholds $\theta$. Training minimizes teacher-feature reconstruction error plus $\lambda \|a\|_0$, using the kernel-density straight-through gradient from Jumping Ahead. We also add a small downstream-task distillation term.
Transmission cost is accounted explicitly rather than through an entropy model. Location $i$ keeps $k_i$ atoms out of a dictionary of $M$. Each kept value is quantized to $b_v$ bits. The index set is enumerative-coded, meaning it is written as its position in the list of all possible index sets of that size. The bits for a swath are then
$$R = \sum_i \left[\log_2 \binom{M}{k_i} + k_i\, b_v\right],$$
and our reported bitrates will count both terms. A lightweight entropy coder on indices is allowed as an ablation, to show how much the explicit count leaves on the table.
At deployment the satellite knows its pass budget $B$. It shifts all thresholds by a common offset $\delta$, so that an atom survives only if $a_i - \theta > \delta$. It chooses the smallest $\delta$ with $R(\delta) \le B$. Because survival is monotone in $\delta$, this is a selection problem over all margins in the swath. It can be solved by expected-linear-time selection plus a short bisection on $R$, which is the same flavor of exact linear-time cardinality projection that the NPG index-tracking work exploits in a different domain. The global budget is shared across tiles, so visually complex tiles automatically receive more atoms. This is the fine-grained counterpart of Earth+'s all-or-nothing decision per 64×64 tile.
On the ground, a linear decoder rebuilds the teacher features as a weighted sum of dictionary atoms. The frozen teacher tail then runs detection or classification. A second linear-plus-small-CNN head produces an RGB preview for analysts.
We also address the known JumpReLU failure mode of a few "dense" features that fire on more than 10% of inputs (Jumping Ahead). These waste index bits at every location. After training, we move any feature that fires above a frequency cutoff into a small fixed dense side channel, and we measure whether this pays for itself.
Baselines
The naive reference point is JPEG-2000 applied to the pixel tiles at the same per-pass byte budget, followed by the unmodified ground detector. This is what flight hardware already does. COSMIC reports that on fMoW its learned codec keeps land-use accuracy up to 3–4% above JPEG2000 (COSMIC), which gives a sense of the gap a learned method should open.
The strongest existing method is FOOL (FOOL): shallow variational bottleneck injection with inter-tile attention and a learned entropy model. It reports a 51% lower bitrate than prior bottleneck-injection methods at <1% mAP drop on DOTA-2, xView and SpaceNet-3. The file gives no absolute mAP or bits-per-pixel values, so we will reproduce FOOL ourselves with the same teacher, student backbone, training data and GPU-hour budget as our model. FOOL's reported relative claims serve only as a sanity check that the reproduction is faithful.
Because FOOL controls rate through a training weight, we give it the most favorable fair treatment. We train one FOOL model per target rate, sweeping as many models as our single model is evaluated at. When FOOL must fit a pass budget at deployment, we take the nearest trained model below that budget. Beating FOOL means matching its mAP within 1 point at its own operating points. It also means exceeding the single-model FOOL variant by a clear margin, which we set in advance at 2 mAP, when budgets are pushed 2–4× away from that model's training rate.
Two ablations isolate the key ingredient, which is $L_0$ training rather than sparsity per se. The first replaces JumpReLU with a ReLU-plus-$L_1$ encoder of the same size. The second replaces it with a TopK encoder trained at a fixed $k$. Both are deployed with the identical global threshold-shift or top-$k$ budgeting. If either matches JumpReLU across the budget range, then our explanation based on unshrunk magnitudes is wrong.
Why not just…?
Why not just use a learned entropy model, since it already spends almost nothing on near-zero latents? This is the most serious threat. At any single operating point, a well-tuned hyperprior codec like FOOL's may equal or beat an explicit index-plus-value code, because $\log_2\binom{M}{k}$ is not free. We do not claim to win on that axis. What an entropy model does not give is exact budget compliance and wide-range rate control from one model. Our budget-sweep experiment measures precisely this. If a single FOOL model re-quantized at deployment stays within 2 mAP of our model across the 4× budget range, the proposal loses its main justification and we will report that.
Why not just train normally and keep the top-$k$ activations at inference, or train a TopK encoder? Jumping Ahead shows that JumpReLU matches or exceeds TopK fidelity at equal sparsity while avoiding TopK's $O(N\log K)$ partial sort, which matters on a 15 W Jetson-class device. The file also documents that post-hoc ranking of an unsparsified representation is noisy (Guo et al.). TopK trained at one $k$ is still a real competitor for deployment at other $k$. The TopK ablation described under Baselines directly tests whether it degrades faster than JumpReLU when the budget moves.
Why not just drop unchanged tiles against a fresh reference, as Earth+ does? Earth+ cuts downlink by 1.3–3.3× over prior onboard compressors, but it decides per whole 64×64 tile. Its authors note false changes from snow and shadows. The approaches are complementary rather than rival: tile differencing decides what to send, and our code decides how cheaply to send it. We will run Earth+-style tile selection in front of both FOOL and our encoder on the Washington State Sentinel-2 data, to check that the gains stack rather than overlap.
Why not just classify on board and send labels? The ΦSat-1 flood segmenter achieves a 100× reduction by sending 2-bit masks (Flood Detection On Low Cost Orbital Hardware). However, it discards everything outside its three classes, and it over-predicts water in cloud shadow with no raw data left to audit. Our code keeps a reconstructable, task-transferable representation. The experiments below test transfer to a task the teacher was not built for.
Proposed Experiments
The main rate-accuracy study uses DOTA-2 and xView object detection, following FOOL's protocol. For each budget in a sweep, we report ground mAP against the exact transmitted bits. The decisive plot shows mAP versus budget for our single model, the per-rate FOOL family, a single FOOL model forced to other budgets, the $L_1$ and TopK ablations, and JPEG-2000. The prediction is that JumpReLU tracks the per-rate FOOL envelope within 1 mAP, while the single-model FOOL variant and the $L_1$ ablation fall away at the budget extremes.
Transfer and fidelity are tested on fMoW. We train the dictionary on detection-teacher features and then fit only a linear classifier on the ground from the transmitted codes. We compare against COSMIC-style reconstructions and JPEG2000 at matched bits. For the hallucination question, we measure how often the RGB preview contains structure absent from the source tile, using a paired edge-agreement score on calm-water and uniform-terrain tiles, the failure cases COSMIC names below 0.1 bpp. A linear atom decoder should show no such additions by construction, and this check verifies the claim empirically.
On WorldFloods, we test whether a flood head trained on the ground from sparse codes approaches the onboard SCNN's reported 67.54% IoU at 10 m (Flood Detection On Low Cost Orbital Hardware), while downlinking a code that also supports reconstruction.
Onboard feasibility is measured on a Jetson Orin Nano at 15 W. We report encoder plus budget-selection latency per megapixel against FOOL-S, which is reported to keep pace with real-time sensor rates. The threshold-shift selection should add negligible time relative to the convolutional encoder. If it does not, the linear-time argument fails in practice.
Finally, we measure how many bits the dense-feature side channel saves, and whether the thresholds learned on one region stay budget-exact under the cross-location and cloud shifts of the Sim benchmark (Embedding-only uplink). Budget exactness should hold by construction, so this experiment tests whether accuracy holds too.
References
- Earth+: On-Board Satellite Imagery Compression Leveraging Historical Earth Observations
- Jumping Ahead: Improving Reconstruction Fidelity with JumpReLU Sparse Autoencoders
- FOOL: Addressing the Downlink Bottleneck in Satellite Computing With Neural Feature Compression
- An efficient optimization approach for a cardinality-constrained index tracking problem
- COSMIC: Compress Satellite Image Efficiently via Diffusion Compensation
- Dependence Guided Unsupervised Feature Selection
- Flood Detection On Low Cost Orbital Hardware
- EMBEDDING-ONLY UPLINK FOR ONBOARD RETRIEVAL UNDER SHIFT IN REMOTE SENSING