Distans och cosinuslikhet
På denna sida
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äng | Tolkning |
|---|---|
| > 0,85 | Mycket lika (parafraser, synonymer) |
| 0,70 – 0,85 | Tematiskt relaterade |
| 0,40 – 0,70 | Löst relaterade |
| < 0,40 | Olika ä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