Transformers de Phrase : Révolution Multimodale et Reranking

Comprendre les Modèles Multimodaux

Les modèles d'embedding traditionnels se concentrent sur la conversion du texte en vecteurs de taille fixe. Cependant, les modèles d'embedding multimodal vont plus loin en intégrant des entrées provenant de diverses modalités telles que le texte, les images, l'audio ou la vidéo dans un espace d'embedding commun. Cette approche permet de comparer une requête textuelle avec des documents d'images ou inversement, en utilisant des fonctions de similarité déjà connues.

Les modèles de reranking traditionnels, souvent appelés Cross Encoder, calculent des scores de pertinence entre des paires de textes. Les rerankers multimodaux, quant à eux, peuvent évaluer des paires où l'un ou les deux éléments sont des images, des documents texte-image combinés ou d'autres modalités. Cela ouvre des possibilités telles que la comparaison d'une requête textuelle avec des documents d'images, la recherche de clips vidéo correspondant à une description ou la construction de pipelines RAG qui fonctionnent à travers les modalités.

Pour utiliser ces modèles multimodaux, certaines dépendances supplémentaires sont nécessaires. Par exemple, pour les images, vous pouvez installer les extras requis avec pip install -U "sentence-transformers[image]". De même, pour les modalités audio et vidéo, des commandes similaires sont disponibles. Les modèles basés sur VLM, comme Qwen3-VL-2B, nécessitent un GPU avec au moins 8 Go de VRAM. Pour les variantes plus avancées, comme les modèles 8B, environ 20 Go de VRAM sont nécessaires. Si vous ne disposez pas d'un GPU local, il est conseillé d'utiliser un service de GPU dans le cloud ou Google Colab. Sur un CPU, ces modèles seront extrêmement lents, et il est préférable d'utiliser des modèles uniquement textuels ou CLIP pour l'inférence sur CPU.

Fonctionnement des Modèles d'Embedding Multimodal

Charger un modèle d'embedding multimodal est similaire au chargement d'un modèle uniquement textuel. Par exemple, avec la bibliothèque sentence-transformers, vous pouvez charger le modèle "Qwen/Qwen3-VL-Embedding-2B". Certains modèles peuvent nécessiter un argument de révision si les demandes d'intégration pour le modèle sont encore en attente. Une fois qu'elles sont fusionnées, vous pourrez les charger sans spécifier de révision.

Le modèle détecte automatiquement les modalités qu'il prend en charge, donc aucune configuration supplémentaire n'est nécessaire. Vous pouvez consulter les paramètres du processeur et du modèle si vous souhaitez contrôler des éléments comme la résolution d'image ou la précision du modèle. Avec un modèle multimodal chargé, model.encode() accepte des images en plus du texte. Les images peuvent être fournies sous forme d'URLs, de chemins de fichiers locaux ou d'objets PIL Image. Voici un exemple d'utilisation :

from sentence_transformers import SentenceTransformer
model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B")
img_embeddings = model.encode([
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])
print(img_embeddings.shape)

Calcul de la Similarité Cross-Modal

Il est possible de calculer des similarités entre des embeddings de texte et d'image, car le modèle les mappe tous deux dans le même espace. Par exemple :

from sentence_transformers import SentenceTransformer
model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B")
img_embeddings = model.encode([
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])
text_embeddings = model.encode([
    "A green car parked in front of a yellow building",
    "A red car driving on a highway",
    "A bee on a pink flower",
    "A wasp on a wooden table",
])
similarities = model.similarity(text_embeddings, img_embeddings)
print(similarities)

Dans cet exemple, "A green car parked in front of a yellow building" est le plus similaire à l'image de la voiture (0.51), et "A bee on a pink flower" est le plus similaire à l'image de l'abeille (0.67). Les négatifs difficiles, comme "A red car driving on a highway" et "A wasp on a wooden table", reçoivent correctement des scores plus bas.

Il est à noter que même les meilleurs scores de correspondance (0.51, 0.67) ne sont pas très proches de 1.0. Cela est dû à l'écart de modalité : les embeddings provenant de différentes modalités ont tendance à se regrouper dans des régions séparées de l'espace. Les similarités cross-modal sont généralement plus faibles que celles au sein de la même modalité (par exemple, texte-texte), mais l'ordre relatif est préservé, assurant ainsi une récupération efficace.

Encodage des Requêtes et Documents

Pour les tâches de récupération, les méthodes encode_query() et encode_document() sont recommandées. De nombreux modèles de récupération préfixent différentes instructions en fonction de si l'entrée est une requête ou un document, similaire à la façon dont les modèles de chat pourraient appliquer différents prompts système en fonction de l'objectif. Les auteurs de modèles peuvent spécifier leurs prompts dans la configuration du modèle, et encode_query() / encode_document() chargent et appliquent automatiquement le bon :

• encode_query() utilise le prompt "query" du modèle (si disponible) et définit task="query".
• encode_document() utilise le premier prompt disponible parmi "document", "passage" ou "corpus", et définit task="document".

En coulisses, les deux sont des wrappers légers autour de encode(), ils gèrent simplement la sélection des prompts pour vous. Voici à quoi ressemble la récupération cross-modal :

from sentence_transformers import SentenceTransformer
model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B")
query_embeddings = model.encode_query([
    "Find me a photo of a vehicle parked near a building",
    "Show me an image of a pollinating insect",
])
doc_embeddings = model.encode_document([
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])
similarities = model.similarity(query_embeddings, doc_embeddings)
print(similarities)

Ces méthodes acceptent les mêmes types d'entrée que encode() (images, URLs, dictionnaires multimodaux, etc.) et passent les mêmes paramètres. Pour les modèles sans prompts spécialisés pour les requêtes/documents, elles se comportent de manière identique à encode().

Les Modèles de Reranking Multimodal

Les modèles de reranking multimodal (CrossEncoder) évaluent la pertinence entre des paires d'entrées, où chaque élément peut être du texte, une image, de l'audio, de la vidéo ou une combinaison. Ils ont tendance à surpasser les modèles d'embedding en termes de qualité, mais sont plus lents car ils traitent chaque paire individuellement. Les rerankers multimodaux pré-entraînés actuellement disponibles se concentrent sur les entrées texte et image, mais l'architecture prend en charge toute modalité que le modèle sous-jacent peut gérer.

Classement des Documents à Modalités Mixtes

La méthode rank() évalue et classe une liste de documents par rapport à une requête, prenant en charge des modalités mixtes :

from sentence_transformers import CrossEncoder
model = CrossEncoder("Qwen/Qwen3-VL-Reranker-2B")
query = "A green car parked in front of a yellow building"
documents = [
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
    "A vintage Volkswagen Beetle painted in bright green sits in a driveway.",
    {"text": "A car in a European city", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg"},
]
rankings = model.rank(query, documents)
for rank in rankings:
    print(f"{rank['score']:.4f}\t(document {rank['corpus_id']})")

Le reranker identifie correctement l'image de la voiture (document 0) comme le résultat le plus pertinent, suivi du document combiné texte+image sur une voiture dans une ville européenne (document 3). L'image de l'abeille (document 1) obtient le score le plus bas.

Gardez à l'esprit que l'écart de modalité peut influencer les scores absolus : les scores de paires texte-image peuvent occuper une plage différente de celle des paires texte-texte ou image-image.

Vous pouvez également vérifier quelles modalités un reranker prend en charge en utilisant modalities et supports(), tout comme avec les modèles d'embedding :

print(model.modalities)
print(model.supports("image"))
print(model.supports(("image", "text")))

Prédiction des Scores de Paires

Vous pouvez également utiliser predict() pour obtenir des scores de pertinence bruts pour des paires d'entrées spécifiques :

from sentence_transformers import CrossEncoder
model = CrossEncoder("jinaai/jina-reranker-m0", trust_remote_code=True)
scores = model.predict([
    ("A green car", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg"),
    ("A bee on a flower", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"),
    ("A green car", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"),
])

Récupérer et Reranker

Un schéma courant consiste à utiliser un modèle d'embedding pour une récupération initiale rapide, puis à affiner les meilleurs résultats avec un reranker :

from sentence_transformers import SentenceTransformer, CrossEncoder
embedder = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B")
query = "revenue growth chart"
query_embedding = embedder.encode_query(query)

Ce processus permet d'optimiser la qualité des résultats de recherche en combinant la rapidité des modèles d'embedding avec la précision des rerankers.