Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Semantische gelijkenis

Les 3 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Het meten van tekstnabijheid
  2. Euclidische afstand
  3. Cosinusgelijkenis
  4. Gelijkenismatrix
  5. Eenvoudig semantisch zoeken
  6. Relevantiedrempel
  7. Belangrijkste punten

Het meten van tekstnabijheid

Zodra u uw teksten met mistral-embed omzet in vectoren, kunt u kwantificeren hoe semantisch dicht twee teksten bij elkaar liggen. Dit is de kern van semantisch zoeken: betekenissen vergelijken, niet alleen woorden. Terwijl een SQL-query met LIKE '%factuur%' slechts een ja of nee oplevert, geeft een gelijkenismaatstaf u een getal, wat rangschikking mogelijk maakt. Die rangschikking is wat het hele systeem waardevol maakt.

In deze les implementeert u de belangrijkste gelijkenismaatstaven en ziet u hoe ze in de praktijk werken aan de hand van concrete Python-voorbeelden.

Euclidische afstand

Euclidische afstand meet de lengte van het lijnstuk tussen twee punten in de vectorruimte. Hoe kleiner de afstand, hoe vergelijkbaarder de teksten. Het onderstaande voorbeeld vergelijkt drie zinnen: de eerste twee zeggen hetzelfde met een ander woordgebruik, terwijl de derde over appeltaart gaat. Zinnen A en B hebben geen gemeenschappelijke woorden, toch zal hun afstand aanzienlijk kleiner zijn dan de afstand tussen A en 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

Cosinusgelijkenis

Cosinusgelijkenis is de meest gebruikte maatstaf voor embeddings. Deze meet de hoek tussen twee vectoren, onafhankelijk van hun grootte. Het resultaat varieert van -1 tot 1, wat een direct leesbare schaal oplevert: u kunt een drempelwaarde instellen en deze communiceren aan een bedrijfsteam zonder vectornormen te hoeven uitleggen.

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)

Het verschil tussen 0,92 en 0,35 is de bruikbare informatie: het gaat niet om de absolute waarde, maar om de marge die relevante resultaten scheidt van onderwerpen die buiten het thema vallen in uw specifieke dataset. U kunt de maatstaf ook handmatig implementeren, al was het maar om te verifiëren wat scikit-learn doet of om afhankelijkheden in een beperkte omgeving te vermijden:

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}")

Gelijkenismatrix

Om meerdere documenten onderling te vergelijken, kunt u een gelijkenismatrix opbouwen. De onderstaande corpus mengt bewust twee thema’s – AI en gastronomie – zodat de structuur direct opvalt: documenten 0, 1 en 3 zijn aan elkaar gerelateerd, terwijl documenten 2 en 4 een aparte cluster vormen. Dit is precies het signaal dat clustering-algoritmen benutten.

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}")

Eenvoudig semantisch zoeken

Al het bovenstaande komt samen in een mini-zoekmachine. De query wordt gecodeerd met hetzelfde model als het corpus – een niet-onderhandelbare voorwaarde, aangezien twee verschillende modellen onvergelijkbare ruimtes produceren – waarna argsort de rangschikking omdraait om de hoogste scores bovenaan te plaatsen.

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']}")

Relevantiedrempel

Deze engine heeft een gebrek dat u in productie snel zult ontdekken: hij retourneert altijd drie resultaten, zelfs als de vraag niets met het corpus te maken heeft. Vraag naar het weer en hij geeft de drie minst verre documenten terug, met belachelijke scores maar een ogenschijnlijk normale rangschikking. In de praktijk moet u daarom een gelijkenisdrempel definiëren waaronder een document als irrelevant wordt beschouwd:

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)

Neem de tijd om deze drempel te kalibreren op ongeveer dertig echte query’s voordat u de dienst opent voor gebruikers. Stelt u deze te hoog in, dan zegt uw engine “ik weet het niet” tegen legitieme vragen. Stelt u deze te laag in, dan voedt u de LLM met context die buiten het onderwerp valt, waardoor juist die hallucinaties ontstaan die RAG had moeten voorkomen.

Belangrijkste punten

  • Cosinusgelijkenis is de standaardmaatstaf voor het vergelijken van embeddings
  • Gebruik sklearn.metrics.pairwise.cosine_similarity voor snelle berekeningen
  • Een gelijkenismatrix stelt u in staat alle documenten onderling te vergelijken
  • Definieer een relevantiedrempel die is afgestemd op uw use case (0,7 is een goede standaardwaarde)
  • Semantisch zoeken vindt resultaten op basis van betekenis, niet op basis van exacte woordovereenkomst