उत्कृष्ट मशीन लर्निंग मॉडल्स के लिए GridSearchCV में महारत हासिल करना: एक व्यापक मार्गदर्शिका

विषय सूची

GridSearchCV का परिचय
डेटासेट को समझना
डेटा प्रीप्रोसेसिंग
- गुम डेटा को संभालना
- श्रेणीकृत चर को एन्कोड करना
- फ़ीचर चयन
- फ़ीचर स्केलिंग
GridSearchCV को लागू करना
- StratifiedKFold के साथ क्रॉस-वैलिडेशन स्थापित करना
- GridSearchCV पैरामीटर की व्याख्या
मशीन लर्निंग मॉडल्स का निर्माण और ट्यूनिंग
- K-Nearest Neighbors (KNN)
- लॉजिस्टिक रिग्रेशन
- गॉसियन नाइव बेयस
- सपोर्ट वेक्टर मशीन (SVM)
- डिसीजन ट्रीज़
- रैंडम फॉरेस्ट
- AdaBoost
- XGBoost
प्रदर्शन विश्लेषण
GridSearchCV का अनुकूलन
निष्कर्ष और अगले कदम

1. GridSearchCV का परिचय

GridSearchCV एक तकनीक है जो मशीन लर्निंग में हाइपरपैरामीटर ट्यूनिंग के लिए उपयोग की जाती है। हाइपरपैरामीटर महत्वपूर्ण पैरामीटर होते हैं जो प्रशिक्षण प्रक्रिया और मॉडल की संरचना को नियंत्रित करते हैं। नियमित पैरामीटरों के विपरीत, हाइपरपैरामीटर प्रशिक्षण चरण शुरू होने से पहले सेट किए जाते हैं और मॉडल के प्रदर्शन पर महत्वपूर्ण प्रभाव डाल सकते हैं।

GridSearchCV निर्दिष्ट पैरामीटर ग्रिड के माध्यम से थकाऊ तरीके से खोज कर कार्य करता है, प्रत्येक संयोजन को क्रॉस-वैलिडेशन का उपयोग करके मूल्यांकन करता है, और चुने हुए मीट्रिक (जैसे, F1-स्कोर, सटीकता) के आधार पर सबसे अच्छे प्रदर्शन वाला संयोजन पहचानता है।

क्यों GridSearchCV?

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

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

2. डेटासेट को समझना

इस प्रदर्शन के लिए, हम एक एयरलाइन यात्री संतुष्टि पर केंद्रित डेटासेट का उपयोग करते हैं। डेटासेट मूल रूप से 100,000 से अधिक रिकॉर्ड्स पर आधारित है, लेकिन इस उदाहरण में इसे 5,000 रिकॉर्ड्स तक सीमित किया गया है ताकि यह व्यवहार्य हो सके। प्रत्येक रिकॉर्ड में 23 विशेषताएँ शामिल हैं, जिनमें जनसांख्यिकीय जानकारी, उड़ान विवरण और संतुष्टि स्तर शामिल हैं।

डेटासेट का नमूना

लिंग	ग्राहक प्रकार	आयु	यात्रा का प्रकार	कक्षा	फ्लाइट दूरी	…	संतुष्टि
महिला	वफादार ग्राहक	41	व्यक्तिगत यात्रा	इको प्लस	746	…	न्यूट्रल या असंतुष्ट
पुरुष	वफादार ग्राहक	53	व्यापार यात्रा	बिजनेस	3095	…	संतुष्ट
पुरुष	अवफादार ग्राहक	21	व्यापार यात्रा	इको	125	…	संतुष्ट
…	…	…	…	…	…	…	…

लक्ष्य चर संतुष्टि है, जिसे “संतुष्ट” या “न्यूट्रल या असंतुष्ट” के रूप में श्रेणीबद्ध किया गया है।

3. डेटा प्रीप्रोसेसिंग

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

गुम डेटा को संभालना

संख्यात्मक डेटा: संख्यात्मक स्तंभों में गुम मानों को मीन इम्प्यूटेशन रणनीति का उपयोग करके संबोधित किया जाता है।

from sklearn.impute import SimpleImputer
import numpy as np

# Initialize imputer for numeric data
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

from sklearn.impute import SimpleImputer

import numpy as np

# Initialize imputer for numeric data

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Identify numerical columns

numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Fit and transform the data

imp_mean.fit(X.iloc[:, numerical_cols])

X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

श्रेणीकृत डेटा: स्ट्रिंग-आधारित स्तंभों के लिए, सबसे सामान्य मान इम्प्यूटेशन रणनीति को लागू किया जाता है।

# Initialize imputer for categorical data
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Identify string columns
string_cols = list(np.where((X.dtypes == object))[0])

# Fit and transform the data
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])

# Initialize imputer for categorical data

imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Identify string columns

string_cols = list(np.where((X.dtypes == object))[0])

# Fit and transform the data

imp_freq.fit(X.iloc[:, string_cols])

X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])

श्रेणीकृत चर को एन्कोड करना

श्रेणीकृत चर को लेबल एन्कोडिंग और वन-हॉट एन्कोडिंग का उपयोग करके संख्यात्मक प्रारूप में परिवर्तित किया जाता है।

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)

def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_vals = len(pd.unique(X[X.columns[col]]))
        if unique_vals == 2 or unique_vals > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
                
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

# Apply encoding
X = EncodingSelection(X)

from sklearn.preprocessing import LabelEncoder, OneHotEncoder

from sklearn.compose import ColumnTransformer

def LabelEncoderMethod(series):

le = LabelEncoder()

return le.fit_transform(series)

def OneHotEncoderMethod(indices, data):

columnTransformer = ColumnTransformer(

[('encoder', OneHotEncoder(), indices)],

remainder='passthrough'

)

return columnTransformer.fit_transform(data)

def EncodingSelection(X, threshold=10):

string_cols = list(np.where((X.dtypes == object))[0])

one_hot_encoding_indices = []

for col in string_cols:

unique_vals = len(pd.unique(X[X.columns[col]]))

if unique_vals == 2 or unique_vals > threshold:

X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])

else:

one_hot_encoding_indices.append(col)

X = OneHotEncoderMethod(one_hot_encoding_indices, X)

return X

# Apply encoding

X = EncodingSelection(X)

फ़ीचर चयन

मॉडल के प्रदर्शन को बढ़ाने और गणनात्मक जटिलता को कम करने के लिए, SelectKBest को ची-स्क्वायर (χ²) सांख्यिकी के साथ उपयोग किया जाता है ताकि शीर्ष 10 विशेषताओं का चयन किया जा सके।

from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Fit SelectKBest
X_selected = kbest.fit_transform(X_scaled, y)

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

# Initialize SelectKBest

kbest = SelectKBest(score_func=chi2, k=10)

# Scale features

scaler = MinMaxScaler()

X_scaled = scaler.fit_transform(X)

# Fit SelectKBest

X_selected = kbest.fit_transform(X_scaled, y)

फ़ीचर स्केलिंग

फ़ीचर स्केलिंग यह सुनिश्चित करती है कि सभी फीचर्स मॉडल के प्रदर्शन में समान रूप से योगदान दें।

from sklearn.preprocessing import StandardScaler

# Initialize StandardScaler
sc = StandardScaler(with_mean=False)

# Fit and transform the training data
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

from sklearn.preprocessing import StandardScaler

# Initialize StandardScaler

sc = StandardScaler(with_mean=False)

# Fit and transform the training data

sc.fit(X_train)

X_train = sc.transform(X_train)

X_test = sc.transform(X_test)

4. GridSearchCV को लागू करना

डेटा प्रीप्रोसेसिंग के साथ, अगला कदम विभिन्न मशीन लर्निंग मॉडलों के लिए हाइपरपैरामीटर ट्यून करने के लिए GridSearchCV स्थापित करना है।

StratifiedKFold के साथ क्रॉस-वैलिडेशन स्थापित करना

StratifiedKFold यह सुनिश्चित करता है कि क्रॉस-वैलिडेशन के प्रत्येक फोल्ड में क्लास लेबल का समान अनुपात बना रहे, जो असंतुलित डेटासेट्स के लिए महत्वपूर्ण है।

from sklearn.model_selection import StratifiedKFold

# Initialize StratifiedKFold
cv = StratifiedKFold(n_splits=2)

from sklearn.model_selection import StratifiedKFold

# Initialize StratifiedKFold

cv = StratifiedKFold(n_splits=2)

GridSearchCV पैरामीटर की व्याख्या

Estimator: मशीन लर्निंग मॉडल जिसे ट्यून किया जाना है।
Param_grid: एक शब्दकोश जो हाइपरपैरामीटर और उनके संबंधित मानों को परिभाषित करता है जिन्हें खोजा जाना है।
Verbose: वर्बोसिटी को नियंत्रित करता है; प्रगति दिखाने के लिए इसे 1 पर सेट करें।
Scoring: प्रदर्शन मीट्रिक जिसे ऑप्टिमाइज़ करना है, उदाहरण के लिए, ‘f1’।
n_jobs: उपयोग करने के लिए CPU कोर की संख्या; इसे -1 पर सेट करने से सभी उपलब्ध कोर उपयोग में लाए जाते हैं।

from sklearn.model_selection import GridSearchCV

# Example: Setting up GridSearchCV for KNN
from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier()
params = {
    'n_neighbors': [4, 5, 6, 7],
    'leaf_size': [1, 3, 5],
    'algorithm': ['auto', 'kd_tree'],
    'weights': ['uniform', 'distance']
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

from sklearn.model_selection import GridSearchCV

# Example: Setting up GridSearchCV for KNN

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier()

params = {

'n_neighbors': [4, 5, 6, 7],

'leaf_size': [1, 3, 5],

'algorithm': ['auto', 'kd_tree'],

'weights': ['uniform', 'distance']

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

5. मशीन लर्निंग मॉडल्स का निर्माण और ट्यूनिंग

5.1 K-Nearest Neighbors (KNN)

KNN एक सरल फिर भी प्रभावी एल्गोरिदम है जो वर्गीकरण कार्यों के लिए उपयुक्त है। GridSearchCV शेज़रों की आदर्श संख्या, लीफ साइज, एल्गोरिदम, और वजन योजना का चयन करने में मदद करता है।

# Fit GridSearchCV
grid_search_cv.fit(X_train, y_train)

# Best parameters
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

# Fit GridSearchCV

grid_search_cv.fit(X_train, y_train)

# Best parameters

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator KNeighborsClassifier(leaf_size=1)
Best score 0.8774673417446253

1 2	Best Estimator KNeighborsClassifier(leaf_size=1) Best score 0.8774673417446253

5.2 लॉजिस्टिक रिग्रेशन

लॉजिस्टिक रिग्रेशन द्विआधारी परिणाम की संभावना को मॉडल करता है। GridSearchCV सॉल्वर प्रकार, पेनल्टी, और नियमितीकरण की ताकत को ट्यून करता है।

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
params = {
    'solver': ['newton-cg', 'lbfgs', 'liblinear'],
    'penalty': ['l1', 'l2'],
    'C': [100, 10, 1.0, 0.1, 0.01]
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

params = {

'solver': ['newton-cg', 'lbfgs', 'liblinear'],

'penalty': ['l1', 'l2'],

'C': [100, 10, 1.0, 0.1, 0.01]

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator LogisticRegression(C=0.01, solver='newton-cg')
Best score 0.8295203666687819

1 2	Best Estimator LogisticRegression(C=0.01, solver='newton-cg') Best score 0.8295203666687819

5.3 गॉसियन नाइव बेयस

गॉसियन नाइव बेयस मानता है कि फीचर्स सामान्य वितरण का अनुसरण करते हैं। इसमें कम हाइपरपैरामीटर होते हैं, जिससे यह GridSearchCV के लिए कम गहन होता है।

from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report

model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
y_pred = model_GNB.predict(X_test)

print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))

from sklearn.naive_bayes import GaussianNB

from sklearn.metrics import accuracy_score, classification_report

model_GNB = GaussianNB()

model_GNB.fit(X_train, y_train)

y_pred = model_GNB.predict(X_test)

print(accuracy_score(y_pred, y_test))

print(classification_report(y_pred, y_test))

आउटपुट:

0.84
              precision    recall  f1-score   support

           0       0.86      0.86      0.86       564
           1       0.82      0.81      0.82       436

    accuracy                           0.84      1000
   macro avg       0.84      0.84      0.84      1000
weighted avg       0.84      0.84      0.84      1000

0.84

precision recall f1-score support

0 0.86 0.86 0.86 564

1 0.82 0.81 0.82 436

accuracy 0.84 1000

macro avg 0.84 0.84 0.84 1000

weighted avg 0.84 0.84 0.84 1000

5.4 सपोर्ट वेक्टर मशीन (SVM)

SVMs बहुमुखी वर्गीकर्ता हैं जो रैखिक और गैर-रैखिक डेटा दोनों पर अच्छी तरह काम करते हैं। GridSearchCV कर्नेल प्रकार, नियमितीकरण पैरामीटर C, डिग्री, गुणांक coef0, और कर्नेल गुणांक gamma को ट्यून करता है।

from sklearn.svm import SVC

model = SVC()
params = {
    'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
    'C': [1, 5, 10],
    'degree': [3, 8],
    'coef0': [0.01, 10, 0.5],
    'gamma': ['auto', 'scale']
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

from sklearn.svm import SVC

model = SVC()

params = {

'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],

'C': [1, 5, 10],

'degree': [3, 8],

'coef0': [0.01, 10, 0.5],

'gamma': ['auto', 'scale']

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator SVC(C=5, coef0=0.01)
Best score 0.9168629045108148

1 2	Best Estimator SVC(C=5, coef0=0.01) Best score 0.9168629045108148

5.5 डिसीजन ट्रीज़

डिसीजन ट्रीज़ डेटा को फीचर मूल्यों के आधार पर विभाजित करके भविष्यवाणियाँ करती हैं। GridSearchCV पैरामीटर जैसे अधिकतम लीफ नोड्स की संख्या और आंतरिक नोड को विभाजित करने के लिए आवश्यक न्यूनतम नमूना संख्या को अनुकूलित करता है।

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
params = {
    'max_leaf_nodes': list(range(2, 100)),
    'min_samples_split': [2, 3, 4]
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

params = {

'max_leaf_nodes': list(range(2, 100)),

'min_samples_split': [2, 3, 4]

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator DecisionTreeClassifier(max_leaf_nodes=29, min_samples_split=4)
Best score 0.9098148654372425

1 2	Best Estimator DecisionTreeClassifier(max_leaf_nodes=29, min_samples_split=4) Best score 0.9098148654372425

5.6 रैंडम फॉरेस्ट

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

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()
params = {
    'bootstrap': [True],
    'max_depth': [80, 90, 100, 110],
    'max_features': [2, 3],
    'min_samples_leaf': [3, 4, 5],
    'min_samples_split': [8, 10, 12],
    'n_estimators': [100, 200, 300, 1000]
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()

params = {

'bootstrap': [True],

'max_depth': [80, 90, 100, 110],

'max_features': [2, 3],

'min_samples_leaf': [3, 4, 5],

'min_samples_split': [8, 10, 12],

'n_estimators': [100, 200, 300, 1000]

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator RandomForestClassifier(max_leaf_nodes=82, min_samples_split=4)
Best score 0.9225835186933584

1 2	Best Estimator RandomForestClassifier(max_leaf_nodes=82, min_samples_split=4) Best score 0.9225835186933584

5.7 AdaBoost

AdaBoost कई कमजोर वर्गीकर्ताओं को एक साथ जोड़कर एक मजबूत वर्गीकर्ता बनाता है। GridSearchCV एस्टिमेटर्स की संख्या और लर्निंग रेट को ट्यून करता है।

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier()
params = {
    'n_estimators': np.arange(10, 300, 10),
    'learning_rate': [0.01, 0.05, 0.1, 1]
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier()

params = {

'n_estimators': np.arange(10, 300, 10),

'learning_rate': [0.01, 0.05, 0.1, 1]

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator AdaBoostClassifier(learning_rate=1, n_estimators=30)
Best score 0.8938313525749858

1 2	Best Estimator AdaBoostClassifier(learning_rate=1, n_estimators=30) Best score 0.8938313525749858

5.8 XGBoost

XGBoost ग्रेडिएंट बूस्टिंग का एक अत्यंत कुशल और स्केलेबल कार्यान्वयन है। इसके व्यापक हाइपरपैरामीटर स्पेस के कारण, GridSearchCV समय लेने वाला हो सकता है।

import xgboost as xgb

model = xgb.XGBClassifier()
params = {
    'min_child_weight': [1, 5, 10],
    'gamma': [0.5, 1, 1.5, 2, 5],
    'subsample': [0.6, 0.8, 1.0],
    'colsample_bytree': [0.6, 0.8, 1.0],
    'max_depth': [3, 4, 5],
    'n_estimators': [100, 500, 1000],
    'learning_rate': [0.01, 0.3, 0.5, 0.1],
    'reg_lambda': [1, 2]
}

grid_search_cv = GridSearchCV(
    estimator=model,
    param_grid=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

grid_search_cv.fit(X_train, y_train)
print("Best Estimator", grid_search_cv.best_estimator_)
print("Best score", grid_search_cv.best_score_)

import xgboost as xgb

model = xgb.XGBClassifier()

params = {

'min_child_weight': [1, 5, 10],

'gamma': [0.5, 1, 1.5, 2, 5],

'subsample': [0.6, 0.8, 1.0],

'colsample_bytree': [0.6, 0.8, 1.0],

'max_depth': [3, 4, 5],

'n_estimators': [100, 500, 1000],

'learning_rate': [0.01, 0.3, 0.5, 0.1],

'reg_lambda': [1, 2]

}

grid_search_cv = GridSearchCV(

estimator=model,

param_grid=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

grid_search_cv.fit(X_train, y_train)

print("Best Estimator", grid_search_cv.best_estimator_)

print("Best score", grid_search_cv.best_score_)

आउटपुट:

Best Estimator XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
              colsample_bynode=1, colsample_bytree=0.8, gamma=0.5, gpu_id=-1,
              importance_type='gain', interaction_constraints='',
              learning_rate=0.01, max_delta_step=0, max_depth=5,
              min_child_weight=1, missing=nan, monotone_constraints='()',
              n_estimators=500, n_jobs=12, num_parallel_tree=1, random_state=0,
              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, subsample=1.0,
              tree_method='exact', validate_parameters=1, verbosity=None)
Best score 0.9267223852716081

Best Estimator XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,

colsample_bynode=1, colsample_bytree=0.8, gamma=0.5, gpu_id=-1,

importance_type='gain', interaction_constraints='',

learning_rate=0.01, max_delta_step=0, max_depth=5,

min_child_weight=1, missing=nan, monotone_constraints='()',

n_estimators=500, n_jobs=12, num_parallel_tree=1, random_state=0,

reg_alpha=0, reg_lambda=1, scale_pos_weight=1, subsample=1.0,

tree_method='exact', validate_parameters=1, verbosity=None)

Best score 0.9267223852716081

नोट: XGBoost GridSearchCV रन व्यापक हाइपरपैरामीटर संयोजनों के कारण विशेष रूप से समय लेने वाला होता है।

6. प्रदर्शन विश्लेषण

ट्यूनिंग के बाद, प्रत्येक मॉडल अपने सर्वश्रेष्ठ F1-स्कोर के आधार पर विभिन्न स्तर के प्रदर्शन प्रस्तुत करता है:

KNN: 0.877
लॉजिस्टिक रिग्रेशन: 0.830
गॉसियन नाइव बेयस: 0.840
SVM: 0.917
डिसीजन ट्री: 0.910
रैंडम फॉरेस्ट: 0.923
AdaBoost: 0.894
XGBoost: 0.927

व्याख्या

XGBoost और रैंडम फॉरेस्ट उच्चतम F1-स्कोर प्रदर्शित करते हैं, जो डेटासेट पर उत्कृष्ट प्रदर्शन को सूचित करते हैं।
SVM भी मजबूत प्रदर्शन दिखाता है।
KNN और AdaBoost थोड़े कम F1-स्कोर के साथ प्रतिस्पर्धी परिणाम प्रदान करते हैं।
लॉजिस्टिक रिग्रेशन और गॉसियन नाइव बेयस, जबकि सरल हैं, फिर भी सम्मानजनक प्रदर्शन मीट्रिक्स प्रदान करते हैं।

7. GridSearchCV का अनुकूलन

GridSearchCV की गणनात्मक तीव्रता को देखते हुए, विशेष रूप से बड़े डेटासेट या विस्तृत पैरामीटर ग्रिड के साथ, अनुकूलन रणनीतियों का अन्वेषण करना महत्वपूर्ण है:

7.1 RandomizedSearchCV

GridSearchCV के विपरीत, RandomizedSearchCV निर्दिष्ट वितरणों से तय संख्या में पैरामीटर सेटिंग्स को नमूनाकरण करता है। यह दृष्टिकोण गणना समय को महत्वपूर्ण रूप से कम कर सकता है जबकि फिर भी हाइपरपैरामीटर की विविध सेट का अन्वेषण करता है।

from sklearn.model_selection import RandomizedSearchCV

# Example setup for RandomizedSearchCV
random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    n_iter=100,  # Number of parameter settings sampled
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1,
    random_state=42
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)
print("Best score", random_search_cv.best_score_)

from sklearn.model_selection import RandomizedSearchCV

# Example setup for RandomizedSearchCV

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

n_iter=100, # Number of parameter settings sampled

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1,

random_state=42

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_)

print("Best score", random_search_cv.best_score_)

7.2 पैरामीटर ग्रिड आकार को कम करना

उन हाइपरपैरामीटर्स पर ध्यान केंद्रित करें जो मॉडल के प्रदर्शन पर महत्वपूर्ण प्रभाव डालते हैं। अन्वेषणात्मक विश्लेषण करें या डोमेन ज्ञान का उपयोग करके कुछ पैरामीटर को अन्य की तुलना में प्राथमिकता दें।

7.3 समानांतर प्रसंस्करण का उपयोग करना

GridSearchCV में n_jobs=-1 सेट करने से सभी उपलब्ध CPU कोर का उपयोग करने की अनुमति मिलती है, जिससे गणना प्रक्रिया में तेजी आती है।

7.4 प्रारंभिक रोकावट

खोज को रोकने के लिए प्रारंभिक रोकावट तंत्र को लागू करें जब एक संतोषजनक प्रदर्शन स्तर प्राप्त हो जाता है, ताकि अनावश्यक गणनाओं से बचा जा सके।

8. निष्कर्ष और अगले कदम

GridSearchCV हाइपरपैरामीटर ट्यूनिंग के लिए एक अनिवार्य उपकरण है, जो मशीन लर्निंग मॉडल के प्रदर्शन को बढ़ाने के लिए एक व्यवस्थित दृष्टिकोण प्रदान करता है। सावधानीपूर्वक डेटा प्रीप्रोसेसिंग, रणनीतिक पैरामीटर ग्रिड निर्माण, और गणनात्मक अनुकूलनों का लाभ उठाकर, डेटा वैज्ञानिक GridSearchCV की पूरी क्षमता का उपयोग कर सकते हैं।

अगले कदम:

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

GridSearchCV और इसके अनुकूलनों में महारत हासिल करके, आप उच्च-प्रदर्शन, विश्वसनीय मशीन लर्निंग मॉडल्स तैयार करने में सक्षम हैं जो विभिन्न डेटा परिदृश्यों का सामना कर सकते हैं।