Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Similarita sémantique

Lekce 3 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Mesure de la proximité textuelle
  2. Distance euclidienne
  3. Similarité cosinus
  4. Matrice de similarité
  5. Recherche sémantique simple
  6. Seuil de pertinence
  7. Klíčové poznatky

Mesure de la proximité textuelle

Une fois que tu as transformé tes textes en vecteurs grâce à mistral-embed, tu peux quantifier à quel point deux textes sont sémantiquement proches. C’est le cœur de la recherche sémantique : comparer des significations, pas seulement des mots. Alors qu’une requête SQL LIKE '%facture%' renvoie un simple oui ou non, une métrique de similarité te donne un nombre, permettant ainsi un classement. C’est ce classement qui donne toute sa valeur au système.

Dans cette leçon, tu vas implémenter les principales métriques de similarité et voir comment elles fonctionnent en pratique avec des exemples concrets en Python.

Distance euclidienne

La distance euclidienne mesure la longueur du segment reliant deux points dans l’espace vectoriel. Plus la distance est faible, plus les textes sont similaires. L’exemple ci-dessous compare trois phrases : les deux premières disent la même chose avec un vocabulaire différent, tandis que la troisième parle de tarte aux pommes. Les phrases A et B n’ont aucun mot en commun, pourtant leur distance sera nettement plus faible que celle entre A et C.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embedding(text):
    """Get the embedding for a text via mistral-embed."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[text],
    )
    return np.array(response.data[0].embedding)

# Three sentences to compare
phrase_a = "Machine learning transforms data into predictions."
phrase_b = "Automatic learning converts data into results."
phrase_c = "The recipe for apple pie is simple."

emb_a = get_embedding(phrase_a)
emb_b = get_embedding(phrase_b)
emb_c = get_embedding(phrase_c)

# Euclidean distances
dist_ab = np.linalg.norm(emb_a - emb_b)
dist_ac = np.linalg.norm(emb_a - emb_c)

print(f"Distance A-B (semantically close): {dist_ab:.4f}")
print(f"Distance A-C (semantically distant): {dist_ac:.4f}")
# A-B will be significantly lower than A-C

Similarité cosinus

La similarité cosinus est la métrique la plus utilisée pour les embeddings. Elle mesure l’angle entre deux vecteurs, indépendamment de leur magnitude. Le résultat varie de -1 à 1, offrant une échelle immédiatement lisible : tu peux définir un seuil et le communiquer à une équipe métier sans avoir à expliquer les normes vectorielles.

from sklearn.metrics.pairwise import cosine_similarity

# With scikit-learn
sim_ab = cosine_similarity([emb_a], [emb_b])[0][0]
sim_ac = cosine_similarity([emb_a], [emb_c])[0][0]

print(f"Cosine similarity A-B: {sim_ab:.4f}")  # ~0.92 (very close)
print(f"Cosine similarity A-C: {sim_ac:.4f}")  # ~0.35 (distant)

L’écart entre 0,92 et 0,35 constitue l’information utile : ce n’est pas la valeur absolue qui compte, mais la marge séparant les résultats pertinents des sujets hors contexte dans ton jeu de données spécifique. Tu peux aussi implémenter la métrique manuellement, ne serait-ce que pour vérifier ce que fait scikit-learn ou pour éviter des dépendances dans un environnement contraint :

def cosine_sim(vec_a, vec_b):
    """Manual cosine similarity."""
    dot = np.dot(vec_a, vec_b)
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    return dot / (norm_a * norm_b)

print(f"Manual verification A-B: {cosine_sim(emb_a, emb_b):.4f}")

Matrice de similarité

Pour comparer plusieurs documents entre eux, tu peux construire une matrice de similarité. Le corpus ci-dessous mélange intentionnellement deux thèmes — l’IA et la gastronomie — afin que la structure saute aux yeux : les documents 0, 1 et 3 sont liés entre eux, tandis que les documents 2 et 4 forment un cluster séparé. C’est exactement le signal qu’exploitent les algorithmes de clustering.

from sklearn.metrics.pairwise import cosine_similarity

documents = [
    "Mistral AI develops language models.",
    "LLMs generate text from prompts.",
    "French cuisine is renowned worldwide.",
    "NLP is a branch of artificial intelligence.",
    "Croissants taste best in the morning.",
]

# Encode all documents
response = client.embeddings.create(
    model="mistral-embed",
    inputs=documents,
)
embeddings = np.array([d.embedding for d in response.data])

# Similarity matrix (5x5)
sim_matrix = cosine_similarity(embeddings)

print("Similarity Matrix:")
for i, doc in enumerate(documents):
    for j, doc2 in enumerate(documents):
        if j > i:
            print(f"  [{i}]-[{j}]: {sim_matrix[i][j]:.3f}")

Recherche sémantique simple

Tout ce qui précède se combine pour former un mini moteur de recherche. La requête est encodée avec le même modèle que le corpus — une condition non négociable, car deux modèles différents produisent des espaces incomparables — puis argsort inverse le classement pour placer les scores les plus élevés en tête.

def recherche_semantique(query, documents, embeddings, top_k=3):
    """Finds the most relevant documents for a query."""
    # Encode the query
    query_response = client.embeddings.create(
        model="mistral-embed",
        inputs=[query],
    )
    query_embedding = np.array(query_response.data[0].embedding)

    # Calculate similarities
    similarities = cosine_similarity(
        [query_embedding], embeddings
    )[0]

    # Sort by descending similarity
    ranked_indices = np.argsort(similarities)[::-1][:top_k]

    results = []
    for idx in ranked_indices:
        results.append({
            "document": documents[idx],
            "score": similarities[idx],
            "index": int(idx),
        })
    return results

# Usage example
query = "How does Mistral's AI work?"
results = recherche_semantique(query, documents, embeddings)

for r in results:
    print(f"  Score: {r['score']:.3f} -- {r['document']}")

Seuil de pertinence

Ce moteur présente un défaut que tu découvriras rapidement en production : il renvoie toujours trois résultats, même lorsque la question n’a rien à voir avec le corpus. Demande-lui la météo, et il te retournera les trois documents les moins éloignés, avec des scores dérisoires mais un classement apparemment normal. En pratique, tu dois donc définir un seuil de similarité en dessous duquel un document est considéré comme non pertinent :

SEUIL_PERTINENCE = 0.7

def recherche_avec_seuil(query, documents, embeddings, seuil=SEUIL_PERTINENCE):
    """Search with filtering by relevance threshold."""
    results = recherche_semantique(query, documents, embeddings, top_k=len(documents))
    return [r for r in results if r["score"] >= seuil]

# A threshold of 0.7 is a good starting point
# Adjust based on your use case:
# - 0.8+: very strict (few results, high relevance)
# - 0.6-0.7: balanced
# - 0.5: permissive (many results, variable relevance)

Prends le temps de calibrer ce seuil sur une trentaine de requêtes réelles avant d’ouvrir le service aux utilisateurs. Si tu le fixes trop haut, ton moteur répondra „Je ne sais pas“ à des questions légitimes. Si tu le fixes trop bas, tu nourriras le LLM avec un contexte hors sujet, créant ainsi les hallucinations mêmes que le RAG était censé prévenir.

Klíčové poznatky

  • La similarité cosinus est la métrique standard pour comparer les embeddings
  • Utilise sklearn.metrics.pairwise.cosine_similarity pour des calculs rapides
  • Une matrice de similarité permet de comparer tous les documents entre eux
  • Définis un seuil de pertinence adapté à ton cas d’usage (0,7 est une bonne valeur par défaut)
  • La recherche sémantique trouve des résultats par le sens, et non par correspondance exacte de mots