Support Vector Machine eller SVM er en av de mest populære Supervised Learning-algoritmene, som brukes til klassifisering så vel som regresjonsproblemer. Imidlertid brukes den først og fremst til klassifiseringsproblemer i maskinlæring.
Målet med SVM-algoritmen er å lage den beste linjen eller beslutningsgrensen som kan segregere n-dimensjonalt rom i klasser slik at vi enkelt kan sette det nye datapunktet i riktig kategori i fremtiden. Denne beste beslutningsgrensen kalles et hyperplan.
SVM velger de ekstreme punktene/vektorene som hjelper til med å lage hyperplanet. Disse ekstreme tilfellene kalles støttevektorer, og derfor kalles algoritmen Support Vector Machine. Tenk på diagrammet nedenfor der det er to forskjellige kategorier som er klassifisert ved hjelp av en beslutningsgrense eller hyperplan:
Eksempel: SVM kan forstås med eksemplet som vi har brukt i KNN-klassifisereren. Anta at vi ser en merkelig katt som også har noen egenskaper til hunder, så hvis vi vil ha en modell som nøyaktig kan identifisere om det er en katt eller hund, så kan en slik modell lages ved å bruke SVM-algoritmen. Vi skal først trene modellen vår med mange bilder av katter og hunder slik at den kan lære om ulike egenskaper ved katter og hunder, og så tester vi den med denne merkelige skapningen. Så ettersom støttevektor skaper en beslutningsgrense mellom disse to dataene (katt og hund) og velger ekstreme tilfeller (støttevektorer), vil den se ekstremtilfellet katt og hund. På grunnlag av støttevektorene vil den klassifisere den som en katt. Tenk på diagrammet nedenfor:
SVM-algoritme kan brukes til Ansiktsgjenkjenning, bildeklassifisering, tekstkategorisering, etc.
1 million i sifre
Typer SVM
SVM kan være av to typer:
Hyperplane og støttevektorer i SVM-algoritmen:
Hyperplan: Det kan være flere linjer/beslutningsgrenser for å skille klassene i n-dimensjonalt rom, men vi må finne ut den beste beslutningsgrensen som hjelper til med å klassifisere datapunktene. Denne beste grensen er kjent som hyperplanet til SVM.
Dimensjonene til hyperplanet avhenger av funksjonene i datasettet, noe som betyr at hvis det er 2 funksjoner (som vist på bildet), vil hyperplanet være en rett linje. Og hvis det er 3 funksjoner, vil hyperplan være et 2-dimensjonalt plan.
Vi lager alltid et hyperplan som har en maksimal margin, som betyr maksimal avstand mellom datapunktene.
Støttevektorer:
Datapunktene eller vektorene som er nærmest hyperplanet og som påvirker posisjonen til hyperplanet, kalles støttevektor. Siden disse vektorene støtter hyperplanet, derfor kalt en støttevektor.
Hvordan fungerer SVM?
Lineær SVM:
Virkemåten til SVM-algoritmen kan forstås ved å bruke et eksempel. Anta at vi har et datasett som har to tagger (grønt og blått), og datasettet har to funksjoner x1 og x2. Vi vil ha en klassifikator som kan klassifisere paret (x1, x2) med koordinater i enten grønt eller blått. Tenk på bildet nedenfor:
Så siden det er 2-d rom, så ved å bare bruke en rett linje, kan vi enkelt skille disse to klassene. Men det kan være flere linjer som kan skille disse klassene. Tenk på bildet nedenfor:
Derfor hjelper SVM-algoritmen til å finne den beste linjen eller beslutningsgrensen; denne beste grensen eller regionen kalles en hyperplan . SVM-algoritmen finner det nærmeste punktet på linjene fra begge klassene. Disse punktene kalles støttevektorer. Avstanden mellom vektorene og hyperplanet kalles som margin . Og målet til SVM er å maksimere denne marginen. De hyperplan med maksimal margin kalles optimalt hyperplan .
gjør mens du er i java
Ikke-lineær SVM:
Hvis data er lineært ordnet, kan vi skille dem ved å bruke en rett linje, men for ikke-lineære data kan vi ikke tegne en enkelt rett linje. Tenk på bildet nedenfor:
Så for å skille disse datapunktene, må vi legge til en dimensjon til. For lineære data har vi brukt to dimensjoner x og y, så for ikke-lineære data vil vi legge til en tredje dimensjon z. Det kan beregnes som:
z=x<sup>2</sup> +y<sup>2</sup>
Ved å legge til den tredje dimensjonen vil prøverommet bli som bildet nedenfor:
Så nå vil SVM dele datasettene inn i klasser på følgende måte. Tenk på bildet nedenfor:
Siden vi er i 3d-rommet, ser det derfor ut som et plan parallelt med x-aksen. Hvis vi konverterer det i 2d-rom med z=1, blir det slik:
Derfor får vi en omkrets på radius 1 i tilfelle ikke-lineære data.
Python-implementering av Support Vector Machine
Nå skal vi implementere SVM-algoritmen ved hjelp av Python. Her skal vi bruke samme datasett brukerdata , som vi har brukt i Logistisk regresjon og KNN-klassifisering.
Inntil dataforbehandlingstrinnet forblir koden den samme. Nedenfor er 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)
Etter å ha utført koden ovenfor, vil vi forhåndsbehandle dataene. Koden vil gi datasettet som:
Den skalerte utgangen for testsettet vil være:
Tilpasse SVM-klassifisereren til treningssettet:
Nå skal treningssettet tilpasses SVM-klassifisereren. For å lage SVM-klassifisereren vil vi importere SVC klasse fra Sklearn.svm bibliotek. Nedenfor er koden for det:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
I koden ovenfor har vi brukt kernel='lineær' , som her lager vi SVM for lineært separerbare data. Imidlertid kan vi endre det for ikke-lineære data. Og så tilpasset vi klassifisereren til treningsdatasettet (x_train, y_train)
Produksjon:
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)
Modellytelsen kan endres ved å endre verdien på C(Regulariseringsfaktor), gamma og kjerne .
Nå vil vi forutsi utgangen for testsettet. For dette vil vi lage en ny vektor y_pred. Nedenfor er koden for det:
#Predicting the test set result y_pred= classifier.predict(x_test)
Etter å ha fått y_pred vektoren, kan vi sammenligne resultatet av y_pred og y_test for å sjekke forskjellen mellom den faktiske verdien og den anslåtte verdien.
Produksjon: Nedenfor er utdata for prediksjonen av testsettet:
Nå vil vi se ytelsen til SVM-klassifikatoren at hvor mange ukorrekte prediksjoner er det sammenlignet med den logistiske regresjonsklassifikatoren. For å lage forvirringsmatrisen må vi importere forvirringsmatrise funksjonen til sklearn-biblioteket. Etter å ha importert funksjonen vil vi kalle den ved å bruke en ny variabel cm . Funksjonen tar hovedsakelig to parametere y_true (de faktiske verdiene) og y_pred (den målrettede verdienretur av klassifikatoren). Nedenfor er koden for det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produksjon:
Som vi kan se i utdatabildet ovenfor, er det 66+24= 90 riktige spådommer og 8+2= 10 riktige spådommer. Derfor kan vi si at vår SVM-modell ble forbedret sammenlignet med den logistiske regresjonsmodellen.
java strenglengde
Nå skal vi visualisere treningssettets resultat, nedenfor er koden for 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()
Produksjon:
Ved å utføre koden ovenfor vil vi få utdataene som:
Som vi kan se, ser utgangen ovenfor ut som den logistiske regresjonsutgangen. I utgangen fikk vi den rette linjen som hyperplan fordi vi har brukte en lineær kjerne i klassifikatoren . Og vi har også diskutert ovenfor at for 2d-rommet er hyperplanet i SVM en rett 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()
Produksjon:
Ved å utføre koden ovenfor vil vi få utdataene som:
Som vi kan se i utdatabildet ovenfor, har SVM-klassifiseringen delt brukerne inn i to regioner (Kjøpt eller Ikke kjøpt). Brukere som har kjøpt SUV-en er i det røde området med de røde punktene. Og brukere som ikke kjøpte SUV-en er i den grønne regionen med grønne spredningspunkter. Hyperplanet har delt de to klassene inn i Kjøpt og ikke kjøpt variabel.