S29L04 – ROC, AUC – इष्टतम थ्रेशोल्ड की गणना (श्रेष्ठ सटीकता विधि)

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

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

ROC कर्व्स और AUC को समझना
ROC कर्व क्या है?
एक ROC कर्व एक ग्राफिकल प्रतिनिधित्व है जो एक बाइनरी क्लासिफायर सिस्टम की निदान क्षमता को दर्शाता है जब इसकी भेदभाव थ्रेशोल्ड बदलती है। यह विभिन्न थ्रेशोल्ड सेटिंग्स पर सत्य सकारात्मक दर (TPR) बनाम असत्य सकारात्मक दर (FPR) को प्लॉट करता है।

  सत्य सकारात्मक दर (TPR): इसे रिकॉल या संवेदनशीलता के नाम से भी जाना जाता है, यह मॉडल द्वारा सही तरीके से पहचानी गई वास्तविक सकारात्मक का अनुपात मापता है।
  
    \[
    \text{TPR} = \frac{\text{True Positives}}{\text{True Positives} + \text{False Negatives}}
    \]
  
  असत्य सकारात्मक दर (FPR): यह मॉडल द्वारा असल में नकारात्मकों को गलत तरीके से सकारात्मक के रूप में पहचाना गया अनुपात मापता है।
  
    \[
    \text{FPR} = \frac{\text{False Positives}}{\text{False Positives} + \text{True Negatives}}
    \]
  

AUC क्या है?
कर्व के नीचे क्षेत्रफल (AUC) मॉडल की सकारात्मक और नकारात्मक कक्षाओं के बीच अंतर करने की समग्र क्षमता को मापता है। उच्च AUC एक बेहतर प्रदर्शन करने वाले मॉडल को इंगित करता है। 0.5 की AUC किसी भी भेदभाव क्षमता को नहीं दर्शाती, जो यादृच्छिक अनुमान के बराबर है, जबकि 1.0 की AUC पूर्ण भेदभाव को इंगित करती है।

डेटासेट अवलोकन: मौसम ऑस्ट्रेलिया
इस मार्गदर्शिका के लिए, हम Weather Australia डेटासेट का उपयोग करेंगे, जिसमें विभिन्न मौसम संबंधी विशेषताएँ शामिल हैं। डेटा सेट को 10,000 रिकॉर्ड शामिल करने के लिए पूर्व-प्रसंस्कृत किया गया है, जिससे अवधारणाओं को समझाने में इसे प्रबंधनीय और प्रभावी बनाया जा सके।
डेटा स्रोत: Kaggle पर Weather Australia डेटासेट

डेटा पूर्व-प्रसंस्करण
प्रभावी पूर्व-प्रसंस्करण मजबूत मशीन लर्निंग मॉडल बनाने के लिए महत्वपूर्ण है। निम्नलिखित चरण Weather Australia डेटासेट पर लागू किए गए पूर्व-प्रसंस्करण पाइपलाइन को रूपरेखा प्रदान करते हैं।
1. लाइब्रेरी और डेटा आयात करना




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, MinMaxScaler, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc, classification_report
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import pandas as pd 
import seaborn as sns
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, MinMaxScaler, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc, classification_report
					
				
			
		






		
		
			
			
Java
			
			data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
			
				
					
				
					1
2
				
						data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
					
				
			
		


नमूना आउटपुट:

  
    तारीख
    स्थान
    न्यूनतम तापमान
    अधिकतम तापमान
    बारिश
    वाष्पीकरण
    धूप
    ...
    आज बारिश
    RISK_MM
    कल बारिश
  
  
    05/01/2012
    CoffsHarbour
    21.3
    26.5
    0.6
    7.6
    6.4
    ...
    No
    0.0
    No
  

2. फीचर चयन
डेटासेट को फीचर्स (X) और लक्ष्य (y) में अलग करें।




		
		
			
			
Java
			
			X = data.iloc[:,:-1]
X.drop('RISK_MM', axis=1, inplace=True)
y = data.iloc[:,-1]
			
				
					
				
					1
2
3
				
						X = data.iloc[:,:-1]
X.drop('RISK_MM', axis=1, inplace=True)
y = data.iloc[:,-1]
					
				
			
		


3. गायब डेटा का प्रबंधन
a. संख्यात्मक फीचर्स
औसत रणनीति का उपयोग करके संख्यात्मक स्तंभों में गायब मानों को इम्प्यूट करें।




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


b. वर्गीकृत फीचर्स
सबसे अधिक सामान्य रणनीति का उपयोग करके वर्गीकृत स्तंभों में गायब मानों को इम्प्यूट करें।




		
		
			
			
Java
			
			string_cols = list(np.where((X.dtypes == object))[0])
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
				
						string_cols = list(np.where((X.dtypes == object))[0])
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		


4. वर्गीकृत वेरिएबल्स को एन्कोड करना
a. लेबल एनकोडिंग
लक्ष्य वेरिएबल के लिए वर्गीकृत लेबल को संख्यात्मक मानों में परिवर्तित करें।




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

y = LabelEncoderMethod(y)
			
				
					
				
					1
2
3
4
5
				
						def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series) 
 
y = LabelEncoderMethod(y)
					
				
			
		


b. वन-हॉट एनकोडिंग
दो से अधिक अद्वितीय मानों वाले वर्गीकृत फीचर्स पर वन-हॉट एनकोडिंग लागू करें।




		
		
			
			
Java
			
			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_values = len(pd.unique(X[X.columns[col]]))
        if unique_values == 2 or unique_values > 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

X = EncodingSelection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						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_values = len(pd.unique(X[X.columns[col]]))
        if unique_values == 2 or unique_values > 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
 
X = EncodingSelection(X)
					
				
			
		


5. फीचर स्केलिंग और चयन
a. फीचर स्केलिंग
परिवर्तनीयों में एकरूपता सुनिश्चित करने के लिए फीचर सेट को मानकीकृत करें।




		
		
			
			
Java
			
			sc = StandardScaler(with_mean=False)
X = sc.fit_transform(X)
			
				
					
				
					1
2
				
						sc = StandardScaler(with_mean=False)
X = sc.fit_transform(X)
					
				
			
		


b. फीचर चयन
काई-स्क्वायर (chi2) सांख्यिकीय परीक्षण के आधार पर शीर्ष 10 फीचर्स चुनें।




		
		
			
			
Java
			
			kbest = SelectKBest(score_func=chi2, k=10)
X = kbest.fit_transform(X, y)
			
				
					
				
					1
2
				
						kbest = SelectKBest(score_func=chi2, k=10)
X = kbest.fit_transform(X, y)
					
				
			
		


6. ट्रेन-टेस्ट विभाजन
मॉडल के प्रदर्शन का मूल्यांकन करने के लिए डेटासेट को प्रशिक्षण और परीक्षण सेटों में विभाजित करें।




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



लॉजिस्टिक रिग्रेशन मॉडल का निर्माण और मूल्यांकन
डेटा पूर्व-प्रसंस्कृत होने के साथ, हम लॉजिस्टिक रिग्रेशन मॉडल बनाने, इसके प्रदर्शन का मूल्यांकन करने, और ROC और AUC मेट्रिक्स का उपयोग करके इसे अनुकूलित करने की प्रक्रिया को आगे बढ़ाते हैं।
1. मॉडल का प्रशिक्षण




		
		
			
			
Java
			
			LRM = LogisticRegression(random_state=0, max_iter=500)
LRM.fit(X_train, y_train)
y_pred = LRM.predict(X_test)
print(f"Accuracy: {accuracy_score(y_pred, y_test):.3f}")
			
				
					
				
					1
2
3
4
				
						LRM = LogisticRegression(random_state=0, max_iter=500)
LRM.fit(X_train, y_train)
y_pred = LRM.predict(X_test)
print(f"Accuracy: {accuracy_score(y_pred, y_test):.3f}")
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Accuracy: 0.872
			
				
					
				
					1
				
						Accuracy: 0.872
					
				
			
		


2. ROC कर्व और AUC गणना
ROC कर्व को प्लॉट करना और AUC की गणना मॉडल के प्रदर्शन की व्यापक समझ प्रदान करती है।




		
		
			
			
Java
			
			predicted_probabilities = LRM.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, predicted_probabilities[:,1])
roc_auc = auc(fpr, tpr)
print(f"AUC: {roc_auc:.3f}")
			
				
					
				
					1
2
3
4
				
						predicted_probabilities = LRM.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, predicted_probabilities[:,1])
roc_auc = auc(fpr, tpr)
print(f"AUC: {roc_auc:.3f}")
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			AUC: 0.884
			
				
					
				
					1
				
						AUC: 0.884
					
				
			
		


3. क्लासिफिकेशन थ्रेशोल्ड का अनुकूलन
0.5 का डिफ़ॉल्ट थ्रेशोल्ड हमेशा सबसे अच्छा प्रदर्शन नहीं दे सकता। इस थ्रेशोल्ड को समायोजित करने से सटीकता और अन्य मेट्रिक्स में सुधार हो सकता है।
a. थ्रेशोल्ड्स के बीच सटीकता की गणना करना




		
		
			
			
Java
			
			accuracies = []
for thresh in thresholds:
    _predictions = [1 if i >= thresh else 0 for i in predicted_probabilities[:, -1]]
    accuracies.append(accuracy_score(y_test, _predictions, normalize=True))

accuracies = pd.concat([pd.Series(thresholds), pd.Series(accuracies)], axis=1)
accuracies.columns = ['threshold', 'accuracy']
accuracies.sort_values(by='accuracy', ascending=False, inplace=True)
print(accuracies.head())
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						accuracies = []
for thresh in thresholds:
    _predictions = [1 if i >= thresh else 0 for i in predicted_probabilities[:, -1]]
    accuracies.append(accuracy_score(y_test, _predictions, normalize=True))
 
accuracies = pd.concat([pd.Series(thresholds), pd.Series(accuracies)], axis=1)
accuracies.columns = ['threshold', 'accuracy']
accuracies.sort_values(by='accuracy', ascending=False, inplace=True)
print(accuracies.head())
					
				
			
		


नमूना आउटपुट:




		
		
			
			
Java
			
			   threshold  accuracy
78    0.547545    0.8760
76    0.560424    0.8755
114   0.428764    0.8755
112   0.432886    0.8755
110   0.433176    0.8755
			
				
					
				
					1
2
3
4
5
6
				
						   threshold  accuracy
78    0.547545    0.8760
76    0.560424    0.8755
114   0.428764    0.8755
112   0.432886    0.8755
110   0.433176    0.8755
					
				
			
		


b. इष्टतम थ्रेशोल्ड का चयन करना




		
		
			
			
Java
			
			optimal_proba_cutoff = accuracies['threshold'].iloc[0]
roc_predictions = [1 if i >= optimal_proba_cutoff else 0 for i in predicted_probabilities[:, -1]]
			
				
					
				
					1
2
				
						optimal_proba_cutoff = accuracies['threshold'].iloc[0]
roc_predictions = [1 if i >= optimal_proba_cutoff else 0 for i in predicted_probabilities[:, -1]]
					
				
			
		


c. इष्टतम थ्रेशोल्ड के साथ मूल्यांकन करना




		
		
			
			
Java
			
			print("Classification Report with Optimal Threshold:")
print(classification_report(roc_predictions, y_test))
			
				
					
				
					1
2
				
						print("Classification Report with Optimal Threshold:")
print(classification_report(roc_predictions, y_test))
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			              precision    recall  f1-score   support

           0       0.97      0.89      0.93      1770
           1       0.48      0.77      0.59       230

    accuracy                           0.88      2000
   macro avg       0.72      0.83      0.76      2000
weighted avg       0.91      0.88      0.89      2000
			
				
					
				
					1
2
3
4
5
6
7
8
				
						              precision    recall  f1-score   support
 
           0       0.97      0.89      0.93      1770
           1       0.48      0.77      0.59       230
 
    accuracy                           0.88      2000
   macro avg       0.72      0.83      0.76      2000
weighted avg       0.91      0.88      0.89      2000
					
				
			
		


डिफ़ॉल्ट थ्रेशोल्ड के साथ तुलना:




		
		
			
			
Java
			
			print("Classification Report with Default Threshold (0.5):")
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
				
						print("Classification Report with Default Threshold (0.5):")
print(classification_report(y_pred, y_test))
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			              precision    recall  f1-score   support

           0       0.96      0.89      0.92      1740
           1       0.51      0.73      0.60       260

    accuracy                           0.87      2000
   macro avg       0.73      0.81      0.76      2000
weighted avg       0.90      0.87      0.88      2000
			
				
					
				
					1
2
3
4
5
6
7
8
				
						              precision    recall  f1-score   support
 
           0       0.96      0.89      0.92      1740
           1       0.51      0.73      0.60       260
 
    accuracy                           0.87      2000
   macro avg       0.73      0.81      0.76      2000
weighted avg       0.90      0.87      0.88      2000
					
				
			
		


जानकारी:

  सटीकता में सुधार: इष्टतम थ्रेशोल्ड से सटीकता में 87.2% से 88% तक थोड़ा सुधार होता है।
  F1-स्कोर में सुधार: F1-स्कोर में 0.60 से 0.59 तक सुधार होता है (प्रिसीजन और रिकॉल के बीच संतुलन को देखते हुए सीमित सुधार)।
  संतुलित प्रिसीजन और रिकॉल: इष्टतम थ्रेशोल्ड प्रिसीजन और रिकॉल दोनों में संतुलन बनाए रखता है, यह सुनिश्चित करते हुए कि किसी एक को अत्यधिक महत्व नहीं दिया गया है।


थ्रेशोल्ड अनुकूलन के लिए सर्वोत्तम अभ्यास

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


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

  ROC और AUC विभिन्न थ्रेशोल्ड पर मॉडल के प्रदर्शन का समग्र दृष्टिकोण प्रदान करते हैं।
  थ्रेशोल्ड अनुकूलन मॉडल मेट्रिक्स को बेहतर बना सकता है, प्रदर्शन को अनुप्रयोग-विशिष्ट आवश्यकताओं के अनुरूप ढालता है।
  व्यापक पूर्व-प्रसंस्करण मजबूत और प्रभावी मशीन लर्निंग मॉडल बनाने के लिए मौलिक है।

इन रणनीतियों के साथ अपने मॉडलों को परिष्कृत करना शुरू करें ताकि बेहतरीन प्रदर्शन और सार्थक अंतर्दृष्टियाँ प्राप्त की जा सकें।

अतिरिक्त संसाधन

  Scikit-learn प्रलेखन
  Kaggle डेटासेट
  ROC कर्व्स को समझना


लेखक: [आपका नाम]

तकनीकी लेखक और डेटा साइंस उत्साही