Vzdálenost a kosinová podobnost
Na této stránce
Cíle
- Porozumět kosinové podobnosti a důvodům, proč je upřednostňována
- Implementovat porovnávání vektorů v Pythonu
- Interpretovat skóre podobnosti
Měření blízkosti mezi vektory
Jakmile převedeš své texty na vektory, vše závisí na jedné otázce: jak rozhodneš, zda jsou dva vektory „blízko“ u sebe? Existují tři odpovědi a výběr záleží.
Eukleidovská vzdálenost je klasická geometrická vzdálenost – ta, kterou bys změřil pravítkem mezi dvěma body. Je intuitivní, ale závisí na velikosti vektoru: dva texty se stejným významem, kde je jeden zakódován s vyšší amplitudou, by se uměle jevily jako velmi vzdálené.
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ární součin sčítá součiny prvků po složkách. Je to nejrychlejší operace v této rodině – tu, kterou procesor provádí nejefektivněji na velkých maticích.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Kosinová podobnost konečně měří úhel mezi dvěma vektory bez ohledu na jejich délku, což z ní činí standardní metriku pro embedingy: záleží pouze na směru významu, nikoliv na jeho intenzitě.
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))
Pohybuje se od -1 pro opačné směry do +1 pro totožné směry. Důležitý je jeden praktický detail: embedingy od OpenAI jsou již normalizované, což znamená, že mají délku 1. Jmenovatel se tedy rovná 1 a skalární součin dává přesně stejný výsledek jako kosinová podobnost – při nižších výpočetních nákladech. Toto je zkratka, kterou budeme používat v celém tomto kurzu.
Praktické srovnání
Nic nenahradí měření na reálných větách. Porovnejme větu, její úplnou parafrázi a větu mimo téma:
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
# Věty k porovnání
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()}
# Porovnání všech párů
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ýsledek:
sim(a, b) = 0.8923 ← velmi blízký význam
sim(a, c) = 0.1247 ← různá témata
sim(b, c) = 0.1189 ← různá témata
Věty a a b nemají žádná společná slova – cat/feline, sleeps/dozes, couch/sofa – přesto dosahují skóre 0,89. Toho žádná lexikální metoda nedosáhne.
Interpretace skóre
Prahové hodnoty závisí na tvém případě použití, ale následující tabulka poskytuje referenční body pro čtení skóre, abys se nespletl o řád.
| Skóre | Interpretace |
|---|---|
| > 0,85 | Velmi podobné (parafráze, synonyma) |
| 0,70 – 0,85 | Tematicky související |
| 0,40 – 0,70 | Volně související |
| < 0,40 | Různá témata |
Tyto hodnoty se liší podle modelu a domény: právní korpus, kde všechny texty sdílejí stejnou formální slovní zásobu, produkuje obecně vyšší skóre než korpus pro obecné účely, a to do té míry, že práh 0,70 se stává příliš benevolentním. Vždy kalibruj na vlastních datech pozorováním třicítky párů, u kterých znáš očekávanou odpověď.
Vyhledávání nejbližších sousedů
Najít dokument znamená vypočítat podobnost mezi vektorem dotazu a všemi vektory v korpusu a poté ponechat top k. Trik spočívá v vyhnutí se smyčkám v Pythonu: násobení matic v NumPy vypočítá všechny podobnosti najednou, ve zlomku času.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Vrátí k nejpodobnějších dokumentů."""
query = np.array(query_embedding)
# Vektorizovaný výpočet všech podobností
similarities = corpus_embeddings @ query
# (funguje, protože embedingy OpenAI jsou normalizované)
# Indexy top k skóre
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Použití
corpus = np.load("embeddings.npy") # matice (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}")
Část [-k:][::-1] si zaslouží druhý pohled: argsort řadí vzestupně, takže vezmeme konec pole, abychom získali nejlepší skóre, a poté ho obrátíme, abychom je seřadili od nejrelevantnějších po nejméně relevantní.
S knihovnou scikit-learn
Když nehledáš konkrétní dokument, ale chceš porovnat celý korpus sám se sebou – například pro detekci duplicit nebo přípravu na shlukování – scikit-learn poskytuje optimalizovanou funkci, která vrátí celou matici.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Matice podobnosti mezi všemi dokumenty
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}")
Měj na paměti, že tato matice má velikost n × n: deset tisíc dokumentů vytvoří sto milionů hodnot, což je přibližně 400 MB ve formátu float32. Nad několik tisíc prvků zpracovávej data po blocích, místo abys volal funkci najednou pro vše.
Klíčové poznatky
- Kosinová podobnost měří úhel mezi vektory nezávisle na jejich velikosti
- Embedingy OpenAI jsou normalizované: skalární součin = kosinová podobnost
- Skóre > 0,85 indikuje velmi podobné texty
- Vyhledávání nejbližších sousedů se efektivně provádí pomocí NumPy nebo scikit-learn