Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Távolság és koszinusz-hasonlóság

4. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Távolság mérése vektorok között
  3. Gyakorlati összehasonlítás
  4. Pontszámok értelmezése
  5. Legközelebbi szomszéd keresése
  6. scikit-learn-nel
  7. Főbb megállapítások

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,85Nagyon hasonló (átfogalmazások, szinonimák)
0,70 – 0,85Tematikusan kapcsolódó
0,40 – 0,70Lazán kapcsolódó
< 0,40Kü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