मशीन लर्निंग के बुनियादी सिद्धांतमध्यमपाठ 1135 मिनट का पाठ

Overfitting और इसे कैसे पहचानें

एक मॉडल जो अपने ट्रेनिंग उदाहरणों को रट लेता है, वह अभ्यास में बिल्कुल सही दिखता है लेकिन नए डेटा पर फेल हो जाता है। इस अंतर (gap) को देखना और इसे नियंत्रित करना सीखें।

पाठ वीडियो में

60 सेकंड में

Overfitting और इसे कैसे पहचानें

एक मॉडल जो अपने ट्रेनिंग उदाहरणों को रट लेता है, वह अभ्यास में बिल्कुल सही दिखता है लेकिन नए डेटा पर फेल हो जाता है। इस अंतर (gap) को देखना और इसे नियंत्रित करना सीखें।

1/3
आसान शब्दों में
दो छात्र गणित की परीक्षा की तैयारी करते हैं। एक पिछले साल के पेपर के उत्तर शब्द-दर-शब्द रट लेता है। दूसरा यह सीखता है कि समस्याओं को हल कैसे किया जाए। पिछले साल के पेपर पर दोनों को पूरे अंक मिलते हैं। इस साल के नए पेपर पर, केवल दूसरा छात्र अच्छा प्रदर्शन करता है। पहला छात्र पिछले साल के पेपर पर "overfit" हो गया था।
Overfitting का मतलब है कि मॉडल ने ट्रेनिंग उदाहरणों को बहुत बारीकी से सीख लिया है, जिसमें उनका रैंडम शोर (noise) भी शामिल है, इसलिए यह नए डेटा पर खराब प्रदर्शन करता है। Underfitting इसका उल्टा है: मॉडल असली पैटर्न को पकड़ने के लिए बहुत सरल है, इसलिए यह हर जगह खराब प्रदर्शन करता है।

कर्व (curves) के साथ इसे देखना

यहाँ हम एक सीधे-सादे कर्व से 12 शोर-युक्त (noisy) बनाए गए पॉइंट्स लेते हैं और तीन polynomials फिट करते हैं: एक सीधी रेखा (straight line), डिग्री 3 वाला कर्व, और डिग्री 9 वाला बहुत अधिक घुमावदार (wiggly) कर्व। फिर हम उसी स्रोत से 100 नए पॉइंट्स पर प्रत्येक की जांच करते हैं।
Python: simple, right, and too flexiblepython
import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(3)
def truth(x):
    return np.sin(x)                         # the hidden pattern

x_train = np.sort(rng.uniform(0, 6, 12))
y_train = truth(x_train) + rng.normal(0, 0.25, 12)
x_new = rng.uniform(x_train.min(), x_train.max(), 100)   # new points inside the same range
y_new = truth(x_new) + rng.normal(0, 0.25, 100)

grid = np.linspace(0, 6, 200)
plt.scatter(x_train, y_train, color="black", label="training points")
for degree in [1, 3, 9]:
    coefs = np.polyfit(x_train, y_train, degree)
    train_err = np.mean(np.abs(np.polyval(coefs, x_train) - y_train))
    new_err = np.mean(np.abs(np.polyval(coefs, x_new) - y_new))
    print("degree", degree, " training error", round(train_err, 3), " new-data error", round(new_err, 3))
    plt.plot(grid, np.polyval(coefs, grid), label="degree " + str(degree))
plt.ylim(-2, 2); plt.legend()
इसे रन करें। डिग्री-9 वाले कर्व में ट्रेनिंग एरर सबसे कम है, क्योंकि यह लगभग हर पॉइंट के पास से गुजरने के लिए मुड़ जाता है। लेकिन नए डेटा पर इसका एरर इसके ट्रेनिंग एरर से बहुत बड़ा है। डिग्री-3 वाला कर्व दोनों पर अच्छा प्रदर्शन करता है। सीधी रेखा दोनों पर खराब है: यह underfit होती है।

साफ संकेत: गैप (the gap)

ट्रेनिंग स्कोरअनदेखे (unseen) डेटा पर स्कोरनिदान (Diagnosis)
खराबखराबUnderfitting: मॉडल बहुत सरल है, या फीचर्स उपयोगी नहीं हैं
अच्छाअच्छा, ट्रेनिंग के करीबएक सही फिट (A healthy fit)
बहुत बढ़ियाकाफी खराबOverfitting: मॉडल ने शोर को रट लिया
आप केवल ट्रेनिंग स्कोर देखकर overfitting का पता नहीं लगा सकते। आपको हमेशा उस डेटा से तुलना करनी चाहिए जो मॉडल ने नहीं देखा है।

Overfitting को कम करने के तरीके

  • सरल मॉडल का उपयोग करें: कम polynomial डिग्री, पेड़ों (trees) के लिए छोटा max_depth, nearest neighbours के लिए बड़ा k।
  • अधिक डेटा प्राप्त करें: अधिक उदाहरणों के साथ, शोर का असर कम (average out) हो जाता है और रटना कठिन हो जाता है।
  • Regularise करें: कई मॉडलों में एक सेटिंग होती है जो बहुत बड़े वेट्स (weights) को सीमित (punish) करती है। scikit-learn के logistic regression में यह C है (छोटा C मतलब मजबूत regularisation); Ridge लीनियर रिग्रेशन है जिसमें यह पहले से शामिल है।
  • कई मॉडलों का औसत निकालें: random forests एकल पेड़ों की overfitting को कम करते हैं।
  • बेकार फीचर्स हटाएं: हर अतिरिक्त फीचर नकली पैटर्न खोजने की एक और जगह बन जाता है।
असली उदाहरण
पुणे में एक छोटी दुकान की मालिक 40 कॉलमों के आधार पर दैनिक बिक्री का अनुमान लगाने के लिए एक मॉडल बनाती है, जिसमें मौसम, दिन और उसके द्वारा पहनी गई शर्ट का रंग शामिल है। पिछले महीने के डेटा पर यह लगभग सही है। अगले महीने यह खराब रहता है। केवल 30 दिनों के डेटा और 40 कॉलमों के साथ, मॉडल को ऐसे "पैटर्न" मिले जो पूरी तरह से संयोग थे, जैसे कि शर्ट का रंग। कम और समझदार फीचर्स के साथ, मॉडल अतीत पर थोड़ा कम सटीक रहता है लेकिन भविष्य के लिए बेहतर होता है।
नोट
Large language models को भी इसके एक रूप का सामना करना पड़ता है: एक मॉडल बेंचमार्क पर अच्छा प्रदर्शन कर सकता है क्योंकि उसी तरह के सवाल उसके ट्रेनिंग डेटा में थे। देखें Contamination: जब टेस्ट लीक हो गया।
यह आज़माएं। कोड में, 12 ट्रेनिंग पॉइंट्स को बदलकर 60 करें। क्या डिग्री-9 वाला कर्व अब भी नए डेटा पर बहुत खराब प्रदर्शन करता है?

और देखें और पढ़ें

लैब

शोर-युक्त बनाए गए डेटा पर ट्री डेप्थ 1 से 12 के लिए ट्रेनिंग और validation सटीकता की एक तालिका, और वह डेप्थ जिसे आप चुनेंगे।

~25 min

समस्या

स्टार्टर make_moons (बनाए गए पॉइंट्स, फिक्स्ड सीड) के साथ एक शोर-युक्त दो-समूह वाला डेटासेट बनाता है और एक validation सेट अलग करता है, जिसका उपयोग सेटिंग्स चुनने के लिए किया जाता है।

  1. 1 से 12 तक की प्रत्येक डेप्थ के लिए, ट्रेनिंग पंक्तियों पर DecisionTreeClassifier(max_depth=depth, random_state=0) फिट करें।
  2. results[depth] = (train_acc, val_acc) स्टोर करें।
  3. best_depth को उच्चतम validation सटीकता वाली डेप्थ पर सेट करें (यदि कोई टाई है, तो ऐसी सबसे छोटी डेप्थ)।
  4. deep_gap को डेप्थ 12 के लिए ट्रेनिंग सटीकता माइनस validation सटीकता पर सेट करें।
  5. प्रिंट की गई तालिका देखें: अंतर कहाँ से बढ़ना शुरू होता है?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1कई डेप्थ में समान सर्वोत्तम validation सटीकता है। सबसे छोटी को प्राथमिकता क्यों दें?दिखाएं

जब दो मॉडल अनदेखे डेटा पर समान रूप से अच्छा प्रदर्शन करते हैं, तो सरल मॉडल आमतौर पर अधिक सुरक्षित होता है: इसमें शोर को रटने के तरीके कम होते हैं, और इसे समझाना आसान होता है। सरल मॉडलों के लिए यह प्राथमिकता विज्ञान और सांख्यिकी में एक पुराना व्यावहारिक नियम (rule of thumb) है।

Q2Validation सेट में केवल 120 पॉइंट्स हैं। आपको सटीकता में 1-पॉइंट के अंतर पर कितना भरोसा करना चाहिए?दिखाएं

ज्यादा नहीं। यहाँ एक पॉइंट का मतलब 120 में से 1 या 2 अधिक सही भविष्यवाणियाँ हैं, जो आसानी से संयोग से हो सकती हैं। छोटे अंतरों को वास्तविक मानने से पहले क्रॉस-वैलिडेशन (cross-validation), या बड़े validation सेट का उपयोग करें।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या 100% ट्रेनिंग स्कोर हमेशा एक बुरा संकेत है?

हमेशा नहीं, लेकिन यह ध्यान से देखने का एक कारण ज़रूर है। कुछ मॉडल, जैसे कि एक गहरा पेड़ (deep tree), रटकर ट्रेनिंग डेटा पर 100% तक पहुँच सकते हैं। जो मायने रखता है वह है अनदेखे डेटा पर स्कोर और दोनों के बीच का अंतर।

कितना बड़ा अंतर (gap) बहुत बड़ा माना जाता है?

इसकी कोई निश्चित संख्या नहीं है। मॉडलों की तुलना करें: यदि किसी सरल मॉडल का अनदेखे डेटा पर स्कोर समान है और अंतर छोटा है, तो उसे प्राथमिकता दें। इस बात पर भी विचार करें कि काम में कितना शोर (noise) है।

क्या कोई मॉडल टेस्ट सेट पर overfit हो सकता है?

हाँ, यदि आप कई मॉडलों को आज़माते हैं और सबसे अच्छे टेस्ट स्कोर वाले मॉडल को चुनते हैं। आप धीरे-धीरे उस टेस्ट सेट के हिसाब से ट्यून हो जाते हैं। अगला पाठ दिखाता है कि एक validation सेट इसे कैसे रोकता है।

क्या अधिक डेटा जोड़ने से underfitting ठीक हो जाती है?

आमतौर पर नहीं। Underfitting वाला मॉडल इतना सरल होता है कि वह अपने पास मौजूद डेटा का भी सही उपयोग नहीं कर पाता। अधिक लचीले मॉडल या बेहतर फीचर्स आज़माएं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें