Embeddings : Les Fondations de la Recherche Sémantique

En Résumé

• Embeddings = Représentations vectorielles qui capturent le sens sémantique (texte similaire → vecteurs proches)
• Meilleur pour la plupart : OpenAI text-embedding-3-small ($0.02/1M tokens, 1536 dimensions)
• Option économique : Sentence Transformers all-mpnet-base-v2 (gratuit, auto-hébergé)
• La qualité compte : Meilleurs embeddings = amélioration de 20-40% de la précision de récupération
• Comparez les modèles en direct sur la plateforme Ailog

Comprendre les Embeddings

Les embeddings sont des représentations vectorielles denses de texte qui capturent le sens sémantique dans un espace de haute dimension. Les mots, phrases ou documents ayant des significations similaires sont positionnés proches les uns des autres dans cet espace vectoriel.

Du Texte aux Vecteurs

Considérez ces phrases :

• "The cat sits on the mat"
• "A feline rests on the rug"
• "Python is a programming language"

De bons embeddings placeront les deux premières phrases proches l'une de l'autre (sens similaire) et la troisième loin (sujet différent).

Pourquoi les Embeddings sont Importants pour le RAG

Les embeddings permettent une recherche sémantique plutôt qu'une correspondance de mots-clés :

Recherche par Mots-Clés (Traditionnelle)

Requête : "how to reset password"
Correspondance : Correspondance exacte de mots
Manque : "password recovery", "forgot credentials", "account access"

Recherche Sémantique (Embeddings)

Requête : "how to reset password"
Trouve : "password recovery", "forgot credentials", "regain account access"
Raison : Sens similaire, mots différents

Modèles d'Embedding Populaires

Embeddings OpenAI

text-embedding-3-small

• Dimensions : 1536
• Coût : $0.02 / 1M tokens
• Performance : Bon pour la plupart des cas d'usage
• Vitesse : Rapide

text-embedding-3-large

• Dimensions : 3072
• Coût : $0.13 / 1M tokens
• Performance : Meilleure précision
• Vitesse : Plus lent, plus de mémoire

Alternatives Open Source

Sentence Transformers

• Modèles : all-MiniLM-L6-v2, all-mpnet-base-v2
• Dimensions : 384-768
• Coût : Gratuit (auto-hébergé)
• Performance : Bon pour l'anglais
• Personnalisable : Peut être affiné sur votre domaine

BGE (BAAI General Embedding)

• Modèles : bge-small, bge-base, bge-large
• Dimensions : 512-1024
• Performance : État de l'art open source
• Langues : Support multilingue

E5 (Microsoft)

• Modèles : e5-small, e5-base, e5-large
• Dimensions : 384-1024
• Performance : Excellent en zéro-shot
• Entraînement : Approche par supervision faible

Cohere Embed

• Dimensions : 1024 (v3), 768 (multilingue)
• Coût : Tarification basée sur API
• Performance : Fort multilingue
• Fonctionnalités : Compression intégrée

Dimensions d'Embedding

Le nombre de dimensions affecte :

Dimensions Élevées (1024-3072)

Avantages :

• Représentations plus expressives
• Meilleure capture des nuances de sens
• Précision plus élevée sur les requêtes complexes

Inconvénients :

• Plus d'espace de stockage requis
• Calculs de similarité plus lents
• Utilisation mémoire plus élevée
• Coûts accrus

Dimensions Faibles (256-512)

Avantages :

• Recherche plus rapide
• Moins de stockage
• Empreinte mémoire réduite
• Rentable à grande échelle

Inconvénients :

• Peut perdre la nuance sémantique
• Précision plus faible sur les distinctions subtiles

Choix Optimal

Pour la plupart des applications RAG :

• 384-768 dimensions : Bon équilibre pour usage général
• 1024-1536 dimensions : Meilleur pour les domaines complexes
• 256-384 dimensions : Applications à fort volume, sensibles aux coûts

Stratégies d'Embedding

Embeddings au Niveau du Document

Incorporer des documents entiers comme vecteurs uniques.

Avantages :

• Capture le thème global du document
• Implémentation simple
• Bon pour la classification de documents

Inconvénients :

• Perd les informations granulaires
• Limite de fenêtre de contexte pour les longs documents
• Mauvais pour la récupération précise

Utiliser quand :

• Les documents sont courts (< 512 tokens)
• Besoin de similarité au niveau du document
• Tâches de classification

Embeddings au Niveau des Chunks

Diviser les documents en chunks, incorporer chacun séparément.

Avantages :

• Récupère des sections spécifiques pertinentes
• Gère les longs documents
• Contexte plus précis

Inconvénients :

• Plus d'embeddings à stocker
• Les limites de chunks peuvent diviser le contexte
• Nécessite une stratégie de découpage

Utiliser quand :

• Les documents sont longs
• Besoin de récupération précise
• La plupart des applications RAG

Embeddings au Niveau des Phrases

Incorporer des phrases individuelles.

Avantages :

• Récupération très précise
• Contexte non pertinent minimal
• Bon pour les systèmes FAQ

Inconvénients :

• Peut manquer de contexte environnant
• Très grand nombre d'embeddings
• Fragmentation du contexte

Utiliser quand :

• Les questions ont des réponses courtes et spécifiques
• Minimisation de l'utilisation de la fenêtre de contexte
• Systèmes FAQ ou Q&A

Approches Hybrides

Combiner plusieurs granularités :

DEVELOPERpython
# Pseudocode
document_embedding = embed(full_document)
chunk_embeddings = [embed(chunk) for chunk in chunks]
sentence_embeddings = [embed(sent) for sent in sentences]

# Récupération : Rechercher au niveau du document, puis descendre aux chunks

Bonnes Pratiques d'Embedding

1. Prétraitement Cohérent

Assurer que le prétraitement d'entraînement et d'inférence correspond :

DEVELOPERpython
# Mauvais : Prétraitement incohérent
training: "The Quick Brown Fox"
inference: "the quick brown fox"

# Bon : Prétraitement cohérent
def preprocess(text):
    return text.lower().strip()

training: preprocess(text)
inference: preprocess(query)

2. Gérer le Texte Long

La plupart des modèles ont des limites de tokens (512 tokens typique).

Options :

• Découpage : Diviser avant l'embedding
• Troncature : Prendre les premiers N tokens
• Résumé : Incorporer le résumé pour les longs documents
• Modèles à contexte long : Utiliser des modèles avec des fenêtres de contexte plus grandes

3. Normaliser les Embeddings

La normalisation L2 améliore la cohérence :

DEVELOPERpython
import numpy as np

def normalize(embedding):
    return embedding / np.linalg.norm(embedding)

Avantages :

• La similarité cosinus devient un produit scalaire (plus rapide)
• Plages de similarité cohérentes
• Meilleur clustering

4. Traitement par Lots

Incorporer plusieurs textes à la fois pour plus d'efficacité :

DEVELOPERpython
# Inefficace : Un à la fois
embeddings = [embed(text) for text in texts]

# Efficace : Embedding par lots
embeddings = embed_batch(texts, batch_size=32)

5. Mise en Cache

Mettre en cache les embeddings pour éviter le recalcul :

DEVELOPERpython
# Utiliser le hachage du contenu comme clé de cache
import hashlib

def get_embedding(text, cache):
    text_hash = hashlib.md5(text.encode()).hexdigest()

    if text_hash not in cache:
        cache[text_hash] = embed(text)

    return cache[text_hash]

Métriques de Similarité

Similarité Cosinus

Mesure l'angle entre les vecteurs. Plage : [-1, 1]

DEVELOPERpython
from numpy import dot
from numpy.linalg import norm

def cosine_similarity(a, b):
    return dot(a, b) / (norm(a) * norm(b))

Meilleur pour : Embeddings normalisés, choix le plus courant

Distance Euclidienne

Mesure la distance en ligne droite. Plage : [0, ∞]

DEVELOPERpython
def euclidean_distance(a, b):
    return norm(a - b)

Meilleur pour : Embeddings non normalisés, clustering

Produit Scalaire

Multiplication et somme simples. Plage : [-∞, ∞]

DEVELOPERpython
def dot_product(a, b):
    return dot(a, b)

Meilleur pour : Embeddings normalisés (équivalent au cosinus), calcul le plus rapide

Adaptation de Domaine

Quand Faire du Fine-Tuning

Considérer le fine-tuning quand :

• Le domaine a un vocabulaire spécialisé
• Les modèles prêts à l'emploi performent mal
• Vous avez des données d'entraînement de qualité
• L'application à haute valeur justifie l'effort

Approches de Fine-Tuning

Apprentissage Contrastif

Paires positives : Éléments similaires
Paires négatives : Éléments dissimilaires

Exemple :
(requête : "reset password", doc : "password recovery") → similaire
(requête : "reset password", doc : "billing info") → dissimilaire

Perte Triplet

(ancre, positif, négatif)

ancre : "database optimization"
positif : "improving SQL query performance"
négatif : "frontend UI design"

Distillation de Connaissances

• Utiliser un grand modèle enseignant (ex. OpenAI)
• Entraîner un petit modèle étudiant pour correspondre
• Déployer le modèle plus petit pour coût/vitesse

Évaluer la Qualité des Embeddings

Métriques Intrinsèques

Tâches de Similarité

• Benchmarks de similarité textuelle sémantique (STS)
• Corrélation avec les jugements humains

Qualité du Clustering

• Les documents similaires se regroupent-ils ensemble ?
• Score de silhouette

Métriques Extrinsèques

Performance de Récupération

• Precision@k
• Recall@k
• NDCG (Normalized Discounted Cumulative Gain)

Métriques RAG de Bout en Bout

• Qualité de réponse avec ces embeddings
• Satisfaction utilisateur
• Taux d'achèvement de tâche

Considérations Pratiques

Besoins de Stockage

Calculer les besoins de stockage :

Stockage = nb_documents × chunks_par_doc × dimensions × octets_par_float

Exemple :
1M documents × 10 chunks × 768 dimensions × 4 octets = 30,7 GB

Latence

Temps d'embedding typiques :

• API OpenAI : 50-200ms par requête
• Sentence Transformers local : 10-50ms par lot
• Accélération GPU : 2-10ms par lot

Coût

Estimation du coût mensuel :

OpenAI text-embedding-3-small :
1M documents × 500 tokens/doc × $0.02/1M tokens = $10

Auto-hébergé :
Instance GPU : $200-500/mois
Amorti sur le volume

Choisir Votre Modèle d'Embedding

Framework de décision :

1. Budget : API ou auto-hébergé ?
2. Volume : Combien d'embeddings nécessaires ?
3. Latence : Temps réel ou par lots ?
4. Langue : Anglais uniquement ou multilingue ?
5. Domaine : Général ou spécialisé ?
6. Précision : Quelle est la criticité de la précision ?

Recommandations

Usage Général (Anglais)

• OpenAI text-embedding-3-small
• Sentence Transformers all-mpnet-base-v2

Multilingue

• Cohere embed-multilingual-v3
• BGE-M3

Optimisé pour les Coûts

• Sentence Transformers auto-hébergé
• E5-small-v2

Précision Maximale

• OpenAI text-embedding-3-large
• Voyage AI voyage-large-2

Conseil d'Expert d'Ailog : Ne réfléchissez pas trop à votre premier choix de modèle d'embedding. OpenAI text-embedding-3-small est le sweet spot pour 90% des applications – excellente qualité, coût raisonnable et aucune infrastructure à gérer. Optimisez vers des modèles spécialisés uniquement après avoir prouvé la valeur du RAG et identifié des goulots d'étranglement spécifiques. Nous avons vu des équipes perdre des mois à affiner des embeddings avant de valider leur cas d'usage.

Tester les Modèles d'Embedding sur Ailog

Comparez les modèles d'embedding sans configuration d'infrastructure :

Sur la plateforme Ailog :

• Testez OpenAI, Cohere et les modèles open source côte à côte
• Benchmarkez la précision de récupération sur vos documents réels
• Voyez les projections de coûts réels basées sur votre volume de données
• Changez de modèle instantanément en un clic

Commencer à tester → Le niveau gratuit inclut tous les principaux modèles d'embedding.

Prochaines Étapes

Avec les embeddings en place, le prochain composant critique est de déterminer comment diviser vos documents. La stratégie de découpage impacte significativement la qualité de récupération et sera couverte dans le guide suivant.