Une architecture de réseau neuronal convolutif (CNN) est un modèle d'apprentissage en profondeur conçu pour traiter des données structurées de type grille, telles que des images. Il se compose de plusieurs couches, notamment des couches convolutionnelles, de pooling et entièrement connectées. Les CNN sont très efficaces pour des tâches telles que la classification d'images, la détection d'objets et la segmentation d'images en raison de leurs capacités d'extraction de caractéristiques hiérarchiques.

VGG-16

Le modèle VGG-16 est une architecture de réseau neuronal convolutif (CNN) proposée par le Visual Geometry Group (VGG) de l'Université d'Oxford. Il se caractérise par sa profondeur, constituée de 16 couches, dont 13 couches convolutives et 3 couches entièrement connectées. VGG-16 est réputé pour sa simplicité et son efficacité, ainsi que pour sa capacité à atteindre de solides performances sur diverses tâches de vision par ordinateur, notamment la classification d'images et la reconnaissance d'objets. L'architecture du modèle comprend une pile de couches convolutives suivies de couches de pooling maximum, avec une profondeur progressivement croissante. Cette conception permet au modèle d'apprendre des représentations hiérarchiques complexes de caractéristiques visuelles, conduisant à des prédictions robustes et précises. Malgré sa simplicité par rapport aux architectures plus récentes, le VGG-16 reste un choix populaire pour de nombreuses applications de deep learning en raison de sa polyvalence et de ses excellentes performances.

L'ImageNet Large Scale Visual Recognition Challenge (ILSVRC) est un concours annuel de vision par ordinateur où les équipes s'attaquent à des tâches telles que la localisation d'objets et la classification d'images. VGG16, proposé par Karen Simonyan et Andrew Zisserman en 2014, a atteint les premiers rangs dans les deux tâches, détectant des objets de 200 classes et classant des images en 1 000 catégories.

différence entre l'arbre binaire et l'arbre de recherche binaire

Architecture VGG-16

Ce modèle réalise 92,7 % parmi les 5 premiers tester la précision sur l'ensemble de données ImageNet qui contient 14 millions d'images appartenant à 1000 classes.

Objectif du modèle VGG-16 :

L'ensemble de données ImageNet contient des images de taille fixe de 224*224 et avoir des canaux RVB. On a donc un tenseur de (224, 224, 3) comme notre contribution. Ce modèle traite l'image d'entrée et génère le vecteur de 1000 valeurs:

hat{y} =egin{bmatrix} hat{y_0} hat{y_1} hat{y_2} . . . hat{y}_{999} end{bmatrix}

Ce vecteur représente la probabilité de classification pour la classe correspondante. Supposons que nous ayons un modèle qui prédit que l'image appartient à la classe 0 avec probabilité 1 , classe 1 avec probabilité 0,05 , classe 2 avec probabilité 0,05 , classe 3 avec probabilité 0,03 , classe 780 avec probabilité 0,72 , classe 999 avec probabilité 0,05 et toutes les autres classes avec 0 .

donc, le vecteur de classification pour cela sera :

hat{y}=egin{bmatrix} hat{y_{0}}=0.1 0.05 0.05 0.03 . . . hat{y_{780}} = 0.72 . . hat{y_{999}} = 0.05 end{bmatrix}

Pour être sûr que ces probabilités s'ajoutent à 1 , nous utilisons la fonction softmax.

Cette fonction softmax est définie comme suit :

hat{y}_i = frac{e^{z_i}}{sum_{j=1}^{n} e^{z_j}}

ligne et colonne

Après cela, nous prenons les 5 candidats les plus probables dans le vecteur.

C =egin{bmatrix} 780 0 1 2 999 end{bmatrix}

et notre vecteur de vérité terrain est défini comme suit :

G = egin{bmatrix} G_{0} G_{1} G_{2} end{bmatrix}=egin{bmatrix} 780 2 999 end{bmatrix}

Ensuite, nous définissons notre fonction Erreur comme suit :

E = frac{1}{n}sum_{k}min_{i}d(c_{i}, G_{k})

conversion d'int en chaîne en java

Il calcule la distance minimale entre chaque classe de vérité terrain et les candidats prédits, où la fonction de distance d est définie comme :

• d=0 sic_i=G_k
• d=1 sinon

Ainsi, la fonction de perte pour cet exemple est :

egin{aligned} E &=frac{1}{3}left ( min_{i}d(c_{i}, G_{1}) +min_{i}d(c_{i}, G_{2})+min_{i}d(c_{i}, G_{3}) ight ) &= frac{1}{3}(0 + 0 +0) &=0 end{aligned}

Puisque toutes les catégories de la vérité terrain se trouvent dans la matrice des 5 premiers prédits, la perte devient donc 0.

VGG Architecture:

L'architecture VGG-16 est un réseau neuronal convolutif profond (CNN) conçu pour les tâches de classification d'images. Il a été introduit par le Visual Geometry Group de l’Université d’Oxford. VGG-16 se caractérise par sa simplicité et son architecture uniforme, ce qui le rend facile à comprendre et à mettre en œuvre.

suite d'outils à ressort

La configuration VGG-16 se compose généralement de 16 couches, dont 13 couches convolutives et 3 couches entièrement connectées. Ces couches sont organisées en blocs, chaque bloc contenant plusieurs couches convolutives suivies d'une couche de pooling maximum pour le sous-échantillonnage.

Carte d'architecture VGG-16

Voici une description de l'architecture VGG-16 basée sur les détails fournis :

1. Couche d'entrée :
   1. Dimensions d'entrée : (224, 224, 3)
2. Couches convolutives (64 filtres, 3×3 filtres, même remplissage) :
   • Deux couches convolutives consécutives avec 64 filtres chacune et une taille de filtre de 3 × 3.
   • Le même remplissage est appliqué pour conserver les dimensions spatiales.
3. Couche de pooling maximale (2 × 2, foulée 2) :
   • Couche de pooling maximum avec une taille de bassin de 2×2 et une foulée de 2.
4. Couches convolutives (128 filtres, 3×3 filtres, même remplissage) :
   • Deux couches convolutives consécutives avec 128 filtres chacune et une taille de filtre de 3×3.
5. Couche de pooling maximale (2 × 2, foulée 2) :
   • Couche de pooling maximum avec une taille de bassin de 2×2 et une foulée de 2.
6. Couches convolutives (256 filtres, 3 × 3 filtres, même remplissage) :
   • Deux couches convolutives consécutives avec 256 filtres chacune et une taille de filtre de 3 × 3.
7. Couches convolutives (512 filtres, 3×3 filtres, même remplissage) :
   • Deux ensembles de trois couches convolutives consécutives avec 512 filtres chacune et une taille de filtre de 3 × 3.
8. Couche de pooling maximale (2 × 2, foulée 2) :
   • Couche de pooling maximum avec une taille de bassin de 2×2 et une foulée de 2.
9. Pile de couches convolutives et pooling maximum :
   • Deux couches convolutives supplémentaires après la pile précédente.
   • Taille du filtre : 3×3.
10. Aplanissement:
    • Aplatissez la carte des caractéristiques de sortie (7x7x512) en un vecteur de taille 25088.
11. Couches entièrement connectées :
    • Trois couches entièrement connectées avec activation ReLU.
    • Première couche avec une taille d'entrée 25088 et une taille de sortie 4096.
    • Deuxième couche avec une taille d'entrée 4096 et une taille de sortie 4096.
    • Troisième couche avec une taille d'entrée 4096 et une taille de sortie 1000, correspondant aux 1000 classes du défi ILSVRC.
    • L'activation Softmax est appliquée à la sortie de la troisième couche entièrement connectée pour la classification.

Cette architecture suit les spécifications fournies, y compris l'utilisation de la fonction d'activation ReLU et les probabilités de sortie de la couche finale entièrement connectée pour 1 000 classes utilisant l'activation softmax.

Configuration VGG-16 :

La principale différence entre les configurations C et D du VGG-16 réside dans l'utilisation de tailles de filtre dans certaines couches convolutives. Alors que les deux versions utilisent principalement des filtres 3×3, dans la version D, il existe des cas où des filtres 1×1 sont utilisés à la place. Cette légère variation se traduit par une différence dans le nombre de paramètres, la version D ayant un nombre de paramètres légèrement supérieur à la version C. Cependant, les deux versions conservent l'architecture globale et les principes du modèle VGG-16.

Configuration VGG différente

Localisation d'objet dans l'image :

Pour effectuer la localisation, nous devons remplacer le score de classe par les coordonnées d'emplacement du cadre englobant. Un emplacement de cadre englobant est représenté par le vecteur 4D (coordonnées centrales (x, y), hauteur, largeur). Il existe deux versions de l'architecture de localisation, l'une est un cadre de délimitation partagé entre différents candidats (le résultat est 4 vecteur de paramètres) et l'autre est une boîte englobante spécifique à la classe (la sortie est 4000 vecteur de paramètres). L'article a expérimenté les deux approches sur l'architecture VGG -16 (D). Ici, nous devons également modifier la perte de la perte de classification en fonctions de perte de régression (telles que MSE ) qui pénalisent l'écart de la perte prévue par rapport à la vérité terrain.

Résultats: VGG-16 était l'une des architectures les plus performantes du défi ILSVRC 2014. Elle était deuxième dans la tâche de classification avec une erreur de classification dans le top 5 de 7,32% (uniquement derrière GoogLeNet avec une erreur de classification de 6,66% ). Il a également remporté la tâche de localisation avec 25,32% erreur de localisation.

Limites du VGG 16 :

• Il est très lent à s'entraîner (le modèle VGG original a été entraîné sur le GPU Nvidia Titan pendant 2-3 semaines).
• La taille des poids imageNet entraînés VGG-16 est 528 Mo. Cela nécessite donc beaucoup d’espace disque et de bande passante, ce qui le rend inefficace.
• 138 millions de paramètres conduisent à un problème de gradients explosifs.

Autres avancées : des Resnets sont introduits pour éviter le problème d'explosion des gradients survenu dans VGG-16.