Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Afstand en Cosinusgelijkenis

Les 4 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Nabijheid tussen vectoren meten
  3. Praktische vergelijking
  4. Scores interpreteren
  5. Zoeken naar naaste buren
  6. Met scikit-learn
  7. Belangrijkste punten

Doelstellingen

  • Inzicht krijgen in cosinusgelijkenis en waarom deze de voorkeur geniet
  • Vectorvergelijking implementeren in Python
  • Gelijkenisscores interpreteren

Nabijheid tussen vectoren meten

Zodra u uw teksten in vectoren hebt omgezet, draait alles om één vraag: hoe bepaalt u of twee vectoren “dicht bij elkaar” liggen? Er bestaan drie antwoorden, en de keuze is bepalend.

Euclidische afstand is de klassieke geometrische afstand—die u met een liniaal tussen twee punten zou meten. Het is intuïtief, maar hangt af van de grootte van de vector: twee teksten met dezelfde betekenis, waarbij de ene met een hogere amplitude is gecodeerd, lijken kunstmatig ver uit elkaar te liggen.

import numpy as np

def euclidean_distance(a: list[float], b: list[float]) -> float:
    return np.linalg.norm(np.array(a) - np.array(b))

Het inproduct sommeert de elementgewijze producten. Het is de snelste bewerking in de familie—de ene die de processor het meest efficiënt uitvoert op grote matrices.

def dot_product(a: list[float], b: list[float]) -> float:
    return np.dot(a, b)

Cosinusgelijkenis meet tot slot de hoek tussen twee vectoren, ongeacht hun lengte, waardoor het de standaardmetriek voor embeddings is: alleen de richting van de betekenis telt, niet de intensiteit.

def cosine_similarity(a: list[float], b: list[float]) -> float:
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

De waarde varieert van -1 voor tegengestelde richtingen tot +1 voor identieke richtingen. Eén praktisch detail is belangrijk: OpenAI-embeddings zijn al genormaliseerd, wat betekent dat ze een lengte van 1 hebben. De noemer is daarom gelijk aan 1, en het inproduct levert exact hetzelfde resultaat op als cosinusgelijkenis—tegen lagere rekenkosten. Dit is de shortcut die we tijdens deze cursus zullen gebruiken.

Praktische vergelijking

Niets overtreft het meten van echte zinnen. Laten we een zin vergelijken met een volledige parafrase en een zin die buiten het onderwerp valt:

from openai import OpenAI

client = OpenAI()

def get_embedding(text: str) -> list[float]:
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-large"
    )
    return response.data[0].embedding

# Te vergelijken zinnen
sentences = {
    "a": "The cat sleeps on the couch",
    "b": "The feline dozes on the sofa",
    "c": "Python is a programming language",
}

embeddings = {k: get_embedding(v) for k, v in sentences.items()}

# Alle paren vergelijken
from itertools import combinations

for (k1, v1), (k2, v2) in combinations(sentences.items(), 2):
    sim = cosine_similarity(embeddings[k1], embeddings[k2])
    print(f"sim({k1}, {k2}) = {sim:.4f}")
    print(f"  {v1}")
    print(f"  {v2}")
    print()

Typisch resultaat:

sim(a, b) = 0.8923   ← zeer vergelijkbare betekenis
sim(a, c) = 0.1247   ← verschillende onderwerpen
sim(b, c) = 0.1189   ← verschillende onderwerpen

Zinnen a en b delen geen woorden—cat/feline, sleeps/dozes, couch/sofa—maar scoren toch 0,89. Dit is precies wat geen enkele lexicale methode kan bereiken.

Scores interpreteren

Drempelwaarden hangen af van uw use case, maar de onderstaande tabel geeft referentiepunten om een score af te lezen zonder een orde van grootte naast te zitten.

ScoreInterpretatie
> 0,85Zeer vergelijkbaar (parafrases, synoniemen)
0,70 – 0,85Thematisch gerelateerd
0,40 – 0,70Losjes gerelateerd
< 0,40Verschillende onderwerpen

Deze waarden variëren per model en domein: een juridisch corpus, waar alle teksten dezelfde formele vocabulaire delen, levert over het algemeen hogere scores op dan een algemeen corpus, tot op het punt waarop een drempel van 0,70 te permissief wordt. Kalibreer altijd op uw eigen data door dertig paren te observeren waarvan u het verwachte antwoord kent.

Zoeken naar naaste buren

Een document vinden betekent de gelijkenis berekenen tussen de query-vector en alle vectoren in het corpus, en vervolgens de top k behouden. De truc is om looping in Python te vermijden: een NumPy-matrixvermenigvuldiging berekent alle gelijkenissen in één keer, in een fractie van de tijd.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Geeft de k meest vergelijkbare documenten terug."""
    query = np.array(query_embedding)

    # Gevectoriseerde berekening van alle gelijkenissen
    similarities = corpus_embeddings @ query
    # (werkt omdat OpenAI-embeddings genormaliseerd zijn)

    # Indices van de top k-scores
    top_k_indices = np.argsort(similarities)[-k:][::-1]

    return [(int(i), float(similarities[i])) for i in top_k_indices]

# Gebruik
corpus = np.load("embeddings.npy")  # matrix (n, 3072)
query_emb = get_embedding("How do I install Python?")

results = search_similar(query_emb, corpus, k=5)
for idx, score in results:
    print(f"Document {idx}: score = {score:.4f}")

De [-k:][::-1] verdient een tweede blik: argsort sorteert in oplopende volgorde, dus we nemen het einde van de array om de beste scores te krijgen, en draaien vervolgens om ze van meest naar minst relevant te rangschikken.

Met scikit-learn

Wanneer u niet op zoek bent naar een document, maar het volledige corpus met zichzelf wilt vergelijken—om bijvoorbeeld duplicaten op te sporen of clustering voor te bereiden—biedt scikit-learn een geoptimaliseerde functie die de volledige matrix retourneert.

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Gelijkenismatrix tussen alle documenten
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)

print(f"Shape: {sim_matrix.shape}")  # (n, n)
print(f"Gelijkenis doc 0 ↔ doc 1: {sim_matrix[0][1]:.4f}")

Houd er rekening mee dat deze matrix een grootte heeft van n × n: tienduizend documenten produceren honderd miljoen waarden, ongeveer 400 MB in float32. Verwerk bij meer dan een paar duizend elementen in blokken in plaats van één enkele aanroep te doen.

Belangrijkste punten

  • Cosinusgelijkenis meet de hoek tussen vectoren, onafhankelijk van hun grootte
  • OpenAI-embeddings zijn genormaliseerd: inproduct = cosinus
  • Een score > 0,85 wijst op zeer vergelijkbare teksten
  • Zoeken naar naaste buren gebeurt efficiënt met NumPy of scikit-learn