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:

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

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 /.

Fichier Objectif
cifar10_input.py CIFAR-10 Lire le format de fichier binaire
cifar10.py CIFAR-Construisez 10 modèles
cifar10_train.py CIFAR sur CPU ou GPU-Former 10 modèles
cifar10_multi_gpu_train.py CIFAR sur plusieurs GPU-Former 10 modèles
cifar10_eval.py CIFAR-Évaluer les performances prédictives de 10 modèles

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:

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

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:

Nom du calque La description
conv1 PlierQuandReLUActivation
pool1 Mise en commun maximale
norm1 Normalisation de la réponse locale
conv2 PlierQuandReLUActivation
norm2 Normalisation de la réponse locale
pool2 Mise en commun maximale
local3 Couche entièrement connectée avec activation ReLU
local4 Couche entièrement connectée avec activation ReLU
softmax_linear Transformation linéaire pour générer un logit

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:

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:

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:

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.

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.

Recommended Posts

Tutoriel TensorFlow - Réseau neuronal à convolution (traduction)
Réseau neuronal paramétrique
Tutoriel TensorFlow - Ensemble de Mandelbrot (traduction)
Tutoriel TensorFlow - TensorFlow Mechanics 101 (Traduction)
Implémenter un réseau neuronal convolutif
Implémenter le réseau neuronal à partir de zéro
Tutoriel TensorFlow - Reconnaissance d'image (traduction)
Implémenter un réseau neuronal à 3 couches
Tutoriel TensorFlow - Téléchargement de données MNIST (traduction)
Réseau de neurones avec Python (scikit-learn)
Modèle de transformation de séquence de didacticiel TensorFlow (traduction)
Tutoriel TensorFlow - Équation différentielle partielle (traduction)
Réseau de neurones commençant par Chainer
Implémentation de réseau neuronal en python
Tutoriel sur le réseau neuronal (CNN) de Pytorch 1.3.1.
4. Entourez les paramètres avec un réseau neuronal!
Implémentation de réseau neuronal (NumPy uniquement)
Implémentation simple d'un réseau neuronal à l'aide de Chainer
Traduction TensorFlow MNIST pour les débutants en ML
Réseau neuronal avec OpenCV 3 et Python 3
Implémentation d'un réseau de neurones à deux couches 2
PRML Chapitre 5 Implémentation Python du réseau neuronal
Modèle de classification simple avec réseau neuronal
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
Théorie et implémentation simples des réseaux neuronaux
Touchez l'objet du réseau neuronal
[Traitement du langage 100 coups 2020] Chapitre 8: Réseau neuronal
Tutoriel TensorFlow - Représentation vectorielle des mots (traduction)
TensorFlow Deep MNIST pour la traduction d'experts
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow