Einführung
In diesem Lab verwenden wir den SGDClassifier von Scikit-Learn, um ein Mehrklassenklassifizierungsmodell auf dem berühmten Iris-Datensatz zu implementieren. Wir werden die Entscheidungsfläche des Modells auf dem Datensatz darstellen und die Hyperebenen visualisieren, die den drei One-versus-all (OVA)-Klassifizierern entsprechen.
VM-Tipps
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 der Einschränkungen von 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.
Daten laden und vorbereiten
Wir beginnen, indem wir die erforderlichen Bibliotheken importieren und den Iris-Datensatz laden. Anschließend mischen wir die Daten und standardisieren sie, um sie für das Training zu verwenden.
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.linear_model import SGDClassifier
## ladet den Iris-Datensatz
iris = datasets.load_iris()
## nimmt die ersten beiden Merkmale
X = iris.data[:, :2]
y = iris.target
Farben = "bry"
## mischt die Daten
idx = np.arange(X.shape[0])
np.random.seed(13)
np.random.shuffle(idx)
X = X[idx]
y = y[idx]
## standardisiert die Daten
Mittelwert = X.mean(axis=0)
Std = X.std(axis=0)
X = (X - Mittelwert) / Std
Modell trainieren
Wir werden nun das SGDClassifier-Modell mit Hilfe der fit()-Methode auf dem Iris-Datensatz trainieren. Diese Methode nimmt die Eingabedaten und die Zielwerte als Eingabe und trainiert das Modell auf den angegebenen Daten.
clf = SGDClassifier(alpha=0.001, max_iter=100).fit(X, y)
Entscheidungsfläche visualisieren
Wir werden nun die Entscheidungsfläche des trainierten Modells auf dem Iris-Datensatz darstellen. Wir werden die DecisionBoundaryDisplay-Klasse verwenden, um die Entscheidungsgrenze des Modells zu visualisieren.
from sklearn.inspection import DecisionBoundaryDisplay
ax = plt.gca()
DecisionBoundaryDisplay.from_estimator(
clf,
X,
cmap=plt.cm.Paired,
ax=ax,
response_method="predict",
xlabel=iris.feature_names[0],
ylabel=iris.feature_names[1],
)
plt.axis("tight")
Trainingspunkte plotten
Wir werden nun die Trainingspunkte auf der Entscheidungsfläche darstellen. Wir werden die scatter()-Methode verwenden, um die Trainingspunkte mit unterschiedlichen Farben für verschiedene Zielwerte zu plotten.
for i, color in zip(clf.classes_, colors):
idx = np.where(y == i)
plt.scatter(
X[idx, 0],
X[idx, 1],
c=color,
label=iris.target_names[i],
cmap=plt.cm.Paired,
edgecolor="black",
s=20,
)
plt.title("Decision surface of multi-class SGD")
plt.axis("tight")
Plotten von One-Against-All-Klassifizierern
Wir werden nun die drei One-Versus-All (OVA)-Klassifizierer auf der Entscheidungsfläche darstellen. Wir werden die coef*- und intercept*-Attribute des trainierten Modells verwenden, um die Hyperebenen zu plotten, die den OVA-Klassifizierern entsprechen.
xmin, xmax = plt.xlim()
ymin, ymax = plt.ylim()
coef = clf.coef_
intercept = clf.intercept_
def plot_hyperplane(c, color):
def line(x0):
return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]
plt.plot([xmin, xmax], [line(xmin), line(xmax)], ls="--", color=color)
for i, color in zip(clf.classes_, colors):
plot_hyperplane(i, color)
plt.legend()
plt.show()
Zusammenfassung
In diesem Lab haben wir gelernt, wie man Scikit-Learn's SGDClassifier verwendet, um ein Mehrklassen-Klassifizierungsmodell auf dem Iris-Datensatz zu implementieren. Wir haben die Entscheidungsfläche des trainierten Modells auf dem Datensatz visualisiert und die Hyperebenen dargestellt, die den drei One-Versus-All (OVA)-Klassifizierern entsprechen.