S29L02 – ROC, AUC – सर्वोत्तम मॉडल का मूल्यांकन

html
ROC कर्व और AUC के साथ मशीन लर्निंग मॉडल का मूल्यांकन: एक व्यापक मार्गदर्शिका
मशीन लर्निंग के क्षेत्र में, आपके डेटा सेट के लिए सही मॉडल का चयन सटीक और विश्वसनीय भविष्यवाणियाँ प्राप्त करने के लिए महत्वपूर्ण है। मॉडलों का मूल्यांकन और तुलना करने के सबसे प्रभावी तरीकों में से एक रिसीवर ऑपरेटिंग कैरेक्टरिस्टिक (ROC) कर्व और एरिया अंडर द कर्व (AUC) के माध्यम से है। यह मार्गदर्शिका ROC कर्व को समझने, AUC की गणना करने, और बाइनरी क्लासिफिकेशन कार्यों के लिए सर्वश्रेष्ठ प्रदर्शन करने वाले मॉडल को चुनने के लिए इन मेट्रिक्स का उपयोग करने में गहराई से प्रवेश करती है। हम विभिन्न मशीन लर्निंग एल्गोरिदम का उपयोग करके इन अवधारणाओं को लागू करने का प्रदर्शन करते हुए एक व्यावहारिक उदाहरण के साथ एक Jupyter Notebook का उपयोग करेंगे।

सामग्री सूची

    ROC कर्व और AUC का परिचय
    सटीकता पर AUC क्यों?
    डेटासेट अवलोकन
    डेटा पूर्व-संसाधन
    मॉडल प्रशिक्षण और मूल्यांकन
        
            K-Nearest Neighbors (KNN)
            लॉजिस्टिक रिग्रेशन
            गॉसियन नायव बेज़
            सपोर्ट वेक्टर मशीन (SVM)
            डिसीजन ट्री
            रैंडम फॉरेस्ट
            एडा बूस्ट
            एक्सजीबूस्ट
        
    
    सर्वश्रेष्ठ मॉडल का चयन
    निष्कर्ष
    संसाधन


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. लाइब्रेरी और डेटा आयात करना




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns

# Load the dataset
data = pd.read_csv('weatherAUS.csv')
data.tail()
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd 
import seaborn as sns
 
# Load the dataset
data = pd.read_csv('weatherAUS.csv')
data.tail()
					
				
			
		


2. फीचर्स और टारगेट को अलग करना




		
		
			
			
Java
			
			# Features (All columns except the last one)
X = data.iloc[:, :-1]

# Target variable
y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
5
				
						# Features (All columns except the last one)
X = data.iloc[:, :-1]
 
# Target variable
y = data.iloc[:, -1]
					
				
			
		


3. लाप Missing डेटा को संभालना
a. न्यूमेरिक फीचर्स




		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

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

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Identify numeric columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])
					
				
			
		


b. कैटेगोरिकल फीचर्स




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

# Impute missing values with the most frequent value
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X.iloc[:, string_cols] = imp_mode.fit_transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
				
						# Identify object (categorical) columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Impute missing values with the most frequent value
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X.iloc[:, string_cols] = imp_mode.fit_transform(X.iloc[:, string_cols])
					
				
			
		


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




		
		
			
			
Java
			
			from sklearn.preprocessing import LabelEncoder

# Initialize Label Encoder
le = LabelEncoder()
y = le.fit_transform(y)
			
				
					
				
					1
2
3
4
5
				
						from sklearn.preprocessing import LabelEncoder
 
# Initialize Label Encoder
le = LabelEncoder()
y = le.fit_transform(y)
					
				
			
		


b. फीचर्स को एनकोड करना




		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

# Function to perform One-Hot Encoding
def 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 categories
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]] = 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)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
# Function to perform One-Hot Encoding
def 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 categories
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]] = 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 फीचर्स का चयन करेंगे।




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

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

# Scale features
X_scaled = scaler.fit_transform(X)

# Fit SelectKBest
kbest.fit(X_scaled, y)

# Get top 10 feature indices
best_features = np.argsort(kbest.scores_)[-10:]

# Select top features
X = X[:, best_features]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
scaler = MinMaxScaler()
 
# Scale features
X_scaled = scaler.fit_transform(X)
 
# Fit SelectKBest
kbest.fit(X_scaled, y)
 
# Get top 10 feature indices
best_features = np.argsort(kbest.scores_)[-10:]
 
# Select top features
X = X[:, best_features]
					
				
			
		


6. डेटासेट को विभाजित करना




		
		
			
			
Java
			
			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
)
			
				
					
				
					1
2
3
4
5
6
				
						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. फीचर स्केलिंग
फीचर्स को मानकीकृत करना यह सुनिश्चित करता है कि प्रत्येक का परिणाम में समान योगदान हो।




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
				
						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)




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, roc_curve, auc
import matplotlib.pyplot as plt
from sklearn import metrics

# Initialize and train KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)

# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.2f}')

# Plot ROC Curve
metrics.plot_roc_curve(knnClassifier, X_test, y_test)  
plt.title('KNN ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, roc_curve, auc
import matplotlib.pyplot as plt
from sklearn import metrics
 
# Initialize and train KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.2f}')
 
# Plot ROC Curve
metrics.plot_roc_curve(knnClassifier, X_test, y_test)  
plt.title('KNN ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			KNN Accuracy: 0.82
			
				
					
				
					1
				
						KNN Accuracy: 0.82
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Initialize and train Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(LRM, X_test, y_test)  
plt.title('Logistic Regression ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.linear_model import LogisticRegression
 
# Initialize and train Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(LRM, X_test, y_test)  
plt.title('Logistic Regression ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.84
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.84
					
				
			
		



नोट: यदि आपको संमिलन चेतावनी मिलती है, तो max_iter बढ़ाने या अपने डेटा को मानकीकृत करने पर विचार करें।
गॉसियन नायव बेज़




		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

# Initialize and train GaussianNB
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_GNB, X_test, y_test)  
plt.title('Gaussian Naive Bayes ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.naive_bayes import GaussianNB
 
# Initialize and train GaussianNB
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_GNB, X_test, y_test)  
plt.title('Gaussian Naive Bayes ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			Gaussian Naive Bayes Accuracy: 0.81
			
				
					
				
					1
				
						Gaussian Naive Bayes Accuracy: 0.81
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn.svm import SVC

# Initialize and train SVM
model_SVC = SVC(probability=True)
model_SVC.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_SVC, X_test, y_test)  
plt.title('SVM ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.svm import SVC
 
# Initialize and train SVM
model_SVC = SVC(probability=True)
model_SVC.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_SVC, X_test, y_test)  
plt.title('SVM ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			SVM Accuracy: 0.84
			
				
					
				
					1
				
						SVM Accuracy: 0.84
					
				
			
		



डिसीजन ट्री




		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

# Initialize and train Decision Tree
model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_DTC, X_test, y_test)  
plt.title('Decision Tree ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.tree import DecisionTreeClassifier
 
# Initialize and train Decision Tree
model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_DTC, X_test, y_test)  
plt.title('Decision Tree ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			Decision Tree Accuracy: 0.78
			
				
					
				
					1
				
						Decision Tree Accuracy: 0.78
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

# Initialize and train Random Forest
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_RFC, X_test, y_test)  
plt.title('Random Forest ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.ensemble import RandomForestClassifier
 
# Initialize and train Random Forest
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_RFC, X_test, y_test)  
plt.title('Random Forest ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			Random Forest Accuracy: 0.84
			
				
					
				
					1
				
						Random Forest Accuracy: 0.84
					
				
			
		



एडा बूस्ट




		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

# Initialize and train AdaBoost
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_ABC, X_test, y_test)  
plt.title('AdaBoost ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.ensemble import AdaBoostClassifier
 
# Initialize and train AdaBoost
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_ABC, X_test, y_test)  
plt.title('AdaBoost ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			AdaBoost Accuracy: 0.84
			
				
					
				
					1
				
						AdaBoost Accuracy: 0.84
					
				
			
		



एक्सजीबूस्ट




		
		
			
			
Java
			
			import xgboost as xgb
from sklearn.exceptions import ConvergenceWarning
import warnings

# Suppress warnings
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=UserWarning)

# Initialize and train XGBoost
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)

# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_xgb, X_test, y_test)  
plt.title('XGBoost ROC Curve')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						import xgboost as xgb
from sklearn.exceptions import ConvergenceWarning
import warnings
 
# Suppress warnings
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=UserWarning)
 
# Initialize and train XGBoost
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
 
# Predict and evaluate
y_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 Curve
metrics.plot_roc_curve(model_xgb, X_test, y_test)  
plt.title('XGBoost ROC Curve')
plt.show()
					
				
			
		


Output:




		
		
			
			
Java
			
			XGBoost Accuracy: 0.85
			
				
					
				
					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 को समझकर और उनका उपयोग करके, डेटा वैज्ञानिक और मशीन लर्निंग प्रैक्टिशनर मॉडल चुनने में अधिक सूचित निर्णय ले सकते हैं, जो उनके भविष्यवाणी कार्यों में उच्च प्रदर्शन और विश्वसनीयता सुनिश्चित करते हैं।
मॉडल	सटीकता	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