When a deployed vision model must learn new categories, the usual options are poor ones. Retraining on all data ever collected is expensive. Fine-tuning on only the new data makes the model forget old categories. Freezing a separate small module per task avoids forgetting, but then someone has to tell the model which module to use at test time, and the number of modules grows with every update. This proposal makes the category hierarchy itself do that bookkeeping. Each node of a taxonomy, such as "furniture → chair → my office chair," owns a small isolated adapter that is trained once, when the node first appears, and then frozen. An input is processed by the adapters on a single root-to-leaf path. The path is chosen by descending a hyperbolic embedding of the taxonomy, meaning an embedding in a negatively curved space where tree-like structures fit with little distortion and where distance from the origin naturally encodes depth.
Under this design, adding a category costs one small training job on new data only. Old categories cannot be overwritten, because their adapters receive no gradient. Inference cost grows with the depth of the tree rather than with the number of tasks seen. The bet is that hyperbolic geometry is what makes routing work without task labels at the deep, crowded levels of a hierarchy, where flat-space routers confuse siblings. The experiments are designed so that this bet can fail visibly.
Core Claim
Parameter isolation guarantees zero forgetting but leaves two problems open. One is task identity at inference: CAGNN needs a task-ID oracle, and EPI routes with Euclidean Mahalanobis distance over a flat list of tasks. The other is cost that scales with total capacity: CAGNN shows that masked networks still compute over the full weight matrix.
Hyperbolic continual learners do not isolate parameters. HMCL protects old concepts by projecting gradients in Lorentz space. HypCL composes adapter updates along one shared path with Möbius addition. HyperCLIC uses fixed hyperbolic prototypes from a WordNet tree that is set before training, combined with distillation and replay.
Our claim is that organizing isolated modules as a tree, and routing through it non-parametrically with hyperbolic entailment cones, gives three things together:
- task-agnostic, class-incremental inference;
- update cost independent of history;
- inference cost logarithmic in the number of leaves for a balanced tree.
We further claim that hyperbolic routing beats an otherwise identical Euclidean tree router by a margin that grows with taxonomy depth and branching. We do not claim that hyperbolic parameters escape the "capacity wall" of Lanzillotta et al.. Their capacity wall concerns weight-space null directions, and exponential volume in embedding space does not obviously transfer to that setting. Our capacity growth is explicit: one adapter per node.
Mechanism
The backbone is a frozen pretrained hyperbolic vision-language encoder, specifically a HyCoCLIP or MERU checkpoint from PalAvik/hycoclip. Its features are mapped onto the Lorentz hyperboloid. We use the Lorentz model rather than the Poincaré ball because HyperExpan found it more numerically stable.
Each taxonomy node $v$ owns a low-rank adapter $A_v$. Each node also stores an apex point $p_v$ on the hyperboloid that defines its entailment cone, following Ganea et al.. The representation of input $x$ at node $v$ is computed in the tangent space at the origin and then mapped back to the manifold:
$$z_v(x) = \exp_0\Big(\log_0 f(x) + \sum_{u \in \pi(v)} A_u(x)\Big)$$
Here $f$ is the frozen encoder, $\pi(v)$ is the root-to-$v$ path, and $\exp_0, \log_0$ are the exponential and logarithmic maps at the origin.
Routing descends greedily, or with a beam of width $k$. At node $v$, the input moves to the child $c$ with the smallest cone-violation energy $E(p_c, z_v(x))$, which is the angular amount by which $z_v(x)$ falls outside $c$'s cone. If every child's energy exceeds a threshold, the model stops and predicts $v$. This gives an honest coarse answer ("a chair, unknown instance") instead of a confident wrong leaf. The aim is to address the miscalibration under incremental updates that Point-UQ highlights.
When a new concept arrives, it is attached under a parent. The parent is given by the label hierarchy, or, in the dynamic-taxonomy setting, chosen by a HyperExpan-style placement score. Then a fresh adapter $A_c$ and apex $p_c$ are trained on the new data alone, with all existing adapters frozen. As in ExSSNeT, old weights are used in the forward pass but never updated.
The only place old knowledge can be disturbed is the router. A new sibling cone can steal inputs from its neighbors. We therefore add a margin loss that pushes $p_c$ away from existing sibling apices, using only stored apex points and no raw data. We also measure routing interference directly as a separate quantity.
Research Program
The work has three stages.
The first stage builds the system above on a fixed taxonomy. It measures accuracy at each level, forgetting, and how often routing errors at each depth cascade into leaf errors.
The second stage relaxes the fixed taxonomy. In this setting superclasses are revealed late, and some concepts arrive without a parent label. This is the setting HyperCLIC explicitly cannot handle. It tests whether placement plus isolated growth keeps old leaves intact.
The third stage is a cost study. It reports training FLOPs per update, wall-clock time, parameter growth, and inference FLOPs as a function of tasks seen, for both our method and the baselines. The goal is to substantiate the retraining-overhead argument made by Chen et al. and Verwimp et al.. We also report the extra cost of hyperbolic operations. HyCoCLIP reports 73 versus 45 training hours against Euclidean CLIP, so that overhead must be shown to be small when it is confined to adapters and routing.
Baselines
Do nothing / naive references. There are two:
- The frozen backbone with zero-shot hyperbolic classification against text embeddings, which is the cost floor.
- Sequential fine-tuning of a single adapter, which is the forgetting ceiling.
A joint-retraining upper bound on all data is also reported. Following PI-GNN, it brackets accuracy and gives the reference cost that incremental methods should beat.
HypCL (HypCL). This is the strongest existing hyperbolic adapter method in class-incremental settings. On CIFAR-100 B0 Inc10 it reports 89.09% average and 82.95% final accuracy, beating Engine. We rerun it with the same backbone, the same per-update adapter parameter budget, and an equal hyperparameter search budget over its bandwidth $b$ and fusion weight $\eta$. Beating it means matching or exceeding final accuracy while showing lower per-update compute and lower forgetting on old classes.
HyperCLIC (HyperCLIC). On the 15-task EgoObjects stream it reports 41.76% instance accuracy and 4.17% forgetting, versus iCaRL at 20.05% and 10.57%. That figure is trained from scratch. A fair comparison therefore reruns HyperCLIC on our pretrained backbone, with its exemplar buffer, and reports both numbers. Beating it means higher instance accuracy at forgetting at or below its level, without any exemplars.
HiDe-PET (HiDe-PET). This is the strongest Euclidean isolation method with task-identity inference. It reports roughly 91.2% final average accuracy on Split CIFAR-100 and roughly 70.9% on Split Cars-196. We run it on the same backbone.
EPI-style flat routing (EPI). This uses per-task adapters with Mahalanobis routing and isolates the value of the tree.
HMCL (HMCL). This is hyperbolic projection without isolation. It reports a 74.5% relative reduction in backward-transfer forgetting on MERU-L versus fine-tuning. It is included for the 15-dataset stream.
Key ablation. The decisive ablation is the identical tree of frozen adapters with Euclidean routing. In this variant, nodes store Euclidean centroids and Gaussian covariances, and routing descends by Mahalanobis distance. Dimension and parameter count are matched to the hyperbolic variant. A second ablation keeps hyperbolic routing but replaces the tree with flat adapters. This separates the contributions of geometry and structure.
Why not just…?
Why not just use a Euclidean tree of adapters with hierarchical Mahalanobis routing? This is the serious threat, and it is why the key ablation exists. For shallow, wide hierarchies a Euclidean tree may route just as well. Euclidean distortion should bite at deep levels with many siblings, as the low-dimensional WordNet results of Nickel and Kiela and the cone F1 gains in Ganea et al. suggest. We will plot the gap in routing accuracy against depth on EgoObjects' 12-level taxonomy, and against embedding dimension. If the gap does not grow with depth, the honest conclusion is that the tree isolation is the contribution and hyperbolic geometry is optional. We will report it that way.
Why not just compose adapters along one path, as HypCL does? A single shared path keeps updating shared parameters, so old classes have no structural protection. HypCL mitigates drift but does not eliminate it. Our forgetting measurements will show whether its drift is practically small. If it is, our remaining advantages are per-update cost and coarse-level abstention, and the experiments will show whether those are worth the extra machinery.
Why not just store exemplars and distill? Distillation methods forget substantially on hierarchical streams: iCaRL at 10.57% and DER at 35.39% on EgoObjects (HyperCLIC). Replay is also excluded under privacy constraints. We include an exemplar budget for HyperCLIC so that it gets its best case.
Why not just project gradients as HMCL does? Projection avoids per-node modules, but it exhausts orthogonal directions as tasks accumulate, as Lanzillotta et al. analyze. It also requires maintaining bases of past representations. A long stream of over 100 nodes will show whether HMCL's accuracy degrades with stream length while ours stays flat.
Proposed Experiments
Benchmarks. The main benchmark is EgoObjects with its 12-level WordNet taxonomy and 15-task protocol. We use CIFAR-100 B0 Inc10 with its 20 superclasses to give a two-level tree, Split Cars-196 with a make → model hierarchy, and the HMCL 15-dataset stream for cross-domain breadth. A dynamic-taxonomy variant of EgoObjects withholds parent labels for a third of new concepts, and the MAG-PSY taxonomy from HyperExpan serves as a placement sanity check.
Metrics. We report:
- final and average accuracy;
- per-level accuracy and Lowest-Common-Ancestor error distance;
- average forgetting, split into adapter forgetting (zero by construction) and router forgetting;
- abstention precision;
- per-update training FLOPs and time;
- inference FLOPs against the number of tasks;
- total parameter growth.
Decisive checks.
- Exemplar-free, our method should match HypCL's reported 82.95% final accuracy on CIFAR-100 B0 Inc10 within noise, while cutting per-update compute.
- On EgoObjects, our method should exceed rerun HyperCLIC instance accuracy at no greater forgetting.
- The advantage of hyperbolic over Euclidean tree routing should grow with depth.
- Inference cost should stay near-constant as leaves grow from tens to over a thousand.
If check 3 fails, the geometry claim is withdrawn. If check 4 fails because the beam width must grow to keep accuracy, the efficiency claim is weakened accordingly.
References
- Capacity-Agnostic Parameter Isolation for Continual Graph Learning
- Rehearsal-free Continual Language Learning via Efficient Parameter Isolation
- Hyperbolic Multimodal Continual Learning
- HypCL: Adapting CLIP in Hyperbolic Space for Continual Learning
- Continual Hyperbolic Learning of Instances and Classes
- Towards guarantees for parameter isolation in continual learning
- HyperExpan: Taxonomy Expansion with Hyperbolic Representation Learning
- Hyperbolic Entailment Cones for Learning Hierarchical Embeddings
- Point-UQ: An Uncertainty-Quantification Paradigm for Point Cloud Few-Shot Class Incremental Learning
- Exclusive Supermask Subnetwork Training for Continual Learning
- AI Maintenance: A Robustness Perspective
- Continual Learning: Applications and the Road Forward
- Compositional Entailment Learning for Hyperbolic Vision-Language Models
- Continual Learning on Dynamic Graphs via Parameter Isolation
- HiDe-PET: Continual Learning via Hierarchical Decomposition of Parameter-Efficient Tuning
- Poincaré Embeddings for Learning Hierarchical Representations