మీరు మీ మొదటి మెషిన్ లెర్నింగ్ మోడల్కు శిక్షణ ఇచ్చారు. ఇది మీ శిక్షణ డేటాపై అద్భుతంగా పనిచేస్తుంది - 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
ధృవీకరణ సెట్ మీ ముందస్తు హెచ్చరిక వ్యవస్థ. శిక్షణ ఖచ్చితత్వం మెరుగవుతూనే ఉంటుంది, అయితే ధ్రువీకరణ ఖచ్చితత్వం పీఠభూములు లేదా పడిపోతే, మీరు అతిగా సరిపోతారు.
రెగ్యులరైజేషన్ లాస్ ఫంక్షన్కు పెనాల్టీని జోడిస్తుంది, ఇది మోడల్ను మితిమీరిన సంక్లిష్ట నమూనాలను నేర్చుకోకుండా నిరుత్సాహపరుస్తుంది.
L2 రెగ్యులరైజేషన్ (రిడ్జ్) పెద్ద బరువులకు జరిమానా విధిస్తుంది:
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)
మోడల్కు శబ్దాన్ని గుర్తుంచుకోవడం మరింత డేటా కష్టతరం చేస్తుంది - సరిగ్గా సరిపోయేలా చాలా ఎక్కువ ఉంది. డేటా సేకరణ ఖరీదైనప్పుడు, డేటా ఆగ్మెంటేషన్ (ఇప్పటికే ఉన్న ఉదాహరణల సవరించిన కాపీలను సృష్టించడం) సహాయపడుతుంది.
కొన్నిసార్లు సరైన పరిష్కారం సమస్య కోసం తక్కువ సంక్లిష్ట నమూనాను ఎంచుకోవడం.
చిన్న డేటాసెట్లతో, యాదృచ్ఛికత కారణంగా ఒకే రైలు/వాల్ స్ప్లిట్ తప్పుదారి పట్టించవచ్చు. K-ఫోల్డ్ క్రాస్ ధ్రువీకరణ మరింత నమ్మదగిన అంచనాను ఇస్తుంది:
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% మాత్రమే. ఇది ఏమి సూచిస్తుంది?
సైన్ ఇన్ చర్చలో చేరండి