आपने अपना पहला मशीन लर्निंग मॉडल प्रशिक्षित कर लिया है। यह आपके प्रशिक्षण डेटा पर शानदार प्रदर्शन करता है - 98% सटीकता! आप इसे नए डेटा पर परीक्षण करते हैं और यह बिखर जाता है: 61% सटीकता। क्या गलत हो गया?
लगभग निश्चित रूप से, आपका मॉडल ओवरफिट है। यह मशीन लर्निंग में दो सबसे आम विफलता तरीकों में से एक है, और इसे समझना - इसके विपरीत, अंडरफिटिंग के साथ - ऐसे मॉडल बनाने के लिए आवश्यक है जो वास्तव में वास्तविक दुनिया में काम करते हैं।
उदाहरणों में गोता लगाने से पहले, इन अवधारणाओं के पीछे के सैद्धांतिक ढांचे को समझने में मदद मिलती है: पूर्वाग्रह-विचरण व्यापार।
प्रत्येक मॉडल पूर्वानुमान त्रुटियाँ करता है। उन त्रुटियों को तीन भागों में विघटित किया जा सकता है:
Total Error = Bias² + Variance + Irreducible Noise
पूर्वाग्रह मॉडल में गलत धारणाओं से हुई त्रुटि है। एक उच्च-पूर्वाग्रह मॉडल बहुत सरल है - यह व्यवस्थित रूप से डेटा में वास्तविक पैटर्न को याद करता है।
विचरण प्रशिक्षण डेटा में संवेदनशीलता से लेकर छोटे उतार-चढ़ाव तक की त्रुटि है। एक उच्च-विचरण मॉडल बहुत जटिल है - यह अंतर्निहित पैटर्न को सीखने के बजाय, इसके शोर सहित प्रशिक्षण डेटा को याद रखता है।
अघुलनशील शोर डेटा में प्राकृतिक यादृच्छिकता है जिसे कोई भी मॉडल समाप्त नहीं कर सकता है।
ट्रेडऑफ़: पूर्वाग्रह कम करने से विचरण बढ़ता है, और इसके विपरीत। मशीन लर्निंग प्रैक्टिशनर के रूप में आपका काम उपयुक्त स्थान ढूंढना है।
अंडरफ़िटिंग तब होता है जब आपका मॉडल डेटा में वास्तविक पैटर्न को पकड़ने के लिए बहुत सरल होता है। यह प्रशिक्षण डेटा और नए डेटा दोनों पर खराब प्रदर्शन करता है।
कल्पना कीजिए कि आपके पास आकार के आधार पर घर की कीमतें दिखाने वाला डेटा है। सच्चा संबंध मोटे तौर पर एक सौम्य वक्र है - कीमतें आकार के साथ बढ़ती हैं, लेकिन शीर्ष स्तर पर कुछ स्थिरता के साथ।
यदि आप इस डेटा में एक सीधी क्षैतिज रेखा फिट करते हैं:
# Underfitting: overly simple model
from sklearn.linear_model import LinearRegression
import numpy as np
# True relationship is quadratic, but we're fitting a simple mean
model = DummyRegressor(strategy='mean')
model.fit(X_train, y_train)
# Training accuracy: 55%
# Test accuracy: 54%
# Both are bad — classic underfitting
मॉडल घर के आकार और कीमत के बीच वास्तविक संबंध को नजरअंदाज करता है। इससे कोई फर्क नहीं पड़ता कि आप इसे प्रशिक्षण डेटा या नया डेटा दिखाते हैं - यह किसी भी तरह से गलत है।
साइन इन करें चर्चा में शामिल हों
ओवरफिटिंग तब होता है जब आपका मॉडल प्रशिक्षण डेटा को बहुत अच्छी तरह से सीखता है - जिसमें इसका शोर और यादृच्छिक भिन्नता भी शामिल है - और नए उदाहरणों को सामान्यीकृत करने में विफल रहता है।
समान घर मूल्य डेटा को फ़िट करने के लिए 15-डिग्री बहुपद का उपयोग करना:
# Overfitting: overly complex model
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
# Degree-15 polynomial — wildly complex for this problem
model = make_pipeline(PolynomialFeatures(15), LinearRegression())
model.fit(X_train, y_train)
train_score = model.score(X_train, y_train) # 0.99 — looks amazing!
test_score = model.score(X_test, y_test) # 0.43 — terrible on new data
बहुपद ने हर प्रशिक्षण बिंदु से गुजरने के लिए खुद को गांठों में बदल लिया है - जिसमें शोरगुल वाले आउटलेर्स भी शामिल हैं। इसने अंतर्निहित पैटर्न को सीखने के बजाय प्रशिक्षण सेट को याद कर लिया है। अनदेखे डेटा पर, यह बेकार है।
ओवरफिटिंग का पता लगाने के लिए एक मौलिक उपकरण आपके डेटा को तीन सेटों में विभाजित करना है:
from sklearn.model_selection import train_test_split
# First split: hold out 20% as the final test set
X_train_val, X_test, y_train_val, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# Second split: hold out 20% of remaining as validation set
X_train, X_val, y_train, y_val = train_test_split(
X_train_val, y_train_val, test_size=0.25, random_state=42
)
# Result: 60% train / 20% validation / 20% test
सत्यापन सेट आपकी प्रारंभिक चेतावनी प्रणाली है। यदि प्रशिक्षण सटीकता में सुधार होता रहता है लेकिन सत्यापन सटीकता स्थिर या गिरती है, तो आप ओवरफिटिंग कर रहे हैं।
नियमितीकरण हानि फ़ंक्शन में एक दंड जोड़ता है जो मॉडल को अत्यधिक जटिल पैटर्न सीखने से हतोत्साहित करता है।
एल2 नियमितीकरण (रिज) बड़े वजन को दंडित करता है:
from sklearn.linear_model import Ridge
model = Ridge(alpha=1.0) # alpha controls regularisation strength
model.fit(X_train, y_train)
L1 नियमितीकरण (लासो) सुविधा चयन करते हुए कुछ भारों को शून्य तक ले जा सकता है:
from sklearn.linear_model import Lasso
model = Lasso(alpha=0.1)
model.fit(X_train, y_train)
प्रशिक्षण के दौरान, न्यूरॉन्स का अनुपात बेतरतीब ढंग से "ड्रॉप आउट" (शून्य पर सेट):
import torch.nn as nn
model = nn.Sequential(
nn.Linear(128, 64),
nn.ReLU(),
nn.Dropout(p=0.5), # 50% of neurons randomly deactivated during training
nn.Linear(64, 1)
)
यह न्यूरॉन्स को सह-अनुकूलन से रोकता है और नेटवर्क को अधिक मजबूत, वितरित प्रतिनिधित्व सीखने के लिए मजबूर करता है।
प्रशिक्षण के दौरान सत्यापन हानि की निगरानी करें और जब यह बढ़ने लगे तो रोकें:
from tensorflow.keras.callbacks import EarlyStopping
early_stop = EarlyStopping(
monitor='val_loss',
patience=5, # stop after 5 epochs without improvement
restore_best_weights=True
)
model.fit(X_train, y_train,
validation_data=(X_val, y_val),
callbacks=[early_stop],
epochs=1000)
अधिक डेटा मॉडल के लिए शोर को याद रखना कठिन बना देता है - सटीक रूप से फिट होने के लिए बस बहुत कुछ है। जब डेटा संग्रह महंगा हो, तो डेटा संवर्द्धन (मौजूदा उदाहरणों की संशोधित प्रतियां बनाना) मदद कर सकता है।
कभी-कभी समस्या के लिए कम जटिल मॉडल चुनना ही सही समाधान होता है।
छोटे डेटासेट के साथ, एकल ट्रेन/वैल विभाजन यादृच्छिकता के कारण भ्रामक हो सकता है। के-फ़ोल्ड क्रॉस-वैलिडेशन अधिक विश्वसनीय अनुमान देता है:
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100)
# 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"Mean accuracy: {scores.mean():.3f} ± {scores.std():.3f}")
# Mean accuracy: 0.847 ± 0.023
डेटा को 5 तहों में विभाजित किया गया है; मॉडल 4 पर प्रशिक्षित होता है और 1 पर मान्य होता है, हर बार घूमता है। अंतिम स्कोर सभी 5 का औसत है - एकल विभाजन से कहीं अधिक विश्वसनीय।
एक मॉडल प्रशिक्षण डेटा पर 99% सटीकता प्राप्त करता है लेकिन परीक्षण डेटा पर केवल 62% सटीकता प्राप्त करता है। यह क्या दर्शाता है?