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

Similitud semántica

Lección 3 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Medición de la proximidad textual
  2. Distancia euclídea
  3. Similitud del coseno
  4. Matriz de similitud
  5. Búsqueda semántica simple
  6. Umbral de relevancia
  7. Puntos clave

Medición de la proximidad textual

Una vez que transformas tus textos en vectores mediante mistral-embed, puedes cuantificar lo semánticamente cercanos que están dos textos. Esta es la esencia de la búsqueda semántica: comparar significados, no solo palabras. Mientras que una consulta SQL LIKE '%factura%' devuelve un simple sí o no, una métrica de similitud te ofrece un número que permite establecer rankings. Ese ranking es lo que dota de valor a todo el sistema.

En esta lección, implementarás las principales métricas de similitud y verás cómo funcionan en la práctica con ejemplos concretos en Python.

Distancia euclídea

La distancia euclídea mide la longitud del segmento entre dos puntos en el espacio vectorial. Cuanto menor sea la distancia, más similares serán los textos. El ejemplo siguiente compara tres frases: las dos primeras dicen lo mismo utilizando vocabulario distinto, mientras que la tercera habla de una tarta de manzana. Las frases A y B no comparten ninguna palabra, pero su distancia será significativamente menor que la distancia entre A y C.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embedding(text):
    """Obtiene el embedding de un texto mediante mistral-embed."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[text],
    )
    return np.array(response.data[0].embedding)

# Tres frases para comparar
phrase_a = "Machine learning transforms data into predictions."
phrase_b = "Automatic learning converts data into results."
phrase_c = "The recipe for apple pie is simple."

emb_a = get_embedding(phrase_a)
emb_b = get_embedding(phrase_b)
emb_c = get_embedding(phrase_c)

# Distancias euclídeas
dist_ab = np.linalg.norm(emb_a - emb_b)
dist_ac = np.linalg.norm(emb_a - emb_c)

print(f"Distancia A-B (semánticamente cercanas): {dist_ab:.4f}")
print(f"Distancia A-C (semánticamente distantes): {dist_ac:.4f}")
# A-B será significativamente menor que A-C

Similitud del coseno

La similitud del coseno es la métrica más utilizada para los embeddings. Mide el ángulo entre dos vectores, independientemente de su magnitud. El resultado oscila entre -1 y 1, lo que proporciona una escala inmediatamente legible: puedes fijar un umbral y comunicarlo a un equipo de negocio sin tener que explicar normas vectoriales.

from sklearn.metrics.pairwise import cosine_similarity

# Con scikit-learn
sim_ab = cosine_similarity([emb_a], [emb_b])[0][0]
sim_ac = cosine_similarity([emb_a], [emb_c])[0][0]

print(f"Similitud del coseno A-B: {sim_ab:.4f}")  # ~0,92 (muy cercanas)
print(f"Similitud del coseno A-C: {sim_ac:.4f}")  # ~0,35 (distantes)

La brecha entre 0,92 y 0,35 es la información útil: no importa el valor absoluto, sino el margen que separa los resultados relevantes de los fuera de tema en tu conjunto de datos específico. También puedes implementar la métrica manualmente, si solo es para verificar qué hace scikit-learn o para evitar dependencias en un entorno restringido:

def cosine_sim(vec_a, vec_b):
    """Similitud del coseno manual."""
    dot = np.dot(vec_a, vec_b)
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    return dot / (norm_a * norm_b)

print(f"Verificación manual A-B: {cosine_sim(emb_a, emb_b):.4f}")

Matriz de similitud

Para comparar múltiples documentos entre sí, puedes construir una matriz de similitud. El corpus siguiente mezcla intencionadamente dos temas —IA y gastronomía—, de modo que la estructura salta a la vista: los documentos 0, 1 y 3 guardan relación entre sí, mientras que los documentos 2 y 4 forman un clúster aparte. Esta es exactamente la señal que explotan los algoritmos de agrupamiento (clustering).

from sklearn.metrics.pairwise import cosine_similarity

documents = [
    "Mistral AI develops language models.",
    "LLMs generate text from prompts.",
    "French cuisine is renowned worldwide.",
    "NLP is a branch of artificial intelligence.",
    "Croissants taste best in the morning.",
]

# Codificar todos los documentos
response = client.embeddings.create(
    model="mistral-embed",
    inputs=documents,
)
embeddings = np.array([d.embedding for d in response.data])

# Matriz de similitud (5x5)
sim_matrix = cosine_similarity(embeddings)

print("Matriz de similitud:")
for i, doc in enumerate(documents):
    for j, doc2 in enumerate(documents):
        if j > i:
            print(f"  [{i}]-[{j}]: {sim_matrix[i][j]:.3f}")

Búsqueda semántica simple

Todo lo anterior se combina en un mini motor de búsqueda. La consulta se codifica con el mismo modelo que el corpus —una condición innegociable, ya que dos modelos distintos producen espacios incomparables— y luego argsort invierte el ordenamiento para colocar las puntuaciones más altas al principio.

def recherche_semantique(query, documents, embeddings, top_k=3):
    """Encuentra los documentos más relevantes para una consulta."""
    # Codificar la consulta
    query_response = client.embeddings.create(
        model="mistral-embed",
        inputs=[query],
    )
    query_embedding = np.array(query_response.data[0].embedding)

    # Calcular similitudes
    similarities = cosine_similarity(
        [query_embedding], embeddings
    )[0]

    # Ordenar por similitud descendente
    ranked_indices = np.argsort(similarities)[::-1][:top_k]

    results = []
    for idx in ranked_indices:
        results.append({
            "document": documents[idx],
            "score": similarities[idx],
            "index": int(idx),
        })
    return results

# Ejemplo de uso
query = "How does Mistral's AI work?"
results = recherche_semantique(query, documents, embeddings)

for r in results:
    print(f"  Puntuación: {r['score']:.3f} -- {r['document']}")

Umbral de relevancia

Este motor tiene un defecto que descubrirás rápidamente en producción: siempre devuelve tres resultados, incluso cuando la pregunta no tiene nada que ver con el corpus. Si le preguntas por el tiempo atmosférico, devolverá los tres documentos menos distantes, con puntuaciones ridículas pero un ranking aparentemente normal. En la práctica, por tanto, debes definir un umbral de similitud por debajo del cual un documento se considera irrelevante:

SEUIL_PERTINENCE = 0.7

def recherche_avec_seuil(query, documents, embeddings, seuil=SEUIL_PERTINENCE):
    """Búsqueda con filtrado por umbral de relevancia."""
    results = recherche_semantique(query, documents, embeddings, top_k=len(documents))
    return [r for r in results if r["score"] >= seuil]

# Un umbral de 0,7 es un buen punto de partida
# Ajústalo según tu caso de uso:
# - 0,8+: muy estricto (pocos resultados, alta relevancia)
# - 0,6-0,7: equilibrado
# - 0,5: permisivo (muchos resultados, relevancia variable)

Tómate el tiempo necesario para calibrar este umbral con unas treinta consultas reales antes de abrir el servicio a los usuarios. Si lo fijas demasiado alto, tu motor dirá «no lo sé» ante preguntas legítimas. Si lo fijas demasiado bajo, alimentarás al LLM con contexto fuera de tema, creando precisamente las alucinaciones que RAG debía evitar.

Puntos clave

  • La similitud del coseno es la métrica estándar para comparar embeddings
  • Usa sklearn.metrics.pairwise.cosine_similarity para cálculos rápidos
  • Una matriz de similitud permite comparar todos los documentos entre sí
  • Define un umbral de relevancia adaptado a tu caso de uso (0,7 es un buen valor por defecto)
  • La búsqueda semántica encuentra resultados por significado, no por coincidencia exacta de palabras