Classification des images en 2022

Les modèles de vision basés sur les transformateurs évoluent progressivement et seraient aussi bons que les modèles convolutifs sur les tâches de classification, de segmentation et de reconnaissance d'action. Nous avons toute une gamme de modèles convolutifs pour les tâches de vision et sont plus populaires que ceux basés sur Transformer. Ce blog se penche sur le modèle SWin Transformer Vision qui a été présenté lors de la Conférence internationale sur la vision par ordinateur (ICCV) 2021 par l'équipe de recherche Microsoft. Il compare ses performances à plusieurs modèles basés sur SOTA Convolution sur la tâche de classification d'images de races de chiens.

Les modèles basés sur des transformateurs deviendront-ils la prochaine grande nouveauté de la vision par ordinateur ? Les transformateurs étant une solution efficace pour les tâches linguistiques, unifieront-ils les différents sous-domaines de l'IA et présenteront-ils des solutions puissantes à des problèmes plus complexes ? Donc retrousser mes manches pour évaluer à quel point ils sont bons sur la tâche de classification pour commencer.

Données choisies et son énoncé de problème :

La myriade de races de chiens avec des changements subtils dans leur apparence physique a été un défi pour les vétérinaires, les propriétaires de chiens, le personnel des refuges pour animaux et les propriétaires potentiels de chiens pour identifier leur bonne race. Ils doivent identifier la race afin de fournir une formation et un traitement appropriés et de répondre à leurs besoins nutritionnels. Les données proviennent du Stanford Dog Dataset qui contient environ 20 000 images de 120 races de chiens à travers le monde. Ces données ont été divisées presque également en train et ensemble de test pour une identification de race de chien de compétition Kaggle.

L'objectif de la solution est de construire un système d'identification de races de chiens capable d'identifier correctement les races de chiens avec un minimum de données et d'identifier correctement même les races de chiens d'apparence similaire. Il s'agit d'une tâche de classification multi-classes et pour chaque image, le modèle doit prédire la probabilité pour les 120 races. Celui avec la probabilité la plus élevée est la race la plus probable du chien dans l'image.

L'analyse exploratoire des données

• Pour une race, les données d'entraînement ont un maximum de 120+ images et un minimum de 66 images. Chaque classe, en moyenne, devrait avoir 85 images. En regardant le bar plot, on conclut qu'il n'y a pas de déséquilibre de classe.

• Bien qu'il n'y ait pas de déséquilibre de classe, les données peuvent être insuffisantes pour entraîner le réseau de neurones. L'augmentation d'image utilisant des perturbations d'image aléatoires et des modèles pré-entraînés permettra de contourner ce problème.

  
  

• Les 5 races avec le plus d'images sont le scottish_deerhound, le maltese_dog, l'afghan_hound, l'entlebucher et le bernese_mountain_dog. Les 5 dernières races avec le moins d'images sont golden_retriever, brabancon_griffon, komondor, eskimo_dog et briard.

  
  

• Une analyse rapide des dimensions spatiales des images d'entraînement est effectuée pour comprendre la distribution de la hauteur, de la largeur et de leurs rapports d'aspect.

• Les images avec des rapports d'aspect très faibles (<0,5) et très élevés (>2,3) sont considérées comme des images anormales. 1,5 est considéré comme un bon format d'image.

  

• En analysant diverses races de chiens, les paires de races ci-dessous se ressemblaient généralement.

  • 'boston_bull', 'bouledogue_francais'
  • 'beagle', 'english_foxhound'
  • 'bernese_mountain_dog', 'greater_swiss_mountain_dog'
  • 'malamute', 'siberian_husky'
  • 'basenji', 'ibizan_hound'
  • 'vizsla', 'rhodesian_ridgeback'
  • 'lhassa', 'shih-tzu'
  • 'whippet', 'italian_greyhound'
  • 'brittany_spaniel', 'welsh_springer_spaniel', 'blenheim_spaniel'
  • 'malinois', 'berger_allemand'
  • 'border_collie', 'collie'
  • 'norfolk_terrier', 'norwich_terrier'

Métriques d'évaluation

• LogLoss, qui évalue de manière rigoureuse la confiance des prédictions du modèle pour les 120 classes en comparant la probabilité de prédiction à la probabilité de vérité terrain, est la métrique clé.
• La matrice de confusion N*N est utilisée pour étudier le résultat des prédictions afin d'analyser s'il existe une paire de classes confondues par le modèle et mal prédites.

SWIN - Modèle basé sur le transformateur

Cette architecture est basée sur "Swin Transformer: Hierarchical Vision Transformer using Shifted Windows" développé par Microsoft Research Team. Cet article traite d'une architecture ViT améliorée qui produit une représentation hiérarchique des cartes de caractéristiques réduisant la complexité de calcul du mécanisme d'auto-attention de quadratique à linéaire. Il est prouvé qu'il donne des résultats identiques à ceux des réseaux de convolution SOTA comme EfficientNet sur le problème de classification Imagenet.

Les éléments constitutifs de cette architecture sont expliqués dans les notes ci-dessous :

Correction d'image :

En NLP, les jetons qui sont les éléments de traitement d'un modèle sont les mots d'une phrase où la taille de 1 jeton est 1 (seulement 1 mot). ViT ( Vi sion T ransformers) traite les « patchs d'image » comme des jetons où chaque patch est une partition d'une image constituée d'un groupe de pixels voisins. Chaque patch d'image est un jeton. La taille d'un jeton dans n'importe quel ViT est patch_height * patch_width * nombre de canaux. Sur la base des dimensions du patch, nous obtenons un certain nombre de patchs ou de jetons pour une seule image. Si la taille de l'image (H*W*3) est de 224 * 224 * 3 pixels et la taille du patch est de 4 * 4, alors nous obtenons 224/4 * 224/4 = 56 * 56 patchs ou 3136 jetons de l'image. Chaque jeton ou patch sera de taille 4*4*3 = 48 dimensions ou 48 pixels de données. Ainsi, l'entrée de l'architecture pour cette image se compose de 3136 jetons chacun de taille 48 dimensions.

Le mécanisme sous-jacent du transformateur SWIN est analogue à toute architecture basée sur CNN où les dimensions spatiales de l'image sont réduites et le nombre de canaux est augmenté. Transformateur SWIN à chaque étape de l'architecture hiérarchique, réduit également le nombre de patchs d'image ou le nombre de jetons tout en augmentant les dimensions des jetons. Avec ce mécanisme à l'esprit, il est plus facile de comprendre facilement l'architecture SWIN.

À chaque étape de l'architecture, nous pouvons voir le nombre de jetons diminuer tandis que la taille des jetons augmente.

L'architecture SWIN-T, outre le " Patch Partitioner", est également composée de 3 autres blocs de construction - Linear Embedding, Swin Transformer Block, Patch Merging. Ces blocs de construction sont répétés et traitent les cartes d'entités de manière hiérarchique.

Incorporation linéaire :

Les 3136 jetons de 48 dimensions chacun provenant du "Patch Partitioner" sont acheminés vers une couche d'alimentation en aval pour intégrer le jeton de 48 vecteurs de caractéristiques dans un vecteur de caractéristiques de taille "C". "C" agit ici comme la capacité du transformateur et l'architecture SWIN a 4 variantes basées sur celle-ci.

• Minuscule (Swin-T) - C est '96'
• Petit (Swin-S) - C est '96'
• Base (Swin-B) - C est '128'
• Grand (Swin-L) - C est '192'

Bloc de transformateur SWin :

Le bloc transformateur SWin est différent du bloc transformateur standard dans l'architecture ViT. Dans SWin Transformers, le Auto-attention multi-têtes (MSA) couche est remplacée soit par la Module fenêtre MSA (W-MSA) ou la Module MSA à fenêtre décalée (SW-MSA) .

Stage1 se compose de 2 blocs de transformateur SWIN-T (voir l'image) où le premier bloc de transformateur a une fenêtre MSA (W-MSA) et le deuxième bloc de transformateur a un module de fenêtre décalée MSA (SW-MSA). Dans le SWin Transformer Block, les entrées et les sorties des couches W-MSA et SW-MSA sont transmises via des couches de normalisation. Il est ensuite soumis à un réseau Feed Forward à 2 couches avec activation des unités linéaires d'erreur gaussienne (GELU). Il existe des connexions résiduelles au sein de chaque bloc et entre ces 2 blocs.

Modules Window MSA (W-MSA) et Shifted Window MSA (SW-MSA)

Pourquoi la couche d'attention standard dans ViT est-elle remplacée par la couche MSA fenêtrée ?

La couche d'attention standard dans ViT était une couche globale calculant l'attention d'un patch avec tous les autres patchs de l'image, conduisant ainsi à une complexité quadratique proportionnelle aux dimensions de l'image. Cela ne s'adapte pas très bien aux images haute résolution.

Le mécanisme d'auto-attention dans le module W-MSA ou SW-MSA est un mécanisme local qui calcule l'auto-attention uniquement entre les patchs dans la même fenêtre de l'image et non à l'extérieur des fenêtres.

Les fenêtres sont comme des partitions plus grandes de l'image où chaque fenêtre comprend des patchs M*M. Le remplacement de l'auto-attention globale par l'auto-attention locale a réduit la complexité de calcul de quadratique à linéaire.

Pourquoi W-MSA et SW-MSA pour l'auto-attention locale ? Quelle est la différence entre eux?

La principale différence entre les modules d'attention W-MSA et SW-MSA réside dans la manière dont les fenêtres de l'image sont configurées.

Dans le module W-MSA, une stratégie de partitionnement de fenêtre régulière est suivie. L'image est répartie uniformément en fenêtres qui ne se chevauchent pas à partir du pixel supérieur gauche de l'image, et chaque fenêtre contient des patchs M*M ou M2 .

Dans le module SW-MSA, la configuration des fenêtres est décalée de celle de la couche W-MSA, en déplaçant les fenêtres de (M/2, M/2) correctifs par rapport à la stratégie de partitionnement habituelle.

Pourquoi une stratégie de partitionnement décalé des fenêtres dans SW-MSA ?

Étant donné que l'attention est restreinte localement dans une fenêtre dans W-MSA, la fenêtre décalée permet à l'attention inter-fenêtres de continuer à produire les avantages de l'attention globale. Cela est possible car les limites de la fenêtre 1 dans la couche W-MSA sont partagées avec les fenêtres W2, W4 et W5 dans la couche SW-MSA. Par conséquent, l'attention globale se produit indirectement via "l'attention locale sur les fenêtres décalées".

Couche de fusion de patchs

La couche Patch Merging réduit le nombre de jetons à mesure que le réseau devient de plus en plus profond. La première couche de fusion de patchs concatène les caractéristiques de chaque groupe de 2×2 patchs voisins.

Transformateurs SWIN sur la classification des races de chiens

Le package tfswin dans PyPI contient des variantes TF-Keras pré-entraînées des transformateurs SWIN et est construit sur la base de l' implémentation officielle de pytorch . Son code est disponible sur github . tfswin est utilisé pour former les images de race de chien.

 from tfswin import SwinTransformerBase224, preprocess_input def build_model1(swintransformer): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) outputs = Lambda(preprocess_input)(inputs) outputs = swintransformer(outputs) outputs = Dense(num_classes, activation='softmax')(outputs) swin_model = Model(inputs=inputs, outputs=outputs) return swin_model #build the model swintransformer = SwinTransformerBase224(include_top=False,pooling='avg') swin_model1 = build_model1(swintransformer) #set the layers of the pretrained model as non-trainable for layer in swin_model1.layers[2].layers: layer.trainable = False swin_model1.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),loss='categorical_crossentropy',metrics=['accuracy'])

Modèles basés sur la convolution

• Pour commencer, diverses variantes de ResNet ont été formées avec différents remplacements pour les couches supérieures, et partiellement pour geler totalement le réseau.

 #Logloss of the test set using various ResNet variants +------------+---------------+-------------------------+----------+ | Model Name | Retrained | Top Layers Replacement | Log_Loss | +------------+---------------+-------------------------+----------+ | ResNet50 | None | ConvBlock_FC_Output | 0.96463 | | ResNet50 | None | GlobalAvgPooling_Output | 0.58147 | | ResNet50 | last 4 layers | ConvBlock_FC_Output | 2.10158 | | ResNet50 | last 4 layers | GlobalAvgPooling_Output | 0.57019 | +------------+---------------+-------------------------+----------+

Code correspondant au modèle ResNet50 avec le moins de perte de log

 from tensorflow.keras.layers import Input,Conv2D,Dense,BatchNormalization,Flatten,Concatenate, Dropout,MaxPooling2D from tensorflow.keras.models import Model from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input def build_model(): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) #added preprocess_input method as a layer to convert input images to those expected by Resnet processed_inputs = preprocess_input(inputs) #use the pretrained ResNet model (Parameter pooling = 'avg' will take care of the Gobal Average Pooling of the ResNet model features) base_model = ResNet50(weights="imagenet", include_top=False,pooling='avg')(processed_inputs) #output layer output = Dense(units=num_classes,activation='softmax',name='Output')(base_model) resnet_model = Model(inputs=inputs, outputs=output) return resnet_model #build the model resnet_model = build_model() #set the layers of the resnet pretrained model as non-trainable except for its last 4 layers which needs to be re-trained for this data for layer in resnet_model.layers[3].layers[:-4]: layer.trainable = False #compile the model resnet_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),loss='categorical_crossentropy',metrics=['accuracy']) print(resnet_model.summary()) history = resnet_model.fit(train_ds, epochs=50, validation_data=val_ds, callbacks=callbacks_list)

• Des modèles convolutionnels pré-formés plus sophistiqués tels que EfficientNet, NASNet, InceptionResNet, Xception et InceptionV3 ont également été formés à l'aide des images de race de chien, à la fois de manière autonome et de manière combinée. La perte de journal sur les données de test (constituées d'images 10K) de ces modèles était inférieure à celle de toutes les variantes ResNet.

 #Logloss of the standalone model variants +----------------------------+-------------+ | Model Name | Log_Loss | +----------------------------+-------------+ | EfficientNetV2M | 0.28347 | | Inception ResNet | 0.28623 | | NasNetLarge | 0.33285 | | Xception | 0.34187 | | Inception_V3 | 0.54297 | | EfficientNetV2M_GlobalAveg | 0.50423 | | InceptionV3_GlobalAveg | 0.46402 | +----------------------------+-------------+

• Pour les modèles autonomes, les couches des modèles pré-formés ont été gelées et leurs couches supérieures ont été remplacées par soit
  • Couche convolutive suivie de la couche MaxPooling
  • Couche de regroupement de la moyenne globale

• L'architecture EfficientNet est un modèle correctement mis à l'échelle dans les 3 dimensions - profondeur, largeur et résolution.
• NASNet-Large est le résultat d'une recherche d'architecture de modèle effectuée à l'aide de divers algorithmes de recherche d'hyperparamètres, d'algorithmes d'optimisation et d'algorithmes d'apprentissage par renforcement.
• InceptionV3 a factorisé de plus grandes convolutions en plus petites convolutions asynchrones et a également inclus des classificateurs auxiliaires pour améliorer la convergence du modèle.
• L'architecture Xception effectue des convolutions séparables en profondeur au lieu des modules de démarrage de l'architecture Inception.
• La perte de log des modèles d'ensemble est réduite de > 0,1 par rapport au modèle autonome le plus performant.

 +--------------------------------------------------------------------------+-----------+ | Model Name | Log_Loss | +--------------------------------------------------------------------------+-----------+ | Ensemble1 - EfficientNEt,InceptionResNet,NasNet,Xception) | 0.17363 | | Ensemble2 - EfficientNEt,InceptionResNet,NasNet,Xception and InceptionV3 | 0.16914 | | Ensemble3 - Ensemble2 with 50% dropout. | 0.16678 | | Ensemble4 - Ensemble of various EfficientNet Architecture | 0.16519 | +--------------------------------------------------------------------------+-----------+

Résultat de l'analyse comparative

 +----------------------------------+------------+----------------------+----------+ | Model Name | Parameters | Train time (seconds) | Log_Loss | +----------------------------------+------------+----------------------+----------+ | EfficientNet_ConvBlock_Output | 54.7M | ~260s | 0.28347 | | InceptionResNet_ConvBlock_Output | 56.1M | ~260s | 0.28623 | | NASNetLarge_ConvBlock_Output | 89.6M | ~330s | 0.33285 | | XCeption_ConvBlock_Output | 23.3M | ~240s | 0.34187 | | InceptionV3_ConvBlock_Output | 24.2M | ~225s | 0.54297 | | EfficientNet_GlobalAvg | 53.3M | ~260s | 0.50423 | | InceptionV3_GlobalAvg | 22M | ~215s | 0.46402 | | swin_base224 | 86.8M | ~550s | 0.47289 | | swin_base384 | 87M | ~600s | 0.41902 | | swin_large384 | 195M | ~1000s | 0.42207 | +----------------------------------+------------+----------------------+----------+

• Les transformateurs SWIN ont obtenu de meilleurs résultats que toutes les variantes ResNet50 et le modèle InceptionV3.

• La perte de log de SWIN Transformer sur ces données est légèrement supérieure à celle des modèles InceptionResNet, EfficientNet, Xception et NasNet Large lorsque leurs sorties sont traitées ultérieurement par couche convolutive suivie de Maxpooling.

• Cependant, SWIN fonctionne aussi bien que le modèle EfficientNet lorsque leurs sorties moyennes sont directement traitées par la couche de sortie.

• Les modèles SWIN sont plus grands que tous les modèles convolutifs et auront donc un impact sur le débit et la latence du système.

  
  

Cette étude s'est avérée utile pour comprendre l'application des modèles basés sur les transformateurs pour la vision par ordinateur.

Vous pouvez trouver le code des notebooks sur mon Github et l'interface graphique pour ce cas d'utilisation ici.

Références:

https://www.kaggle.com/competitions/dog-breed-identification

https://arxiv.org/pdf/2103.14030.pdf

https://www.youtube.com/watch?v=tFYxJZBAbE8&t=362s

https://towardsdatascience.com/swin-vision-transformers-hacking-the-human-eye-4223ba9764c3

https://github.com/shkarupa-alex/tfswin