Distância e Similaridade de Cosseno
Nesta página
Objetivos
- Compreender a similaridade de cosseno e por que é preferida
- Implementar a comparação de vetores em Python
- Interpretar pontuações de similaridade
Medir a Proximidade Entre Vetores
Depois de converter os seus textos em vetores, tudo depende de uma questão: como decide se dois vetores estão “próximos”? Existem três respostas possíveis e a escolha faz toda a diferença.
A distância euclidiana é a distância geométrica clássica — aquela que mediria com uma régua entre dois pontos. É intuitiva, mas depende da magnitude do vetor: dois textos com o mesmo significado, onde um é codificado com maior amplitude, pareceriam artificialmente distantes.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
O produto escalar soma os produtos elemento a elemento. É a operação mais rápida da família — aquela que o processador executa com maior eficiência em matrizes grandes.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
A similaridade de cosseno, por fim, mede o ângulo entre dois vetores independentemente do seu comprimento, tornando-a a métrica padrão para embeddings: apenas a direção do significado importa, não a sua intensidade.
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))
Varia de -1 para direções opostas a +1 para direções idênticas. Um detalhe prático é crucial: os embeddings da OpenAI já estão normalizados, ou seja, têm comprimento 1. O denominador é, portanto, igual a 1 e o produto escalar produz exatamente o mesmo resultado que a similaridade de cosseno — com um custo computacional menor. Este é o atalho que utilizaremos ao longo deste curso.
Comparação Prática
Nada supera a medição de frases reais. Vamos comparar uma frase, a sua paráfrase completa e uma frase fora de contexto:
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
# Sentences to compare
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()}
# Compare all pairs
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()
Resultado típico:
sim(a, b) = 0.8923 ← very close meaning
sim(a, c) = 0.1247 ← different topics
sim(b, c) = 0.1189 ← different topics
As frases a e b não partilham palavras — cat/feline, sleeps/dozes, couch/sofa — no entanto, obtêm uma pontuação de 0,89. É exatamente isto que nenhum método lexical consegue alcançar.
Interpretar Pontuações
Os limiares dependem do seu caso de uso, mas a tabela abaixo fornece pontos de referência para ler uma pontuação sem errar por uma ordem de grandeza.
| Pontuação | Interpretação |
|---|---|
| > 0,85 | Muito semelhante (paráfrases, sinónimos) |
| 0,70 – 0,85 | Tematicamente relacionado |
| 0,40 – 0,70 | Ligeiramente relacionado |
| < 0,40 | Tópicos diferentes |
Estes valores variam consoante o modelo e o domínio: um corpus jurídico, onde todos os textos partilham o mesmo vocabulário formal, produz geralmente pontuações mais elevadas do que um corpus de uso geral, a ponto de um limiar de 0,70 se tornar demasiado permissivo. Calibre sempre com os seus próprios dados, observando cerca de trinta pares onde conhece a resposta esperada.
Pesquisa do Vizinho Mais Próximo
Encontrar um documento significa calcular a similaridade entre o vetor da consulta e todos os vetores do corpus, mantendo depois os top k. O truque consiste em evitar ciclos em Python: uma multiplicação de matrizes NumPy calcula todas as similaridades de uma vez, numa fração do tempo.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Returns the k most similar documents."""
query = np.array(query_embedding)
# Vectorized calculation of all similarities
similarities = corpus_embeddings @ query
# (works because OpenAI embeddings are normalized)
# Indices of the top k scores
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Usage
corpus = np.load("embeddings.npy") # matrix (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}")
O [-k:][::-1] merece uma segunda análise: o argsort ordena por ordem crescente, pelo que pegamos no final do array para obter as melhores pontuações e depois invertemos para as classificar da mais relevante para a menos relevante.
Com scikit-learn
Quando não procura um documento, mas quer comparar todo o corpus consigo mesmo — para detetar duplicados, por exemplo, ou preparar para clustering —, o scikit-learn fornece uma função otimizada que devolve a matriz completa.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Similarity matrix between all documents
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}")
Tenha em mente que esta matriz tem dimensão n × n: dez mil documentos produzem cem milhões de valores, cerca de 400 MB em float32. Para além de alguns milhares de elementos, processe em blocos em vez de fazer uma única chamada.
Pontos-chave
- A similaridade de cosseno mede o ângulo entre vetores, independentemente da sua magnitude
- Os embeddings da OpenAI estão normalizados: produto escalar = cosseno
- Uma pontuação > 0,85 indica textos muito semelhantes
- A pesquisa do vizinho mais próximo é feita eficientemente com NumPy ou scikit-learn