Catastrophic Forgetting: The Core Challenge - Continual Learning: Learning Without Forgetting | OneNoughtOne

0/328

Machine LearningContinual Learning

Continual Learning: Learning Without Forgetting

LevelAdvanced

Duration90 mins

TopicContinual Learning

1 / 5

Catastrophic Forgetting: The Core Challenge

The Fundamental Conflict in Neural Learning

Imagine training a neural network to recognize cats with exceptional accuracy—99% precision across thousands of feline images. Now, you want the same network to also recognize dogs. You train it on a dog dataset, and afterward, test it on both species. The dog recognition is excellent, but something alarming has happened: the network has forgotten how to recognize cats. Not gradually degraded—catastrophically forgotten.

This phenomenon, known as catastrophic forgetting (also called catastrophic interference), represents one of the most fundamental challenges in machine learning. It exposes a critical gap between how artificial neural networks learn and how biological brains continuously acquire knowledge throughout a lifetime.

Understanding catastrophic forgetting is the essential first step toward building truly intelligent systems that can learn continuously—systems that don't require retraining from scratch every time new data arrives, systems that can accumulate knowledge over time like humans do.

What You Will Learn

By the end of this page, you will understand the neurobiological and computational roots of catastrophic forgetting, why standard neural network training inherently causes this problem, the mathematical formulation of the stability-plasticity dilemma, and how this challenge motivates the entire field of continual learning.

Historical Context and Discovery

Catastrophic forgetting was first formally identified in connectionist models during the 1980s, though its roots trace to earlier work in cognitive psychology and neuroscience. The phenomenon emerged as researchers attempted to build neural network models that could learn multiple tasks sequentially—a capability humans demonstrate effortlessly.

The McCloskey-Cohen Experiment (1989):

Michael McCloskey and Neal Cohen conducted one of the seminal studies demonstrating catastrophic forgetting. They trained a simple feedforward network to learn arithmetic facts (like counting from 1 to 10), then attempted to teach it additional facts. The network exhibited severe forgetting of the original learning—performance dropped from near-perfect to chance level on previously mastered content.

Their finding was stark: sequential learning in neural networks causes rapid, severe loss of previously acquired knowledge. This wasn't gradual decay or graceful degradation—it was wholesale destruction of learned representations.

The Contrast with Human Learning

A human who learns Spanish doesn't suddenly forget English. A chess grandmaster who takes up Go doesn't lose their chess ability. Yet standard neural networks exhibit precisely this pathological behavior—new learning actively destroys old knowledge. This fundamental mismatch between artificial and biological learning systems has profound implications for AI development.

French's Systematic Analysis (1999):

Robert French's influential review paper 'Catastrophic Forgetting in Connectionist Networks' provided a comprehensive theoretical framework. French identified that the problem stems from what he termed representational overlap—the fact that neural networks encode multiple memories using the same shared weights. When new information is learned, the weight updates necessarily disturb the precise configurations that encoded previous memories.

French proposed that catastrophic forgetting could be understood as a manifestation of the stability-plasticity dilemma—a fundamental tradeoff that any learning system must navigate:

Plasticity: The ability to acquire new knowledge and adapt to new inputs
Stability: The ability to retain previously learned knowledge against interference

Too much plasticity leads to catastrophic forgetting. Too much stability prevents new learning. The challenge is finding the right balance.

Key Milestones in Catastrophic Forgetting Research
Year	Researchers	Contribution	Impact
1989	McCloskey & Cohen	First systematic demonstration in neural networks	Established the phenomenon as a fundamental problem
1990	Ratcliff	Analysis of forgetting in backpropagation networks	Showed the problem is inherent to gradient-based learning
1995	French	Pseudo-rehearsal method proposed	First computational mitigation strategy
1999	French	Comprehensive review and theoretical framework	Unified the field and defined stability-plasticity dilemma
2017	Kirkpatrick et al.	Elastic Weight Consolidation (EWC)	Modern deep learning approach to regularization-based solutions

Mathematical Formulation of Catastrophic Forgetting

To deeply understand catastrophic forgetting, we must formalize it mathematically. Consider a neural network with parameters $\theta$ that we train sequentially on tasks $T_1, T_2, \ldots, T_n$.

Standard Training Dynamics:

For task $T_1$ with training data $D_1$, we optimize:

$$\theta_1^* = \arg\min_{\theta} \mathcal{L}_1(\theta; D_1)$$

where $\mathcal{L}_1$ is the loss function for task 1. After training, the network achieves parameters $\theta_1^*$ that perform well on $T_1$.

When task $T_2$ arrives with data $D_2$, standard training continues from $\theta_1^*$:

$$\theta_2^* = \arg\min_{\theta} \mathcal{L}_2(\theta; D_2)$$

The catastrophic forgetting problem manifests as:

$$\mathcal{L}_1(\theta_2^; D_1) \gg \mathcal{L}_1(\theta_1^; D_1)$$

The loss on task 1 increases dramatically after training on task 2, despite no explicit changes to the task 1 objective.

The Overwriting Problem

Gradient descent updates weights to minimize the current objective without regard for previous objectives. Since the same weights encode multiple task representations, optimizing for task 2 inevitably moves parameters away from the subspace that was optimal for task 1. This is not a bug in backpropagation—it is an intrinsic property of how shared parameterizations work.

Loss Landscape Perspective:

Visualizing the loss landscape provides geometric intuition. Imagine the parameter space as a high-dimensional terrain where valleys represent good solutions for different tasks.

For task $T_1$, optimization finds a minimum $\theta_1^$ in the loss landscape $\mathcal{L}_1$. This point sits in a valley of the $T_1$ landscape. However, when we switch to optimizing $\mathcal{L}_2$, the landscape changes entirely. The point $\theta_1^$ may be on a steep slope in the $T_2$ landscape, and gradient descent will push parameters far away to find a $T_2$ minimum.

The result: $\theta_2^*$ is in a completely different region of parameter space, one that is suboptimal (often catastrophically so) for task $T_1$.

Formal Definition of Forgetting:

We can quantify forgetting precisely. Let $A_{i,j}$ denote the accuracy on task $T_i$ after training on task $T_j$. The forgetting for task $i$ after learning task $j$ is:

$$F_{i,j} = \max_{k \in \{1,\ldots,j-1\}} A_{i,k} - A_{i,j}$$

This measures the maximum decrease in performance on task $i$ compared to any previous point in training. Average forgetting across all tasks provides a single metric:

$$\bar{F} = \frac{1}{n-1} \sum_{i=1}^{n-1} F_{i,n}$$

forgetting_metric.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import numpy as np
 
def compute_forgetting(accuracy_matrix):
    """
    Compute average forgetting from an accuracy matrix.
    
    Args:
        accuracy_matrix: np.ndarray of shape (n_tasks, n_tasks)
                        accuracy_matrix[i][j] = accuracy on task i 
                        after training on task j
    
    Returns:
        dict with per-task forgetting and average forgetting
    
    Mathematical formulation:
        F_i = max_{k < n} A_{i,k} - A_{i,n}  (for each task i < n)
        Average F = (1/(n-1)) * sum(F_i)
    """
    n_tasks = accuracy_matrix.shape[0]
    forgetting = []
    
    for i in range(n_tasks - 1):
        # Maximum accuracy achieved on task i before final task
        max_prev_accuracy = np.max(accuracy_matrix[i, i:n_tasks-1])
        # Final accuracy on task i after all training
        final_accuracy = accuracy_matrix[i, n_tasks - 1]
        # Forgetting is the drop from peak to final
        task_forgetting = max(0, max_prev_accuracy - final_accuracy)
        forgetting.append(task_forgetting)
    
    return {
        'per_task_forgetting': forgetting,
        'average_forgetting': np.mean(forgetting) if forgetting else 0.0,
        'max_forgetting': np.max(forgetting) if forgetting else 0.0
    }
 
# Example: Network trained on 5 sequential tasks
# Rows: task index, Columns: accuracy after training on task j
accuracy_matrix = np.array([
    [0.95, 0.72, 0.45, 0.28, 0.15],  # Task 1 performance over time
    [0.00, 0.93, 0.68, 0.42, 0.23],  # Task 2 performance
    [0.00, 0.00, 0.91, 0.55, 0.31],  # Task 3 performance
    [0.00, 0.00, 0.00, 0.94, 0.48],  # Task 4 performance
    [0.00, 0.00, 0.00, 0.00, 0.96],  # Task 5 (current)
])
 
results = compute_forgetting(accuracy_matrix)
print(f"Per-task forgetting: {results['per_task_forgetting']}")
print(f"Average forgetting: {results['average_forgetting']:.2%}")
print(f"Maximum forgetting: {results['max_forgetting']:.2%}")

Why Standard Training Causes Forgetting

To truly grasp catastrophic forgetting, we must understand the mechanics of how neural networks learn and why those mechanics are fundamentally incompatible with sequential learning.

The Distributed Representation Problem:

Neural networks encode information through distributed representations—each concept is represented by a pattern of activations across many neurons, and each neuron participates in representing many concepts. This is actually a strength for generalization: similar inputs produce similar representations.

However, this same property causes catastrophic forgetting. When we learn a new task:

Gradients flow through all weights: Backpropagation updates weights throughout the network, not just weights 'responsible' for new information
No memory of previous gradients: Each gradient update is computed solely based on current batch loss—there's no mechanism to preserve weight configurations important for old tasks
Overlapping representations get overwritten: Neurons that encoded old task features get repurposed for new task features

The Three Mechanisms of Forgetting

•Weight Magnitude Drift — Gradient updates accumulate over time, pushing weights far from their original values. Even if individual updates are small, thousands of updates on a new task can completely transform the weight matrix.
•Feature Interference — Hidden layers learn features useful for the current task. These features may be incompatible with features needed for previous tasks, leading to representation collapse.
•Output Layer Catastrophe — For classification, output layer weights for old classes receive no gradient signal when training on new classes. They don't just decay—they may be actively corrupted by interference from new class training.

An Illustrative Example:

Consider a simple binary classifier distinguishing between the digit '0' and '1'. The network learns weights that detect features like curves (for '0') and straight lines (for '1').

Now we train on '2' vs '3'. The optimal features for this task involve detecting loops, hooks, and specific curve patterns—quite different from the original features. The gradient updates:

Strengthen neurons for detecting new features
Do not reinforce neurons for old features (no training signal)
May actively reshape old feature detectors if those neurons are recruited for new features

After training, the network has excellent '2' vs '3' performance but has lost the capability to distinguish '0' from '1'—not because those weights were explicitly removed, but because they were implicitly overwritten.

The Gradient Is a Local Operator

The key insight is that gradient descent is a local optimization operator. It knows nothing about global solution quality or historical learning. Each update moves toward minimizing current loss, regardless of consequences for past learning. This myopia is the root cause of catastrophic forgetting.

The Stability-Plasticity Dilemma

The stability-plasticity dilemma (also called the stability-plasticity tradeoff) was first articulated by Stephen Grossberg in the context of biological neural systems. It poses a fundamental question: How can a learning system be simultaneously plastic enough to acquire new knowledge and stable enough to retain existing knowledge?

This dilemma isn't just a quirk of artificial neural networks—it's a necessary tradeoff that any learning system must confront.

Formal Statement of the Dilemma:

Consider a learning system with fixed capacity $C$ (e.g., number of parameters). For sequential tasks $T_1, T_2, \ldots, T_n$, we want to optimize:

$$\min_{\theta} \sum_{i=1}^{n} \mathcal{L}_i(\theta; D_i)$$

But we only have access to one task's data at a time. At any moment, we face a dilemma:

High Plasticity

•Rapidly adapts to new tasks
•Large learning rates and updates
•No constraints on weight changes
•Risk: Complete forgetting of old tasks
•Extreme case: Train from scratch each time

High Stability

•Perfectly retains old knowledge
•Minimal learning rates and updates
•Strict constraints on weight changes
•Risk: Unable to learn new tasks
•Extreme case: Frozen network, no learning

Neither Extreme Is Viable:

A system with only plasticity forgets everything except the current task—useless for building cumulative knowledge. A system with only stability cannot adapt—useless for learning anything new.

The challenge is finding a dynamic balance. This is where continual learning algorithms come in: they implement various strategies to manage this tradeoff, typically by:

Identifying important parameters and protecting them from change (regularization approaches)
Rehearsing old experiences alongside new ones (replay methods)
Dedicating separate capacity for different tasks (architectural approaches)
Learning to learn how to balance stability and plasticity (meta-learning approaches)

Biological Inspiration

The human brain solves the stability-plasticity dilemma through multiple mechanisms: hippocampal replay during sleep consolidates memories; separate brain regions specialize for different types of information; neuromodulatory signals control when learning occurs. Continual learning research often draws inspiration from these biological solutions.

Experimental Evidence of Catastrophic Forgetting

The severity of catastrophic forgetting has been demonstrated across various architectures, domains, and scales. Understanding these experimental results is crucial for appreciating why this problem demands specialized solutions.

Benchmark Studies:

Modern continual learning research uses standardized benchmarks to measure forgetting. One of the most common is Permuted MNIST: the same network learns to classify MNIST digits, but each task uses a different fixed permutation of pixels. Despite the underlying digit classes being the same, the network sees each permutation as a completely new visual pattern.

Catastrophic Forgetting in Standard Benchmarks
Benchmark	Network	Metric	Without Protection	Observations
Permuted MNIST (10 tasks)	MLP (2 hidden layers)	Final Task 1 Accuracy	~20%	From 98% initial → 20% after 10 tasks
Split CIFAR-100 (20 tasks)	ResNet-18	Average Accuracy	~25%	Severe forgetting, especially early tasks
Sequential ImageNet	VGG-16	Accuracy Drop	~80%	First task accuracy drops dramatically
Continual NLP (5 domains)	BERT-base	Average F1	~35%	Domain adaptation causes prior forgetting

The Permuted MNIST Demonstration:

Let's walk through a concrete experiment that vividly demonstrates catastrophic forgetting:

permuted_mnist_forgetting.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import numpy as np
import matplotlib.pyplot as plt
 
class SimpleMLP(nn.Module):
    """Two-layer MLP for MNIST classification"""
    def __init__(self, hidden_size=256):
        super().__init__()
        self.network = nn.Sequential(
            nn.Flatten(),
            nn.Linear(784, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, 10)
        )
    
    def forward(self, x):
        return self.network(x)
 
def create_permutation(seed):
    """Create a fixed permutation for a task"""
    rng = np.random.RandomState(seed)
    return torch.LongTensor(rng.permutation(784))
 
def apply_permutation(x, permutation):
    """Apply permutation to flatten images"""
    x = x.view(-1, 784)
    return x[:, permutation].view(-1, 1, 28, 28)
 
def evaluate(model, test_loader, permutation, device):
    """Evaluate model on a specific permuted task"""
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            images = apply_permutation(images, permutation).to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = outputs.max(1)
            correct += predicted.eq(labels).sum().item()
            total += labels.size(0)
    return 100. * correct / total
 
def train_sequentially(n_tasks=5, epochs_per_task=5):
    """
    Demonstrate catastrophic forgetting on Permuted MNIST.
    
    Returns:
        accuracy_matrix: Accuracy[task_i][after_task_j]
    """
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # Data loading
    transform = transforms.ToTensor()
    train_data = datasets.MNIST('./data', train=True, download=True, transform=transform)
    test_data = datasets.MNIST('./data', train=False, transform=transform)
    train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
    test_loader = DataLoader(test_data, batch_size=1000)
    
    # Create permutations for each task
    permutations = [create_permutation(seed=i) for i in range(n_tasks)]
    
    # Initialize model
    model = SimpleMLP(hidden_size=256).to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # Accuracy tracking matrix
    accuracy_matrix = np.zeros((n_tasks, n_tasks))
    
    # Sequential training
    for task_id in range(n_tasks):
        print(f"
--- Training on Task {task_id + 1} ---")
        permutation = permutations[task_id]
        
        # Train on current task
        model.train()
        for epoch in range(epochs_per_task):
            for images, labels in train_loader:
                images = apply_permutation(images, permutation).to(device)
                labels = labels.to(device)
                
                optimizer.zero_grad()
                outputs = model(images)
                loss = criterion(outputs, labels)
                loss.backward()
                optimizer.step()
        
        # Evaluate on all tasks seen so far
        for eval_task in range(task_id + 1):
            acc = evaluate(model, test_loader, permutations[eval_task], device)
            accuracy_matrix[eval_task][task_id] = acc
            print(f"  Task {eval_task + 1} accuracy: {acc:.2f}%")
    
    return accuracy_matrix
 
# Run demonstration
accuracy_matrix = train_sequentially(n_tasks=5, epochs_per_task=5)
 
# Print results
print("
=== CATASTROPHIC FORGETTING DEMONSTRATION ===")
print("
Accuracy Matrix (rows=tasks, cols=after training on task j):")
print(accuracy_matrix.round(1))
 
print("
Key Observations:")
print(f"- Task 1 initial accuracy: {accuracy_matrix[0][0]:.1f}%")
print(f"- Task 1 final accuracy: {accuracy_matrix[0][4]:.1f}%")
print(f"- Task 1 forgetting: {accuracy_matrix[0][0] - accuracy_matrix[0][4]:.1f}%")

The Stunning Results

Running this experiment typically shows Task 1 accuracy dropping from ~98% to ~20-30% after training on subsequent tasks. This is not gradual degradation—it's near-complete erasure. The network that once perfectly recognized original MNIST can barely do better than chance after learning just 4 more permutation tasks.

Factors Affecting Forgetting Severity

Catastrophic forgetting is not uniform—its severity depends on multiple factors. Understanding these factors helps predict when forgetting will be most problematic and guides the selection of appropriate mitigation strategies.

Task Similarity:

Counter-intuitively, very similar tasks and very dissimilar tasks can both cause forgetting, but through different mechanisms:

Similar tasks: Share features but have different optimal classifier boundaries. Feature representations may remain useful, but classifier layers get confused.
Dissimilar tasks: Require completely different features. Shared hidden layers get repurposed entirely, destroying old representations.

The 'sweet spot' of moderate similarity—where some features transfer but conflict is minimized—often produces the least forgetting.

Key Factors Influencing Forgetting

•Network Capacity — Larger networks with more parameters can encode more information and may show less forgetting due to spare capacity. However, this is not a complete solution—even very large networks exhibit forgetting.
•Learning Rate — Higher learning rates cause larger weight updates, leading to faster and more severe forgetting. Lower rates cause slower forgetting but also slower new learning.
•Number of Training Epochs — More training on new tasks causes more forgetting. There's a tradeoff between new task performance and old task retention.
•Task Order — Harder tasks early may create more robust representations, but this effect is complex and task-dependent. Some orderings cause more interference than others.
•Network Depth — Deeper networks may have more forgetting in later layers (task-specific) but better retention in early layers (generic features). Architecture significantly impacts forgetting patterns.
•Data Distribution — Class-imbalanced or noised data can exacerbate forgetting. Clean, balanced datasets typically show more consistent forgetting patterns.

Architectural Influence:

Different architectures exhibit different forgetting patterns:

Dense MLPs: Show severe forgetting because all weights participate in all tasks
CNNs: Often retain early convolutional features better than classifier features
Transformers: Can exhibit catastrophic forgetting at scale, especially in attention heads
Modular networks: Can be designed to isolate task-specific knowledge, reducing interference

Diagnosing Forgetting in Your System

When debugging continual learning, track accuracy on all previous tasks after each training phase. Plot the accuracy trajectory for each task over time. Sharp drops indicate catastrophic forgetting; gradual decline suggests more manageable interference. This diagnosis guides algorithm selection.

The Continual Learning Paradigm

Catastrophic forgetting motivates the entire field of continual learning (also called lifelong learning, incremental learning, or sequential learning). This paradigm fundamentally changes how we think about machine learning systems.

Standard ML Assumption:

$$\text{Static dataset } D \rightarrow \text{Train model } f_{\theta} \rightarrow \text{Deploy forever}$$

Continual Learning Reality:

$$\text{Stream of tasks } T_1, T_2, \ldots \rightarrow \text{Update model continuously } f_{\theta_t} \rightarrow \text{Perform well on all tasks}$$

Standard ML vs. Continual Learning
Aspect	Standard ML	Continual Learning
Data availability	All data available at once	Data arrives sequentially
Learning objective	Minimize loss on single distribution	Maintain performance across all distributions
Memory constraint	Store entire dataset	Limited or no storage of old data
Retraining	Full retraining for new data	Incremental updates only
Evaluation	Single held-out test set	Accuracy on all seen tasks
Failure mode	Poor generalization	Catastrophic forgetting

Continual Learning Scenarios:

The field defines several standard scenarios based on available information:

1. Task-Incremental Learning (Task-IL)

Task identity is provided at both train and test time
Easiest scenario—model knows which 'head' to use
Example: Multi-task network with task-specific classifiers

2. Domain-Incremental Learning (Domain-IL)

Task identity not required at test time, but output space is the same
Model must solve the same problem across different domains
Example: Sentiment analysis across different text sources

3. Class-Incremental Learning (Class-IL)

Task identity not provided at test time
Output space grows with new classes
Most challenging—must distinguish all classes ever seen
Example: Object recognition that learns new categories over time

Why This Matters for Real AI

Real-world AI systems must adapt to non-stationary environments: user preferences shift, language evolves, new categories appear, and distribution shifts occur. A system that requires retraining from scratch each time new data arrives is impractical at scale. Continual learning is about building systems that can grow and adapt—like biological intelligence does.

Preview: Approaches to Overcoming Forgetting

Having established the problem of catastrophic forgetting, let's preview the major solution families that the remainder of this module will explore in depth.

Three Major Paradigms:

Continual learning solutions fall into three broad categories, each attacking the stability-plasticity dilemma from a different angle:

Solution Paradigms

•Regularization Approaches — Add constraints to the loss function that penalize changes to important parameters. Methods like EWC, SI, and LwF protect critical weights from modification while allowing plasticity in unimportant parameters. Next page: Regularization Approaches
•Replay Methods — Store examples from previous tasks (true replay) or train a generative model to reproduce them (pseudo-replay). Mixing old and new data during training prevents forgetting. Various methods differ in what and how much to store. Page 2: Replay Methods
•Dynamic Architectures — Add new capacity for new tasks rather than forcing all tasks into fixed parameters. Methods include progressive networks, parameter isolation, and dynamic expansion. Eliminates interference by giving tasks their own resources. Page 3: Dynamic Architectures

Comparison of Solution Approaches
Approach	Memory Cost	Compute Cost	Forward Transfer	Backward Transfer	Limitations
Regularization	O(params)	Low (per update)	Preserved	Limited	May under-protect; hyperparameter sensitive
Replay	O(samples)	Moderate	Depends	Good	Memory for exemplars; privacy concerns
Dynamic Arch	O(tasks × params)	High	Excellent	Good (if shared base)	Model size grows; complex management

Looking Ahead

Each approach has trade-offs. State-of-the-art continual learning often combines multiple strategies—for example, regularization plus selective replay, or dynamic architecture with regularization. The following pages will give you deep mastery of each approach, enabling you to architect continual learning systems for real-world applications.

Summary: Catastrophic Forgetting

We have established the foundational understanding of catastrophic forgetting—the core challenge that defines and motivates the field of continual learning. Let's consolidate the key insights:

Key Takeaways

•Catastrophic forgetting is severe and rapid — Neural networks don't gradually decay on old tasks; they can lose nearly all previous knowledge after training on new tasks.
•Distributed representations cause the problem — Because the same weights encode multiple tasks, optimizing for new tasks inherently disturbs old task representations.
•The stability-plasticity dilemma is fundamental — Any learning system must balance retaining old knowledge (stability) with acquiring new knowledge (plasticity).
•Standard gradient descent provides no protection — Backpropagation updates weights myopically based on current loss, with no awareness of past objectives.
•Task similarity affects forgetting patterns — Both very similar and very dissimilar tasks can cause forgetting, through different mechanisms.
•Continual learning reframes the ML problem — Instead of training once on static data, we seek systems that learn incrementally while preserving accumulated knowledge.
•Three solution paradigms exist — Regularization (protect weights), replay (rehearse memories), and dynamic architectures (allocate new capacity) each address the challenge differently.

What's Next:

In the next page, we will dive deep into regularization approaches—methods that protect important parameters from modification by adding constraints to the learning objective. We'll explore Elastic Weight Consolidation (EWC), Synaptic Intelligence (SI), Learning without Forgetting (LwF), and their mathematical foundations.

Page Complete

You now understand why neural networks catastrophically forget, the mathematical formulation of the problem, and the landscape of solutions. This foundation is essential for mastering the specific continual learning algorithms covered in upcoming pages. The stability-plasticity dilemma is not just a technical hurdle—it's a window into what we need for truly intelligent, lifelong learning systems.