Distanța și similaritatea cosinus
Pe această pagină
Obiective
- Înțelegeți similaritatea cosinus și motivul pentru care este preferată
- Implementați compararea vectorilor în Python
- Interpretați scorurile de similaritate
Măsurarea proximității dintre vectori
Odată ce ați convertit textele în vectori, totul depinde de o singură întrebare: cum decideți dacă doi vectori sunt „apropiați“? Există trei răspunsuri posibile, iar alegerea contează.
Distanța euclidiană este distanța geometrică clasică – cea pe care ați măsura-o cu o riglă între două puncte. Este intuitivă, dar depinde de magnitudinea vectorului: două texte cu același sens, dintre care unul este codificat cu o amplitudine mai mare, ar părea artificial îndepărtate.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Produsul scalar însumează produsele element cu element. Este cea mai rapidă operație din familie – cea pe care procesorul o execută cel mai eficient pe matrici mari.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Similaritatea cosinus, în final, măsoară unghiul dintre doi vectori indiferent de lungimea lor, ceea ce o face metrica standard pentru embeddings: contează doar direcția sensului, nu intensitatea acestuia.
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))
Valoarea variază de la -1 pentru direcții opuse la +1 pentru direcții identice. Un detaliu practic este esențial: embeddings-urile OpenAI sunt deja normalizate, ceea ce înseamnă că au o lungime de 1. Prin urmare, numitorul este egal cu 1, iar produsul scalar oferă exact același rezultat ca similaritatea cosinus – la un cost computațional mai mic. Aceasta este scurtătura pe care o vom folosi pe tot parcursul acestui curs.
Comparație practică
Nimic nu bate măsurarea unor propoziții reale. Să comparăm o propoziție, parafraza sa completă și o propoziție fără legătură cu subiectul:
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
# Propoziții de comparat
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()}
# Compară toate perechile
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()
Rezultat tipic:
sim(a, b) = 0.8923 ← sens foarte apropiat
sim(a, c) = 0.1247 ← subiecte diferite
sim(b, c) = 0.1189 ← subiecte diferite
Propozițiile a și b nu au niciun cuvânt comun – cat/feline, sleeps/dozes, couch/sofa – totuși obțin un scor de 0,89. Acesta este exact ceea ce nicio metodă lexicală nu poate realiza.
Interpretarea scorurilor
Pragurile depind de cazul dumneavoastră de utilizare, dar tabelul de mai jos oferă puncte de referință pentru citirea unui scor fără a greși cu un ordin de mărime.
| Scor | Interpretare |
|---|---|
| > 0,85 | Foarte similare (parafraze, sinonime) |
| 0,70 – 0,85 | Corelate tematic |
| 0,40 – 0,70 | Slab corelate |
| < 0,40 | Subiecte diferite |
Aceste valori variază în funcție de model și domeniu: un corpus juridic, unde toate textele partajează același vocabular formal, produce în general scoruri mai mari decât un corpus de uz general, până la punctul în care un prag de 0,70 devine prea permisiv. Calibrați întotdeauna pe propriile date observând treizeci de perechi pentru care cunoașteți răspunsul așteptat.
Căutarea celui mai apropiat vecin
Găsirea unui document înseamnă calcularea similarității dintre vectorul interogării și toți vectorii din corpus, apoi păstrarea primilor k. Trucul este să evitați bucla în Python: o înmulțire de matrici NumPy calculează toate similaritățile deodată, într-o fracțiune de secundă.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Returnează cele mai similare k documente."""
query = np.array(query_embedding)
# Calcul vectorizat al tuturor similarităților
similarities = corpus_embeddings @ query
# (funcționează deoarece embeddings-urile OpenAI sunt normalizate)
# Indicii pentru cele mai mari k scoruri
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Utilizare
corpus = np.load("embeddings.npy") # matrice (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}")
Secvența [-k:][::-1] merită o a doua privire: argsort sortează în ordine crescătoare, așa că luăm sfârșitul tabloului pentru a obține cele mai bune scoruri, apoi inversăm pentru a le clasifica de la cele mai relevante la cele mai puțin relevante.
Cu scikit-learn
Când nu căutați un document, ci doriți să comparați întregul corpus cu el însuși – pentru a detecta duplicate, de exemplu, sau pentru a vă pregăti pentru clustering – scikit-learn oferă o funcție optimizată care returnează matricea completă.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Matrice de similaritate între toate documentele
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)
print(f"Shape: {sim_matrix.shape}") # (n, n)
print(f"Similaritate doc 0 ↔ doc 1: {sim_matrix[0][1]:.4f}")
Rețineți că această matrice are dimensiunea n × n: zece mii de documente produc o sută de milioane de valori, aproximativ 400 MB în float32. Dincolo de câteva mii de elemente, procesați în blocuri în loc să faceți un singur apel.
Puncte cheie
- Similaritatea cosinus măsoară unghiul dintre vectori, independent de magnitudinea lor
- Embeddings-urile OpenAI sunt normalizate: produs scalar = cosinus
- Un scor > 0,85 indică texte foarte similare
- Căutarea celui mai apropiat vecin se face eficient cu NumPy sau scikit-learn