Classifier des chiffres manuscrits avec le classifieur MLP

Introduction

Ce tutoriel vous montrera comment créer un MLPClassifier à l'aide de Scikit-learn pour classifier des chiffres manuscrits à partir de l'ensemble de données MNIST. Nous visualiserons également les poids de la première couche du MLP pour mieux comprendre le comportement d'apprentissage.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Nous commencerons par importer les bibliothèques nécessaires pour ce projet.

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

Chargement des données

Ensuite, nous chargerons l'ensemble de données MNIST à l'aide de la fonction fetch_openml de Scikit-learn.

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

Prétraitement des données

Nous allons normaliser les données en divisant chaque valeur de pixel par 255.0, qui est la valeur maximale de pixel.

X = X / 255.0

Diviser les données

Nous allons diviser l'ensemble de données en un ensemble d'entraînement et un ensemble de test à l'aide de la fonction train_test_split.

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

Entraîner le MLPClassifier

Nous allons créer un MLPClassifier avec une seule couche cachée contenant 40 neurones. Nous allons entraîner le MLP pour seulement 8 itérations en raison de contraintes de ressources. Nous capturerons également l'Avertissement de convergence qui sera levé car le modèle ne convergera pas dans le nombre limité d'itérations.

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)

Évaluer le modèle

Nous allons évaluer le MLPClassifier en calculant sa précision sur les ensembles d'entraînement et de test.

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

Visualiser les poids

Enfin, nous allons visualiser les poids de la première couche du MLP. Nous allons créer une grille de sous-graphiques 4x4 et afficher chaque poids sous forme d'une image en niveaux de gris de 28x28 pixels.

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()

Sommaire

Dans ce tutoriel, nous avons appris à créer un MLPClassifier à l'aide de Scikit-learn pour classifier des chiffres manuscrits à partir de l'ensemble de données MNIST. Nous avons également visualisé les poids de la première couche du MLP pour mieux comprendre le comportement d'apprentissage.