[PYTHON] Tutoriel TensorFlow - Réseau neuronal à convolution (traduction)

Tutoriel TensorFlow (réseaux de neurones convolutifs) http://www.tensorflow.org/tutorials/deep_cnn/index.html#convolutional-neural-networks C'est une traduction de. Nous sommes impatients de signaler toute erreur de traduction.

Remarque: ce didacticiel est destiné aux utilisateurs avancés de TensorFlow et suppose une expertise et une expérience en apprentissage automatique.

Aperçu

La classification CIFAR-10 est un problème d'analyse comparative courant dans l'apprentissage automatique. Le problème est de classer les images RVB 32x32 pixels en 10 catégories: avions, voitures, oiseaux, chats, cerfs, chiens, grenouilles, chevaux, bateaux et camions.

Pour plus d'informations, voir page CIFAR-10 et [Rapport technique] d'Alex Krizhevsky (http://www.cs.toronto.edu/) Voir% 7Ekriz / learning-features-2009-TR.pdf).

Cible

Le but de ce didacticiel est de créer un réseau neuronal convolutif (CNN) relativement petit pour la reconnaissance d'images. Dans les étapes de ce tutoriel:

1. Mettez en évidence les configurations standard pour l'architecture, la formation et l'évaluation du réseau.
2. Fournit des modèles pour créer des modèles plus grands et plus sophistiqués.

J'ai choisi CIFAR-10 car il est suffisamment complexe pour pratiquer une grande partie de la capacité à évoluer vers un grand modèle de TensorFlow. En même temps, le modèle est suffisamment petit pour s'entraîner rapidement. Par conséquent, il est idéal pour essayer de nouvelles idées et expérimenter de nouvelles technologies.

Faits saillants du didacticiel

Ce didacticiel CIFAR-10 montre quelques structures importantes pour la conception de modèles plus grands et plus sophistiqués dans TensorFlow:

• Fold, [ReLU Activation](https://www.tensorflow.org/api_docs/python/nn.html# relu), Maximum Pooling et Local Response Normalization /Nn.html#local_response_normalization), une composante mathématique centrale
• Visualisation de l'activité du réseau pendant la formation, y compris les images d'entrée, la perte, l'activation et la distribution de gradient (https://www.tensorflow.org/how_tos/summaries_and_tensorboard/index.html)
• Calculez la moyenne mobile des paramètres entraînés et utilisez ces valeurs moyennes pendant l'évaluation pour améliorer les performances de prédiction. Routine à utiliser
• Implémentation de Learning Rate Schedule qui diminue systématiquement avec le temps
• Pré-extraction de la file d'attente des données d'entrée (https://www.tensorflow.org/api_docs/python/io_ops.html#shuffle_batch) pour séparer le modèle de la latence du disque et du prétraitement coûteux des images

Il fournit également une version multi-GPU du modèle, qui décrit:

• Paramètres du modèle pour la formation avec plusieurs cartes GPU en même temps.
• Partage et mise à jour des variables sur plusieurs GPU.

Nous espérons que ce tutoriel sera le point de départ pour créer un CNN plus grand pour vos tâches d'image dans TensorFlow.

Architecture modèle

Le modèle de ce didacticiel CIFAR-10 est une architecture multicouche avec des convolutions et des non-linéarités alternées. Ces couches sont suivies d'une couche entièrement connectée qui mène au classificateur Softmax. Le modèle suit l'architecture décrite par Alex Krizhevsky, à l'exception de quelques différences dans les couches supérieures.

Ce modèle a été formé sur le GPU pour atteindre des performances maximales avec une précision d'environ 86% en quelques heures. Pour plus d'informations, voir [ci-dessous](# évaluation du modèle) et code. Il se compose de 1 068 298 paramètres d'apprentissage et nécessite environ 19,5 millions de multiplications et d'additions pour calculer une seule inférence d'image.

Structure du code

Le code de ce didacticiel se trouve sur tensorflow / models / image / cifar10 /.

Modèle CIFAR-10

Le réseau CIFAR-10 est principalement contenu dans cifar10.py. Le graphique d'entraînement complet contient environ 765 opérations. Vous pouvez voir que le code peut être rendu presque réutilisable en construisant le graphique avec les modules suivants:

1. Entrée de modèle (#Model Input): inputs () et distorted_inputs () ajoutent des opérations pour lire et prétraiter les images CIFAR à des fins d'évaluation et de formation.
2. Modèle de prédiction (#Model Prediction): inference () ajoute une opération pour effectuer une estimation, ou classer, sur l'image spécifiée.
3. Model Training (#Model Training): loss () et train () ajoutent des opérations pour calculer les pertes, les gradients, les mises à jour de variables et les résumés de visualisation.

Modèle d'entrée

La partie entrée du modèle est construite par les fonctions inputs () et distorted_inputs () qui lisent les images du fichier de données binaires CIFAR-10. Étant donné que ces fichiers contiennent des enregistrements de longueur d'octet fixe, j'utilise tf.FixedLengthRecordReader. Pour plus d'informations sur la classe Reader, consultez Lecture de données (https://www.tensorflow.org/how_tos/reading_data/index.html#reading-from-files).

L'image est traitée comme suit:

• L'image est recadrée à 24x24 pixels, centrée pour l'évaluation et aléatoire pour la formation.
• L'image est presque blanchie de sorte que le modèle ne dépend pas de la plage dynamique.

Lors de la formation, nous appliquons une série de distorsions aléatoires pour augmenter artificiellement l'ensemble de données:

• Retournez l'image au hasard à gauche et à droite (https://www.tensorflow.org/api_docs/python/image.html#random_flip_left_right)
• Déforme aléatoirement la [luminosité] de l'image (https://www.tensorflow.org/api_docs/python/image.html#random_brightness)
• Déforme aléatoirement le [Contraste] de l'image (https://www.tensorflow.org/api_docs/python/image.html#tf_image_random_contrast)

Voir la page Images (https://www.tensorflow.org/api_docs/python/image.html) pour une liste des distorsions disponibles. Attachez image_summary à l'image afin de pouvoir les visualiser dans TensorBoard. Nous vous recommandons de vous assurer que les données d'entrée sont créées correctement.

Le processus de lecture d'une image à partir d'un disque et de sa déformation peut prendre un certain temps. Pour éviter que cette opération ne ralentisse l'entraînement, ceci dans 16 threads séparés qui remplissent continuellement la file d'attente de TensorFlow (https://www.tensorflow.org/api_docs/python/io_ops.html#shuffle_batch) Éxécuter.

Prédiction de modèle

Le prédicteur du modèle est constitué de la fonction inference (), qui ajoute une opération pour calculer le logit de la prédiction. Cette partie du modèle est construite comme suit:

Le graphique de l'opération d'inférence générée par TensorBoard est le suivant.

Exercice: La sortie de l'inférence est un logit non normalisé. Veuillez modifier l'architecture du réseau et utiliser tf.softmax () pour renvoyer la prédiction normalisée. ..

Les fonctions inputs () et inference () fournissent tous les composants nécessaires pour évaluer un modèle. Maintenant, concentrons-nous sur les opérations de construction qui forment le modèle.

Exercice: L'architecture du modèle d'inférence () est légèrement différente du modèle CIFAR-10 défini dans cuda-convnet. Plus précisément, la couche supérieure du modèle original d'Alex est constituée de jointures partielles et non de jointures complètes. Essayez de modifier l'architecture pour que la couche supérieure soit partiellement jointe.

Formation modèle

La manière habituelle de former un réseau pour la classification de classe N est la régression logistique multitermique (https://en.wikipedia.org/wiki/Multinomial_logistic_regression), également appelée régression Softmax. La régression Softmax applique une non-linéarité Softmax à la sortie du réseau, avec des prédictions et des étiquettes normalisées 1-Encodage à chaud, [Cross Entropy](https://www.tensorflow.org/api_docs/python/nn. html # softmax_cross_entropy_with_logits) est calculé. Il applique également la perte de poids normale (https://www.tensorflow.org/api_docs/python/nn.html#l2_loss) à toutes les variables entraînées pour la régularisation. La fonction objective du modèle renvoyée par la fonction loss () est la somme de la perte d'entropie croisée et de tous ces termes de décroissance de poids.

Visualisez cela dans TensorBoard à l'aide de scalar_summary:

Algorithme standard de Descente de pente ([Training] pour d'autres méthodes (https://www.tensorflow.org/api_docs/python/train. (Voir html)) pour entraîner le modèle avec un taux d'apprentissage qui décroît de façon exponentielle au fil du temps. Faire.

La fonction train () calcule le gradient et met à jour les variables d'apprentissage (voir GradientDescentOptimizer pour plus d'informations). Ajoutez les opérations requises pour minimiser la fonction objectif. Cette fonction renvoie une opération qui effectue tous les calculs nécessaires pour entraîner et mettre à jour le modèle pour un lot d'images.

Lancement de modèle et formation

La construction du modèle est maintenant terminée. Lançons le modèle et effectuons l'opération d'entraînement avec le script cifar10_train.py.

python cifar10_train.py

Remarque: l'ensemble de données CIFAR-10 est automatiquement téléchargé la première fois que vous exécutez une cible du didacticiel CIFAR-10. L'ensemble de données fait environ 160 Mo, alors buvez du café la première fois que vous l'exécutez.

Vous devriez voir quelque chose comme ceci:

Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
2015-11-04 11:45:45.927302: step 0, loss = 4.68 (2.0 examples/sec; 64.221 sec/batch)
2015-11-04 11:45:49.133065: step 10, loss = 4.66 (533.8 examples/sec; 0.240 sec/batch)
2015-11-04 11:45:51.397710: step 20, loss = 4.64 (597.4 examples/sec; 0.214 sec/batch)
2015-11-04 11:45:54.446850: step 30, loss = 4.62 (391.0 examples/sec; 0.327 sec/batch)
2015-11-04 11:45:57.152676: step 40, loss = 4.61 (430.2 examples/sec; 0.298 sec/batch)
2015-11-04 11:46:00.437717: step 50, loss = 4.59 (406.4 examples/sec; 0.315 sec/batch)
...

Le script rapporte non seulement la perte totale toutes les 10 étapes, mais également la vitesse à laquelle le dernier lot de données a été traité. Certains commentaires:

• Le premier lot de données peut être anormalement lent (par exemple, quelques minutes). En effet, le thread de prétraitement remplit la file d'attente mélangée avec 20 000 images CIFAR traitées.

• La perte déclarée est la perte moyenne du dernier lot. Notez que cette perte est la somme de l'entropie croisée et de tous les termes de décroissance de poids.

• Faites attention à la vitesse de traitement du lot. Les chiffres indiqués ci-dessus ont été obtenus avec le Tesla K40c. Dégradation attendue des performances lors de l'exécution sur le processeur

Exercices: lors des expériences, vous pouvez souvent trouver ennuyeux que la première étape de formation prenne trop de temps. Essayez de réduire le nombre d'images qui remplissent la file d'attente en premier. Recherchez NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN dans cifar10.py.

cifar10_train.py enregistre périodiquement tous les paramètres du modèle dans le fichier Checkpoint (https://www.tensorflow.org/how_tos/variables/index.html#saving-and-restoring) (https) (: //www.tensorflow.org/api_docs/python/state_ops.html#Saver), mais n'évalue pas le modèle. Le fichier de point de contrôle est utilisé par cifar10_eval.py pour mesurer les performances prédictives (voir Évaluation du modèle ci-dessous (#Model Evaluation)).

L'exécution des étapes ci-dessus commencera à entraîner le modèle CIFAR-10. Félicitations!

Le texte du terminal renvoyé par cifar10_train.py fournit un aperçu minimal de la façon dont le modèle est entraîné. Je souhaite obtenir plus d'informations sur le modèle pendant la formation:

• La perte est-elle vraiment réduite ou s'agit-il simplement de bruit?
• Le modèle est-il fourni avec l'image appropriée?
• Les dégradés, les activations et les pondérations sont-ils raisonnables?
• Quel est le taux d'apprentissage actuellement?

TensorBoard provient de cifar10_train.py [SummaryWriter](https://www.tensorflow.org/api_docs/python/train.html#SummaryWriter Il fournit cette fonctionnalité en affichant les données périodiquement exportées via).

Par exemple, vous pouvez voir comment la répartition de l'activation et de la parcimonie dans la fonctionnalité local3 évolue pendant l'entraînement:

Il est particulièrement intéressant de suivre les fonctions de perte individuelles au fil du temps, ainsi que les pertes totales. Cependant, la perte montre une quantité importante de bruit en raison de la petite taille du lot utilisé pour la formation. En pratique, il est très utile de visualiser la moyenne mobile en plus des valeurs brutes. Découvrez comment le script utilise ExponentialMovingAverage (https://www.tensorflow.org/api_docs/python/train.html#ExponentialMovingAverage) à cette fin.

Évaluation du modèle

Évaluons maintenant le fonctionnement du modèle entraîné avec l'ensemble de données fourni. Le modèle est évalué par le script cifar10_eval.py. Il crée un modèle à l'aide de la fonction inference () et utilise les 10 000 images de l'ensemble d'évaluation CIFAR-10. Il calcule une précision de 1, c'est-à-dire la fréquence à laquelle les principales prédictions correspondent à la véritable étiquette de l'image.

Un script d'évaluation est exécuté périodiquement sur le dernier fichier de point de contrôle créé par cifar10_train.py pour surveiller l'amélioration du modèle pendant l'entraînement.

python cifar10_eval.py

Veillez à ne pas exécuter les binaires d'évaluation et de formation sur le même GPU. Sinon, vous manquerez de mémoire. Envisagez d'exécuter l'évaluation sur un GPU différent si disponible, ou de suspendre le binaire d'entraînement sur le même GPU.

Vous devriez voir quelque chose comme ceci:

2015-11-06 08:30:44.391206: precision @ 1 = 0.860
...

Le script renvoie simplement une précision @ 1 sur une base régulière, dans ce cas une précision de 86%. cifar10_eval.py exporte également un résumé qui peut être visualisé dans TensorBoard. Ces résumés fournissent des informations supplémentaires sur le modèle lors de l'évaluation.

Le script d'entraînement calcule la version moyenne mobile (https://www.tensorflow.org/api_docs/python/train.html#ExponentialMovingAverage) de toutes les variables entraînées. Le script d'évaluation remplace les paramètres du modèle entraîné par la version moyenne mobile. Ce remplacement améliore les performances du modèle lors de l'évaluation.

Exercice: vous pouvez améliorer les performances prédictives mesurées par la précision @ 1 d'environ 3% en utilisant les paramètres de moyenne du modèle. Modifiez cifar10_eval.py afin qu'il n'utilise pas le paramètre de moyenne et vérifiez que les performances de prédiction sont dégradées.

Modèles d'entraînement avec plusieurs cartes GPU

Les postes de travail actuels peuvent contenir plusieurs GPU pour les calculs scientifiques et technologiques. TensorFlow peut tirer parti de cet environnement en effectuant des opérations de formation sur plusieurs cartes en même temps.

La formation dans des modèles parallèles et distribués nécessite une coordination du processus de formation. Pour plus tard, une copie du modèle entraîné par un sous-ensemble de données est appelée réplique de modèle.

Si vous adoptez simplement la mise à jour asynchrone des paramètres du modèle Les répliques de modèles individuelles peuvent être entraînées avec des copies plus anciennes des paramètres de modèle, ce qui se traduit par des performances d'entraînement inférieures aux meilleures. Inversement, si vous adoptez une mise à jour entièrement synchrone, elle sera aussi lente que la réplique de modèle la plus lente.

Sur les stations de travail avec plusieurs cartes GPU, chaque GPU a des vitesses similaires et contient suffisamment de mémoire pour exécuter tous les modèles CIFAR-10. Par conséquent, nous allons concevoir le système de formation comme suit:

• Placez des répliques de modèles individuelles sur chaque GPU
• Attendez la fin du traitement des données par lots pour tous les GPU et mettez à jour les paramètres du modèle de manière synchrone

Le schéma de ce modèle est ci-dessous:

Notez que chaque GPU calcule un gradient de données de lot unique ainsi qu'une estimation. Ce paramètre vous permet de diviser efficacement de gros lots de données entre les GPU.

Ce paramètre nécessite que tous les GPU partagent les paramètres du modèle. Comme on le sait, le transfert de données vers et depuis le GPU est très lent. Pour cette raison, nous avons décidé de stocker et de mettre à jour tous les paramètres du modèle dans le CPU (voir encadré vert). Une fois qu'un nouveau lot de données a été traité par tous les GPU, un nouveau jeu de paramètres de modèle est transféré vers les GPU.

Le GPU est synchronisé en fonctionnement. Tous les gradients sont accumulés et moyennés à partir du GPU (voir encadré vert). Les paramètres du modèle sont mis à jour avec le gradient moyen de toutes les répliques de modèle.

Placement des variables et des opérations sur l'appareil

Le placement d'opérations et de variables sur l'appareil nécessite une abstraction spéciale.

La première abstraction dont nous avons besoin est une fonction pour calculer l'inférence et le gradient d'une réplique de modèle unique. Dans le code, cette abstraction est appelée "tour". Vous devez définir deux attributs pour chaque tour.

• Nom unique pour toutes les opérations dans la tour. tf.name_scope () fournit ce nom unique en ajoutant une portée. Par exemple, tower_0 est ajouté avant chaque opération dans la première tour, par exemple tower_0 / conv1 / Conv2D

• Le périphérique matériel préféré effectuera les opérations dans la tour. tf.device () rend cela explicite. Par exemple, toutes les opérations qui se trouvent dans la portée de l'appareil ('/ gpu: 0') dans la première tour doivent être effectuées sur le premier GPU.

Toutes les variables sont fixées au CPU et peuvent être partagées par plusieurs versions de GPU via tf.get_variable () Accéder. Consultez les procédures dans les variables partagées (https://www.tensorflow.org/how_tos/variable_scope/index.html).

Lancement du modèle et formation sur plusieurs cartes GPU

Si vous avez plusieurs cartes GPU et qu'elles sont installées sur votre machine, vous pouvez les utiliser avec le script cifar10_multi_gpu_train.py pour entraîner votre modèle plus rapidement. Cette version du script de formation met en parallèle le modèle sur plusieurs cartes GPU.

python cifar10_multi_gpu_train.py --num_gpus=2

La sortie du script d'entraînement doit ressembler à ceci:

Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
2015-11-04 11:45:45.927302: step 0, loss = 4.68 (2.0 examples/sec; 64.221 sec/batch)
2015-11-04 11:45:49.133065: step 10, loss = 4.66 (533.8 examples/sec; 0.240 sec/batch)
2015-11-04 11:45:51.397710: step 20, loss = 4.64 (597.4 examples/sec; 0.214 sec/batch)
2015-11-04 11:45:54.446850: step 30, loss = 4.62 (391.0 examples/sec; 0.327 sec/batch)
2015-11-04 11:45:57.152676: step 40, loss = 4.61 (430.2 examples/sec; 0.298 sec/batch)
2015-11-04 11:46:00.437717: step 50, loss = 4.59 (406.4 examples/sec; 0.315 sec/batch)
...

Notez que le nombre de cartes GPU est de 1 par défaut. De plus, si votre machine n'a qu'un seul GPU disponible, tous les calculs seront placés sur ce GPU, même si vous en demandez plus.

Exercice: par défaut, cifar10_train.py s'exécute avec une taille de lot de 128. Exécutez cifar10_multi_gpu_train.py sur deux GPU avec une taille de lot de 64 et comparez les vitesses d'entraînement.

L'étape suivante

Félicitations! Vous avez terminé le didacticiel CIFAR-10.

Si vous souhaitez développer et former votre propre système de classification d'images, nous vous recommandons de créer ce didacticiel et de remplacer les composants pour résoudre ce problème de classification d'images.

Exercice: Street View House Numbers (SVHN) Téléchargez l'ensemble de données. Forkez le tutoriel CIFAR-10 et échangez les données d'entrée pour SVHN. Essayez de modifier votre architecture réseau pour améliorer les performances prédictives.