Vision Transformers : La Révolution dans le Traitement d’Images

Les Vision Transformers (ViT) ont introduit une nouvelle approche dans le traitement d’images, utilisant l’architecture des Transformers initialement conçue pour le traitement du langage naturel.

Architecture des Vision Transformers

1. Patch Embedding

class PatchEmbed(nn.Module):
    def __init__(self, img_size, patch_size, in_channels=3, embed_dim=768):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        self.n_patches = (img_size // patch_size) ** 2
        
        self.proj = nn.Conv2d(
            in_channels,
            embed_dim,
            kernel_size=patch_size,
            stride=patch_size
        )
        
    def forward(self, x):
        x = self.proj(x)  # (B, E, H', W')
        x = x.flatten(2)  # (B, E, N)
        x = x.transpose(1, 2)  # (B, N, E)
        return x

2. Vision Transformer

class VisionTransformer(nn.Module):
    def __init__(self, img_size, patch_size, in_channels, n_classes, embed_dim, 
                 num_heads, num_layers, mlp_ratio=4., qkv_bias=True):
        super().__init__()
        
        self.patch_embed = PatchEmbed(img_size, patch_size, in_channels, embed_dim)
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.pos_embed = nn.Parameter(torch.zeros(1, self.patch_embed.n_patches + 1, embed_dim))
        self.pos_drop = nn.Dropout(p=0.1)
        
        self.blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads, mlp_ratio, qkv_bias)
            for _ in range(num_layers)
        ])
        
        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, n_classes)
        
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        
    def forward(self, x):
        B = x.shape[0]
        
        # Patch embedding
        x = self.patch_embed(x)
        
        # Ajout du token de classification
        cls_token = self.cls_token.expand(B, -1, -1)
        x = torch.cat((cls_token, x), dim=1)
        
        # Position embedding
        x = x + self.pos_embed
        x = self.pos_drop(x)
        
        # Transformer blocks
        for block in self.blocks:
            x = block(x)
            
        x = self.norm(x)
        x = x[:, 0]  # Utilisation du token de classification
        
        return self.head(x)

Applications Pratiques

1. Classification d’Images

from transformers import ViTImageProcessor, ViTForImageClassification

# Chargement du modèle et du processeur
processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')
model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')

# Prédiction
image = Image.open('image.jpg')
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

2. Détection d’Objets

class DETR(nn.Module):
    def __init__(self, num_classes, num_queries, hidden_dim):
        super().__init__()
        
        self.backbone = VisionTransformer(...)
        self.transformer = Transformer(...)
        self.class_embed = nn.Linear(hidden_dim, num_classes + 1)
        self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3)
        
    def forward(self, x):
        features = self.backbone(x)
        hs = self.transformer(features)
        
        outputs_class = self.class_embed(hs)
        outputs_coord = self.bbox_embed(hs).sigmoid()
        
        return {'pred_logits': outputs_class[-1], 
                'pred_boxes': outputs_coord[-1]}

Avantages par rapport aux CNNs

1. Attention Globale

   • Meilleure compréhension du contexte global
   • Capture des relations à longue distance
   • Plus flexible que les convolutions locales

2. Flexibilité

   • Architecture uniforme pour différentes tâches
   • Facilement extensible
   • Meilleure adaptation aux données

3. Performance

   • Résultats supérieurs sur certaines tâches
   • Meilleure généralisation
   • Plus efficace sur les grands ensembles de données

Limitations et Solutions

1. Besoin en Données

• Solution : Pré-entraînement sur de grands ensembles de données
• Fine-tuning sur des tâches spécifiques

2. Complexité Computatoire

• Solution : Patch embedding efficace
• Optimisation de l’attention

3. Mémoire

• Solution : Attention éparse
• Gradient checkpointing

Exemples d’Utilisation

Classification d’Images Médicales

# Configuration pour les images médicales
model = VisionTransformer(
    img_size=224,
    patch_size=16,
    in_channels=3,
    n_classes=num_classes,
    embed_dim=768,
    num_heads=12,
    num_layers=12
)

# Entraînement
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

for epoch in range(num_epochs):
    model.train()
    for batch in train_loader:
        images, labels = batch
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    scheduler.step()

Conclusion

Les Vision Transformers représentent une avancée majeure dans le traitement d’images, offrant une alternative puissante aux CNNs traditionnels. Leur architecture flexible et leur capacité à capturer des relations globales en font un outil précieux pour de nombreuses applications.

Ressources Complémentaires

• ViT Paper
• DETR Paper
• Hugging Face Vision Transformers