Domain-Incremental Learning

The core challenge is a non-stationary input distribution (P(X)) while the output space and task function (P(Y|X)) remain constant. For example, a digit classifier must perform consistently whether the input is from the MNIST dataset (handwritten digits), SVHN (street view house numbers), or synthetic digits, all representing the same 10 classes. The model must adapt to new visual domains without forgetting how to classify digits.

Unlike task-incremental learning, no task identifier is provided at test time. The model must infer the correct output based solely on the input's domain characteristics. This requires the learned representation to be domain-invariant or to contain sufficient cues to automatically activate the appropriate domain-specific processing pathway. This makes it more challenging than scenarios where the task ID is explicitly given.

The model must solve the stability-plasticity dilemma at the feature level. It needs:

• Plasticity to learn new feature extractors relevant to the novel domain.
• Stability to protect high-level, task-relevant features shared across domains. Algorithms often use regularization (e.g., EWC, SI) to penalize changes to important parameters for old domains, or dynamic architectures to allocate new capacity.

Experience Replay (ER) is the most empirically effective and widely used strategy. A replay buffer stores a small, curated subset of examples from previous domains. During training on a new domain, these old examples are interleaved. This directly rehearses the task on old data distributions, preventing catastrophic forgetting. Variants like Generative Replay use a generative model to produce synthetic past data.

Standard benchmarks artificially create domain sequences:

• Rotated MNIST: Sequential tasks of MNIST digits rotated by a fixed angle (e.g., 0°, 15°, 30°...).
• Permuted MNIST: Sequential tasks with a fixed pixel permutation applied to MNIST images.
• Split CIFAR-100-C: Using the CIFAR-100-C corruption benchmark, where each task introduces a different type of image corruption (e.g., Gaussian noise, blur, fog). Performance is measured by average accuracy across all seen domains after sequential training.

• vs. Class-Incremental: Both are task-agnostic at test time. However, class-incremental learning expands the output space (new classes), while domain-incremental keeps it fixed.
• vs. Task-Incremental: Task-incremental provides a task identifier at test time, simplifying the problem. Domain-incremental is harder as the model must implicitly infer the domain. This positioning makes it a critical testbed for developing robust, general-purpose continual learning systems.

Domain-incremental learning is a scenario in continual learning where a model must perform the same underlying task (e.g., classification) across a sequence of tasks, but the input data distribution (the domain) changes significantly. The core challenge is to maintain performance on all domains without forgetting, despite the distribution shift. For example, a digit classifier trained sequentially on MNIST (handwritten digits), SVHN (street-view house numbers), and USPS (scanned digits) must recognize digits from all three domains, even though the visual style, background, and resolution differ dramatically.

It is critical to distinguish domain-incremental learning from other continual learning settings:

• vs. Class-Incremental: The set of output classes remains fixed. The model does not need to expand its classification head.
• vs. Task-Incremental: The task (e.g., digit classification) is constant, so no explicit task identifier is typically required at inference time, unlike task-incremental learning where a task ID is provided.
• vs. General Domain Adaptation: The model learns domains sequentially over a long period, not as a one-time adaptation from a single source to a single target. The goal is lifelong accumulation of multi-domain robustness.

Techniques from general continual learning are adapted, with a focus on learning domain-invariant representations:

• Regularization Methods: Algorithms like Elastic Weight Consolidation (EWC) or Synaptic Intelligence (SI) penalize changes to parameters important for previous domains.
• Replay-Based Methods: Experience Replay (ER) stores exemplars from past domains in a buffer for interleaved rehearsal. Generative Replay uses a generative model to produce synthetic data from old domains.
• Architectural Methods: Parameter isolation strategies, such as learning domain-specific adapter modules or prompts, can compartmentalize knowledge.
• Representation Learning: Encouraging the model to learn a shared, domain-agnostic feature space through techniques like contrastive learning or domain-invariant regularization.

Performance is measured across all encountered domains after sequential training:

• Average Accuracy: The mean accuracy calculated over all domains after learning the final task. This is the primary metric.
• Forgetting Measure: Quantifies the drop in performance on a domain from its peak accuracy after it was first learned to its final accuracy. High forgetting indicates catastrophic interference.
• Forward Transfer: Measures how learning an earlier domain improves initial performance on a new, related domain.
• Backward Transfer: Can be positive (learning a new domain helps an old one) or negative (learning a new domain harms an old one, i.e., forgetting).

Researchers use standardized dataset splits to evaluate domain-incremental algorithms:

• Permuted MNIST: A classic benchmark where each task presents MNIST digits with a fixed, random pixel permutation applied, creating a new 'domain'.
• Rotated MNIST: Each task presents MNIST digits rotated by a fixed increment (e.g., 0, 15, 30, ... degrees).
• Split CIFAR-100-C: Uses the CIFAR-100-C corruption benchmark, where each task introduces a different type of image corruption (e.g., Gaussian noise, blur, fog) as a new domain.
• DomainNet: A large-scale dataset with six distinct visual domains (Clipart, Infograph, Painting, Quickdraw, Real, Sketch) of the same 345 object categories, often split into sequential tasks.

Domain-incremental learning is essential for systems that operate in non-stationary real-world environments:

• Autonomous Vehicles: A perception model must adapt to changing visual domains: sunny, rainy, snowy, night-time, and new city environments without forgetting how to drive in previous conditions.
• Medical Imaging: A diagnostic model deployed across different hospitals must adapt to variations in scanner manufacturers, imaging protocols, and patient populations while maintaining high accuracy on all.
• E-commerce Recommendation: A product recommendation system must adapt to shifting user behavior domains (e.g., seasonal trends, new product categories, economic changes) without losing relevance for long-term user preferences.
• Industrial IoT: Predictive maintenance models on factory equipment must adapt to domain shifts caused by machine wear, new production batches, or environmental changes in the facility.

The overarching machine learning paradigm where a model learns sequentially from a non-stationary stream of data or tasks. The core objective is to accumulate knowledge over time without suffering from catastrophic forgetting. It encompasses several specific scenarios:

• Task-Incremental Learning: Tasks change, and a task ID is provided at test time.
• Class-Incremental Learning: New classes are added over time, with no task ID at test.
• Domain-Incremental Learning: The input distribution shifts, but the output space remains constant.

The primary failure mode in continual learning, where a neural network abruptly loses performance on previously learned tasks after being trained on new data. This occurs due to unconstrained parameter updates that overwrite knowledge encoded in the model's weights. It is a direct manifestation of the stability-plasticity dilemma, where the model's plasticity (ability to learn new things) damages its stability (ability to remember old things).

The fundamental trade-off at the heart of all continual learning systems. Stability refers to a model's resistance to forgetting previously learned knowledge. Plasticity refers to its capacity to integrate new information and adapt. Algorithms must balance these competing demands:

• Too much stability leads to intransigence and an inability to learn new tasks.
• Too much plasticity leads to catastrophic forgetting of old tasks. Domain-incremental learning explicitly tests this balance under shifting input distributions.

A foundational technique where a subset of past training data is stored in a fixed-size replay buffer. During training on new tasks, the model interleaves learning from new data with rehearsal on samples from this buffer. This approach:

• Provides direct exposure to old data distributions.
• Helps mitigate representation drift in the model's hidden layers.
• Variants include Generative Replay (using a generative model to produce synthetic past data) and Dark Experience Replay (DER) (storing past model logits for stronger regularization).

A regularization-based algorithm that addresses catastrophic forgetting by adding a quadratic penalty to the loss function. This penalty slows down learning on network parameters deemed important for previous tasks. Importance is estimated using the diagonal of the Fisher information matrix. The core mechanics:

• Calculates a parameter importance score per weight after learning a task.
• During new task training, changes to important weights are heavily penalized.
• It is a prime example of an importance-weighting strategy for parameter protection.

The two other primary continual learning scenarios, differentiated by the task identifier at evaluation:

• Task-Incremental Learning (Task-IL): The easiest setting. The model is told which task a test sample belongs to (e.g., via a task ID), allowing it to use task-specific output heads. Forgetting is less severe.
• Class-Incremental Learning (Class-IL): A more challenging and realistic setting. New classes are introduced sequentially, and the model must classify a test sample among all classes seen so far without a task identifier. This directly tests the model's ability to maintain a unified, non-conflicting representation space. Domain-incremental learning sits between these in difficulty, as the output space is stable but the input distribution changes.