Reconnaissance de chiffres écrits à la main

Introduction

Ce laboratoire montre comment utiliser scikit-learn pour reconnaître des images de chiffres écrits à la main de 0 à 9.

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 au carnet Jupyter pour pratiquer.

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

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

Skills Graph

Importation des bibliothèques

Tout d'abord, nous devons importer les bibliothèques nécessaires. Nous utiliserons matplotlib pour la visualisation, datasets et metrics de sklearn pour charger et évaluer le jeu de données, et svm pour entraîner la machine à vecteurs de support.

import matplotlib.pyplot as plt
from sklearn import datasets, svm, metrics
from sklearn.model_selection import train_test_split

Charger et visualiser le jeu de données de chiffres

Nous allons charger le jeu de données de chiffres qui est composé d'images de 8x8 pixels de chiffres. Nous utiliserons la méthode imshow() de matplotlib pour visualiser les 4 premières images ainsi que leurs étiquettes correspondantes.

digits = datasets.load_digits()

_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 3))
for ax, image, label in zip(axes, digits.images, digits.target):
    ax.set_axis_off()
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
    ax.set_title("Training: %i" % label)

Préparer le jeu de données

Nous devons aplatir les images pour transformer chaque tableau 2D de valeurs d'échelle de gris de forme (8, 8) en forme (64,). Cela nous donnera un jeu de données de forme (n_samples, n_features), où n_samples est le nombre d'images et n_features est le nombre total de pixels dans chaque image.

n_samples = len(digits.images)
data = digits.images.reshape((n_samples, -1))

Diviser le jeu de données

Nous allons diviser le jeu de données en sous-ensembles d'entraînement et de test de 50% chacun en utilisant la méthode train_test_split() de sklearn.model_selection.

X_train, X_test, y_train, y_test = train_test_split(
    data, digits.target, test_size=0.5, shuffle=False
)

Entraîner la machine à vecteurs de support

Nous allons entraîner un classifieur à vecteurs de support sur les échantillons d'entraînement en utilisant la méthode svm.SVC() de sklearn.

clf = svm.SVC(gamma=0.001)
clf.fit(X_train, y_train)

Prédire et évaluer le modèle

Nous utiliserons le modèle entraîné pour prédire la valeur des chiffres pour les échantillons dans le sous-ensemble de test. Ensuite, nous évaluerons le modèle en utilisant les méthodes metrics.classification_report() et metrics.ConfusionMatrixDisplay.from_predictions() de sklearn.metrics.

predicted = clf.predict(X_test)

print(
    f"Classification report for classifier {clf}:\n"
    f"{metrics.classification_report(y_test, predicted)}\n"
)

disp = metrics.ConfusionMatrixDisplay.from_predictions(y_test, predicted)
disp.figure_.suptitle("Matrice de confusion")
print(f"Matrice de confusion:\n{disp.confusion_matrix}")

Rebâtir le rapport de classification à partir de la matrice de confusion

Si les résultats de l'évaluation d'un classifieur sont stockés sous forme d'une matrice de confusion et non en termes de y_true et y_pred, nous pouvons toujours construire un rapport de classification en utilisant la méthode metrics.classification_report() comme suit :

y_true = []
y_pred = []
cm = disp.confusion_matrix

for gt in range(len(cm)):
    for pred in range(len(cm)):
        y_true += [gt] * cm[gt][pred]
        y_pred += [pred] * cm[gt][pred]

print(
    "Rapport de classification reconstruit à partir de la matrice de confusion :\n"
    f"{metrics.classification_report(y_true, y_pred)}\n"
)

Sommaire

Dans ce laboratoire, nous avons appris à utiliser scikit-learn pour reconnaître des chiffres écrits à la main de 0 à 9 en utilisant une machine à vecteurs de support. Nous avons chargé et visualisé le jeu de données de chiffres, préparé et divisé le jeu de données, entraîné le modèle, prédit et évalué le modèle en utilisant un rapport de classification et une matrice de confusion.