Handschriftliche Ziffern mit MLP Classifier klassifizieren

Einführung

Dieses Tutorial zeigt Ihnen, wie Sie einen MLPClassifier mit Scikit-learn erstellen, um handschriftliche Ziffern aus dem MNIST-Datensatz zu klassifizieren. Wir werden auch die Gewichte der ersten Schicht des MLP visualisieren, um Einblicke in das Lernverhalten zu gewinnen.

Tipps für die virtuelle Maschine (VM)

Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und auf Jupyter Notebook für die Übung zuzugreifen.

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

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem umgehend für Sie lösen.

Skills Graph

Bibliotheken importieren

Wir beginnen, indem wir die für dieses Projekt erforderlichen Bibliotheken importieren.

import warnings
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.exceptions import ConvergenceWarning
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split

Daten laden

Als nächstes laden wir den MNIST-Datensatz mit der Funktion fetch_openml von Scikit-learn.

X, y = fetch_openml(
    "mnist_784", version=1, return_X_y=True, as_frame=False, parser="pandas"
)

Daten vorverarbeiten

Wir normalisieren die Daten, indem wir jeden Pixelwert durch 255,0 teilen, was der maximale Pixelwert ist.

X = X / 255.0

Daten aufteilen

Wir teilen den Datensatz in einen Trainingssatz und einen Testsatz auf, indem wir die Funktion train_test_split verwenden.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0, test_size=0.7)

MLPClassifier trainieren

Wir erstellen einen MLPClassifier (Multi-Layer Perceptron Classifier) mit einer einzigen versteckten Schicht, die 40 Neuronen enthält. Aufgrund von Ressourcenbeschränkungen trainieren wir das MLP nur für 8 Iterationen. Wir fangen auch die ConvergenceWarning (Konvergenzwarnung) ab, die geworfen wird, weil das Modell innerhalb der begrenzten Anzahl von Iterationen nicht konvergieren wird.

mlp = MLPClassifier(
    hidden_layer_sizes=(40,),
    max_iter=8,
    alpha=1e-4,
    solver="sgd",
    verbose=10,
    random_state=1,
    learning_rate_init=0.2,
)

with warnings.catch_warnings():
    warnings.filterwarnings("ignore", category=ConvergenceWarning, module="sklearn")
    mlp.fit(X_train, y_train)

Das Modell auswerten

Wir bewerten den MLPClassifier, indem wir seine Genauigkeit (Accuracy) auf den Trainings- und Testsets berechnen.

print("Training set score: %f" % mlp.score(X_train, y_train))
print("Test set score: %f" % mlp.score(X_test, y_test))

Gewichte visualisieren

Schließlich visualisieren wir die Gewichte der ersten Schicht des MLP. Wir erstellen ein 4x4-Raster von Teilplots und zeigen jedes Gewicht als 28x28 Pixel Graustufenbild an.

fig, axes = plt.subplots(4, 4)
vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()
for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):
    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=0.5 * vmin, vmax=0.5 * vmax)
    ax.set_xticks(())
    ax.set_yticks(())

plt.show()

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man mit Scikit-learn einen MLPClassifier (Multi-Layer Perceptron Classifier) erstellt, um handschriftliche Ziffern aus dem MNIST-Datensatz zu klassifizieren. Wir haben auch die Gewichte der ersten Schicht des MLP visualisiert, um Einblicke in das Lernverhalten zu gewinnen.