पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग
शिक्षार्थी प्रशिक्षण और सत्यापन त्रुटि वक्र बनाएँगे, कम-फिटिंग और अधिक-फिटिंग वाले क्षेत्रों की पहचान करेंगे तथा पक्षपात-विचरण विघटन की अवधारणा समझेंगे।
पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
मशीन लर्निंग में मूलभूत तनाव
हर मशीन लर्निंग मॉडल को दो प्रतिस्पर्धी शक्तियों के बीच एक मूलभूत तनाव का सामना करना पड़ता है: डेटा में जटिल प्रतिरूपों को पकड़ने की उसकी क्षमता (लचीलापन) और उन प्रतिरूपों को नए उदाहरणों पर सामान्यीकृत करने की उसकी क्षमता (नियमितता)। बहुत अधिक लचीलापन अति-अनुकूलन की ओर ले जाता है; बहुत कम लचीलापन कम-अनुकूलन की ओर। सही संतुलन खोजना मॉडल चयन और हाइपरपैरामीटर समायोजन की मुख्य चुनौती है।
पक्षपात-विचरण संतुलन इस तनाव को गणितीय नाम और रूपरेखा देता है। मॉडल में क्या गलत है, इसका निदान करने और उसे ठीक करने का सटीक तरीका जानने के लिए इसे समझना आवश्यक है।
पक्षपात: गलत धारणाओं से उत्पन्न व्यवस्थित त्रुटि
पक्षपात वह त्रुटि है जो लर्निंग एल्गोरिदम की गलत धारणाओं से उत्पन्न होती है। अधिक पक्षपात वाला मॉडल इतना सरल होता है कि वह विशेषताओं और लक्ष्य के बीच वास्तविक संबंध को समझ नहीं पाता — आप उसे कितना भी प्रशिक्षण डेटा दें, वह व्यवस्थित रूप से गलत पूर्वानुमान लगाता है।
इसका पारंपरिक उदाहरण है: ऐसे डेटा पर सीधी रेखा फिट करने का प्रयास करना, जिसमें स्पष्ट गैर-रैखिक (वक्र) पैटर्न हो। आपके पास कितना भी डेटा हो, रेखा उस वक्र को सही ढंग से नहीं पकड़ पाएगी। मॉडल अल्प-फिटिंग कर रहा है — इसमें अधिक पक्षपात है, क्योंकि इस समस्या के लिए इसकी रैखिकता की धारणा गलत है।
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Non-linear data: y = sin(x) + noise
np.random.seed(42)
X = np.sort(np.random.uniform(0, 10, 200)).reshape(-1, 1)
y = np.sin(X.ravel()) + np.random.randn(200) * 0.2
# High-bias model: straight line on non-linear data
linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)
print(f'Linear model train MSE: {mean_squared_error(y, y_pred_linear):.3f}')
# High error even on training data -- high biasविचरण: प्रशिक्षण डेटा के प्रति संवेदनशीलता
विचरण वह त्रुटि है जो प्रशिक्षण डेटा में होने वाले छोटे-छोटे उतार-चढ़ावों के प्रति संवेदनशीलता से उत्पन्न होती है। अधिक विचरण वाला मॉडल प्रशिक्षण डेटा को — उसके शोर सहित — इतनी सटीकता से सीखता है कि प्रशिक्षण सेट में बहुत छोटे बदलाव भी बिल्कुल अलग मॉडल बना देते हैं।
इसका पारंपरिक उदाहरण है: असीमित गहराई वाला निर्णय वृक्ष, जो प्रशिक्षण के हर उदाहरण को याद कर लेता है। उसी वितरण से लिए गए किसी अलग यादृच्छिक प्रशिक्षण सेट पर यह बिल्कुल अलग वृक्ष सीखेगा। अधिक विचरण का अर्थ है कि मॉडल अति-फिटिंग कर रहा है — वह संकेत के बजाय शोर को पकड़ता है और नए डेटा पर खराब सामान्यीकरण करता है।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=200, n_features=5, random_state=42)
# Demonstrate high variance: train on two different splits
for seed in [1, 2, 3]:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=seed)
deep_tree = DecisionTreeClassifier() # unlimited depth
deep_tree.fit(X_train, y_train)
print(f'seed={seed}: train={deep_tree.score(X_train, y_train):.2f} test={deep_tree.score(X_test, y_test):.2f}')
# Large variation in test scores across seeds = high varianceपक्षपात-विचरण का विघटन
किसी भी मॉडल की अपेक्षित परीक्षण त्रुटि को गणितीय रूप से तीन पदों में विभाजित किया जा सकता है:
Expected Error = Bias² + Variance + Irreducible Noise
- Bias²: गलत धारणाओं से उत्पन्न वर्गित व्यवस्थित त्रुटि। अधिक लचीले मॉडल का उपयोग करके इसे कम किया जा सकता है।
- Variance: प्रशिक्षण डेटा के प्रति संवेदनशीलता से उत्पन्न परिवर्तनशीलता। नियमितीकरण, अधिक डेटा या सरल मॉडल का उपयोग करके इसे कम किया जा सकता है।
- Irreducible Noise: डेटा में मौजूद अंतर्निहित यादृच्छिकता, जिसे कोई भी मॉडल समाप्त नहीं कर सकता।
आप केवल पक्षपात और विचरण को नियंत्रित कर सकते हैं। लक्ष्य ऐसी मॉडल जटिलता ढूँढ़ना है जो इनके योग को न्यूनतम करे।
अल्प-फिटिंग: लक्षण और कारण
अल्प-फिटिंग तब होती है जब कोई मॉडल डेटा में मौजूद पैटर्न को पकड़ने के लिए बहुत सरल होता है। प्रशिक्षण और परीक्षण, दोनों का प्रदर्शन खराब होता है। मॉडल में अधिक पक्षपात होता है।
अल्प-फिटिंग के लक्षण:
- प्रशिक्षण सटीकता कम होती है (मॉडल प्रशिक्षण डेटा पर भी अच्छी तरह फिट नहीं हो पाता)।
- प्रशिक्षण और सत्यापन त्रुटियाँ, दोनों अधिक और एक-दूसरे के करीब होती हैं (कोई बड़ा अंतर नहीं होता)।
- अधिक प्रशिक्षण डेटा जोड़ने से महत्वपूर्ण सुधार नहीं होता।
कारण: बहुत सरल एल्गोरिदम (जैसे, गैर-रैखिक डेटा के लिए रैखिक मॉडल), बहुत अधिक नियमितीकरण, बहुत कम विशेषताएँ या मॉडल के बहुत कम पैरामीटर।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Underfitting: depth=1 is too shallow for 30-feature dataset
shallow = DecisionTreeClassifier(max_depth=1)
shallow.fit(X_train, y_train)
train_acc = shallow.score(X_train, y_train)
test_acc = shallow.score(X_test, y_test)
print(f'depth=1 (underfitting): train={train_acc:.3f} test={test_acc:.3f}')
print('Both low -- classic underfitting signature')अति-फिटिंग: लक्षण और कारण
अति-फिटिंग तब होती है जब कोई मॉडल प्रशिक्षण डेटा — उसके शोर सहित — को बहुत सटीकता से सीख लेता है और सामान्यीकरण करने में विफल रहता है। प्रशिक्षण का प्रदर्शन बहुत अधिक होता है, लेकिन परीक्षण का प्रदर्शन काफी कम होता है। मॉडल में अधिक विचरण होता है।
अति-फिटिंग के लक्षण:
- प्रशिक्षण सटीकता बहुत अधिक (लगभग 100%) होती है, जबकि परीक्षण सटीकता काफी कम होती है।
- प्रशिक्षण और सत्यापन त्रुटि वक्रों के बीच बड़ा अंतर होता है।
- अधिक प्रशिक्षण डेटा जोड़ने से परीक्षण प्रदर्शन लगातार बेहतर होता है।
कारण: बहुत जटिल मॉडल, बहुत कम प्रशिक्षण उदाहरण, बहुत अधिक विशेषताएँ (आयामों का अभिशाप) या अपर्याप्त नियमितीकरण।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Overfitting: unlimited depth memorises training data
deep = DecisionTreeClassifier() # max_depth=None
deep.fit(X_train, y_train)
train_acc = deep.score(X_train, y_train)
test_acc = deep.score(X_test, y_test)
print(f'depth=None (overfitting): train={train_acc:.3f} test={test_acc:.3f}')
print(f'Overfit gap: {train_acc - test_acc:.3f} -- classic overfitting signature')पक्षपात-विचरण वक्र का आलेखन
सबसे उपयोगी दृश्यांकन है मॉडल की जटिलता (जैसे, वृक्ष की गहराई) के आधार पर प्रशिक्षण और सत्यापन त्रुटि का आलेखन करना। जैसे-जैसे जटिलता बढ़ती है:
- प्रशिक्षण त्रुटि लगातार घटती है (या कम बनी रहती है)।
- सत्यापन त्रुटि U-आकार बनाती है: शुरुआत में अधिक (अल्प-फिटिंग), फिर घटकर इष्टतम जटिलता पर न्यूनतम होती है और उसके बाद फिर बढ़ती है (अति-फिटिंग)।
इष्टतम मॉडल जटिलता सत्यापन त्रुटि के U-आकार वाले वक्र के सबसे निचले बिंदु पर होती है।
import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
train_errors, test_errors = [], []
depths = range(1, 20)
for d in depths:
m = DecisionTreeClassifier(max_depth=d).fit(X_train, y_train)
train_errors.append(1 - m.score(X_train, y_train))
test_errors.append(1 - m.score(X_test, y_test))
plt.plot(depths, train_errors, label='Train Error')
plt.plot(depths, test_errors, label='Test Error')
plt.xlabel('Tree Depth (Model Complexity)')
plt.ylabel('Classification Error')
plt.legend()
plt.title('Bias-Variance Trade-off Curve')
plt.show()लर्निंग वक्र: डेटा के आकार से निदान
लर्निंग वक्र मॉडल की जटिलता के बजाय प्रशिक्षण सेट के आकार के आधार पर प्रशिक्षण और सत्यापन त्रुटि का आलेखन करता है। लर्निंग वक्र यह पता लगाने में मदद करते हैं कि आपके मॉडल को अधिक डेटा से लाभ होगा या नहीं:
- यदि दोनों वक्र समान रूप से अधिक त्रुटि पर मिलते हैं: अधिक पक्षपात — अधिक डेटा से मदद नहीं मिलेगी; आपको बेहतर मॉडल चाहिए।
- यदि प्रशिक्षण त्रुटि कम लेकिन सत्यापन त्रुटि अधिक है और डेटा बढ़ने पर यह अंतर घटता है: अधिक विचरण — अधिक डेटा से मदद मिलेगी; डेटा एकत्र करना जारी रखें।
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
train_sizes, train_scores, val_scores = learning_curve(
DecisionTreeClassifier(max_depth=None), # overfitting model
X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)
plt.plot(train_sizes, train_scores.mean(axis=1), label='Train')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.fill_between(train_sizes,
val_scores.mean(axis=1) - val_scores.std(axis=1),
val_scores.mean(axis=1) + val_scores.std(axis=1), alpha=0.2)
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Learning Curve')
plt.show()नियमितीकरण: विचरण को नियंत्रित करना
नियमितीकरण मूल मॉडल परिवार को बदले बिना विचरण (अति-फिटिंग) कम करने की प्रमुख तकनीक है। यह हानि फलन में मॉडल की जटिलता के लिए दंड जोड़ता है, जिससे मॉडल को शोर पर फिट होने से रोका जाता है।
नियमितीकरण की सामान्य तकनीकें:
- वृक्ष की गहराई की सीमा (
max_depth): वृक्षों को इतना गहरा होने से रोकती है कि वे प्रशिक्षण डेटा को याद कर लें। - L2 दंड (Ridge): भारों को शून्य की ओर छोटा करता है।
- L1 दंड (Lasso): कुछ भारों को ठीक शून्य कर देता है (विशेषता चयन)।
- ड्रॉपआउट (तंत्रिका नेटवर्क): प्रशिक्षण के दौरान सक्रियणों को यादृच्छिक रूप से शून्य करता है।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
# Compare regularised vs non-regularised tree
for max_depth in [None, 10, 5, 3, 2]:
model = DecisionTreeClassifier(max_depth=max_depth, random_state=42)
cv = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f'max_depth={max_depth}: CV acc = {cv.mean():.3f} (+/- {cv.std():.3f})')उचित संतुलन: इष्टतम मॉडल जटिलता
इष्टतम मॉडल जटिलता परीक्षण/सत्यापन त्रुटि वक्र के न्यूनतम बिंदु पर होती है। इसे व्यवस्थित रूप से ढूँढ़ने के लिए:
- जटिलता मानों की एक सीमा निर्धारित करें (जैसे, वृक्ष की गहराई 1 से 20 तक या नियमितीकरण पैरामीटर C का मान 0.001 से 100 तक)।
- हर मान के लिए प्रशिक्षण फोल्ड पर प्रशिक्षण दें और सत्यापन फोल्ड पर मूल्यांकन करें (स्थिरता के लिए क्रॉस-वैलिडेशन का उपयोग करें)।
- वह जटिलता चुनें जो क्रॉस-वैलिडेटेड स्कोर का सर्वोत्तम मान दे।
- उस इष्टतम जटिलता के साथ सभी प्रशिक्षण डेटा पर अंतिम मॉडल को फिर से प्रशिक्षित करें।
इस प्रक्रिया को हाइपरपैरामीटर ट्यूनिंग कहा जाता है और आप बाद के पाठ में इसे GridSearchCV से स्वचालित करेंगे।
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
best_score, best_depth = 0, 1
for depth in range(1, 25):
model = DecisionTreeClassifier(max_depth=depth, random_state=42)
score = cross_val_score(model, X, y, cv=5).mean()
if score > best_score:
best_score, best_depth = score, depth
print(f'depth={depth:2d}: CV acc = {score:.3f}')
print(f'\nOptimal depth: {best_depth} with CV acc: {best_score:.3f}')व्यावहारिक पक्षपात-विचरण त्वरित संदर्शिका
पक्षपात-विचरण की समस्याओं का निदान और समाधान करने के लिए त्वरित संदर्शिका:
- अधिक पक्षपात (अल्प-फिटिंग) के समाधान: अधिक जटिल मॉडल का उपयोग करें, अधिक विशेषताएँ जोड़ें, नियमितीकरण की तीव्रता घटाएँ, बहुपद या अंतःक्रिया विशेषताएँ बनाएँ।
- अधिक विचरण (अति-फिटिंग) के समाधान: अधिक प्रशिक्षण डेटा एकत्र करें, अधिक मजबूत नियमितीकरण लागू करें, मॉडल की जटिलता घटाएँ, समूह मॉडल (बैगिंग) का उपयोग करें, ड्रॉपआउट लागू करें (तंत्रिका नेटवर्क), शोर वाली विशेषताओं को हटाने के लिए विशेषता चयन करें।
- यह स्पष्ट न हो कि समस्या कौन-सी है: लर्निंग वक्र का आलेखन करें — यदि प्रशिक्षण और सत्यापन, दोनों त्रुटियाँ अधिक हों → पक्षपात; यदि बड़ा अंतर हो → विचरण।
त्वरित जाँच
इस पाठ में दिए गए Python के साथ मशीन लर्निंग संबंधी विचारों की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: पक्षपात अत्यधिक सरल मॉडलों से उत्पन्न व्यवस्थित त्रुटि है, जो डेटा में अल्प-फिटिंग करते हैं, विचरण प्रशिक्षण डेटा के प्रति संवेदनशीलता है, जो अति-फिटिंग और खराब सामान्यीकरण का कारण बनती है, और इष्टतम मॉडल जटिलता पक्षपात तथा विचरण के योग को न्यूनतम करती है; इसे U-आकार वाले सत्यापन त्रुटि वक्र की जाँच करके या दोनों समस्याओं में अंतर करने के लिए लर्निंग वक्रों का उपयोग करके ढूँढ़ा जाता है। अब हम एक DummyClassifier आधाररेखा बनाएँगे और न्यूनतम प्रदर्शन सीमा निर्धारित करेंगे, जिसे हर वास्तविक मॉडल को पार करना होगा।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग” पाठ निःशुल्क है?
हाँ—“पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग” में मैं क्या सीखूँगा?
शिक्षार्थी प्रशिक्षण और सत्यापन त्रुटि वक्र बनाएँगे, कम-फिटिंग और अधिक-फिटिंग वाले क्षेत्रों की पहचान करेंगे तथा पक्षपात-विचरण विघटन की अवधारणा समझेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते
- train_test_split: अनुपात, बीज और स्तरीकरण
- पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग
- आधारभूत मॉडल: DummyClassifier को हमेशा हराइए