Vergleich von Online-Löser für die Klassifizierung handschriftlicher Ziffern

Einführung

In diesem Lab werden wir die Leistung verschiedener Online-Löser für die Klassifizierung von handschriftlichen Ziffern vergleichen. Wir werden die scikit-learn-Bibliothek verwenden, um die Daten zu laden und vorzuverarbeiten, sowie die Klassifizierer zu trainieren und zu testen. Ziel ist es, zu beobachten, wie sich verschiedene Löser unter verschiedenen Proportionen von Trainingsdaten verhalten.

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.

Laden und Vorverarbeiten der Daten

Wir beginnen mit dem Laden des handschriftlichen Ziffern-Datensatzes aus scikit-learn und teilen ihn in Trainings- und Testsets auf. Wir skalieren auch die Daten, um eine mittlere Null und eine Varianz von 1 zu erhalten.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

## Lade den Ziffern-Datensatz
X, y = datasets.load_digits(return_X_y=True)

## Teile die Daten in Trainings- und Testsets auf
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Skaliere die Daten, um eine mittlere Null und eine Varianz von 1 zu erhalten
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Definieren der Klassifizierer

Wir werden mehrere Online-Löser für die Klassifizierung definieren, jeder mit unterschiedlichen Hyperparametern. Wir werden die folgenden Klassifizierer verwenden:

• SGDClassifier
• Perceptron
• PassiveAggressiveClassifier
• LogisticRegression

from sklearn.linear_model import SGDClassifier, Perceptron, PassiveAggressiveClassifier, LogisticRegression

classifiers = [
    ("SGD", SGDClassifier(max_iter=1000)),
    ("Perceptron", Perceptron(max_iter=1000)),
    ("Passive-Aggressive I", PassiveAggressiveClassifier(max_iter=1000, loss="hinge", C=1.0, tol=1e-4)),
    ("Passive-Aggressive II", PassiveAggressiveClassifier(max_iter=1000, loss="squared_hinge", C=1.0, tol=1e-4)),
    ("LogisticRegression", LogisticRegression(max_iter=1000))
]

Trainieren und Auswerten der Klassifizierer

Wir werden jeden Klassifizierer auf unterschiedlichen Proportionen der Trainingsdaten trainieren, von 1% bis 95%, und deren Leistung auf dem Testset auswerten. Wir wiederholen diesen Prozess 10-mal, um eine genauerere Schätzung der Testfehlerrate zu erhalten.

heldout = [0.01, 0.05, 0.25, 0.5, 0.75, 0.9, 0.95]
rounds = 10
xx = 1.0 - np.array(heldout)

for name, clf in classifiers:
    print("Training %s" % name)
    yy = []
    for i in heldout:
        yy_ = []
        for r in range(rounds):
            X_train_, X_test_, y_train_, y_test_ = train_test_split(X_train, y_train, test_size=i, random_state=r)
            clf.fit(X_train_, y_train_)
            y_pred = clf.predict(X_test_)
            yy_.append(1 - np.mean(y_pred == y_test_))
        yy.append(np.mean(yy_))
    plt.plot(xx, yy, label=name)

plt.legend(loc="upper right")
plt.xlabel("Proportion of training data")
plt.ylabel("Test error rate")
plt.show()

Die Ergebnisse interpretieren

Wir können aus dem Diagramm beobachten, dass der SGDClassifier, das Perceptron und der Passive-Aggressive-Klassifizierer ähnlich gut performen, wobei der Passive-Aggressive-II-Klassifizierer leicht bessere Ergebnisse erzielt. Der LogisticRegression-Klassifizierer führt insgesamt am besten ab, mit der niedrigsten Testfehlerrate für alle Proportionen der Trainingsdaten.

Zusammenfassung

In diesem Lab haben wir die Leistung verschiedener Online-Löser für die Klassifizierung handschriftlicher Ziffern verglichen. Wir haben festgestellt, dass der LogisticRegression-Klassifizierer insgesamt am besten abläuft und dass der SGDClassifier, das Perceptron und der Passive-Aggressive-Klassifizierer ähnlich gut performen. Dieser Vergleich kann uns helfen, den am besten geeigneten Klassifizierer für unser spezielles Problem und unseren Datensatz auszuwählen.