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.
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.