Support Vector Machine – Einführung in die maschinellen Lernalgorithmen

4 min read

SVM-Modell von Grund auf

Support Vector Machine

Einführung

Ich denke, Sie haben sich inzwischen an lineare Regression und logistische Regressionsalgorithmen gewöhnt. Wenn nicht, schlage ich vor, dass Sie sich diese ansehen, bevor Sie mit der Unterstützung der Vektormaschine beginnen. Support Vector Machine ist ein weiterer einfacher Algorithmus, den jeder Experte für maschinelles Lernen in seinem Arsenal haben sollte. Support Vector Machine wird von vielen sehr bevorzugt, da sie bei geringer Rechenleistung eine erhebliche Genauigkeit erzeugt. Support Vector Machine, abgekürzt als SVM, kann sowohl für Regressions- als auch für Klassifizierungsaufgaben verwendet werden. Es wird jedoch häufig für Klassifizierungsziele verwendet.

Was ist Support Vector Machine?

Das Ziel des Unterstützungsvektormaschinenalgorithmus besteht darin, eine Hyperebene in einem N-dimensionalen Raum (N – die Anzahl von Merkmalen) zu finden, die die Datenpunkte eindeutig klassifiziert.

Mögliche Hyperflugzeuge

Um die beiden Klassen von Datenpunkten zu trennen, gibt es viele mögliche Hyperebenen, die ausgewählt werden können. Unser Ziel ist es, eine Ebene zu finden, die den maximalen Abstand hat, d.h. den maximalen Abstand zwischen den Datenpunkten beider Klassen. Durch die Maximierung des Randabstands wird eine gewisse Verstärkung erzielt, sodass zukünftige Datenpunkte sicherer klassifiziert werden können.

Hyperplanes und Unterstützungsvektoren
Hyperebenen im 2D- und 3D-Objektraum

Hyperebenen sind Entscheidungsgrenzen, mit deren Hilfe die Datenpunkte klassifiziert werden. Datenpunkte, die auf beiden Seiten der Hyperebene liegen, können verschiedenen Klassen zugeordnet werden. Die Dimension der Hyperebene hängt auch von der Anzahl der Features ab. Wenn die Anzahl der Eingabe-Features 2 ist, ist die Hyperebene nur eine Linie. Wenn die Anzahl der Eingabe-Features 3 ist, wird die Hyperebene zu einer zweidimensionalen Ebene. Es wird schwierig, sich vorzustellen, wenn die Anzahl der Features 3 übersteigt.

Unterstützungsvektoren sind Datenpunkte, die näher an der Hyperebene liegen und die Position und Orientierung der Hyperebene beeinflussen. Mit diesen Unterstützungsvektoren maximieren wir den Spielraum des Klassifikators. Durch das Löschen der Unterstützungsvektoren wird die Position der Hyperebene geändert. Dies sind die Punkte, die uns beim Aufbau unserer SVM helfen.

Intuition großer Margen

Bei der logistischen Regression nehmen wir die Ausgabe der linearen Funktion und quetschen den Wert innerhalb des Bereichs von [0, 1] mit der Sigmoid-Funktion. Wenn der gequetschte Wert größer als ein Schwellenwert (0.5) ist, weisen wir ihm eine Bezeichnung 1 zu, andernfalls eine Bezeichnung 0. In SVM nehmen wir die Ausgabe der linearen Funktion und wenn diese Ausgabe größer als 1 ist, identifizieren wir sie mit einer Klasse, wenn diese Ausgabe -1 ausmacht, identifizieren wir sie mit der anderen Klasse. Wenn es sich um eine Klasse handelt und wenn die Ausgabe -1 ist, identifizieren wir uns mit einer anderen Klasse. Da die Schwellenwerte in SVM auf 1 und -1 geändert werden, erhalten wir diesen Verstärkungsbereich ([-1, 1]), der als Rand dient.

Kostenfunktion und Verlaufsaktualisierungen

Im SVM-Algorithmus wollen wir den Abstand zwischen den Datenpunkten und der Hyperebene maximieren. Die Verlustfunktion, die zur Maximierung der Marge beiträgt, ist der Scharnierverlust.

Gelenkverlustfunktion

Die Kosten sind 0, wenn der vorhergesagte Wert und der tatsächliche Wert dasselbe Vorzeichen haben. Wenn dies nicht der Fall ist, berechnen wir den Verlustwert. Wir fügen der Kostenfunktion auch einen Regularisierungsparameter hinzu. Das Ziel des Regularisierungsparameters besteht darin, die Margenmaximierung und den Verlust auszugleichen. Nach dem Hinzufügen des Regularisierungsparameters sehen die Kostenfunktionen wie folgt aus.

Verlustfunktion für SVM

Jetzt, da wir die Verlustfunktion haben, nehmen wir partielle Ableitungen bezüglich der Gewichtungen, um die Gradienten zu finden. Mit den Steigungen können wir unsere Gewichtungen aktualisieren.

Farbverläufe

Wenn keine Fehlklassifizierung vorliegt, d.h. unser Modell die Klasse unseres Datenpunkts richtig vorhersagt, müssen wir nur den Verlauf über den Parameter für die Regularisierung aktualisieren.

Verlaufsaktualisierung – Keine Fehlklassifizierung

Wenn eine Fehlklassifizierung vorliegt, d.h. unser Modell einen Fehler bei der Vorhersage der Klasse unserer Datenpunkte macht, schließen wir den Verlust zusammen mit dem Regularisierungsparameter mit ein, um die Aktualisierung der Steigung durchzuführen.

Verlaufsaktualisierung – Fehlklassifizierung
SVM-Implementierung in Python

Der Datensatz, den wir zur Implementierung unseres SVM-Algorithmus verwenden werden, ist der Iris-Datensatz. Sie können diesen von diesem Link herunterladen.

import pandas as pd

df = pd.read_csv('/Users/rohith/Documents/Datasets/Iris_dataset/iris.csv')
df = df.drop(['Id'],axis=1)
target = df['Species']
s = set()
for val in target:
    s.add(val)
s = list(s)
rows = list(range(100,150))
df = df.drop(df.index[rows])

Da das Iris-Dataset drei Klassen hat, werden wir eine der Klassen entfernen. Dies führt zu einem binären Klassifizierungsproblem.

import matplotlib.pyplot as plt

x = df['SepalLengthCm']
y = df['PetalLengthCm']

setosa_x = x[:50]
setosa_y = y[:50]

versicolor_x = x[50:]
versicolor_y = y[50:]

plt.figure(figsize=(8,6))
plt.scatter(setosa_x,setosa_y,marker='+',color='green')
plt.scatter(versicolor_x,versicolor_y,marker='_',color='red')
plt.show()
Datenpunkte visualisieren

Außerdem stehen uns vier Funktionen zur Verfügung. Wir werden nur zwei Funktionen verwenden, nämlich Sepal-Länge und Blütenblatt-Länge. Wir nehmen diese beiden Funktionen und plotten sie zur Visualisierung. Aus dem obigen Diagramm können Sie folgern, dass eine lineare Linie zur Trennung der Datenpunkte verwendet werden kann.

from sklearn.utils import shuffle
from sklearn.cross_validation import train_test_split
import numpy as np
## Drop rest of the features and extract the target values
df = df.drop(['SepalWidthCm','PetalWidthCm'],axis=1)
Y = []
target = df['Species']
for val in target:
    if(val == 'Iris-setosa'):
        Y.append(-1)
    else:
        Y.append(1)
df = df.drop(['Species'],axis=1)
X = df.values.tolist()
## Shuffle and split the data into training and test set
X, Y = shuffle(X,Y)
x_train = []
y_train = []
x_test = []
y_test = []

x_train, x_test, y_train, y_test = train_test_split(X, Y, train_size=0.9)

x_train = np.array(x_train)
y_train = np.array(y_train)
x_test = np.array(x_test)
y_test = np.array(y_test)

y_train = y_train.reshape(90,1)
y_test = y_test.reshape(10,1)

Wir extrahieren die erforderlichen Funktionen und teilen sie in Trainings- und Testdaten auf. 90% der Daten werden für das Training verwendet und die restlichen 10% für Tests. Lassen Sie uns nun unser SVM-Modell mit der numpy-Bibliothek erstellen.

## Support Vector Machine 
import numpy as np

train_f1 = x_train[:,0]
train_f2 = x_train[:,1]

train_f1 = train_f1.reshape(90,1)
train_f2 = train_f2.reshape(90,1)

w1 = np.zeros((90,1))
w2 = np.zeros((90,1))

epochs = 1
alpha = 0.0001

while(epochs < 10000):
    y = w1 * train_f1 + w2 * train_f2
    prod = y * y_train
    print(epochs)
    count = 0
    for val in prod:
        if(val >= 1):
            cost = 0
            w1 = w1 - alpha * (2 * 1/epochs * w1)
            w2 = w2 - alpha * (2 * 1/epochs * w2)
            
        else:
            cost = 1 - val 
            w1 = w1 + alpha * (train_f1[count] * y_train[count] - 2 * 1/epochs * w1)
            w2 = w2 + alpha * (train_f2[count] * y_train[count] - 2 * 1/epochs * w2)
        count += 1
    epochs += 1

α (0,0001) ist die Lernrate und der Regularisierungsparameter λ ist auf 1 / Epochen eingestellt. Daher verringert der Regularisierungswert die Anzahl der Epochen.

from sklearn.metrics import accuracy_score

## Clip the weights 
index = list(range(10,90))
w1 = np.delete(w1,index)
w2 = np.delete(w2,index)

w1 = w1.reshape(10,1)
w2 = w2.reshape(10,1)
## Extract the test data features 
test_f1 = x_test[:,0]
test_f2 = x_test[:,1]

test_f1 = test_f1.reshape(10,1)
test_f2 = test_f2.reshape(10,1)
## Predict
y_pred = w1 * test_f1 + w2 * test_f2
predictions = []
for val in y_pred:
    if(val > 1):
        predictions.append(1)
    else:
        predictions.append(-1)

print(accuracy_score(y_test,predictions))

Wir schneiden nun die Gewichtungen ab, da die Testdaten nur 10 Datenpunkte enthalten. Wir extrahieren die Merkmale aus den Testdaten und prognostizieren die Werte. Wir erhalten die Vorhersagen und vergleichen sie mit den tatsächlichen Werten und drucken die Genauigkeit unseres Modells.

Genauigkeit unseres SVM-Modells

Es gibt eine andere einfache Möglichkeit, den SVM-Algorithmus zu implementieren. Wir können die Scikit-Lernbibliothek verwenden und einfach die zugehörigen Funktionen aufrufen, um das SVM-Modell zu implementieren. Die Anzahl der Codezeilen reduziert deutlich zu wenige Zeilen.

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

clf = SVC(kernel='linear')
clf.fit(x_train,y_train)
y_pred = clf.predict(x_test)
print(accuracy_score(y_test,y_pred))

Fazit

Support Vector Machine ist ein eleganter und leistungsfähiger Algorithmus. Benutze es weise 🙂

Quelle

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.