Razdalja in kosinusna podobnost
Na tej strani
Cilji
- Razumevanje kosinusne podobnosti in razlogov za njeno prednost
- Implementacija primerjave vektorjev v Pythonu
- Interpretacija rezultatov podobnosti
Merjenje bližine med vektorji
Ko besedila pretvoriš v vektorje, je vse odvisno od enega vprašanja: kako se odločiš, ali sta dva vektorja „blizu”? Obstajajo trije odgovori in izbira je pomembna.
Evklidska razdalja je klasična geometrijska razdalja – tista, ki bi jo izmeril z ravnilom med dvema točkama. Intuitivna je, vendar je odvisna od velikosti (magnitude) vektorja: dve besedili z enakim pomenom, kjer je eno kodirano z večjo amplitudo, bi se umetno zdela zelo oddaljeni.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Skalarni produkt sešteje produkte posameznih elementov. To je najhitrejša operacija v družini – tista, ki jo procesor na velikih matrikah izvrši najbolj učinkovito.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Kosinusna podobnost nazadnje meri kot med dvema vektorjema ne glede na njuno dolžino, zaradi česar je standardna metrika za vdelave (embeddings): pomembna je le smer pomena, ne njegova intenzivnost.
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))
Vrednost se giblje od -1 za nasprotne smeri do +1 za identične smeri. Pomembna je ena praktična podrobnost: vdelave OpenAI so že normalizirane, kar pomeni, da imajo dolžino 1. Imenovalec je zato enak 1 in skalarni produkt daje popolnoma enak rezultat kot kosinusna podobnost – ob nižjih računalniških stroških. To je bližnjica, ki jo bomo uporabljali skozi celoten tečaj.
Praktična primerjava
Nič ne premaga merjenja na realnih stavkih. Primerjajmo stavek, njegovo popolno parafrazo in stavek, ki ni povezan s temo:
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
# Stavki za primerjavo
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()}
# Primerjava vseh parov
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()
Tipičen rezultat:
sim(a, b) = 0.8923 ← zelo podoben pomen
sim(a, c) = 0.1247 ← različne teme
sim(b, c) = 0.1189 ← različne teme
Stavka a in b nimata skupnih besed – mačka/felina, spi/drema, kavč/sofa –, vendar dosežeta oceno 0,89. Točno to je tisto, česar nobena leksikalna metoda ne more doseči.
Interpretacija rezultatov
Pragovi so odvisni od tvoje uporabe, vendar spodnja tabela podaja referenčne točke za branje rezultata, ne da bi zgrešil za red velikosti.
| Rezultat | Interpretacija |
|---|---|
| > 0,85 | Zelo podobno (parafraze, sopomenke) |
| 0,70 – 0,85 | Tematsko povezano |
| 0,40 – 0,70 | Ohlapno povezano |
| < 0,40 | Različne teme |
Te vrednosti se razlikujejo glede na model in področje: pravni korpus, kjer vsa besedila delijo isto formalno besedišče, proizvede na splošno višje rezultate kot korpus splošne namembnosti, in sicer do te mere, da prag 0,70 postane preveč dopustljiv. Vedno umeri sistem na svojih podatkih tako, da opazuješ trideset ali več parov, kjer poznaš pričakovani odgovor.
Iskanje najbližjih sosedov
Iskanje dokumenta pomeni izračun podobnosti med vektorjem poizvedbe in vsemi vektorji v korpusu, nato pa obdržiš najboljših k. Trik je v izogibanju zankam v Pythonu: množenje matrik NumPy izračuna vse podobnosti hkrati, v delčku časa.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Vrne k najbolj podobnih dokumentov."""
query = np.array(query_embedding)
# Vektoriziran izračun vseh podobnosti
similarities = corpus_embeddings @ query
# (deluje, ker so vdelave OpenAI normalizirane)
# Indeksi najboljših k rezultatov
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Uporaba
corpus = np.load("embeddings.npy") # matrika (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}")
Del [-k:][::-1] si zasluži drugi pogled: argsort razvršča v naraščajočem vrstnem redu, zato vzamemo konec polja, da dobimo najboljše rezultate, nato pa ga obrnemo, da jih razvrstimo od najbolj do najmanj relevantnih.
S knjižnico scikit-learn
Ko ne iščeš dokumenta, ampak želiš primerjati celoten korpus sam s seboj – na primer za odkrivanje duplikatov ali pripravo na gručenje (clustering) – scikit-learn ponuja optimizirano funkcijo, ki vrne celotno matriko.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Matrika podobnosti med vsemi dokumenti
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}")
Imej v mislih, da je ta matrika velikosti n × n: deset tisoč dokumentov proizvede sto milijonov vrednosti, kar znaša približno 400 MB v formatu float32. Pri več kot nekaj tisoč elementi obdeluj podatke v blokih, namesto da bi opravil en sam klic.
Ključne ugotovitve
- Kosinusna podobnost meri kot med vektorji, neodvisno od njihove velikosti
- Vdelave OpenAI so normalizirane: skalarni produkt = kosinus
- Rezultat > 0,85 kaže na zelo podobna besedila
- Iskanje najbližjih sosedov se učinkovito izvaja z NumPy ali scikit-learn