Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Distans och cosinuslikhet

Lektion 4 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Att mäta närhet mellan vektorer
  3. Praktisk jämförelse
  4. Att tolka poäng
  5. Sökning efter närmaste granne
  6. Med scikit-learn
  7. Viktiga punkter

Mål

  • Förstå cosinuslikhet och varför den föredras
  • Implementera vektorjämförelse i Python
  • Tolka likhetspoäng

Att mäta närhet mellan vektorer

När du har omvandlat dina texter till vektorer handlar allt om en enda fråga: hur avgör du om två vektorer är “nära” varandra? Tre svar existerar samtidigt, och valet spelar roll.

Euklidiskt avstånd är det klassiska geometriska avståndet – det du skulle mäta med en linjal mellan två punkter. Det är intuitivt, men det beror på vektorns magnitud: två texter med samma betydelse, där den ena kodats med högre amplitud, skulle artificiellt verka långt ifrån varandra.

import numpy as np

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

Punktprodukten summerar de elementvisa produkterna. Det är den snabbaste operationen i familjen – den som processorn utför mest effektivt på stora matriser.

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

Cosinuslikhet mäter slutligen vinkeln mellan två vektorer oavsett deras längd, vilket gör den till standardmåttet för embeddings: endast betydelsens riktning spelar roll, inte dess 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))

Värdet sträcker sig från -1 för motsatta riktningar till +1 för identiska riktningar. En praktisk detalj är viktig: OpenAI-embeddings är redan normaliserade, vilket innebär att de har längden 1. Nämnaren blir därför 1, och punktprodukten ger exakt samma resultat som cosinuslikhet – men till en lägre beräkningskostnad. Detta är genvägen vi kommer att använda genom hela denna kurs.

Praktisk jämförelse

Inget slår att mäta på verkliga meningar. Låt oss jämföra en mening, en fullständig parafras av den och en mening som inte hör till ämnet:

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

# Meningar att jämföra
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()}

# Jämför alla 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()

Typiskt resultat:

sim(a, b) = 0.8923   ← mycket nära betydelse
sim(a, c) = 0.1247   ← olika ämnen
sim(b, c) = 0.1189   ← olika ämnen

Meningarna a och b delar inga ord – cat/feline, sleeps/dozes, couch/sofa – ändå får de poängen 0,89. Detta är exakt vad ingen lexikalisk metod kan uppnå.

Att tolka poäng

Tröskelvärden beror på ditt användningsområde, men tabellen nedan ger referenspunkter för att läsa av en poäng utan att missa med en storleksordning.

PoängTolkning
> 0,85Mycket lika (parafraser, synonymer)
0,70 – 0,85Tematiskt relaterade
0,40 – 0,70Löst relaterade
< 0,40Olika ämnen

Dessa värden varierar beroende på modell och domän: ett juridiskt korpus, där alla texter delar samma formella ordförråd, ger generellt högre poäng än ett allmänt korpus, så pass att en tröskel på 0,70 blir för tillåtande. Kalibrera alltid på dina egna data genom att observera trettio eller så par där du känner till det förväntade svaret.

Sökning efter närmaste granne

Att hitta ett dokument innebär att du beräknar likheten mellan frågevektorn och alla vektorer i korpuset, för att sedan behålla de k bästa. Trickset är att undvika loopar i Python: en matrismultiplikation med NumPy beräknar alla likheter på en gång, på en bråkdels sekund.

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

    # Vektoriserad beräkning av alla likheter
    similarities = corpus_embeddings @ query
    # (fungerar eftersom OpenAI-embeddings är normaliserade)

    # Index för de k högsta poängen
    top_k_indices = np.argsort(similarities)[-k:][::-1]

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

# Användning
corpus = np.load("embeddings.npy")  # matris (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}: poäng = {score:.4f}")

[-k:][::-1] förtjänar en andra titt: argsort sorterar i stigande ordning, så vi tar slutet av arrayen för att få de bästa poängen, och vänder sedan ordningen för att rangordna dem från mest till minst relevanta.

Med scikit-learn

När du inte söker efter ett specifikt dokument utan vill jämföra hela korpuset med sig självt – för att till exempel upptäcka dubbletter eller förbereda för klustring – erbjuder scikit-learn en optimerad funktion som returnerar hela matrisen.

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

# Likhetsmatris mellan alla dokument
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)

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

Tänk på att denna matris har storleken n × n: tiotusen dokument ger hundra miljoner värden, cirka 400 MB i float32. Utöver några tusen element bör du bearbeta data i block istället för att göra ett enda anrop.

Viktiga punkter

  • Cosinuslikhet mäter vinkeln mellan vektorer, oberoende av deras magnitud
  • OpenAI-embeddings är normaliserade: punktprodukt = cosinus
  • En poäng > 0,85 indikerar mycket lika texter
  • Sökning efter närmaste granne görs effektivt med NumPy eller scikit-learn