Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Afstand og cosinusligehed

Lektion 4 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Måling af nærhed mellem vektorer
  3. Praktisk sammenligning
  4. Fortolkning af scorer
  5. Søgning efter nærmeste nabo
  6. Med scikit-learn
  7. Vigtige pointer

Mål

  • Forstå cosinusligehed og hvorfor den foretrækkes
  • Implementere vektorsammenligning i Python
  • Fortolke lighedsscorer

Måling af nærhed mellem vektorer

Når du har konverteret dine tekster til vektorer, afhænger alt af ét spørgsmål: Hvordan afgør du, om to vektorer er “tætte” på hinanden? Tre svar eksisterer sideløbende, og valget betyder noget.

Euklidisk afstand er den klassiske geometriske afstand – den, du ville måle med en lineal mellem to punkter. Den er intuitiv, men den afhænger af vektorens størrelse: To tekster med samme betydning, hvor den ene er kodet med højere amplitude, vil kunstigt fremstå langt fra hinanden.

import numpy as np

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

Prikproduktet summerer produkterne af elementerne parvis. Det er den hurtigste operation i familien – den, processoren udfører mest effektivt på store matricer.

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

Cosinusligehed måler endelig vinklen mellem to vektorer uafhængigt af deres længde, hvilket gør den til standardmetrikken for embeddings: Kun betydningens retning tæller, ikke dens intensitet.

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

Den varierer fra -1 for modsatte retninger til +1 for identiske retninger. Én praktisk detalje er vigtig: OpenAI embeddings er allerede normaliserede, hvilket betyder, at de har en længde på 1. Nævneren bliver derfor 1, og prikproduktet giver præcis samme resultat som cosinusligehed – men med lavere beregningsomkostninger. Det er den genvej, vi vil bruge gennem hele dette kursus.

Praktisk sammenligning

Intet slår måling på rigtige sætninger. Lad os sammenligne en sætning, dens fulde parafrase og en sætning uden for emnet:

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

# Sætninger der skal sammenlignes
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()}

# Sammenlign alle par
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()

Typisk resultat:

sim(a, b) = 0.8923   ← meget tæt betydning
sim(a, c) = 0.1247   ← forskellige emner
sim(b, c) = 0.1189   ← forskellige emner

Sætningerne a og b deler ingen ord – cat/feline, sleeps/dozes, couch/sofa – alligevel scorer de 0,89. Det er præcis det, ingen leksikalsk metode kan opnå.

Fortolkning af scorer

Tærskelværdier afhænger af dit brugstilfælde, men tabellen nedenfor giver referencepunkter til at læse en score uden at ramme ved siden af med en størrelsesorden.

ScoreFortolkning
> 0,85Meget lig (parafraser, synonymer)
0,70 – 0,85Tematisk relateret
0,40 – 0,70Løst relateret
< 0,40Forskellige emner

Disse værdier varierer afhængigt af model og domæne: Et juridisk korpus, hvor alle tekster deler det samme formelle ordforråd, producerer generelt højere scorer end et generelt korpus, så meget at en tærskel på 0,70 bliver for lempelig. Kalibrér altid på dine egne data ved at observere omkring tredive par, hvor du kender det forventede svar.

Søgning efter nærmeste nabo

At finde et dokument betyder at beregne ligheden mellem forespørgselsvektoren og alle vektorer i korpussen og derefter beholde de øverste k. Tricket er at undgå loops i Python: En matrixmultiplikation i NumPy beregner alle ligheder på én gang på en brøkdel af tiden.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Returnerer de k mest lignende dokumenter."""
    query = np.array(query_embedding)

    # Vektoriseret beregning af alle ligheder
    similarities = corpus_embeddings @ query
    # (fungerer fordi OpenAI embeddings er normaliserede)

    # Indekser for de øverste k scorer
    top_k_indices = np.argsort(similarities)[-k:][::-1]

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

# Brug
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"Dokument {idx}: score = {score:.4f}")

[-k:][::-1] fortjener et andet kig: argsort sorterer i stigende rækkefølge, så vi tager slutningen af arrayet for at få de bedste scorer og vender derefter rækkefølgen for at rangere dem fra mest til mindst relevant.

Med scikit-learn

Når du ikke leder efter et specifikt dokument, men ønsker at sammenligne hele korpussen med sig selv – for eksempel for at opdage dubletter eller forberede klyngedannelse – tilbyder scikit-learn en optimeret funktion, der returnerer hele matricen.

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

# Lighedsmatrix mellem alle dokumenter
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)

print(f"Form: {sim_matrix.shape}")  # (n, n)
print(f"Lighed dok 0 ↔ dok 1: {sim_matrix[0][1]:.4f}")

Husk på, at denne matrix har størrelsen n × n: Ti tusinde dokumenter producerer hundrede millioner værdier, hvilket svarer til ca. 400 MB i float32. Ud over nogle få tusinde elementer bør du behandle data i blokke i stedet for at foretage et enkelt opkald.

Vigtige pointer

  • Cosinusligehed måler vinklen mellem vektorer uafhængigt af deres størrelse
  • OpenAI embeddings er normaliserede: prikprodukt = cosinus
  • En score > 0,85 indikerer meget lignende tekster
  • Søgning efter nærmeste nabo udføres effektivt med NumPy eller scikit-learn