मोडेलका सेटिङ ट्युन गर्ने · मेसिन लर्निङ, हातमा

तपाईंले तालिम दिने हरेक मोडेलमा सेटिङ हुन्छन् — max_depth, n_neighbors, alpha, n_estimators — जुन तपाईंले तालिमअघि छान्नुहुन्छ र अप्टिमाइजेसन प्रक्रियाले समायोजन गर्दैन। यी हाइपरपारामिटर हुन्, र तिनलाई राम्रोसँग छान्नु प्रायः औसत मोडेल र बलियो मोडेलबीचको फरक हुन्छ। यो खण्ड हाइपरपारामिटर स्पेस व्यवस्थित रूपमा खोज्ने र सर्वोत्तम संयोजन भेट्ने मानक scikit-learn उपकरण-पेटी हो — परीक्षण-सेट जानकारी तपाईंको छनोटमा नलीक गरी।

पारामिटर बनाम हाइपरपारामिटर

उपयोगी भेद:

पारामिटर मोडेल भित्रका नब हुन् जुन तालिमले समायोजन गर्छ — लोजिस्टिक रिग्रेसनका भार, निर्णय रुखका विभाजन, k-means का cluster केन्द्र। तपाईंले यिनलाई सिधै सेट गर्नुहुन्न; model.fit(...) ले गर्छ।
हाइपरपारामिटर मोडेलका सेटिङ हुन् जुन तपाईंले तालिमअघि छान्नुहुन्छ — max_depth, learning_rate, n_neighbors। तपाईं यिनलाई स्पष्ट रूपमा सेट गर्नुहुन्छ; तालिमले छुँदैन।

ट्युनिङ भनेको तालिम प्राप्त मोडेललाई सर्वोत्तम (उच्चतम cross-validation शुद्धता, न्यूनतम cross-validation MSE, आदि) बनाउने हाइपरपारामिटर मान भेट्ने हो।

गलत तरिका

सामान्य सुरुआती दृष्टिकोण:

# यसो नगर्नुहोस्
for depth in [3, 5, 10, 20]:
    model = DecisionTreeClassifier(max_depth=depth)
    model.fit(X_train, y_train)
    test_acc = model.score(X_test, y_test)
    print(f"depth={depth}: {test_acc:.3f}")

# अनि सर्वोत्तम गहिराइसँग तैनात गर्नुहोस्

समस्या: तपाईंले परीक्षण सेटमा ट्युन गर्नुभयो। “सर्वोत्तम” गहिराइ त्यो हो जुन विशिष्ट परीक्षण सेटमा तपाईंसँग जे छ त्यसमा सबैभन्दा राम्रो प्रदर्शन गर्छ। त्यो सङ्ख्या अब सामान्यीकरणको इमानदार अनुमान होइन — तपाईंले सिधै परीक्षण-सेट स्कोर अनुकूलन गर्नुभयो।

सही दृष्टिकोण हाइपरपारामिटरलाई अलग्गै प्रमाणीकरण सेट (वा cross-validation, राम्रो संस्करण) मा मूल्याङ्कन गर्ने, परीक्षण सेटलाई अन्तिम रिपोर्टसम्म नछुने, र त्यसपछि मात्र इमानदार प्रदर्शन जाँच्ने हो।

सही तरिका: `GridSearchCV`

scikit-learn को GridSearchCV ले भारी उठाउँछ:

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth": [3, 5, 10, None],
    "min_samples_split": [2, 5, 10],
}

grid = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,           # तालिम डाटामा 5-fold cross-validation
    scoring="accuracy",
    n_jobs=-1,      # सबै CPU कोर प्रयोग गर्नुहोस्
    verbose=1,
)

grid.fit(X_train, y_train)

print(f"Best params: {grid.best_params_}")
print(f"Best CV score: {grid.best_score_:.3f}")

# अछूता परीक्षण सेटमा इमानदार मूल्याङ्कन, एक पटक, अन्त्यमा
print(f"Test accuracy: {grid.score(X_test, y_test):.3f}")

के भर्खर भयो:

GridSearchCV ले हाइपरपारामिटरको हरेक संयोजनका लागि नयाँ मोडेल तालिम दिन्छ (यहाँ, 3×4×3 = 36 संयोजन)।
हरेक संयोजनका लागि, यसले तालिम डाटामा 5-fold cross-validation गर्छ, 5 folds मा औसत स्कोर गणना गर्दै।
यसले सर्वोत्तम औसत CV स्कोर भएको संयोजन राख्छ।
grid.best_estimator_ तालिम डाटा सबैमा ती सर्वोत्तम हाइपरपारामिटरसँग तालिम दिइएको मोडेल हो।
तपाईं परीक्षण सेटमा एक पटक अन्त्यमा मूल्याङ्कन गर्नुहुन्छ। परीक्षण सेट ट्युनिङका बेला कहिल्यै छोइएको थिएन।

यो ट्युनिङका लागि सुनौलो मानक हो। एउटै तल्लो छेउ: धेरै हाइपरपारामिटर र धेरै मानसँग, ग्रिड छिटो बढ्छ। 5-fold CV सँग 36-संयोजन ग्रिडले 180 मोडेल तालिम दिन्छ। 1000-संयोजन ग्रिडले 5000 मोडेल तालिम दिन्छ। ठूला डाटासेटमा, यो महँगो हुन्छ।

`RandomizedSearchCV` — जब ग्रिड धेरै ठूलो हुन्छ

जब हाइपरपारामिटर स्पेस ठूलो हुन्छ, RandomizedSearchCV ले हरेक कोसिस गर्नुको सट्टा अनियमित संयोजनको नमुना लिन्छ:

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

param_dist = {
    "n_estimators": randint(50, 500),
    "max_depth": randint(3, 20),
    "min_samples_split": randint(2, 20),
    "max_features": uniform(0.1, 0.9),
}

search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=50,        # 50 अनियमित संयोजन कोसिस गर्नुहोस्
    cv=5,
    scoring="accuracy",
    n_jobs=-1,
    random_state=42,
)

search.fit(X_train, y_train)
print(search.best_params_)

प्रति-सहज ज्ञानले, 50 प्रयासको RandomizedSearch ले प्रायः 200+ प्रयासको पूर्ण ग्रिड जस्तै लगभग उही सर्वोत्तम हाइपरपारामिटर भेट्छ। कारण: अधिकांश हाइपरपारामिटरमा केही मुख्य मान हुन्छन् जहाँ मोडेल राम्रोसँग प्रदर्शन गर्छ, र 50 अनियमित प्रयासले सामान्यतया कम्तीमा एकमा (वा नजिकै) पुग्न पर्याप्त हुन्छन्।

अधिकांश परियोजनाका लागि, 30-50 पुनरावृत्तिसहित RandomizedSearchCV GridSearchCV भन्दा बढी व्यवहारिक छ। जब तपाईंसँग सानो, राम्रोसँग बुझिएको हाइपरपारामिटर स्पेस छ तब GridSearch प्रयोग गर्नुहोस्।

कुन हाइपरपारामिटर ट्युन गर्ने?

यो पाठ्यक्रमका मोडेलहरूका लागि छोटो मार्गदर्शक:

Logistic regression: C (regularisation शक्तिको उल्टो, सानो = अधिक regularisation), penalty (l1 vs l2), class_weight।

Random forest: n_estimators (अधिक रुख = राम्रो, घट्दो प्रतिफलसँग), max_depth (overfitting नियन्त्रण गर्छ), min_samples_split, max_features (हरेक विभाजनमा हरेक रुखले विचार गर्ने फिचरहरूको सङ्ख्या — forest विविधताका लागि प्रमुख नब)।

Gradient boosting (GradientBoostingClassifier वा xgboost): learning_rate, n_estimators, max_depth। यी तीन बलियोसँग अन्तरक्रिया गर्छन्; सँगै ट्युन गर्नुहोस्।

K-NN: n_neighbors, weights (uniform vs distance), metric।

Decision tree: max_depth, min_samples_split, min_samples_leaf।

अधिकांश tabular परियोजनाका लागि, तपाईंलाई सबै हाइपरपारामिटर ट्युन गर्नु पर्दैन। तपाईंको मोडेल कक्षाका लागि सबैभन्दा महत्त्वपूर्ण 2-3 छान्नु 80% gain समात्न पर्याप्त हुन्छ।

कार्यगत उदाहरण — random forest ट्युन गर्ने

परीक्षण शुद्धता 0.78 भएको पूर्वनिर्धारित random forest बाट सुरु गर्दै, हामी ट्युन गर्नेछौं र कति टाढा पुग्न सक्छौं हेर्नेछौं:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint
import time

# आधार
default = RandomForestClassifier(random_state=42)
default.fit(X_train, y_train)
print(f"Default: train={default.score(X_train, y_train):.3f}  test={default.score(X_test, y_test):.3f}")

# ट्युन गरिएको
param_dist = {
    "n_estimators": randint(100, 500),
    "max_depth": randint(3, 30),
    "min_samples_split": randint(2, 20),
    "min_samples_leaf": randint(1, 10),
    "max_features": ["sqrt", "log2", 0.3, 0.5],
}

start = time.time()
search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=40,
    cv=5,
    scoring="f1",
    n_jobs=-1,
    random_state=42,
)
search.fit(X_train, y_train)
elapsed = time.time() - start

print(f"Search took {elapsed:.1f}s")
print(f"Best params: {search.best_params_}")
print(f"Best CV F1: {search.best_score_:.3f}")
print(f"Tuned test F1: {search.score(X_test, y_test):.3f}")

सामान्य नतिजा:

Default: train=0.998  test=0.778
Search took 67.4s
Best params: {'max_depth': 11, 'max_features': 'sqrt', 'min_samples_leaf': 4, 'min_samples_split': 14, 'n_estimators': 312}
Best CV F1: 0.804
Tuned test F1: 0.811

ट्युन गरिएको मोडेल परीक्षण F1 मा 3 प्रतिशत बिन्दु राम्रो छ, train/test खाडल बन्द भयो (कम overfitting), र मोडेल बढी बलियो छ। साठी सेकेन्ड कम्प्युट समयले 3-5 अङ्क वास्तविक प्रदर्शन किन्यो।

Note

व्यवहारिक नोट: हाइपरपारामिटर ट्युनिङ धेरै नब भएका मोडेलहरू (random forests, gradient boosting) मा सबैभन्दा मूल्यवान् छ र थोरै नब भएका मोडेलहरू (रेखीय रिग्रेसन) मा कम मूल्यवान् छ। Gradient boosting ट्युन गर्दा तपाईं 78% बाट 86% मा जान सक्नुहुन्छ। रेखीय रिग्रेसन ट्युन गर्दा विरलै 1-2 प्रतिशत बिन्दुभन्दा बढी सर्छ। तदनुसार प्रयास आवंटन गर्नुहोस्।

ट्युनिङ Pipeline भित्र काम गर्छ

तपाईं step_name__hyperparameter सिन्ट्याक्स प्रयोग गरेर Pipeline भित्र कुनै पनि चरणको हाइपरपारामिटर ट्युन गर्न सक्नुहुन्छ:

pipeline = Pipeline([
    ("scale", StandardScaler()),
    ("clf", LogisticRegression(max_iter=1000)),
])

param_grid = {
    "clf__C": [0.01, 0.1, 1.0, 10.0, 100.0],
    "clf__penalty": ["l1", "l2"],
    "clf__solver": ["liblinear"],
}

grid = GridSearchCV(pipeline, param_grid, cv=5, scoring="f1")
grid.fit(X_train, y_train)

डबल underscore (clf__C) ले ग्रिड खोजलाई “pipeline को clf चरणको C हाइपरपारामिटर ट्युन गर्नुहोस्” भन्छ। यसले तपाईंलाई पूर्व-प्रशोधन र ट्युनिङलाई लीकेजबिना सफा रूपमा संयोजन गर्न दिन्छ।

समय बजेटबारे टिप्पणी

हाइपरपारामिटर खोज तपाईंको कम्प्युट बजेटले सीमित हुन्छ। उपयोगी नियम-अङ्गुष्ठ:

छिटो अन्वेषण: 20-30 पुनरावृत्तिसहित RandomizedSearchCV, 5-fold CV। ल्यापटपमा घण्टौं-देखि-रातभर।
उत्पादन मोडेल: छिटो अन्वेषणबाट पहिचान गरिएका हाइपरपारामिटरको केन्द्रित उपसमूहमा GridSearchCV (वा 100+ पुनरावृत्तिसँग बढी ध्यानले RandomizedSearch)।
धेरै ठूला मोडेल / धेरै लामो तालिम: सबै ट्युन नगर्नुहोस्। प्रकाशित configurations बाट पूर्वनिर्धारित प्रयोग गर्नुहोस्, सबैभन्दा महत्त्वपूर्ण एक वा दुई हाइपरपारामिटर ट्युन गर्नुहोस्, र थप ट्युनिङमा घट्दो प्रतिफल छ स्वीकार्नुहोस्।

ट्युनिङ-बजेट वार्ता आफ्नो टिम र stakeholders सँग स्पष्ट हुन योग्य छ।

आफ्नो बुझाइ जाँच्नुहोस्

Quick check

—

एक टिम सदस्यले फरक max_depth मानहरूमा `for` लूप चलाउँछन्, हरेक मोडेललाई तालिम सेटमा तालिम दिने र परीक्षण सेटमा स्कोर गर्ने। तिनले उच्चतम परीक्षण स्कोरसहितको गहिराइ छान्छन् र त्यो परीक्षण स्कोरलाई 'मोडेलको शुद्धता' का रूपमा रिपोर्ट गर्छन्। के गलत छ?

केही होइन — यसरी ट्युनिङ काम गर्छ।
परीक्षण सेटविरुद्ध हाइपरपारामिटर ट्युन गरेर, रिपोर्ट गरिएको परीक्षण स्कोर अब सामान्यीकरणको इमानदार अनुमान होइन — यो *उच्च भएकोमा छानिएको* परीक्षण सेटको स्कोर हो। मोडेल वास्तवमै नदेखिएको डाटामा त्यत्तिकै राम्रोसँग प्रदर्शन नगर्न सक्छ। उपचार: हाइपरपारामिटर ट्युन गर्न तालिम सेटमा cross-validation प्रयोग गर्नुहोस् (जस्तै cv=5 सँग GridSearchCV वा RandomizedSearchCV), र परीक्षण सेटमा केवल एक पटक स्कोर गर्नुहोस्, धेरै अन्त्यमा।
for लूपले अधिक गहिराइ मानहरूमा iterate गर्नुपर्छ।
ठूलो मोडेल प्रयोग गर्नुहोस्।