Catastrophic forgetting: Question bank — AI-ML deep dive

Reminder of the symbols you'll meet:

$θ$ = the one shared bag of weights that stores all skills.
$θ^{*}$ = the weights right after the old task finished — the "good spot" we want to stay near.
$L_{new}$ , $L_{old}$ = the loss (badness score) on the new and old tasks.
$F_{i}$ = Fisher importance of weight $i$ : how much moving that weight hurts the old task.
$λ$ = the dial for how hard the EWC spring pulls back to $θ^{*}$ .
$η$ = learning rate, the size of each gradient step.

The valleys, the drift, and the spring — one glance. In the left picture the old and new tasks are two different valleys over the same weights; naive fine-tuning slides $θ$ out of the old valley into the new one (that slide is forgetting). In the right picture the EWC spring pulls $θ$ back toward $θ^{*}$ , so it settles at a compromise that is decent on both.

True or false — justify

Forgetting is caused by the network literally deleting old weights

False — no weight is deleted; the same weights are overwritten to new values that happen to be good for the new task and bad for the old one. The information is displaced, not erased into a void.

A bigger model with more parameters cannot suffer catastrophic forgetting

False — more capacity helps but doesn't cure it; because knowledge is distributed and overlapping, new-task gradients still touch weights the old task depended on unless you actively protect them.

If two tasks share their loss minimum in weight space, fine-tuning the second causes no forgetting

True — if

θ^{*}

already sits in the new task's valley, gradient descent has no reason to leave the old good region; forgetting comes from the minima being in different places.

Catastrophic forgetting only happens in neural networks, not in classical models like linear regression

False in spirit — any model with shared parameters and a new-task-only objective drifts; it's called "catastrophic" in nets because the loss is non-convex and the drop is abrupt rather than gradual.

Elastic Weight Consolidation (EWC) lets the new task learn freely in directions the old task didn't care about

True — where

F_{i} \approx 0

the penalty

\frac{λ}{2} F_{i} (θ_{i} - θ_{i}^{*})^{2}

vanishes, so those weights move without resistance and the new skill uses that "spare capacity."

Rehearsal with a small buffer is mathematically identical to joint multi-task training

False — a buffer only approximates the full old loss; with fewer old samples the gradient estimate of

L_{old}

is noisier and biased toward whatever the buffer happens to contain.

Freezing the base weights (LoRA/adapters) makes forgetting impossible for the frozen skills

True for the base — if the base weights literally cannot change, the knowledge stored purely in them cannot be overwritten; skills that route through the new adapter can still shift behavior though.

Training the new task for more epochs is a safe way to boost new-task accuracy

False — extra epochs push

θ

further from

θ^{*}

, so new accuracy climbs while old accuracy keeps falling; in sequential learning, learning is not monotone across tasks.

The diagonal Fisher used in EWC captures every way the old task depends on the weights

False — it keeps only one number per weight and drops all cross-weight (off-diagonal) correlations; when two weights are important jointly, independent springs mis-protect that tilted direction.

Spot the error

"To measure forgetting, just check that new-task accuracy went up."

The error: forgetting is about the old task. You must re-evaluate the old task after training the new one; the gap between old-task-before and old-task-after is the forgetting.

"EWC uses

F_{i}

, so we must keep the entire old dataset to recompute the loss each step."

Wrong — the whole Bayesian trick is that the old data's influence is compressed into

θ^{*}

and

F_{i}

(computed once). You store two vectors, not the dataset.

"Set

λ

as large as possible so we never forget anything."

Too-large

λ

freezes

θ

near

θ^{*}

and blocks the new task from learning;

λ

trades old-retention against new-learning and must be tuned, not maximized.

"Fisher information

F_{i}

is the first derivative of the loss, so it's zero at the minimum."

Confusion of order — at

θ^{*}

the gradient (first derivative) is ~zero, but

F_{i}

captures curvature (second-derivative-like), which is large exactly for weights that matter. Large

F_{i}

, not zero.

"The Fisher matrix is diagonal, so weight

i

's importance never depends on weight

j

That's an approximation we chose, not a fact — the true Fisher has off-diagonal terms; EWC drops them for cheapness, so this statement confuses the convenient assumption with reality.

"Rehearsal fixes forgetting, so lowering the learning rate is unnecessary."

They attack different levers and stack: rehearsal puts

L_{old}

back in the gradient; a lower

η

shrinks each drift step. Using both is common, not redundant.

"LoRA adds parameters, so the model gets bigger and slower forever and that's the cost."

The real trade-off isn't size — LoRA modules are tiny; the point is that base weights are frozen, so old knowledge is untouchable. The cost is expressiveness limits of the low-rank update, not bloat.

"Because EWC penalizes weight movement, it must reduce the model's final new-task accuracy versus naive fine-tuning."

Not necessarily — it constrains only high-

F_{i}

directions; the new task usually has enough free directions to still fit, and it keeps the old skill that naive tuning throws away.

Why questions

Why does the naive fine-tuning loss

L_{new}

cause forgetting even though it's a perfectly good loss?

Because it contains no term mentioning the old task, so gradient descent has zero incentive to stay near

θ^{*}

— moving out of the old valley is "free" as long as new loss drops.

Why do we approximate the old posterior as a Gaussian instead of using it exactly?

The exact posterior over millions of weights is intractable; near a minimum any smooth loss is locally quadratic, so a Gaussian (Laplace approximation) is a cheap, accurate-enough summary that gives us the

F_{i} (θ_{i} - θ_{i}^{*})^{2}

penalty.

Why does the EWC penalty use a squared distance

(θ_{i} - θ_{i}^{*})^{2}

rather than absolute distance?

The squared form comes directly from the Gaussian log-density (a quadratic), which is the Laplace approximation of the old posterior — it behaves like a physical spring whose restoring force grows with displacement.

Why does EWC keep only the diagonal of the Fisher matrix instead of the full matrix?

A full Fisher over millions of weights is a giant dense matrix — impossible to store or invert; the diagonal is one number per weight, cheap and enough for a rough per-weight importance, at the cost of ignoring correlations.

Why is a lower learning rate a partial fix rather than a real solution?

It slows drift out of the old valley but never adds an old-task term to the objective; given enough steps

θ

still leaves

θ^{*}

. It buys time, not protection.

Why does knowledge being "distributed" make forgetting worse than if each task had its own weights?

With per-task slots, updating task B can't touch task A. Because real nets share and overlap weights, a B-update lands on weights A also relies on, so B's improvement bleeds into A's collapse.

Why is

F_{i}

interpreted as "importance" of weight

i

A large

F_{i}

means the old-task loss is steeply curved along weight

i

— a small move there sharply increases old-task loss — so that weight was pinning down old knowledge and must be held near

θ^{*}

Edge cases

If a weight has

F_{i} = 0

, what does EWC do to it, and is that safe?

The penalty term is zero, so the weight moves completely freely — safe precisely because

F_{i} = 0

means the old task didn't depend on it, so moving it costs no old knowledge.

What happens under EWC if the new and old tasks want the same value for a high-

F_{i}

weight?

No conflict — the spring is already satisfied, the penalty is zero at that point, and both objectives agree; EWC only bites when they disagree on important weights.

What is the limiting behavior of EWC as

λ \to \infty

The penalty dominates and pins

θ = θ^{*}

exactly; the model perfectly remembers the old task but learns nothing new — the extreme "freeze everything" corner.

What is the limiting behavior as

λ \to 0

The penalty vanishes and

L_{EWC} \to L_{new}

— you recover plain naive fine-tuning, so you get full new-task learning and full catastrophic forgetting.

When can the diagonal-Fisher assumption fail even with a well-tuned

λ

When important weights are correlated so the old task's "good direction" is tilted across several weights; independent per-weight springs can't hold a tilted valley, so EWC under-protects that direction.

With three sequential tasks A→B→C, does one EWC penalty from A suffice?

No — after B you have a new good spot and new importances; you generally accumulate penalties (anchor + Fisher) for each prior task, or fold them into a running quadratic, else C-training can still forget B.

What if the new task's data is empty (zero new samples)?

Then

L_{new}

contributes no gradient and only the EWC spring acts, pulling

θ

toward

θ^{*}

— nothing new is learned and nothing old is lost, the degenerate no-op case.

If the old and new tasks are actually the same task, is there still a forgetting risk?

No real risk — the minima coincide, so fine-tuning moves

θ

within the same valley; any "drop" would just be normal optimization noise, not forgetting.

Connections

Fisher Information — the $F_{i}$ importance weights probed by these traps.
Laplace Approximation — why the penalty is quadratic.
LoRA and Adapters — the "freeze the base" edge cases.
Continual Learning — the 3-task accumulation case above.
Multi-task Learning — the joint-training ideal rehearsal approximates.
Learning Rate & Optimization — why low $η$ is only a partial fix.
Fine-Tuning LLMs — where these traps show up in practice.