Comparer les solveurs en ligne pour la classification de chiffres manuscrits

Introduction

Dans ce laboratoire, nous comparerons les performances de différents solveurs en ligne pour la classification de chiffres manuscrits. Nous utiliserons la bibliothèque scikit-learn pour charger et prétraiter les données, ainsi que pour entraîner et tester les classifieurs. Le but est d'observer comment différents solveurs se comportent avec différentes proportions de données d'entraînement.

Conseils sur la VM

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

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

Charger et prétraiter les données

Nous commencerons par charger l'ensemble de données de chiffres manuscrits à partir de scikit-learn et le diviser en ensembles d'entraînement et de test. Nous allons également mettre à l'échelle les données pour qu'elles aient une moyenne nulle et une variance unitaire.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

## Charger l'ensemble de données de chiffres
X, y = datasets.load_digits(return_X_y=True)

## Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Mettre à l'échelle les données pour qu'elles aient une moyenne nulle et une variance unitaire
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Définir les classifieurs

Nous allons définir plusieurs solveurs en ligne pour la classification, chacun avec différents hyperparamètres. Nous utiliserons les classifieurs suivants :

• SGDClassifier
• Perceptron
• PassiveAggressiveClassifier
• LogisticRegression

from sklearn.linear_model import SGDClassifier, Perceptron, PassiveAggressiveClassifier, LogisticRegression

classifiers = [
    ("SGD", SGDClassifier(max_iter=1000)),
    ("Perceptron", Perceptron(max_iter=1000)),
    ("Passive-Aggressive I", PassiveAggressiveClassifier(max_iter=1000, loss="hinge", C=1.0, tol=1e-4)),
    ("Passive-Aggressive II", PassiveAggressiveClassifier(max_iter=1000, loss="squared_hinge", C=1.0, tol=1e-4)),
    ("LogisticRegression", LogisticRegression(max_iter=1000))
]

Entraîner et évaluer les classifieurs

Nous allons entraîner chaque classifieur avec différentes proportions des données d'entraînement, allant de 1% à 95%, et évaluer leur performance sur l'ensemble de test. Nous allons répéter ce processus 10 fois pour obtenir une estimation plus précise du taux d'erreur sur le test.

heldout = [0.01, 0.05, 0.25, 0.5, 0.75, 0.9, 0.95]
rounds = 10
xx = 1.0 - np.array(heldout)

for name, clf in classifiers:
    print("Training %s" % name)
    yy = []
    for i in heldout:
        yy_ = []
        for r in range(rounds):
            X_train_, X_test_, y_train_, y_test_ = train_test_split(X_train, y_train, test_size=i, random_state=r)
            clf.fit(X_train_, y_train_)
            y_pred = clf.predict(X_test_)
            yy_.append(1 - np.mean(y_pred == y_test_))
        yy.append(np.mean(yy_))
    plt.plot(xx, yy, label=name)

plt.legend(loc="upper right")
plt.xlabel("Proportion of training data")
plt.ylabel("Test error rate")
plt.show()

Interpréter les résultats

On peut observer à partir du graphique que les classifieurs SGDClassifier, Perceptron et Passive-Aggressive ont des performances similaires, le classifieur Passive-Aggressive II ayant légèrement de meilleures performances. Le classifieur LogisticRegression a globalement les meilleures performances, avec le taux d'erreur sur le test le plus bas pour toutes les proportions de données d'entraînement.

Sommaire

Dans ce laboratoire, nous avons comparé les performances de différents solveurs en ligne pour la classification de chiffres manuscrits. Nous avons observé que le classifieur LogisticRegression a globalement les meilleures performances, et que les classifieurs SGDClassifier, Perceptron et Passive-Aggressive ont des performances similaires. Cette comparaison peut nous aider à choisir le classifieur le plus approprié pour notre problème et notre ensemble de données spécifiques.