Support Vector Machine of SVM is een van de meest populaire Supervised Learning-algoritmen, die wordt gebruikt voor zowel classificatie- als regressieproblemen. Het wordt echter voornamelijk gebruikt voor classificatieproblemen bij Machine Learning.
Het doel van het SVM-algoritme is om de beste lijn of beslissingsgrens te creëren die de n-dimensionale ruimte in klassen kan opdelen, zodat we het nieuwe datapunt in de toekomst gemakkelijk in de juiste categorie kunnen plaatsen. Deze beste beslissingsgrens wordt een hypervlak genoemd.
SVM kiest de extreme punten/vectoren die helpen bij het creëren van het hypervlak. Deze extreme gevallen worden ondersteuningsvectoren genoemd en daarom wordt het algoritme Support Vector Machine genoemd. Beschouw het onderstaande diagram waarin er twee verschillende categorieën zijn die worden geclassificeerd met behulp van een beslissingsgrens of hypervlak:
Voorbeeld: SVM kan worden begrepen met het voorbeeld dat we hebben gebruikt in de KNN-classificator. Stel dat we een vreemde kat zien die ook enkele kenmerken van honden heeft, dus als we een model willen dat nauwkeurig kan identificeren of het een kat of een hond is, kan zo'n model worden gemaakt met behulp van het SVM-algoritme. We zullen ons model eerst trainen met veel afbeeldingen van katten en honden, zodat het de verschillende kenmerken van katten en honden kan leren kennen, en daarna testen we het met dit vreemde wezen. Dus omdat de steunvector een beslissingsgrens creëert tussen deze twee gegevens (kat en hond) en extreme gevallen kiest (steunvectoren), zal hij het extreme geval van kat en hond zien. Op basis van de steunvectoren zal het dier als een kat worden geclassificeerd. Beschouw het onderstaande diagram:
SVM-algoritme kan hiervoor worden gebruikt Gezichtsdetectie, beeldclassificatie, tekstcategorisatie, enz.
typ variabelen java
Soorten SVM
SVM kan uit twee typen bestaan:
Hypervlak- en ondersteuningsvectoren in het SVM-algoritme:
Hypervlak: Er kunnen meerdere lijnen/beslissingsgrenzen zijn om de klassen in de n-dimensionale ruimte te scheiden, maar we moeten de beste beslissingsgrens vinden die helpt bij het classificeren van de gegevenspunten. Deze beste grens staat bekend als het hypervlak van SVM.
De afmetingen van het hypervlak zijn afhankelijk van de kenmerken die aanwezig zijn in de dataset, wat betekent dat als er twee kenmerken zijn (zoals weergegeven in de afbeelding), het hypervlak een rechte lijn zal zijn. En als er drie kenmerken zijn, dan is het hypervlak een tweedimensionaal vlak.
We creëren altijd een hypervlak met een maximale marge, wat de maximale afstand tussen de datapunten betekent.
Ondersteuningsvectoren:
De datapunten of vectoren die zich het dichtst bij het hypervlak bevinden en die de positie van het hypervlak beïnvloeden, worden ondersteuningsvector genoemd. Omdat deze vectoren het hypervlak ondersteunen, worden ze daarom een ondersteuningsvector genoemd.
Hoe werkt SVM?
Lineaire SVM:
De werking van het SVM-algoritme kan worden begrepen aan de hand van een voorbeeld. Stel dat we een dataset hebben met twee tags (groen en blauw), en de dataset heeft twee features x1 en x2. We willen een classificator die het paar (x1, x2) coördinaten in groen of blauw kan classificeren. Beschouw de onderstaande afbeelding:
Omdat het een 2D-ruimte is, kunnen we deze twee klassen eenvoudig scheiden door alleen maar een rechte lijn te gebruiken. Maar er kunnen meerdere lijnen zijn die deze klassen kunnen scheiden. Beschouw de onderstaande afbeelding:
Het SVM-algoritme helpt dus bij het vinden van de beste lijn of beslissingsgrens; deze beste grens of regio wordt a genoemd hypervlak . Het SVM-algoritme vindt het dichtstbijzijnde punt van de lijnen uit beide klassen. Deze punten worden steunvectoren genoemd. De afstand tussen de vectoren en het hypervlak wordt genoemd als marge . En het doel van SVM is om deze marge te maximaliseren. De hypervlak met maximale marge heet de optimaal hypervlak .
Niet-lineaire SVM:
Als gegevens lineair zijn gerangschikt, kunnen we deze scheiden door een rechte lijn te gebruiken, maar voor niet-lineaire gegevens kunnen we geen enkele rechte lijn trekken. Beschouw de onderstaande afbeelding:
Om deze gegevenspunten te scheiden, moeten we nog een dimensie toevoegen. Voor lineaire gegevens hebben we twee dimensies x en y gebruikt, dus voor niet-lineaire gegevens voegen we een derde dimensie z toe. Het kan worden berekend als:
z=x<sup>2</sup> +y<sup>2</sup>
Door de derde dimensie toe te voegen, wordt de voorbeeldruimte zoals onderstaande afbeelding:
Dus nu zal SVM de datasets op de volgende manier in klassen verdelen. Beschouw de onderstaande afbeelding:
Omdat we ons in de 3D-ruimte bevinden, lijkt het op een vlak evenwijdig aan de x-as. Als we het in de 2D-ruimte converteren met z=1, wordt het als:
datalinklaagprotocollen
Daarom krijgen we een omtrek met straal 1 in het geval van niet-lineaire gegevens.
Python-implementatie van Support Vector Machine
Nu zullen we het SVM-algoritme implementeren met behulp van Python. Hier zullen we dezelfde dataset gebruiken gebruikersgegevens , die we hebben gebruikt in logistieke regressie en KNN-classificatie.
Tot de stap voorverwerking van gegevens blijft de code hetzelfde. Hieronder staat de code:
#Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Na het uitvoeren van bovenstaande code gaan we de gegevens voorbewerken. De code geeft de dataset als:
De geschaalde uitvoer voor de testset is:
De SVM-classificator aan de trainingsset aanpassen:
Nu wordt de trainingsset aangepast aan de SVM-classificator. Om de SVM-classificator te maken, zullen we importeren SVC klasse uit Sklearn.svm bibliotheek. Hieronder staat de code ervoor:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
In de bovenstaande code hebben we gebruikt kernel='lineair' , omdat we hier SVM creëren voor lineair scheidbare gegevens. We kunnen dit echter wijzigen voor niet-lineaire gegevens. En vervolgens hebben we de classificator aangepast aan de trainingsdataset (x_train, y_train)
Uitgang:
Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False)
De modelprestaties kunnen worden gewijzigd door de waarde van te wijzigen C (regularisatiefactor), gamma en kernel .
Nu gaan we de uitvoer voor de testset voorspellen. Hiervoor zullen we een nieuwe vector y_pred maken. Hieronder staat de code ervoor:
#Predicting the test set result y_pred= classifier.predict(x_test)
Nadat we de y_pred-vector hebben verkregen, kunnen we het resultaat vergelijken van y_pred En y_test om het verschil tussen de werkelijke waarde en de voorspelde waarde te controleren.
Uitgang: Hieronder vindt u de uitvoer voor de voorspelling van de testset:
algoritme voor rsa
Nu zullen we de prestaties van de SVM-classificator zien, hoeveel onjuiste voorspellingen er zijn in vergelijking met de logistieke regressieclassificator. Om de verwarringsmatrix te creëren, moeten we de verwarring_matrix functie van de sklearn-bibliotheek. Nadat we de functie hebben geïmporteerd, zullen we deze aanroepen met een nieuwe variabele cm . De functie heeft hoofdzakelijk twee parameters nodig y_true (de werkelijke waarden) en y_pred (de beoogde waarderetour door de classificator). Hieronder staat de code ervoor:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Uitgang:
Zoals we in de bovenstaande uitvoerafbeelding kunnen zien, zijn er 66+24= 90 correcte voorspellingen en 8+2= 10 correcte voorspellingen. Daarom kunnen we zeggen dat ons SVM-model verbeterd is in vergelijking met het logistieke regressiemodel.
Nu gaan we het resultaat van de trainingsset visualiseren, hieronder vindt u de code ervoor:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Uitgang:
Door de bovenstaande code uit te voeren, krijgen we de uitvoer als:
Zoals we kunnen zien, lijkt de bovenstaande uitvoer op de logistieke regressie-uitvoer. In de uitvoer hebben we de rechte lijn als hypervlak gekregen, omdat we dat hebben gedaan gebruikte een lineaire kernel in de classificator . En we hebben hierboven ook besproken dat voor de 2D-ruimte het hypervlak in SVM een rechte lijn is.
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Uitgang:
Door de bovenstaande code uit te voeren, krijgen we de uitvoer als:
Zoals we in de bovenstaande uitvoerafbeelding kunnen zien, heeft de SVM-classificator de gebruikers in twee regio's verdeeld (Gekocht of Niet gekocht). Gebruikers die de SUV hebben gekocht, bevinden zich in het rode gebied met de rode spreidingspunten. En gebruikers die de SUV niet hebben gekocht, bevinden zich in de groene regio met groene spreidingspunten. Het hypervlak heeft de twee klassen verdeeld in gekochte en niet gekochte variabelen.