S23L04 – पायथन का उपयोग करके SVM कार्यान्वयन

html
Python में सपोर्ट वेक्टर मशीन (SVM) लागू करना: एक व्यापक गाइड

Python की scikit-learn लाइब्रेरी का उपयोग करके सपोर्ट वेक्टर मशीन (SVM) लागू करने पर हमारे गहन मार्गदर्शिका में आपका स्वागत है। चाहे आप डेटा साइंस के उत्साही हों या एक अनुभवी पेशेवर, यह लेख आपको पूरे प्रक्रिया से गुजराएगा—SVM की बुनियादी अवधारणाओं को समझने से लेकर Jupyter Notebook का उपयोग करके पूर्ण कार्यान्वयन तक। चलिए शुरू करते हैं!

सामग्री सूची

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



1. सपोर्ट वेक्टर मशीन (SVM) का परिचय

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

SVM की मुख्य विशेषताएँ:

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



2. पर्यावरण सेटअप करना

शुरू करने से पहले, सुनिश्चित करें कि आपके पास आवश्यक लाइब्रेरी इंस्टॉल हैं। आप उन्हें pip का उपयोग करके इंस्टॉल कर सकते हैं:





		
		
			
			
Java
			
			pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
			
				
					
				
					1
				
						pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
					
				
			
		



ध्यान दें: mlxtend निर्णय क्षेत्रों को विज़ुअलाइज़ करने के लिए उपयोग किया जाता है।


3. डेटा अन्वेषण और पूर्वसंसाधन

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

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

गायब डेटा मशीन लर्निंग मॉडलों के प्रदर्शन को प्रतिकूल रूप से प्रभावित कर सकता है। हम गायब मानों को इस प्रकार संभालेंगे:


    संख्यात्मक फीचर्स: गायब मानों को माध्य से प्रतिस्थापित करना।
    श्रेणीनुसार फीचर्स: सबसे अधिक आवृत्ति वाले मान से गायब मानों को प्रतिस्थापित करना।






		
		
			
			
Java
			
			import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

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

# फीचर्स और लक्ष्य को अलग करें
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# संख्यात्मक गायब मानों को संभालें
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])

# श्रेणीनुसार गायब मानों को संभालें
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
 
# डेटासेट लोड करें
data = pd.read_csv('weatherAUS.csv')
 
# फीचर्स और लक्ष्य को अलग करें
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# संख्यात्मक गायब मानों को संभालें
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])
 
# श्रेणीनुसार गायब मानों को संभालें
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
					
				
			
		



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

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


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






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

# लेबल एन्कोडिंग फ़ंक्शन
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# लक्ष्य चर में लेबल एन्कोडिंग लागू करें
y = label_encode(y)

# एन्कोडिंग के लिए कॉलम की पहचान करें
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # लेबल एन्कोड करें
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # वन-हॉट एन्कोड करें
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X

X = encoding_selection(X)
			
				
					
				
					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
				
						from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# लेबल एन्कोडिंग फ़ंक्शन
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
# लक्ष्य चर में लेबल एन्कोडिंग लागू करें
y = label_encode(y)
 
# एन्कोडिंग के लिए कॉलम की पहचान करें
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # लेबल एन्कोड करें
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # वन-हॉट एन्कोड करें
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X
 
X = encoding_selection(X)
					
				
			
		



3.3 फीचर चयन

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





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

# फीचर्स को स्केल करें
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# शीर्ष 2 फीचर्स का चयन करें
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# फीचर्स को स्केल करें
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# शीर्ष 2 फीचर्स का चयन करें
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
					
				
			
		




4. डेटासेट को विभाजित करना

हम डेटासेट को प्रशिक्षण और परीक्षण सेट में विभाजित करेंगे ताकि मॉडल के प्रदर्शन का मूल्यांकन अनदेखे डेटा पर किया जा सके।





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_selected, 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_selected, y, test_size=0.20, random_state=1)
					
				
			
		




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

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





		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)

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




6. मॉडल बनाना और उनका मूल्यांकन करना

हम उनके प्रदर्शन की तुलना करने के लिए चार विभिन्न मॉडल बनाएंगे:


    K-Nearest Neighbors (KNN)
    लॉजिस्टिक रिग्रेशन
    गॉसियन नाइवे बेयस
    सपोर्ट वेक्टर मशीन (SVM)


6.1 K-Nearest Neighbors (KNN)





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

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			KNN Accuracy: 0.8003
			
				
					
				
					1
				
						KNN Accuracy: 0.8003
					
				
			
		



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





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.linear_model import LogisticRegression
 
log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.8297
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.8297
					
				
			
		



6.3 गॉसियन नाइवे बेयस





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.naive_bayes import GaussianNB
 
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			Gaussian Naive Bayes Accuracy: 0.7960
			
				
					
				
					1
				
						Gaussian Naive Bayes Accuracy: 0.7960
					
				
			
		



6.4 सपोर्ट वेक्टर मशीन (SVM)





		
		
			
			
Java
			
			from sklearn.svm import SVC

svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.svm import SVC
 
svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			SVM Accuracy: 0.8282
			
				
					
				
					1
				
						SVM Accuracy: 0.8282
					
				
			
		



मॉडल सटीकताओं का सारांश:

    
        मॉडल
        सटीकता
    
    
        KNN
        80.03%
    
    
        लॉजिस्टिक रिग्रेशन
        82.97%
    
    
        गॉसियन नाइवे बेयस
        79.60%
    
    
        SVM
        82.82%
    


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



7. निर्णय क्षेत्रों का विज़ुअलाइज़ेशन

निर्णय सीमाओं का विज़ुअलाइज़ेशन यह समझने में मदद करता है कि विभिन्न मॉडल डेटा को कैसे वर्गीकृत करते हैं।





		
		
			
			
Java
			
			from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

# विज़ुअलाइज़ेशन के लिए Iris डेटासेट लोड करें
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# मॉडल इनिशियलाइज़ करें
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()

# मॉडल फिट करें
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)

# विज़ुअलाइज़ेशन फ़ंक्शन
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()

# प्रत्येक मॉडल के लिए निर्णय क्षेत्र को प्लॉट करें
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
			
				
					
				
					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
				
						from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
 
# विज़ुअलाइज़ेशन के लिए Iris डेटासेट लोड करें
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target
 
# मॉडल इनिशियलाइज़ करें
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()
 
# मॉडल फिट करें
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)
 
# विज़ुअलाइज़ेशन फ़ंक्शन
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()
 
# प्रत्येक मॉडल के लिए निर्णय क्षेत्र को प्लॉट करें
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
					
				
			
		



विज़ुअलाइज़ेशन:

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


8. निष्कर्ष

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

मुख्य सीख:

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


इस व्यापक दृष्टिकोण का पालन करके, आप प्रभावी रूप से SVM और अन्य वर्गीकरण एल्गोरिदम को लागू कर सकते हैं ताकि वास्तविक दुनिया की समस्याओं को हल किया जा सके।


9. संदर्भ


    Scikit-Learn डाक्यूमेंटेशन
    Support Vector Machines - विकिपीडिया
    MLxtend: मशीन लर्निंग एक्सटेंशन्स




पढ़ने के लिए धन्यवाद! यदि आपके कोई प्रश्न या प्रतिक्रिया हैं, तो कृपया नीचे टिप्पणी छोड़ें।
मॉडल	सटीकता
KNN	80.03%
लॉजिस्टिक रिग्रेशन	82.97%
गॉसियन नाइवे बेयस	79.60%
SVM	82.82%