# Catastrophic Forgetting और Replay — Fine-tuning बनाम Prompting

Source: https://www.skillbyai.com/hi/fine-tuning/r-forget

> नए कार्य पर प्रशिक्षण पुराने को मिटा सकता है; पुराने उदाहरण वापस मिलाना मदद करता है।

## नया कौशल अंदर, पुराना बाहर

जब नेटवर्क सिर्फ़ नए डेटा पर प्रशिक्षित होता है, weights उसे फ़िट करने को खिसकते हैं और पहले के कौशलों को सहारा देने वाली चीज़ अधिलेखित कर सकते हैं: **catastrophic forgetting**। LLMs में यह संकरे tuning के बाद खोई सामान्य क्षमता, अन्यत्र बदतर formatting या भूली भाषाओं के रूप में दिखता है। उपाय: **कम learning rate** और कम epochs, **LoRA** (बेस जमा रहता है), **replay** (सामान्य या पहले के डेटा का नमूना प्रशिक्षण set में मिलाना), और ऐसा मूल्यांकन जिसमें पुराने कौशल भी हों, सिर्फ़ नया नहीं।

## Fine-tuning चुपचाप क्या तोड़ सकती है

मॉडल को विशेषीकृत करना पुराने कौशल मिटा सकता है, आत्मविश्वासी ग़लत तथ्य जोड़ सकता है और सुरक्षा व्यवहार कमज़ोर कर सकता है।

![तीन विचार: forgetting, तथ्य, सुरक्षा।](assets/figures/fine-tuning/section-5-map.svg) — चित्र 5.1 — Forgetting, तथ्य और सुरक्षा।

## छोटे नेटवर्क में forgetting और replay, चलाकर

मैंने यह Python, numpy 2.5.3 और scikit-learn 1.9.1 के साथ, निश्चित random seeds पर चलाया। यह छोटे क्लासिकल मॉडल प्रशिक्षित करता है, language model नहीं: तंत्र (gradient descent, learning rate, overfitting, forgetting, low-rank अद्यतन) वही विचार हैं जो LLM के fine-tuning पर लागू होते हैं, पर संख्याएँ LLM के परिणाम नहीं हैं। छोटा neural network कार्य A सीखता है (A पर सटीकता 0.965)। सिर्फ़ कार्य B पर fine-tune करने के बाद B पर 0.961 पर A पर 0.041, यानी A भुला दिया गया। B और 500 replay किए A उदाहरणों पर fine-tuning दोनों बचाती है (A 0.961, B 0.956)। यहाँ दोनों कार्य बनाए हुए regime-flag खिलौना हैं, LLM नहीं।

```python
import numpy as np
from sklearn.neural_network import MLPClassifier

rng = np.random.default_rng(3)
w = np.array([1.5, -1.0, 1.0, 0.5, -1.5, 0, 0, 0])
def task(flag, n=2000):                              # same inputs, but the flag feature says which rule applies
    X = rng.normal(size=(n, 8)); X[:, 7] = flag
    s = X @ w; y = ((s if flag == 0 else -s) + rng.normal(size=n) * 0.3 > 0).astype(int)
    return X, y
XA, yA = task(0); XB, yB = task(1); XAt, yAt = task(0); XBt, yBt = task(1)

def run(replay):
    m = MLPClassifier(hidden_layer_sizes=(32,), learning_rate_init=0.01, random_state=0)
    for _ in range(40): m.partial_fit(XA, yA, classes=[0, 1])
    before = (m.score(XAt, yAt), m.score(XBt, yBt))
    X, y = (np.vstack([XB, XA[:500]]), np.concatenate([yB, yA[:500]])) if replay else (XB, yB)
    for _ in range(80): m.partial_fit(X, y)
    return before, (m.score(XAt, yAt), m.score(XBt, yBt))

b, a = run(replay=False)
print(f"trained on task A      : accuracy on A {b[0]:.3f} | on B {b[1]:.3f}")
print(f"then fine-tuned on B   : accuracy on A {a[0]:.3f} | on B {a[1]:.3f}   <- A forgotten")
b, a = run(replay=True)
print(f"fine-tuned on B + 500 A: accuracy on A {a[0]:.3f} | on B {a[1]:.3f}   <- both kept")

```

Output:

```
trained on task A      : accuracy on A 0.965 | on B 0.045
then fine-tuned on B   : accuracy on A 0.041 | on B 0.961   <- A forgotten
fine-tuned on B + 500 A: accuracy on A 0.961 | on B 0.956   <- both kept
```

## Regression suite रखें

पुराने कौशल के prompts का छोटा set रखें और forgetting जल्दी पकड़ने को हर tuning run के बाद दोबारा चलाएँ।

**Quiz:** Catastrophic forgetting घटाने में कौन-सा मदद करता है?

- [ ] Validation set हटाना
- [ ] सिर्फ़ नए कार्य पर और देर तक प्रशिक्षण
- [x] पहले के डेटा का नमूना replay करना, कम learning rate या LoRA
- [ ] Learning rate बहुत बढ़ाना

*Answer:* पहले के डेटा का नमूना replay करना, कम learning rate या LoRA. पुराना व्यवहार प्रशिक्षण और मूल्यांकन दोनों में रखें।