Vzdialenosť a kosínusová podobnosť
Na tejto strane
Ciele
- Pochopiť kosínusovú podobnosť a dôvody jej preferencie
- Implementovať porovnávanie vektorov v Pythone
- Interpretovať skóre podobnosti
Meranie blízkosti medzi vektormi
Keď už máš svoje texty prevedené na vektory, všetko sa točí okolo jednej otázky: ako rozhodneš, či sú dva vektory „blízko“ pri sebe? Existujú tri odpovede a výber záleží.
Euklidovská vzdialenosť je klasická geometrická vzdialenosť – tá, ktorú by si odmeral pravítkom medzi dvoma bodmi. Je intuitívna, ale závisí od veľkosti vektora: dva texty s rovnakým významom, kde jeden je zakódovaný s vyššou amplitúdou, by sa umelo javili ako veľmi vzdialené.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Skalárny súčin sčítava súčiny prvkov na rovnakých pozíciách. Je to najrýchlejšia operácia v tejto rodine – tú, ktorú procesor vykonáva najefektívnejšie na veľkých maticiach.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Kosínusová podobnosť napokon meria uhol medzi dvoma vektormi bez ohľadu na ich dĺžku, čo z nej robí štandardnú metriku pre vektory (embeddings): záleží len na smere významu, nie na jeho intenzite.
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))
Rozsah je od -1 pre opačné smery po +1 pre identické smery. Dôležitý je jeden praktický detail: vektory od OpenAI sú už normalizované, čo znamená, že majú dĺžku 1. Menovateľ sa teda rovná 1 a skalárny súčin poskytuje presne rovnaký výsledok ako kosínusová podobnosť – pri nižších výpočtových nákladoch. Toto je skratka, ktorú budeme používať počas celého tohto kurzu.
Praktické porovnanie
Nič nenahradí meranie na reálnych vetách. Porovnajme vetu, jej úplnú parafrázu a vetu mimo témy:
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
# Vety na porovnanie
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()}
# Porovnať všetky páry
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()
Typický výsledok:
sim(a, b) = 0.8923 ← veľmi blízky význam
sim(a, c) = 0.1247 ← rôzne témy
sim(b, c) = 0.1189 ← rôzne témy
Vety a a b nemajú spoločné žiadne slová – mačka/feline, spí/dozes, gauč/sofa – no dosahujú skóre 0,89. Presne to je niečo, čo žiadna lexikálna metóda nedokáže.
Interpretácia skóre
Prahové hodnoty závisia od tvojho prípadu použitia, ale nasledujúca tabuľka poskytuje referenčné body na čítanie skóra bez chyby o rád.
| Skóre | Interpretácia |
|---|---|
| > 0,85 | Veľmi podobné (parafrázy, synonymá) |
| 0,70 – 0,85 | Tematicky súvisiace |
| 0,40 – 0,70 | Voľne súvisiace |
| < 0,40 | Rôzne témy |
Tieto hodnoty sa líšia podľa modelu a domény: právny korpus, kde všetky texty zdieľajú rovnakú formálnu slovnú zásobu, produkuje všeobecne vyššie skóre než všeobecný korpus, a to až do bodu, keď sa prah 0,70 stáva príliš benevolentným. Vždy kalibruj na vlastných dátach pozorovaním tridsiatich párov, pri ktorých poznáš očakávanú odpoveď.
Vyhľadávanie najbližších susedov
Nájsť dokument znamená vypočítať podobnosť medzi vektorom dotazu a všetkými vektormi v korpuse a potom ponechať najlepších k. Trik spočíva v vyhnutí sa cyklom v Pythone: násobenie matíc v NumPy vypočíta všetky podobnosti naraz, v zlomku času.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Vráti k najpodobnejších dokumentov."""
query = np.array(query_embedding)
# Vektorizovaný výpočet všetkých podobností
similarities = corpus_embeddings @ query
# (funguje, pretože vektory OpenAI sú normalizované)
# Indexy najlepších k skóre
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Použitie
corpus = np.load("embeddings.npy") # matica (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}")
Časť [-k:][::-1] si zaslúži druhý pohľad: argsort triedi vzostupne, takže vezmeme koniec poľa, aby sme získali najlepšie skóre, a potom ho obrátime, aby sme ich zoradili od najrelevantnejších po najmenej relevantné.
Pomocou knižnice scikit-learn
Ak nehľadáš konkrétny dokument, ale chceš porovnať celý korpus so sebou samým – napríklad na detekciu duplikátov alebo prípravu na zhlukovanie – scikit-learn poskytuje optimalizovanú funkciu, ktorá vráti celú maticu.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Matica podobnosti medzi všetkými dokumentmi
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}")
Maj na pamäti, že táto matica má veľkosť n × n: desaťtisíc dokumentov vytvorí sto miliónov hodnôt, čo je približne 400 MB vo formáte float32. Pri viac než niekoľkých tisícovkách prvkov spracúvaj dáta po blokoch namiesto jedného volania.
Kľúčové poznatky
- Kosínusová podobnosť meria uhol medzi vektormi nezávisle od ich veľkosti
- Vektory OpenAI sú normalizované: skalárny súčin sa rovná kosínusu
- Skóre > 0,85 indikuje veľmi podobné texty
- Vyhľadávanie najbližších susedov sa efektívne vykonáva pomocou NumPy alebo scikit-learn