08 - Vision Transformer (ViT) : Architecture et Applications Pratiques
En 2020, un article de Google Research a radicalement changé la computer vision : « An Image is Worth 16x16 Words ». L'intuition était simple mais révolutionnaire — appliquer l'architecture Transformer directement aux images en traitant les patches visuels comme des tokens. Le résultat fut le Vision Transformer (ViT).
Les ViT évoluent mieux que les CNN avec plus de données et de calcul, et des variantes comme Swin Transformer et DeiT les rendent efficaces même sur des datasets de taille moyenne.
Ce Que Vous Apprendrez
- Architecture ViT : patch embedding, positional encoding, attention visuel
- Implémentation complète depuis zéro avec PyTorch
- Différences entre ViT-B/16, DeiT, Swin Transformer
- Fine-tuning pour des tâches spécifiques
- ViT vs CNN : quand choisir chacun
Architecture ViT
Implémentation ViT depuis Zéro
import torch
import torch.nn as nn
class PatchEmbedding(nn.Module):
def __init__(self, img_size=224, patch_size=16,
in_channels=3, d_model=768):
super().__init__()
self.n_patches = (img_size // patch_size) ** 2
self.proj = nn.Conv2d(in_channels, d_model,
kernel_size=patch_size, stride=patch_size)
def forward(self, x):
x = self.proj(x)
return x.flatten(2).transpose(1, 2)
class VisionTransformer(nn.Module):
def __init__(self, img_size=224, patch_size=16,
n_classes=1000, d_model=768,
n_heads=12, n_layers=12):
super().__init__()
self.patch_embed = PatchEmbedding(
img_size, patch_size, 3, d_model)
n_patches = self.patch_embed.n_patches
self.cls_token = nn.Parameter(torch.zeros(1, 1, d_model))
self.pos_embed = nn.Parameter(
torch.zeros(1, n_patches + 1, d_model))
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model, nhead=n_heads,
dim_feedforward=d_model * 4,
activation='gelu', batch_first=True)
self.encoder = nn.TransformerEncoder(
encoder_layer, num_layers=n_layers)
self.head = nn.Linear(d_model, n_classes)
def forward(self, x):
B = x.shape[0]
x = self.patch_embed(x)
cls = self.cls_token.expand(B, -1, -1)
x = torch.cat([cls, x], dim=1)
x = x + self.pos_embed
x = self.encoder(x)
return self.head(x[:, 0])Variantes : DeiT, Swin, BEiT
| Modèle | Innovation Clé | Avantage |
|---|---|---|
| ViT original | Patches comme tokens | Simplicité, scalabilité |
| DeiT | Distillation token | Fonctionne sans pré-entraînement massif |
| Swin Transformer | Attention locale avec fenêtres glissantes | Efficace pour haute résolution |
| BEiT | Pré-entraînement type BERT | Meilleur transfer learning |
Conclusions
Les Vision Transformers ont changé la computer vision autant que les Transformers ont changé le NLP. Le choix entre ViT et CNN dépend de la taille du dataset et des exigences de latence.
Prochaines Étapes
- Article suivant : Recherche d'Architecture Neurale (NAS) : AutoML
- Lecture : « An Image is Worth 16x16 Words » (Dosovitskiy et al. 2020)