S26L04 – कन्फ्यूजन मैट्रिक्स त्रि-आयामी

html
भ्रम मैट्रिसेस में महारत: मशीन लर्निंग अभ्यासकर्ताओं के लिए एक व्यापक गाइड

सामग्री सूची

    भ्रम मैट्रिक्स क्या है?
    भ्रम मैट्रिक्स के घटक
        
            सच्चा सकारात्मक (TP)
            सच्चा नकारात्मक (TN)
            फर्ज़ी सकारात्मक (FP)
            फर्ज़ी नकारात्मक (FN)
        
    
    एकाधिक श्रेणियों के साथ भ्रम मैट्रिक्स को समझना
    Scikit-Learn का उपयोग करके भ्रम मैट्रिक्स बनाना
    भ्रम मैट्रिक्स को दृश्य रूप देना
    मॉडल प्रदर्शन मीट्रिक्स की व्याख्या
        
            सटीकता
            परिशुद्धता
            रिकॉल
            F1 स्कोर
            विशिष्टता
        
    
    उन्नत: एकाधिक श्रेणी भ्रम मैट्रिसेस को संभालना
    मौसम भविष्यवाणी डेटासेट के साथ व्यावहारिक कार्यान्वयन
    निष्कर्ष


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



चित्र 1: भ्रम मैट्रिक्स की बुनियादी संरचना।

भ्रम मैट्रिक्स के घटक
भ्रम मैट्रिक्स के व्यक्तिगत घटकों को समझना परिणामों की प्रभावी व्याख्या के लिए महत्वपूर्ण है। मैट्रिक्स चार प्रमुख मीट्रिक्स से बना होता है:

सच्चा सकारात्मक (TP)

    परिभाषा: सकारात्मक के रूप में सही तरीके से वर्गीकृत की गई स्थितियों की संख्या।
    उदाहरण: यदि मॉडल भविष्यवाणी करता है कि कल बारिश होगी और वास्तव में बारिश होती है, तो यह एक सच्चा सकारात्मक है।


सच्चा नकारात्मक (TN)

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


फर्ज़ी सकारात्मक (FP)

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


फर्ज़ी नकारात्मक (FN)

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




चित्र 2: भ्रम मैट्रिक्स के भीतर TP, TN, FP, और FN का विभाजन।

एकाधिक श्रेणियों के साथ भ्रम मैट्रिक्स को समझना
जहाँ बाइनरी वर्गीकरण में दो श्रेणियाँ (सकारात्मक और नकारात्मक) शामिल होती हैं, वहीं बहु-श्रेणी वर्गीकरण भ्रम मैट्रिक्स को और अधिक श्रेणियों के लिए विस्तारित करता है। उदाहरण के लिए, तीन श्रेणियों वाले एक डेटासेट—सेटोसा, वर्सिकोलर, और वर्जिनिका—में, भ्रम मैट्रिक्स एक 3x3 ग्रिड बन जाता है। प्रत्येक पंक्ति वास्तविक श्रेणी का प्रतिनिधित्व करती है, और प्रत्येक कॉलम भविष्यवाणी की गई श्रेणी का प्रतिनिधित्व करता है। तिरछी रेखा के तत्व अभी भी सही भविष्यवाणियों का प्रतिनिधित्व करते हैं, जबकि ऑफ-डायगोनल तत्व विभिन्न प्रकार की गलत वर्गीकरण को दर्शाते हैं।



चित्र 3: एक बहु-श्रेणी भ्रम मैट्रिक्स का उदाहरण।

Scikit-Learn का उपयोग करके भ्रम मैट्रिक्स बनाना
पाइथन की scikit-learn लाइब्रेरी भ्रम मैट्रिसेस को उत्पन्न करने और विश्लेषण करने के लिए मजबूत उपकरण प्रदान करती है। नीचे scikit-learn का उपयोग करके भ्रम मैट्रिक्स बनाने के लिए चरण-दर-चरण गाइड दिया गया है, जिसे एक व्यावहारिक उदाहरण के साथ पूरा किया गया है।

चरण 1: आवश्यक पुस्तकालय आयात करें




		
		
			
			
Java
			
			import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
					
				
			
		



चरण 2: डेटासेट लोड और तैयार करें
प्रदर्शन के लिए, हम Weather Australia डेटासेट का उपयोग करेंगे।





		
		
			
			
Java
			
			# डेटासेट को लोड करें
data = pd.read_csv('weatherAUS.csv')

# विशेषताओं और लक्ष्य परिवर्तनीय को परिभाषित करें
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# गायब डेटा को संभालना
from sklearn.impute import SimpleImputer
import numpy as np

# संख्यात्मक विशेषताएँ
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

# श्रेणीबद्ध विशेषताएँ
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])

# श्रेणीबद्ध परिवर्तनीयों को एन्कोड करना
X = pd.get_dummies(X, drop_first=True)

# लक्ष्य परिवर्तनीय को एन्कोड करना
le = LabelEncoder()
y = le.fit_transform(y)
			
				
					
				
					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
				
						# डेटासेट को लोड करें
data = pd.read_csv('weatherAUS.csv')
 
# विशेषताओं और लक्ष्य परिवर्तनीय को परिभाषित करें
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# गायब डेटा को संभालना
from sklearn.impute import SimpleImputer
import numpy as np
 
# संख्यात्मक विशेषताएँ
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
 
# श्रेणीबद्ध विशेषताएँ
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])
 
# श्रेणीबद्ध परिवर्तनीयों को एन्कोड करना
X = pd.get_dummies(X, drop_first=True)
 
# लक्ष्य परिवर्तनीय को एन्कोड करना
le = LabelEncoder()
y = le.fit_transform(y)
					
				
			
		



चरण 3: डेटासेट को विभाजित करें




		
		
			
			
Java
			
			# प्रशिक्षण और परीक्षण सेट में विभाजित करें
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
4
				
						# प्रशिक्षण और परीक्षण सेट में विभाजित करें
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
					
				
			
		



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




		
		
			
			
Java
			
			# विशेषताओं को मानकीकृत करें
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
				
						# विशेषताओं को मानकीकृत करें
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



चरण 5: एक वर्गीकरण मॉडल ट्रेन करें
इस उदाहरण के लिए हम लॉजिस्टिक रिग्रेशन का उपयोग करेंगे।





		
		
			
			
Java
			
			# मॉडल को इनिशियलाइज़ और ट्रेन करें
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)

# भविष्यवाणियाँ करें
y_pred = model.predict(X_test)
			
				
					
				
					1
2
3
4
5
6
				
						# मॉडल को इनिशियलाइज़ और ट्रेन करें
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)
 
# भविष्यवाणियाँ करें
y_pred = model.predict(X_test)
					
				
			
		



चरण 6: भ्रम मैट्रिक्स उत्पन्न करें




		
		
			
			
Java
			
			# सटीकता की गणना करें
accuracy = accuracy_score(y_pred, y_test)
print(f'Accuracy: {accuracy:.4f}')

# भ्रम मैट्रिक्स उत्पन्न करें
cm = confusion_matrix(y_test, y_pred)
print('Confusion Matrix:')
print(cm)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# सटीकता की गणना करें
accuracy = accuracy_score(y_pred, y_test)
print(f'Accuracy: {accuracy:.4f}')
 
# भ्रम मैट्रिक्स उत्पन्न करें
cm = confusion_matrix(y_test, y_pred)
print('Confusion Matrix:')
print(cm)
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Accuracy: 0.8297
Confusion Matrix:
[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
3
4
				
						Accuracy: 0.8297
Confusion Matrix:
[[21087  1058]
 [ 3786  2508]]
					
				
			
		



भ्रम मैट्रिक्स को दृश्य रूप देना
दृश्यकरण मॉडल प्रदर्शन की सहज समझ में सहायक होता है। Scikit-learn भ्रम मैट्रिसेस को आसानी से प्लॉट करने के लिए अंतर्निर्मित फंक्शन्स प्रदान करता है।





		
		
			
			
Java
			
			# भ्रम मैट्रिक्स को प्लॉट करें
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Confusion Matrix')
plt.show()
			
				
					
				
					1
2
3
4
				
						# भ्रम मैट्रिक्स को प्लॉट करें
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Confusion Matrix')
plt.show()
					
				
			
		





चित्र 4: scikit-learn का उपयोग करके भ्रम मैट्रिक्स का दृश्यकरण।

मॉडल प्रदर्शन मीट्रिक्स की व्याख्या
सटीकता से परे, भ्रम मैट्रिक्स कई अन्य प्रदर्शन मीट्रिक्स की गणना की अनुमति देता है:

सटीकता

    परिभाषा: कुल स्थितियों में से सही तरीके से वर्गीकृत की गई स्थितियों का अनुपात।
    सूत्र: 
      \[
      \text{सटीकता} = \frac{TP + TN}{TP + TN + FP + FN}
      \]
    
    व्याख्या: उपयोगी होने के बावजूद, सटीकता भ्रामक हो सकती है, विशेष रूप से असंतुलित डेटासेट में।


परिशुद्धता

    परिभाषा: सही तरीके से预测 किए गए सकारात्मक अवलोकनों का कुल预测 सकारात्मकों पर अनुपात।
    सूत्र: 
      \[
      \text{परिशुद्धता} = \frac{TP}{TP + FP}
      \]
    
    व्याख्या: उच्च परिशुद्धता यह संकेत देती है कि एक एल्गोरिदम ने अप्रासंगिक परिणामों की तुलना में काफी अधिक प्रासंगिक परिणाम लौटाए हैं।


रिकॉल (संवेदनशीलता)

    परिभाषा: सही तरीके से预测 किए गए सकारात्मक अवलोकनों का वास्तविक श्रेणी में सभी अवलोकनों पर अनुपात।
    सूत्र: 
      \[
      \text{रिकॉल} = \frac{TP}{TP + FN}
      \]
    
    व्याख्या: उच्च रिकॉल यह संकेत देता है कि एक एल्गोरिदम ने अधिकांश प्रासंगिक परिणामों को लौटाया है।


F1 स्कोर

    परिभाषा: परिशुद्धता और रिकॉल का भारित औसत।
    सूत्र: 
      \[
      F1 = 2 \times \frac{\text{परिशुद्धता} \times \text{रिकॉल}}{\text{परिशुद्धता} + \text{रिकॉल}}
      \]
    
    व्याख्या: F1 स्कोर परिशुद्धता और रिकॉल के बीच संतुलन को दर्शाता है।


विशिष्टता

    परिभाषा: सही तरीके से预测 किए गए नकारात्मक अवलोकनों का सभी वास्तविक नकारात्मकों पर अनुपात।
    सूत्र: 
      \[
      \text{विशिष्टता} = \frac{TN}{TN + FP}
      \]
    
    व्याख्या: उच्च विशिष्टता यह संकेत देती है कि मॉडल नकारात्मक मामलों की पहचान को प्रभावी ढंग से करता है।


उन्नत: एकाधिक श्रेणी भ्रम मैट्रिसेस को संभालना
दो से अधिक श्रेणियों वाले परिदृश्यों में, भ्रम मैट्रिक्स एक बहु-मैत्रिक ग्रिड में विस्तारित हो जाता है। प्रत्येक तिरछा तत्व प्रत्येक श्रेणी के लिए सही तरीके से वर्गीकृत किए गए अवलोकनों का प्रतिनिधित्व करता है, जबकि ऑफ-डायगोनल तत्व विभिन्न प्रकार की गलत वर्गीकरण को दर्शाते हैं।

उदाहरण:
तीन-श्रेणी वर्गीकरण समस्या जिसमें श्रेणियाँ A, B, और C हैं, पर विचार करें।





		
		
			
			
Java
			
			               Predicted
               A    B    C
Actual A      50     2     3
       B       5    45     5
       C       2     3    48
			
				
					
				
					1
2
3
4
5
				
						               Predicted
               A    B    C
Actual A      50     2     3
       B       5    45     5
       C       2     3    48
					
				
			
		




    श्रेणी A के लिए सच्चे सकारात्मक: 50
    श्रेणी A के लिए फर्ज़ी सकारात्मक: 5 (B से) + 2 (C से) = 7
    श्रेणी A के लिए फर्ज़ी नकारात्मक: 2 (B को) + 3 (C को) = 5
    श्रेणी A के लिए सच्चे नकारात्मक: कुल - (TP + FP + FN) = 100 - (50 + 7 + 5) = 38


Scikit-learn का confusion_matrix फंक्शन आसानी से बहु-श्रेणी परिदृश्यों को संभालता है, एक स्पष्ट मैट्रिक्स प्रदान करता है जो विस्तृत प्रदर्शन विश्लेषण को सुविधाजनक बनाता है।

मौसम भविष्यवाणी डेटासेट के साथ व्यावहारिक कार्यान्वयन
सिद्धांतों को मजबूत करने के लिए, आइए Weather Australia डेटासेट का उपयोग करके एक व्यावहारिक उदाहरण पर चलते हैं। यह डेटासेट विभिन्न मौसम विशेषताओं के आधार पर अगले दिन बारिश होगी या नहीं, इसकी भविष्यवाणी करने में शामिल है।

चरण-दर-चरण कार्यान्वयन

    डेटा पूर्व-संसाधन:
        
            SimpleImputer का उपयोग करके गायब मानों को संभालें।
            एक-हॉट एन्कोडिंग का उपयोग करके श्रेणीबद्ध परिवर्तनीयों को एन्कोड करें।
            LabelEncoder का उपयोग करके लक्ष्य परिवर्तनीय को एन्कोड करें।
        
    
    फीचर स्केलिंग:
        
            विशेषताओं को इस प्रकार मानकीकृत करें कि प्रत्येक मॉडल प्रदर्शन में समान रूप से योगदान दे।
        
    
    मॉडल प्रशिक्षण:
        
            K-Nearest Neighbors, Logistic Regression, Gaussian Naive Bayes, Support Vector Machines, Decision Trees, Random Forests, AdaBoost, और XGBoost जैसे कई वर्गीकरण मॉडल को ट्रेन करें।
        
    
    मूल्यांकन:
        
            प्रत्येक मॉडल के लिए सटीकता स्कोर की गणना करें।
            भ्रम मैट्रिसेस उत्पन्न करें और उन्हें दृश्य रूप देकर भविष्यवाणियों के वितरण को समझें।
        
    


नमूना कोड स्निपेट्स

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




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# मॉडल को इनिशियलाइज़ करें
LRM = LogisticRegression(random_state=0, max_iter=200)

# मॉडल को ट्रेन करें
LRM.fit(X_train, y_train)

# परीक्षण डेटा पर भविष्यवाणी करें
y_pred = LRM.predict(X_test)

# सटीकता का मूल्यांकन करें
print(accuracy_score(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.linear_model import LogisticRegression
 
# मॉडल को इनिशियलाइज़ करें
LRM = LogisticRegression(random_state=0, max_iter=200)
 
# मॉडल को ट्रेन करें
LRM.fit(X_train, y_train)
 
# परीक्षण डेटा पर भविष्यवाणी करें
y_pred = LRM.predict(X_test)
 
# सटीकता का मूल्यांकन करें
print(accuracy_score(y_pred, y_test))
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			0.8296705228735187
			
				
					
				
					1
				
						0.8296705228735187
					
				
			
		



भ्रम मैट्रिक्स उत्पन्न करना:




		
		
			
			
Java
			
			from sklearn.metrics import confusion_matrix, plot_confusion_matrix

# भ्रम मैट्रिक्स की गणना करें
cm = confusion_matrix(y_test, y_pred)
print(cm)

# भ्रम मैट्रिक्स को प्लॉट करें
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Logistic Regression Confusion Matrix')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.metrics import confusion_matrix, plot_confusion_matrix
 
# भ्रम मैट्रिक्स की गणना करें
cm = confusion_matrix(y_test, y_pred)
print(cm)
 
# भ्रम मैट्रिक्स को प्लॉट करें
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Logistic Regression Confusion Matrix')
plt.show()
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
				
						[[21087  1058]
 [ 3786  2508]]
					
				
			
		





चित्र 5: लॉजिस्टिक रिग्रेशन मॉडल के लिए भ्रम मैट्रिक्स।

कई मॉडलों की तुलनात्मक सटीकता:




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# मॉडलों को इनिशियलाइज़ करें
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Logistic Regression': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}

# मॉडलों को ट्रेन और मूल्यांकन करें
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'{name} Accuracy: {accuracy:.4f}')
			
				
					
				
					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
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb
 
# मॉडलों को इनिशियलाइज़ करें
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Logistic Regression': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}
 
# मॉडलों को ट्रेन और मूल्यांकन करें
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'{name} Accuracy: {accuracy:.4f}')
					
				
			
		



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




		
		
			
			
Java
			
			KNN Accuracy: 0.8003
Logistic Regression Accuracy: 0.8297
GaussianNB Accuracy: 0.7960
SVC Accuracy: 0.8282
Decision Tree Accuracy: 0.8302
Random Forest Accuracy: 0.8302
AdaBoost Accuracy: 0.8299
XGBoost Accuracy: 0.8302
			
				
					
				
					1
2
3
4
5
6
7
8
				
						KNN Accuracy: 0.8003
Logistic Regression Accuracy: 0.8297
GaussianNB Accuracy: 0.7960
SVC Accuracy: 0.8282
Decision Tree Accuracy: 0.8302
Random Forest Accuracy: 0.8302
AdaBoost Accuracy: 0.8299
XGBoost Accuracy: 0.8302
					
				
			
		



आउटपुट से स्पष्ट है कि Decision Tree, Random Forest, और XGBoost मॉडल सबसे उच्च सटीकता प्रदर्शित करते हैं, जिन्हें Logistic Regression और AdaBoost ने निकटता से पीछा किया है।

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



अधिक विस्तृत उदाहरणों और उन्नत तकनीकों के लिए, scikit-learn दस्तावेजीकरण पर भ्रम मैट्रिसेस का संदर्भ लें।