Support Vector Machine oder SVM ist einer der beliebtesten Algorithmen für überwachtes Lernen, der sowohl für Klassifizierungs- als auch für Regressionsprobleme verwendet wird. In erster Linie wird es jedoch für Klassifizierungsprobleme beim maschinellen Lernen verwendet.
Das Ziel des SVM-Algorithmus besteht darin, die beste Linie oder Entscheidungsgrenze zu erstellen, die den n-dimensionalen Raum in Klassen aufteilen kann, sodass wir den neuen Datenpunkt in Zukunft problemlos in die richtige Kategorie einordnen können. Diese beste Entscheidungsgrenze wird Hyperebene genannt.
SVM wählt die Extrempunkte/Vektoren aus, die bei der Erstellung der Hyperebene hilfreich sind. Diese Extremfälle werden als Support-Vektoren bezeichnet, und daher wird der Algorithmus als Support-Vektor-Maschine bezeichnet. Betrachten Sie das folgende Diagramm, in dem es zwei verschiedene Kategorien gibt, die anhand einer Entscheidungsgrenze oder Hyperebene klassifiziert werden:
Beispiel: SVM kann anhand des Beispiels verstanden werden, das wir im KNN-Klassifikator verwendet haben. Angenommen, wir sehen eine seltsame Katze, die auch einige Merkmale eines Hundes aufweist. Wenn wir also ein Modell benötigen, das genau erkennen kann, ob es sich um eine Katze oder einen Hund handelt, kann ein solches Modell mithilfe des SVM-Algorithmus erstellt werden. Wir trainieren unser Modell zunächst mit vielen Bildern von Katzen und Hunden, damit es die verschiedenen Merkmale von Katzen und Hunden kennenlernen kann, und testen es dann mit dieser seltsamen Kreatur. Wenn der Unterstützungsvektor also eine Entscheidungsgrenze zwischen diesen beiden Daten (Katze und Hund) erstellt und Extremfälle (Unterstützungsvektoren) auswählt, wird der Extremfall Katze und Hund angezeigt. Auf der Grundlage der Unterstützungsvektoren wird es als Katze klassifiziert. Betrachten Sie das folgende Diagramm:
Der SVM-Algorithmus kann verwendet werden für Gesichtserkennung, Bildklassifizierung, Textkategorisierung, usw.
Systemsoftware
Arten von SVM
Es gibt zwei Arten von SVM:
Hyperebene und Unterstützungsvektoren im SVM-Algorithmus:
Hyperebene: Es kann mehrere Linien/Entscheidungsgrenzen geben, um die Klassen im n-dimensionalen Raum zu trennen, aber wir müssen die beste Entscheidungsgrenze herausfinden, die bei der Klassifizierung der Datenpunkte hilft. Diese beste Grenze wird als SVM-Hyperebene bezeichnet.
Die Abmessungen der Hyperebene hängen von den im Datensatz vorhandenen Features ab. Wenn also zwei Features vorhanden sind (wie im Bild gezeigt), ist die Hyperebene eine gerade Linie. Und wenn es drei Features gibt, ist die Hyperebene eine zweidimensionale Ebene.
Wir erstellen immer eine Hyperebene mit einem maximalen Rand, also dem maximalen Abstand zwischen den Datenpunkten.
Unterstützungsvektoren:
Die Datenpunkte oder Vektoren, die der Hyperebene am nächsten liegen und die Position der Hyperebene beeinflussen, werden als Stützvektor bezeichnet. Da diese Vektoren die Hyperebene unterstützen, werden sie daher als Unterstützungsvektor bezeichnet.
Wie funktioniert SVM?
Lineare SVM:
Anhand eines Beispiels lässt sich die Funktionsweise des SVM-Algorithmus nachvollziehen. Angenommen, wir haben einen Datensatz mit zwei Tags (grün und blau) und der Datensatz verfügt über zwei Merkmale x1 und x2. Wir wollen einen Klassifikator, der das Koordinatenpaar (x1, x2) entweder in Grün oder Blau klassifizieren kann. Betrachten Sie das folgende Bild:
Da es sich also um einen zweidimensionalen Raum handelt, können wir diese beiden Klassen einfach durch die Verwendung einer geraden Linie trennen. Es kann jedoch mehrere Zeilen geben, die diese Klassen trennen können. Betrachten Sie das folgende Bild:
Daher hilft der SVM-Algorithmus dabei, die beste Linie oder Entscheidungsgrenze zu finden; Diese beste Grenze oder Region wird als a bezeichnet Hyperebene . Der SVM-Algorithmus findet den nächstgelegenen Punkt der Linien beider Klassen. Diese Punkte werden Stützvektoren genannt. Der Abstand zwischen den Vektoren und der Hyperebene wird als bezeichnet Marge . Und das Ziel von SVM ist es, diese Marge zu maximieren. Der Hyperebene mit maximaler Marge heißt die optimale Hyperebene .
Nichtlineare SVM:
Wenn Daten linear angeordnet sind, können wir sie mithilfe einer geraden Linie trennen. Bei nichtlinearen Daten können wir jedoch keine einzelne gerade Linie zeichnen. Betrachten Sie das folgende Bild:
Um diese Datenpunkte zu trennen, müssen wir eine weitere Dimension hinzufügen. Für lineare Daten haben wir zwei Dimensionen x und y verwendet, für nichtlineare Daten fügen wir eine dritte Dimension z hinzu. Es kann wie folgt berechnet werden:
Java-String zum Zeichen
z=x<sup>2</sup> +y<sup>2</sup>
Durch Hinzufügen der dritten Dimension sieht der Beispielraum wie im folgenden Bild aus:
Nun teilt SVM die Datensätze wie folgt in Klassen ein. Betrachten Sie das folgende Bild:
Da wir uns im dreidimensionalen Raum befinden, sieht es wie eine Ebene parallel zur x-Achse aus. Wenn wir es in den 2D-Raum mit z=1 konvertieren, wird es wie folgt aussehen:
Daher erhalten wir bei nichtlinearen Daten einen Umfang mit Radius 1.
Python-Implementierung der Support Vector Machine
Jetzt implementieren wir den SVM-Algorithmus mit Python. Hier verwenden wir denselben Datensatz Benutzerdaten , die wir in der logistischen Regression und der KNN-Klassifizierung verwendet haben.
Bis zum Datenvorverarbeitungsschritt bleibt der Code derselbe. Unten ist der 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)
Nach der Ausführung des obigen Codes werden wir die Daten vorverarbeiten. Der Code gibt den Datensatz wie folgt aus:
Die skalierte Ausgabe für den Testsatz lautet:
Anpassen des SVM-Klassifikators an den Trainingssatz:
Jetzt wird der Trainingssatz an den SVM-Klassifikator angepasst. Um den SVM-Klassifikator zu erstellen, importieren wir SVC Klasse von Sklearn.svm Bibliothek. Unten ist der Code dafür:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
Im obigen Code haben wir verwendet kernel='linear' , da wir hier eine SVM für linear trennbare Daten erstellen. Wir können es jedoch für nichtlineare Daten ändern. Und dann haben wir den Klassifikator an den Trainingsdatensatz (x_train, y_train) angepasst.
Ausgabe:
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)
Die Modellleistung kann durch Ändern des Werts von geändert werden C (Regularisierungsfaktor), Gamma und Kernel .
Jetzt werden wir die Ausgabe für den Testsatz vorhersagen. Dazu erstellen wir einen neuen Vektor y_pred. Unten ist der Code dafür:
#Predicting the test set result y_pred= classifier.predict(x_test)
Nachdem wir den y_pred-Vektor erhalten haben, können wir das Ergebnis vergleichen y_pred Und y_test um die Differenz zwischen dem tatsächlichen Wert und dem vorhergesagten Wert zu überprüfen.
Ausgabe: Unten ist die Ausgabe für die Vorhersage des Testsatzes:
Jetzt werden wir die Leistung des SVM-Klassifikators sehen, wie viele falsche Vorhersagen es im Vergleich zum logistischen Regressionsklassifikator gibt. Um die Verwirrungsmatrix zu erstellen, müssen wir die importieren Verwirrung Matrix Funktion der Sklearn-Bibliothek. Nachdem wir die Funktion importiert haben, rufen wir sie mit einer neuen Variablen auf cm . Die Funktion benötigt hauptsächlich zwei Parameter y_true (die tatsächlichen Werte) und y_pred (der vom Klassifikator zurückgegebene Zielwert). Unten ist der Code dafür:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Ausgabe:
Wie wir im obigen Ausgabebild sehen können, gibt es 66+24= 90 richtige Vorhersagen und 8+2= 10 richtige Vorhersagen. Daher können wir sagen, dass sich unser SVM-Modell im Vergleich zum logistischen Regressionsmodell verbessert hat.
Jetzt visualisieren wir das Ergebnis des Trainingssatzes. Unten finden Sie den Code dafür:
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()
Ausgabe:
Wenn wir den obigen Code ausführen, erhalten wir die Ausgabe wie folgt:
Wie wir sehen können, ähnelt die obige Ausgabe der Ausgabe der logistischen Regression. In der Ausgabe haben wir die gerade Linie als Hyperebene erhalten, weil wir haben verwendete einen linearen Kernel im Klassifikator . Und wir haben oben auch besprochen, dass die Hyperebene in SVM für den 2D-Raum eine gerade Linie ist.
#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()
Ausgabe:
Wenn wir den obigen Code ausführen, erhalten wir die Ausgabe wie folgt:
Wie wir im obigen Ausgabebild sehen können, hat der SVM-Klassifikator die Benutzer in zwei Regionen unterteilt (gekauft oder nicht gekauft). Nutzer, die den SUV gekauft haben, liegen mit den roten Streupunkten im roten Bereich. Und Nutzer, die das SUV nicht gekauft haben, liegen mit grünen Streupunkten im grünen Bereich. Die Hyperebene hat die beiden Klassen in gekaufte und nicht gekaufte Variablen unterteilt.
obj in Java