Embeddings y Similitud

Los embeddings convierten texto en vectores de tamaño fijo donde la similitud semántica corresponde a la cercanía geométrica. Potencian la búsqueda semántica, la agrupación y la recuperación en RAG.

Receta

Tarjeta de receta de referencia rápida, lista para copiar y pegar.

from openai import OpenAI
import numpy as np
 
client = OpenAI()
emb = client.embeddings.create(model="text-embedding-3-small", input=["texto de consulta"])
vec = np.array(emb.data[0].embedding)
 
# similitud del coseno
def cosine(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Cuándo usar esto:

• Búsqueda semántica sobre documentos, código o artículos de soporte.
• Agrupación o deduplicación de contenido de texto.
• Paso de recuperación de RAG antes de la generación de LLM.
• Sistemas de recomendación basados en similitud de texto.

Ejemplo de Trabajo

"""embeddings_similarity.py - generar embeddings, indexar y buscar documentos."""
from __future__ import annotations
 
import numpy as np
from openai import OpenAI
 
client = OpenAI()
MODEL = "text-embedding-3-small"
 
documents = [
    "FastAPI es un framework web moderno de Python para construir APIs.",
    "PyTorch es un framework de aprendizaje profundo con grafos de cómputo dinámicos.",
    "pandas 2.2 proporciona operaciones de DataFrame para el análisis de datos tabulares.",
    "pytest es el framework de pruebas estándar para proyectos de Python.",
]
 
def embed_texts(texts: list[str]) -> np.ndarray:
    response = client.embeddings.create(model=MODEL, input=texts)
    vectors = [item.embedding for item in response.data]
    arr = np.array(vectors, dtype=np.float32)
    norms = np.linalg.norm(arr, axis=1, keepdims=True)
    return arr / norms  # Normalización L2 para similitud del coseno mediante producto punto
 
doc_embeddings = embed_texts(documents)
 
query = "¿Cómo pruebo mi código de Python?"
query_vec = embed_texts([query])[0]
 
scores = doc_embeddings @ query_vec  # similitud del coseno (normalizada)
ranked = sorted(zip(scores, documents), reverse=True)
for score, doc in ranked:
    print(f"{score:.3f}  {doc}")

Lo que esto demuestra:

• Generación de embeddings por lotes con OpenAI text-embedding-3-small.
• Normalización L2 para que el producto punto sea igual a la similitud del coseno.
• Clasificación de documentos por relevancia a una consulta en lenguaje natural.
• Coincidencia semántica: "probar código de Python" clasifica pytest en primer lugar.

Inmersión Profunda

Cómo Funciona

• Modelo de embedding codifica texto en un vector de dimensión fija (p. ej., 1536).
• Textos similares producen vectores con alta similitud del coseno.
• Normalización (L2) hace que el producto punto sea equivalente a la similitud del coseno.
• Índice vectorial (FAISS, pgvector) permite una búsqueda rápida de vecinos más cercanos a escala.
• Se debe usar el mismo modelo para indexar y consultar.

Modelos de Embedding

Notas de Python

# Embeddings locales con sentence-transformers
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("all-MiniLM-L6-v2")
vectors = model.encode(documents, normalize_embeddings=True)

Trampas Comunes

• Mezclar modelos de embedding - diferentes modelos producen espacios vectoriales incompatibles. Solución: un modelo por índice; volver a generar los embeddings de todos los documentos al cambiar de modelo.
• No normalizar vectores - el producto punto sin normalización no es similitud del coseno. Solución: normalizar L2 antes de indexar y buscar.
• Generar embeddings de textos muy largos - los modelos tienen límites de tokens; los documentos largos se truncan. Solución: dividir los documentos en fragmentos antes de generar los embeddings.
• Comparar entre diferentes dimensiones - los vectores de 384 dimensiones vs 1536 dimensiones no se pueden comparar. Solución: modelo y dimensión consistentes.
• Ignorar el costo de los embeddings a escala - generar embeddings para millones de documentos suma. Solución: cachear embeddings; agrupar solicitudes; usar modelos más pequeños.
• Expectativa de búsqueda por palabras clave - los embeddings no encuentran coincidencias exactas de palabras clave. Solución: búsqueda híbrida (embeddings + BM25).

Alternativas

Preguntas Frecuentes

client.embeddings.create(model="text-embedding-3-small", input=texts, dimensions=512)

Relacionado

• Conceptos Básicos de RAG - pipeline de recuperación
• Bases de Datos Vectoriales - almacenamiento y búsqueda
• Fragmentación e Ingesta - división de documentos
• SDK de OpenAI y Otros - API de embeddings
• Recuperación y Reclasificación - búsqueda híbrida

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.