सपोर्ट वेक्टर मशीन क्या है?

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

SVM का उपयोग प्रतिगमन और वर्गीकरण समस्याओं दोनों के लिए किया जा सकता है लेकिन इसका व्यापक रूप से वर्गीकरण के लिए उपयोग किया जाता है।

इससे पहले कि हम आगे बढ़ें, आइए कुछ शर्तों की व्याख्या करें।

कर्नेल एक फ़ंक्शन है जिसका उपयोग डेटा को उच्च आयाम में बदलने के लिए किया जाता है।

हाइपरप्लेन कक्षाओं को अलग करने वाली रेखा है (वर्गीकरण समस्याओं के लिए)। प्रतिगमन के लिए, यह वह रेखा है जिसे हम परिणाम जारी रखने के मूल्यों की भविष्यवाणी करने के लिए अपने डेटा में फिट करते हैं।

सीमा रेखाएँ वे रेखाएँ हैं जो उस क्षेत्र का निर्माण करती हैं जिसका हमने पहले उल्लेख किया था। वे हाइपर प्लेन के चारों ओर दो रेखाएँ हैं जो मार्जिन का प्रतिनिधित्व करती हैं।

समर्थन वेक्टर डेटा बिंदु हैं जो इन सीमा रेखाओं के सबसे करीब हैं।

गुठली

हमने उल्लेख किया कि कर्नेल हमारे डेटा को उच्च आयामों में बदलने का कार्य है। वैसे यह हमारे लिए कैसे उपयोगी है?

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

सबसे अधिक इस्तेमाल की जाने वाली तीन गुठली हैं:

• रैखिक कर्नेल
• बहुपद कर्नेल:
• रेडियल बेसिस फंक्शन (आरबीएफ) — अतिव्यापी डेटा से निपटने के लिए अच्छा है

समर्थन वेक्टर रिग्रेशन (एसवीआर)

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

y=w1x1+c

एक विशेषता वाले डेटासेट के लिए SVR को ध्यान में रखते हुए, समीकरण समान दिखता है लेकिन एक त्रुटि पर विचार करने के साथ।

−e≤y−(w1x1+c)≤e

समीकरण को देखते हुए, यह स्पष्ट है कि लागत गणना में केवल ई त्रुटि क्षेत्र के बाहर के बिंदुओं पर विचार किया जाएगा।

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

हाइपरप्लेन डेटा के लिए सबसे उपयुक्त है जब यह अधिकतम संभव बिंदु के साथ मेल खाता है। हम सीमा रेखाएँ निर्धारित करते हैं (e का मान जो हाइपरप्लेन से दूरी है) ताकि हाइपरप्लेन के निकटतम बिंदु सीमा रेखा के भीतर हों।

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

 import numpy as np from sklearn.svm import SVR import matplotlib.pyplot as plt np.random.seed(5) X = np.sort(5 * np.random.rand(40, 1), axis=0) T = np.linspace(0, 5, 5)[:, np.newaxis] y = np.sin(X).ravel() # Add noise to targets y[::5] += 1 * (0.5 - np.random.rand(8)) # Fit regression model SVR_rbf = SVR(kernel='rbf' ) SVR_lin = SVR(kernel='linear') SVR_poly = SVR(kernel='poly') y_rbf = SVR_rbf.fit(X, y).predict(X) y_lin = SVR_lin.fit(X, y).predict(X) y_poly = SVR_poly.fit(X, y).predict(X) # look at the results plt.scatter(X, y, c='k', label='data') plt.plot(X, y_rbf, c='b', label='RBF') plt.plot(X, y_lin, c='r',label='Linear') plt.plot(X, y_poly, c='g',label='Polynomial') plt.xlabel('data') plt.ylabel('outcome') plt.title('Support Vector Regression') plt.legend() plt.show()

वर्गीकरण के लिए समर्थन वेक्टर मशीनें

हम पहले ही देख चुके हैं कि कैसे "सपोर्ट वेक्टर मशीन (एसवीएम)" एल्गोरिथम प्रतिगमन के लिए काम करता है। वर्गीकरण के लिए विचार वास्तव में लगभग समान है। वास्तव में एसवीएम का उपयोग ज्यादातर वर्गीकरण समस्याओं के लिए किया जाता है। मुझे विश्वास है कि आप पहले से ही सोच सकते हैं कि क्यों…

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

मार्जिन प्रत्येक वर्ग से दो निकटतम बिंदुओं के बीच का अंतर है जो हाइपरप्लेन से निकटतम बिंदुओं (समर्थन वैक्टर) की दूरी है। हाइपरप्लेन जो डेटा के लिए सबसे अच्छा फिट बैठता है, जिसका अर्थ है कि दो वर्गों को सबसे अच्छा अलग करता है, अधिकतम संभव मार्जिन वाला हाइपरप्लेन है। इसलिए, SVM एल्गोरिथम अधिकतम मार्जिन (निकटतम बिंदुओं की दूरी) के साथ हाइपरप्लेन की खोज करता है।

जैसा कि हमने प्रतिगमन खंड में पहले ही उल्लेख किया है, कुछ डेटासेट एक रैखिक हाइपरप्लेन द्वारा वर्गीकृत होने के लिए उपयुक्त नहीं हैं ... इस मामले में, फिर से "कर्नेल ट्रिक" हमारे बचाव में आती है जो डेटा को उच्च आयामों में मैप करती है, इसलिए इसे संभव बनाती है डेटा को एक रैखिक हाइपरप्लेन द्वारा वर्गीकृत किया जाना है। चूंकि हमने पहले ही कर्नेल प्रकारों पर चर्चा की है और यह कैसे काम करता है, मैं एक कार्यान्वयन उदाहरण के साथ जारी रखूंगा ...

आइए स्किकिट लर्निंग लाइब्रेरी के कैंसर डेटासेट का उपयोग जारी रखें:

 from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split X, y = load_breast_cancer(return_X_y = True) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) X_sub = X[:, 0:2] # create a mesh to plot in x_min, x_max = X_sub[:, 0].min() - 1, X_sub[:, 0].max() + 1 y_min, y_max = X_sub[:, 1].min() - 1, X_sub[:, 1].max() + 1 h = (x_max / x_min)/100 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) #import the SVM model from sklearn import svm C = 1.0 # SVM regularization parameter svc = svm.SVC(kernel='linear').fit(X_sub, y) #play with this, change kernel to rbf plt.subplot(1, 1, 1) Z = svc.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.contourf(xx, yy, Z, cmap=plt.cm.Paired, alpha=0.8) plt.scatter(X_sub[:, 0], X_sub[:, 1], c=y, cmap=plt.cm.Paired) plt.scatter(X_sub[svc.support_, 0], X_sub[svc.support_, 1],c='k', cmap=plt.cm.Paired) plt.xlabel('Sepal length') plt.ylabel('Sepal width') plt.xlim(xx.min(), xx.max()) plt.title('SVC with linear kernel') plt.show()

 #Create and instance of the classifier model with a linear kernel lsvm = svm.SVC(kernel="linear") #fit the model to our train split from previous example lsvm.fit(X_train,y_train) #Make predictions using the test split so we can evaluate its performance y_pred = lsvm.predict(X_test)

आइए परीक्षण सेट से वास्तविक मूल्यों की भविष्यवाणियों की तुलना करके मॉडल के प्रदर्शन की तुलना करें…

 from sklearn import metrics print("Accuracy:",metrics.accuracy_score(y_test, y_pred)) print("Precision:",metrics.precision_score(y_test, y_pred)) print("Recall:",metrics.recall_score(y_test, y_pred))

हम 95.6% की सटीकता हासिल करने में सफल रहे जो बहुत अच्छा है। आइए ओवरफिटिंग की जांच के लिए प्रशिक्षण और परीक्षण स्कोर की तुलना करें…

 print("training set score: %f" % lsvm.score(X_train, y_train)) print("test set score: %f" % lsvm.score(X_test, y_test))

प्रशिक्षण स्कोर टेस्ट स्कोर से थोड़ा अधिक लगता है। हम कह सकते हैं कि मॉडल ओवरफिटिंग है, हालांकि ज्यादा नहीं।

यदि आप इसे पसंद करते हैं, तो बेझिझक मुझे और अधिक मुफ्त मशीन लर्निंग ट्यूटोरियल और कोर्स के लिए फॉलो करें!