Maîtriser la classification de chiffres écrits à la main avec la régression logistique

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser un algorithme de régression logistique pour classifier des chiffres écrits à la main à partir de l'ensemble de données MNIST. Nous utiliserons l'algorithme SAGA pour ajuster une régression logistique multinomiale avec une pénalité L1 sur un sous-ensemble de la tâche de classification des chiffres MNIST.

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 Carnet de notes 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 laboratoire. Nous utiliserons la bibliothèque scikit-learn pour récupérer l'ensemble de données, entraîner le modèle et évaluer les performances du modèle.

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

Charger l'ensemble de données MNIST

Nous allons charger l'ensemble de données MNIST en utilisant la fonction fetch_openml de scikit-learn. Nous sélectionnerons également un sous-ensemble des données en définissant le nombre d'échantillons d'entraînement sur 5000.

## Diminuer pour une convergence plus rapide
t0 = time.time()
train_samples = 5000

## Charger les données à partir de https://www.openml.org/d/554
X, y = fetch_openml(
    "mnist_784", version=1, return_X_y=True, as_frame=False, parser="pandas"
)

Prétraitement

Nous allons prétraiter les données en les mélangeant, en divisant l'ensemble de données en ensembles d'entraînement et de test, et en mettant à l'échelle les données à l'aide de StandardScaler.

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)

Entraîner le modèle

Nous allons entraîner le modèle en utilisant la régression logistique avec une pénalité L1 et l'algorithme SAGA. Nous allons définir la valeur de C sur 50,0 divisée par le nombre d'échantillons d'entraînement.

## Augmenter la tolérance pour une convergence plus rapide
clf = LogisticRegression(C=50.0 / train_samples, penalty="l1", solver="saga", tol=0.1)
clf.fit(X_train, y_train)

Évaluer le modèle

Nous allons évaluer les performances du modèle en calculant la rareté et le score de précision.

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)

Visualiser le modèle

Nous allons visualiser le modèle en traçant les vecteurs de classification pour chaque classe.

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("Classe %i" % i)
plt.suptitle("Vecteur de classification pour...")

run_time = time.time() - t0
print("Exécution de l'exemple en %.3f s" % run_time)
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à utiliser la régression logistique pour classifier des chiffres écrits à la main à partir de l'ensemble de données MNIST. Nous avons également appris à utiliser l'algorithme SAGA avec une pénalité L1 pour la régression logistique. Nous avons obtenu un score de précision supérieur à 0,8 avec un vecteur de poids sparse, rendant le modèle plus interprétable. Cependant, nous avons également noté que cette précision est considérablement inférieure à celle que peut atteindre un modèle linéaire pénalisé L2 ou un modèle de perceptron multicouche non linéaire sur cet ensemble de données.

Régression logistique multinomiale MNIST