SimCLR : L’Apprentissage Contrastif Révolutionnaire

Résumé

SimCLR (Simple framework for Contrastive Learning of visual Representations) est une méthode d’apprentissage auto-supervisé introduite par Google Brain en 2020. Ce cadre simplifié mais extrêmement puissant démontre que l’apprentissage par contraste, combiné à des augmentations de données appropriées et à des lots d’entraînement de grande taille, permet d’obtenir des représentations visuelles de très haute qualité — rivalisant avec des modèles entièrement supervisés entraînés sur ImageNet. L’idée centrale est remarquablement élégante : pour chaque image, on génère deux versions augmentées, on les encode à travers un réseau de neurones, et on maximise leur similarité tout en les distinguant de toutes les autres images du même lot. Cette approche, purement contrastive et sans aucune annotation, a ouvert la voie à une nouvelle génération de modèles de vision par ordinateur capables d’apprendre à partir de données non étiquetées en quantités massives.

Principes Mathématiques Fondamentaux

Génération des Paires Augmentées

Pour chaque image $x$ tirée d’un ensemble de données, SimCLR génère systématiquement deux versions augmentées $\tilde{x}_i$ et $\tilde{x}_j$ en appliquant des transformations aléatoires composées. Ces transformations incluent notamment le recadrage aléatoire avec changement d’échelle (RandomResizedCrop), la distorsion des couleurs (ColorJitter), le flou gaussien (GaussianBlur), la conversion en niveaux de gris et la réflexion horizontale. Le choix de ces augmentations est crucial : elles doivent préserver l’information sémantique de l’image tout en modifiant suffisamment son apparence pour forcer le modèle à extraire des caractéristiques invariantes.

Encodage et Projection

Chaque version augmentée passe ensuite à travers un encodeur profond $f(\cdot)$, typiquement un réseau ResNet, qui produit une représentation intermédiaire de dimension élevée :

$$z_i = f(\tilde{x}_i) \quad \text{et} \quad z_j = f(\tilde{x}_j)$$

Ces représentations $z_i$ et $z_j$ sont ensuite transformées par un petit réseau de neurones multicouche $g(\cdot)$, appelé projection head, qui produit les vecteurs de projection finale :

$$h_i = g(z_i) \quad \text{et} \quad h_j = g(z_j)$$

La projection head est généralement un MLP à deux couches avec une non-linéarité ReLU intermédiaire. Il est remarquable que cette petite tête de projection améliore significativement la qualité des représentations, même si seule la sortie de l’encodeur $f$ (et non celle de $g$) est utilisée pour les tâches en aval. Ce phénomène suggère que la projection head agit comme un filtre qui élimine les informations non pertinentes pour la tâche contrastive.

La Fonction de Perte NT-Xent

Le cœur de SimCLR réside dans la fonction de perte NT-Xent (Normalized Temperature-scaled Cross-Entropy). Pour une paire positive $(i, j)$ issue de la même image, la contribution à la perte est définie comme suit :

$$\ell_{i,j} = -\log \frac{\exp(\text{sim}(h_i, h_j) / \tau)}{\sum_{k \neq i} \exp(\text{sim}(h_i, h_k) / \tau)}$$

où $\text{sim}(u, v) = \frac{u \cdot v}{|u| \cdot |v|}$ représente la similarité cosinus entre deux vecteurs normalisés, et $\tau > 0$ est un paramètre de température qui contrôle la sensibilité de la fonction de similarité relative.

La somme au dénominateur s’étend sur tous les autres échantillons du lot. C’est ici que réside la puissance du contraste : les paires positives (les deux augmentations d’une même image) doivent avoir une similarité élevée, tandis que les paires négatives (issues d’images différentes) doivent être repoussées dans l’espace de représentation.

Importance de la Taille du Lot

La qualité des représentations apprises par SimCLR dépend fortement de la taille du lot. Un lot volumineux contient plus d’exemples négatifs, ce qui signifie plus de contrastes à apprendre. Avec un lot de taille $N$ images, on obtient $2N$ échantillons augmentés, ce qui donne $2(N-1)$ exemples négatifs pour chaque paire positive. Des expériences ont montré qu’augmenter la taille du lot de 256 à 8192 images améliore significativement la précision en transfert linéaire sur ImageNet. Cette dépendance au lot a motivé l’utilisation de techniques comme l’accumulation de gradients et la multiplication de lots synthétiques pour reproduire les résultats avec des ressources limitées.

Intuition : Un Exercice de Reconnaissance Visuelle

SimCLR, c’est fondamentalement un exercice de reconnaissance visuelle sophistiqué. Imaginez la scène suivante : on montre deux photos du même chat à un modèle, mais la première photo est recadrée de manière à ne montrer que la tête du félin, tandis que la seconde a ses couleurs modifiées — elle est plus saturée, plus claire, comme prise sous un éclairage différent. On demande alors au modèle de reconnaître qu’il s’agit du même chat malgré ces différences apparentes.

En même temps, on lui montre des photos de chiens, de voitures, de fleurs et de bâtiments, et on lui dit implicitement : « Tout ça, c’est différent. Ces images ne représentent pas le même concept. »

Progressivement, au fil de millions d’exemples, le modèle apprend à discerner ce qui fait l’essence profonde d’un objet visuel, au-delà de l’angle de prise de vue, de la lumière ambiante, du recadrage ou des variations chromatiques. Il capture des invariants sémantiques — des caractéristiques qui définissent un chat, un chien, une voiture, indépendamment des circonstances superficielles de leur représentation visuelle.

Cette analogie n’est pas éloignée de la manière dont le cerveau humain apprend à reconnaître les objets dès la petite enfance, bien avant qu’on ne nous apprenne les noms des choses. Les nourrissons développent leur compréhension du monde visuel en observant les mêmes objets sous différents angles, différentes lumières, différentes distances — exactement le principe que SimCLR formalise mathématiquement.

C’est cette intuition simple mais profonde qui rend SimCLR si puissant : pas besoin de mécanismes complexes de mémoire, de prédiction d’exemples futurs ou de distillation entre modèles. Juste un principe de contraste pur, appliqué de manière répétée et à grande échelle. Le modèle apprend progressivement ce qui fait l’essence d’un objet visuel, au-delà de l’angle, de la lumière ou du recadrage.

Implémentation Complète en Python avec PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import transforms, models, datasets
from torch.utils.data import DataLoader
import numpy as np


# ============================================================
# 1. Augmentations de données (vue par échantillon)
# ============================================================
class SimCLRTransform:
    """Deux vues augmentées stochastiques pour SimCLR."""

    def __init__(self, size=96):
        self.transform = transforms.Compose([
            transforms.RandomResizedCrop(
                size=size,
                scale=(0.2, 1.0),
                ratio=(0.75, 1.33)
            ),
            transforms.RandomHorizontalFlip(p=0.5),
            transforms.ColorJitter(
                brightness=0.8,
                contrast=0.8,
                saturation=0.8,
                hue=0.2
            ),
            transforms.RandomGrayscale(p=0.2),
            transforms.RandomApply(
                [transforms.GaussianBlur(kernel_size=5, sigma=(0.1, 2.0))],
                p=0.5
            ),
            transforms.ToTensor(),
            transforms.Normalize(
                mean=[0.4914, 0.4822, 0.4465],
                std=[0.2470, 0.2435, 0.2616]
            )
        ])

    def __call__(self, x):
        xi = self.transform(x)
        xj = self.transform(x)
        return xi, xj


# ============================================================
# 2. Modèle SimCLR : Encodeur + Projection Head
# ============================================================
class ProjectionHead(nn.Module):
    """Petit MLP à deux couches pour la projection."""

    def __init__(self, input_dim=2048, hidden_dim=2048, output_dim=256):
        super().__init__()
        self.projection = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(inplace=True),
            nn.Linear(hidden_dim, output_dim)
        )

    def forward(self, x):
        return self.projection(x)


class SimCLRModel(nn.Module):
    """Modèle SimCLR complet : ResNet + Projection Head."""

    def __init__(self, projection_dim=256, base_model=None):
        super().__init__()
        if base_model is None:
            resnet = models.resnet50(weights=None)
        else:
            resnet = base_model
        # Retirer la couche de classification
        self.feature_dim = resnet.fc.in_features
        resnet.fc = nn.Identity()
        self.encoder = resnet
        self.projector = ProjectionHead(
            input_dim=self.feature_dim,
            hidden_dim=self.feature_dim,
            output_dim=projection_dim
        )

    def forward(self, x):
        z = self.encoder(x)
        h = self.projector(z)
        # Normalisation L2 pour la similarité cosinus
        h = F.normalize(h, dim=1)
        return z, h


# ============================================================
# 3. Perte NT-Xent (Normalized Temperature-scaled Cross-Entropy)
# ============================================================
class NTXentLoss(nn.Module):
    """Fonction de perte contrastive NT-Xent."""

    def __init__(self, temperature=0.5):
        super().__init__()
        self.temperature = temperature

    def forward(self, z_i, z_j):
        batch_size = z_i.size(0)
        # Concaténer les deux vues
        representations = torch.cat([z_i, z_j], dim=0)  # [2N, D]

        # Matrice de similarité cosinus
        sim_matrix = torch.matmul(
            representations, representations.T
        ) / self.temperature  # [2N, 2N]

        # Masque pour exclure la diagonale (similarité avec soi-même)
        mask = torch.eye(2 * batch_size, dtype=torch.bool, device=z_i.device)
        sim_matrix.masked_fill_(mask, -float('inf'))

        # Labels : pour chaque échantillon i, le positif est (i + batch_size) % (2N)
        labels = torch.cat([
            torch.arange(batch_size, 2 * batch_size),
            torch.arange(0, batch_size)
        ]).to(z_i.device)

        loss = F.cross_entropy(sim_matrix, labels)
        return loss


# ============================================================
# 4. Boucle d'Entraînement Auto-Supervisé
# ============================================================
def train_simclr(model, dataloader, num_epochs=50, lr=1e-3, device='cuda'):
    """Entraînement SimCLR complet sur un jeu de données."""
    model = model.to(device)
    optimizer = torch.optim.Adam(
        model.parameters(), lr=lr, weight_decay=1e-6
    )
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=num_epochs * len(dataloader)
    )
    criterion = NTXentLoss(temperature=0.5)

    for epoch in range(num_epochs):
        model.train()
        epoch_loss = 0.0

        for (xi, xj), _ in dataloader:
            xi, xj = xi.to(device), xj.to(device)

            # Obtenir les projections pour les deux vues
            _, hi = model(xi)
            _, hj = model(xj)

            # Calculer la perte contrastive
            loss = criterion(hi, hj)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            scheduler.step()

            epoch_loss += loss.item()

        avg_loss = epoch_loss / len(dataloader)
        print(f"Époque {epoch+1}/{num_epochs} — Perte : {avg_loss:.4f}")

    return model


# ============================================================
# 5. Évaluation par Fine-Tuning Linéaire sur CIFAR-10
# ============================================================
def linear_evaluation(encoder, cifar10_train, cifar10_val, device='cuda'):
    """Évaluation de la qualité des représentations par un classifieur linéaire."""
    encoder.eval()
    encoder.requires_grad_(False)

    def extract_features(dataloader):
        features, labels_list = [], []
        with torch.no_grad():
            for images, labels in dataloader:
                images = images.to(device)
                z, _ = encoder(images)
                features.append(z.cpu())
                labels_list.append(labels)
        return torch.cat(features), torch.cat(labels_list)

    train_features, train_labels = extract_features(cifar10_train)
    val_features, val_labels = extract_features(cifar10_val)

    # Entraîner un classifieur linéaire
    num_classes = 10
    linear = nn.Linear(train_features.size(1), num_classes).to(device)
    optimizer = torch.optim.SGD(linear.parameters(), lr=0.1, momentum=0.9)
    criterion = nn.CrossEntropyLoss()

    for epoch in range(50):
        linear.train()
        perm = torch.randperm(train_features.size(0))
        train_features = train_features[perm]
        train_labels = train_labels[perm]

        batch_size = 256
        for i in range(0, len(train_features), batch_size):
            batch_feat = train_features[i:i+batch_size].to(device)
            batch_lbl = train_labels[i:i+batch_size].to(device)
            logits = linear(batch_feat)
            loss = criterion(logits, batch_lbl)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        linear.eval()
        with torch.no_grad():
            val_logits = linear(val_features.to(device))
            pred = val_logits.argmax(dim=1)
            acc = (pred == val_labels.to(device)).float().mean().item()
            if epoch % 10 == 0:
                print(f"Précision linéaire (ép. {epoch+1}) : {acc*100:.1f}%")

    return acc


# ============================================================
# 6. Évaluation k-NN (sans entraînement supplémentaire)
# ============================================================
def knn_evaluation(encoder, cifar10_train, cifar10_test, k=200, device='cuda'):
    """Évaluation par k-plus-proches-voisins sur les représentations apprises."""
    encoder.eval()

    def extract(dataloader):
        feats, labs = [], []
        with torch.no_grad():
            for images, labels in dataloader:
                z, _ = encoder(images.to(device))
                feats.append(z.cpu())
                labs.append(labels)
        return torch.cat(feats), torch.cat(labs)

    train_f, train_l = extract(cifar10_train)
    test_f, test_l = extract(cifar10_test)

    train_f = F.normalize(train_f, dim=1)
    test_f = F.normalize(test_f, dim=1)

    correct = 0
    chunk_size = 256
    for i in range(0, test_f.size(0), chunk_size):
        batch = test_f[i:i+chunk_size].to(device)
        sim = torch.matmul(batch, train_f.T.to(device))
        _, top_k_idx = sim.topk(k, dim=1)
        top_k_labels = train_l[top_k_idx]
        mode_labels, _ = torch.mode(top_k_labels, dim=1)
        correct += (mode_labels.cpu() == test_l[i:i+chunk_size]).sum().item()

    accuracy = correct / test_f.size(0)
    print(f"Précision k-NN (k={k}) : {accuracy*100:.1f}%")
    return accuracy

Guide des Hyperparamètres Critiques

Taille du Lot (batch_size)

La taille du lot est sans doute l’hyperparamètre le plus influent sur la qualité des représentations. Plus le lot est grand, plus le nombre d’exemples négatifs est important, et plus le contraste est informatif. Les résultats publiés dans l’article original utilisent des tailles de lot de 4096 à 8192 images. Pour ceux dont les ressources sont limitées, des techniques comme l’accumulation de gradients ou la mémoire de files d’attente (memory bank) peuvent atténuer partiellement ce problème, bien que les résultats ne soient pas strictement équivalents.

Température (tau)

Le paramètre de température $\tau$ contrôle la distribution des similarités. Une valeur trop élevée ($\tau > 1.0$) rend la fonction de perte trop plate : le modèle ne distingue pas suffisamment les exemples positifs des négatifs. Une valeur trop basse ($\tau < 0.1$) rend la perte trop sensible et peut causer des instabilités numériques. La valeur recommandée dans l’article original est $\tau = 0.5$, qui offre un bon compromis entre sélectivité et stabilité dans la plupart des scénarios.

Dimension de Projection

La dimension de sortie de la projection head influence directement la capacité du modèle à discriminer les paires positives des négatives. Une dimension de 128 à 256 est suffisante pour la plupart des applications. Des dimensions supérieures (512, 1024) peuvent apporter des gains marginaux mais au prix d’un coût computationnel accru.

Stratégie d’Augmentations

Le choix des augmentations est fondamental. L’article original identifie deux transformations comme particulièrement essentielles :

• Recadrage et changement d’échelle aléatoires (RandomResizedCrop) : force le modèle à reconnaître les objets quelle que soit leur position et leur taille dans l’image. Sans cette augmentation, les performances chutent de manière significative.
• Distorsion des couleurs (ColorJitter) : empêche le modèle de s’appuyer sur des indices chromatiques superficiels, le contraignant à extraire des caractéristiques structurelles plus profondes.

Le flou gaussien, bien qu’utile, est moins critique. La conversion en niveaux de gris et la réflexion horizontale sont des ajouts bénéfiques mais secondaires.

Avantages et Limites de SimCLR

Avantages

• Simplicité conceptuelle remarquable : contrairement à d’autres méthodes d’apprentissage auto-supervisé qui nécessitent des architectures complexes (mémoire, distillation, prédiction d’exemples futurs), SimCLR repose sur une idée simple et intuitive — le contraste entre vues augmentées.
• Excellentes performances en transfert : les représentations apprises par SimCLR se transfèrent remarquablement bien à des tâches de classification, de détection d’objets et de segmentation sémantique.
• Scalabilité exceptionnelle : la qualité des représentations s’améliore continuellement avec la taille du modèle et du jeu de données, sans signe de saturation prématurée.
• Aucune annotation nécessaire : contrairement aux approches supervisées traditionnelles, SimCLR n’exige aucune étiquette pour la phase d’apprentissage préliminaire.

Limites

• Dépendance à la taille du lot : les meilleurs résultats nécessitent des lots de plusieurs milliers d’images, ce qui exige une mémoire GPU considérable ou des techniques d’optimisation avancées comme le mélange de données distribuées (DistributedDataParallel).
• Coût computationnel élevé : le traitement de deux vues augmentées pour chaque image double le coût de calcul par rapport à un entraînement standard. De plus, la grande taille du lot augmente les besoins en communication inter-GPU.
• Sensibilité aux augmentations inappropriées : certaines tâches (images médicales, imagerie satellite) ne peuvent pas supporter certaines augmentations standard comme la distorsion des couleurs. L’adaptation des stratégies d’augmentation est alors nécessaire.
• Absence de mécanisme de mémoire : chaque lot est indépendant. Des techniques comme MoCo ou BYOL, qui maintiennent une mémoire d’exemples précédents, peuvent surpasser SimCLR dans certains contextes.

Quatre Cas d’Usage Concrets

1. Entraînement Préliminaire pour la Classification Médicale

En imagerie médicale (radiographies, IRM, scanners), les données étiquetées sont extrêmement rares et coûteuses à obtenir — un radiologue expérimenté doit annoter chaque image manuellement. SimCLR permet d’entraîner un encodeur sur des dizaines de milliers d’images non étiquetées, puis d’effectuer un fine-tuning avec seulement quelques centaines d’exemples annotés. Cette approche réduit considérablement le besoin d’annotation tout en atteignant des performances comparables à un entraînement entièrement supervisé.

2. Détection d’Anomalies dans la Vision Industrielle

Dans un contexte de contrôle qualité industriel, les images de produits défectueux sont rares et difficiles à collecter systématiquement. SimCLR peut être entraîné sur des images de produits conformes uniquement. Lorsqu’un produit défectueux est présenté, sa représentation augmentée ne correspondra pas aux motifs appris — le score de similarité sera faible, signalant ainsi une anomalie potentielle. Cette méthode est particulièrement efficace pour détecter des défauts non catalogués au préalable.

3. Apprentissage de Représentations Vidéo

En appliquant SimCLR à des cadres vidéo traités comme des images indépendantes, on peut apprendre des représentations spatiales puissantes. Ces représentations servent ensuite de base à des modèles vidéo qui intègrent la dimension temporelle. Cette approche est utilisée dans la surveillance intelligente, l’analyse sportive automatisée, et la reconnaissance d’actions humaines.

4. Recherche d’Images par Similarité Sémantique

Les représentations apprises par SimCLR organisent naturellement les images dans un espace vectoriel où les images sémantiquement similaires sont proches les unes des autres. Cela permet de construire des systèmes de recherche d’images où l’utilisateur soumet une image requête et le système retourne les images les plus similaires en termes de contenu sémantique, sans aucune annotation textuelle préalable. C’est particulièrement utile pour les bibliothèques d’images, les galeries d’art numériques et les plateformes de commerce en ligne.

Voir Aussi

• Maîtrisez le Mahjong avec Python : Guide Complet pour Développeurs et Enthousiastes
• Maîtriser les Graphes en Grille avec Python : Guide Complet et Astuces d’Optimisation