S29L06 – CAP वक्र कार्यान्वयन

html
पाइथन में समग्र सटीकता प्रोफ़ाइल (CAP) वक्रों को लागू करना: एक व्यापक मार्गदर्शिका



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

विषय सूची


CAP वक्रों का परिचय
CAP वक्रों के महत्व को समझना
CAP वक्र कार्यान्वयन के लिए डेटा की तैयारी
गायब डेटा को संभालना
श्रेणीबद्ध चर को एन्कोड करना
फीचर चयन और स्केलिंग
वर्गीकरण मॉडलों का निर्माण और मूल्यांकन
CAP वक्र उत्पन्न करना
CAP वक्रों के उपयोग से कई मॉडलों की तुलना करना
निष्कर्ष
संदर्भ



1. CAP वक्रों का परिचय

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

CAP वक्रों की मुख्य विशेषताएँ:

सहज दृश्यीकरण: यादृच्छिक चयन की तुलना में मॉडल के प्रदर्शन का स्पष्ट चित्रण प्रदान करता है।
मॉडल तुलना: एक ही डेटासेट पर कई मॉडलों की तुलना करने में सहायक।
प्रदर्शन मेट्रिक: CAP वक्र के नीचे का क्षेत्रफल (AUC) मॉडल मूल्यांकन के लिए एक मेट्रिक के रूप में कार्य करता है।



2. CAP वक्रों के महत्व को समझना

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

CAP वक्रों के उपयोग के लाभ:

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



3. CAP वक्र कार्यान्वयन के लिए डेटा की तैयारी

सटीक मॉडल मूल्यांकन और CAP वक्र उत्पन्न करने के लिए उचित डेटा तैयारी आवश्यक है। यहां पाइथन की Pandas और Scikit-learn लाइब्रेरीज़ का उपयोग करके डेटा प्रीप्रोसेसिंग चरणों का एक विवेचन प्रस्तुत किया गया है।

चरण-दर-चरण डेटा तैयारी:


लाइब्रेरीज़ इम्पोर्ट करना:




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns
			
				
					
				
					1
2
				
						import pandas as pd 
import seaborn as sns
					
				
			
		



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




		
		
			
			
Java
			
			data = pd.read_csv('bangla.csv')
data.tail()
			
				
					
				
					1
2
				
						data = pd.read_csv('bangla.csv')
data.tail()
					
				
			
		



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




		
		
			
			
Java
			
			                                                 file_name  zero_crossing  ...
1737  Tumi Robe Nirobe, Artist - DWIJEN  MUKHOPADHYA...          78516   
1738  TUMI SANDHYAR MEGHMALA  Srikanta Acharya  Rabi...         176887   
...
			
				
					
				
					1
2
3
4
				
						                                                 file_name  zero_crossing  ...
1737  Tumi Robe Nirobe, Artist - DWIJEN  MUKHOPADHYA...          78516   
1738  TUMI SANDHYAR MEGHMALA  Srikanta Acharya  Rabi...         176887   
...
					
				
			
		



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




		
		
			
			
Java
			
			X = data.iloc[:,:-1]
y = data.iloc[:,-1]
			
				
					
				
					1
2
				
						X = data.iloc[:,:-1]
y = data.iloc[:,-1]
					
				
			
		






4. गायब डेटा को संभालना

गायब डेटा मॉडल के प्रदर्शन को विकृत कर सकता है। प्रशिक्षण से पहले गायब मानों को संबोधित करना आवश्यक है।

संख्यात्मक गायब मानों को संभालना:




		
		
			
			
Java
			
			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])
			
				
					
				
					1
2
3
4
5
6
7
				
						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])
					
				
			
		



श्रेणीबद्ध गायब मानों को संभालना:




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




5. श्रेणीबद्ध चर को एन्कोड करना

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

वन-हॉट एन्कोडिंग विधि:




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

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices )], remainder='passthrough')
    return columnTransformer.fit_transform(data)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices )], remainder='passthrough')
    return columnTransformer.fit_transform(data)
					
				
			
		



लेबल एन्कोडिंग विधि:




		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series) 
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series) 
					
				
			
		



एन्कोडिंग को लागू करना:




		
		
			
			
Java
			
			y = LabelEncoderMethod(y)

def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == np.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

X = EncodingSelection(X)
X.shape  # Output: (1742, 30)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						y = LabelEncoderMethod(y)
 
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == np.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
 
X = EncodingSelection(X)
X.shape  # Output: (1742, 30)
					
				
			
		






6. फीचर चयन और स्केलिंग

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

फीचर चयन:




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

kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.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)
X.shape  # Output: (1742, 10)
del x_temp
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.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)
X.shape  # Output: (1742, 10)
del x_temp
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn import preprocessing

sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)

X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn import preprocessing
 
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
 
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		




7. वर्गीकरण मॉडलों का निर्माण और मूल्यांकन

CAP वक्रों का उपयोग करके उनके प्रदर्शन का मूल्यांकन करने के लिए कई वर्गीकरण मॉडल प्रशिक्षित किए जाते हैं।

ट्रेन-टेस्ट विभाजन:




		
		
			
			
Java
			
			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)
			
				
					
				
					1
2
3
				
						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)
					
				
			
		



मॉडलों का निर्माण:

के-नियरस्ट नेबर्स (KNN):




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)  # Output: 0.6475
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)  # Output: 0.6475
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)  # Output: ~0.63
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.linear_model import LogisticRegression
 
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)  # Output: ~0.63
					
				
			
		



गॉसियन नायव बेयस:




		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
y_pred_gnb = model_GNB.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)  # Output: 0.831
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.naive_bayes import GaussianNB
 
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
y_pred_gnb = model_GNB.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)  # Output: 0.831
					
				
			
		



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




		
		
			
			
Java
			
			from sklearn.svm import SVC

model_SVC = SVC()
model_SVC.fit(X_train, y_train)
y_pred_svc = model_SVC.predict(X_test)
svc_accuracy = accuracy_score(y_pred_svc, y_test)  # Output: 0.8765
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.svm import SVC
 
model_SVC = SVC()
model_SVC.fit(X_train, y_train)
y_pred_svc = model_SVC.predict(X_test)
svc_accuracy = accuracy_score(y_pred_svc, y_test)  # Output: 0.8765
					
				
			
		



डिसीजन ट्री क्लासिफायर:




		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)
y_pred_dtc = model_DTC.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)  # Output: 0.8175
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.tree import DecisionTreeClassifier
 
model_DTC = DecisionTreeClassifier()
model_DTC.fit(X_train, y_train)
y_pred_dtc = model_DTC.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)  # Output: 0.8175
					
				
			
		



रैंडम फॉरेस्ट क्लासिफायर:




		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
y_pred_rfc = model_RFC.predict(X_test)
rfc_accuracy = accuracy_score(y_pred_rfc, y_test)  # Output: 0.8725
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.ensemble import RandomForestClassifier
 
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
y_pred_rfc = model_RFC.predict(X_test)
rfc_accuracy = accuracy_score(y_pred_rfc, y_test)  # Output: 0.8725
					
				
			
		



AdaBoost क्लासिफायर:




		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
y_pred_abc = model_ABC.predict(X_test)
abc_accuracy = accuracy_score(y_pred_abc, y_test)  # Output: 0.8725
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.ensemble import AdaBoostClassifier
 
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
y_pred_abc = model_ABC.predict(X_test)
abc_accuracy = accuracy_score(y_pred_abc, y_test)  # Output: 0.8725
					
				
			
		



XGBoost क्लासिफायर:




		
		
			
			
Java
			
			import xgboost as xgb

model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
y_pred_xgb = model_xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)  # Output: 0.8715
			
				
					
				
					1
2
3
4
5
6
				
						import xgboost as xgb
 
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
y_pred_xgb = model_xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)  # Output: 0.8715
					
				
			
		






8. CAP वक्र उत्पन्न करना

CAP वक्र मॉडल के प्रदर्शन को एक यादृच्छिक मॉडल के मुकाबले देखने के लिए प्लॉट किया जाता है।

यादृच्छिक मॉडल को प्लॉट करना:




		
		
			
			
Java
			
			import matplotlib.pyplot as plt

# कुल टेस्ट सैंपल्स की संख्या
total = len(y_test) 

# कुल सकारात्मक उदाहरणों की संख्या
sum_count = np.sum(y_test) 

plt.figure(figsize=(10, 6)) 

# यादृच्छिक मॉडल को प्लॉट करना
plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='Random Model') 
plt.legend()
plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						import matplotlib.pyplot as plt
 
# कुल टेस्ट सैंपल्स की संख्या
total = len(y_test) 
 
# कुल सकारात्मक उदाहरणों की संख्या
sum_count = np.sum(y_test) 
 
plt.figure(figsize=(10, 6)) 
 
# यादृच्छिक मॉडल को प्लॉट करना
plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='Random Model') 
plt.legend()
plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.show()
					
				
			
		



लॉजिस्टिक रिग्रेशन मॉडल को प्लॉट करना:




		
		
			
			
Java
			
			# लॉजिस्टिक रिग्रेशन का उपयोग करके भविष्यवाणी करना
pred_lr = LRM.predict(X_test)
x_values = np.arange(0, total + 1)

# भविष्यवाणियों और वास्तविक मानों को सॉर्ट करना
sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)

# CAP मान उत्पन्न करना
cap = []
for p, o in sorted_zip:
    if p == o:
        cap.append(p)
    else:
        cap.append(o)
        
y_values = np.append([0], np.cumsum(cap))

# CAP वक्र को प्लॉट करना
plt.figure(figsize=(10, 6)) 
plt.plot(x_values, y_values, color='blue', linewidth=3, label='Logistic Regression')
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 

plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
			
				
					
				
					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
27
				
						# लॉजिस्टिक रिग्रेशन का उपयोग करके भविष्यवाणी करना
pred_lr = LRM.predict(X_test)
x_values = np.arange(0, total + 1)
 
# भविष्यवाणियों और वास्तविक मानों को सॉर्ट करना
sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)
 
# CAP मान उत्पन्न करना
cap = []
for p, o in sorted_zip:
    if p == o:
        cap.append(p)
    else:
        cap.append(o)
        
y_values = np.append([0], np.cumsum(cap))
 
# CAP वक्र को प्लॉट करना
plt.figure(figsize=(10, 6)) 
plt.plot(x_values, y_values, color='blue', linewidth=3, label='Logistic Regression')
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 
 
plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
					
				
			
		






9. CAP वक्रों के उपयोग से कई मॉडलों की तुलना करना

मसलों के प्रदर्शन का दृश्य मूल्यांकन और तुलना करने के लिए कई मॉडलों के लिए CAP वक्रों को प्लॉट करके देखा जा सकता है।

CAP उत्पन्न करने का एक फंक्शन परिभाषित करना:




		
		
			
			
Java
			
			def CAP_gen(model, X_test=X_test, y_test=y_test):
    pred = model.predict(X_test)
    sorted_zip = sorted(zip(pred, y_test), reverse=True)
    cap = []
    for p, o in sorted_zip:
        if p == o:
            cap.append(p)
        else:
            cap.append(o)
    y_values = np.append([0], np.cumsum(cap))
    x_values = np.arange(0, len(y_test) + 1)
    return (x_values, y_values)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						def CAP_gen(model, X_test=X_test, y_test=y_test):
    pred = model.predict(X_test)
    sorted_zip = sorted(zip(pred, y_test), reverse=True)
    cap = []
    for p, o in sorted_zip:
        if p == o:
            cap.append(p)
        else:
            cap.append(o)
    y_values = np.append([0], np.cumsum(cap))
    x_values = np.arange(0, len(y_test) + 1)
    return (x_values, y_values)
					
				
			
		



कई CAP वक्रों को प्लॉट करना:




		
		
			
			
Java
			
			plt.figure(figsize=(10, 6)) 

# गॉसियन नायव बेयस के लिए CAP प्लॉट करना
x_gnb, y_gnb = CAP_gen(model_GNB)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# XGBoost के लिए CAP प्लॉट करना
x_xgb, y_xgb = CAP_gen(model_xgb)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# AdaBoost के लिए CAP प्लॉट करना
x_abc, y_abc = CAP_gen(model_ABC)
plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')

# यादृच्छिक मॉडल को प्लॉट करना
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 

plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						plt.figure(figsize=(10, 6)) 
 
# गॉसियन नायव बेयस के लिए CAP प्लॉट करना
x_gnb, y_gnb = CAP_gen(model_GNB)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')
 
# XGBoost के लिए CAP प्लॉट करना
x_xgb, y_xgb = CAP_gen(model_xgb)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')
 
# AdaBoost के लिए CAP प्लॉट करना
x_abc, y_abc = CAP_gen(model_ABC)
plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')
 
# यादृच्छिक मॉडल को प्लॉट करना
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 
 
plt.xlabel('कुल अवलोकन', fontsize=16)
plt.ylabel('CAP मान', fontsize=16)
plt.title('समग्र सटीकता प्रोफ़ाइल', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
					
				
			
		





CAP वक्रों से, XGBoost और SVM (SVC) जैसे मॉडल अपने संबंधित वक्रों के तहत बड़े क्षेत्रों के साथ बेहतर प्रदर्शन प्रदर्शित करते हैं, जो यादृच्छिक मॉडल की तुलना में सच्चे सकारात्मक भविष्यवाणियों को प्राथमिकता देने में उच्च कार्यक्षमता को इंगित करता है।


10. निष्कर्ष

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

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

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


11. संदर्भ


Scikit-learn दस्तावेजीकरण पर गायब मानों को पूरा करना
Scikit-learn दस्तावेजीकरण पर फीचर चयन
समग्र सटीकता प्रोफ़ाइल (CAP) वक्रों को समझना
XGBoost दस्तावेजीकरण




अस्वीकरण: इस लेख में संदर्भित छवियाँ (https://example.com/...) प्लेसहोल्डर हैं। इन्हें CAP वक्रों से संबंधित वास्तविक छवि यूआरएल से बदलें।