MNIST Multinomiale Logistische Regression

Einführung

In diesem Lab werden wir lernen, wie wir einen Logistische-Regression-Algorithmus verwenden, um handschriftliche Ziffern aus dem MNIST-Datensatz zu klassifizieren. Wir werden den SAGA-Algorithmus verwenden, um eine multinomiale Logistische Regression mit L1-Strafe auf einem Teilsatz der MNIST-Ziffern-Klassifizierungaufgabe anzupassen.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

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.

Bibliotheken importieren

Wir beginnen, indem wir die erforderlichen Bibliotheken für dieses Lab importieren. Wir werden die scikit-learn-Bibliothek verwenden, um den Datensatz abzurufen, das Modell zu trainieren und die Leistung des Modells zu bewerten.

import time
import matplotlib.pyplot as plt
import numpy as np

from sklearn.datasets import fetch_openml
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.utils import check_random_state

MNIST-Datensatz laden

Wir werden den MNIST-Datensatz mit der Funktion fetch_openml aus scikit-learn laden. Wir werden auch einen Teilsatz der Daten auswählen, indem wir die Anzahl der train_samples auf 5000 setzen.

## Turn down for faster convergence
t0 = time.time()
train_samples = 5000

## Load data from https://www.openml.org/d/554
X, y = fetch_openml(
    "mnist_784", version=1, return_X_y=True, as_frame=False, parser="pandas"
)

Vorverarbeitung

Wir werden die Daten vorverarbeiten, indem wir die Daten mischen, den Datensatz in Trainings- und Testsets unterteilen und die Daten mit StandardScaler skalieren.

random_state = check_random_state(0)
permutation = random_state.permutation(X.shape[0])
X = X[permutation]
y = y[permutation]
X = X.reshape((X.shape[0], -1))

X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=train_samples, test_size=10000
)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Modell trainieren

Wir werden das Modell mit Logistischer Regression mit L1-Strafe und SAGA-Algorithmus trainieren. Wir werden den Wert von C auf 50,0 geteilt durch die Anzahl der Trainingsbeispiele setzen.

## Turn up tolerance for faster convergence
clf = LogisticRegression(C=50.0 / train_samples, penalty="l1", solver="saga", tol=0.1)
clf.fit(X_train, y_train)

Modell bewerten

Wir werden die Leistung des Modells bewerten, indem wir die Sparsität und die Genauigkeit berechnen.

sparsity = np.mean(clf.coef_ == 0) * 100
score = clf.score(X_test, y_test)

print("Sparsity with L1 penalty: %.2f%%" % sparsity)
print("Test score with L1 penalty: %.4f" % score)

Modell visualisieren

Wir werden das Modell visualisieren, indem wir die Klassifikationsvektoren für jede Klasse darstellen.

coef = clf.coef_.copy()
plt.figure(figsize=(10, 5))
scale = np.abs(coef).max()
for i in range(10):
    l1_plot = plt.subplot(2, 5, i + 1)
    l1_plot.imshow(
        coef[i].reshape(28, 28),
        interpolation="nearest",
        cmap=plt.cm.RdBu,
        vmin=-scale,
        vmax=scale,
    )
    l1_plot.set_xticks(())
    l1_plot.set_yticks(())
    l1_plot.set_xlabel("Klasse %i" % i)
plt.suptitle("Klassifikationsvektor für...")

laufzeit = time.time() - t0
print("Beispiellauf in %.3f s" % laufzeit)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Logistische Regression verwendet, um handschriftliche Ziffern aus dem MNIST-Datensatz zu klassifizieren. Wir haben auch gelernt, wie man den SAGA-Algorithmus mit L1-Strafe für die Logistische Regression verwendet. Wir haben einen Genauigkeitsscore von über 0,8 mit einem sparsen Gewichtsvektor erreicht, was das Modell interpretierbarer macht. Allerdings haben wir auch festgestellt, dass diese Genauigkeit deutlich unter der liegt, die von einem L2-straffierten linearen Modell oder einem nicht-linearen Mehrschicht-Perzeptronmodell auf diesem Datensatz erreicht werden kann.