Introduction
Les réseaux neuronaux sont utilisés comme méthode de profond d’apprentissage, l’un des nombreux sous-champs de l’intelligence artificielle. Ils étaient la premières proposées autour de 70 ans il y a comme une tentative visant à simuler la façon dont le cerveau humain fonctionne, mais sous une forme beaucoup plus simplifiée. « Neurones » individuels sont reliés en couches, avec les pondérations attribuées à déterminer comment le neurone répond lorsque les signaux sont propagées à travers le réseau. Auparavant, les réseaux de neurones ont été limitées dans le nombre de neurones qu’ils ont été en mesure de simuler et donc la complexité de l’apprentissage, qu’ils pouvaient atteindre. Mais ces dernières années, en raison de progrès dans le développement de matériel, nous avons été en mesure de construire des réseaux très profondes et de les former sur des ensembles de données énormes à réaliser des percées dans l’intelligence de la machine.
Ces avancées ont permis aux machines d’égaler et dépasser les capacités de l’homme à exécuter certaines tâches. Une telle tâche est la reconnaissance de l’objet. Bien que les machines ont historiquement été incapables de faire correspondre la vision humaine, les progrès récents dans l’apprentissage profond ont permis de construire des réseaux de neurones qui peuvent reconnaître des objets, des visages, texte et même émotions.
Dans ce didacticiel, vous allez implémenter un petit paragraphe de reconnaissance d’objets — reconnaissance des chiffres. À l’aide de TensorFlow, une bibliothèque de Python open source développée par les laboratoires de cerveau de Google pour la recherche en formation profonde, vous prenez des images dessinées à la main des chiffres 0 à 9 et construire et former un réseau de neurones à reconnaître et à prévoir l’étiquette correcte pour obtenir le chiffre affichée.
Alors que vous n’aurez pas besoin d’expérience préalable en pratique apprentissage profond ou TensorFlow pour suivre ce didacticiel, nous supposerons que certaine familiarité avec la machine learning termes et concepts tels que la formation et des tests, des étiquettes, optimisation, et Evaluation. Vous pouvez en apprendre plus sur ces concepts dans Une Introduction au Machine Learning.
Conditions préalables
Pour compléter ce tutoriel, vous aurez besoin :
Un local environnement de développement Python 3, y compris pip, un outil permettant d’installer les paquets Python et venv, pour créer des environnements virtuels.
Étape 1 : Configuration du projet
Avant que vous pouvez développer le programme de reconnaissance, vous aurez besoin d’installer quelques dépendances et créer un espace de travail pour vos fichiers.
Nous utiliserons un environnement virtuel Python 3 pour gérer les dépendances de notre projet. Créez un répertoire pour votre projet et naviguez vers le nouveau répertoire :
mkdir tensorflow-demo
cd tensorflow-demo
Exécutez les commandes suivantes pour configurer l’environnement virtuel pour ce tutoriel :
python3 -m venv tensorflow-demo
source tensorflow-demo/bin/activate
Ensuite, installer les bibliothèques que vous allez utiliser dans ce tutoriel. Nous allons utiliser des versions spécifiques de ces bibliothèques en créant un fichier requirements.txt dans le répertoire de projet qui spécifie les exigences et la version que nous avons besoin. Créez le fichier requirements.txt :
touch requirements.txt
Ouvrez le fichier dans votre éditeur de texte et ajoutez les lignes suivantes pour spécifier les bibliothèques Image, NumPy et TensorFlow et leurs versions :
Requirements.txt
image==1.5.20
numpy==1.14.3
tensorflow==1.4.0
Enregistrez le fichier et quittez l’éditeur. Ensuite, installez ces bibliothèques avec la commande suivante :
pip install -r requirements.txt
Avec les dépendances installés, nous pouvons commencer à travailler sur notre projet.
Étape 2 — Importation du Dataset MNIST
Le groupe de données que nous utiliserons dans ce tutoriel est appelée le dataset MNIST , et c’est un classique dans la communauté d’apprentissage de la machine. Cet ensemble est composé d’images de chiffres manuscrits, 28 x 28 pixels de taille. Voici quelques exemples des chiffres inclus dans le dataset :
Examples of MNIST images
Nous allons créer un programme Python pour fonctionner avec cet ensemble de données. Nous allons utiliser un fichier pour l’ensemble de nos travaux dans ce tutoriel. Créez un nouveau fichier appelé main.py:
touch main.py
Maintenant, ouvrez ce fichier dans votre éditeur de texte, de choix et ajoutez cette ligne de code dans le fichier à importer la bibliothèque de TensorFlow :
main.py
import tensorflow as tf
Ajoutez les lignes de code suivantes à votre fichier pour importer le dataset MNIST et stocker les données d’image dans la variable mnist:
main.py
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(“MNIST_data/”, one_hot=True) # y labels are oh-encoded
Lors de la lecture des données, nous utilisons un-chaud-codage pour représenter les étiquettes (le réel chiffre tiré, par exemple « 3 ») des images. Un chaud-codage utilise un vecteur des valeurs binaires pour représenter des valeurs numériques ou catégoriques. Nos étiquettes sont pour les chiffres 0-9, le vecteur contient dix valeurs, une pour chaque chiffre possible. Une des valeurs suivantes est définie sur 1, pour représenter le chiffre à ce niveau du vecteur, et le reste sont réglés sur 0. Par exemple, le chiffre 3 est représenté en utilisant le vecteur [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]. Comme la valeur à l’index 3 est stockée en tant que 1, le vecteur représente donc le chiffre 3.
Pour représenter les images réelles elles-mêmes, les 28 x 28 pixels sont aplatis dans un vecteur 1D qui est 784 pixels de taille. Chacune des 784 pixels qui composent l’image est enregistrée comme une valeur comprise entre 0 et 255. Ceci détermine le niveau de gris du pixel, comme nos images sont présentées dans le noir et blanc uniquement. Si un pixel noir est représenté par 255 et un pixel blanc de 0, avec les différents tons de gris, quelque part entre les deux.
Nous pouvons utiliser la variable mnist pour savoir la taille de l’objet dataset, que nous avons juste importé. En regardant le num_examples pour chacune des trois sous-ensembles, nous pouvons déterminer que le dataset a été divisé en 55 000 images de la formation, 5000 pour la validation et 10 000 pour les tests. Ajoutez les lignes suivantes à votre fichier :
main.py
n_train = mnist.train.num_examples # 55,000
n_validation = mnist.validation.num_examples # 5000
n_test = mnist.test.num_examples # 10,000
Maintenant que nous avons nos données importées, il est temps de penser à des réseaux de neurones.
Étape 3 — Définition de l’Architecture de réseau de neurones
L’architecture de réseaux de neurones se réfère à des éléments tels que le nombre de couches dans le réseau, le nombre d’unités dans chaque couche, et comment les unités connectées entre les couches. Comme les réseaux neuronaux sont librement inspirés par le fonctionnement du cerveau humain, ici la terme unité est utilisée pour représenter ce que nous penserions biologiquement de comme un neurone. Comme neurones transmettant des signaux autour du cerveau, unités prennent certaines valeurs des unités précédentes comme entrée, effectuent un calcul et passent ensuite sur la nouvelle valeur comme sortie à d’autres unités. Ces unités sont superposées pour former le réseau, en commençant au moins avec une couche pour la saisie de valeurs et une couche de valeurs de sortie. Le terme couche cachée est utilisée pour tous les calques entre l’entrée et de sortie, c’est-à-dire les « cachés » dans le monde réel.
Architectures différentes peuvent donner des résultats radicalement différents, comme la performance peut être considérée en fonction de l’architecture, entre autres choses, telles que les paramètres, les données et la durée de la formation.
Ajoutez les lignes de code suivantes à votre fichier pour stocker le nombre d’unités par couche dans des variables globales. Cela nous permet de modifier l’architecture du réseau en un seul endroit et à la fin de ce tutoriel, vous pouvez tester par vous-même comment différents nombres de couches et unités affectera les résultats de notre modèle :
main.py
n_input = 784 # input layer (28×28 pixels)
n_hidden1 = 512 # 1st hidden layer
n_hidden2 = 256 # 2nd hidden layer
n_hidden3 = 128 # 3rd hidden layer
n_output = 10 # output layer (0-9 digits)
Le diagramme suivant montre une visualisation de l’architecture, que nous avons conçu, avec chaque couche entièrement connecté aux couches environnantes :
Diagram of a neural network
Le terme « profond neural network » se rapporte au nombre de calques masqués, avec « peu profonde » habituellement sens juste une couche cachée et « profondément », se référant à plusieurs calques masqués. Donné suffisamment de données formation, un réseau de neurones peu profond avec un nombre suffisant d’unités devrait théoriquement être capable de représenter toutes les fonctions qu’un réseau de neurones profonds peut. Mais il est souvent plus efficace par le calcul d’utiliser un réseau de neurones plus petite profondeur pour atteindre la même tâche qui exigerait un réseau peu profond avec les unités exponentiellement plus cachées. Réseaux neuronaux peu profonds heurtent aussi souvent surapprentissage, où le réseau essentiellement mémorise les données d’apprentissage qu’il a vu et qu’il n’est pas capable de généraliser la connaissance de nouvelles données. C’est pourquoi les réseaux de neurones profonds sont plus couramment utilisés : les couches multiples entre les données d’entrée brutes et l’étiquette de sortie permettent au réseau d’apprendre les fonctionnalités à différents niveaux d’abstraction, rendant le réseau lui-même mieux capable de généraliser.
Autres éléments du réseau neuronal qui doivent être définis ici sont les hyperparameters. À la différence des paramètres qui seront mis à jour au cours de la formation, ces valeurs sont définies au départ et restent constantes tout au long du processus. Dans votre fichier, définissez les variables et les valeurs suivantes :
main.py
learning_rate = 1e-4
n_iterations = 1000
batch_size = 128
dropout = 0.5
Le taux d’apprentissage représente omment beaucoup les paramètres ajustera à chaque étape du processus d’apprentissage. Ces ajustements sont un élément clé de la formation : après chaque passage à travers le réseau nous accorder les poids un peu pour essayer de réduire les pertes. Plus grands taux d’apprentissage peuvent converger plus rapidement, mais ont également le potentiel de remettre les gaz les valeurs optimales car ils sont mis à jour. Le nombre d’itérations on veut dire combien de fois nous passons par l’étape de formation et la taille de lot se réfère aux exemples combien la formation que nous utilisons à chaque étape. La variable de dropout représente un seuil auquel nous elimanate certaines unités au hasard. Nous allons utiliser dropout dans notre dernière couche cachée pour donner à chaque unité de 50 % de chances d’être éliminées à chaque étape de la formation. Cela permet d’éviter de surapprentissage.
Nous avons maintenant défini l’architecture de notre réseau de neurones et le hyperparameters qui influent sur le processus d’apprentissage. L’étape suivante consiste à construire le réseau sous forme de graphique TensorFlow.
Étape 4 — Construire le graphique de TensorFlow
Pour construire notre réseau, nous allons configurer le réseau sous forme de graphique informatique pour TensorFlow à exécuter. Le concept de base de TensorFlow est le tenseur, une structure de données semblable à une matrice ou une liste. initialisée, manipulé comme ils sont passés par le graphique et mis à jour via le processus d’apprentissage.
Nous allons commencer en définissant trois tenseurs comme espaces réservés, qui sont des tenseurs qui nous allons nourrir les valeurs en plus tard. Ajoutez ce qui suit à votre fichier :
main.py
X = tf.placeholder(“float”, [None, n_input])
Y = tf.placeholder(“float”, [None, n_output])
keep_prob = tf.placeholder(tf.float32)
Le seul paramètre qui doit être spécifié lors de sa déclaration est la taille des données dans que nous alimenterons. Pour X , nous utilisons une forme [None, 784], où None représente n’importe quel montant, tel que nous alimenterons dans un nombre indéfini de 784-pixel images. La forme du Y est [None, 10] comme nous l’utiliserons pour un nombre indéfini de sorties de l’étiquette, avec 10 classes possibles. Le tenseur de keep_prob est utilisé pour contrôler le taux d’abandon, et nous l’initialiser comme un espace réservé plutôt qu’une variable immuable parce que nous voulons utiliser le tenseur de même tant pour la formation (lorsque dropout est définie sur 0.5) et les tests (quand dropout a la valeur 1.0).
Les paramètres qui le réseau mettra à jour dans le processus de formation sont les valeurs de weight et les bias , alors pour ces derniers, il faut définir une valeur initiale plutôt que d’un espace réservé vide. Ces valeurs sont essentiellement le réseau d’où son apprentissage, qu’ils sont utilisés dans les fonctions d’activation des neurones, ce qui représente la force des liaisons entre unités.
Étant donné que les valeurs sont optimisés au cours de la formation, nous pourrions les définir à zéro pour l’instant. Mais la valeur initiale a fait un impact significatif sur la précision finale du modèle. Nous utiliserons les valeurs aléatoires d’une distribution normale tronquée pour les poids. Nous voulons être proche de zéro, donc ils peuvent ajuster dans une direction soit positive ou négative et légèrement différente, alors qu’elles génèrent des erreurs différentes. Cela fera en sorte que le modèle apprend quelque chose d’utile. Ajoutez ces lignes :
main.py
weights = {
‘w1’: tf.Variable(tf.truncated_normal([n_input, n_hidden1], stddev=0.1)),
‘w2’: tf.Variable(tf.truncated_normal([n_hidden1, n_hidden2], stddev=0.1)),
‘w3’: tf.Variable(tf.truncated_normal([n_hidden2, n_hidden3], stddev=0.1)),
‘out’: tf.Variable(tf.truncated_normal([n_hidden3, n_output], stddev=0.1)),
}
Pour le biais, nous utilisons une petite valeur constante pour s’assurer que les tenseurs activent dans les étapes initiales et donc contribuent à la propagation. Les poids et les préjugés tenseurs sont stockés dans les objets dictionary pour faciliter l’accès. Ajoutez ce code à votre fichier pour définir les biais :
main.py
biases = {
‘b1’: tf.Variable(tf.constant(0.1, shape=[n_hidden1])),
‘b2’: tf.Variable(tf.constant(0.1, shape=[n_hidden2])),
‘b3’: tf.Variable(tf.constant(0.1, shape=[n_hidden3])),
‘out’: tf.Variable(tf.constant(0.1, shape=[n_output]))
}
Ensuite, configurez les couches du réseau en définissant les opérations qui vont manipuler les tenseurs. Ajouter ces lignes à votre fichier :
main.py
layer_1 = tf.add(tf.matmul(X, weights[‘w1’]), biases[‘b1’])
layer_2 = tf.add(tf.matmul(layer_1, weights[‘w2’]), biases[‘b2’])
layer_3 = tf.add(tf.matmul(layer_2, weights[‘w3’]), biases[‘b3’])
layer_drop = tf.nn.dropout(layer_3, keep_prob)
output_layer = tf.matmul(layer_3, weights[‘out’]) + biases[‘out’]
Chaque couche cachée exécutera la multiplication de matrices sur les sorties de la couche précédente et le poids de la couche actuelle et ajouter le biais à ces valeurs. À la dernière couche masquée, nous appliquerons une opération d’abandon à l’aide de notre valeur de keep_prob de 0.5.
La dernière étape dans la construction du graphique est de définir la fonction de perte que nous voulons optimiser. Un choix populaire de fonction de perte dans les programmes de TensorFlow est entropie croisée, également connu sous le nom de log-perte, qui quantifie la différence entre deux distributions de probabilité (les prédictions et les étiquettes). Une classification parfaite donnerait lieu à une entropie croisée de 0, avec la perte complètement minimisée.
Il faut aussi choisir l’algorithme d’optimisation qui serviront à réduire au minimum la perte de fonction. Un processus appelé optimisation de descente de gradient est une méthode commune pour trouver le minimum (local) d’une fonction par la démarche itérative le long du gradient dans un sens négatif (ordre décroissant). Il y a plusieurs choix d’algorithmes d’optimisation de descente de gradient déjà implémentées dans TensorFlow et dans ce tutoriel nous allons utiliser l’ optimiseur de Adam. Cela s’étend à l’optimisation de la descente de gradient en utilisant l’élan pour accélérer le processus par le biais de calculer une moyenne pondérée exponentielle des gradients et s’en servir dans les ajustements. Ajoutez le code suivant à votre fichier :
main.py
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=output_layer))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
Nous avons maintenant défini le réseau et essayez-le construit avec TensorFlow. L’étape suivante consiste à nourrir les données dans les graphes à former, puis effectuez un test qu’il a réellement appris quelque chose.
Étape 5-Formation et tests
Le processus de formation consiste à alimenter le dataset de formation dans les graphes et optimisation de la fonction de perte. Chaque fois que le réseau parcourt un lot d’images plus de formation, il met à jour les paramètres pour réduire la perte afin de mieux prédire les chiffres affichés. Le processus de test implique l’exécution de notre dataset test dans les graphes formés, garder une trace du nombre d’images qui sont correctement prévu, afin que nous puissions calculer la précision.
Avant de commencer le processus de formation, nous définissons notre méthode d’évaluation de la précision donc nous pouvons imprimer sur mini-lots de données tandis que nous formons. Ces relevés imprimés permettra de vérifier que de la première itération du dernier, perte augmentations et diminutions exactitude ; ils permettront également de suivre ou non nous avons couru assez itérations pour arriver à un résultat uniforme et optimal :
main.py
correct_pred = tf.equal(tf.argmax(output_layer, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
Dans correct_pred, nous utilisons la fonction arg_max pour comparer Quelles images sont étant prédit correctement en regardant output_layer (prévisions) et Y (étiquettes), et nous utilisons la fonction equal à retourner C’est une liste de [booléens] (tps : / /www.digitalocean.com/community/tutorials/understanding-data-types-in-python-3#booleans). Nous pouvons alors monter cette liste à flotteurs et calculer la moyenne pour obtenir un score total de précision.
Nous sommes maintenant prêts à initialiser une session pour faire fonctionner le graphique. Dans cette session nous alimentera le réseau avec nos exemples de formation, et une fois formés, nous alimentons le même graphe enrichi de nouveaux exemples de test afin de déterminer l’exactitude du modèle. Ajoutez les lignes de code suivantes à votre fichier :
main.py
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
The essence of the training process in deep learning is to optimize the loss function. Here we are aiming to minimize the difference between the predicted labels of the images, and the true labels of the images. The process involves four steps which are repeated for a set number of iterations:
Propager les valeurs vers l’avant à travers le réseau
Calculer la perte
Propager les valeurs vers l’arrière à travers le réseau
Mettre à jour les paramètres
À chaque étape de la formation, les paramètres sont ajustées pour tenter de réduire la perte pour l’étape suivante. En cours de l’apprentissage, nous devrions voir une réduction des pertes, et finalement, nous pouvons arrêter formation et utiliser le réseau comme un modèle pour tester nos nouvelles données.
Ajoutez ce code au fichier :
main.py
# train on mini batches
for i in range(n_iterations):
batch_x, batch_y = mnist.train.next_batch(batch_size)
sess.run(train_step, feed_dict={X: batch_x, Y: batch_y, keep_prob:dropout})
# print loss and accuracy (per minibatch)
if i%100==0:
minibatch_loss, minibatch_accuracy = sess.run([cross_entropy, accuracy], feed_dict={X: batch_x, Y: batch_y, keep_prob:1.0})
print(“Iteration”, str(i), “\t| Loss =”, str(minibatch_loss), “\t| Accuracy =”, str(minibatch_accuracy))
Après 100 itérations de chaque étape de la formation dans laquelle on nourrit un mini lot d’images via le réseau, nous imprimons sur la perte et l’exactitude de ce lot. Notez que nous ne devrions pas être attend une perte décroissante et augmentant la précision ici, car les valeurs sont par lot, pas pour le modèle entier. Nous utilisons mini-lots d’images plutôt que leur alimentation par individuellement pour accélérer le processus de formation et permettent au réseau voir un certain nombre de différents exemples avant de mettre à jour les paramètres.
Une fois la formation terminée, nous pouvons exécuter la session sur les images de test. Cette fois, nous utilisons un taux d’abandon scolaire de keep_prob de 1.0 à s’assurer que toutes les unités sont actifs dans le processus de test.
Ajoutez ce code au fichier :
main.py
test_accuracy = sess.run(accuracy, feed_dict={X: mnist.test.images, Y: mnist.test.labels, keep_prob:1.0})
print(“\nAccuracy on test set:”, test_accuracy)
Il est maintenant temps de lancer notre programme et voir la précision avec laquelle notre réseau de neurones peut reconnaître ces chiffres manuscrites. Enregistrez le fichier main.py et exécutez la commande suivante dans le terminal pour exécuter le script :
python3 main.py
Vous verrez une sortie similaire à ce qui suit, les résultats individuels de perte et de précision peuvent varier :
Output
Iteration 0 | Loss = 3.67079 | Accuracy = 0.140625
Iteration 100 | Loss = 0.492122 | Accuracy = 0.84375
Iteration 200 | Loss = 0.421595 | Accuracy = 0.882812
Iteration 300 | Loss = 0.307726 | Accuracy = 0.921875
Iteration 400 | Loss = 0.392948 | Accuracy = 0.882812
Iteration 500 | Loss = 0.371461 | Accuracy = 0.90625
Iteration 600 | Loss = 0.378425 | Accuracy = 0.882812
Iteration 700 | Loss = 0.338605 | Accuracy = 0.914062
Iteration 800 | Loss = 0.379697 | Accuracy = 0.875
Iteration 900 | Loss = 0.444303 | Accuracy = 0.90625
Accuracy on test set: 0.9206
Pour essayer d’améliorer la précision de notre modèle, ou pour en savoir plus sur l’impact de l’écoute hyperparameters, nous pouvons tester l’effet de modifier le taux d’apprentissage, le seuil d’abandon, la taille de lot et le nombre d’itérations. Nous pouvons également changer le nombre d’unités dans nos couches cachées et modifier la quantité de couches cachées eux-mêmes, de voir comment les différentes architectures, augmenter ou diminuer la précision du modèle.
Afin de démontrer que le réseau est en fait reconnaître les images dessinées à la main, nous allons le tester sur une seule image de nos propres.
Tout d’abord soit télécharger cette image test échantillon ou ouvrir un éditeur graphique et créer votre propre image de 28 x 28 pixels d’un chiffre.
Ouvrez le fichier main.py dans votre éditeur et ajoutez les lignes de code suivantes en haut du fichier à importer deux bibliothèques nécessaires à la manipulation d’images.
main.py
import numpy as np
from PIL import Image
…
Puis à la fin du fichier, ajoutez la ligne suivante de code pour charger l’image de test du chiffre manuscrit :
main.py
img = np.invert(Image.open(“test_img.png”).convert(‘L’)).ravel()
La fonction open de la bibliothèque Image charge l’image de test sous forme de tableau 4D contenant les trois canaux de couleur de RVB et de la transparence Alpha. Ce n’est pas la même représentation que nous avons utilisé précédemment lors de la lecture dans le dataset à l’aide de TensorFlow, donc nous aurons besoin d’effectuer un travail supplémentaire pour faire correspondre le format.
Tout d’abord, nous utilisons la fonction convert avec le paramètre L afin de réduire la représentation de RVBA 4D à un canal de couleur en niveaux de gris. Nous stocker sous forme d’un tableau numpy et inverser à l’aide de np.invert, parce que la matrice actuelle représente noir 0 et blanc 255, alors que nous devons au contraire. Enfin, nous appelons ravel pour aplatir le tableau.
Maintenant que les données d’image sont structurées correctement, nous pouvons exécuter une session dans la même manière que précédemment, mais cette fois seulement se nourrir à la seule image pour tester. Ajoutez le code suivant à votre fichier pour tester l’image et imprimer l’étiquette de sortie.
main.py
prediction = sess.run(tf.argmax(output_layer,1), feed_dict={X: [img]})
print (“Prediction for test image:”, np.squeeze(prediction))
La fonction np.squeeze est appelée sur la prédiction pour renvoyer le nombre entier unique du tableau (c’est-à-dire de passer de [2] à 2). Le résultat montre que le réseau a reconnu cette image comme le chiffre 2.
Output
Prediction for test image: 2
Vous pouvez essayer de tester le réseau avec des images plus complexes – – chiffres qui ressemblent à des autres chiffres, par exemple, ou les chiffres qui ont été dessinés mal ou incorrectement – – pour voir à quel point il les tarifs.
Conclusion
Dans ce tutoriel, vous formés avec succès un réseau de neurones pour classer le dataset MNIST avec environ 92 % exactitude et testé sur une image de votre choix. Les recherches actuelles de state-of-the-art réalise environ 99 % sur ce même problème, en utilisant des architectures de réseaux plus complexes impliquant des couches convolutifs. Ces utilisation la structure 2D de l’image afin de mieux représenter le contenu, à la différence de notre méthode qui aplati tous les pixels dans un vecteur de 784 unités. Vous pouvez en savoir plus sur ce sujet sur le site Web TensorFlowet de voir la recherche des documents détaillant les résultats les plus précis sur le site Web MNIST.
Maintenant que vous savez comment construire et former un réseau de neurones, vous pouvez essayer et utiliser cette implémentation sur vos propres données ou tester sur d’autres ensembles de données populaires tels que les Numéros de maison Google StreetView, ou le dataset ICRA-10 pour une image plus générale reconnaissance.