सबसे सरल नियम एक सीधी रेखा है: "हर एक डिग्री ज़्यादा यानी कुछ स्कूप ज़्यादा"। इस note के उदाहरण में वह नोटबुक में दर्ज दिनों पर आम तौर पर 27.5 स्कूप से चूकता है, क्योंकि उसे यह नहीं दिखता कि सबसे तेज़ गर्मी में बिक्री गिर जाती है। तो नियम को ज़्यादा छूट दी जा सकती है और curve को मुड़ने दिया जा सकता है। आज़माए गए curves में सबसे लचीला curve ठीक सभी 10 बिंदुओं से होकर गुज़रता है। नोटबुक के दिनों पर उसकी error 0 है।

यह एकदम सही नियम जैसा दिखता है। बस इतना है कि नोटबुक के दिन बीत चुके हैं, और नियम को कल काम करना है। उसी स्टॉल के 400 नए दिनों पर यह "एकदम सही" curve आम तौर पर 236.5 स्कूप से चूकता है। मध्यम लचीलेपन वाला curve, जो नोटबुक पर ख़राब दिख रहा था (10.9), नए दिनों पर 16.8 से चूकता है।

Overfitting वह स्थिति है जिसमें model की error सीखने में इस्तेमाल हुए data पर छोटी होती है, और उसी तरह के नए data पर उसके मुकाबले बहुत बड़ी (Goodfellow, Bengio और Courville, Deep Learning, §5.2)। Model अपने data set की उन ख़ासियतों पर fit हो गया जो उसके बाहर दोहराई नहीं जातीं। उलटी मुश्किल को underfitting कहते हैं: नियम इतना सरल है कि उस data को भी ठीक से नहीं बता पाता जो उसने देखा है। हमारे उदाहरण की सीधी रेखा ऐसा ही बर्ताव करती है।

यह अंतर कहाँ से आता है

नोटबुक की हर entry दो चीज़ों से बनी है: नियमितता (गर्मी ज़्यादा, तो आइसक्रीम ज़्यादा) और संयोग (उस दिन संयोग से सैलानियों का एक दल आ गया)। नियम को पहली चीज़ पकड़नी है और दूसरी छोड़ देनी है। लेकिन model को नहीं पता कि क्या क्या है। उसे सिर्फ़ बिंदु दिखते हैं।

Model कितना संयोग सोख लेगा, यह उसके लचीलेपन से तय होता है, जिसे साहित्य में capacity कहते हैं: कई अलग-अलग शक्लों पर fit हो सकने की क्षमता। उदाहरण के curve को 2 से 10 संख्याएँ बताती हैं, जिन्हें data के हिसाब से चुना जाता है; उनकी गिनती curve की degree से एक ज़्यादा है। Degree 9 वाले curve के पास 10 दिनों के लिए ऐसी 10 संख्याएँ हैं, इसलिए वह हर बिंदु पर जा बैठ सकता है, सारे संयोग समेत। पाठ्यपुस्तक के लेखक इसे यूँ बताते हैं: बहुत लचीला model सही संबंध को तो दिखा सकता है, लेकिन ढेरों दूसरे संबंधों को भी, जो training data पर उतने ही अच्छे बैठते हैं, और इसकी संभावना कम है कि वह ठीक वही चुने जो आगे भी काम आए (§5.2)।

आम तौर पर सिलसिला ऐसा रहता है: लचीलापन बढ़ने पर training data पर error घटती है, जबकि नए data पर error पहले घटती है, फिर बढ़ने लगती है (§5.2, चित्र 5.3)। इससे एक व्यावहारिक नियम निकलता है। Model को उस data पर नहीं परखा जाता जिस पर उसने सीखा, और लचीलापन उस data की error देखकर नहीं चुना जाता, क्योंकि वह हमेशा सबसे ज़्यादा लचीलेपन की ओर इशारा करेगी। Data का एक हिस्सा अलग रख दिया जाता है: validation set [Polski] settings चुनने के काम आता है, और अलग test set अंतिम मूल्यांकन के (§5.3)।

ख़ुद जाँचिए

नीचे वही स्टॉल है। इस note की सारी संख्याएँ दोबारा निकाली जा सकती हैं: "शुरू से" पर click करने पर 10 दिन दिखते हैं, और प्रयोग 1–5 बताए गए मामलों को set कर देते हैं।

दो चीज़ें करके देखने लायक़ हैं, जो स्थिर chart नहीं दिखाता। पहली, "24 और नोटबुक" चालू कीजिए और degree बदलिए: कम degree पर धूसर रेखाएँ एक-दूसरे के पास रहती हैं, ऊँची degree पर हर तरफ़ बिखर जाती हैं, जबकि हर एक उसी स्टॉल से आई है। दूसरी, किसी एक बिंदु को खींचकर बहुत ऊपर ले जाइए। Degree 2 वाला curve बस थोड़ा-सा खिसकेगा, जबकि degree 9 वाला curve उस बिंदु पर पहुँचने के लिए अपनी पूरी लंबाई में बदल जाएगा।

क्या मदद करता है

• ज़्यादा data। 80 दिनों पर वही degree 9 वाला curve नोटबुक पर आम तौर पर 14.8 स्कूप से और नए दिनों पर 15.9 से चूकता है। अंतर लगभग मिट जाता है, क्योंकि curve अब हर बिंदु पर नहीं बैठ सकता (§5.2)।
• कम लचीलापन। 10 दिनों पर degree 3 वाला curve: नोटबुक पर 10.9, नए दिनों पर 16.8।
• Regularization, यानी training के तरीके में ऐसा बदलाव जिसका मक़सद नए data पर error घटाना है, training data पर नहीं (§5.2.2)। इसका एक उदाहरण बड़े coefficients पर penalty है, जो Weight decay [Polski] से जुड़ी हुई है: penalty λ = 0.01 के साथ degree 9 वाला curve नोटबुक पर 5.8 से और नए दिनों पर 21.2 से चूकता है, 236.5 की जगह।

इनमें से कोई भी setting सिर्फ़ training data की error देखकर नहीं चुनी जा सकती।

सीमाएँ

• यह मेरा अपना उदाहरण है, जिसमें एक ही input मात्रा और simulated data है। यहाँ सिर्फ़ संयोग ही आम तौर पर 15 स्कूप की error देता है, और नए दिनों पर कोई नियम इससे नीचे नहीं जाएगा।
• "पहले बेहतर, फिर बदतर" वाली शक्ल आम है, गारंटी नहीं। लेखक बताते हैं कि deep networks में model का असल लचीलापन तय करना भी मुश्किल है, क्योंकि वह training algorithm पर भी निर्भर करता है (§5.2)। इसलिए LLM के parameters की संख्या अकेले यह नहीं बताती कि model overfit है या नहीं।
• नए data पर छोटी error उसी स्रोत के data के बारे में है। अगर स्टॉल समुद्र किनारे चला जाए, तो शहर वाली नोटबुक किसी बात का वादा नहीं करती।

संबंधित विषय

• Weight decay [Polski] weights के आकार को सीमित करता है और training data तथा नए data की error के बीच का अंतर घटाने के तरीकों में से एक है।
• Grokking [Polski] उन मामलों को बताता है जिनमें overfit दिखने वाला model लंबी अतिरिक्त training के बाद नए data पर अच्छा काम करने लगता है।
• छोटे data set पर Fine-tuning [Polski] के लिए भी यही जाँच चाहिए: अलग data, जिसे model ने training के दौरान नहीं देखा।
• Catastrophic Forgetting [Polski] एक अलग समस्या है: वहाँ model नई training के बाद पुरानी क्षमता खो देता है, जबकि यहाँ वह शुरू से ही अपने training data के बाहर कमज़ोर चलता है।

50% वाले रूप के लिए हम अलग-अलग मानवीय समय वाले tasks पर agent की सफल और असफल कोशिशें जमा करते हैं। फिर सफलता की संभावना का curve fit करते हैं और वह समय पढ़ते हैं जहाँ यह curve 50% को काटता है। यह किसी तय समय वाले tasks के distribution के लिए एक अनुमान है; इसका मतलब यह नहीं कि उनमें से हर task के पूरे होने की संभावना एक जैसी है। METR: परिभाषा और methodology।

समझाने के लिए एक उदाहरण: अगर fit किया गया curve दो घंटे पर 50% तक पहुँचता है, तो horizon दो घंटे है। सफल task को agent इससे कहीं जल्दी पूरा कर सकता है। यह नतीजा अपने आप यह भी नहीं बताता कि किसी दूसरे क्षेत्र का task वह कितनी सफलता से करेगा।

इस reading के लिए ज़रूरी है कि इंसान के समय और AI के लिए कठिनाई के बीच कोई सार्थक संबंध हो। जब curve सपाट होता है, तो संभावना में छोटा-सा बदलाव भी threshold के साथ उसके कटान बिंदु को बहुत दूर खिसका सकता है। METR horizon के रूपांतरण पर लेख इस समस्या को एक ऐसे उदाहरण पर दिखाता है जिसे गिनकर देखा जा सकता है, और METR के data पर की गई नई fit की चर्चा करता है। Nguyen और Fithian, §2–3।

Horizons की तुलना करते समय tasks के set, agent के environment, कोशिशों के budget और सफलता के चुने गए threshold की जानकारी साथ रखनी चाहिए।

मान लीजिए कि दो agents वही तीन tasks हल करते हैं। पहला आम तौर पर A और B कर लेता है, दूसरा C भी। सफलताओं का प्रतिशत अकेले एक ranking दे देता है। IRT इसके अलावा यह अनुमान लगाने की कोशिश करता है कि बाकी tasks के मुकाबले C कितना कठिन है और क्षमता का कितना अंतर जवाबों के इस pattern को समझाता है। यह समझाने के लिए एक उदाहरण है; इतनी छोटी तालिका भरोसेमंद fit के लिए काफ़ी नहीं है।

सरल Rasch model में सफलता की संभावना तब बढ़ती है जब task की कठिनाई के मुकाबले agent की क्षमता ज़्यादा हो। दोनों मात्राएँ छिपी हुई हैं: हम उनका अनुमान नतीजों से लगाते हैं, बजाय इसके कि कठिनाई को सीधे निर्देश की लंबाई या इंसान के समय के बराबर मान लें। IRT के अलग-अलग रूप और parameters तथा मान्यताएँ जोड़ते हैं।

METR horizons के विश्लेषण में लेखक छिपी हुई कठिनाई को, data से सीखे गए एक curve के ज़रिए, इंसान के काम के समय से जोड़ते हैं। वे tasks के परिवारों के effects और दोहराई गई कोशिशों के नतीजों का बिखराव भी जोड़ते हैं। इससे यह जाँचा जा सकता है कि किस दायरे में समय सचमुच AI के लिए कठिन और आसान tasks में फ़र्क़ करता है। Nguyen और Fithian, §2.3 और §3.1।

जवाबों का अच्छा अनुमान यह साबित नहीं करता कि सीखा गया parameter agent की हर तरह की क्षमता को समेट लेता है। व्याख्या करते समय model की मान्यताओं को और उन tasks पर नतीजों को जाँचना ज़रूरी है जो fit में इस्तेमाल नहीं हुए।

Model को शिकायतें बिना किसी रोक-टोक के सिखाई जा सकती हैं। तब weights उधर खिसकते हैं जिधर नए task को फ़ायदा हो, वे weights भी जिन पर डिलीवरी और वापसी की पहचान टिकी थी। हर बदलाव पर एक जैसी penalty भी लगाई जा सकती है, लेकिन तब model पुरानी settings से इतना चिपका रहता है कि नई चीज़ ठीक से सीख नहीं पाता। ज़रूरत इस सवाल के जवाब की है: किन weights को छेड़ा जा सकता है, और किन्हें न छेड़ना बेहतर है?

Elastic Weight Consolidation (EWC) नए task की training में इस बात की penalty जोड़ता है कि weights पुराने task के बाद वाले मानों से कितनी दूर जाते हैं, और कोई weight पुराने task के लिए जितना अहम था, penalty उतनी ही बड़ी होती है। लेखक इसकी तुलना हर weight से बँधी spring से करते हैं: अहम weights पर सख़्त, बाकी पर ढीली (Kirkpatrick et al., Overcoming catastrophic forgetting in neural networks, §2)।

दो weights, एक नया task

सिर्फ़ दो weights लेते हैं। डिलीवरी और वापसी सीखने के बाद दोनों का मान 1 है। पहला पुराने विभागों के लिए बहुत अहम है (महत्व 10), दूसरा लगभग बेअसर (महत्व 0.1)। नया task बस इतना चाहता है कि दोनों weights का जोड़ 4 हो। यह कई settings से पूरा होता है: (2, 2), लेकिन (1, 3) भी।

• बिना सुरक्षा training दोनों weights को बराबर खिसकाती है, (2, 2) तक। नया task सीख लिया गया है, लेकिन अहम weight 1 से हट गया और पुराने task पर loss 0 से बढ़कर 5.05 हो जाता है।
• दोनों weights पर एक जैसी penalty उन्हें आधे रास्ते में, (1.67, 1.67) पर रोक देती है। पुराने task को कम नुक़सान होता है, लेकिन जोड़ 4 की जगह 3.33 है।
• EWC लगभग सारी हरकत कम अहम weight पर डाल देता है: (1.02, 2.80)। जोड़ 3.82 है, और पुराने task पर loss सिर्फ़ 0.16।

Loss वह संख्या है जो बताती है कि model कितना ग़लत है; यह जितनी छोटी हो, उतना अच्छा। नीचे के प्रयोग में आप penalty की ताक़त λ और सुरक्षा का तरीका बदल सकते हैं। नतीजा ठीक इसी दो weights वाले उदाहरण के लिए निकाला जाता है; यह किसी असली network का simulation नहीं है।

कैसे पता चलता है कि कौन-सा weight अहम है

असली network में महत्व कोई पहले से नहीं बताता। उसका अनुमान पुराना task ख़त्म होने के बाद लगाया जाता है, जब तक उसका data उपलब्ध है: यह देखा जाता है कि किसी weight में छोटा-सा बदलाव पुराने उदाहरणों पर model के जवाबों को कितना बदल देता है। पेपर इसके लिए Fisher information matrix के diagonal का इस्तेमाल करता है, यानी हर weight के लिए महत्व की एक संख्या। इसके बाद data हटाया जा सकता है; weights के पुराने मान और उनके महत्व बचे रहते हैं।

नई training के दौरान दो हिस्सों का जोड़ minimize किया जाता है (पेपर में समीकरण 3):

$L_B$ नए task पर loss है, $\theta_i$ weight संख्या $i$ का मौजूदा मान है, $\theta^*_{A,i}$ पुराने task के बाद उसका मान, $F_i$ उसका महत्व, और $\lambda$ बताता है कि नए task के मुकाबले पुराना task कितना मायने रखता है। हमारे उदाहरण में $F = (10,\ 0.1)$ और $\lambda = 1$ है।

इस तरीके की सीमाएँ

महत्व एक अनुमान है, जो एक ही बिंदु पर और हर weight के लिए अलग से निकाला जाता है। लेखक ख़ुद दिखाते हैं कि उनका अनुमान कभी-कभी इस बारे में ज़रूरत से ज़्यादा आश्वस्त होता है कि कौन-से weights ग़ैर-ज़रूरी हैं, और इसे इस तरीके की मुख्य कमज़ोरी बताते हैं (§2.2 और §3)। Atari games पर उनके प्रयोगों में EWC वाला agent एक के बाद एक कई games सीखता गया, लेकिन हर game के लिए अलग से train किए गए networks की बराबरी नहीं कर पाया। नतीजे अंकों की पहचान और games के बारे में हैं, बड़े language models के बारे में नहीं। हमारे दो weights और ग्राहकों के संदेश हमारा अपना सरलीकरण हैं।

• Catastrophic Forgetting [Polski] नई training के बाद पुरानी क्षमताओं में भारी गिरावट है; EWC पुराने data तक पहुँच के बिना इसे कम करने की कोशिश करता है।
• Experience Replay इसी समस्या को दूसरे ढंग से हल करता है: वह weights के महत्व की जगह कुछ पुराने उदाहरण सँभालकर रखता है।
• Continual Learning लक्ष्य बताता है, यानी पहले के tasks को बचाए रखते हुए नए tasks सीखना; EWC उसके तरीकों में से एक है।
• Fine-tuning [Polski] तैयार model की आगे की training है; EWC अहम weights को छेड़ने पर penalty जोड़कर उसका लक्ष्य बदल देता है।

पाठ और चित्र AI की मदद से तैयार किए गए हैं। दो weights, उनके महत्व और demonstration सिखाने के लिए बनाया गया मेरा अपना सरल उदाहरण हैं; चित्र एक रूपक है, model की बनावट का आरेख नहीं।

पहले चार रख लें? तब memory सिर्फ़ शुरुआत को जानती है। हमेशा आख़िरी चार रखें? तब वह सिर्फ़ अंत को जानती है। "पूरे में से चार" का निष्पक्ष यादृच्छिक चुनाव करने के लिए या तो सब कुछ सँभालकर रखना पड़ता, या संदेशों की संख्या पहले से मालूम होनी चाहिए। सवाल यह है: जगहों की संख्या तय हो और stream की लंबाई मालूम न हो, तो हर संदेश को बराबर मौक़ा कैसे दिया जाए?

Reservoir Sampling ऐसे data पर, जिसकी संख्या हमें पहले से मालूम नहीं, एक ही बार गुज़रते हुए तय आकार का यादृच्छिक नमूना बनाए रखने का तरीका है। हर नए संदेश के बाद memory में, जिसे यहाँ reservoir कहा जाता है, अब तक आई हर चीज़ का एक निष्पक्ष यादृच्छिक नमूना होता है। सबसे सरल रूप, Algorithm R, का वर्णन Vitter, Random Sampling with a Reservoir, §2 में है, जो इसका श्रेय Alan Waterman को देते हैं।

दो क़दमों का नुस्ख़ा

1. पहले चार संदेश बिना किसी यादृच्छिक चुनाव के memory में जाते हैं।
2. संदेश संख्या $t$ (पाँचवाँ, छठा और उसके बाद का हर संदेश) $4/t$ की संभावना से memory में जाता है। अगर वह गया, तो बचाए गए चार में से यादृच्छिक रूप से चुने गए किसी एक की जगह लेता है।

यानी पाँचवाँ संदेश 4/5 की संभावना से अंदर जाता है, सौवाँ 4/100 की संभावना से। नए संदेशों के अंदर जाने की संभावना घटती जाती है, लेकिन पुराने संदेश पहले ही कई बार निकाले जाने के ख़तरे से गुज़र चुके होते हैं, और ये दोनों असर एक-दूसरे को ठीक-ठीक बराबर कर देते हैं। पाँचवें संदेश के बाद इसे जाँच लेते हैं। वह 4/5 की संभावना से अंदर जाता है। पहला संदेश तभी बाहर होता है जब पाँचवाँ अंदर गया (4/5) और ठीक उसी की जगह पर पड़ा (1/4), यानी 1/5 की संभावना से। वह 4/5 की संभावना से बना रहता है: ठीक उतनी, जितनी पाँचवें की है। $t$ संदेशों के बाद उनमें से हर एक $4/t$ की संभावना से memory में होता है।

बराबर मौक़ा गारंटी नहीं है

प्रयोग में stream में 20 संदेश हैं। अठारह डिलीवरी के बारे में हैं, और दो, नौवाँ और पंद्रहवाँ, वापसी के बारे में। हर बार चलाने पर ऐसी stream 2000 बार गुज़ारी जाती है और गिना जाता है कि कोई स्थान आख़िर में कितनी बार memory में बचा। यादृच्छिक चुनाव असली हैं, इसलिए नतीजे हर बार प्रतिशत के एक अंश जितने अलग होते हैं।

Reservoir Sampling में हर bar करीब 20% का होता है, यानी 4/20। साथ ही ज़्यादातर runs में वापसी वाले दोनों संदेशों में से कोई भी memory में नहीं बचता। सटीक मान 3060/4845 है, यानी करीब 63%: 20 संदेशों में से चुने गए सभी चौकों में से इतने सिर्फ़ डिलीवरी वाले अठारह संदेशों से बने होते हैं। यह तरीका अलग-अलग संदेशों के साथ निष्पक्ष है, लेकिन इस बात का ध्यान नहीं रखता कि हर श्रेणी का कोई प्रतिनिधि मौजूद रहे।

यह कहाँ मायने रखता है

दोहराव वाली training में Reservoir Sampling कभी-कभी buffer में लिखने का तरीका होता है: न stream की लंबाई मालूम होनी चाहिए, न tasks के बीच की सीमाएँ। Chaudhry et al., Continual Learning with Tiny Episodic Memories, §2, algorithm 2 इसे ठीक इसी तरह इस्तेमाल करते हैं। Image tasks पर उनके प्रयोगों में यह अच्छा चला, सिवाय बहुत छोटी memories के, जहाँ buffer से पहले की classes ग़ायब हो जाती थीं; तब वे रणनीतियाँ बेहतर रहीं जो classes के बराबर प्रतिनिधित्व का ध्यान रखती हैं (§4.4)। यह image classification का नतीजा है, LLM का नहीं।

Algorithm अपने आप में machine learning के बारे में नहीं है। Vitter का 1985 का पेपर अनजानी लंबाई वाले magnetic tape से records के यादृच्छिक चुनाव का वर्णन करता है और तेज़ रूप सुझाता है, जो हर record पर यादृच्छिक चुनाव करने की जगह यह निकालते हैं कि कितने records छोड़ने हैं। ग्राहकों के संदेश और 20 स्थानों वाली stream हमारा अपना उदाहरण हैं।

• Experience Replay को पुराने उदाहरणों वाला buffer चाहिए; Reservoir Sampling यह तय करने के तरीकों में से एक है कि उसमें क्या जाए।
• Continual Learning सीमित memory के साथ data की stream से सीखना मानकर चलता है, यानी ऐसी स्थिति जिसमें सब कुछ बचाकर नहीं रखा जा सकता।
• Catastrophic Forgetting [Polski] तब और बढ़ सकता है जब छोटी memory से किसी पुरानी श्रेणी के सारे उदाहरण निकल जाएँ।

पाठ और चित्र AI की मदद से तैयार किए गए हैं। संदेशों की stream और demonstration सिखाने के लिए बनाया गया मेरा अपना सरल उदाहरण हैं; चित्र एक रूपक है, algorithm का आरेख नहीं।

Experience Replay (ER) का मतलब है पहले के कुछ उदाहरणों को सँभालकर रखना और उन्हें training में दोबारा इस्तेमाल करना। सरल रूप में हम नए data के batch में memory से लिए गए उदाहरण मिला देते हैं; इस memory को replay buffer कहते हैं। यह दोहराव के लिए रखे गए data का डिब्बा है, model के पूरे ज्ञान का record नहीं। ऐसी साझा training का वर्णन Chaudhry et al., Continual Learning with Tiny Episodic Memories, §2, algorithm 1 में है।

अगले अभ्यास में क्या जाता है

Archive खोने से पहले हमने चार संदेश उनके सही विभागों के साथ बचा लिए थे। अब हमारे पास चार नई शिकायतें हैं। दोहराव के बिना model चार नए संदेशों पर सीखता है। दोहराव के साथ वह चार पुराने संदेशों पर भी अभ्यास करता है: उसे फिर से संकेत मिलता है कि "पार्सल कहाँ है?" डिलीवरी का मामला है। इस छोटे उदाहरण में हम पूरा buffer इस्तेमाल करते हैं; बड़े buffers से आम तौर पर एक यादृच्छिक हिस्सा लिया जाता है।

लेकिन memory की जगहें गिन लेना काफ़ी नहीं है। डिलीवरी के बारे में बचाए गए चार सवालों में वापसी का एक भी उदाहरण नहीं है। उनमें से दो की जगह "ख़रीदा हुआ सामान कैसे लौटाऊँ?" और "मुझे कमीज़ लौटानी है" रख देने पर दोहरावों की संख्या वही रहती है, लेकिन अब उनमें पहले के दोनों विभाग शामिल हैं। नीचे का प्रयोग data के batch में उदाहरण गिनता है; वह model की accuracy का अनुमान नहीं लगाता।

दोहराव सिर्फ़ उपलब्ध data पर मदद करता है

Model को पहले के जवाबों का अभ्यास करने का मौक़ा मिलता है, सारी क्षमताएँ बची रहने की गारंटी नहीं। यादृच्छिक छोटा नमूना किसी दुर्लभ श्रेणी को पूरी तरह छोड़ सकता है; शोधकर्ताओं ने यह समस्या बहुत छोटे buffers के साथ देखी (उसी पेपर का §4.4)। हमारे संदेश हमारा अपना उदाहरण हैं, उन प्रयोगों का नतीजा नहीं। Training का असर अलग रखे गए पुराने और नए संदेशों पर जाँचना पड़ता है, जो training में इस्तेमाल न हुए हों। Buffer memory भी घेरता है और उसके लिए चुने हुए data को सँभालकर रखना पड़ता है।

यह भी देखें: Reservoir Sampling — यह तय करने का तरीका कि stream के कौन-से उदाहरण तय आकार वाले buffer में जाएँ, जिसमें हर उदाहरण को बराबर मौक़ा मिलता है।

Games में, Reinforcement Learning [Polski] में — यानी rewards के आधार पर actions सीखने में — स्थिति, action, reward और अगली स्थिति सँभालकर रखी जाती है। ऐसे records को यादृच्छिक ढंग से चुनने से ठीक एक के बाद एक आने वाली घटनाओं पर निर्भरता घटती है (Mnih et al., Human-level control through deep reinforcement learning, Methods, "Training algorithm for deep Q-networks")। यह सही विभाग वाले संदेश से अलग क़िस्म का data है; Atari के नतीजों को सीधे LLM पर लागू नहीं करना चाहिए।

• Continual Learning पहले की क्षमताओं को बचाए रखते हुए आगे सीखने का लक्ष्य बताता है; ER उसे हासिल करने के तरीकों में से एक है।
• Catastrophic Forgetting [Polski] पुरानी क्षमताओं में भारी गिरावट को बताता है, जिसे दोहराव कम कर सकता है।
• Fine-tuning [Polski] model की आगे की training है; replay उसके data का चुनाव बदल देता है। पुराने संदेशों को बातचीत में बस चिपका देना model का ऐसा update नहीं है।

पाठ और चित्र AI की मदद से तैयार किए गए हैं। संदेश और demonstration सिखाने के लिए बनाया गया मेरा अपना सरल उदाहरण हैं; चित्र एक रूपक है, model की बनावट का आरेख नहीं।

आपको ज़रूरत है कि model को नई चीज़ें सिखाई जाएँ और पहले की क्षमताएँ बनी रहें। यही Continual Learning का लक्ष्य है: एक के बाद एक आते data या tasks पर सीखना, यह ध्यान में रखते हुए कि model पहले क्या सीख चुका है। यह नाम एक समस्या और तरीकों के एक परिवार को बताता है; यह इस बात की गारंटी नहीं है कि model कुछ नहीं भूलेगा। इस ज़रूरत का वर्णन Kirkpatrick et al., Overcoming catastrophic forgetting in neural networks, §1 में मिलता है।

सिखाने और जाँचने में हम क्या बदलते हैं

मान लीजिए कि पहले की training में इस्तेमाल हुए उदाहरणों का पूरा archive अब उपलब्ध नहीं है। उसे हटाने से पहले हमने एक छोटा नमूना बचा लिया था: 20 संदेश, जिनके सही विभाग हमें मालूम हैं। एक संभव तरीका यह है कि इस नमूने को शिकायतों के नए उदाहरणों में मिला दिया जाए। इससे आगे की training को यह संकेत भी मिलता रहता है कि "मेरा पार्सल कहाँ है?" को अब भी सही ढंग से सँभालना है। पुराने उदाहरणों को दोबारा इस्तेमाल करना उन रणनीतियों में से एक है जिनका वर्णन van de Ven और Tolias, Three scenarios for continual learning, §3.3 में है।

यह भी देखें: Experience Replay — पुराने उदाहरणों का एक छोटा नमूना सँभालकर रखना और उसे नई training में मिलाना।

मूल्यांकन करने वाली टीम पुराने संदेशों का एक अलग test रखती है, जिसे हम training में इस्तेमाल नहीं करते। हर update के बाद हम पुरानी और नई, दोनों श्रेणियों की जाँच करते हैं। नीचे दिए गए आँकड़े एक गढ़ा हुआ उदाहरण हैं, किसी शोध का नतीजा नहीं; हर test में 100 संदेश हैं।

आख़िरी रूप पहले की क्षमता को बेहतर बचाए रखता है, हालाँकि शिकायतों को वह दूसरे रूप से कुछ कमज़ोर पहचानता है। तालिका यह दिखाती है कि किन चीज़ों की तुलना करनी है; वह यह वादा नहीं करती कि 20 उदाहरण जोड़ने पर ऐसा ही नतीजा मिलेगा।

शर्तें कठिनाई को बदल देती हैं

हमारे उदाहरण में model अब तक सीखे गए सभी विभागों में से ख़ुद चुनता है। "यह संदेश नई श्रेणी का है" जैसा इशारा test को आसान बना देता। तरीकों की तुलना करते समय यह अहम है कि ऐसे इशारे और tasks के बीच की सीमाएँ उपलब्ध हैं या नहीं (van de Ven और Tolias, §2–2.3)। छोटा नमूना दुर्लभ सवालों को छोड़ सकता है; अच्छा औसत यह साबित नहीं करता कि हर क्षमता बची हुई है।

• Catastrophic Forgetting [Polski] पुरानी क्षमताओं में भारी गिरावट को बताता है; उसका demonstration दिखाता है कि नई training साझा settings को कैसे बदल देती है।
• Fine-tuning [Polski] चुने हुए उदाहरणों पर model की आगे की training है। हर नई training के बाद हम पहले की क्षमताओं को भी जाँचते हैं।
• Knowledge Distillation [Polski] पुराने model से update किए जा रहे model तक संकेत पहुँचा सकता है; यह मूल संदेशों को सँभालकर रखने से अलग रणनीति है (van de Ven और Tolias के पेपर का §3.3)।

पाठ और चित्र AI की मदद से तैयार किए गए हैं; संदेश, नमूने का आकार और तालिका के नतीजे सिखाने के लिए बनाया गया मेरा अपना उदाहरण हैं। चित्र पहले की क्षमताओं को बचाए रखने का लक्ष्य दिखाता है, model की बनावट नहीं।