S20L05 – पाइथन के अंतर्गत बहु-वर्ग वर्गीकरण पर लॉजिस्टिक प्रतिगमन

html
पाइथन में बहु-कक्षा वर्गीकरण के लिए लॉजिस्टिक रिग्रेशन का कार्यान्वयन: एक व्यापक मार्गदर्शिका

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

सामग्री तालिका


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


बहु-कक्षा वर्गीकरण का परिचय

बहु-कक्षा वर्गीकरण एक प्रकार का वर्गीकरण कार्य है जहां प्रत्येक उदाहरण को तीन या उससे अधिक श्रेणियों में से एक में वर्गीकृत किया जाता है। द्विआधारी वर्गीकरण के विपरीत, जो दो श्रेणियों के साथ काम करता है, बहु-कक्षा वर्गीकरण विशेष चुनौतियां प्रस्तुत करता है और ऐसे एल्गोरिदमों की आवश्यकता होती है जो कई श्रेणियों के बीच प्रभावी ढंग से अंतर कर सकें।

लॉजिस्टिक रिग्रेशन पारंपरिक रूप से द्विआधारी वर्गीकरण के लिए जाना जाता है लेकिन इसे वन-वर्स-रेस्ट (OvR) या बहुसंख्यक दृष्टिकोण जैसी रणनीतियों का उपयोग करके बहु-कक्षा परिदृश्यों को संभालने के लिए विस्तारित किया जा सकता है। इसकी सरलता, विवेचनशीलता, और दक्षता इसे विभिन्न वर्गीकरण कार्यों के लिए एक लोकप्रिय विकल्प बनाती है।

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

इस मार्गदर्शिका के लिए, हम Bangla Music Dataset का उपयोग करते हैं, जिसमें बंगला गीतों से निकाले गए फीचर्स शामिल हैं। मुख्य उद्देश्य इन फीचर्स के आधार पर गीतों को शैलियों में वर्गीकृत करना है। डेटासेट में स्पेक्ट्रल सेंट्रोइड, स्पेक्ट्रल बैंडविड्थ, क्रोमा आवृत्ति, और मेल-फ्रीक्वेंसी सेप्सट्रल गुणांक (MFCCs) जैसी विभिन्न ऑडियो विशेषताएं शामिल हैं।

डेटासेट स्रोत: Kaggle - Bangla Music Dataset

नमूना डेटा अवलोकन





		
		
			
			
Java
			
			import pandas as pd

# Load the dataset
data = pd.read_csv('bangla.csv')
print(data.tail())
			
				
					
				
					1
2
3
4
5
				
						import pandas as pd
 
# Load the dataset
data = pd.read_csv('bangla.csv')
print(data.tail())
					
				
			
		







		
		
			
			
Java
			
			                                               file_name  zero_crossing  \
1737  Tumi Robe Nirobe, Artist - DWIJEN  MUKHOPADHYA...          78516   
1738  TUMI SANDHYAR MEGHMALA  Srikanta Acharya  Rabi...         176887   
1739  Utal Haowa Laglo Amar Gaaner Taranite  Sagar S...         133326   
1740  venge mor ghorer chabi by anima roy.. album ro...         179932   
1741   vora thak vora thak by anima roy ( 160kbps ).mp3         175244   

          spectral_centroid  spectral_rolloff  spectral_bandwidth  \
1737         800.797115       1436.990088         1090.389766   
1738        1734.844686       3464.133429         1954.831684   
1739        1380.139172       2745.410904         1775.717428   
1740        1961.435018       4141.554401         2324.507425   
1741        1878.657768       3877.461439         2228.147952   

          chroma_frequency      rmse         delta  melspectogram       tempo  \
1737          0.227325  0.108344  2.078194e-08       3.020211  117.453835   
1738          0.271189  0.124934  5.785562e-08       4.098559  129.199219   
1739          0.263462  0.111411  4.204189e-08       3.147722  143.554688   
1740          0.261823  0.168673  3.245319e-07       7.674615  143.554688   
1741          0.232985  0.311113  1.531590e-07      26.447679  129.199219   

          ...    mfcc11     mfcc12     mfcc13    mfcc14    mfcc15    mfcc16  \
1737  ... -2.615630   2.119485 -12.506942 -1.148996  0.090582 -8.694072   
1738  ...  1.693247  -4.076407  -2.017894 -7.419591 -0.488603 -8.690254   
1739  ...  2.487961  -3.434017  -6.099467 -6.008315 -7.483330 -2.908477   
1740  ...  1.192605 -13.142963   0.281834 -5.981567 -1.066383  0.677886   
1741  ... -5.636770 -12.078487   1.692546 -6.005674  1.502304 -0.415201   

          mfcc17    mfcc18    mfcc19     label  
1737 -6.597594  2.925687 -6.154576  rabindra  
1738 -7.090489 -6.530357 -5.593533  rabindra  
1739  0.783345 -3.394053 -3.157621  rabindra  
1740  0.803132 -3.304548  4.309490  rabindra  
1741  2.389623 -3.135799  0.225479  rabindra  

[5 rows x 31 columns]
			
				
					
				
					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
28
29
30
31
32
33
34
35
36
				
						                                               file_name  zero_crossing  \
1737  Tumi Robe Nirobe, Artist - DWIJEN  MUKHOPADHYA...          78516   
1738  TUMI SANDHYAR MEGHMALA  Srikanta Acharya  Rabi...         176887   
1739  Utal Haowa Laglo Amar Gaaner Taranite  Sagar S...         133326   
1740  venge mor ghorer chabi by anima roy.. album ro...         179932   
1741   vora thak vora thak by anima roy ( 160kbps ).mp3         175244   
 
          spectral_centroid  spectral_rolloff  spectral_bandwidth  \
1737         800.797115       1436.990088         1090.389766   
1738        1734.844686       3464.133429         1954.831684   
1739        1380.139172       2745.410904         1775.717428   
1740        1961.435018       4141.554401         2324.507425   
1741        1878.657768       3877.461439         2228.147952   
 
          chroma_frequency      rmse         delta  melspectogram       tempo  \
1737          0.227325  0.108344  2.078194e-08       3.020211  117.453835   
1738          0.271189  0.124934  5.785562e-08       4.098559  129.199219   
1739          0.263462  0.111411  4.204189e-08       3.147722  143.554688   
1740          0.261823  0.168673  3.245319e-07       7.674615  143.554688   
1741          0.232985  0.311113  1.531590e-07      26.447679  129.199219   
 
          ...    mfcc11     mfcc12     mfcc13    mfcc14    mfcc15    mfcc16  \
1737  ... -2.615630   2.119485 -12.506942 -1.148996  0.090582 -8.694072   
1738  ...  1.693247  -4.076407  -2.017894 -7.419591 -0.488603 -8.690254   
1739  ...  2.487961  -3.434017  -6.099467 -6.008315 -7.483330 -2.908477   
1740  ...  1.192605 -13.142963   0.281834 -5.981567 -1.066383  0.677886   
1741  ... -5.636770 -12.078487   1.692546 -6.005674  1.502304 -0.415201   
 
          mfcc17    mfcc18    mfcc19     label  
1737 -6.597594  2.925687 -6.154576  rabindra  
1738 -7.090489 -6.530357 -5.593533  rabindra  
1739  0.783345 -3.394053 -3.157621  rabindra  
1740  0.803132 -3.304548  4.309490  rabindra  
1741  2.389623 -3.135799  0.225479  rabindra  
 
[5 rows x 31 columns]
					
				
			
		



डेटा पूर्व-संसाधन

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

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

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

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

संख्यात्मक फीचर्स के लिए, गुम मानों को माध्य रणनीति का उपयोग करके पूरित किया जाता है।





		
		
			
			
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 SimpleImputer for mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data
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 SimpleImputer for mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



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

श्रेणीबद्ध फीचर्स के लिए, गुम मानों को सबसे अधिक बार रणनीति का उपयोग करके पूरित किया जाता है।





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

# Initialize SimpleImputer for most frequent strategy
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
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 columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Initialize SimpleImputer for most frequent strategy
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform the data
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		



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

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

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

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





		
		
			
			
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
7
8
9
				
						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)
					
				
			
		



X के लिए एन्कोडिंग चयन

प्रत्येक फीचर में अद्वितीय श्रेणियों की संख्या के आधार पर एन्कोडिंग रणनीतियों का संयोजन लागू किया जाता है।





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    # Step 01: Select the string columns
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Step 02: Label encode columns with 2 or more than 'threshold' categories
    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)
                
    # Step 03: One-hot encode the remaining columns
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

# Apply encoding selection
X = EncodingSelection(X)
print(f"Encoded feature shape: {X.shape}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						def EncodingSelection(X, threshold=10):
    # Step 01: Select the string columns
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Step 02: Label encode columns with 2 or more than 'threshold' categories
    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)
                
    # Step 03: One-hot encode the remaining columns
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
# Apply encoding selection
X = EncodingSelection(X)
print(f"Encoded feature shape: {X.shape}")
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Encoded feature shape: (1742, 30)
			
				
					
				
					1
				
						Encoded feature shape: (1742, 30)
					
				
			
		



फीचर चयन

सबसे प्रासंगिक फीचर्स का चयन मॉडल के प्रदर्शन को बढ़ाता है और संगणनात्मक जटिलता को कम करता है।





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

# Initialize Min-Max Scaler
MMS = preprocessing.MinMaxScaler()

# Define number of best features to select
K_features = 12

# Scale the features
x_temp = MMS.fit_transform(X)

# Apply SelectKBest with chi-squared scoring
kbest = SelectKBest(score_func=chi2, k=10)
x_temp = kbest.fit(x_temp, y)

# Identify top features
best_features = np.argsort(x_temp.scores_)[-K_features:]

# Determine features to delete
features_to_delete = np.argsort(x_temp.scores_)[:-K_features]

# Reduce X to selected features
X = np.delete(X, features_to_delete, axis=1)
print(f"Reduced feature shape: {X.shape}")
			
				
					
				
					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.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
# Initialize Min-Max Scaler
MMS = preprocessing.MinMaxScaler()
 
# Define number of best features to select
K_features = 12
 
# Scale the features
x_temp = MMS.fit_transform(X)
 
# Apply SelectKBest with chi-squared scoring
kbest = SelectKBest(score_func=chi2, k=10)
x_temp = kbest.fit(x_temp, y)
 
# Identify top features
best_features = np.argsort(x_temp.scores_)[-K_features:]
 
# Determine features to delete
features_to_delete = np.argsort(x_temp.scores_)[:-K_features]
 
# Reduce X to selected features
X = np.delete(X, features_to_delete, axis=1)
print(f"Reduced feature shape: {X.shape}")
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Reduced feature shape: (1742, 12)
			
				
					
				
					1
				
						Reduced feature shape: (1742, 12)
					
				
			
		



मॉडल प्रशिक्षण और मूल्यांकन

डेटा को पूर्व-संसाधित करने और फीचर्स का चयन करने के बाद, हम अपने मॉडलों को प्रशिक्षित और मूल्यांकन करने के लिए आगे बढ़ते हैं।

K-निकटतम पड़ोसी (KNN) वर्गीकार

KNN एक सरल, उदाहरण-आधारित सीखने का एल्गोरिदम है जो वर्गीकरण कार्यों के लिए एक आधाररेखा के रूप में कार्य कर सकता है।





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

# Initialize KNN with 8 neighbors
knnClassifier = KNeighborsClassifier(n_neighbors=8)

# Train the model
knnClassifier.fit(X_train, y_train)

# Make predictions
y_pred_knn = knnClassifier.predict(X_test)

# Evaluate accuracy
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
# Initialize KNN with 8 neighbors
knnClassifier = KNeighborsClassifier(n_neighbors=8)
 
# Train the model
knnClassifier.fit(X_train, y_train)
 
# Make predictions
y_pred_knn = knnClassifier.predict(X_test)
 
# Evaluate accuracy
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2f}")
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			KNN Accuracy: 0.68
			
				
					
				
					1
				
						KNN Accuracy: 0.68
					
				
			
		



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

लॉजिस्टिक रिग्रेशन को यहां बहुसंख्यक दृष्टिकोण का उपयोग करके बहु-कक्षा वर्गीकरण को संभालने के लिए विस्तारित किया गया है।





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Initialize Logistic Regression with increased iterations
LRM = LogisticRegression(random_state=0, max_iter=1000, multi_class='multinomial', solver='lbfgs')

# Train the model
LRM.fit(X_train, y_train)

# Make predictions
y_pred_lr = LRM.predict(X_test)

# Evaluate accuracy
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.linear_model import LogisticRegression
 
# Initialize Logistic Regression with increased iterations
LRM = LogisticRegression(random_state=0, max_iter=1000, multi_class='multinomial', solver='lbfgs')
 
# Train the model
LRM.fit(X_train, y_train)
 
# Make predictions
y_pred_lr = LRM.predict(X_test)
 
# Evaluate accuracy
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.65
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.65
					
				
			
		



तुलनात्मक विश्लेषण

दोनों मॉडलों का मूल्यांकन करने पर, इस विशेष परिदृश्य में K-निकटतम पड़ोसी वर्गीकार लॉजिस्टिक रिग्रेशन से बेहतर प्रदर्शन करता है।


    KNN सटीकता: 67.9%
    लॉजिस्टिक रिग्रेशन सटीकता: 65.0%


हालांकि, निम्नलिखित टिप्पणियों को ध्यान में रखना आवश्यक है:


    इटरेशन सीमा चेतावनी: प्रारंभ में, लॉजिस्टिक रिग्रेशन को संगम समस्याओं का सामना करना पड़ा, जिन्हें max_iter पैरामीटर को 300 से बढ़ाकर 1000 करने से हल किया गया।
    मॉडल प्रदर्शन: हालांकि KNN ने उच्च सटीकता दिखाई, लॉजिस्टिक रिग्रेशन बेहतर विवेचनशीलता प्रदान करता है और बड़े डेटासेट के साथ अधिक स्केलेबल हो सकता है।


भविष्य के सुधार:

    हाइपरपैरामीटर ट्यूनिंग: लॉजिस्टिक रिग्रेशन में C, penalty, और अन्य पैरामीटर्स को समायोजित करने से प्रदर्शन में सुधार हो सकता है।
    क्रॉस-वैलिडेशन: क्रॉस-वैलिडेशन तकनीकों को लागू करने से मॉडल प्रदर्शन का अधिक मजबूत मूल्यांकन प्रदान किया जा सकता है।
    फीचर इंजीनियरिंग: अधिक सूचनात्मक फीचर्स को बनाना या चुनना वर्गीकरण सटीकता को बढ़ा सकता है।


निष्कर्ष

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

पूर्ण पाइथन कार्यान्वयन

नीचे सभी चर्चा किए गए चरणों को समेटने वाला पूर्ण पाइथन कोड दिया गया है:





		
		
			
			
Java
			
			# Import necessary libraries
import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler, MinMaxScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Load the dataset
data = pd.read_csv('bangla.csv')

# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Handling missing data - Numeric type
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])

# Handling missing string data
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])

# Encoding methods
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)

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

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

# Apply encoding selection
X = EncodingSelection(X)
print(f"Encoded feature shape: {X.shape}")

# Feature selection
MMS = MinMaxScaler()
K_features = 12
x_temp = MMS.fit_transform(X)
kbest = SelectKBest(score_func=chi2, k=10)
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)
print(f"Reduced feature shape: {X.shape}")

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(f"Training set shape: {X_train.shape}")

# Feature scaling
sc = StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
print(f"Scaled Training set shape: {X_train.shape}")
print(f"Scaled Test set shape: {X_test.shape}")

# Building KNN model
knnClassifier = KNeighborsClassifier(n_neighbors=8)
knnClassifier.fit(X_train, y_train)
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2f}")

# Building Logistic Regression model
LRM = LogisticRegression(random_state=0, max_iter=1000, multi_class='multinomial', solver='lbfgs')
LRM.fit(X_train, y_train)
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")
			
				
					
				
					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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
				
						# Import necessary libraries
import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler, MinMaxScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
 
# Load the dataset
data = pd.read_csv('bangla.csv')
 
# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Handling missing data - Numeric type
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])
 
# Handling missing string data
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])
 
# Encoding methods
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
 
def LabelEncoderMethod(series):
    le = LabelEncoder()
    le.fit(series)
    return le.transform(series)
 
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == 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
 
# Apply encoding selection
X = EncodingSelection(X)
print(f"Encoded feature shape: {X.shape}")
 
# Feature selection
MMS = MinMaxScaler()
K_features = 12
x_temp = MMS.fit_transform(X)
kbest = SelectKBest(score_func=chi2, k=10)
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)
print(f"Reduced feature shape: {X.shape}")
 
# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(f"Training set shape: {X_train.shape}")
 
# Feature scaling
sc = StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
print(f"Scaled Training set shape: {X_train.shape}")
print(f"Scaled Test set shape: {X_test.shape}")
 
# Building KNN model
knnClassifier = KNeighborsClassifier(n_neighbors=8)
knnClassifier.fit(X_train, y_train)
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2f}")
 
# Building Logistic Regression model
LRM = LogisticRegression(random_state=0, max_iter=1000, multi_class='multinomial', solver='lbfgs')
LRM.fit(X_train, y_train)
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}")
					
				
			
		



नोट: कोड निष्पादित करने से पहले सुनिश्चित करें कि डेटासेट bangla.csv सही ढंग से आपके कार्य निर्देशिका में रखा गया है।

कीवर्ड्स


    लॉजिस्टिक रिग्रेशन
    बहु-कक्षा वर्गीकरण
    पाइथन ट्यूटोरियल
    मशीन लर्निंग
    डेटा पूर्व-संसाधन
    फीचर चयन
    K-निकटतम पड़ोसी (KNN)
    Scikit-learn
    डेटा साइंस
    पाइथन मशीन लर्निंग