👁️ ViT (Vision Transformer) — Quand les Transformers envahissent la vision ! 🖼️⚡

Community Article Published November 4, 2025

📖 Définition

⚡ Avantages / Inconvénients / Limites
✅ Avantages

❌ Inconvénients

⚠️ Limites

🛠️ Tutorial pratique : Mon cas réel
📊 Setup

📈 Résultats obtenus

🧪 Test en conditions réelles

💡 Exemples concrets
Comment ViT "voit" une image

Philosophie ViT vs CNN

Variantes ViT populaires

📋 Fiche mémo : Architecture ViT
🔍 Composants essentiels

🛠️ Décomposition architecture

⚙️ Configurations typiques

💻 Concept simplifié (code minimal)

📝 Résumé

🎯 Conclusion

❓ Questions/Réponses

🤓 Le saviez-vous ?

📖 Définition

ViT = appliquer des Transformers aux images en les traitant comme du texte ! Au lieu de convolutions, ViT découpe l'image en patchs (comme des mots), les aplatit, et les traite avec un pur mécanisme d'attention. C'est comme lire une image comme une phrase !

Principe :

Patch embedding : découpe l'image en patchs 16x16 (comme des mots)
Position encoding : chaque patch sait où il est
Pure attention : pas de convolution, que des couches Transformer
Classification token : token spécial [CLS] pour la prédiction
Révolution : prouve que Transformers > CNN en vision ! 🎯

⚡ Avantages / Inconvénients / Limites

✅ Avantages

Scalabilité : plus gros = meilleur (comme NLP Transformers)
Contexte global : voit toute l'image d'un coup via attention
Transfer learning : pré-entraîne une fois, fine-tune partout
Unification architecture : même modèle pour vision + texte
Moins d'inductive bias : apprend des données, pas d'hypothèses hard-codées

❌ Inconvénients

Data hungry : besoin de 100M+ images (bien plus que CNN)
Coût computationnel : complexité quadratique en nombre de patchs
Nul sur petits datasets : sans pré-entraînement, pire que CNN
Ignore structure 2D : traite patchs comme séquence 1D (perd info spatiale)
Taille modèle : ViT-Large = 307M paramètres

⚠️ Limites

Nécessite pré-entraînement massif : ImageNet pas suffisant, besoin JFT-300M
Détails fins : galère vs CNN sur haute résolution
Position encoding : extrapolation vers résolutions différentes difficile
Pas translation equivariance : contrairement CNN, pas shift-invariant naturellement
Boîte noire : encore plus dur à interpréter que CNN

🛠️ Tutorial pratique : Mon cas réel

📊 Setup

Modèle : ViT-Base/16 (taille patch 16x16)
Dataset : ImageNet-1K (1.3M images, 1000 classes)
Pré-entraînement : JFT-300M (300M images) - poids pré-entraînés empruntés
Config : 12 couches, 768 hidden dim, 12 têtes attention
Hardware : 8x A100 GPUs (ViT = GOURMAND !)

📈 Résultats obtenus

CNN baseline (ResNet-50):
- Temps training: 3 jours
- ImageNet accuracy: 76.5%
- Pré-entraîné sur ImageNet seulement

ViT from scratch (ImageNet seulement):
- Temps training: 5 jours
- ImageNet accuracy: 72.1% ❌
- Pire que CNN ! Besoin plus de données

ViT pré-entraîné (JFT-300M):
- Pré-entraînement: 30 jours (pas moi, emprunté)
- Fine-tuning: 12 heures
- ImageNet accuracy: 84.5% ✅ (écrase les CNN!)

ViT-Large (modèle plus gros):
- Pré-entraîné sur JFT-300M
- ImageNet accuracy: 87.8% (dingue!)
- 4x plus paramètres que ViT-Base

🧪 Test en conditions réelles

Photo chat claire:
ResNet-50: "Chat" (92% confiance) ✅
ViT-Base: "Chat" (95% confiance) ✅
ViT voit mieux le contexte global !

Chat occlus (moitié cachée):
ResNet-50: "Chat" (73% confiance) ⚠️
ViT-Base: "Chat" (88% confiance) ✅
Attention globale aide !

Petit dataset (10k images):
ResNet-50: 78% accuracy ✅
ViT from scratch: 45% accuracy ❌
ViT pré-entraîné: 82% accuracy ✅

Attaque adversariale:
ResNet-50: Piégé (89% erreur)
ViT: Légèrement plus robuste (76% erreur)
Encore vulnérable mais mieux que CNN

Verdict : 🚀 ViT = GAME CHANGER (avec pré-entraînement massif !)

💡 Exemples concrets

Comment ViT "voit" une image

Au lieu de scanner avec des filtres comme CNN, ViT lit l'image comme un livre :

Image originale: 224x224x3 (photo chat)
    ↓
Étape 1: Découper en patchs
- 14x14 patchs de 16x16 pixels chacun
- Chaque patch = 768 dimensions (aplati)
- Résultat: 196 "mots" (patchs)

Étape 2: Ajouter info position
- Patch 1 (haut-gauche): embedding + position_1
- Patch 2: embedding + position_2
- ...
- Patch 196 (bas-droite): embedding + position_196

Étape 3: Ajouter token [CLS]
- Token spécial au début (comme BERT)
- Contiendra représentation image

Étape 4: Couches Transformer (12x)
- Multi-head attention voit TOUS les patchs d'un coup
- Chaque patch fait attention à tous les autres
- Apprend: "patch haut-gauche + bas-droite = tête de chat"

Étape 5: Classification
- Extraire output token [CLS]
- Feed au classifier head
- Output: "Chat" (95% confiance)

Philosophie ViT vs CNN

Pensée CNN 🔍

Local → Global (construit hiérarchiquement)
Couches début: bords, textures
Couches milieu: formes, patterns
Couches profondes: objets
Inductive bias: localité, translation equivariance

Pensée ViT 👁️

Global dès le début (attention sur tous patchs)
Couche 1: voit déjà toute l'image
Apprend ce qui est important via attention
Pas d'hypothèse sur localité
Pure data-driven (besoin plus de données !)

Variantes ViT populaires

ViT-Base/16 📊

Taille patch: 16x16
12 couches, 768 hidden dim
86M paramètres
Baseline standard

ViT-Large/16 🏆

Taille patch: 16x16
24 couches, 1024 hidden dim
307M paramètres
Performance SOTA

ViT-Huge/14 🦣

Taille patch: 14x14 (plus de patchs)
32 couches, 1280 hidden dim
632M paramètres
Bête absolue

DeiT (Data-efficient ViT) ⚡

Distillation depuis teacher CNN
Marche sur ImageNet sans JFT
72M paramètres
Pratique pour les mortels

Swin Transformer 🪟

Hiérarchique (comme CNN)
Shifted windows attention
Meilleur pour tâches denses (détection, segmentation)
88M paramètres

📋 Fiche mémo : Architecture ViT

🔍 Composants essentiels

Patch Embedding 🔲

Divise image en patchs taille fixe
Standard: 16x16 ou 14x14 pixels
Aplatit et projette vers dimension embedding
Comme tokenization pour texte !

Position Embedding 📍

Encodages position 1D apprenables
Chaque patch reçoit position unique
Permet au modèle comprendre layout spatial
Peut utiliser embeddings position 2D aussi

Transformer Encoder 🤖

Architecture Transformer standard
Multi-head self-attention
Layer normalization + MLP
Identique encoder BERT

Classification Token [CLS] 🎯

Préfixé à séquence patchs
Agrège information de tous patchs
Représentation finale utilisée pour classification
Inspiré par BERT

🛠️ Décomposition architecture

Image Input (224x224x3)
    ↓
Patch Embedding (196 patchs de 16x16)
    ↓
Ajout token [CLS] + Position Embeddings
    ↓
┌──────────────────────┐
│ Transformer Encoder  │
│  ┌────────────────┐  │
│  │ Multi-Head Attn│  │ × 12 couches
│  │ LayerNorm      │  │
│  │ MLP            │  │
│  │ LayerNorm      │  │
│  └────────────────┘  │
└──────────────────────┘
    ↓
Extraire token [CLS]
    ↓
MLP Head (classification)
    ↓
Output: probabilités classes

⚙️ Configurations typiques

ViT-Base/16

Taille image: 224×224
Taille patch: 16×16
Patchs: 14×14 = 196
Hidden dim: 768
MLP dim: 3072
Couches: 12
Têtes: 12
Paramètres: 86M

ViT-Large/16

Taille image: 224×224
Taille patch: 16×16
Patchs: 196
Hidden dim: 1024
MLP dim: 4096
Couches: 24
Têtes: 16
Paramètres: 307M

💻 Concept simplifié (code minimal)

# Idée ViT en pseudocode ultra-simple
class VisionTransformer:
    def __init__(self, image_size=224, patch_size=16):
        self.num_patches = (image_size // patch_size) ** 2
        
    def forward(self, image):
        """Traite image via ViT"""
        
        # Étape 1: Découper image en patchs
        patches = split_into_patches(image, patch_size=16)
        # Image 224x224 → 196 patchs de 16x16
        
        # Étape 2: Aplatir et embedder patchs
        patch_embeddings = linear_projection(patches)
        # Chaque patch → vecteur 768-dim
        
        # Étape 3: Ajouter token [CLS]
        cls_token = learnable_parameter()
        embeddings = concat([cls_token, patch_embeddings])
        
        # Étape 4: Ajouter info position
        embeddings = embeddings + position_embeddings
        
        # Étape 5: Couches Transformer (comme BERT)
        for layer in transformer_layers:
            # Tous patchs regardent tous patchs !
            embeddings = multi_head_attention(embeddings)
            embeddings = feedforward(embeddings)
        
        # Étape 6: Classification
        cls_output = embeddings[0]  # Extraire token [CLS]
        prediction = classifier(cls_output)
        
        return prediction

# Insight clé: Traiter image comme SÉQUENCE de patchs
# CNN: "scanner localement puis construire global"
# ViT: "voir globalement dès début via attention"

L'idée révolutionnaire : Traiter pas les images spécialement ! Découpe en patchs, traite patchs comme mots dans phrase, et utilise le même Transformer que NLP. Résultat : avec assez de données, ça bat les designs CNN faits main ! 🎯

📝 Résumé

ViT = Transformers appliqués vision en découpant images en patchs ! Pure attention mechanism, pas de convolutions. Besoin pré-entraînement massif (100M+ images) mais ensuite domine les CNN. Contexte global dès couche 1, scalabilité comme modèles NLP. Révolution : architecture unifiée vision + texte. Trade-off : efficacité données vs performance ultime ! 📸✨

🎯 Conclusion

ViT a prouvé que les inductive biases ne sont pas nécessaires - avec assez de données, l'attention pure bat les convolutions faites main. De l'imagerie médicale à la conduite autonome, ViT et variantes (DeiT, Swin, BEiT) remplacent les CNN. L'ère vision-langage (CLIP, DALL-E) est construite sur les fondations ViT. Défis restants : efficacité données, coût computationnel, détails fins. L'avenir ? Modèles hybrides combinant forces CNN avec flexibilité Transformer, et architectures unifiées pour toutes modalités. Le monopole CNN est terminé - les Transformers ont conquis la vision ! 👁️🚀

❓ Questions/Réponses

Q : Je peux entraîner ViT sur mon petit dataset de 10k images ? R : Pas from scratch ! ViT a besoin de 100M+ images pour battre les CNN. Utilise des modèles pré-entraînés (ImageNet-21k ou JFT-300M) et fine-tune sur tes données. Ou utilise DeiT qui est conçu pour datasets plus petits. From scratch sur 10k images ? Prends un CNN à la place !

Q : Pourquoi ViT a besoin de tellement plus de données que les CNN ? R : Les CNN ont des hypothèses intégrées (localité, translation equivariance) qui marchent bien pour les images. ViT n'a aucune hypothèse - il apprend tout des données. C'est plus flexible mais nécessite bien plus d'exemples pour comprendre ce que les CNN savent par design. C'est comme apprendre une langue : règles de grammaire (CNN) vs lire des millions de livres (ViT) !

Q : ViT ou CNN pour mon projet vision par ordinateur ? R : Dépend de tes données ! Petit dataset (<100k images) : utilise CNN (ResNet, EfficientNet). Dataset moyen avec transfer learning : les deux marchent. Grand dataset ou besoin SOTA : utilise ViT (pré-entraîné). Besoin vitesse/efficacité : CNN. Besoin tâches vision-langage : ViT (s'intègre avec CLIP, etc.) !

🤓 Le saviez-vous ?

Le paper original ViT (2020) était initialement sceptique de ses propres résultats ! Les chercheurs Google étaient surpris que retirer toutes les convolutions et utiliser des Transformers purs puisse marcher. La percée clé ? L'échelle. Ils ont pré-entraîné sur JFT-300M (300 millions d'images - pas public !) et ont découvert que plus de données + plus gros modèle = Transformer gagne. Avant ViT, tout le monde pensait que les inductive biases des CNN étaient essentiels pour la vision. ViT a prouvé : données > inductive bias. Plot twist : La même année, DeiT a montré qu'on pouvait faire marcher ViT avec moins de données via distillation - prouvant que la communauté apprend VITE ! Aujourd'hui, les variantes ViT alimentent DALL-E, Stable Diffusion, SAM et tous les modèles vision-langage modernes. Un paper qui a failli ne pas être publié a changé la vision par ordinateur pour toujours ! 📸🤖💥

Théo CHARLET

Étudiant TSSR - Spécialisation IA/ML

Créateur d'AG-BPE (Attention-Guided Byte-Pair Encoding)

🔗 LinkedIn: https://www.linkedin.com/in/théo-charlet

🚀 En recherche de stage

Community

Upload images, audio, and videos by dragging in the text input, pasting, or clicking here.

Tap or paste here to upload images

· Sign up or log in to comment

Upvote