Prototype Based Class Expansion Without Retraining

29 concepts23 papers1 proposal

Standard deep learning models excel at classification within a fixed, closed world. However, when deployed in dynamic environments, they encounter a fundamental bottleneck: the ubiquitous softmax classification layer. A standard softmax layer relies on a fixed weight matrix where each row represents a specific class boundary. Introducing a new category requires structurally altering this matrix and retraining the entire network via backpropagation. As noted by Krystian Mikolajczyk et al., this retraining process is computationally intensive and scales poorly. Furthermore, Hong-Ming Yang et al. observe that these parametric boundaries make models brittle and overconfident when encountering unseen data.

To overcome this limitation, a powerful paradigm has emerged: prototype-based class expansion. Instead of drawing rigid parametric boundaries to separate classes, these systems decouple the feature extractor from the classification architecture. By mapping inputs into a shared metric space and representing classes as non-parametric centroids, models can instantly learn new categories without modifying their underlying weights.


The Core Mechanism: Shifting from Boundaries to Centroids

The core intuition behind prototype-based learning is a shift from discriminative hyperplanes to geometric proximity. The network acts as an embedding engine, projecting raw inputs into a high-dimensional feature space. Within this space, rather than training a classifier to draw lines between categories, each class is defined simply by its geometric center, or prototype.

Standard Softmax (Parametric)          Prototype-Based (Non-Parametric)
       Class A                                Class A
          |                                      |
   -----> W1 -----> Class A               -----> ⊙ (Centroid A)
Input                                  Input
   -----> W2 -----> Class B               -----> ⊙ (Centroid B)
          |                                      |
       Class B                                Class B
(Requires retraining W to add Class C)   (Simply add Centroid C to memory)

To classify an incoming sample, the model computes its embedding vector and calculates its distance to the existing class prototypes. As demonstrated by Samantha Guerriero et al., this Nearest Class Mean (NCM) framework performs competitively with standard softmax networks while offering unprecedented architectural flexibility.

When a new category emerges, the system does not trigger a gradient descent loop. Instead, it processes the new samples through the frozen feature extractor, computes their average feature vector, and appends this new coordinate to a dynamic lookup table or memory bank (Hu Xu et al.; David Mojzísek et al.). The classification layer "morphs" instantly because it is treated as a retrieval problem against an expanding database rather than a static matrix of weights (Xiangyun Zhao et al.).


Why It Works: Geometric Stability and Zero Forgetting

Prototype-based expansion works seamlessly because it fundamentally bypasses the root cause of catastrophic forgetting. In standard networks, forgetting occurs because the gradient updates required to accommodate new data overwrite the weight configurations optimized for historical data. By eliminating backpropagation during the expansion phase, the representations of previously learned classes remain perfectly preserved (Kimin Lee et al.; Jun CEN et al.).

This approach relies on three key properties of high-dimensional metric spaces:

1. Representation Averaging Scales Linearly

Because classes are represented by their feature averages, adding a new category is an $O(1)$ memory insertion task. Guang Chen et al. demonstrate that this allows classification systems to scale to thousands of classes on the fly. Similarly, Michael Hersche et al. leverage hyperdimensional computing to map classes to quasi-orthogonal vectors, enabling instant, few-shot incremental updates with zero degradation of core feature extractors.

2. Flexible Distance Metrics Shape the Space

The geometric behavior of the embedding space can be tailored using different distance metrics. For instance, Kimin Lee et al. model class distributions using generative Mahalanobis distances, allowing the system to incorporate new classes by simply updating class-conditional means and covariances. To achieve structural scalability, Hari Chandana Kuchibhotla et al. replace standard linear layers with cosine similarity-based projections, ensuring the model can expand to an arbitrary number of categories without requiring architectural modifications.

3. Clustering Mitigates Label Drift

By mapping data samples into a vector space clustered around category centers rather than forcing them into discrete softmax bins, the system naturally accommodates variations within a class. Bowen Yu et al. show that this clustering strategy effectively mitigates catastrophic forgetting when new classification categories are introduced mid-project, as the underlying feature space remains stable even as new centers are calculated.


Managing the Open World

In real-world scenarios, systems must not only learn new classes but also recognize when an input does not belong to any known category. Prototype networks excel at this "open-world" recognition by defining rejection thresholds based on distance.

Abhijit Bendale et al. formalized this by managing "open space risk" through the Nearest Non-Outlier (NNO) algorithm. If a sample falls too far from all existing prototypes, it is flagged as an unknown category. Once labeled, its prototype is calculated and added to the memory bank, dynamically expanding the system's knowledge base.

This plug-and-play architecture can be adapted to various complex environments:

  • Deep Metric Learning: Arwin Gansekoele et al. utilize a triplet loss framework to ensure that the underlying metric space remains highly discriminative, allowing the system to accurately cluster and identify entirely new classes without retraining.
  • Ensemble Expansion: Deng-Bao Wang et al. address emerging labels in partial label learning by training dedicated one-class detectors for new categories and appending them to an existing ensemble, avoiding a global model overhaul.
  • Non-Parametric Subspaces: Syed Afaq Ali Shah et al. eliminate the training phase entirely by representing classes as linear subspaces, allowing for immediate registration of new subjects in data-limited scenarios.

Even early symbolic machine learning systems foreshadowed this concept. For example, the NGLAUBER system proposed by Randy Jones dynamically introduced abstract classes when multiple objects exhibited identical behaviors, rewriting its internal facts to simplify representations and enable broader generalizations without starting from scratch.

Ultimately, by shifting the burden of learning from weight optimization to geometric memory insertion, prototype-based class expansion provides a scalable, robust, and mathematically elegant solution for open-world lifelong learning.

Key Foundational Work

Multiple Object Class Detection with a Generative Model (2006) — contributed 1 concept elements to this direction.
Generating Predictions to Aid the Scientific Discovery Process (1986) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_prototype_based_incremental_learning_01197582,
  title = {prototype-based incremental learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/prototype-based-incremental-learning/rdr_01197582f1624159aa7b6e0e5685effe},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_prototype_based_incremental_learning_01197582_v1,
  title = {prototype-based incremental learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/prototype-based-incremental-learning/rdr_01197582f1624159aa7b6e0e5685effe/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake