Support Vector Machine eller SVM är en av de mest populära Supervised Learning-algoritmerna, som används för såväl klassificering som regressionsproblem. Det används dock i första hand för klassificeringsproblem i maskininlärning.
Målet med SVM-algoritmen är att skapa den bästa linjen eller beslutsgränsen som kan segregera n-dimensionellt utrymme i klasser så att vi enkelt kan placera den nya datapunkten i rätt kategori i framtiden. Denna bästa beslutsgräns kallas ett hyperplan.
SVM väljer de extrema punkter/vektorer som hjälper till att skapa hyperplanet. Dessa extrema fall kallas stödvektorer, och därför kallas algoritmen Support Vector Machine. Betrakta diagrammet nedan där det finns två olika kategorier som klassificeras med hjälp av en beslutsgräns eller hyperplan:
Exempel: SVM kan förstås med exemplet som vi har använt i KNN-klassificeraren. Anta att vi ser en konstig katt som också har vissa egenskaper hos hundar, så om vi vill ha en modell som exakt kan identifiera om det är en katt eller hund, så kan en sådan modell skapas genom att använda SVM-algoritmen. Vi kommer först att träna vår modell med massor av bilder på katter och hundar så att den kan lära sig om olika egenskaper hos katter och hundar, och sedan testar vi den med denna märkliga varelse. Så eftersom stödvektor skapar en beslutsgräns mellan dessa två data (katt och hund) och väljer extremfall (stödvektorer), kommer den att se extremfallet katt och hund. På basis av stödvektorerna kommer den att klassificera den som en katt. Tänk på nedanstående diagram:
SVM-algoritm kan användas för Ansiktsavkänning, bildklassificering, textkategorisering, etc.
np.unik
Typer av SVM
SVM kan vara av två typer:
Hyperplane och stödvektorer i SVM-algoritmen:
Hyperplan: Det kan finnas flera linjer/beslutsgränser för att segregera klasserna i det n-dimensionella rummet, men vi måste ta reda på den bästa beslutsgränsen som hjälper till att klassificera datapunkterna. Denna bästa gräns är känd som SVMs hyperplan.
Dimensionerna för hyperplanet beror på funktionerna som finns i datamängden, vilket betyder att om det finns 2 funktioner (som visas på bilden), så kommer hyperplanet att vara en rak linje. Och om det finns 3 funktioner, kommer hyperplan att vara ett 2-dimensionellt plan.
Vi skapar alltid ett hyperplan som har en maximal marginal, vilket innebär det maximala avståndet mellan datapunkterna.
Supportvektorer:
De datapunkter eller vektorer som ligger närmast hyperplanet och som påverkar hyperplanets position kallas Support Vector. Eftersom dessa vektorer stöder hyperplanet, kallas därför en stödvektor.
Hur fungerar SVM?
Linjär SVM:
SVM-algoritmens funktion kan förstås genom att använda ett exempel. Anta att vi har en datauppsättning som har två taggar (grön och blå), och datauppsättningen har två funktioner x1 och x2. Vi vill ha en klassificerare som kan klassificera paret (x1, x2) av koordinater i antingen grönt eller blått. Tänk på bilden nedan:
Så eftersom det är tvådimensionellt utrymme så genom att bara använda en rak linje kan vi enkelt separera dessa två klasser. Men det kan finnas flera rader som kan skilja dessa klasser åt. Tänk på bilden nedan:
Därför hjälper SVM-algoritmen att hitta den bästa linjen eller beslutsgränsen; denna bästa gräns eller region kallas en hyperplan . SVM-algoritmen hittar den närmaste punkten på linjerna från båda klasserna. Dessa punkter kallas stödvektorer. Avståndet mellan vektorerna och hyperplanet kallas som marginal . Och målet för SVM är att maximera denna marginal. De hyperplan med maximal marginal kallas optimalt hyperplan .
Icke-linjär SVM:
Om data är linjärt ordnade kan vi separera dem genom att använda en rät linje, men för icke-linjära data kan vi inte rita en enda rät linje. Tänk på bilden nedan:
Så för att separera dessa datapunkter måste vi lägga till ytterligare en dimension. För linjär data har vi använt två dimensioner x och y, så för icke-linjär data lägger vi till en tredje dimension z. Det kan beräknas som:
z=x<sup>2</sup> +y<sup>2</sup>
Genom att lägga till den tredje dimensionen blir provutrymmet som bilden nedan:
Så nu kommer SVM att dela upp datamängderna i klasser på följande sätt. Tänk på bilden nedan:
Eftersom vi är i 3-d rymden ser det därför ut som ett plan parallellt med x-axeln. Om vi konverterar det i 2d rymden med z=1, blir det som:
Därför får vi en omkrets med radie 1 i fallet med icke-linjära data.
Python-implementering av Support Vector Machine
Nu ska vi implementera SVM-algoritmen med Python. Här kommer vi att använda samma dataset användardata , som vi har använt i logistisk regression och KNN-klassificering.
Fram till steget för dataförbehandling kommer koden att förbli densamma. Nedan är koden:
#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)
Efter exekvering av ovanstående kod kommer vi att förbehandla data. Koden kommer att ge datasetet som:
Den skalade utgången för testsetet kommer att vara:
typer av for loop
Anpassa SVM-klassificeraren till träningssetet:
Nu ska träningssetet anpassas till SVM klassificeraren. För att skapa SVM-klassificeraren kommer vi att importera SVC klass från Sklearn.svm bibliotek. Nedan är koden för det:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
I ovanstående kod har vi använt kernel='linjär' , eftersom vi här skapar SVM för linjärt separerbara data. Vi kan dock ändra det för icke-linjära data. Och sedan anpassade vi klassificeraren till träningsdatauppsättningen (x_train, y_train)
Produktion:
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)
Modellens prestanda kan ändras genom att ändra värdet på C (Regularization factor), gamma och kärna .
java sträng konkat
Nu kommer vi att förutsäga utdata för testset. För detta kommer vi att skapa en ny vektor y_pred. Nedan är koden för det:
#Predicting the test set result y_pred= classifier.predict(x_test)
Efter att ha fått vektorn y_pred kan vi jämföra resultatet av y_pred och y_test för att kontrollera skillnaden mellan det faktiska värdet och det förutsagda värdet.
Produktion: Nedan är resultatet för förutsägelsen av testsetet:
Nu kommer vi att se prestandan för SVM-klassificeraren att hur många felaktiga förutsägelser som finns jämfört med den logistiska regressionsklassificeraren. För att skapa förvirringsmatrisen måste vi importera confusion_matrix sklearn-bibliotekets funktion. Efter att ha importerat funktionen kommer vi att kalla den med en ny variabel centimeter . Funktionen tar huvudsakligen två parametrar y_true (de faktiska värdena) och y_pred (den riktade värderetur av klassificeraren). Nedan är koden för det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produktion:
Som vi kan se i utdatabilden ovan finns det 66+24= 90 korrekta förutsägelser och 8+2= 10 korrekta förutsägelser. Därför kan vi säga att vår SVM-modell förbättrades jämfört med den logistiska regressionsmodellen.
Nu ska vi visualisera träningsuppsättningens resultat, nedan är koden för det:
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()
Produktion:
Genom att köra ovanstående kod får vi utdata som:
Som vi kan se verkar ovanstående utdata likna logistisk regression. I utgången fick vi den raka linjen som hyperplan eftersom vi har använde en linjär kärna i klassificeraren . Och vi har också diskuterat ovan att för 2d-rymden är hyperplanet i SVM en rak linje.
#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()
Produktion:
Genom att köra ovanstående kod får vi utdata som:
Som vi kan se i ovanstående utdatabild har SVM-klassificeraren delat upp användarna i två regioner (Köpt eller Ej köpt). Användare som köpt SUV:n befinner sig i det röda området med de röda punkterna. Och användare som inte köpte SUV:n befinner sig i den gröna regionen med gröna spridningspunkter. Hyperplanet har delat upp de två klasserna i köpt och ej köpt variabel.