S27L02 – वर्गीकरण मॉडल मुख्य टेम्पलेट

html
वर्गीकरण मॉडलों में महारत: मूल्यांकन तकनीकों और डेटासेट हैंडलिंग के साथ एक व्यापक मार्गदर्शिका

परिचय

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



सामग्री सूची


    डेटासेट को समझना
    डेटा प्रीप्रोसेसिंग
        
            मिसिंग डेटा को संभालना
            श्रेणीबद्ध वेरिएबल्स को एन्कोड करना
            फीचर चयन
            फीचर स्केलिंग
        
    
    वर्गीकरण मॉडलों का निर्माण और मूल्यांकन
        
            के-नियरेस्ट नेबर (KNN) क्लासिफायर
            लॉजिस्टिक रिग्रेशन
            गॉसियन नाइव बेयस (GaussianNB)
            समर्थन वेक्टर मशीन (SVM)
            डिसीजन ट्री क्लासिफायर
            रैंडम फॉरेस्ट क्लासिफायर
            एडा बूस्ट क्लासिफायर
            XGBoost क्लासिफायर
        
    
    निष्कर्ष




डेटासेट को समझना

मॉडल निर्माण में गहराई से उतरने से पहले, वर्तमान डेटासेट को समझना महत्वपूर्ण है। इस मार्गदर्शिका के लिए, हम Kaggle से Airline Passenger Satisfaction डेटासेट का उपयोग करेंगे। इस डेटासेट में यात्रियों की संतुष्टि को प्रभावित करने वाले विभिन्न कारक शामिल हैं, जिससे यह वर्गीकरण कार्यों के लिए आदर्श बनता है।

डेटा लोड करना

हम आवश्यक पुस्तकालयों को आयात करके और डेटासेट को pandas DataFrame में लोड करके शुरू करेंगे।





		
		
			
			
Java
			
			import pandas as pd
import seaborn as sns

# Load datasets
data1 = pd.read_csv('Airline1.csv')
data2 = pd.read_csv('Airline2.csv')

# Concatenate datasets
data = pd.concat([data1, data2])
print(data.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import pandas as pd
import seaborn as sns
 
# Load datasets
data1 = pd.read_csv('Airline1.csv')
data2 = pd.read_csv('Airline2.csv')
 
# Concatenate datasets
data = pd.concat([data1, data2])
print(data.shape)
					
				
			
		



Output:




		
		
			
			
Java
			
			(129880, 25)
			
				
					
				
					1
				
						(129880, 25)
					
				
			
		



इसका मतलब है कि हमारे पास प्रत्येक में 25 विशेषताओं के साथ 1,29,880 रिकॉर्ड्स हैं।



डेटा प्रीप्रोसेसिंग

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

मिसिंग डेटा को संभालना

संख्यात्मक डेटा:

संख्यात्मक कॉलमों के लिए, हम मिसिंग मानों को भरने के लिए माध्य इम्प्यूटेशन का उपयोग करेंगे।





		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

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

# Initialize imputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform
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
8
9
10
11
12
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Initialize imputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Fit and transform
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



श्रेणीबद्ध डेटा:

श्रेणीबद्ध कॉलमों के लिए, हम मिसिंग मानों को इम्प्यूट करने के लिए सबसे अधिक सामान्य रणनीति का उपयोग करेंगे।





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

# Initialize imputer
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						# Identify string/object columns
string_cols = list(np.where((X.dtypes == np.object))[0])
 
# Initialize imputer
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		



श्रेणीबद्ध वेरिएबल्स को एन्कोड करना

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

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

द्विआधारी श्रेणीबद्ध वेरिएबल्स या जिनमें श्रेणियों की संख्या अधिक होती है, उनके लिए लेबल एन्कोडिंग कुशल होता है।





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)

# Encode target variable
y = LabelEncoderMethod(y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
 
# Encode target variable
y = LabelEncoderMethod(y)
					
				
			
		



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

सीमित संख्या में श्रेणियों वाले श्रेणीबद्ध वेरिएबल्स के लिए, वन-हॉट एन्कोडिंग मॉडल को उन स्थानों के बीच कोई संबंध न बताते हुए उन्हें अलग करने में मदद करती है।





		
		
			
			
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
			
			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)
print(X.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						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)
print(X.shape)
					
				
			
		



Output:




		
		
			
			
Java
			
			(129880, 26)
			
				
					
				
					1
				
						(129880, 26)
					
				
			
		



फीचर चयन

सबसे प्रासंगिक फीचर्स का चयन करने से मॉडल प्रदर्शन में सुधार होता है और कंप्यूटेशनल जटिलता कम होती है। हम फीचर चयन के लिए ची-स्क्वायर टेस्ट का उपयोग करेंगे।





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

# Initialize
kbest = SelectKBest(score_func=chi2, k='all')
MMS = preprocessing.MinMaxScaler()
K_features = 10

# Apply transformations
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)

# Select top K features
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)
print(X.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
# Initialize
kbest = SelectKBest(score_func=chi2, k='all')
MMS = preprocessing.MinMaxScaler()
K_features = 10
 
# Apply transformations
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
 
# Select top K features
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)
print(X.shape)
					
				
			
		



Output:




		
		
			
			
Java
			
			(129880, 10)
			
				
					
				
					1
				
						(129880, 10)
					
				
			
		



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

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





		
		
			
			
Java
			
			from sklearn import preprocessing

# Initialize scaler
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)

# Transform features
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

print(X_train.shape)
print(X_test.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						from sklearn import preprocessing
 
# Initialize scaler
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
 
# Transform features
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
 
print(X_train.shape)
print(X_test.shape)
					
				
			
		



Output:




		
		
			
			
Java
			
			(103904, 10)
(25976, 10)
			
				
					
				
					1
2
				
						(103904, 10)
(25976, 10)
					
				
			
		





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

प्रीप्रोसेस्ड डेटा के साथ, हम अब विभिन्न वर्गीकरण मॉडलों का निर्माण और उनका मूल्यांकन कर सकते हैं। हम कई एल्गोरिदम का पता लगाएंगे ताकि उनके प्रदर्शन की तुलना की जा सके।

के-नियरेस्ट नेबर (KNN) क्लासिफायर

KNN एक सरल लेकिन प्रभावी एल्गोरिदम है जो डेटा बिंदुओं को उनके निकटतम पड़ोसियों के बहुसंख्यक लेबल के आधार पर वर्गीकृत करता है।





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

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

# Predict and evaluate
y_pred = knnClassifier.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test, target_names=['No', 'Yes']))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
 
# Initialize and train
knnClassifier = KNeighborsClassifier(n_neighbors=10)
knnClassifier.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = knnClassifier.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test, target_names=['No', 'Yes']))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.932668617185094
              precision    recall  f1-score   support

           No       0.96      0.92      0.94     15395
          Yes       0.90      0.94      0.92     10581

    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.932668617185094
              precision    recall  f1-score   support
 
           No       0.96      0.92      0.94     15395
          Yes       0.90      0.94      0.92     10581
 
    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretation:
KNN क्लासिफायर ने 93.27% उच्च सटीकता हासिल की है, जो यात्री संतुष्टि की भविष्यवाणी में उत्कृष्ट प्रदर्शन को दर्शाती है।

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

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





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Initialize and train
LRM = LogisticRegression()
LRM.fit(X_train, y_train)

# Predict and evaluate
y_pred = LRM.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.linear_model import LogisticRegression
 
# Initialize and train
LRM = LogisticRegression()
LRM.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = LRM.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.8557129658145981
              precision    recall  f1-score   support

           No       0.88      0.87      0.87     15068
          Yes       0.82      0.84      0.83     10908

    accuracy                           0.86     25976
   macro avg       0.85      0.85      0.85     25976
weighted avg       0.86      0.86      0.86     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.8557129658145981
              precision    recall  f1-score   support
 
           No       0.88      0.87      0.87     15068
          Yes       0.82      0.84      0.83     10908
 
    accuracy                           0.86     25976
   macro avg       0.85      0.85      0.85     25976
weighted avg       0.86      0.86      0.86     25976
					
				
			
		



Interpretation:
लॉजिस्टिक रिग्रेशन ने 85.57% की सटीकता प्रदान की है, जो KNN की तुलना में थोड़ी कम लेकिन अभी भी बेसलाइन तुलना के लिए प्रशंसनीय है।

गॉसियन नाइव बेयस (GaussianNB)

GaussianNB बायेस के प्रमेय पर आधारित एक संभाव्य क्लासिफायर है, जो फीचर्स की स्वतंत्रता मानता है।





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

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

# Predict and evaluate
y_pred = model_GNB.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.naive_bayes import GaussianNB
 
# Initialize and train
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_GNB.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.828688019710502
              precision    recall  f1-score   support

           No       0.84      0.85      0.85     14662
          Yes       0.81      0.80      0.80     11314

    accuracy                           0.83     25976
   macro avg       0.83      0.82      0.83     25976
weighted avg       0.83      0.83      0.83     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.828688019710502
              precision    recall  f1-score   support
 
           No       0.84      0.85      0.85     14662
          Yes       0.81      0.80      0.80     11314
 
    accuracy                           0.83     25976
   macro avg       0.83      0.82      0.83     25976
weighted avg       0.83      0.83      0.83     25976
					
				
			
		



Interpretation:
GaussianNB ने 82.87% की सटीकता हासिल की है, जो इसके सरल अंतर्निहित अनुमानों के बावजूद इसकी प्रभावशीलता को दर्शाती है।

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

SVM वर्गों को अलग करने के लिए हाइपरप्लेन बनाता है, उनके बीच मार्जिन को अनुकूलित करता है।





		
		
			
			
Java
			
			from sklearn.svm import SVC

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

# Predict and evaluate
y_pred = model_SVC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.svm import SVC
 
# Initialize and train
model_SVC = SVC()
model_SVC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_SVC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.9325916230366492
              precision    recall  f1-score   support

           No       0.95      0.93      0.94     15033
          Yes       0.91      0.93      0.92     10943

    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9325916230366492
              precision    recall  f1-score   support
 
           No       0.95      0.93      0.94     15033
          Yes       0.91      0.93      0.92     10943
 
    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretation:
SVM ने KNN के प्रदर्शन को प्रतिबिंबित किया है, 93.26% की सटीकता के साथ, जो वर्गीकरण कार्यों में इसकी मजबूती को दर्शाता है।

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

डिसीजन ट्री डेटा को फीचर मानों के आधार पर विभाजित करता है, निर्णयों के एक वृक्ष जैसी मॉडलिंग बनाता है।





		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

# Initialize and train
model_DTC = DecisionTreeClassifier(max_leaf_nodes=25, min_samples_split=4, random_state=42)
model_DTC.fit(X_train, y_train)

# Predict and evaluate
y_pred = model_DTC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.tree import DecisionTreeClassifier
 
# Initialize and train
model_DTC = DecisionTreeClassifier(max_leaf_nodes=25, min_samples_split=4, random_state=42)
model_DTC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_DTC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.9256621496766245
              precision    recall  f1-score   support

           No       0.95      0.92      0.94     15213
          Yes       0.90      0.93      0.91     10763

    accuracy                           0.93     25976
   macro avg       0.92      0.93      0.92     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9256621496766245
              precision    recall  f1-score   support
 
           No       0.95      0.92      0.94     15213
          Yes       0.90      0.93      0.91     10763
 
    accuracy                           0.93     25976
   macro avg       0.92      0.93      0.92     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretation:
डिसीजन ट्री क्लासिफायर ने 92.57% की सटीकता दर्ज की है, जो डेटा में जटिल पैटर्न्स को पकड़ने की इसकी क्षमता को दर्शाती है।

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

रैंडम फॉरेस्ट कई डिसीजन ट्री बनाता है और उनके भविष्यवाणियों को समेकित करता है ताकि सटीकता और मजबूती में सुधार हो सके।





		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

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

# Predict and evaluate
y_pred = model_RFC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.ensemble import RandomForestClassifier
 
# Initialize and train
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_RFC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.9181937172774869
              precision    recall  f1-score   support

           No       0.93      0.93      0.93     14837
          Yes       0.90      0.91      0.90     11139

    accuracy                           0.92     25976
   macro avg       0.92      0.92      0.92     25976
weighted avg       0.92      0.92      0.92     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9181937172774869
              precision    recall  f1-score   support
 
           No       0.93      0.93      0.93     14837
          Yes       0.90      0.91      0.90     11139
 
    accuracy                           0.92     25976
   macro avg       0.92      0.92      0.92     25976
weighted avg       0.92      0.92      0.92     25976
					
				
			
		



Interpretation:
रैंडम फॉरेस्ट ने 91.82% की सटीकता हासिल की है, जो एन्सेम्बल लर्निंग के माध्यम से बायस और वैरिएंस को प्रभावी ढंग से संतुलित करती है।

एडा बूस्ट क्लासिफायर

एडा बूस्ट कई कमजोर क्लासिफायर्स को मिलाकर एक मजबूत क्लासिफायर बनाता है, जो पहले से गलत तरीके से वर्गीकृत उदाहरणों पर ध्यान केंद्रित करता है।





		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

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

# Predict and evaluate
y_pred = model_ABC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.ensemble import AdaBoostClassifier
 
# Initialize and train
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_ABC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.9101863258392362
              precision    recall  f1-score   support

           No       0.93      0.92      0.92     14977
          Yes       0.89      0.90      0.89     10999

    accuracy                           0.91     25976
   macro avg       0.91      0.91      0.91     25976
weighted avg       0.91      0.91      0.91     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9101863258392362
              precision    recall  f1-score   support
 
           No       0.93      0.92      0.92     14977
          Yes       0.89      0.90      0.89     10999
 
    accuracy                           0.91     25976
   macro avg       0.91      0.91      0.91     25976
weighted avg       0.91      0.91      0.91     25976
					
				
			
		



Interpretation:
एडा बूस्ट ने 91.02% की सटीकता प्राप्त की है, जो बूस्टिंग तकनीकों के माध्यम से मॉडल प्रदर्शन में सुधार की इसकी क्षमता को दर्शाता है।

XGBoost क्लासिफायर

XGBoost एक अत्यधिक अनुकूलित ग्रेडिएंट बूस्टिंग फ्रेमवर्क है जो अपने प्रदर्शन और गति के लिए जाना जाता है।





		
		
			
			
Java
			
			import xgboost as xgb

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

# Predict and evaluate
y_pred = model_xgb.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import xgboost as xgb
 
# Initialize and train
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
 
# Predict and evaluate
y_pred = model_xgb.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Output:




		
		
			
			
Java
			
			0.9410994764397905
              precision    recall  f1-score   support

           No       0.96      0.94      0.95     15122
          Yes       0.92      0.94      0.93     10854

    accuracy                           0.94     25976
   macro avg       0.94      0.94      0.94     25976
weighted avg       0.94      0.94      0.94     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9410994764397905
              precision    recall  f1-score   support
 
           No       0.96      0.94      0.95     15122
          Yes       0.92      0.94      0.93     10854
 
    accuracy                           0.94     25976
   macro avg       0.94      0.94      0.94     25976
weighted avg       0.94      0.94      0.94     25976
					
				
			
		



Interpretation:
XGBoost ने 94.11% की शानदार सटीकता के साथ पायदान पर कब्जा कर लिया है, जो जटिल डेटासेट्स को संभालने और उच्च भविष्यवाणी शक्ति के साथ इसके श्रेष्ठता को रेखांकित करता है।



निष्कर्ष

प्रभावी वर्गीकरण मॉडल बनाने के लिए सूक्ष्म डेटा प्रीप्रोसेसिंग, सूचित फीचर चयन, और कार्य के लिए सही एल्गोरिदम का चयन करना आवश्यक है। हमारे व्यापक Jupyter Notebook मास्टर टेम्पलेट के माध्यम से, हमने विभिन्न वर्गीकरण एल्गोरिदम का पता लगाया है, प्रत्येक की अपनी अनूठी ताकत के साथ। K-नियरेस्ट नेबर और लॉजिस्टिक रिग्रेशन से लेकर रैंडम फॉरेस्ट और XGBoost जैसे उन्नत एन्सेम्बल तकनीकों तक, टूलकिट विशाल और विविध डेटासेट्स के लिए अनुकूलनीय है।

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

मुख्य बिंदु:


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


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



संसाधन:


    Kaggle: Airline Passenger Satisfaction
    Scikit-Learn दस्तावेज़ीकरण
    XGBoost दस्तावेज़ीकरण


संपर्क में बने रहें:

मशीन लर्निंग और डेटा विज्ञान पर अधिक ट्यूटोरियल और अंतर्दृष्टि के लिए, हमारे न्यूज़लेटर की सदस्यता लें और हमें LinkedIn पर फॉलो करें।