Embeddings y Similitud Vectorial: Teoría Aplicada

Concepto clave

Los embeddings son representaciones vectoriales de datos (texto, imágenes, audio) que capturan su significado semántico en un espacio multidimensional. Imagina que cada palabra o documento es un punto en un mapa, donde palabras similares (como "perro" y "can") están cerca, y palabras diferentes (como "perro" y "computadora") están lejos. En sistemas RAG, los embeddings convierten consultas y documentos en vectores para buscar información relevante.

La similitud vectorial mide cuán cercanos están dos vectores en este espacio. Métricas como cosine similarity (similitud del coseno) calculan el ángulo entre vectores: un valor de 1 indica vectores idénticos, 0 vectores ortogonales (sin relación), y -1 vectores opuestos. En la práctica, esto permite encontrar documentos relevantes para una consulta sin coincidencias exactas de palabras.

"Los embeddings transforman el lenguaje humano en matemáticas que las máquinas pueden comparar."

Cómo funciona en la práctica

Veamos un ejemplo paso a paso para buscar documentos en una base de datos vectorial:

1. Generar embeddings: Usa un modelo como Sentence-BERT para convertir documentos y consultas en vectores de 384 dimensiones.
2. Almacenar vectores: Inserta los vectores de documentos en Chroma, Pinecone o pgvector con metadatos (ej., título, fuente).
3. Consultar: Convierte la pregunta del usuario en un vector y busca los k vecinos más cercanos usando cosine similarity.
4. Recuperar: Devuelve los documentos originales asociados a los vectores más similares.

Ejemplo con datos:

La consulta "¿Cómo aprender Python?" tiene embedding [0.22, -0.08, 0.52] y mayor similitud con el tercer documento.

Caso de estudio

Una empresa de e-commerce implementa un sistema RAG para responder preguntas sobre productos. Usan pgvector con PostgreSQL para almacenar embeddings de descripciones de 10,000 productos. Cuando un usuario pregunta "¿Qué laptop tiene mejor batería?":

1. El sistema genera un embedding de la consulta con el modelo all-MiniLM-L6-v2.
2. Ejecuta una consulta SQL en pgvector: SELECT product_id, description FROM products ORDER BY embedding <=> query_embedding LIMIT 5 (<=> calcula distancia).
3. Recupera las 5 descripciones más similares, como "Laptop X con batería de 12 horas".
4. Un modelo LLM como GPT-4 sintetiza una respuesta natural: "La Laptop X ofrece hasta 12 horas de batería, según nuestras descripciones."

Resultado: Respuestas precisas sin necesidad de etiquetar manualmente cada producto.

Errores comunes

• Usar embeddings de baja dimensión: Modelos con menos de 100 dimensiones pueden perder matices. Solución: Emplea modelos modernos como OpenAI text-embedding-3-large (3072 dimensiones) o ajusta según tu caso.
• Ignorar normalización: No normalizar vectores antes de calcular similitud lleva a resultados inconsistentes. Solución: Siempre normaliza a longitud 1 para cosine similarity.
• No indexar vectores eficientemente: Buscar en vectores sin índices (como HNSW en Pinecone) es lento con millones de documentos. Solución: Configura índices apropiados en tu base de datos vectorial.
• Olvidar metadatos: Almacenar solo vectores sin metadatos (ej., ID, fecha) impide filtrar resultados. Solución: Incluye metadatos clave en cada vector.
• Asumir que más dimensiones siempre es mejor: Dimensiones excesivas aumentan costo y ruido. Solución: Prueba con 384-768 dimensiones para texto y evalúa rendimiento.

Checklist de dominio

1. Puedo explicar qué es un embedding y cómo representa significado semántico.
2. Sé calcular similitud vectorial usando cosine similarity en código (ej., Python con numpy).
3. He generado embeddings para al menos 100 documentos usando un modelo como Sentence-BERT o OpenAI.
4. Puedo configurar una base de datos vectorial (Chroma, Pinecone o pgvector) para almacenar y consultar embeddings.
5. Entiendo cómo la elección de modelo de embeddings afecta la precisión de recuperación en RAG.
6. Sé normalizar vectores y aplicar métricas de distancia apropiadas (cosine, euclidiana).
7. Puedo integrar embeddings en un flujo de trabajo RAG completo, desde ingesta hasta respuesta.

Implementa una búsqueda semántica con embeddings en Python

En este ejercicio, crearás un sistema básico de búsqueda semántica usando embeddings y similitud vectorial. Sigue estos pasos:

1. Prepara los datos: Crea una lista de 5-10 documentos cortos (ej., frases sobre tecnología) en un archivo documents.txt.
2. Genera embeddings: Usa la biblioteca sentence-transformers en Python para cargar el modelo all-MiniLM-L6-v2 y convertir cada documento en un vector de 384 dimensiones. Almacena los embeddings en una lista.
3. Calcula similitud: Escribe una función que tome una consulta de usuario, genere su embedding, y calcule la similitud del coseno con cada documento usando numpy o scipy. Fórmula: cosine_similarity(A, B) = dot(A, B) / (norm(A) * norm(B)).
4. Recupera resultados: Ordena los documentos por similitud (de mayor a menor) y muestra los 3 más relevantes con sus puntajes.
5. Prueba el sistema: Ejecuta consultas como "lenguaje de programación" y verifica que devuelva documentos relacionados (ej., sobre Python o Java).

Entrega un script Python funcional con comentarios explicando cada paso.

• Recuerda instalar las bibliotecas necesarias: pip install sentence-transformers numpy.
• Normaliza los vectores antes de calcular similitud para mayor precisión.
• Usa model.encode() para generar embeddings de texto.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.