अंडरफिटिंग क्या है? ML मॉडलों में उच्च बायस की पहचान और उसे दूर करने के तरीके

जब हम परिणामों का पूर्वानुमान लगाने या पैटर्न पहचानने के लिए मॉडल बनाते हैं, तो कई तरह की चुनौतियाँ सामने आती हैं। एक आम चुनौती यह होती है कि मॉडल आपके डेटा में छिपे वास्तविक रुझानों को सही ढंग से कैप्चर करे। कभी-कभी मॉडल इतने सरल होते हैं कि वे जटिलताओं को सीख ही नहीं पाते, जिससे प्रदर्शन कमजोर हो जाता है। इसे ही अंडरफिटिंग कहते हैं।

अंडरफिटिंग मॉडल न केवल उस डेटा पर खराब प्रदर्शन करता है जिस पर उसे प्रशिक्षित किया गया था, बल्कि नए, अनदेखे डेटा पर भी सामान्यीकृत नहीं कर पाता। यानी वास्तविक दुनिया में आपकी भविष्यवाणियाँ अविश्वसनीय हो सकती हैं। अंडरफिटिंग की पहचान करना और उसे दूर करना, मज़बूत और प्रभावी मशीन लर्निंग मॉडल बनाने की एक अहम कड़ी है। 

लेखक द्वारा चित्र

इस लेख में हम देखेंगे कि अंडरफिटिंग क्या है, यह क्यों होती है, इसे कैसे पहचाना जाए, और सबसे महत्वपूर्ण—अंडरफिटिंग को कैसे ठीक किया जाए। यदि आप मशीन लर्निंग को हाथों-हाथ सीखना चाहते हैं, तो हमारा Machine Learning Fundamentals in Python ट्रैक अवश्य देखें। 

अंडरफिटिंग क्या है?

आइए अंडरफिटिंग की अवधारणा को गहराई से समझें और देखें कि यह अपने समकक्ष ओवरफिटिंग से कैसे भिन्न है। इस फ़र्क को समझना मॉडल डायग्नॉस्टिक्स और सुधार के लिए बुनियादी है।

लेखक द्वारा चित्र

सरल शब्दों में, अंडरफिटिंग तब होती है जब मशीन लर्निंग मॉडल प्रशिक्षण डेटा में मौजूद मूल पैटर्न को कैप्चर करने के लिए बहुत सरल होता है। मान लीजिए आप उन बिंदुओं पर सीधी रेखा फिट करने की कोशिश कर रहे हैं जो स्पष्ट रूप से एक वक्र का अनुसरण करते हैं—रेखा (हमारा मॉडल) पर्याप्त जटिल नहीं है। अंडरफिटिंग मॉडल में उच्च बायस होता है, यानी यह डेटा के बारे में सख्त मान्यताएँ बनाता है (जैसे जहाँ रैखिक संबंध नहीं है, वहाँ रैखिक संबंध मान लेना)। 

क्योंकि यह डेटा को ठीक से सीख नहीं पाता, इसलिए यह प्रशिक्षण डेटा पर भी और नए, अनदेखे डेटा (टेस्ट डेटा) पर भी खराब प्रदर्शन करता है। हालाँकि, ऐसे मॉडलों में प्रायः कम वैरिएंस होता है, यानी यदि आप डेटा के अलग-अलग सबसेट पर ट्रेन करें तो भी भविष्यवाणियाँ ज़्यादा नहीं बदलतीं। सरलता उन्हें सुसंगत बनाती है—भले ही लगातार गलत हों।

गणितीय रूप से, यह मॉडल की अपेक्षित त्रुटि के बायस-वैरिएंस विघटन से जुड़ा है। किसी मॉडल की अपेक्षित त्रुटि तीन घटकों में बाँटी जा सकती है: बायस का वर्ग, वैरिएंस, और अपसांहार्य त्रुटि:

जहाँ:

• E[(y - f̂(x))²] भविष्यवाणी की अपेक्षित वर्ग त्रुटि है।

• Bias(f̂(x)) वास्तविक फ़ंक्शन f(x) को मॉडल से अनुरूपित करने पर आने वाली त्रुटि को मापता है।

• Var(f̂(x)) अलग-अलग प्रशिक्षण डेटासेट्स पर मॉडल की भविष्यवाणी में होने वाली परिवर्तनशीलता है।

• σ² अपसांहार्य त्रुटि का प्रतिनिधित्व करता है — डेटा में निहित शोर जिसे भविष्यवाणी नहीं किया जा सकता।

अंडरफिटिंग में, त्रुटि में Bias(f̂(x)) पद हावी रहता है। मॉडल बहुत सरल होता है, जिसके कारण तंत्रगत त्रुटियाँ होती हैं और वास्तविक संबंध कैप्चर नहीं हो पाता।

अंडरफिटिंग बनाम ओवरफिटिंग का तुलना-विरुद्ध

अंडरफिटिंग को ओवरफिटिंग से तुलना करने पर और स्पष्टता मिलती है। जहाँ अंडरफिटिंग मॉडल बहुत सरल होते हैं, वहीं ओवरफिटिंग मॉडल अत्यधिक जटिल होते हैं। वे प्रशिक्षण डेटा को बहुत अच्छी तरह सीख लेते हैं, और मूल पैटर्न के साथ-साथ शोर व यादृच्छिक उतार-चढ़ाव भी पकड़ लेते हैं।

बायस-वैरिएंस ट्रेड-ऑफ - लेखक द्वारा चित्र

आइए अंडरफिटिंग और ओवरफिटिंग के मुख्य अंतर देखें:

यह हमें बायस-वैरिएंस ट्रेड-ऑफ की अहम अवधारणा तक ले जाता है।

• उच्च बायस (अंडरफिटिंग): सरल मॉडलों में बायस अधिक और वैरिएंस कम होता है। ये लगातार गलत होते हैं, पर अलग-अलग प्रशिक्षण डेटा पर ज़्यादा बदलते नहीं।
• उच्च वैरिएंस (ओवरफिटिंग): जटिल मॉडलों में बायस कम पर वैरिएंस अधिक होता है। वे प्रशिक्षण डेटा पर बहुत अच्छा फिट करते हैं (कम बायस) लेकिन विशेष प्रशिक्षण डेटा के प्रति अत्यधिक संवेदनशील होते हैं, जिससे नए डेटा पर सामान्यीकरण कमजोर होता है। इसके बारे में अधिक जानें हमारे लेख What is Overfitting? में।

लक्ष्य है संतुलन पाना: मॉडल इतना जटिल हो कि वास्तविक पैटर्न पकड़ सके (कम बायस), पर इतना जटिल न हो कि शोर भी सीख ले (कम वैरिएंस)।

उदाहरण:

• अंडरफिटिंग उदाहरण: घर की कीमत का पूर्वानुमान केवल कमरों की संख्या से लगाना, जबकि कीमत आकार, स्थान, उम्र आदि पर निर्भर करती है। मॉडल बहुत सरल है (उच्च बायस) और ज़्यादातर घरों के लिए गलत भविष्यवाणी करेगा।
• ओवरफिटिंग उदाहरण: एक अत्यधिक जटिल बहुपद रिग्रेशन मॉडल बनाना जो प्रशिक्षण सेट के हर बिंदु से होकर गुज़रता हो। यह प्रशिक्षण डेटा पर लगभग शून्य त्रुटि देगा, पर नए घरों पर बहुत खराब प्रदर्शन करेगा क्योंकि इसने प्रशिक्षण सेट-विशिष्ट शोर सीख लिया है (उच्च वैरिएंस)।

यह समझना कि आपका मॉडल इस स्पेक्ट्रम में कहाँ आता है, प्रभावी मशीन लर्निंग समाधान विकसित करने के लिए महत्वपूर्ण है—जैसा कि हम आगे अंडरफिटिंग की पहचान और समाधान में देखेंगे।

अंडरफिटिंग के कारण और निदान संकेतक

अब जब हमने समझ लिया कि अंडरफिटिंग क्या है, तो देखें यह क्यों होती है और अपने प्रोजेक्ट्स में आप इसे कैसे पहचान सकते हैं। मूल कारण पहचानना सही निवारण रणनीति चुनने के लिए आवश्यक है। 

अंडरफिटिंग के प्राथमिक कारण

कई कारक मॉडल को अंडरफिट कर सकते हैं:

मॉडल जटिलता का अभाव

चुना गया अल्गोरिद्म डेटा की अंतर्निहित संरचना के लिए बहुत सरल हो सकता है। जैसे, जब फीचर्स और टारगेट के बीच संबंध अत्यधिक गैर-रैखिक हो, तब लीनियर रिग्रेशन का उपयोग करना। मॉडल में स्वाभाविक रूप से जटिलताओं को पकड़ने की क्षमता नहीं होती।

अपर्याप्त प्रशिक्षण

मॉडल को पर्याप्त समय तक प्रशिक्षित नहीं किया गया हो सकता है (जैसे, न्यूरल नेटवर्क में बहुत कम epochs) या उपयुक्त लर्निंग पैरामीटर्स के साथ नहीं। यदि प्रशिक्षण समय से पहले रुक जाए, तो मॉडल, क्षमता होते हुए भी, पैटर्न सीख नहीं पाता।

कमज़ोर फीचर अभिव्यक्ति 

प्रशिक्षण के लिए उपयोग किए गए फीचर्स, टारगेट को प्रभावित करने वाले मूल कारकों का पर्याप्त प्रतिनिधित्व नहीं कर पाते। यह हो सकता है:

• महत्वपूर्ण फीचर्स का न होना: प्रमुख प्रेडिक्टर्स डेटासेट में शामिल नहीं हुए।
• गैर-प्रासंगिक फीचर्स: डेटासेट में शोर या ऐसे फीचर्स हों जिनका परिणाम से संबंध न हो—जो सरल मॉडल को भटका सकते हैं।
• रूपांतरण की आवश्यकता वाले फीचर्स: फीचर्स को स्केलिंग, नॉर्मलाइज़ेशन या एन्कोडिंग (जैसे श्रेणीबद्ध वेरिएबल्स) की आवश्यकता हो सकती है।

अत्यधिक रेग्युलराइज़ेशन

रेग्युलराइज़ेशन तकनीकें (जैसे L1 या L2 पेनल्टी) मुख्यतः ओवरफिटिंग रोकने के लिए जटिलता पर दंड जोड़ती हैं। पर यदि रेग्युलराइज़ेशन की तीव्रता (जैसे lambda पैरामीटर) बहुत अधिक सेट हो, तो यह मॉडल को बहुत अधिक सरल बना सकती है और अंडरफिटिंग करा सकती है। रेग्युलराइज़ेशन के बारे में अधिक जानें Towards Preventing Overfitting in Machine Learning: Regularization में।

कम-गुणवत्ता या अपर्याप्त डेटा

• पर्याप्त डेटा का न होना: यदि प्रशिक्षण डेटासेट बहुत छोटा है, तो मॉडल के पास पैटर्न प्रभावी ढंग से सीखने के लिए पर्याप्त उदाहरण नहीं होंगे।
• उच्च शोर: यदि डेटा बहुत शोरयुक्त है, तो खासकर सरल मॉडल के लिए सिग्नल और शोर में फर्क करना कठिन हो सकता है।
• मिसिंग वैल्यूज़: मिसिंग डेटा का बड़ा हिस्सा, खासकर यदि सही ढंग से हैंडल न किया जाए, तो सीखने की क्षमता को बाधित कर सकता है। इससे निपटने की तकनीकों के लिए देखें Handling Missing Data with Imputations in R।

पता लगाने के तरीके

कैसे जानें कि आपका मॉडल अंडरफिट हो रहा है? यहाँ कुछ सामान्य डायग्नोस्टिक तरीक़े हैं:

परफ़ॉर्मेंस मैट्रिक्स का विश्लेषण 

सबसे सीधा संकेत है दोनों—ट्रेनिंग सेट और वैलिडेशन/टेस्ट सेट—पर खराब प्रदर्शन। यदि आपका मॉडल उसी डेटा पर भी उच्च त्रुटि (या कम एक्युरेसी, कम R-squared, आदि) देता है जिस पर इसे प्रशिक्षित किया गया था, तो यह मज़बूत संकेत है कि इसने पैटर्न प्रभावी ढंग से नहीं सीखे। ओवरफिटिंग के विपरीत, जहाँ ट्रेनिंग परफ़ॉर्मेंस उत्कृष्ट पर टेस्ट पर कमजोर होता है, अंडरफिटिंग में हर जगह प्रदर्शन खराब रहता है।

लर्निंग कर्व्स

ट्रेनिंग और वैलिडेशन सेट पर मॉडल के प्रदर्शन (जैसे, त्रुटि या एक्युरेसी) को प्रशिक्षण समय या डेटासेट के आकार के फ़ंक्शन के रूप में प्लॉट करना काफ़ी सूचनाप्रद होता है। अंडरफिटिंग मॉडल के लिए, लर्निंग कर्व्स आमतौर पर दिखाते हैं:

• उच्च ट्रेनिंग त्रुटि जो जल्दी plateau पर पहुँच जाती है।
• उच्च वैलिडेशन त्रुटि जो ट्रेनिंग त्रुटि के क़रीब होती है और वह भी plateau पर रहती है।
• दोनों कर्व्स उच्च त्रुटि स्तर पर अभिसरित होते हैं, दर्शाते हुए कि अधिक डेटा या प्रशिक्षण से भी महत्वपूर्ण सुधार नहीं हो रहा।

फीचर विश्लेषण

उपयोग किए गए फीचर्स की समीक्षा करें। क्या वे प्रासंगिक हैं? क्या कोई इंटरैक्शन छूट गया है? क्या संख्यात्मक फीचर्स स्केल किए गए हैं? क्या श्रेणीबद्ध फीचर्स उचित रूप से एन्कोड हुए हैं? 

कभी-कभी फीचर इंजीनियरिंग पर लौटना स्पष्ट कर देता है कि मॉडल संघर्ष क्यों कर रहा है। मूल बातें देखिए Machine Learning Fundamentals in R में। सांख्यिकीय संबंधों पर गहरी समझ के लिए देखें Statistical Inference in R।

तुलनात्मक मॉडलिंग

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

ऐसी तुलना को आप ट्रैक कर सकते हैं इन टूल्स से: Machine Learning Experimentation: An Introduction to Weights & Biases।

इन कारणों और तरीकों को समझकर आप अंडरफिटिंग का प्रभावी निदान कर पाएँगे और प्रदर्शन सुधारने के कदम उठा पाएँगे।

अंडरफिटिंग के निवारण के उपाय और श्रेष्ठ प्रक्रियाएँ

एक बार आपने अंडरफिटिंग की पहचान कर ली, अगला कदम है इसे ठीक करना। सौभाग्य से, कई प्रभावी रणनीतियाँ हैं जो मॉडल की क्षमता बढ़ाती हैं ताकि वह डेटा के मूल पैटर्न सीख सके। आइए कुछ तरीक़े देखें:

मॉडल जटिलता बढ़ाना

यदि आपका मॉडल बहुत सरल है (उच्च बायस), तो उसे अधिक जटिल बनाना अक्सर अंडरफिटिंग दूर कर देता है। यह निम्न तरीकों से किया जा सकता है:

अल्गोरिद्म चयन

अधिक शक्तिशाली मॉडल पर स्विच करें। यदि लीनियर रिग्रेशन अंडरफिट कर रहा है, तो पॉलिनोमियल रिग्रेशन, डिसीजन ट्री, रैंडम फॉरेस्ट, ग्रेडिएंट बूस्टिंग मशीनें (जैसे XGBoost या LightGBM), या नॉन-लिनियर कर्नल वाले SVM आज़माएँ। ये मॉडल जटिल संबंध कैप्चर करने की अधिक क्षमता रखते हैं।

पॉलिनोमियल फीचर विस्तार

रिग्रेशन समस्याओं में, मौजूदा संख्यात्मक फीचर्स से पॉलिनोमियल फीचर्स बनाएँ। इससे लीनियर मॉडल भी अधिक जटिल, वक्राकार संबंध फिट कर सकते हैं। उदाहरण के लिए, यदि आपके पास फीचर x है, तो x2, x3 आदि नए फीचर जोड़ें। Scikit-learn इसके लिए PolynomialFeatures प्रदान करता है।

हाइपरपैरामीटर ट्यूनिंग

कई जटिल मॉडलों में ऐसे हाइपरपैरामीटर्स होते हैं जो उनकी जटिलता नियंत्रित करते हैं (जैसे, डिसीजन ट्री की गहराई, न्यूरल नेटवर्क लेयर में न्यूरॉन्स की संख्या, SVM में C पैरामीटर)। इन्हें इस तरह ट्यून करें कि अधिक जटिलता संभव हो और बायस घटे। 

Grid Search या Randomized Search जैसी तकनीकें यहाँ ज़रूरी हैं। अधिक जानें कोर्स Hyperparameter Tuning in Python या Hyperparameter Tuning in R से। यह ट्यूटोरियल भी देखें: Hyperparameter Optimization in Machine Learning Models।

फीचर इंजीनियरिंग और डेटा ऑग्मेंटेशन

कभी-कभी समस्या मॉडल नहीं, बल्कि डेटा का प्रतिनिधित्व होता है। फीचर्स सुधारने से बड़ा लाभ मिलता है। यह इस प्रकार किया जा सकता है:

डोमेन-विशिष्ट फीचर निर्माण

समस्या-क्षेत्र की समझ का उपयोग कर अधिक सूचनात्मक फीचर्स बनाएँ। जैसे, घर की कीमत भविष्यवाणी में 'बेडरूम' और 'बाथरूम' को जोड़कर 'कुल कमरे' बनाना, या 'निर्माण वर्ष' से 'घर की आयु' निकालना।

इंटरैक्शन फीचर्स

मौजूदा फीचर्स के बीच इंटरैक्शन दर्शाने वाले फीचर्स बनाएँ (जैसे, दो फीचर्स का गुणन)। इससे मॉडल सहक्रियात्मक प्रभाव पकड़ सकते हैं।

डेटा समृद्धि

संभव हो तो बाहरी स्रोतों से डेटासेट समृद्ध करें। जैसे, ग्राहक डेटा में जनसांख्यिकीय जानकारी जोड़ना या बिक्री पूर्वानुमान में मौसम डेटा जोड़ना।

डेटा ऑग्मेंटेशन (मुख्यतः असंरचित डेटा के लिए)

छवि या पाठ डेटा के लिए, इमेज घुमाने/पलटने या टेक्स्ट में पर्यायवाची प्रतिस्थापन जैसी तकनीकें प्रशिक्षण सेट का आकार और विविधता कृत्रिम रूप से बढ़ाती हैं, जिससे मॉडल अधिक मज़बूत पैटर्न सीख सकता है।

रेग्युलराइज़ेशन समायोजन

यदि अंडरफिटिंग का कारण अत्यधिक रेग्युलराइज़ेशन है, तो उसे कम करें। रेग्युलराइज़ेशन पैरामीटर का मान घटाएँ (जैसे Ridge/Lasso में alpha, SVM में C – ध्यान दें कि SVM में छोटा C मज़बूत रेग्युलराइज़ेशन दर्शाता है, इसलिए यहाँ आप C बढ़ाएँ)।

यदि आप ड्रॉपआउट का उपयोग कर रहे हैं, तो ड्रॉपआउट दर घटाएँ (ट्रेनिंग के दौरान हटाए गए न्यूरॉन्स का अंश)। कम दर से नेटवर्क की क्षमता अधिक बनी रहती है।

उचित संतुलन पाना सावधानीपूर्वक ट्यूनिंग माँगता है—यही हाइपरपैरामीटर ऑप्टिमाइज़ेशन के महत्व को फिर रेखांकित करता है।

एंसेंबल विधियाँ

एंसेंबल विधियाँ कई व्यक्तिगत मॉडलों (वीक लर्नर्स) की भविष्यवाणियों को मिलाकर अधिक मज़बूत अंतिम भविष्यवाणी देती हैं। वे अक्सर बायस और वैरिएंस—दोनों—घटाने में प्रभावी होती हैं। कुछ प्रमुख एंसेंबल विधियाँ:

• बैगिंग (जैसे, Random Forests): विभिन्न बूटस्ट्रैप सैंपल्स पर कई मॉडल (जैसे, डिसीजन ट्री) स्वतंत्र रूप से प्रशिक्षित कर, उनकी भविष्यवाणियों का औसत लेते हैं। यह मुख्यतः वैरिएंस घटाता है, पर यदि बेस लर्नर्स थोड़े बायस्ड हों तो मददगार रहता है। अधिक जानकारी के लिए हमारा बैगिंग ट्यूटोरियल देखें।
• बूस्टिंग (जैसे, AdaBoost, Gradient Boosting): मॉडल क्रमिक रूप से प्रशिक्षित होते हैं, जहाँ हर नया मॉडल पिछले मॉडलों की त्रुटियाँ सुधारने पर फोकस करता है। बूस्टिंग विशेष रूप से बायस घटाने और वीक लर्नर्स को स्ट्रॉन्ग बनाने में कारगर है—अंडरफिटिंग से निपटने का शक्तिशाली साधन। अधिक जानने के लिए हमारा बूस्टिंग गाइड देखें। 
• स्टैकिंग: कई अलग-अलग प्रकार के मॉडल ट्रेन कर, एक अन्य मॉडल (मेटा-लर्नर) से उनकी भविष्यवाणियों का सर्वोत्तम संयोजन सीखना।

इन रणनीतियों को, अक्सर संयोजन में, अपनाकर आप अंडरफिटिंग का प्रभावी समाधान कर सकते हैं और ऐसे मॉडल बना सकते हैं जो आपके डेटा की जटिलताओं को बेहतर ढंग से कैप्चर करें।

व्यावहारिक अनुप्रयोग और केस स्टडीज़

डेटासेट्स और कोड के साथ अंडरफिटिंग को क्रियान्वयन में देखना इस अवधारणा को काफ़ी स्पष्ट करता है। आइए व्यावहारिक उदाहरणों से देखें कि अंडरफिटिंग मॉडल कैसे व्यवहार करता है और उसका प्रदर्शन कैसे सुधर सकता है।

लीनियर रिग्रेशन में अंडरफिटिंग उदाहरण

अंडरफिटिंग आमतौर पर तब दिखती है जब किसी गैर-रैखिक संबंध को एक सरल रैखिक मॉडल से समझाने की कोशिश की जाती है। आइए ऐसा ही एक उदाहरण लें—ऐसे डेटा पर लीनियर रिग्रेशन फिट करना जो क्वाड्रेटिक पैटर्न का अनुसरण करता है।

हम सिंथेटिक डेटा जनरेट करेंगे जहाँ टारगेट वेरिएबल y का फीचर X से क्वाड्रेटिक संबंध होगा। पहले हम एक सरल लीनियर रिग्रेशन मॉडल फिट करेंगे। इसका कमजोर प्रदर्शन (उच्च Mean Squared Error - MSE) देखेंगे और यह भी विज़ुअलाइज़ करेंगे कि यह डेटा के वक्र को कैसे पकड़ने में विफल रहता है। 

इसके बाद हम पॉलिनोमियल टर्म जोड़कर फीचर्स का विस्तार करेंगे और पॉलिनोमियल रिग्रेशन मॉडल फिट करेंगे। इससे दिखेगा कि मॉडल जटिलता बढ़ाने से बायस कैसे घटता है और सटीकता में उल्लेखनीय सुधार आता है।

आवश्यक लाइब्रेरीज़ इम्पोर्ट करते हैं:

# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_errorसंचालित द्वारा

अब सिंथेटिक गैर-रैखिक डेटा जनरेट करें। हम क्वाड्रेटिक संबंध बनाएँगे: y = 0.5*X^2 + X + 2 + शोर।

np.random.seed(42) # for reproducibility
num_samples = 100
X = np.sort(10 * np.random.rand(num_samples, 1) - 5, axis=0) # Feature X (sorted for plotting)
y_true = 0.5 * X**2 + X + 2 # True quadratic relationship
y = y_true + np.random.randn(num_samples, 1) * 5 # Add some noise to make it realisticसंचालित द्वारा

अब एक सरल लीनियर रिग्रेशन मॉडल (Underfitting Model) फिट करते हैं:

linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)
mse_linear = mean_squared_error(y, y_pred_linear)

print(f"--- Simple Linear Regression (Potential Underfitting Model) ---")
print(f"Mean Squared Error (MSE): {mse_linear:.2f}")
print(f"Model Coefficients (slope): {linear_model.coef_[0][0]:.2f}")
print(f"Model Intercept: {linear_model.intercept_[0]:.2f}")संचालित द्वारा

आउटपुट:

--- Simple Linear Regression (Potential Underfitting Model) ---

Mean Squared Error (MSE): 34.03

Model Coefficients (slope): 1.00

Model Intercept: 6.42संचालित द्वारा

अब हम पॉलिनोमियल रिग्रेशन मॉडल (सुधरा हुआ मॉडल) फिट करेंगे। इसके लिए डिग्री 2 के पॉलिनोमियल फीचर्स बनाएँगे और उन पर लीनियर मॉडल फिट करेंगे। PolynomialFeatures स्टेप नए फीचर्स जोड़ता है। LinearRegression स्टेप प्रत्येक के लिए गुणांक सीखता है।

डिग्री 2 के लिए, हमें X और X^2 के लिए गुणांक की अपेक्षा रहती है। एक पाइपलाइन यह प्रक्रिया सरल बनाती है। पाइपलाइन का named_steps एट्रिब्यूट अलग-अलग स्टेप्स तक पहुँच देता है, जैसा नीचे दिखाया है:

polynomial_model = make_pipeline(PolynomialFeatures(degree=2, include_bias=False), LinearRegression())
polynomial_model.fit(X, y)
y_pred_poly = polynomial_model.predict(X)
mse_poly = mean_squared_error(y, y_pred_poly)

print(f"\n--- Polynomial Regression (Degree 2) ---")
print(f"Mean Squared Error (MSE): {mse_poly:.2f}")
poly_reg_coeffs = polynomial_model.named_steps['linearregression'].coef_[0]
poly_reg_intercept = polynomial_model.named_steps['linearregression'].intercept_[0]
print(f"Model Coefficients (for X, X^2): {poly_reg_coeffs[0]:.2f}, {poly_reg_coeffs[1]:.2f}")
print(f"Model Intercept: {poly_reg_intercept:.2f}")संचालित द्वारा

आउटपुट:

--- Polynomial Regression (Degree 2) ---

Mean Squared Error (MSE): 20.48

Model Coefficients (for X, X^2): 1.13, 0.50

Model Intercept: 2.04संचालित द्वारा

अब मॉडल फिटिंग का विज़ुअलाइज़ेशन करें:

# Visualization
plt.figure(figsize=(10, 4))
plt.scatter(X, y, s=30, label="Actual Data Points", alpha=0.7, edgecolors='k')
plt.plot(X, y_pred_linear, color='red', linewidth=2, label=f'Linear Fit (Underfitting)\nMSE: {mse_linear:.2f}')
plt.plot(X, y_pred_poly, color='green', linewidth=2, label=f'Polynomial Fit (Degree 2)\nMSE: {mse_poly:.2f}')
plt.title('Demonstrating Underfitting with Linear vs. Polynomial Regression', fontsize=16)
plt.xlabel('Feature X', fontsize=14)
plt.ylabel('Target y', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()संचालित द्वारा

आउटपुट:

प्लॉट स्पष्ट रूप से दिखाता है कि सरल लीनियर मॉडल अंडरफिट कर रहा है—यह डेटा में वक्र को नहीं पकड़ पाता। X^2 टर्म जोड़ने वाला पॉलिनोमियल रिग्रेशन बेहतर फिट देता है, जैसा कि कम MSE से स्पष्ट है।

यह दर्शाता है कि जब अंतर्निहित संबंध गैर-रैखिक हो, तो फीचर्स का विस्तार (मॉडल जटिलता बढ़ाना) बायस घटाकर सटीकता सुधार सकता है। अगला, एक मेडिकल डायग्नोसिस केस स्टडी देखते हैं।

मेडिकल डायग्नोसिस केस स्टडी

आइए scikit-learn में उपलब्ध प्रसिद्ध Breast Cancer Wisconsin (Diagnostic) डेटासेट से एक परिदृश्य सिम्युलेट करें।

पहले हम बहुत सीमित फीचर सेट से एक क्लासीफिकेशन मॉडल बनाएँगे, जो अंडरफिटिंग करा सकता है। फिर अधिक व्यापक फीचर सेट और संभवतः अधिक जटिल अल्गोरिद्म से सुधार दिखाएँगे।

आवश्यक लाइब्रेरीज़ इम्पोर्ट करें:

# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix, ConfusionMatrixDisplayसंचालित द्वारा

अब डेटा लोड और तैयार करें:

cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = cancer.target # 0 for malignant, 1 for benignसंचालित द्वारा

डेमोंस्ट्रेशन के लिए, अंडरफिटिंग परिदृश्य में बहुत सीमित फीचर्स चुनते हैं। ये अकेले में सर्वाधिक प्रेडिक्टिव नहीं हो सकते:

features_limited = ['mean texture', 'mean symmetry']
X_limited = X[features_limited]संचालित द्वारा

सुधरे मॉडल के लिए, बड़ा (या सभी) फीचर सेट इस्तेमाल करेंगे। हम पहले 10 फीचर्स लेते हैं:

features_comprehensive = cancer.feature_names[:10]
X_comprehensive = X[features_comprehensive]संचालित द्वारा

डेटा विभाजित करें। स्पष्टता के लिए प्रत्येक फीचर सेट के लिए अलग-अलग करेंगे:

X_train_lim, X_test_lim, y_train, y_test = train_test_split(X_limited, y, test_size=0.3, random_state=42, stratify=y)
X_train_comp, X_test_comp, _, _ = train_test_split(X_comprehensive, y, test_size=0.3, random_state=42, stratify=y) # y_train and y_test are the sameसंचालित द्वारा

फीचर्स स्केल करें—लॉजिस्टिक रिग्रेशन और अनेक अल्गोरिद्म्स हेतु यह महत्वपूर्ण है:

scaler_lim = StandardScaler().fit(X_train_lim)
X_train_lim_scaled = scaler_lim.transform(X_train_lim)
X_test_lim_scaled = scaler_lim.transform(X_test_lim)

scaler_comp = StandardScaler().fit(X_train_comp)
X_train_comp_scaled = scaler_comp.transform(X_train_comp)
X_test_comp_scaled = scaler_comp.transform(X_test_comp)संचालित द्वारा

अब सीमित फीचर्स के साथ लॉजिस्टिक रिग्रेशन फिट करें:

print("Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)")
log_reg_limited = LogisticRegression(random_state=42, solver='liblinear') # liblinear is good for small datasets
log_reg_limited.fit(X_train_lim_scaled, y_train)
y_pred_lim = log_reg_limited.predict(X_test_lim_scaled)
y_proba_lim = log_reg_limited.predict_proba(X_test_lim_scaled)[:, 1]

acc_lim = accuracy_score(y_test, y_pred_lim)
auc_lim = roc_auc_score(y_test, y_proba_lim)
print(f"Features used: {features_limited}")
print(f"Accuracy: {acc_lim:.4f}")
print(f"AUC: {auc_lim:.4f}")संचालित द्वारा

आउटपुट:

Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)

Features used: ['mean texture', 'mean symmetry']

Accuracy: 0.7544

AUC: 0.8151संचालित द्वारा

अब निवारण अपनाएँ। अधिक फीचर्स के साथ लॉजिस्टिक रिग्रेशन फिट करेंगे:

print("Scenario 2: Logistic Regression (Comprehensive Features)")
log_reg_comp = LogisticRegression(random_state=42, solver='liblinear')
log_reg_comp.fit(X_train_comp_scaled, y_train)
y_pred_comp_lr = log_reg_comp.predict(X_test_comp_scaled)
y_proba_comp_lr = log_reg_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_lr = accuracy_score(y_test, y_pred_comp_lr)
auc_comp_lr = roc_auc_score(y_test, y_proba_comp_lr)
print(f"Features used: First 10 features") # For brevity
print(f"Accuracy: {acc_comp_lr:.4f}")
print(f"AUC: {auc_comp_lr:.4f}")संचालित द्वारा

आउटपुट:

Scenario 2: Logistic Regression (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9181

AUC: 0.9831संचालित द्वारा

अब अधिक जटिल मॉडल, जैसे Random Forest, अधिक फीचर्स के साथ फिट करें:

print("Scenario 3: Random Forest (Comprehensive Features)")
rf_comp = RandomForestClassifier(random_state=42, n_estimators=100) # n_estimators is a key hyperparameter
rf_comp.fit(X_train_comp_scaled, y_train) # RF can also benefit from scaled data, though less sensitive
y_pred_comp_rf = rf_comp.predict(X_test_comp_scaled)
y_proba_comp_rf = rf_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_rf = accuracy_score(y_test, y_pred_comp_rf)
auc_comp_rf = roc_auc_score(y_test, y_proba_comp_rf)
print(f"Features used: First 10 features")
print(f"Accuracy: {acc_comp_rf:.4f}")
print(f"AUC: {auc_comp_rf:.4f}")संचालित द्वारा

आउटपुट:

Scenario 3: Random Forest (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9415

AUC: 0.9878संचालित द्वारा

अब प्रत्येक केस के लिए कन्फ्यूज़न मैट्रिक्स प्लॉट और तुलना करें:

fig, axes = plt.subplots(1, 3, figsize=(20, 5))
fig.suptitle('Comparison of Model Performance (Confusion Matrices on Test Set)', fontsize=16)

# Model 1: Logistic Regression (Limited Features)
cm_lim = confusion_matrix(y_test, y_pred_lim)
disp_lim = ConfusionMatrixDisplay(confusion_matrix=cm_lim, display_labels=cancer.target_names)
disp_lim.plot(ax=axes[0], cmap='Blues')
axes[0].set_title(f'LogReg (Limited Features)\nAcc: {acc_lim:.2f}, AUC: {auc_lim:.2f}')

# Model 2: Logistic Regression (Comprehensive Features)
cm_comp_lr = confusion_matrix(y_test, y_pred_comp_lr)
disp_comp_lr = ConfusionMatrixDisplay(confusion_matrix=cm_comp_lr, display_labels=cancer.target_names)
disp_comp_lr.plot(ax=axes[1], cmap='Greens')
axes[1].set_title(f'LogReg (Comprehensive Features)\nAcc: {acc_comp_lr:.2f}, AUC: {auc_comp_lr:.2f}')

# Model 3: Random Forest (Comprehensive Features)
cm_comp_rf = confusion_matrix(y_test, y_pred_comp_rf)
disp_comp_rf = ConfusionMatrixDisplay(confusion_matrix=cm_comp_rf, display_labels=cancer.target_names)
disp_comp_rf.plot(ax=axes[2], cmap='Oranges')
axes[2].set_title(f'Random Forest (Comprehensive Features)\nAcc: {acc_comp_rf:.2f}, AUC: {auc_comp_rf:.2f}')

plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for suptitle
plt.show()संचालित द्वारा

आउटपुट:

इस केस स्टडी में, केवल दो फीचर्स पर प्रशिक्षित LogisticRegression (परिदृश्य 1) के अंडरफिट होने की अपेक्षा है—सूचना अपर्याप्त होने से एक्युरेसी और AUC कमजोर रहते हैं। 

उसी अल्गोरिद्म को अधिक व्यापक फीचर सेट (परिदृश्य 2) देने पर प्रदर्शन आमतौर पर सुधरता है क्योंकि सीखने के लिए अधिक जानकारी मिलती है और बायस घटता है।

और सुधार अक्सर अधिक जटिल अल्गोरिद्म जैसे RandomForestClassifier (परिदृश्य 3) से दिखता है, क्योंकि यह गैर-रैखिकताएँ और फीचर इंटरैक्शन अधिक प्रभावी ढंग से पकड़ता है—बायस और घटता है और फिट बेहतर होता है।

उन्नत विषय और भविष्य की दिशाएँ

हालाँकि हमने बुनियादी बातें कवर की हैं, मशीन लर्निंग का परिदृश्य लगातार विकसित हो रहा है। यहाँ संक्षेप में देखें कि अंडरफिटिंग उन्नत क्षेत्रों से कैसे संबंधित है।

डीप लर्निंग की भूमिका

डीप लर्निंग मॉडल, विशेषकर कई परतों वाले डीप न्यूरल नेटवर्क, उच्च क्षमता के लिए जाने जाते हैं—सैद्धांतिक रूप से वे बहुत जटिल फ़ंक्शंस का सन्निकटन कर सकते हैं।

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

फिर भी, डीप लर्निंग उन समस्याओं से मुक्त नहीं है जो अंडरफिटिंग जैसी दिखती हों। यदि नेटवर्क का डिज़ाइन खराब हो (जैसे, कार्य के लिए पर्याप्त गहराई/चौड़ाई न हो), प्रशिक्षण पर्याप्त न हो, या अनुचित एक्टिवेशन/ऑप्टिमाइज़ेशन का उपयोग हो, तो यह कन्वर्ज न कर पाएगा और उच्च ट्रेनिंग त्रुटि दिखा सकता है।

रेज़िडुअल कनेक्शंस (ResNets) और नॉर्मलाइज़ेशन तकनीकें (Batch Normalization) जैसी आर्किटेक्चरल नवाचार अत्यधिक गहरे नेटवर्क को प्रभावी ढंग से प्रशिक्षित करने में मदद करते हैं—vanishing/exploding gradients की समस्याएँ कम करते हैं—और नेटवर्क को अपनी पूरी क्षमता तक पहुँचने देते हैं, जिससे अंडरफिटिंग जैसे कन्वर्जेंस मुद्दे टलते हैं।

ऑटोएमएल (AutoML)

अंडरफिटिंग और ओवरफिटिंग—दोनों—से बचने के लिए सही मॉडल, फीचर्स और हाइपरपैरामीटर्स खोजना समय-साध्य हो सकता है। AutoML इस प्रक्रिया को स्वचालित करने का लक्ष्य रखता है।

AutoML फ्रेमवर्क्स स्वतः अलग-अलग मॉडल प्रकार (लीनियर मॉडलों से लेकर जटिल एंसेंबल्स और न्यूरल नेटवर्क तक) आज़माते हैं, फीचर इंजीनियरिंग/सेलेक्शन करते हैं, और हाइपरपैरामीटर्स ऑप्टिमाइज़ करते हैं। विशाल विकल्प-स्थान में व्यवस्थित खोज करके, AutoML ऐसे कॉन्फ़िगरेशन खोज सकता है जिनमें अंडरफिटिंग से बचने के लिए पर्याप्त जटिलता हो।

Neural Architecture Search (NAS) जैसी विधियाँ स्वतः नेटवर्क आर्किटेक्चर डिज़ाइन करती हैं, जबकि Bayesian Optimization जैसे उन्नत हाइपरपैरामीटर ऑप्टिमाइज़ेशन तरीक़े अच्छे सेटिंग्स कुशलतापूर्वक खोजते हैं। ये टूल्स, अंडरफिटिंग मॉडल का निदान व सुधार करने के लिए आवश्यक मैनुअल प्रयास को घटाते हुए, उपयुक्त मॉडल शीघ्रता से खोजने में मदद करते हैं।

निष्कर्ष

अंडरफिटिंग बनाम ओवरफिटिंग की दुविधा को समझना सफल मशीन लर्निंग के लिए बुनियादी है। हमने देखा कि अंडरफिटिंग तब उत्पन्न होती है जब मॉडल बहुत सरल (उच्च बायस) होता है और डेटा के मूल रुझानों को पकड़ नहीं पाता—फलस्वरूप ट्रेनिंग और अनदेखे डेटा—दोनों—पर प्रदर्शन कमजोर रहता है। इसके प्रमुख कारण हैं: अपर्याप्त मॉडल जटिलता, कमज़ोर फीचर्स, अपर्याप्त प्रशिक्षण, और अत्यधिक रेग्युलराइज़ेशन।

अंडरफिटिंग का निदान करने में परफ़ॉर्मेंस मैट्रिक्स जाँचना, लर्निंग कर्व्स प्लॉट करना, और मॉडलों की तुलना करना शामिल है—अक्सर कोड की मदद से। सौभाग्य से, अंडरफिटिंग ठीक करने की कई रणनीतियाँ हैं: मॉडल जटिलता बढ़ाना (बेहतर अल्गोरिद्म चुनना, फीचर विस्तार, हाइपरपैरामीटर ट्यूनिंग), फीचर्स सुधारना (फीचर इंजीनियरिंग, डेटा समृद्धि), रेग्युलराइज़ेशन समायोजन, और शक्तिशाली एंसेंबल विधियाँ—जैसा कि हमारे कोड उदाहरणों में दिखाया गया।

इन तकनीकों और अन्य विषयों को हैंड्स-ऑन उदाहरणों के साथ सीखने के लिए, हमारा Machine Learning Fundamentals in Python स्किल ट्रैक देखें।