Embeddings : transformer du texte en vecteurs pour la recherche sémantique

Comment un ordinateur peut-il comprendre que “voiture” et “automobile” sont des synonymes ? Grâce aux embeddings : des représentations numériques qui capturent le sens des mots et des phrases. Ce guide vous explique comment les utiliser pour construire un moteur de recherche sémantique.

À la fin de ce guide, vous saurez générer des embeddings, calculer des similarités et choisir le bon modèle pour votre projet.

Qu’est-ce qu’un embedding ?

Un embedding est un vecteur de nombres (par exemple 384 dimensions) qui représente le sens d’un texte dans un espace mathématique.

"Ansible gère les serveurs"     →  [0.12, -0.34, 0.78, ..., 0.56]
"Kubernetes orchestre les pods" →  [-0.23, 0.45, 0.12, ..., 0.89]
"La recette du gâteau"          →  [0.67, 0.23, -0.45, ..., -0.12]

L’idée clé : les textes au sens similaire ont des vecteurs proches. Les textes différents ont des vecteurs éloignés.

Espace vectoriel (simplifié en 2D) :

     DevOps ────┬──── Ansible
                │      │
                │      ├── Kubernetes
                │      │
                └──── Docker

     Cuisine ───┬──── Gâteau
                │
                └──── Recette

Dans cet espace, “Ansible” est proche de “Kubernetes” mais loin de “Gâteau”.

Pourquoi les embeddings sont essentiels pour le RAG

Un système RAG a besoin de trouver les passages pertinents pour répondre à une question. Deux approches :

Approche	Méthode	Limite
Recherche exacte	Mots-clés (BM25, TF-IDF)	“voiture” ≠ “automobile”
Recherche sémantique	Embeddings + similarité	Comprend les synonymes et le contexte

Glissez pour voir

Exemple :

Question : "Comment gérer mes serveurs automatiquement ?"
Document : "Ansible est un outil d'automatisation IT."

Recherche exacte : ✗ (pas de mot commun)
Recherche sémantique : ✓ (sens très proche)

Prérequis

# Environnement Python 3.10+
python3 -m venv embeddings-test
source embeddings-test/bin/activate

# sentence-transformers (inclut PyTorch)
pip install sentence-transformers numpy

Première exécution

Le premier chargement d’un modèle télécharge les poids depuis Hugging Face (~100-500 Mo selon le modèle). Les exécutions suivantes utilisent le cache local.

Générer des embeddings avec sentence-transformers

La bibliothèque sentence-transformers fournit une API simple pour encoder du texte :

from sentence_transformers import SentenceTransformer

# Charger un modèle multilingue
model = SentenceTransformer("intfloat/multilingual-e5-small")

# Encoder des textes
textes = [
    "Ansible est un outil d'automatisation",
    "Docker crée des conteneurs",
    "La recette du gâteau au chocolat"
]

# Générer les embeddings
embeddings = model.encode(textes, show_progress_bar=False)

print(f"Nombre de textes : {len(embeddings)}")
print(f"Dimensions : {embeddings.shape[1]}")
print(f"Type : {embeddings.dtype}")

Résultat :

Nombre de textes : 3
Dimensions : 384
Type : float32

Chaque texte est transformé en un vecteur de 384 nombres à virgule flottante.

Les préfixes E5 : query vs passage

Les modèles E5 (comme multilingual-e5-small) utilisent des préfixes pour distinguer les requêtes des documents :

Préfixe	Usage	Exemple
query:	Question de l’utilisateur	"query: Comment installer Ansible ?"
passage:	Document à indexer	"passage: Ansible est un outil..."

Glissez pour voir

# ✗ Sans préfixe (moins précis)
embeddings = model.encode(["Comment installer Ansible ?"])

# ✓ Avec préfixes (recommandé pour E5)
query_emb = model.encode(["query: Comment installer Ansible ?"])
doc_emb = model.encode(["passage: Ansible est un outil d'automatisation..."])

Modèles sans préfixes

Tous les modèles n’utilisent pas de préfixes. Par exemple, all-MiniLM-L6-v2 n’en a pas besoin. Consultez toujours la documentation du modèle sur Hugging Face.

Mesurer la similarité entre vecteurs

Une fois les embeddings générés, il faut mesurer leur proximité. La métrique la plus utilisée est la similarité cosinus.

Similarité cosinus

La similarité cosinus mesure l’angle entre deux vecteurs :

• 1.0 = vecteurs identiques (même direction)
• 0.0 = vecteurs perpendiculaires (aucune relation)
• -1.0 = vecteurs opposés (sens contraire)

from sentence_transformers.util import cos_sim

# Trois textes avec des relations différentes
textes = [
    "Ansible automatise la configuration des serveurs",
    "Comment gérer l'infrastructure avec Ansible ?",
    "La recette du gâteau au chocolat"
]

# Avec préfixes E5
passages = [f"passage: {t}" for t in textes]
embeddings = model.encode(passages)

# Matrice de similarité
print("Matrice de similarité cosinus :")
print(cos_sim(embeddings, embeddings))

Résultat :

tensor([[1.0000, 0.9012, 0.7845],
        [0.9012, 1.0000, 0.7623],
        [0.7845, 0.7623, 1.0000]])

Lecture :

• Texte 1 ↔ Texte 2 : 0.90 (très similaires — même sujet : Ansible)
• Texte 1 ↔ Texte 3 : 0.78 (différents — DevOps vs cuisine)
• Diagonale : 1.00 (un texte est identique à lui-même)

Autres métriques de similarité

Métrique	Formule	Usage
Cosinus	(a · b) / (‖a‖ × ‖b‖)	Standard pour embeddings normalisés
Dot product	a · b	Équivalent au cosinus si vecteurs normalisés
Euclidienne	‖a - b‖	Distance (inverser le sens : 0 = proche)

Glissez pour voir

from sentence_transformers.util import cos_sim, dot_score
import numpy as np

a = model.encode(["passage: Ansible"])
b = model.encode(["passage: Kubernetes"])

# Cosinus
print(f"Cosinus : {cos_sim(a, b)[0][0]:.4f}")

# Dot product
print(f"Dot product : {dot_score(a, b)[0][0]:.4f}")

# Distance euclidienne
dist = np.linalg.norm(a - b)
print(f"Euclidienne : {dist:.4f}")

Modèles normalisés

Les modèles E5 produisent des embeddings normalisés (longueur = 1). Dans ce cas, similarité cosinus = dot product. Utilisez le dot product pour de meilleures performances.

Recherche sémantique : trouver les documents pertinents

L’usage principal des embeddings est la recherche sémantique : trouver les documents les plus proches d’une question.

from sentence_transformers import SentenceTransformer
from sentence_transformers.util import cos_sim
import numpy as np

model = SentenceTransformer("intfloat/multilingual-e5-small")

# Base de documents
documents = [
    "Ansible est un outil d'automatisation IT open source",
    "Les playbooks Ansible sont écrits en YAML",
    "Docker permet de créer des conteneurs isolés",
    "Kubernetes orchestre les conteneurs dans un cluster",
    "Terraform gère l'infrastructure as code",
]

# Indexer les documents
doc_embeddings = model.encode([f"passage: {d}" for d in documents])

def rechercher(question: str, top_k: int = 3) -> list[tuple[str, float]]:
    """Recherche les documents les plus pertinents."""
    query_emb = model.encode([f"query: {question}"])

    # Calculer les similarités
    scores = cos_sim(query_emb, doc_embeddings)[0]

    # Trier par score décroissant
    indices = np.argsort(scores.numpy())[::-1][:top_k]

    return [(documents[i], float(scores[i])) for i in indices]

# Test
question = "Comment automatiser la gestion de mes serveurs ?"
resultats = rechercher(question)

print(f"Question : {question}\n")
print("Résultats :")
for doc, score in resultats:
    print(f"  [{score:.3f}] {doc}")

Résultat :

Question : Comment automatiser la gestion de mes serveurs ?

Résultats :
  [0.876] Ansible est un outil d'automatisation IT open source
  [0.812] Les playbooks Ansible sont écrits en YAML
  [0.798] Terraform gère l'infrastructure as code

Le système trouve Ansible comme meilleur résultat, même si le mot “serveur” n’apparaît pas dans le document.

Similarité cross-lingue (multilingue)

Les modèles multilingues comme E5 comprennent plusieurs langues dans le même espace vectoriel :

textes = [
    ("FR", "Comment installer Ansible sur Ubuntu ?"),
    ("EN", "How to install Ansible on Ubuntu?"),
    ("FR", "Déployer une application avec Kubernetes"),
    ("EN", "Deploy an application with Kubernetes"),
    ("FR", "La recette du gâteau au chocolat"),
]

embeddings = model.encode([f"passage: {t[1]}" for t in textes])

# Question en français
question_fr = "query: Guide d'installation d'Ansible"
query_emb = model.encode([question_fr])

print(f"Question (FR) : '{question_fr[7:]}'")
print("\nScores par document :")

scores = cos_sim(query_emb, embeddings)[0]
for i, (lang, texte) in enumerate(textes):
    print(f"  [{lang}] {scores[i]:.3f} - {texte}")

Résultat :

Question (FR) : 'Guide d'installation d'Ansible'

Scores par document :
  [FR] 0.914 - Comment installer Ansible sur Ubuntu ?
  [EN] 0.891 - How to install Ansible on Ubuntu?
  [FR] 0.875 - Déployer une application avec Kubernetes
  [EN] 0.859 - Deploy an application with Kubernetes
  [FR] 0.846 - La recette du gâteau au chocolat

Recherche multilingue

Une question en français trouve des documents en anglais (et vice versa). C’est particulièrement utile pour les documentations techniques disponibles dans plusieurs langues.

Choisir le bon modèle d’embeddings

Le choix du modèle impacte la qualité, la vitesse et la compatibilité linguistique.

Modèles recommandés

Modèle	Dimensions	Langues	Taille	Usage
intfloat/multilingual-e5-small	384	100+	471 Mo	Multilingue, bon compromis
intfloat/multilingual-e5-base	768	100+	1.1 Go	Multilingue, meilleure qualité
all-MiniLM-L6-v2	384	EN	80 Mo	Anglais, très rapide
BAAI/bge-m3	1024	100+	2.2 Go	État de l’art multilingue

Glissez pour voir

Critères de choix

Débutant

Recommandation : intfloat/multilingual-e5-small

• Multilingue (FR, EN, etc.)
• Bon équilibre qualité/vitesse
• Fonctionne bien sur CPU
• Préfixes query:/passage: à ajouter

model = SentenceTransformer("intfloat/multilingual-e5-small")

Anglais uniquement

Recommandation : all-MiniLM-L6-v2

• Ultra rapide (80 Mo)
• Excellent pour le prototypage
• Pas de préfixes nécessaires

model = SentenceTransformer("all-MiniLM-L6-v2")

Production multilingue

Recommandation : BAAI/bge-m3

• État de l’art sur MTEB
• Supporte dense + sparse retrieval
• 1024 dimensions (plus précis)
• Plus lourd (2.2 Go)

model = SentenceTransformer("BAAI/bge-m3")

Benchmark de performance

Test sur un CPU Intel i7 (encodage de 100 phrases) :

Modèle	Temps	Score MTEB (retrieval)
all-MiniLM-L6-v2	0.8s	56.3
multilingual-e5-small	1.2s	61.5
multilingual-e5-base	2.8s	64.2
bge-m3	4.5s	68.4

Glissez pour voir

Impact de la longueur du texte

Les embeddings ont un comportement différent selon la longueur du texte :

texte_court = "Ansible gère les serveurs"
texte_moyen = "Ansible est un outil d'automatisation IT qui permet de gérer la configuration des serveurs de manière déclarative"
texte_long = texte_moyen + ". Il utilise SSH pour se connecter aux serveurs distants et exécuter des tâches. Cette approche agentless simplifie l'infrastructure."

embs = model.encode([
    f"passage: {texte_court}",
    f"passage: {texte_moyen}",
    f"passage: {texte_long}"
])

query = "query: Outil pour gérer l'infrastructure serveurs"
query_emb = model.encode([query])

print(f"Question : '{query[7:]}'")
print(f"\n{'Version':<10} {'Longueur':>10} {'Score':>10}")
print("-" * 35)
for i, (nom, texte) in enumerate([
    ("Court", texte_court),
    ("Moyen", texte_moyen),
    ("Long", texte_long)
]):
    score = cos_sim(query_emb, embs[i:i+1])[0][0]
    print(f"{nom:<10} {len(texte):>10} {score:.4f}")

Résultat typique :

Question : 'Outil pour gérer l'infrastructure serveurs'

Version      Longueur      Score
-----------------------------------
Court              25     0.8863
Moyen             113     0.8641
Long              340     0.8680

Observation

Un texte trop court manque de contexte. Un texte trop long dilue le signal. Le texte moyen (100-300 caractères par chunk) offre souvent le meilleur équilibre.

Intégration dans un pipeline RAG

Les embeddings sont la pierre angulaire du RAG. Voici comment ils s’intègrent :

from sentence_transformers import SentenceTransformer
import chromadb

# 1. Charger le modèle (une fois)
model = SentenceTransformer("intfloat/multilingual-e5-small")

# 2. Configurer ChromaDB
client = chromadb.PersistentClient(path="./ma_base")
collection = client.get_or_create_collection(
    name="documentation",
    metadata={"hnsw:space": "cosine"}  # Utiliser cosinus
)

# 3. Indexer des documents
def indexer(documents: list[str], ids: list[str]):
    embeddings = model.encode([f"passage: {d}" for d in documents])
    collection.add(
        embeddings=embeddings.tolist(),
        documents=documents,
        ids=ids
    )

# 4. Rechercher
def rechercher(question: str, n_results: int = 3):
    query_emb = model.encode([f"query: {question}"])
    resultats = collection.query(
        query_embeddings=query_emb.tolist(),
        n_results=n_results
    )
    return resultats

# Usage
indexer(
    documents=["Ansible automatise...", "Docker conteneurise..."],
    ids=["doc1", "doc2"]
)

resultats = rechercher("Comment automatiser mes serveurs ?")
print(resultats["documents"])

Optimisations pour la production

Batch encoding

Encodez plusieurs textes à la fois pour de meilleures performances :

# ✗ Lent : un par un
for doc in documents:
    emb = model.encode(doc)

# ✓ Rapide : par batch
embeddings = model.encode(documents, batch_size=32, show_progress_bar=True)

Normalisation explicite

Si votre base vectorielle attend des vecteurs normalisés :

embeddings = model.encode(documents, normalize_embeddings=True)

GPU (si disponible)

model = SentenceTransformer("intfloat/multilingual-e5-small", device="cuda")

Erreurs courantes et solutions

Erreur	Cause	Solution
Scores toujours ~0.8	Préfixes manquants (E5)	Ajouter query:/passage:
Résultats non pertinents	Mauvais modèle pour la langue	Utiliser un modèle multilingue
Mémoire insuffisante	Modèle trop gros	Utiliser multilingual-e5-small
Encodage lent	Batch size trop petit	Augmenter batch_size

Glissez pour voir

À retenir

Point clé	Recommandation
Modèle débutant	intfloat/multilingual-e5-small
Préfixes E5	query: pour questions, passage: pour documents
Métrique	Similarité cosinus (ou dot product si normalisé)
Taille texte idéale	100-300 caractères par chunk
Batch encoding	Toujours encoder par lots

Glissez pour voir

Prochaines étapes

RAG pratique Assemblez chunking + embeddings + LLM dans un pipeline fonctionnel

ChromaDB Stockez et recherchez vos embeddings efficacement

Chunking Découper les documents avant de générer les embeddings

×

📖 Voir la documentation →