Un examen des architectures d'apprentissage profond populaires : AlexNet, VGG16 et GoogleNet

Introduction

Des problèmes allant de la reconnaissance d’images à la génération d’images et au marquage ont grandement bénéficié de diverses avancées architecturales en matière d’apprentissage profond (DL). Comprendre les subtilités des différents modèles DL vous aidera à comprendre l'évolution du domaine et à trouver la solution adaptée aux problèmes que vous essayez de résoudre.

Au cours des dernières années, de nombreuses architectures ont vu le jour, variant sous de nombreux aspects, tels que les types de couches, les hyperparamètres, etc. Dans cette série, nous passerons en revue plusieurs des architectures DL les plus remarquables qui ont défini le domaine et redéfini notre capacité pour résoudre des problèmes critiques.

Dans la première partie de cette série, nous couvrirons les modèles « antérieurs » publiés de 2012 à 2014. Cela comprend :

• AlexNet
• VGG16
• GoogleNet

Conditions préalables

Pour bien comprendre les concepts, nous recommandons fortement d'avoir une compréhension de base de l'apprentissage profond et des réseaux de neurones, en particulier des réseaux de neurones convolutifs (CNN). Une connaissance des concepts clés tels que les couches, les fonctions d'activation, la rétropropagation et la descente de gradient est nécessaire. Une connaissance générale des techniques de traitement d'images et une expérience avec un framework d'apprentissage profond tel que TensorFlow ou PyTorch seront également utiles pour comprendre les applications pratiques de celles-ci. architectures.

AlexNet (2012)

AlexNet est l'une des architectures de réseaux neuronaux les plus populaires à ce jour. Il a été proposé par Alex Krizhevsky pour le ImageNet Large Scale Visual Recognition Challenge (ILSVRV) et est basé sur des réseaux de neurones convolutifs. ILSVRV évalue les algorithmes de détection d'objets et de classification d'images. En 2012, Alex Krizhevsky et al. publié la Classification ImageNet avec réseaux de neurones à convolution profonde. C'est à ce moment-là qu'on a entendu parler d'AlexNet pour la première fois.

Le défi consistait à développer un réseau neuronal à convolution profonde pour classer les 1,2 million d'images haute résolution de l'ensemble de données ImageNet LSVRC-2010 dans plus de 1 000 catégories différentes. L’architecture a atteint un taux d’erreur parmi les 5 premiers (le taux de non-identification de la véritable étiquette d’une image donnée parmi les 5 meilleures prédictions d’un modèle) de 15,3 %. Le deuxième meilleur résultat arrive loin derrière, à 26,2 %.

Architecture AlexNet

L'architecture est composée de huit couches au total, parmi lesquelles les 5 premières sont des couches convolutives et les 3 dernières sont entièrement connectées. Les deux premières couches convolutives sont connectées à des couches de pooling maximum qui se chevauchent pour extraire un nombre maximum de fonctionnalités. Les troisième, quatrième et cinquième couches convolutives sont directement connectées aux couches entièrement connectées. Toutes les sorties des couches convolutives et entièrement connectées sont connectées à la fonction d'activation non linéaire ReLu. La couche de sortie finale est connectée à une couche d'activation softmax, qui produit une distribution de 1 000 étiquettes de classe.

Architecture AlexNet

Les dimensions d'entrée du réseau sont (256 × 256 × 3), ce qui signifie que l'entrée vers AlexNet est une image RVB (3 canaux) de (256 × 256) pixels. Il y a plus de 60 millions de paramètres et 650 000 neurones impliqués dans l’architecture. Pour réduire le surapprentissage pendant le processus de formation, le réseau utilise des couches d'abandon. Les neurones « abandonnés » ne contribuent pas au passage vers l'avant et ne participent pas à la rétropropagation. Ces couches sont présentes dans les deux premières couches entièrement connectées.

Formation et résultats AlexNet

Le modèle utilise une fonction d'optimisation de descente de gradient stochastique avec une taille de lot, une impulsion et une décroissance de poids définies respectivement sur 128, 0,9 et 0,0005. Toutes les couches utilisent un taux d'apprentissage égal de 0,001. Pour résoudre le problème du surapprentissage pendant la formation, AlexNet utilise à la fois des couches d'augmentation et d'abandon de données. Il a fallu environ six jours pour s'entraîner sur deux GPU GTX 580 3 Go pendant 90 cycles.

Vous trouverez ci-dessous une capture d'écran des résultats obtenus à l'aide de l'architecture AlexNet :

Résultats utilisant AlexNet sur l'ensemble de données ImageNet

En ce qui concerne les résultats sur l'ensemble de données ILSVRC-2010, AlexNet a atteint des taux d'erreur parmi les 1 et 5 premiers ensembles de tests de 37,5 % et 17,0 % lors de la tenue du concours.

Les frameworks d'apprentissage en profondeur populaires comme PyTorch et TensorFlow disposent désormais de l'implémentation de base d'architectures comme AlexNet. Vous trouverez ci-dessous quelques liens pertinents pour le mettre en œuvre vous-même.

1. Modèle Tensorflow AlexNet
2. Autres références : Comprendre AlexNet
3. L'article original : Classification ImageNet avec des réseaux de neurones à convolution profonde

VGG16 (2014)

VGG est une architecture de réseau neuronal populaire proposée par Karen Simonyan et Andrew Zisserman de l'Université d'Oxford. Il est également basé sur les CNN et a été appliqué au ImageNet Challenge en 2014. Les auteurs détaillent leur travail dans leur article, Very Deep Convolutional Networks for large-scale Image Recognition. Le réseau a atteint une précision de test de 92,7 % parmi les 5 premiers sur l'ensemble de données ImageNet.

Les améliorations majeures de VGG, par rapport à AlexNet, incluent l'utilisation de filtres de grande taille de noyau (tailles 11 et 5 dans les première et deuxième couches convolutives, respectivement) avec plusieurs filtres de taille de noyau (3 × 3), l'un après l'autre.

Architecture VGG

Les dimensions d'entrée de l'architecture sont fixées à la taille de l'image (244 × 244). Lors d'une étape de prétraitement, la valeur RVB moyenne est soustraite de chaque pixel d'une image.

Source : Implémentation étape par étape de VGG16 dans Keras pour les débutants

Une fois le prétraitement terminé, les images sont transmises à une pile de couches convolutives avec de petits filtres de champ récepteur de taille (3 × 3). Dans quelques configurations, la taille du filtre est définie sur (1 × 1), ce qui peut être identifié comme une transformation linéaire des canaux d'entrée (suivie d'une non-linéarité).

La foulée de l'opération de convolution est fixée à 1. Le pooling spatial est effectué par cinq couches de pooling maximum, qui suivent plusieurs couches de convolution. Le pooling maximum est effectué sur une fenêtre de pixels (2 × 2), avec une taille de foulée définie sur 2.

La configuration des couches entièrement connectées est toujours la même ; les deux premières couches ont chacune 4 096 canaux, la troisième effectue une classification ILSVRC à 1 000 voies (et contient donc 1 000 canaux, un pour chaque classe) et la dernière couche est la couche softmax. Toutes les couches cachées du réseau VGG sont suivies par la fonction d'activation ReLu.

Configuration, formation et résultats de VGG

Le réseau VGG comporte cinq configurations nommées A à E. La profondeur de la configuration augmente de gauche (A) à droite (B), avec l'ajout de couches supplémentaires. Vous trouverez ci-dessous un tableau décrivant toutes les architectures réseau potentielles :

Toutes les configurations suivent le modèle universel de l'architecture et ne diffèrent qu'en profondeur ; de 11 couches de poids dans le réseau A (8 couches convolutives et 3 couches entièrement connectées), à 19 couches de poids dans le réseau E (16 couches convolutives et 3 entièrement connectées). Le nombre de canaux des couches convolutives est plutôt petit, commençant par 64 dans la première couche, puis augmentant d'un facteur 2 après chaque couche de pooling maximum, jusqu'à atteindre 512. Vous trouverez ci-dessous une image montrant le nombre total de paramètres (en millions). ) :

La formation d'une image sur le réseau VGG utilise des techniques similaires à Krizhevsky et al., mentionnées précédemment (c'est-à-dire la formation d'AlexNet). Il n'y a que quelques exceptions lorsque des images d'entraînement multi-échelles sont impliquées. L'ensemble du processus de formation est réalisé en optimisant l'objectif de régression logistique multinomiale à l'aide d'une descente de gradient en mini-lots basée sur la rétropropagation. La taille du lot et l'élan sont respectivement fixés à 256 et 0,9. La régularisation des abandons a été ajoutée pour les deux premières couches entièrement connectées, fixant le taux d'abandon à 0,5. Le taux d'apprentissage du réseau a été initialement fixé à 0,001, puis a diminué d'un facteur 10 lorsque la précision de l'ensemble de validation a cessé de s'améliorer. Au total, le taux d'apprentissage a été réduit de 3 fois et l'apprentissage a été arrêté après 370 000 itérations (74 époques).

Le VGG16 a largement surpassé la génération précédente de modèles dans les compétitions ILSVRC-2012 et ILSVRC-2013. Concernant les performances single-net, l'architecture VGG16 a obtenu le meilleur résultat (7,0% d'erreur de test). Vous trouverez ci-dessous un tableau montrant les taux d'erreur.

Concernant le matériel et le temps de formation, le réseau VGG a nécessité des semaines de formation en utilisant les GPU Titan Black de NVIDIA.

Il y a deux inconvénients majeurs à noter si vous travaillez avec un réseau VGG. Premièrement, la formation prend beaucoup de temps. Deuxièmement, les poids de l’architecture réseau sont assez importants. En raison de sa profondeur et du nombre de nœuds entièrement connectés, le modèle VGG16 formé fait plus de 500 Mo. VGG16 est utilisé dans de nombreux problèmes de classification d'images d'apprentissage profond ; cependant, des architectures de réseau plus petites sont souvent plus souhaitables (telles que SqueezeNet, GoogleNet, etc.)

Les frameworks d'apprentissage en profondeur populaires tels que PyTorch et TensorFlow ont l'implémentation de base de l'architecture VGG16. Vous trouverez ci-dessous quelques liens pertinents.

1. Implémentation de PyTorch VGG
2. Implémentation de Tensorflow VGG
3. Lien vers le document de recherche original

GoogleNet (2014)

L'Inception Network a été l'une des avancées majeures dans le domaine des réseaux de neurones, en particulier pour les CNN. Jusqu'à présent, il existe trois versions d'Inception Networks, nommées Inception Version 1, 2 et 3. La première version est entrée sur le terrain en 2014 et, comme le nom « GoogleNet » l'indique, elle a été développée par une équipe de Google. Ce réseau était chargé d'établir un nouvel état de l'art en matière de classification et de détection dans l'ILSVRC. Cette première version du réseau Inception est appelée GoogleNet.

Si un réseau est construit avec de nombreuses couches profondes, il peut être confronté au problème du surajustement. Pour résoudre ce problème, les auteurs du document de recherche Aller plus loin avec les convolutions ont proposé l'architecture GoogleNet avec l'idée d'avoir des filtres de plusieurs tailles pouvant fonctionner au même niveau. Avec cette idée, le réseau devient en réalité plus large que plus profond. Vous trouverez ci-dessous une image montrant un module Naive Inception.

Comme le montre le diagramme ci-dessus, l'opération de convolution est effectuée sur des entrées avec trois tailles de filtre : (1 × 1), (3 × 3) et (5 × 5). Une opération de pooling maximum est également effectuée avec les convolutions et est ensuite envoyée au module de démarrage suivant.

Étant donné que la formation des réseaux de neurones prend du temps et coûte cher, les auteurs limitent le nombre de canaux d'entrée en ajoutant une convolution supplémentaire (1 × 1) avant les convolutions (3 × 3) et (5 × 5) pour réduire les dimensions du réseau et effectuer des calculs plus rapides. Vous trouverez ci-dessous une image montrant un module Naive Inception avec cet ajout.

Ce sont les éléments constitutifs de GoogleNet. Vous trouverez ci-dessous un rapport détaillé sur son architecture.

Architecture GoogleNet

L'architecture GoogleNet comporte 22 couches, dont 27 couches de pooling. Il y a 9 modules de démarrage empilés linéairement au total. Les extrémités des modules de création sont connectées à la couche de pooling moyenne globale. Vous trouverez ci-dessous une image agrandie de l'architecture complète de GoogleNet.

La Boîte Orange dans l'architecture est la tige qui présente peu de circonvolutions préliminaires. Les cases violettes sont les classes auxiliaires. (Crédits image : un guide simple des versions du réseau Inception).

L'architecture détaillée et les paramètres sont expliqués dans l'image ci-dessous.

Formation et résultats GoogleNet

GoogleNet est formé à l'aide de systèmes d'apprentissage automatique distribués avec un degré modeste de parallélisme des modèles et des données. La formation utilisait une descente de gradient stochastique asynchrone avec une impulsion de 0,9 et un calendrier de taux d'apprentissage fixe diminuant le taux d'apprentissage de 4 % toutes les 8 époques. Vous trouverez ci-dessous une image des résultats des équipes ayant participé à l'ILSVRC 2014. GoogleNet occupe la première place avec un taux d'erreur de 6,67 %.

Vous trouverez ci-dessous quelques liens pertinents que je vous encourage à consulter si vous souhaitez utiliser ou mettre en œuvre GoogleNet.

1. Lien vers le document de recherche original
2. Implémentation PyTorch de GoogleNet
3. Implémentation Tensorflow de GoogleNet

Conclusion

Ces architectures ont jeté les bases de nombreux modèles avancés d’apprentissage profond d’aujourd’hui. L'introduction d'AlexNet et l'utilisation de GPU ont marqué un tournant dans les performances de classification d'images. VGG16 a démontré la puissance de la profondeur et de la simplicité en utilisant de petits filtres convolutifs, tandis que GoogleNet a introduit le module Inception pour atteindre un équilibre entre efficacité et précision.