Abandoning Hopeless Inputs Early: Radial Trajectories in a Shared Hyperbolic Space for Early-Exit Networks

Early-exit networks attach small classifiers to intermediate layers. When one of these classifiers is confident enough, the network stops and returns its answer, so easy inputs cost less compute. The part nobody handles well is the opposite case. Some inputs are hopeless: corrupted images, off-distribution content, or classes the model will never resolve. These inputs produce low confidence at every exit, so the network runs all of its layers and then gets them wrong anyway. Rethinking Calibration for Early-Exit Neural Networks named these "futile samples." It showed that calibrating each exit does not help, because a calibrated exit knows its own accuracy but not whether later layers will do better. That paper's remedy is an after-the-fact meta-classifier over softmax scores. The backbone itself is never taught to make hopelessness visible.

We propose to make hopelessness a geometric property the network learns during training. All exits embed into one shared hyperbolic space. Hyperbolic space is curved so that volume grows exponentially away from a center point, which makes it a natural fit for tree-like hierarchies: generic concepts sit near the center and specific ones near the edge. Each input's distance from the center is then tracked across depth. Inputs moving steadily outward are worth more layers. Inputs that stay stuck near the center, where hyperbolic geometry already tends to pull unfamiliar data (Balanced Hyperbolic Embeddings Are Natural Out-of-Distribution Detectors), can be abandoned early. Abandonment need not mean silence. Because points near the center correspond to coarse parent concepts, an abandoned input can still receive a coarse answer, such as "vehicle" instead of a wrong "pickup truck."

Core Claim

Early-exit decisions should be three-way: commit, continue, or abandon. The abandon decision can be read cheaply, at a cost linear in the hidden dimension, from two quantities in a hyperbolic space shared by all exits. The first is how far the embedding is from the center. The second is whether that distance is still growing across layers. We claim this beats post-hoc softmax failure prediction on the compute wasted on inputs the network ultimately misclassifies. We also claim the coarse fallback answer for abandoned inputs is correct far more often than the fine-grained answer the full network would have produced for them.

The claim is falsifiable in a specific way, and the design is built around it. Hyperbolic Embeddings of Supervised Models proves that ordinary classification confidence is proportional to hyperbolic distance from the center. A Euclidean network's logit norm may therefore carry the same information. If a Euclidean network trained with the same radial losses matches our results, the credit belongs to the training signal and not to curvature. We will report that outcome as such.

What Exists and What Is Missing

The closest work is More Than A Shortcut: A Hyperbolic Approach To Early-Exit Networks (HypEE). HypEE embeds exits in the Lorentz model of hyperbolic space, trains deeper exits to lie inside "entailment cones" of earlier ones, and exits when the embedding norm is large. On ESC-50 with a BEATs backbone, HypEE raised first-exit accuracy from 58.32% to 82.19%. HypEE is our method source for shared Lorentz embeddings. It differs from our proposal in three ways. It only decides whether to commit, so ambiguous inputs still run to the end. It reads radius at a single layer rather than as a trajectory. It was evaluated only on audio.

Detecting the Semantic Fixed Point (GCEE) does track a trajectory. It stops Transformers when Euclidean hidden-state updates shrink and align. Its own limitation motivates our work: a trajectory can settle on a wrong answer just as easily as a right one, so settling says nothing about correctness. Radial velocity toward the edge is a trajectory signal that also carries semantic direction.

The failure-prediction side motivates the problem and supplies the strongest competitor. EEFP (Rethinking Calibration) trains a two-layer MLP on top-k scores and their history to predict whether stopping now is right. EERO casts each exit as a classifier with a reject option under a compute budget. MOOD routes easy out-of-distribution images to early exits using compression length. All three operate on top of a Euclidean backbone and change nothing about what the representation encodes.

Two papers supply the geometric machinery. Balanced Hyperbolic Learning (Kasarla et al.) fixes class prototypes and balances norms so that shallow branches of the hierarchy are not mistaken for uncertainty. We reuse that recipe, because without it "near the center" would conflate rare superclasses with hopeless inputs. Uncertainty Estimation via Hyperspherical Confidence Mapping shows that training on mixup-interpolated inputs pushes ambiguous examples into the interior of a sphere. We borrow that idea to manufacture training examples of futility, since training accuracy is near 100% and real failures are scarce.

Towards Anytime Classification constrains our design. It shows that more than 25% of ImageNet samples lose ground-truth probability between exits. Any radial rule must therefore be checked for prediction flips, and not just for averaged accuracy.

Research Program

Take a multi-exit backbone with exits $l = 1, \dots, L$. Each exit maps its features through a small head and an exponential map into a Lorentz hyperbolic space shared by all exits, giving an embedding $z_l(x)$. Class prototypes are fixed on or near the boundary of this space, following the balanced construction. For CIFAR-100 they are built from its 20 superclasses. For ImageNet they are built from WordNet. Superclass prototypes sit at a smaller radius along their children's mean direction.

Every exit is trained with a geodesic prototype loss against the same prototypes, which makes radii comparable across depth. Two further losses shape the trajectory. The first penalizes any decrease in radius across exits on correctly classified training inputs. The second pulls mixup-interpolated and synthetically corrupted inputs toward a small inner ball.

At inference, the method computes

$$r_l(x) = d_{\mathbb{H}}(o, z_l(x)), \qquad v_l(x) = r_l(x) - r_{l-1}(x),$$

where $o$ is the center of the space, $d_{\mathbb{H}}$ is hyperbolic distance (a single arccosh of the time coordinate in the Lorentz model), $r_l$ is the radius at exit $l$, and $v_l$ is its change from the previous exit.

The network commits when $r_l$ exceeds a commit threshold and the nearest leaf prototype is clearly nearer than the second nearest. It abandons when $r_l$ stays below an inner threshold and $v_l$ stays small for $K$ consecutive exits after a short warmup. When it abandons, it returns the nearest superclass prototype, or a reject, depending on the deployment setting. Otherwise it continues.

Thresholds are set on a held-out split to meet a target compute budget, using the same budgeted procedure for every method. To handle crowding at the boundary, we cap the radius and compute in the Lorentz model rather than the Poincaré ball.

The analysis has three parts. First, we measure how well $(r_l, v_l)$ at early exits predicts final-exit failure. Second, we check whether this separation survives distribution shift on DomainNet. Third, we test whether radius depends on superclass size once balancing is applied, which is the known bias that balancing is meant to remove.

Baselines

The naive reference point is the same backbone with temperature-scaled entropy thresholds at each exit, as in The Right Tool for the Job, plus the full network run on every input. These two points anchor the accuracy-versus-compute curve.

The strongest existing competitor is EEFP (Rethinking Calibration). It targets exactly our question, stopping early on inputs that will fail, and it was evaluated on the vision backbones and datasets we use. We run the authors' MLP with top-k scores and trajectory history on an identical Euclidean multi-exit backbone. The data, training epochs, and threshold search budget match ours. The file quotes no exact EEFP score: no reported result found on Lacuna for EEFP's AUROC or cost-accuracy numbers on CIFAR-100, TinyImageNet, or ImageNet-1k. We will therefore reproduce it. Beating EEFP means two things at a matched compute budget. Final accuracy must be no worse. Compute spent on inputs that end up misclassified must be significantly lower. As a secondary target, the failure-prediction AUROC at the first two exits must be higher.

We also run HypEE's single-radius commit trigger on our shared Lorentz backbone, with a naive radius cutoff added for abandonment. This is the obvious extension of the closest work, and it isolates whether the trajectory $v_l$ matters beyond the instantaneous radius.

For out-of-distribution rejection, MOOD is the reference. It reports CIFAR-100 compute savings averaging 22.02% and CIFAR-10 AUROC of 0.9126 on MSDNet, and we run it on MSDNet for comparability.

The key ablation is a Euclidean twin. It uses the same architecture, the same prototype and radial-ordering losses applied to logit or feature norm, the same mixup-futility loss, and the same three-way rule. A second ablation feeds our $(r_l, v_l)$ features into the EEFP MLP. Together these separate three possible sources of any gain: the curvature itself, the training-time shaping, and the decision rule.

Why not just…?

Why not just use EEFP on the softmax trajectory? EEFP is the real competitor and may well be close. Its inputs, however, are scores from heads that were never trained to separate "not yet sure" from "never going to be sure." At early exits the two look identical in softmax space, which is exactly why futile inputs were a problem in the first place. The ablation that feeds EEFP our geometric features answers this directly. If EEFP on softmax already matches geometric features at early exits, the representation contributes nothing and we will say so.

Why not just track logit or feature norm in an ordinary Euclidean network? This is the most serious threat. The equivalence in Hyperbolic Embeddings of Supervised Models suggests that Euclidean norm and hyperbolic radius may encode the same confidence. The evidence against it is indirect. Hyperbolizing scores cut CIFAR-100 false positives at 95% recall from 58.24% to 49.46% under balanced learning (Kasarla et al.). HypEE's 32-dimensional hyperbolic model matched a 128-dimensional Euclidean one. Neither result tests early abandonment. The Euclidean-twin ablation is designed to settle the question. If the twin matches us, the contribution reduces to the training losses and the three-way rule, which remains useful, and we will drop the curvature claim.

Why not just cap depth with a compute budget and a reject option, as in EERO? A budget limits the total spent but does not direct savings away from hopeless inputs. EERO's scorers come from Euclidean classifier outputs, and its rejected inputs get no answer at all. We compare under EERO's own budgeted threshold procedure. We also report the correctness of coarse fallback answers, which a pure reject option cannot provide.

Proposed Experiments

Experiments cover CIFAR-100, where the superclass hierarchy is built in, TinyImageNet, ImageNet-1k with WordNet prototypes, and DomainNet for shift. Backbones are MSDNet, ResNet-34, and ViT-Small, matching the EEFP evaluation. Futility is measured on naturally misclassified test inputs, on corrupted copies of the test sets, and on MOOD's out-of-distribution suite (SVHN, Textures, Places365, LSUN, iSUN).

The metrics are accuracy against FLOPs, the fraction of FLOPs spent on inputs the network ends up misclassifying, the EEFP failure-prediction AUROC per exit, superclass accuracy of abandoned inputs, and the per-sample rate of ground-truth probability drops across exits. The last metric is compared against the more-than-25% figure from Towards Anytime Classification.

The decisive checks are three. First, at matched final accuracy, abandonment must cut FLOPs spent on eventually-wrong inputs by a clear margin over reproduced EEFP. Second, the Euclidean twin must fall measurably short, or the curvature claim is withdrawn. Third, abandoned inputs must receive correct superclass answers much more often than their fine-grained final-exit answers are correct. If radial velocity adds nothing over single-layer radius in the HypEE-style ablation, the trajectory component is dropped, and the paper becomes a study of learned radial futility.