मशीन लर्निंग मॉडल ट्यूनिंग का अनुकूलन: GridSearchCV की बजाय RandomizedSearchCV को अपनाना

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

सामग्री तालिका

GridSearchCV को समझना और इसकी सीमाएँ
RandomizedSearchCV का परिचय
तुलनात्मक विश्लेषण: GridSearchCV बनाम RandomizedSearchCV
डेटा तैयारी और प्रीप्रोसेसिंग
मॉडल निर्माण और हाइपरपैरामीटर ट्यूनिंग
परिणाम और प्रदर्शन मूल्यांकन
निष्कर्ष: कब चुनें RandomizedSearchCV
संसाधन और आगे की पढ़ाई

GridSearchCV को समझना और इसकी सीमाएँ

GridSearchCV scikit-learn में हाइपरपैरामीटर ट्यूनिंग के लिए एक शक्तिशाली उपकरण है। यह एक पूर्व-परिभाषित हाइपरपैरामीटर सेट के माध्यम से थकाऊ खोज करता है ताकि उस संयोजन की पहचान की जा सके जो निर्दिष्ट मीट्रिक के आधार पर सर्वश्रेष्ठ मॉडल प्रदर्शन प्रदान करता है।

मुख्य विशेषताएं:

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

सीमाएँ:

गणनात्मक रूप से भारी: जैसे-जैसे पैरामीटर ग्रिड बढ़ता है, संयोजनों की संख्या तेजी से बढ़ जाती है, जिससे गणना समय लंबा हो जाता है।
मेमोरी की खपत: बड़ी डाटासेट्स को कई पैरामीटर संयोजनों के साथ संभालना सिस्टम संसाधनों पर दबाव डाल सकता है।
प्रतिदान में कमी: सभी पैरामीटर संयोजन मॉडल प्रदर्शन में महत्वपूर्ण योगदान नहीं देते, जिससे थकाऊ खोज अप्रभावी हो जाती है।

उदाहरण: GridSearchCV का उपयोग करके 129,000 से अधिक रिकॉर्ड वाले डेटासेट को प्रोसेस करने में लगभग 12 घंटे लगे, भले ही हार्डवेयर मजबूत हो। यह बड़े पैमाने पर अनुप्रयोगों के लिए इसकी अप्रायोगिकता को दर्शाता है।

RandomizedSearchCV का परिचय

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

लाभ:

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

कैसे काम करता है:

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

तुलनात्मक विश्लेषण: GridSearchCV बनाम RandomizedSearchCV

पहलू	GridSearchCV	RandomizedSearchCV
खोज विधि	थकाऊ	यादृच्छिक सैंपलिंग
गणना समय	उच्च	कम से मध्यम
संसाधन उपयोग	उच्च	मध्यम से कम
प्रदर्शन	संभावित रूप से सर्वश्रेष्ठ	कम प्रयास के साथ तुलनीय
लचीलापन	स्थिर संयोजन	प्रायिकता-आधारित सैंपलिंग

दृश्यमान: व्यावहारिक रूप से, RandomizedSearchCV मॉडल ट्यूनिंग समय को घंटों से केवल मिनटों में कम कर सकता है बिना प्रदर्शन में महत्वपूर्ण गिरावट के।

डेटा तैयारी और प्रीप्रोसेसिंग

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

डेटासेट लोड करना

उपयोग किया गया डेटासेट Airline Passenger Satisfaction है जो Kaggle से है। इसमें 5,000 रिकॉर्ड हैं जिनमें से 23 फीचर्स यात्रियों के अनुभवों और संतुष्टि स्तरों से संबंधित हैं।

import pandas as pd 
import seaborn as sns

# Loading the small dataset
data = pd.read_csv('Airline2_tiny.csv')
print(data.shape)  # Output: (4999, 23)

import pandas as pd

import seaborn as sns

# Loading the small dataset

data = pd.read_csv('Airline2_tiny.csv')

print(data.shape) # Output: (4999, 23)

मिसिंग डेटा संभालना

न्यूमेरिक डेटा

मिसिंग न्यूमेरिक मानों को मीन रणनीति का उपयोग करके इम्यूट किया जाता है।

import numpy as np
from sklearn.impute import SimpleImputer

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

import numpy as np

from sklearn.impute import SimpleImputer

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

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

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

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

कैटेगोरिकल डेटा

मिसिंग कैटेगोरिकल मानों को अधिकतम बार रणनीति का उपयोग करके इम्यूट किया जाता है।

imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
string_cols = list(np.where((X.dtypes == 'object'))[0])
imp_mode.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols])

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

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

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

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

कैटेगोरिकल वेरिएबल्स को एन्कोड करना

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

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

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

def LabelEncoderMethod(series):
    le = LabelEncoder()
    le.fit(series)
    return le.transform(series) 

def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == 'object'))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 or length > 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)
print(X.shape)  # Output: (4999, 24)

from sklearn.compose import ColumnTransformer

from sklearn.preprocessing import OneHotEncoder, LabelEncoder

def OneHotEncoderMethod(indices, data):

columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices )], remainder='passthrough')

return columnTransformer.fit_transform(data)

def LabelEncoderMethod(series):

le = LabelEncoder()

le.fit(series)

return le.transform(series)

def EncodingSelection(X, threshold=10):

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

one_hot_encoding_indices = []

for col in string_cols:

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

if length == 2 or length > 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)

print(X.shape) # Output: (4999, 24)

फीचर सेलेक्शन

सबसे प्रासंगिक फीचर्स का चयन मॉडल प्रदर्शन को बढ़ाता है और जटिलता को कम करता है।

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

kbest = SelectKBest(score_func=chi2, k='all')
MMS = MinMaxScaler()
K_features = 10

x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = np.argsort(x_temp.scores_)[:-K_features]
X = np.delete(X, features_to_delete, axis=1)
print(X.shape)  # Output: (4999, 10)

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

kbest = SelectKBest(score_func=chi2, k='all')

MMS = MinMaxScaler()

K_features = 10

x_temp = MMS.fit_transform(X)

x_temp = kbest.fit(x_temp, y)

best_features = np.argsort(x_temp.scores_)[-K_features:]

features_to_delete = np.argsort(x_temp.scores_)[:-K_features]

X = np.delete(X, features_to_delete, axis=1)

print(X.shape) # Output: (4999, 10)

ट्रेन-टेस्ट स्प्लिट

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

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
print(X_train.shape)  # Output: (3999, 10)
print(X_test.shape)   # Output: (1000, 10)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)

print(X_train.shape) # Output: (3999, 10)

print(X_test.shape) # Output: (1000, 10)

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

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

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)

sc.fit(X_train)

X_train = sc.transform(X_train)

X_test = sc.transform(X_test)

मॉडल निर्माण और हाइपरपैरामीटर ट्यूनिंग

डेटा को प्रीप्रोसेस करने के बाद, RandomizedSearchCV का उपयोग करके विभिन्न मशीन लर्निंग मॉडलों का निर्माण और अनुकूलन करने का समय है।

K-Nearest Neighbors (KNN)

KNN एक सरल, इंस्टेंस-आधारित लर्निंग एल्गोरिदम है।

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold

model = KNeighborsClassifier()

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

cv = StratifiedKFold(n_splits=2)
random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: KNeighborsClassifier(leaf_size=1)
print("Best score", random_search_cv.best_score_)          # Output: 0.8774673417446253

from sklearn.neighbors import KNeighborsClassifier

from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold

model = KNeighborsClassifier()

params = {

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

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

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

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

}

cv = StratifiedKFold(n_splits=2)

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: KNeighborsClassifier(leaf_size=1)

print("Best score", random_search_cv.best_score_) # Output: 0.8774673417446253

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

एक प्रायिकात्मक मॉडल जो बाइनरी क्लासीफिकेशन कार्यों के लिए उपयोग किया जाता है।

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]
}

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: LogisticRegression(C=0.01)
print("Best score", random_search_cv.best_score_)          # Output: 0.8295203666687819

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]

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: LogisticRegression(C=0.01)

print("Best score", random_search_cv.best_score_) # Output: 0.8295203666687819

गॉसियन नाइव बेयस (GaussianNB)

एक सरल लेकिन प्रभावी प्रायिकात्मक क्लासिफायर जो बेयस प्रमेय पर आधारित है।

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))  # Output: 0.84
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)) # Output: 0.84

print(classification_report(y_pred, y_test))

आउटपुट:

              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

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

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

एक मजबूत क्लासिफायर जो उच्च-आयामी स्थानों में प्रभावी होता है।

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']
}

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: SVC(C=10, coef0=0.5, degree=8)
print("Best score", random_search_cv.best_score_)          # Output: 0.9165979221213969

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']

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: SVC(C=10, coef0=0.5, degree=8)

print("Best score", random_search_cv.best_score_) # Output: 0.9165979221213969

डिसीजन ट्री

एक पदानुक्रमिक मॉडल जो फीचर स्प्लिट्स के आधार पर निर्णय लेता है।

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

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

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: DecisionTreeClassifier(max_leaf_nodes=30, min_samples_split=4)
print("Best score", random_search_cv.best_score_)          # Output: 0.9069240944070234

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

params = {

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

'min_samples_split': [2, 3, 4]

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: DecisionTreeClassifier(max_leaf_nodes=30, min_samples_split=4)

print("Best score", random_search_cv.best_score_) # Output: 0.9069240944070234

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

एक एन्सेम्बल विधि जो कई डिसीजन ट्रीज़ का उपयोग करके भविष्यवाणी प्रदर्शन को बढ़ाती है।

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]
}

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: RandomForestClassifier(max_leaf_nodes=96, min_samples_split=3)
print("Best score", random_search_cv.best_score_)          # Output: 0.9227615146702333

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]

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: RandomForestClassifier(max_leaf_nodes=96, min_samples_split=3)

print("Best score", random_search_cv.best_score_) # Output: 0.9227615146702333

AdaBoost

एक बूस्टिंग एन्सेम्बल विधि जो कई कमजोर शिक्षार्थियों को मिलाकर एक मजबूत शिक्षार्थी बनाती है।

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier()

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

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: AdaBoostClassifier(learning_rate=0.1, n_estimators=200)
print("Best score", random_search_cv.best_score_)          # Output: 0.8906331862757826

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier()

params = {

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

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

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: AdaBoostClassifier(learning_rate=0.1, n_estimators=200)

print("Best score", random_search_cv.best_score_) # Output: 0.8906331862757826

XGBoost

एक अनुकूलित ग्रेडिएंट बूस्टिंग फ्रेमवर्क जो अपने प्रदर्शन और गति के लिए जाना जाता है।

import xgboost as xgb
from sklearn.metrics import accuracy_score, classification_report

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]
}

random_search_cv = RandomizedSearchCV(
    estimator=model,
    param_distributions=params,
    verbose=1,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

random_search_cv.fit(X_train, y_train)
print("Best Estimator", random_search_cv.best_estimator_)  # Output: XGBClassifier with best parameters
print("Best score", random_search_cv.best_score_)          # Output: 0.922052180776655

# Model Evaluation
model_best = random_search_cv.best_estimator_
model_best.fit(X_train, y_train)
y_pred = model_best.predict(X_test)
print(accuracy_score(y_pred, y_test))  # Output: 0.937
print(classification_report(y_pred, y_test))

import xgboost as xgb

from sklearn.metrics import accuracy_score, classification_report

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]

}

random_search_cv = RandomizedSearchCV(

estimator=model,

param_distributions=params,

verbose=1,

cv=cv,

scoring='f1',

n_jobs=-1

)

random_search_cv.fit(X_train, y_train)

print("Best Estimator", random_search_cv.best_estimator_) # Output: XGBClassifier with best parameters

print("Best score", random_search_cv.best_score_) # Output: 0.922052180776655

# Model Evaluation

model_best = random_search_cv.best_estimator_

model_best.fit(X_train, y_train)

y_pred = model_best.predict(X_test)

print(accuracy_score(y_pred, y_test)) # Output: 0.937

print(classification_report(y_pred, y_test))

आउटपुट:

              precision    recall  f1-score   support

           0       0.96      0.93      0.95       583
           1       0.91      0.94      0.93       417

    accuracy                           0.94      1000
   macro avg       0.93      0.94      0.94      1000
weighted avg       0.94      0.94      0.94      1000

precision recall f1-score support

0 0.96 0.93 0.95 583

1 0.91 0.94 0.93 417

accuracy 0.94 1000

macro avg 0.93 0.94 0.94 1000

weighted avg 0.94 0.94 0.94 1000

परिणाम और प्रदर्शन मूल्यांकन

RandomizedSearchCV की प्रभावशीलता मॉडल प्रदर्शन से स्पष्ट होती है:

KNN ने ~0.877 का F1-score प्राप्त किया।
लॉजिस्टिक रिग्रेशन ने ~0.830 का F1-score दिया।
GaussianNB ने 84% की सटीकता बरकरार रखी।
SVM ने ~0.917 के प्रभावशाली F1-score के साथ उत्कृष्ट प्रदर्शन किया।
डिसीजन ट्री ने ~0.907 का F1-score प्राप्त किया।
रैंडम फॉरेस्ट ने ~0.923 के F1-score के साथ शीर्ष पर रहा।
AdaBoost ने ~0.891 का F1-score प्राप्त किया।
XGBoost ने ~0.922 का F1-score और 93.7% की सटीकता के साथ उत्कृष्ट प्रदर्शन किया।

मुख्य अवलोकन:

RandomForestClassifier और XGBoost ने श्रेष्ठ प्रदर्शन दिखाया।
RandomizedSearchCV ने समय को 12 घंटे से अधिक (GridSearchCV) से केवल मिनटों में कम कर दिया बिना मॉडल की सटीकता से समझौता किए।

निष्कर्ष: कब चुनें RandomizedSearchCV

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

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

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

संसाधन और आगे की पढ़ाई

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