Support Vector Machine eller SVM er en af de mest populære Supervised Learning-algoritmer, som bruges til både klassifikations- og regressionsproblemer. Det bruges dog primært til klassifikationsproblemer i maskinlæring.
Målet med SVM-algoritmen er at skabe den bedste linje eller beslutningsgrænse, der kan adskille n-dimensionelt rum i klasser, så vi nemt kan placere det nye datapunkt i den rigtige kategori i fremtiden. Denne bedste beslutningsgrænse kaldes et hyperplan.
SVM vælger de ekstreme punkter/vektorer, der hjælper med at skabe hyperplanet. Disse ekstreme tilfælde kaldes støttevektorer, og derfor kaldes algoritmen Support Vector Machine. Overvej nedenstående diagram, hvor der er to forskellige kategorier, der er klassificeret ved hjælp af en beslutningsgrænse eller hyperplan:
Eksempel: SVM kan forstås med det eksempel, som vi har brugt i KNN-klassifikatoren. Antag, at vi ser en mærkelig kat, som også har nogle egenskaber ved hunde, så hvis vi vil have en model, der præcist kan identificere, om det er en kat eller hund, så kan en sådan model oprettes ved at bruge SVM-algoritmen. Vi vil først træne vores model med masser af billeder af katte og hunde, så den kan lære om forskellige træk ved katte og hunde, og derefter tester vi den med dette mærkelige væsen. Så da støttevektor skaber en beslutningsgrænse mellem disse to data (kat og hund) og vælger ekstreme tilfælde (støttevektorer), vil den se ekstreme tilfælde af kat og hund. På basis af støttevektorerne vil den klassificere den som en kat. Overvej nedenstående diagram:
SVM algoritme kan bruges til Ansigtsgenkendelse, billedklassificering, tekstkategorisering, etc.
15 af 100,00
Typer af SVM
SVM kan være af to typer:
Hyperplane- og støttevektorer i SVM-algoritmen:
Hyperplan: Der kan være flere linjer/beslutningsgrænser for at adskille klasserne i n-dimensionelt rum, men vi skal finde ud af den bedste beslutningsgrænse, der hjælper med at klassificere datapunkterne. Denne bedste grænse er kendt som SVM's hyperplan.
Dimensionerne af hyperplanet afhænger af funktionerne i datasættet, hvilket betyder, at hvis der er 2 funktioner (som vist på billedet), så vil hyperplanet være en lige linje. Og hvis der er 3 funktioner, så vil hyperplan være et 2-dimensionelt plan.
Vi opretter altid et hyperplan, der har en maksimal margin, hvilket betyder den maksimale afstand mellem datapunkterne.
Supportvektorer:
De datapunkter eller vektorer, der er tættest på hyperplanet, og som påvirker hyperplanets position, betegnes som Support Vector. Da disse vektorer understøtter hyperplanet, derfor kaldet en støttevektor.
Hvordan virker SVM?
Lineær SVM:
Funktionen af SVM-algoritmen kan forstås ved at bruge et eksempel. Antag, at vi har et datasæt, der har to tags (grøn og blå), og datasættet har to funktioner x1 og x2. Vi ønsker en klassifikator, der kan klassificere parret (x1, x2) af koordinater i enten grøn eller blå. Overvej billedet nedenfor:
Så da det er 2-d rum, så ved blot at bruge en lige linje, kan vi nemt adskille disse to klasser. Men der kan være flere linjer, der kan adskille disse klasser. Overvej billedet nedenfor:
Derfor hjælper SVM-algoritmen med at finde den bedste linje eller beslutningsgrænse; denne bedste grænse eller region kaldes en hyperplan . SVM-algoritmen finder det nærmeste punkt på linjerne fra begge klasser. Disse punkter kaldes støttevektorer. Afstanden mellem vektorerne og hyperplanet kaldes som margen . Og målet med SVM er at maksimere denne margin. Det hyperplan med maksimal margin kaldes optimalt hyperplan .
anaconda vs python slange
Ikke-lineær SVM:
Hvis data er lineært arrangeret, så kan vi adskille dem ved at bruge en ret linje, men for ikke-lineære data kan vi ikke tegne en enkelt ret linje. Overvej billedet nedenfor:
Så for at adskille disse datapunkter er vi nødt til at tilføje en dimension mere. Til lineære data har vi brugt to dimensioner x og y, så for ikke-lineære data tilføjer vi en tredje dimension z. Det kan beregnes som:
z=x<sup>2</sup> +y<sup>2</sup>
Ved at tilføje den tredje dimension vil prøverummet blive som billedet nedenfor:
Så nu vil SVM opdele datasættene i klasser på følgende måde. Overvej billedet nedenfor:
Da vi er i 3-d rum, ser det derfor ud som et plan parallelt med x-aksen. Hvis vi konverterer det i 2d rum med z=1, bliver det som:
Derfor får vi en omkreds på radius 1 i tilfælde af ikke-lineære data.
Python Implementering af Support Vector Machine
Nu vil vi implementere SVM-algoritmen ved hjælp af Python. Her vil vi bruge det samme datasæt brugerdata , som vi har brugt i Logistisk regression og KNN klassificering.
Indtil dataforbehandlingstrinnet forbliver 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)
Efter at have udført ovenstående kode, vil vi forbehandle dataene. Koden vil give datasættet som:
Det skalerede output for testsættet vil være:
Tilpasning af SVM-klassifikatoren til træningssættet:
Nu vil træningssættet blive tilpasset til SVM-klassifikatoren. For at oprette SVM-klassificeringen importerer vi SVC klasse fra Sklearn.svm bibliotek. Nedenfor er koden til det:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
I ovenstående kode har vi brugt kernel='lineær' , da vi her opretter SVM til lineært separerbare data. Vi kan dog ændre det for ikke-lineære data. Og så tilpassede vi klassificeringen til træningsdatasættet (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 ydeevne kan ændres ved at ændre værdien af C(Regularization factor), gamma og kernel .
Nu vil vi forudsige outputtet for testsæt. Til dette vil vi oprette en ny vektor y_pred. Nedenfor er koden til det:
#Predicting the test set result y_pred= classifier.predict(x_test)
Efter at have fået y_pred vektoren, kan vi sammenligne resultatet af y_pred og y_test for at kontrollere forskellen mellem den faktiske værdi og den forudsagte værdi.
Produktion: Nedenfor er output for forudsigelsen af testsættet:
Nu vil vi se ydeevnen af SVM-klassifikatoren, hvor mange ukorrekte forudsigelser er der sammenlignet med den logistiske regressionsklassifikator. For at skabe forvirringsmatricen skal vi importere forvirringsmatrix sklearn-bibliotekets funktion. Efter import af funktionen kalder vi den ved hjælp af en ny variabel cm . Funktionen tager primært to parametre y_sandt (de faktiske værdier) og y_pred (den målrettede værdiretur af klassifikatoren). Nedenfor er koden til det:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produktion:
Som vi kan se i ovenstående outputbillede, er der 66+24= 90 korrekte forudsigelser og 8+2= 10 rigtige forudsigelser. Derfor kan vi sige, at vores SVM-model er forbedret sammenlignet med den logistiske regressionsmodel.
java polymorfi
Nu vil vi visualisere træningssættets resultat, nedenfor er koden til 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:
Ved at udføre ovenstående kode får vi output som:
Som vi kan se, ligner ovenstående output det logistiske regressionsoutput. I outputtet fik vi den lige linje som hyperplan, fordi vi har brugt en lineær kerne i klassificeringen . Og vi har også diskuteret ovenfor, at for 2d-rummet er hyperplanet i SVM en lige 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:
Ved at udføre ovenstående kode får vi output som:
Som vi kan se i ovenstående outputbillede, har SVM-klassifikatoren opdelt brugerne i to regioner (Købt eller Ikke købt). Brugere, der har købt SUV'en, er i det røde område med de røde spredningspunkter. Og brugere, der ikke har købt SUV'en, er i den grønne region med grønne spredningspunkter. Hyperplanet har opdelt de to klasser i Købt og ikke købt variabel.