Accueil › Glossaire › CLIP

CLIP (Contrastive Language-Image Pre-training)

CLIP est un modèle multimodal développé par OpenAI qui entraîne conjointement un encodeur d’images et un encodeur de texte à aligner leurs représentations dans un espace vectoriel partagé via un objectif contrastif. Entraîné sur 400 millions de paires image-texte du web, CLIP permet la classification d’images zero-shot : il égale ResNet-50 sur ImageNet sans avoir vu un seul exemple étiqueté du dataset.

Pourquoi CLIP est une révolution

Avant CLIP, la vision par ordinateur fonctionnait selon un paradigme rigide : vous définissiez un ensemble fixe de classes (chat, chien, voiture…), vous assembliez un dataset étiqueté, et vous entraîniez un classificateur. Le modèle ne pouvait reconnaître que les catégories vues pendant l’entraînement. Ajouter une nouvelle classe nécessitait de nouvelles données et un réentraînement.

CLIP casse ce paradigme en apprenant directement à partir de descriptions en langage naturel. Au lieu de prédire « classe n°42 », il apprend à associer une image à un texte descriptif. À l’inférence, vous pouvez lui donner n’importe quel ensemble de descriptions textuelles (« a photo of a cat », « a photo of a dog », « a photo of a flamingo ») et le modèle classifie l’image dans la catégorie la plus sémantiquement proche. C’est la classification zero-shot : aucun exemple étiqueté n’est nécessaire pour la tâche cible.

Le résultat est spectaculaire : CLIP ViT-L/14 égale la performance d’un ResNet-50 supervisé sur ImageNet (76,2 % vs. 76,1 % top-1), sans avoir vu un seul des 1,28 million d’exemples ImageNet pendant son entraînement. Et contrairement à un ResNet supervisé, CLIP se transfère à des dizaines d’autres benchmarks sans modification.

Architecture de CLIP

Le principe du double encodeur

CLIP est constitué de deux réseaux indépendants qui projettent leurs entrées respectives dans un espace vectoriel commun :

Encodeur image. OpenAI a expérimenté avec des ResNet modifiés (RN50, RN101, RN50×4, RN50×16, RN50×64) et des Vision Transformers (ViT-B/32, ViT-B/16, ViT-L/14). Les ViT se sont révélés 3× plus efficaces en termes de compute. Le meilleur modèle utilise un ViT-L/14 (~428 M paramètres) avec des patches de 14×14 pixels. L’image est découpée en patches, chaque patch est projeté linéairement, puis la séquence passe dans un encodeur Transformer. La représentation finale est le vecteur du token [CLS], projeté dans l’espace partagé via une couche linéaire.

Encodeur texte. Un Transformer de 63 M paramètres (12 couches, 512 dimensions, 8 têtes d’attention), architecturalement similaire à GPT-2. Le texte est tokenizé en BPE (vocabulaire de 49 152 tokens), encadré par des tokens [SOS] et [EOS], avec une longueur de contexte de 77 tokens. L’activation du token [EOS] à la dernière couche, après LayerNorm et projection linéaire, donne la représentation textuelle.

Les deux encodeurs projettent dans un espace de même dimension (512 pour ViT-B, 768 pour ViT-L), où la similarité cosinus mesure la proximité sémantique entre une image et un texte.

L’objectif contrastif

L’entraînement utilise un objectif d’apprentissage contrastif (InfoNCE loss). Pour un batch de N paires image-texte, CLIP calcule la matrice N×N de similarités cosinus entre tous les embeddings d’images et de textes. L’objectif est de maximiser la similarité des N paires correctes (la diagonale) et de minimiser celle des N²-N paires incorrectes.

Concrètement, c’est une cross-entropy symétrique : pour chaque image, le texte correct doit être le plus similaire parmi les N textes du batch ; pour chaque texte, l’image correcte doit être la plus similaire parmi les N images. Le paramètre de température τ (appris pendant l’entraînement) contrôle la « dureté » de la distribution.

Avec un batch size de 32 768, le modèle voit environ 1 milliard de paires négatives par epoch, ce qui explique la richesse des représentations apprises.

Les données d’entraînement : WebImageText

CLIP est entraîné sur WebImageText (WIT), un dataset propriétaire de 400 millions de paires image-texte collectées depuis internet. Le processus de curation part de 500 000 requêtes textuelles (mots fréquents de Wikipedia, bigrammes à forte information mutuelle, noms d’articles Wikipedia, synsets WordNet) et récupère jusqu’à 20 000 paires par requête.

Ce dataset n’a jamais été rendu public, ce qui a motivé la communauté à créer des alternatives ouvertes comme LAION-400M, LAION-2B et DataComp-1B pour reproduire et étendre les résultats de CLIP.

La classification zero-shot en pratique

Le mécanisme de classification zero-shot de CLIP est étonnamment simple :

1. Définissez vos classes sous forme de phrases : « a photo of a cat », « a photo of a dog », « a photo of a car ».

2. Passez chaque phrase dans l’encodeur texte pour obtenir un vecteur par classe.

3. Passez l’image à classifier dans l’encodeur image pour obtenir son vecteur.

4. Calculez la similarité cosinus entre le vecteur image et chaque vecteur de classe.

5. La classe avec la plus haute similarité est la prédiction.

La formulation du prompt textuel (prompt engineering) a un impact significatif sur les performances. « a photo of a {class} » fonctionne mieux que simplement « {class} » car cela réduit l’ambiguïté (le mot « crane » peut être un oiseau ou une grue de chantier). L’utilisation de templates multiples (« a photo of a {class} », « a good photo of a {class} », « a drawing of a {class} ») avec moyennage des embeddings améliore encore les résultats.

import torch
import clip
from PIL import Image

# Charger le modèle
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-L/14", device=device)

# Préparer image et textes
image = preprocess(Image.open("photo.jpg")).unsqueeze(0).to(device)
text = clip.tokenize([
    "a photo of a cat",
    "a photo of a dog",
    "a photo of a bird"
]).to(device)

# Calculer les similarités
with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)
    
    # Normaliser et calculer la similarité
    image_features /= image_features.norm(dim=-1, keepdim=True)
    text_features /= text_features.norm(dim=-1, keepdim=True)
    similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1)

print(similarity)  # Probabilités par classe

Les modèles CLIP et leurs variantes

Modèles OpenAI originaux

OpenCLIP : la reproduction open source

OpenCLIP (LAION) est une implémentation open source de CLIP qui permet d’entraîner des modèles CLIP sur n’importe quel dataset. Les modèles OpenCLIP entraînés sur LAION-2B et DataComp-1B surpassent les modèles originaux d’OpenAI. Le modèle ViT-G/14 entraîné sur LAION-2B atteint 80,1 % zero-shot ImageNet, soit +4 points au-dessus du meilleur modèle d’OpenAI.

import open_clip

# Charger un modèle OpenCLIP
model, _, preprocess = open_clip.create_model_and_transforms(
    "ViT-L-14",
    pretrained="datacomp_xl_s13b_b90k"
)
tokenizer = open_clip.get_tokenizer("ViT-L-14")

# Lister tous les modèles disponibles
available = open_clip.list_pretrained()
print(f"{len(available)} modèles pré-entraînés disponibles")

Variantes notables de CLIP

SigLIP (Google). Remplace la softmax contrastive par une loss sigmoïde par paire, éliminant le besoin de communication entre GPUs pour les grands batch sizes. Plus efficace à entraîner que CLIP standard, avec des performances comparables.

MetaCLIP (Meta, ICLR 2024). Se concentre sur la curation des données plutôt que sur l’architecture. En appliquant l’algorithme de curation de CLIP à CommonCrawl, MetaCLIP surpasse CLIP avec les mêmes données (70,8 % vs. 68,3 % sur ViT-B). Avec un ViT-bigG, MetaCLIP atteint 82,1 % zero-shot ImageNet.

EVA-CLIP (BAAI). Utilise des encodeurs visuels EVA (ViT pré-entraîné avec masked image modeling) comme initialisation, puis l’entraînement contrastif CLIP. Les représentations MIM donnent un meilleur point de départ que l’initialisation aléatoire.

MobileCLIP (Apple, CVPR 2024). Optimise CLIP pour le déploiement mobile via la distillation multi-modale. MobileCLIP-B atteint 77,2 % zero-shot ImageNet tout en étant compatible avec les NPU mobiles.

ALIGN (Google). Entraîné sur 1,8 milliard de paires image-texte non filtrées, montrant que la quantité de données brutes peut compenser un filtrage moins strict.

Applications de CLIP

Classification zero-shot

L’usage le plus direct. CLIP classifie des images dans des catégories arbitraires définies par du texte, sans entraînement additionnel. C’est particulièrement utile quand les classes changent fréquemment (modération de contenu, catalogage dynamique) ou quand les données annotées sont rares.

Recherche image-texte (retrieval)

Les embeddings CLIP permettent de chercher des images à partir de descriptions textuelles (et inversement). C’est le moteur derrière de nombreux systèmes de recherche d’images : vous tapez « sunset over mountains » et le système retourne les images dont l’embedding est le plus proche de l’embedding du texte.

Guidage de la génération d’images

CLIP est un composant essentiel des systèmes de génération d’images. DALL-E 2 utilise CLIP pour encoder le prompt textuel. Stable Diffusion utilise l’encodeur texte de CLIP (ou OpenCLIP) pour convertir le prompt en embeddings qui guident le processus de diffusion. Sans CLIP, la génération d’images à partir de texte serait considérablement moins performante.

Backbone visuel pour les modèles vision-langage

La plupart des vision-language models récents utilisent un encodeur visuel CLIP ou dérivé de CLIP. LLaVA, BLIP-2, Flamingo, et même les modes multimodaux des LLM commerciaux (GPT-5.4, Claude, Gemini) s’appuient sur des encodeurs visuels entraînés de manière contrastive. L’encodeur CLIP produit des représentations visuelles déjà alignées avec le langage, ce qui facilite l’intégration avec un LLM.

Segmentation ouverte

Des architectures comme CLIPSeg, GroupViT et OpenSeg exploitent les embeddings CLIP pour la segmentation sémantique à vocabulaire ouvert. Plutôt que de segmenter dans un ensemble fixe de classes, ces modèles segmentent des régions correspondant à n’importe quelle description textuelle.

Filtrage de datasets

CLIP score (la similarité cosinus entre l’embedding d’une image et celui de sa légende) est devenu un outil standard de filtrage de qualité pour les datasets image-texte. LAION-5B, DataComp et d’autres grands datasets utilisent le CLIP score pour éliminer les paires image-texte de mauvaise qualité.

Limites de CLIP

Faible sur les tâches fines. CLIP a du mal à distinguer des sous-catégories très proches (espèces d’oiseaux, modèles de voitures). Sa supervision textuelle est trop grossière pour ces distinctions fines. Un modèle supervisé fine-tuné sur un dataset spécialisé sera toujours plus performant pour ces cas.

Comptage et raisonnement spatial. CLIP ne sait pas compter les objets dans une image ni raisonner sur leurs relations spatiales (« le chat est au-dessus du chien »). L’objectif contrastif capture la co-occurrence sémantique, pas la structure compositionnelle de la scène.

Sensibilité au prompt. Les performances zero-shot varient significativement selon la formulation du prompt. « a photo of a dog » et « dog » donnent des résultats différents. Un ensemble de templates avec moyennage améliore la robustesse, mais le choix du prompt reste un hyperparamètre important.

Biais sociétaux. CLIP absorbe les biais présents dans les 400 millions de paires image-texte du web. Des études ont montré des biais de genre, de race et culturels dans les classifications CLIP, ce qui nécessite une attention particulière en production.

Pas de compréhension profonde. CLIP aligne des représentations globales d’images et de textes, mais ne modélise pas les relations fines entre régions d’image et mots spécifiques. Pour le visual grounding (localiser précisément un objet décrit par du texte), des modèles dédiés sont nécessaires.

CLIP vs. les autres modèles multimodaux

Verdict. CLIP reste le choix n°1 pour le retrieval image-texte et la classification zero-shot grâce à sa vitesse et sa simplicité. Pour les tâches nécessitant une compréhension profonde (VQA, captioning), des modèles comme BLIP-2 ou les VLM connectés à des LLM sont plus adaptés. Pour les features visuelles pures (sans alignement texte), DINOv2 produit des représentations de meilleure qualité. L’idéal est souvent de combiner CLIP avec d’autres modèles : par exemple, utiliser CLIP pour le retrieval et un LLM pour la génération de texte.

Utiliser CLIP en pratique

Quel modèle CLIP choisir ?

Via Hugging Face Transformers

from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")

inputs = processor(
    text=["a photo of a cat", "a photo of a dog"],
    images=image,
    return_tensors="pt",
    padding=True
)

outputs = model(**inputs)
logits_per_image = outputs.logits_per_image
probs = logits_per_image.softmax(dim=1)
print(probs)

Extraire et stocker des embeddings

Pour un système de retrieval en production, pré-calculez les embeddings de votre base d’images, stockez-les dans une base vectorielle (Pinecone, Milvus, Qdrant, FAISS), puis calculez l’embedding du texte de recherche à la volée et faites une recherche nearest-neighbor.

import torch
import clip

model, preprocess = clip.load("ViT-L/14")

# Encoder une image
image_input = preprocess(image).unsqueeze(0)
with torch.no_grad():
    image_embedding = model.encode_image(image_input)
    image_embedding /= image_embedding.norm(dim=-1, keepdim=True)

# Stocker image_embedding (numpy array de 768 dimensions)
# dans votre base vectorielle

# À la recherche : encoder le texte
text_input = clip.tokenize(["sunset over mountains"])
with torch.no_grad():
    text_embedding = model.encode_text(text_input)
    text_embedding /= text_embedding.norm(dim=-1, keepdim=True)

# Rechercher les images les plus proches dans la base

Impact de CLIP

CLIP est l’un des travaux les plus influents de la décennie en IA. Son impact se mesure sur plusieurs axes.

Génération d’images. Sans CLIP comme encodeur textuel, les modèles comme Stable Diffusion, DALL-E 3 et Midjourney n’existeraient pas sous leur forme actuelle. L’alignement texte-image appris par CLIP est la brique qui permet de contrôler la génération par des prompts en langage naturel.

Modèles de fondation multimodaux. La philosophie CLIP (apprendre des représentations à partir de supervision textuelle web-scale) a influencé toute la génération de modèles multimodaux : LLaVA, Flamingo, BLIP, CoCa, et les modes vision des LLM commerciaux.

Démocratisation via OpenCLIP. La reproduction open source de CLIP par LAION a permis à toute la communauté de recherche d’entraîner, fine-tuner et adapter des modèles CLIP, accélérant l’innovation dans le domaine.

Paradigme zero-shot. CLIP a normalisé l’évaluation zero-shot comme métrique standard. La capacité à généraliser à des tâches non vues est devenue un critère central de qualité pour les modèles de fondation.