Binäre Klassifizierung der Iris-Flower mit SVM

Einführung

In diesem Tutorial wird der Prozess des Einsatzes unterschiedlicher SVM-Kerne für die Klassifizierung behandelt. Wir werden den Iris-Datensatz verwenden, der Messungen von Blumen enthält. Dieser Datensatz hat drei Klassen, aber wir werden nur zwei von ihnen für die binäre Klassifizierung verwenden.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Daten laden

Wir beginnen mit dem Laden des Iris-Datensatzes und wählen nur die ersten beiden Merkmale für die Visualisierung.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets, svm

iris = datasets.load_iris()
X = iris.data
y = iris.target

X = X[y!= 0, :2]
y = y[y!= 0]

Daten vorbereiten

Als nächstes werden wir die Daten für das Training und die Tests vorbereiten. Wir werden die Daten in 90% für das Training und 10% für die Tests unterteilen.

n_sample = len(X)

np.random.seed(0)
order = np.random.permutation(n_sample)
X = X[order]
y = y[order].astype(float)

X_train = X[: int(0.9 * n_sample)]
y_train = y[: int(0.9 * n_sample)]
X_test = X[int(0.9 * n_sample) :]
y_test = y[int(0.9 * n_sample) :]

Modell mit verschiedenen Kernen trainieren

Wir werden nun das SVM-Modell mit drei verschiedenen Kernen trainieren: linear, rbf und poly. Für jedes Kernel werden wir das Modell an die Trainingsdaten anpassen, die Entscheidungsgrenze plotten und die Genauigkeit auf den Testdaten anzeigen.

## fit the model
for kernel in ("linear", "rbf", "poly"):
    clf = svm.SVC(kernel=kernel, gamma=10)
    clf.fit(X_train, y_train)

    plt.figure()
    plt.clf()
    plt.scatter(
        X[:, 0], X[:, 1], c=y, zorder=10, cmap=plt.cm.Paired, edgecolor="k", s=20
    )

    ## Circle out the test data
    plt.scatter(
        X_test[:, 0], X_test[:, 1], s=80, facecolors="none", zorder=10, edgecolor="k"
    )

    plt.axis("tight")
    x_min = X[:, 0].min()
    x_max = X[:, 0].max()
    y_min = X[:, 1].min()
    y_max = X[:, 1].max()

    XX, YY = np.mgrid[x_min:x_max:200j, y_min:y_max:200j]
    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])

    ## Put the result into a color plot
    Z = Z.reshape(XX.shape)
    plt.pcolormesh(XX, YY, Z > 0, cmap=plt.cm.Paired)
    plt.contour(
        XX,
        YY,
        Z,
        colors=["k", "k", "k"],
        linestyles=["--", "-", "--"],
        levels=[-0.5, 0, 0.5],
    )

    plt.title(kernel)
    plt.show()

    print(f"Genauigkeit mit {kernel} Kernel: {clf.score(X_test, y_test)}")

Ergebnisse interpretieren

Wir können sehen, dass der lineare Kernel eine lineare Entscheidungsgrenze erzeugt, während die rbf- und poly-Kerne komplexere Grenzen erzeugen. Die Genauigkeit auf den Testdaten ist mit dem rbf-Kernel am höchsten, gefolgt vom poly-Kernel und dann vom linearen Kernel.

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie verschiedene SVM-Kerne für die Klassifizierung verwendet werden. Wir haben ein SVM-Modell mit drei verschiedenen Kernen trainiert und die Entscheidungsgrenzen für jedes visualisiert. Wir haben auch die Genauigkeit auf den Testdaten für jedes Kernel berechnet. Wir haben festgestellt, dass der rbf-Kernel die besten Ergebnisse für den Iris-Datensatz erzielte.