Ir al contenido principal
Español— Elegir un idioma
Menú

Distancia y similitud del coseno

Lección 4 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. Medición de la proximidad entre vectores
  3. Comparación práctica
  4. Interpretación de las puntuaciones
  5. Búsqueda del vecino más cercano
  6. Con scikit-learn
  7. Resumen

Objetivos

  • Comprender la similitud del coseno y por qué se prefiere.
  • Implementar la comparación de vectores en Python.
  • Interpretar las puntuaciones de similitud.

Medición de la proximidad entre vectores

Una vez que has convertido tus textos en vectores, todo depende de una pregunta: ¿cómo decides si dos vectores están «cerca»? Coexisten tres respuestas y la elección importa.

La distancia euclídea es la distancia geométrica clásica, la que medirías con una regla entre dos puntos. Es intuitiva, pero depende de la magnitud del vector: dos textos con el mismo significado, donde uno se codifica con mayor amplitud, parecerían artificialmente muy separados.

import numpy as np

def euclidean_distance(a: list[float], b: list[float]) -> float:
    return np.linalg.norm(np.array(a) - np.array(b))

El producto escalar suma los productos elemento a elemento. Es la operación más rápida de la familia, la que el procesador ejecuta con mayor eficiencia en matrices grandes.

def dot_product(a: list[float], b: list[float]) -> float:
    return np.dot(a, b)

La similitud del coseno, por último, mide el ángulo entre dos vectores independientemente de su longitud, lo que la convierte en la métrica estándar para los embeddings: solo importa la dirección del significado, no su intensidad.

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))

Su rango va desde -1 para direcciones opuestas hasta +1 para direcciones idénticas. Hay un detalle práctico importante: los embeddings de OpenAI ya están normalizados, es decir, tienen una longitud de 1. Por tanto, el denominador es igual a 1 y el producto escalar ofrece exactamente el mismo resultado que la similitud del coseno, pero con un coste computacional menor. Este es el atajo que utilizaremos durante todo este curso.

Comparación práctica

Nada supera la medición de frases reales. Comparemos una frase, su paráfrasis completa y una frase fuera de tema:

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

# Frases a comparar
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()}

# Comparar todos los pares
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   ← significado muy cercano
sim(a, c) = 0.1247   ← temas diferentes
sim(b, c) = 0.1189   ← temas diferentes

Las frases a y b no comparten palabras (cat/feline, sleeps/dozes, couch/sofa), sin embargo obtienen una puntuación de 0,89. Esto es exactamente lo que ningún método léxico puede lograr.

Interpretación de las puntuaciones

Los umbrales dependen de tu caso de uso, pero la tabla siguiente ofrece puntos de referencia para leer una puntuación sin errar en un orden de magnitud.

PuntuaciónInterpretación
> 0,85Muy similar (paráfrasis, sinónimos)
0,70 – 0,85Temáticamente relacionado
0,40 – 0,70Relacionado vagamente
< 0,40Temas diferentes

Estos valores varían según el modelo y el dominio: un corpus jurídico, donde todos los textos comparten el mismo vocabulario formal, produce generalmente puntuaciones más altas que un corpus de propósito general, hasta el punto de que un umbral de 0,70 resulta demasiado permisivo. Calibra siempre con tus propios datos observando unas treinta parejas donde conozcas la respuesta esperada.

Búsqueda del vecino más cercano

Encontrar un documento implica calcular la similitud entre el vector de la consulta y todos los vectores del corpus, para luego conservar los k mejores. El truco consiste en evitar bucles en Python: una multiplicación de matrices con NumPy calcula todas las similitudes a la vez, en una fracción del tiempo.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Devuelve los k documentos más similares."""
    query = np.array(query_embedding)

    # Cálculo vectorizado de todas las similitudes
    similarities = corpus_embeddings @ query
    # (funciona porque los embeddings de OpenAI están normalizados)

    # Índices de las k mejores puntuaciones
    top_k_indices = np.argsort(similarities)[-k:][::-1]

    return [(int(i), float(similarities[i])) for i in top_k_indices]

# Uso
corpus = np.load("embeddings.npy")  # matriz (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}")

La expresión [-k:][::-1] merece una segunda mirada: argsort ordena de forma ascendente, así que tomamos el final del array para obtener las mejores puntuaciones y luego invertimos el orden para clasificarlas de más a menos relevantes.

Con scikit-learn

Cuando no buscas un documento concreto, sino que quieres comparar todo el corpus consigo mismo (para detectar duplicados, por ejemplo, o prepararte para un agrupamiento), scikit-learn proporciona una función optimizada que devuelve la matriz completa.

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Matriz de similitud entre todos los documentos
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}")

Ten en cuenta que esta matriz tiene un tamaño de n × n: diez mil documentos producen cien millones de valores, unos 400 MB en float32. Más allá de unos pocos miles de elementos, procesa por bloques en lugar de hacer una única llamada.

Resumen

  • La similitud del coseno mide el ángulo entre vectores, independientemente de su magnitud.
  • Los embeddings de OpenAI están normalizados: producto escalar = coseno.
  • Una puntuación > 0,85 indica textos muy similares.
  • La búsqueda del vecino más cercano se realiza eficientemente con NumPy o scikit-learn.