Udaljenost i kosinusna sličnost
Na ovoj stranici
Ciljevi
- Razumjeti kosinusnu sličnost i zašto se preferira
- Implementirati usporedbu vektora u Pythonu
- Interpretirati rezultate sličnosti
Mjerenje blizine između vektora
Kada pretvoriš tekstove u vektore, sve se svodi na jedno pitanje: kako odlučiti jesu li dva vektora “blizu”? Postoje tri odgovora, a izbor je bitan.
Euklidska udaljenost klasična je geometrijska udaljenost – ona koju bi izmjerio ravnalom između dviju točaka. Intuitivna je, ali ovisi o veličini (magnitudi) vektora: dva teksta istog značenja, gdje je jedan kodiran većom amplitudom, umjetno bi se činila udaljenima.
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 umnožak (dot product) zbraja umnoške po elementima. To je najbrža operacija u obitelji – ona koju procesor najučinkovitije izvršava na velikim matricama.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Kosinusna sličnost, naposljetku, mjeri kut između dva vektora bez obzira na njihovu duljinu, što je čini standardnom metrikom za embedinge: bitan je samo smjer značenja, a ne njegov intenzitet.
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))
Vrijednosti se kreću od -1 za suprotne smjerove do +1 za identične smjerove. Jedna praktična pojedinost je ključna: OpenAI embedinzi su već normalizirani, što znači da imaju duljinu 1. Nazivnik je stoga jednak 1, pa skalarni umnožak daje točno isti rezultat kao i kosinusna sličnost – uz manji računalni trošak. To je prečac koji ćemo koristiti tijekom cijelog ovog tečaja.
Praktična usporedba
Ništa ne nadmašuje mjerenje na stvarnim rečenicama. Usporedimo rečenicu, njezinu potpunu parafrazu i rečenicu izvan teme:
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
# Rečenice za usporedbu
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()}
# Usporedi sve parove
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čan rezultat:
sim(a, b) = 0.8923 ← vrlo blisko značenje
sim(a, c) = 0.1247 ← različite teme
sim(b, c) = 0.1189 ← različite teme
Rečenice a i b nemaju zajedničkih riječi – cat/feline, sleeps/dozes, couch/sofa – ipak postižu rezultat 0,89. To je točno ono što nijedna leksička metoda ne može postići.
Interpretacija rezultata
Pragovi ovise o tvom slučaju upotrebe, ali donja tablica daje referentne točke za čitanje rezultata kako ne bi promašio red veličine.
| Rezultat | Interpretacija |
|---|---|
| > 0,85 | Vrlo slično (parafraze, sinonimi) |
| 0,70 – 0,85 | Tematski povezano |
| 0,40 – 0,70 | Labavo povezano |
| < 0,40 | Različite teme |
Ove vrijednosti variraju ovisno o modelu i domeni: pravni korpus, gdje svi tekstovi dijele isti formalni rječnik, proizvodi općenito više rezultate od korpusa opće namjene, do te mjere da prag od 0,70 postaje previše propustan. Uvijek kalibriraj na vlastitim podacima promatranjem tridesetak parova za koje znaš očekivani odgovor.
Pretraživanje najbližih susjeda
Pronalaženje dokumenta znači izračunavanje sličnosti između vektora upita i svih vektora u korpusu, a zatim zadržavanje najboljih k. Trik je izbjeći petlje u Pythonu: množenje NumPy matrica izračunava sve sličnosti odjednom, u djeliću vremena.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Vraća k najsličnijih dokumenata."""
query = np.array(query_embedding)
# Vektorizirani izračun svih sličnosti
similarities = corpus_embeddings @ query
# (funkcionira jer su OpenAI embedinzi normalizirani)
# Indeksi top k rezultata
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Upotreba
corpus = np.load("embeddings.npy") # matrica (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}")
Dio [-k:][::-1] zaslužuje drugi pogled: argsort sortira u uzlaznom redoslijedu, pa uzimamo kraj niza kako bismo dobili najbolje rezultate, a zatim ga obrćemo kako bismo ih rangirali od najrelevantnijih prema najmanje relevantnima.
Uz scikit-learn
Kada ne tražiš dokument, već želiš usporediti cijeli korpus sa samim sobom – na primjer, za otkrivanje duplikata ili pripremu za klasteriranje – scikit-learn nudi optimiziranu funkciju koja vraća punu matricu.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Matrica sličnosti između svih dokumenata
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}")
Imaj na umu da je ova matrica veličine n × n: deset tisuća dokumenata proizvodi sto milijuna vrijednosti, što je oko 400 MB u formatu float32. Iznad nekoliko tisuća elemenata, obrađuj podatke u blokovima umjesto jednim pozivom.
Ključne točke
- Kosinusna sličnost mjeri kut između vektora, neovisno o njihovoj veličini
- OpenAI embedinzi su normalizirani: skalarni umnožak = kosinus
- Rezultat > 0,85 ukazuje na vrlo slične tekstove
- Pretraživanje najbližih susjeda učinkovito se izvodi s NumPyjem ili scikit-learnom