Távolság és koszinusz-hasonlóság
Ezen az oldalon
Célok
- Megérteni a koszinusz-hasonlóságot és azt, miért ezt részesítik előnyben
- Vektor-összehasonlítás megvalósítása Pythonban
- Hasonlósági pontszámok értelmezése
Távolság mérése vektorok között
Miután szövegeidet vektorokká alakítottad, minden egyetlen kérdésen múlik: hogyan döntöd el, hogy két vektor „közel“ van-e egymáshoz? Három válasz létezik, és a választás számít.
Az euklideszi távolság a klasszikus geometriai távolság – az, amit vonalzóval mérnél két pont között. Intuitív, de függ a vektor nagyságától: két azonos jelentésű szöveg esetén, ha az egyiket nagyobb amplitúdóval kódolták, mesterségesen távolinak tűnhetnek egymástól.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
A skaláris szorzat az elemenkénti szorzatok összegét adja. Ez a leggyorsabb művelet a családban – a processzor ezt hajtja végre a leghatékonyabban nagy mátrixokon.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Végül a koszinusz-hasonlóság a két vektor közötti szöget méri, függetlenül a hosszuktól, így ez a szabványos mérőszám a beágyazásokhoz: csak a jelentés iránya számít, nem az intenzitása.
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))
Értéke -1-től (ellentétes irány) +1-ig (azonos irány) terjed. Egy gyakorlati részlet fontos: az OpenAI beágyazások már normalizáltak, ami azt jelenti, hogy hosszuk 1. A nevező ezért 1, és a skaláris szorzat pontosan ugyanazt az eredményt adja, mint a koszinusz-hasonlóság – kisebb számítási költséggel. Ezt a rövidítést használjuk végig ezen a tanfolyamon.
Gyakorlati összehasonlítás
Semmi sem helyettesíti a valódi mondatok mérését. Hasonlítsunk össze egy mondatot, annak teljes átfogalmazását és egy témán kívüli mondatot:
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
# Összehasonlítandó mondatok
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()}
# Minden pár összehasonlítása
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()
Tipikus eredmény:
sim(a, b) = 0.8923 ← nagyon közeli jelentés
sim(a, c) = 0.1247 ← különböző témák
sim(b, c) = 0.1189 ← különböző témák
Az „a“ és „b“ mondatoknak nincs közös szavuk – macska/félelem, alszik/szundikál, kanapé/divány –, mégis 0,89-es pontszámot érnek el. Pontosan ezt nem képes elérni egyetlen lexikális módszer sem.
Pontszámok értelmezése
A küszöbértékek a felhasználási esettől függenek, de az alábbi táblázat referenciaértékeket ad a pontszám olvasásához, hogy ne tévedj nagyságrenddel.
| Pontszám | Értelmezés |
|---|---|
| > 0,85 | Nagyon hasonló (átfogalmazások, szinonimák) |
| 0,70 – 0,85 | Tematikusan kapcsolódó |
| 0,40 – 0,70 | Lazán kapcsolódó |
| < 0,40 | Különböző témák |
Ezek az értékek modellenként és domainenként változnak: egy jogi korpusz, ahol minden szöveg ugyanazt a formális szókincset használja, általában magasabb pontszámokat produkál, mint egy általános célú korpusz, egészen addig, hogy a 0,70-es küszöb túl megengedővé válik. Mindig kalibráld a saját adataidon úgy, hogy megfigyelsz harminc olyan párt, ahol ismered a várt választ.
Legközelebbi szomszéd keresése
Egy dokumentum megtalálása azt jelenti, hogy kiszámolod a hasonlóságot a lekérdezés vektora és a korpusz összes vektora között, majd megtartod a legjobb k darabot. A trükk az, hogy elkerüld a Python-ciklusokat: egy NumPy mátrixszorzás egyszerre számolja ki az összes hasonlóságot, a idő töredéke alatt.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Visszaadja a k leginkább hasonló dokumentumot."""
query = np.array(query_embedding)
# Összes hasonlóság vektorizált számítása
similarities = corpus_embeddings @ query
# (működik, mert az OpenAI beágyazások normalizáltak)
A legjobb k pontszám indexei
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Használat
corpus = np.load("embeddings.npy") # mátrix (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}")
A [-k:][::-1] részlet deserves egy második pillantást: az argsort növekvő sorrendbe rendez, ezért a tömb végét vesszük, hogy megkapjuk a legjobb pontszámokat, majd megfordítjuk, hogy a legrelevánsabbtól a legkevésbé relevánsig rangsoroljuk őket.
scikit-learn-nel
Ha nem egy dokumentumot keresel, hanem az egész korpuszt akarod önmagával összehasonlítani – például duplikációk észlelésére vagy klaszterezés előkészítésére –, a scikit-learn optimalizált függvényt biztosít, amely visszaadja a teljes mátrixot.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Hasonlósági mátrix az összes dokumentum között
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)
print(f"Shape: {sim_matrix.shape}") # (n, n)
print(f"Similarity doc 0 ↔ doc 1: {sim_matrix[0][1]:.4f}")
Ne feledd, hogy ez a mátrix n × n méretű: tízezer dokumentum százmillió értéket eredményez, ami float32-ben körülbelül 400 MB. Néhány ezer elemen túl blokkokban dolgozz, ne egyetlen hívással.
Főbb megállapítások
- A koszinusz-hasonlóság a vektorok közötti szöget méri, függetlenül a nagyságuktól
- Az OpenAI beágyazások normalizáltak: skaláris szorzat = koszinusz
- A > 0,85 pontszám nagyon hasonló szövegeket jelez
- A legközelebbi szomszéd keresése hatékonyan végezhető NumPy-val vagy scikit-learn-nel