Continual Learning and Catastrophic Forgetting
1. Overview
Continual Learning (also Lifelong Learning) is a machine learning paradigm in which a single model learns from the data of multiple tasks and distributions that arrive sequentially over time, while preserving previously acquired knowledge so that performance across all tasks is maintained and accumulated. The phenomenon in which existing knowledge is abruptly lost while learning new knowledge is called Catastrophic Forgetting.
Traditional supervised learning assumes that the entire dataset is given at once as independently and identically distributed (i.i.d.) samples, and minimizes loss over repeated epochs. In reality, however, AI services do not receive data all at once. New product categories are added, new malware variants emerge, and user preferences and market trends keep changing. In such a non-stationary data stream environment, retraining the model on the full dataset every time increases storage and compute costs more than linearly, and in many cases past raw data cannot even be retained due to privacy regulations (such as the GDPR right to erasure). Continual learning confronts this problem head-on with the goal of "updating the model using only new data while not forgetting the past."
The root cause of catastrophic forgetting is that a neural network's knowledge is held as a distributed representation across all weights. When the gradient descent of task B moves weights that had converged for task A without any regard for task A's loss landscape, the parameters that were important to A get overwritten. Ever since McCloskey and Cohen first reported this phenomenon in 1989, continual learning has remained a core challenge for AI that grows by accumulating experience like a human (lifelong learning), and it has recently drawn renewed attention in connection with the demand to continually update large language models (LLMs) without discarding and retraining them — so-called Continual Pre-training.
The key characteristics that continual learning aims for can be summarized as follows.
- Incremental knowledge accumulation: the ideal is to monotonically increase performance across all tasks as new tasks are learned.
- Limited access to the past: knowledge is preserved with few resources, without storing and reusing all past data.
- Exploiting knowledge transfer: it pursues a virtuous cycle of learning new tasks faster with past knowledge (forward transfer) and reinforcing the past with new tasks (positive backward transfer).
- Adaptation during operation: it aims for online adaptability to distribution shifts in the operating environment without redeployment.
Continual learning is also biologically inspired. According to the brain's Complementary Learning Systems theory, the hippocampus rapidly stores recent experiences and slowly replays them to the neocortex during sleep to integrate them with existing knowledge. The idea behind rehearsal-based methods — preventing forgetting via buffer replay — corresponds directly to this "consolidation through memory replay" mechanism. The reason a human does not forget their mother tongue upon learning a new language lies in such selective preservation and replay, and continual learning can be seen as an attempt to reproduce this in artificial neural networks.
In terms of learning resources, continual learning differs decisively from traditional batch learning in two assumptions. First, data arrives as a non-stationary stream whose distribution changes over time, so the i.i.d. assumption breaks. Second, access to past data is restricted, so data that has gone by cannot be freely revisited. Strictly honoring both constraints — seeing data only once — yields Online CL, whereas allowing multiple epochs per task yields offline (batch) continual learning. Furthermore, task-free continual learning, in which even task boundaries are not specified and the distribution shifts gradually, is the most realistic yet most difficult setting, corresponding to situations such as autonomous driving and streaming recommendation where the model itself must detect "when the task has changed."
2. Basic Structure of Continual Learning and the Stability-Plasticity Dilemma
flowchart LR
subgraph STREAM["Non-stationary data stream (in time order)"]
T1["Task 1 data"] --> T2["Task 2 data"] --> T3["Task 3 data"]
end
T1 --> M["Single model (parameters theta)"]
T2 --> M
T3 --> M
M --> EVAL["Cumulative evaluation (all tasks 1~N)"]
EVAL --> P["Plasticity: ability to learn new tasks"]
EVAL --> S["Stability: ability to preserve prior knowledge"]
P -. if excessive .-> F["Catastrophic forgetting"]
S -. if excessive .-> R["Rigidity (fails to learn new tasks)"]
The performance of continual learning is determined by the balance of two conflicting abilities. One is Plasticity, the ability to learn a newly arriving task well enough. The other is Stability, the ability to maintain performance on already-learned tasks. If weights are updated freely to maximize plasticity, past knowledge is overwritten and forgetting occurs; conversely, if weights are excessively fixed for the sake of stability, the model cannot learn new tasks and becomes rigid. This is called the Stability-Plasticity Dilemma, and every continual learning method is ultimately a different strategy about which point on this scale to choose.
The learning setup is divided into three scenarios depending on whether a task identifier (task-id) is provided at evaluation time. The table below organizes these in order of difficulty; in particular, Class-IL (class-incremental) is the hardest and closest to practice, because at inference time one cannot know which task it is and must distinguish all classes with a single classifier.
| Scenario | Task boundary | task-id at inference | Example | Difficulty |
|---|---|---|---|---|
| Task-IL (task-incremental) | Clear | Provided | Separate output head per task | Low |
| Domain-IL (domain-incremental) | Clear | Not needed (same classes) | Autonomous-driving perception under changed lighting/weather | Medium |
| Class-IL (class-incremental) | Clear | Not provided | A classifier to which new classes keep being added | High |
For instance, a situation where an autonomous-driving perception model is trained only on daytime footage and then sequentially learns nighttime and rainy footage corresponds to Domain-IL, while a visual-inspection model to which new defect types are added monthly on a manufacturing line corresponds to Class-IL. Since even the same algorithm shows large performance gaps depending on the scenario, the scenario must always be stated when comparing benchmarks.
The properties an ideal continual learning algorithm should possess are also clear. First is bounded memory: storage must not grow without limit even as the number of tasks increases. Second is task-boundary independence: it must work even without being told when a task changes. Third is constant time/compute per step: the update cost must not explode in proportion to the cumulative number of tasks. Real-world methods strike a balance by sacrificing some of these three properties — PNN gives up memory, rehearsal gives up task-boundary independence, and full retraining gives up constant time. Thus there is no "perfect" continual learning yet, and an engineering judgment is required to decide what to concede given the operating constraints.
3. Classification of Continual Learning Methods
flowchart TB
CL["Continual learning methods"] --> REG["Regularization-based"]
CL --> REP["Rehearsal/Replay-based"]
CL --> ARC["Architecture-based"]
REG --> EWC["EWC: suppress change of important weights"]
REG --> LWF["LwF: preserve outputs via knowledge distillation"]
REP --> ER["Experience replay: buffer of past samples"]
REP --> GEN["Generative replay: reconstruct the past with GAN/VAE"]
ARC --> PNN["Progressive Net: add a column per task"]
ARC --> PET["Prompt/adapter: add only a few parameters"]
Continual learning methods are broadly divided into three families according to how they suppress forgetting. Each family takes a different view of solving the stability-plasticity dilemma, and in practice hybrids combining two or three families are common. Regularization secures stability by "moving important weights less," rehearsal secures it by "repeatedly reviewing the past," and architecture-based methods remove interference itself by "isolating parameters per task." No approach is free: each pays a cost in loss design, storage space, or model capacity, respectively.
A. Regularization-based
Regularization-based methods add a loss term that suppresses change more strongly for parameters that were more important to past tasks. Because they do not store past data, they are memory-efficient and safe from a privacy standpoint. The representative method EWC (Elastic Weight Consolidation, Kirkpatrick 2017) estimates parameter importance via the Fisher Information Matrix and imposes a quadratic penalty when an important weight drifts away from its previous optimum. Intuitively, it attaches a "spring (elasticity)" to each weight, holding the more important ones more firmly in place.
Another axis is LwF (Learning without Forgetting), which leverages knowledge distillation: it uses the output (soft target) obtained by passing new data through the past model as a teacher, constraining the new model to maintain the past input-output relationship. There are many variants in how parameter importance is estimated — whereas EWC measures importance via Fisher information, SI (Synaptic Intelligence) tracks online the cumulative contribution of each weight to the loss over the entire learning trajectory, and MAS (Memory Aware Synapses) estimates importance in an unsupervised manner from the sensitivity (gradient magnitude) of the output function. Thus the very definition of "what counts as important" distinguishes the methods.
Regularization methods are simple to implement and impose no storage burden, but as the number of tasks grows, the penalties demanded by different tasks collide and performance gradually degrades, and if importance estimation is inaccurate, both preservation and learning can fail. Recent studies even report that when a pre-trained model is used, plain L2 regularization outperforms the more complex EWC, so method choice depends heavily on whether pre-training is used and on the data characteristics. Hence regularization is often operated complementarily by combining it with small-scale rehearsal rather than being used alone.
B. Rehearsal/Replay-based
Rehearsal-based methods store a portion of past data in a small memory buffer and, when learning a new task, interleave it with the new data for retraining. The idea is similar to how a human maintains memory through review, and it is known to deliver the most stable performance on average among the three families. When the buffer is small, which samples to keep becomes the key, so techniques such as the herding of iCaRL, which picks representative samples close to the class mean, and Reservoir Sampling, which guarantees uniform random replacement, are used.
Beyond simply mixing in and retraining on past samples, there is also a family that suppresses forgetting at the gradient level. GEM/A-GEM (Gradient Episodic Memory) performs constrained optimization that guarantees past performance by projecting the new task's gradient only onto directions that do not increase the loss on buffer samples. DER (Dark Experience Replay) stores not only the labels of past samples but also the logits at the time and uses them as a distillation loss, raising stability even with a small buffer.
In environments where the originals cannot be stored, Generative Replay is used. This is a scheme in which generative models such as GANs and VAEs produce pseudo-samples resembling the past distribution to serve as review data. Rehearsal delivers a clear effect, but because it retains past originals, it comes with a trade-off of privacy and copyright violation risk and buffer memory and retraining compute cost. For example, storing just 20 samples per class means that with 1,000 classes one must permanently retain 20,000 images, so in regulated industries this retention itself becomes a constraint. Moreover, generative replay carries the risk that if the generative model reconstructs the distribution inaccurately, one ends up "learning distorted memories rather than reviving the past through review," so the generation quality determines the upper bound of overall performance.
C. Architecture-based (Parameter Isolation)
Architecture-based methods isolate and allocate dedicated parameters per task to physically block interference. PNN (Progressive Neural Networks) appends a new neural-network column each time a task is added and freezes the past columns, fundamentally blocking forgetting but with the drawback that the model grows in proportion to the number of tasks. PackNet suppresses capacity growth by repurposing leftover neurons via pruning for new tasks.
As a compromise that aims at both curbing capacity growth and suppressing forgetting, there are HAT (Hard Attention to the Task), which controls which neurons to activate per task via learned masks, and DEN (Dynamically Expandable Network), which dynamically expands and prunes the network only when needed. Instead of unconditionally adding columns like PNN, these expand only selectively, judging whether the existing capacity is sufficient for the new task.
In the recent era of large models, the approach of freezing the body and adding only a few parameters per task, such as prompts, adapters, or LoRA, is in the spotlight. Because the full weights are not touched, forgetting is inherently mitigated, and the added cost per task is as small as a few MB. Techniques like L2P (Learning to Prompt), which automatically select the prompt suited to a task, are representative, and this fits well with the practical need to continually extend a pre-trained large model without discarding it, spreading rapidly. However, as tasks multiply, how to select and route the per-task prompts/adapters becomes a new problem, and a wrong selection re-invokes interference, so routing accuracy becomes the key.
4. Evaluation Metrics and Comparison of Methods
Continual learning cannot be evaluated by a single accuracy figure; after all learning is finished, one looks together at the average accuracy including past tasks (ACC) and at Backward Transfer (BWT, degree of forgetting), which measures how much past performance has dropped. A large negative BWT means severe forgetting, while if a new task actually raises past performance it becomes positive. The degree to which learning a new task speeds up thanks to prior knowledge is measured by Forward Transfer (FWT).
In other words, a good continual learning model aims for a state with high ACC, a small negative BWT magnitude (little forgetting), and positive FWT. Since the three metrics often conflict, agreeing first on which metric to weight according to the service goal should precede method selection. For example, a regulation-facing model must strictly limit drops in past-task performance, so it takes BWT as the top-priority constraint.
| Family | Forgetting suppression | Memory/compute | Privacy | Scalability |
|---|---|---|---|---|
| Regularization (EWC·LwF) | Medium | Very low | Safe (no originals retained) | Degrades with many tasks |
| Rehearsal (ER·iCaRL) | High | Buffer/retraining cost | Risky (originals retained) | Good |
| Architecture (PNN·adapter) | Very high | Parameter growth | Safe | Burden as tasks increase |
As a concrete numeric example, on Split-CIFAR-100 (100 classes split into 10 tasks), sequential learning with no countermeasure (naive fine-tuning) fits only the last task well and collapses to an average accuracy in the 20% range, whereas adding a small rehearsal buffer (a few dozen images per class) is generally reported to recover average accuracy into the 50-60% range and to greatly reduce the negative magnitude of BWT (degree of forgetting). Representative benchmarks include Split-MNIST, Split-CIFAR-10/100, CORe50 for sequential object recognition, and ImageNet-family settings at large scale, and a fair comparison controlling for the scenario (Task/Domain/Class-IL) and buffer size is essential.
The difference among the three families ultimately comes down to "what to use as a resource." Regularization is the lightest because it uses only a loss term with no extra storage, but its preservation power is weak; rehearsal is powerful because it uses past data as a resource but carries a heavy storage/regulatory burden; and architecture-based methods block interference by using extra parameters as a resource but bloat the model. Therefore it is reasonable to prioritize regularization/generative replay for strictly regulated finance and healthcare, rehearsal for internal services where data retention is unrestricted, and adapter/prompt approaches for large-model operating environments.
Continual learning is easily confused with several similar learning paradigms, so the boundaries need to be made clear. The table below distinguishes them by the manner of data arrival and the objective. The key is that only continual learning simultaneously requires the three conditions that "data arrives sequentially, access to the past is restricted, and the past must not be forgotten."
| Paradigm | Data arrival | Past data | Main objective |
|---|---|---|---|
| Multi-task | Simultaneous | All accessible | Jointly optimize multiple tasks |
| Transfer | Sequential (once) | Accessible | Improve source→target performance |
| Online | Sequential (stream) | Not retained | Immediate adaptation (forgetting not a focus) |
| Continual | Sequential (non-stationary) | Limited | Adaptation + preservation of the past |
Whereas transfer learning only needs to do well on the new task by "using the past as a stepping stone," continual learning is stricter in that it must also maintain the performance of the past task that served as the stepping stone. Also, online learning focuses on adapting quickly to the latest distribution and does not actively prevent forgetting, whereas continual learning requires adaptation and preservation at the same time. Confusing this distinction makes it easy to fail by choosing a method that does not fit the problem.
5. Deep Dive: Practical Use Cases and Trends in LLM Continual Learning
Continual learning no longer remains an academic concept; it is being concretized as a model-update strategy in MLOps at industrial sites where data constantly changes. In recommendation systems, since user preferences and product catalogs change daily, incremental learning is applied instead of full retraining to cut update costs, and in financial fraud detection, novel fraud patterns are reviewed via a rehearsal buffer to maintain the ability to detect past types. Manufacturing visual inspection is a typical Class-IL problem in which new defect classes are continually added, so retaining representative samples in the iCaRL style is widely used.
Pitfalls in the evaluation itself are also important in practice. Because a stability gap is observed, in which past-task performance temporarily plunges right after learning and then gradually recovers, judging model quality from a single measurement right after an update can underestimate performance. Also, looking only at the final average accuracy (ACC) cannot distinguish a model that "does the new task well but has forgotten all of the past" from one that "maintained everything evenly," so BWT (degree of forgetting), FWT (forward transfer), and per-task performance curves must be monitored together.
Natural language understanding (NLU) for voice assistants and chatbots is also a field where continual learning is valuable. New intents and commands are continually added, and one must learn only the new intents incrementally without full retraining while preserving recognition rates for existing intents. Medical imaging diagnosis models, too, must be updated under regulations that forbid taking past data off-site when new lesion types or images captured on new equipment are added, so generative-replay and regularization families of continual learning are actively being examined. In this way, the practical demand for continual learning exists commonly across almost all operational AI where "data does not stop and the past cannot all be gathered."
The most active area recently is the continual updating of large language models (LLMs). Retraining a model of hundreds of billions of parameters from scratch every time new knowledge arises is unrealistic, costing on the order of millions of dollars. Accordingly, (1) parameter-efficient continual learning that freezes the body and updates only LoRA/adapters per domain, (2) a mix of Continual Pre-training and replay that continues learning on the latest corpus while preventing degradation of past abilities, and (3) combination with RAG ([[retrieval-augmented-generation]]), which avoids forgetting itself by injecting external knowledge via retrieval rather than into the parameters, are used complementarily. In particular, RAG "updates only the knowledge without retraining the model," so it is regarded as a practical alternative that structurally lightens the burden of continual learning. Surveys around 2024 commonly report that simple methods are surprisingly strong when starting from a pre-trained model, and that the rehearsal family still holds an edge in difficult scenarios.
In sum, in practical LLM operation it is desirable to design "what to put where" in a layered manner. That is, the approach of separating frequently changing factual knowledge into RAG's external store, style such as domain tone and format into adapters/LoRA, and fundamental capability improvement into careful continual pre-training — managing each layer's update cadence, cost, and risk independently — is spreading.
6. Considerations and Implications
Introducing continual learning is not a mere algorithm choice but a matter of designing data governance, infrastructure, and operating policy together, and from a professional-engineer perspective the following must be considered comprehensively.
- Scenario alignment: One must first clearly define whether the problem to solve is Task-IL or Class-IL. Approaching a Class-IL problem that lacks a task identifier at inference with a method that assumes Task-IL causes performance to plunge in real services. Benchmark figures must always be compared within the same scenario.
- Privacy/regulatory trade-off: Rehearsal performs excellently, but retaining past originals can conflict with the retention-period and erasure rights of the GDPR and personal-information protection laws. In regulated industries, prioritize families that leave no originals, such as generative replay, regularization, and adapters, and if retention is unavoidable, establish pseudonymization and retention-period policies together.
- Cost-performance balance and retraining strategy: One must compute the break-even point between forgetting prevention and full retraining. A hybrid that detects performance degradation via data-drift monitoring ([[model-drift-monitoring]]) and runs incremental updates → periodic full retraining in parallel is realistic, and the storage cost of buffers/extra parameters should be reflected in the TCO.
- Operation/validation framework (MLOps): Include cumulative evaluation (ACC·BWT) in CI to check that past-task performance does not fall below a threshold even after learning a new task, and block regressions on updated models via shadow/canary deployment. Track version and data lineage with a model registry ([[ml-model-registry]]) to secure the possibility of rollback.
- Evaluation automation and reproducibility: Because the stability gap distorts quality in a single measurement right after an update, one must automatically aggregate ACC·BWT trends over an interval and fix experimental conditions such as scenario and buffer size as metadata to secure reproducibility. Otherwise the very comparison between methods loses credibility.
- Outlook and related technologies: Continual learning is expanding into personalized learning for on-device AI ([[on-device-ai]]), continual extension of foundation models, and multimodal continual learning. In the long run, the direction of combining with external memory such as RAG and knowledge graphs — reducing the burden of parameter updates while continually accumulating knowledge — is promising. Moreover, hybrids combining several families (e.g., small-scale rehearsal + adapters) are trending toward becoming the de facto practical standard, so a combination design tailored to the constraints is preferable to fixating on a single method.
References
- A Comprehensive Survey of Continual Learning: Theory, Method and Application (arXiv 2302.00487): https://arxiv.org/pdf/2302.00487
- A Closer Look at Rehearsal-Free Continual Learning (Smith et al., 2022): https://par.nsf.gov/servlets/purl/10489407
- Incremental Learning Methodologies for Addressing Catastrophic Forgetting (JAIR, 2025): https://mlanthology.org/jair/2025/serraperello2025jair-incremental
In one line: Continual learning is a paradigm that prevents catastrophic forgetting while sequentially learning a non-stationary data stream, reconciling the stability-plasticity dilemma through regularization, rehearsal, and architecture-based strategies, and in the LLM era it is a core technology that continually extends models without discarding them by combining adapters, continual pre-training, and RAG.