परिचय

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

उदाहरण

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

एसवीएम के प्रकार

L inear SVM : "रैखिक रूप से अलग करने योग्य डेटा" शब्द उस डेटा को संदर्भित करता है जिसे केवल एक सीधी रेखा का उपयोग करके दो समूहों में विभाजित किया जा सकता है। ऐसे डेटा को वर्गीकृत करने के लिए रैखिक एसवीएम का उपयोग किया जाता है, और उपयोग किए गए क्लासिफायर को रैखिक एसवीएम क्लासिफायरियर के रूप में जाना जाता है।

एन ऑन-लीनियर एसवीएम : गैर-रैखिक एसवीएम का उपयोग गैर-रैखिक रूप से अलग किए गए डेटा के लिए किया जाता है, जिसका अर्थ है कि यदि किसी डेटासेट को एक सीधी रेखा का उपयोग करके वर्गीकृत नहीं किया जा सकता है, तो ऐसे डेटा को गैर-रैखिक डेटा कहा जाता है और उपयोग किए जाने वाले क्लासिफायर को गैर-रैखिक डेटा कहा जाता है। -रैखिक एसवीएम वर्गीकारक।

कार्यरत

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

लागत समारोह और ढाल अद्यतन

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

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

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

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

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

नमूना कार्यक्रम स्निपेट

पुस्तकालयों का आयात करना

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split

class SVM:
    def __init__(self, learning_rate=0.0001, lambda_param=0.001, n_iters=10000):
        self.weights = None
        self.bias =  None
        self.lr = learning_rate
        self.lambda_param = lambda_param
        self.n_iters = n_iters
    def fit(self,X,y):
        n_samples, n_features = X.shape
        
        y1 = np.where(y <= 0, -1, 1)
        
        self.weights = np.zeros(n_features)
        self.bias = 0
        for i in range(self.n_iters):
            for idx, x_i in enumerate(X):
                condition = y1[idx] * (np.dot(x_i, self.weights) - self.bias) >= 1
                if condition:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights)
                else:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights - np.dot(x_i, y1[idx]))
                    self.bias -= self.lr * y1[idx]
        
    def predict(self, X):
        approx = np.dot(X, self.weights) - self.bias
        return np.sign(approx)

def accuracy(y_true,y_pred):
    acc = np.sum(y_true == y_pred)/len(y_true)
    return acc
X, y =  datasets.make_blobs(n_samples=10, n_features=2, centers=2, cluster_std=1.05, random_state=40)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=42)
y = np.where(y == 0, -1, 1)
clf = SVM()
clf.fit(X_train,y_train)
predict = clf.predict(X_test)
svm_acc = accuracy(y_test,predict)
print('Accuracy:',svm_acc)
print(f'''
     Final Weight:{clf.weights}
     Final Bias:{clf.bias}
     ''')

अंतिम वजन: [0.34494241 0.1443094]
अंतिम पूर्वाग्रह: -0.012899999999999977

VISUALIZATION

def visualize_svm():
    def get_hyperplane_value(x, w, b, offset):
        return (-w[0] * x + b + offset) / w[1]
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    plt.scatter(X[:,0], X[:,1], marker='x',c=y)

    x0_1 = np.amin(X[:,0])
    x0_2 = np.amax(X[:,0])

    x1_1 = get_hyperplane_value(x0_1, clf.weights, clf.bias, 0)
    x1_2 = get_hyperplane_value(x0_2, clf.weights, clf.bias, 0)

    x1_1_m = get_hyperplane_value(x0_1, clf.weights, clf.bias, -1)
    x1_2_m = get_hyperplane_value(x0_2, clf.weights, clf.bias, -1)

    x1_1_p = get_hyperplane_value(x0_1, clf.weights, clf.bias, 1)
    x1_2_p = get_hyperplane_value(x0_2, clf.weights, clf.bias, 1)

    ax.plot([x0_1, x0_2],[x1_1, x1_2], 'b--')
    ax.plot([x0_1, x0_2],[x1_1_m, x1_2_m], 'k')
    ax.plot([x0_1, x0_2],[x1_1_p, x1_2_p], 'k')

    x1_min = np.amin(X[:,1])
    x1_max = np.amax(X[:,1])
    ax.set_ylim([x1_min-3,x1_max+3])

    plt.show()

visualize_svm()

      
                

                    
                    
                
            

चेहरा पहचान — SVMc छवि के हिस्सों को चेहरे और गैर-चेहरे के रूप में वर्गीकृत करता है और चेहरे के चारों ओर एक चौकोर सीमा बनाता है।

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

निष्कर्ष

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

संदर्भ

समर्थन वेक्टर यंत्र

आर्टिफिशियल इंटेलिजेंस एंड डेटा साइंस (एआई एंड डीएस), विश्वकर्मा इंस्टीट्यूट ऑफ टेक्नोलॉजी, पुणे के छात्रों द्वारा सांख्यिकीय अनुमान (एसआई) के लिए एक होम असाइनमेंट।

द्वारा तैयार:-

1. अजिंक्य महाजन
2. आदित्य बोधनकर
3. रिया ढकलकर
4. दीक्षा प्रसाद
5. शिवानी महाजन