Reconnaissance des chiffres en 30 minutes –

Au cours de la dernière décennie, l'utilisation de réseaux de neurones artificiels (RNA) a considérablement augmenté. Les gens ont utilisé les ANN dans diagnostics médicaux pour prédire les prix en Bitcoin et créer de fausses vidéos Obama ! Avec tout l’enthousiasme suscité par l’apprentissage en profondeur et les réseaux de neurones artificiels, n’avez-vous jamais voulu en créer un pour vous-même? Dans ce didacticiel, nous allons créer un modèle pour reconnaître les chiffres manuscrits.

Nous utilisons la bibliothèque keras pour former le modèle dans ce didacticiel. Keras est une bibliothèque de haut niveau en Python qui recouvre TensorFlow CNTK et Theano . Par défaut, Keras utilise un backend TensorFlow par défaut, et nous l'utilisons également pour former notre modèle.

Réseaux de neurones artificiels

Un réseau de neurones artificiel est un modèle mathématique qui convertit un ensemble d'entrées en un ensemble de sorties à travers un certain nombre de couches cachées. Un ANN fonctionne avec des couches cachées, chacune étant une forme transitoire associée à une probabilité. Dans un réseau de neurones typique, chaque nœud d'une couche prend en entrée tous les nœuds de la couche précédente. Un modèle peut avoir un ou plusieurs calques masqués.

Les ANN reçoivent un calque d'entrée pour le transformer en calques masqués. Un ANN est initialisé en attribuant des poids et des biais aléatoires à chaque nœud des couches masquées. Lorsque les données d'apprentissage entrent dans le modèle, il modifie ces poids et biais en utilisant les erreurs générées à chaque étape. Par conséquent, notre modèle "apprend" le modèle en parcourant les données de formation.

Réseaux de neurones condensés

Dans ce didacticiel, nous allons identifier des chiffres, qui constituent une version simple de la classification des images. Une image est essentiellement une collection de points ou de pixels. Un pixel peut être identifié par ses couleurs composantes (RVB). Par conséquent, les données d'entrée d'une image sont essentiellement un tableau 2D de pixels, chacun représentant une couleur.

Si nous devions former un réseau neuronal normal basé sur des données d'image, nous devrions fournir une longue liste d'entrées, dont chacun serait connecté à la couche cachée suivante. Cela rend le processus difficile à mettre à l'échelle.

Dans un réseau de neurones convolués (CNN), les couches sont disposées dans une matrice 3D (coordonnée sur l'axe des X, coordonnée sur l'axe des Y et couleur). En conséquence, un nœud de la couche cachée ne serait connecté qu'à une petite région située au voisinage de la couche d'entrée correspondante, ce qui rendrait le processus beaucoup plus efficace qu'un réseau de neurones traditionnel. Les CNN sont donc très populaires lorsqu'il s'agit de travailler avec des images et des vidéos.

Les différents types de couches d'un CNN sont les suivants:

• couches convolutives : elles passent en entrée à travers certains filtres, qui identifient les caractéristiques dans l'image
• des couches de regroupement : elles combinent des caractéristiques convolutives, contribuant à la réduction des caractéristiques
• des couches aplaties : elles convertissent une couche N-dimensionnelle en une couche de classification 1D
• : la couche finale, qui indique le résultat final.

Explorons maintenant les données.

Explorez le jeu de données MNIST

Comme vous vous en êtes peut-être rendu compte, nous avons besoin de données étiquetées pour former tous les modèles. Dans ce didacticiel, nous allons utiliser le jeu de données MNIST de chiffres manuscrits. Ce jeu de données fait partie du paquet Keras. Il contient un ensemble de formation de 60000 exemples et un ensemble de test de 10 000 exemples. Nous allons former les données sur le kit d’entraînement et valider les résultats en fonction des données de test. En outre, nous allons créer notre propre image pour vérifier si le modèle peut la prédire correctement.

Commençons par importer le jeu de données MNIST de Keras. La méthode .load_data () renvoie les ensembles de données d'apprentissage et de test:

 à partir de keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data ()

Essayons de visualiser les chiffres du jeu de données. Si vous utilisez des blocs-notes Jupyter, utilisez la fonction magique suivante pour afficher en ligne Graphes Matplotlib :

% matplotlib inline

Importez ensuite le module pyplot de matplotlib et utilisez la méthode .imshow () pour afficher l'image:

 import matplotlib.pyplot as plt

image_index = 35
print (y_train [image_index])
plt.imshow (x_train [image_index]cmap = 'Grays')
plt.show ()

L'étiquette de l'image est imprimée puis l'image est affichée.

Vérifions la taille des ensembles de données de formation et de test:

 print ( x_train.shape)
print (x_test.shape)

Notez que chaque image a les dimensions de 28 x 28:

 (60000, 28, 28)
(10000, 28, 28)

Nous voudrions peut-être aussi explorer la variable dépendante stockée dans y_train . Imprimons toutes les étiquettes jusqu’au chiffre que nous avons visualisé ci-dessus:

 print (y_train [:image_index + 1])

[5 0 4 1 9 2 1 3 1 4 3 5 3 6 1 7 2 8 6 9 4 0 9 1 1 2 4 3 2 7 3 8 6 9 0 5]

Nettoyage des données

Maintenant que nous avons vu la structure des données, travaillons plus avant avant de créer le modèle.

Pour utiliser l'API Keras, il est nécessaire de remodeler chaque image au format suivant. (M x N x 1). Nous allons utiliser la méthode .reshape () pour effectuer cette action. Enfin, normalisez les données d’image en divisant chaque valeur de pixel par 255 (la valeur RVB pouvant aller de 0 à 255):

 # enregistrer les dimensions de l’image en entrée
img_rows, img_cols = 28, 28

x_train = x_train.reshape (x_train.shape [0]img_rows, img_cols, 1)
x_test = x_test.reshape (x_test.shape [0]img_rows, img_cols, 1)

x_train / = 255
x_test / = 255

Ensuite, nous devons convertir la variable dépendante sous forme d'entiers en une matrice de classe binaire. Ceci peut être réalisé par la fonction to_categorical () :

 de keras.utils import to_categorical
num_classes = 10

y_train = to_categorical (y_train, num_classes)
y_test = to_categorical (y_test, num_classes)

Nous sommes maintenant prêts à créer le modèle et à l’entraîner!

Conception d’un modèle

Le processus de conception du modèle est le facteur le plus complexe, qui a un impact direct sur les performances du modèle. Pour ce tutoriel, nous allons utiliser ce dessin de la documentation de Keras .

Pour créer le modèle, nous commençons par initialiser un modèle séquentiel. Il crée un objet de modèle vide. La première étape consiste à ajouter une couche de convolution qui prend l’image d’entrée:

 from keras.models import Sequential
de keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D

modèle = séquentiel ()
model.add (Conv2D (32, taille de noyau = (3, 3),
     activation = 'relu',
     input_shape = (img_rows, img_cols, 1)))

Une activation «relu» signifie «Unités linéaires rectifiées», qui prend le maximum d'une valeur ou zéro. Ensuite, nous ajoutons une autre couche convolutive, suivie d'une couche de regroupement:

 model.add (Conv2D (64, (3, 3), activation = 'relu'))
model.add (MaxPooling2D (pool_size = (2, 2)))

Ensuite, nous ajoutons un calque “abandonné”. Alors que les réseaux de neurones sont formés sur d’énormes jeux de données, un problème de surajustement peut survenir. Pour éviter ce problème, nous abandonnons au hasard les unités et leurs connexions au cours du processus de formation. Dans ce cas, nous abandonnerons 25% des unités:

 model.add (Dropout (0.25))

Ensuite, nous ajoutons un calque aplatissant pour convertir le calque masqué précédent en un tableau 1D:

 model.add (Flatten ())

Une fois les données mises à plat dans une matrice 1D, nous pouvons ajouter une couche cachée dense, ce qui est normal pour un réseau de neurones traditionnel. Ensuite, ajoutez une autre couche de suppression avant d'ajouter une couche dense finale qui classe les données:

 model.add (Dense (128, activation = 'relu'))
model.add (abandon (0.5))
model.add (Dense (num_classes, activation = 'softmax'))

L'activation «softmax» est utilisée lorsque nous souhaitons classer les données dans un certain nombre de classes prédéfinies.

Compiler et former un modèle

Dans le processus de conception du modèle, nous avons créé un modèle sans fonction objectif. Nous devons compiler le modèle et spécifier une fonction de perte, une fonction d'optimisation et une métrique pour évaluer les performances du modèle.

Nous devons utiliser une fonction de perte sparse_categorical_crossentropy dans le cas où nous avons une variable dépendante de l'entier. Pour obtenir une variable dépendante basée sur un vecteur, telle qu'un tableau de dix tailles, à la sortie de chaque cas de test, utilisez categorical_crossentropy . Dans cet exemple, nous allons utiliser l'optimiseur adam . La métrique est la base d’évaluation de la performance de notre modèle, bien que nous ne puissions en juger et ne soit pas utilisée à l’étape de formation:

 model.compile (loss = 'sparse_categorical_crossentropy',
      optimiseur = 'adam',
      métriques = ['accuracy'])

Nous sommes maintenant prêts à former le modèle à l’aide de la méthode .fit () . Nous devons spécifier une époque et une taille de lot lors de la formation du modèle. Une époque est une passe avant et une passe arrière de tous les exemples d’entraînement. La taille d'un lot correspond au nombre d'exemples d'apprentissage dans une passe en aval ou en aval.

Enfin, sauvegardez le modèle une fois la formation terminée pour pouvoir utiliser ses résultats ultérieurement:

 batch_size = 128
époque = 10

model.fit (x_train, y_train,
          batch_size = batch_size,
          époques = époques,
          verbeux = 1,
          validation_data = (x_test, y_test))
score = model.evaluate (x_test, y_test, verbose = 0)
print ('Test loss:', score [0])
print ('Test precision:', score [1])
model.save ("test_model.h5")

Lorsque nous exécutons le code ci-dessus, la sortie suivante s'affiche pendant l'exécution du modèle. Cela prend environ dix minutes dans un Macbook Air 2018 équipé de cahiers Jupyter:

 Entraînez-vous sur 60000 échantillons, validez sur 10000 échantillons
Epoque 1/10
60000/60000 [==============================] - 144s 2ms / échelon - perte: 0.2827 - acc: 0.9131 - val_loss: 0.0612 - val_acc: 0.9809
Epoque 2/10
60000/60000 [==============================] - 206s 3ms / échelon - perte: 0.0922 - acc: 0.9720 - valeur de perte: 0.0427 - valeur de valeur: 0.9857
...
Epoque 9/10
60000/60000 [==============================] - 142s 2ms / étape - perte: 0.0329 - acc: 0.9895 - valeur de perte: 0.0276 - valeur de valeur: 0.9919
Epoque 10/10
60000/60000 [==============================] - 141s 2ms / étape - perte: 0.0301 - acc: 0.9901 - valeur de perte: 0.0261 - valeur de valeur: 0.9919
Perte d'essai: 0.026140549496188395
Exactitude du test: 0.9919

À la fin de l'époque finale, la précision de l'ensemble de données de test est de 99,19%. Il est difficile de dire à quel point la précision doit être élevée. Pour un test, une précision supérieure à 99% est très bonne. Cependant, il reste beaucoup à améliorer en peaufinant les paramètres du modèle. Voici une soumission d'un concours de reconnaissance de chiffres sur Kaggle atteignant une précision de 99,7%

Test avec chiffres manuscrits

Maintenant que le modèle est prêt, utilisons une image personnalisée pour évaluer les performances de l'outil. modèle. J'ai hébergé un 28 × 28 chiffres personnalisé sur Imgur . Commençons par lire l’image à l’aide de la bibliothèque imageio et explorons l’aspect des données d’entrée:

 import imageio
importer numpy en tant que np
de pyplot d'importation matplotlib en tant que plt

im = imageio.imread ("https://i.imgur.com/a3Rql9C.png")

Ensuite, convertissez les valeurs RVB en niveaux de gris . Nous pouvons ensuite utiliser la méthode .imshow () décrite ci-dessus pour afficher l'image:

 grey = np.dot (im [...,:3][0.299, 0.587, 0.114])
plt.imshow (grey, cmap = plt.get_cmap ('grey'))
plt.show ()

Ensuite, remodelez l'image et normalisez les valeurs pour la rendre prête à l'emploi. être utilisé dans le modèle que nous venons de créer:

 # remodeler l'image
gray = gray.reshape (1, img_rows, img_cols, 1)

# normaliser l'image
gris / = 255

Chargez le modèle à partir du fichier enregistré à l'aide de la fonction load_model () et prédisez le chiffre à l'aide de la méthode .predict () :

 # charger le modèle.
from keras.models import load_model
model = load_model ("test_model.h5")

# prédire le chiffre
prédiction = model.predict (grey)
print (prediction.argmax ())

Le modèle prédit correctement le chiffre affiché dans l'image:

 5

Final Thoughts

Dans ce didacticiel, nous avons créé un réseau de neurones avec Keras à l'aide du backend TensorFlow pour classifier les chiffres manuscrits. Bien que nous ayons atteint une précision de 99%, il existe encore des possibilités d'amélioration. Nous avons également appris à classer les chiffres manuscrits personnalisés, qui ne faisaient pas partie du jeu de données de test. Ce tutoriel vient toutefois de rayer le champ des réseaux de neurones artificiels. Il existe de nombreuses utilisations des réseaux de neurones qui ne sont limitées que par notre imagination.

Pouvez-vous améliorer la précision du modèle? Quelles autres techniques pouvez-vous penser à utiliser? Faites-moi savoir sur Twitter .

Shaumik est un optimiste, mais un parapluie. Roorkee, étudiant de premier cycle à l'Institut indien de technologie, et cofondateur de The Blog Bowl, il adore écrire, alors qu'il n'est pas occupé à garder le drapeau bleu sous les drapeaux.