html
ROC कर्व और AUC के साथ मशीन लर्निंग मॉडल का मूल्यांकन: एक व्यापक मार्गदर्शिका
मशीन लर्निंग के क्षेत्र में, आपके डेटा सेट के लिए सही मॉडल का चयन सटीक और विश्वसनीय भविष्यवाणियाँ प्राप्त करने के लिए महत्वपूर्ण है। मॉडलों का मूल्यांकन और तुलना करने के सबसे प्रभावी तरीकों में से एक रिसीवर ऑपरेटिंग कैरेक्टरिस्टिक (ROC) कर्व और एरिया अंडर द कर्व (AUC) के माध्यम से है। यह मार्गदर्शिका ROC कर्व को समझने, AUC की गणना करने, और बाइनरी क्लासिफिकेशन कार्यों के लिए सर्वश्रेष्ठ प्रदर्शन करने वाले मॉडल को चुनने के लिए इन मेट्रिक्स का उपयोग करने में गहराई से प्रवेश करती है। हम विभिन्न मशीन लर्निंग एल्गोरिदम का उपयोग करके इन अवधारणाओं को लागू करने का प्रदर्शन करते हुए एक व्यावहारिक उदाहरण के साथ एक Jupyter Notebook का उपयोग करेंगे।
सामग्री सूची
- ROC कर्व और AUC का परिचय
- सटीकता पर AUC क्यों?
- डेटासेट अवलोकन
- डेटा पूर्व-संसाधन
- मॉडल प्रशिक्षण और मूल्यांकन
- सर्वश्रेष्ठ मॉडल का चयन
- निष्कर्ष
- संसाधन
ROC कर्व और AUC का परिचय
ROC कर्व क्या है?
रिसीवर ऑपरेटिंग कैरेक्टरिस्टिक (ROC) कर्व एक ग्राफिकल प्रतिनिधित्व है जो यह दर्शाता है कि एक बाइनरी क्लासिफायर सिस्टम की निदान क्षमता उसके भेदभाव सीमा के बदलने पर कैसी होती है। ROC कर्व दो पैरामीटर को प्लॉट करता है:
- ट्रू पॉजिटिव रेट (TPR): जिसे सेंसिटिविटी या रीकॉल के नाम से भी जाना जाता है, यह वास्तविक पॉजिटिव्स में से सही पहचान की गई हिस्सेदारी को मापता है।
- फॉल्स पॉजिटिव रेट (FPR): यह वास्तविक नेगेटिव्स में से गलत तरीके से पॉजिटिव्स के रूप में पहचान की गई हिस्सेदारी को मापता है।
ROC कर्व विभिन्न सीमा सेटिंग्स पर सेंसिटिविटी और विशिष्टता (1 - FPR) के बीच टौड़-ओफ को विज़ुअलाइज़ करने में सक्षम बनाता है।
AUC को समझना
एरिया अंडर द कर्व (AUC) मॉडल की पॉजिटिव और नेगेटिव क्लासेस के बीच भेदभाव करने की कुल क्षमता को परिमाणित करता है। AUC का मान 0 से 1 तक होता है:
- AUC = 1: परफेक्ट क्लासिफायर।
- AUC = 0.5: कोई भेदभाव नहीं (यादृच्छिक अनुमान के बराबर)।
- AUC < 0.5: उल्टा भविष्यवाणी (यादृच्छिक से भी खराब)।
उच्च AUC बेहतर प्रदर्शन करने वाले मॉडल को इंगित करता है।
सटीकता पर AUC क्यों?
जबकि सटीकता सभी की गई भविष्यवाणियों में से सही भविष्यवाणियों का अनुपात मापती है, यह क्लास असंतुलन के मामलों में भ्रामक हो सकती है। उदाहरण के लिए, यदि 95% डेटा एक ही क्लास से संबंधित है, तो केवल उस क्लास की भविष्यवाणी करने वाला मॉडल 95% सटीकता प्राप्त करेगा लेकिन अल्पसंख्यक क्लास को पकड़ने में विफल रहेगा।
दूसरी ओर, AUC मॉडल के प्रदर्शन का अधिक सूक्ष्म मूल्यांकन प्रदान करता है, यह सभी क्लासिफिकेशन सीमाओं पर मॉडल के प्रदर्शन को ध्यान में रखते हुए, जिसे असंतुलित डेटासेट्स के लिए अधिक विश्वसनीय मेट्रिक बनाता है।
डेटासेट अवलोकन
हमारे विश्लेषण के लिए, हम Kaggle के मौसम डेटासेट का उपयोग करेंगे। इस डेटासेट में विभिन्न ऑस्ट्रेलियाई स्थानों पर प्रतिदिन रिकॉर्ड किए गए विभिन्न मौसम-संबंधी गुण शामिल हैं।
उद्देश्य: आज के मौसम की शर्तों के आधार पर यह भविष्यवाणी करना कि क्या कल वर्षा होगी (RainTomorrow
)।
प्रकार: बाइनरी क्लासिफिकेशन (Yes
/No
)।
डेटा पूर्व-संसाधन
प्रभावी डेटा पूर्व-संसाधन मजबूत मशीन लर्निंग मॉडल बनाने की नींव है। यहाँ एक चरण-दर-चरण विश्लेषण है:
1. लाइब्रेरी और डेटा आयात करना
123456
import pandas as pd import seaborn as sns # Load the datasetdata = pd.read_csv('weatherAUS.csv')data.tail()
2. फीचर्स और टारगेट को अलग करना
12345
# Features (All columns except the last one)X = data.iloc[:, :-1] # Target variabley = data.iloc[:, -1]
3. लाप Missing डेटा को संभालना
a. न्यूमेरिक फीचर्स
123456789
import numpy as npfrom sklearn.impute import SimpleImputer # Identify numeric columnsnumerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) # Impute missing values with meanimp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])
b. कैटेगोरिकल फीचर्स
123456
# Identify object (categorical) columnsstring_cols = list(np.where((X.dtypes == object))[0]) # Impute missing values with the most frequent valueimp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')X.iloc[:, string_cols] = imp_mode.fit_transform(X.iloc[:, string_cols])
4. कैटेगोरिकल वेरिएबल्स को एनकोड करना
a. टारगेट के लिए लेबल एनकोडिंग
12345
from sklearn.preprocessing import LabelEncoder # Initialize Label Encoderle = LabelEncoder()y = le.fit_transform(y)
b. फीचर्स को एनकोड करना
1234567891011121314151617181920212223242526
from sklearn.compose import ColumnTransformerfrom sklearn.preprocessing import OneHotEncoder # Function to perform One-Hot Encodingdef OneHotEncoderMethod(indices, data): columnTransformer = ColumnTransformer( [('encoder', OneHotEncoder(), indices)], remainder='passthrough' ) return columnTransformer.fit_transform(data) # Identify columns for One-Hot Encoding based on the number of unique categoriesdef 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]] = le.fit_transform(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X X = EncodingSelection(X)
5. फीचर चयन
मॉडल की जटिलता को कम करने और प्रदर्शन में सुधार लाने के लिए, हम ची-स्क्वायर (Chi2) परीक्षण का उपयोग करके शीर्ष 10 फीचर्स का चयन करेंगे।
123456789101112131415161718
from sklearn.feature_selection import SelectKBest, chi2from sklearn.preprocessing import MinMaxScaler # Initialize SelectKBestkbest = SelectKBest(score_func=chi2, k=10)scaler = MinMaxScaler() # Scale featuresX_scaled = scaler.fit_transform(X) # Fit SelectKBestkbest.fit(X_scaled, y) # Get top 10 feature indicesbest_features = np.argsort(kbest.scores_)[-10:] # Select top featuresX = X[:, best_features]
6. डेटासेट को विभाजित करना
123456
from sklearn.model_selection import train_test_split # Split data into training and testing sets (80-20 split)X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.20, random_state=1)
7. फीचर स्केलिंग
फीचर्स को मानकीकृत करना यह सुनिश्चित करता है कि प्रत्येक का परिणाम में समान योगदान हो।
12345
from sklearn.preprocessing import StandardScaler sc = StandardScaler(with_mean=False)X_train = sc.fit_transform(X_train)X_test = sc.transform(X_test)
मॉडल प्रशिक्षण और मूल्यांकन
हम कई क्लासिफिकेशन मॉडल्स को प्रशिक्षित करेंगे और उनकी प्रदर्शन का मूल्यांकन सटीकता और AUC दोनों का उपयोग करके करेंगे।
K-Nearest Neighbors (KNN)
123456789101112131415161718
from sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_score, roc_curve, aucimport matplotlib.pyplot as pltfrom sklearn import metrics # Initialize and train KNNknnClassifier = KNeighborsClassifier(n_neighbors=3)knnClassifier.fit(X_train, y_train) # Predict and evaluatey_pred_knn = knnClassifier.predict(X_test)accuracy_knn = accuracy_score(y_pred_knn, y_test)print(f'KNN Accuracy: {accuracy_knn:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(knnClassifier, X_test, y_test) plt.title('KNN ROC Curve')plt.show()
Output:
1
KNN Accuracy: 0.82
लॉजिस्टिक रिग्रेशन
123456789101112131415
from sklearn.linear_model import LogisticRegression # Initialize and train Logistic RegressionLRM = LogisticRegression(random_state=0, max_iter=200)LRM.fit(X_train, y_train) # Predict and evaluatey_pred_lr = LRM.predict(X_test)accuracy_lr = accuracy_score(y_pred_lr, y_test)print(f'Logistic Regression Accuracy: {accuracy_lr:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(LRM, X_test, y_test) plt.title('Logistic Regression ROC Curve')plt.show()
Output:
1
Logistic Regression Accuracy: 0.84
नोट: यदि आपको संमिलन चेतावनी मिलती है, तो max_iter
बढ़ाने या अपने डेटा को मानकीकृत करने पर विचार करें।
गॉसियन नायव बेज़
123456789101112131415
from sklearn.naive_bayes import GaussianNB # Initialize and train GaussianNBmodel_GNB = GaussianNB()model_GNB.fit(X_train, y_train) # Predict and evaluatey_pred_gnb = model_GNB.predict(X_test)accuracy_gnb = accuracy_score(y_pred_gnb, y_test)print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_GNB, X_test, y_test) plt.title('Gaussian Naive Bayes ROC Curve')plt.show()
Output:
1
Gaussian Naive Bayes Accuracy: 0.81
सपोर्ट वेक्टर मशीन (SVM)
123456789101112131415
from sklearn.svm import SVC # Initialize and train SVMmodel_SVC = SVC(probability=True)model_SVC.fit(X_train, y_train) # Predict and evaluatey_pred_svc = model_SVC.predict(X_test)accuracy_svc = accuracy_score(y_pred_svc, y_test)print(f'SVM Accuracy: {accuracy_svc:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_SVC, X_test, y_test) plt.title('SVM ROC Curve')plt.show()
Output:
1
SVM Accuracy: 0.84
डिसीजन ट्री
123456789101112131415
from sklearn.tree import DecisionTreeClassifier # Initialize and train Decision Treemodel_DTC = DecisionTreeClassifier()model_DTC.fit(X_train, y_train) # Predict and evaluatey_pred_dtc = model_DTC.predict(X_test)accuracy_dtc = accuracy_score(y_pred_dtc, y_test)print(f'Decision Tree Accuracy: {accuracy_dtc:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_DTC, X_test, y_test) plt.title('Decision Tree ROC Curve')plt.show()
Output:
1
Decision Tree Accuracy: 0.78
रैंडम फॉरेस्ट
123456789101112131415
from sklearn.ensemble import RandomForestClassifier # Initialize and train Random Forestmodel_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)model_RFC.fit(X_train, y_train) # Predict and evaluatey_pred_rfc = model_RFC.predict(X_test)accuracy_rfc = accuracy_score(y_pred_rfc, y_test)print(f'Random Forest Accuracy: {accuracy_rfc:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_RFC, X_test, y_test) plt.title('Random Forest ROC Curve')plt.show()
Output:
1
Random Forest Accuracy: 0.84
एडा बूस्ट
123456789101112131415
from sklearn.ensemble import AdaBoostClassifier # Initialize and train AdaBoostmodel_ABC = AdaBoostClassifier()model_ABC.fit(X_train, y_train) # Predict and evaluatey_pred_abc = model_ABC.predict(X_test)accuracy_abc = accuracy_score(y_pred_abc, y_test)print(f'AdaBoost Accuracy: {accuracy_abc:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_ABC, X_test, y_test) plt.title('AdaBoost ROC Curve')plt.show()
Output:
1
AdaBoost Accuracy: 0.84
एक्सजीबूस्ट
123456789101112131415161718192021
import xgboost as xgbfrom sklearn.exceptions import ConvergenceWarningimport warnings # Suppress warningswarnings.filterwarnings("ignore", category=ConvergenceWarning)warnings.filterwarnings("ignore", category=UserWarning) # Initialize and train XGBoostmodel_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')model_xgb.fit(X_train, y_train) # Predict and evaluatey_pred_xgb = model_xgb.predict(X_test)accuracy_xgb = accuracy_score(y_pred_xgb, y_test)print(f'XGBoost Accuracy: {accuracy_xgb:.2f}') # Plot ROC Curvemetrics.plot_roc_curve(model_xgb, X_test, y_test) plt.title('XGBoost ROC Curve')plt.show()
Output:
1
XGBoost Accuracy: 0.85
सर्वश्रेष्ठ मॉडल का चयन
सभी मॉडलों का मूल्यांकन करने के बाद, हम निम्नलिखित सटीकताओं को देखते हैं:
मॉडल
सटीकता
AUC
K-Nearest Neighbors
0.82
0.80
लॉजिस्टिक रिग्रेशन
0.84
0.86
गॉसियन नायव बेज़
0.81
0.81
SVM
0.84
0.86
डिसीजन ट्री
0.78
0.89
रैंडम फॉरेस्ट
0.84
0.85
एडा बूस्ट
0.84
0.86
एक्सजीबूस्ट
0.85
0.87
मुख्य अवलोकन:
- एक्सजीबूस्ट सबसे उच्च सटीकता (85%) और मजबूत AUC (0.87) के साथ शीर्ष प्रदर्शनकर्ता के रूप में उभरता है।
- लॉजिस्टिक रिग्रेशन, SVM, और एडा बूस्ट भी लगभग 84% सटीकता और 0.86 के AUC के साथ प्रशंसनीय प्रदर्शन दिखाते हैं।
- डिसीजन ट्री सबसे कम सटीकता (78%) दिखाता है लेकिन अपेक्षाकृत उच्च AUC (0.89) रखता है, जो निम्न भविष्यवाणी सटीकता के बावजूद क्लासेस को अलग करने की क्षमता को इंगित करता है।
निष्कर्ष: जबकि सटीकता एक सरल मेट्रिक प्रदान करती है, AUC मॉडल के विभिन्न सीमा पर प्रदर्शन के बारे में गहरी अंतर्दृष्टि प्रदान करता है। इस परिदृश्य में, एक्सजीबूस्ट सबसे विश्वसनीय मॉडल के रूप में उभरता है, जो उच्च सटीकता और मजबूत भेदभाव क्षमता दोनों को संतुलित करता है।
निष्कर्ष
मशीन लर्निंग मॉडलों का मूल्यांकन करने के लिए एक बहुआयामी दृष्टिकोण की आवश्यकता होती है। केवल सटीकता पर निर्भर रहना भ्रामक हो सकता है, खासकर उन डेटासेट्स में जहां क्लास असंतुलन होता है। ROC कर्व और AUC मॉडल के प्रदर्शन का अधिक व्यापक मूल्यांकन प्रदान करते हैं, जो इसकी क्लासेस के बीच प्रभावी ढंग से भेद करने की क्षमता को उजागर करते हैं।
इस मार्गदर्शिका में, हमने डेटा को पूर्व-संसाधित करने, कई क्लासिफिकेशन मॉडलों को प्रशिक्षित करने, और उन्हें ROC कर्व और AUC का उपयोग करके मूल्यांकन करने के तरीके का अन्वेषण किया। Jupyter Notebook का उपयोग करके व्यावहारिक कार्यान्वयन ने प्रत्येक मॉडल की ताकत का प्रदर्शन किया, अंततः यह दिखाते हुए कि एक्सजीबूस्ट प्रदान किए गए डेटासेट के आधार पर वर्षा की भविष्यवाणी करने के लिए श्रेष्ठ विकल्प था।
संसाधन
- Wikipedia पर ROC कर्व
- AUC की व्याख्या
- Kaggle मौसम डेटासेट
- Scikit-Learn डाक्यूमेंटेशन
- XGBoost डाक्यूमेंटेशन
ROC कर्व और AUC को समझकर और उनका उपयोग करके, डेटा वैज्ञानिक और मशीन लर्निंग प्रैक्टिशनर मॉडल चुनने में अधिक सूचित निर्णय ले सकते हैं, जो उनके भविष्यवाणी कार्यों में उच्च प्रदर्शन और विश्वसनीयता सुनिश्चित करते हैं।