Embeddings

Embeddings

Los embeddings son, básicamente, una forma de convertir palabras o textos en números que un ordenador puede entender y procesar. 

Imagínate que tienes un diccionario gigante donde cada palabra tiene asignada una serie de números que representan su "significado matemático".

La gracia está en que palabras con significados parecidos tendrán números similares. Por ejemplo, "perro" y "gato" estarían más cerca numéricamente que "perro" y "frigorífico", porque tienen más relación semántica.

En el contexto del RAG, los embeddings son fundamentales porque actúan como el "traductor" entre el lenguaje humano y lo que entiende la máquina.

Cuando tú haces una pregunta, el sistema convierte tu pregunta en embeddings, y luego busca en su base de datos documentos que tengan embeddings similares. Es como si estuviera buscando textos que "hablen de lo mismo" que tu pregunta.

Ahora bien, ¿cómo obtenemos embeddings? Necesitamos un modelo, para ello podemos usar un modelo de pago como por ejemplo los que ofrece openai, o podemos usar un modelo opensource. A continuación veremos ambas opciones.

OpenAIEmbeddings con text-embedding-3-large

OpenAI proporciona modelos de embeddings especializados que transforman texto en representaciones vectoriales densas de alta calidad. El modelo text-embedding-3-large representa la última generación de estos modelos, ofreciendo una dimensionalidad de 3072 y un rendimiento superior en tareas de búsqueda semántica.

Configuración inicial

Para utilizar OpenAI Embeddings en LangChain, necesitas instalar las dependencias correspondientes y configurar tu clave API:

from langchain_openai import OpenAIEmbeddings
import os

# Configurar la clave API
os.environ["OPENAI_API_KEY"] = "tu-clave-api-aquí"

# Inicializar el modelo de embeddings
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-large"
)

La clase OpenAIEmbeddings maneja automáticamente la comunicación con la API de OpenAI y proporciona métodos optimizados para procesar tanto documentos individuales como lotes de texto.

Generación de embeddings para documentos individuales

El método embed_query() está diseñado para generar embeddings de consultas de búsqueda, mientras que embed_documents() procesa listas de documentos:

# Embedding para una consulta
query = "¿Cuáles son los beneficios de la inteligencia artificial?"
query_embedding = embeddings.embed_query(query)

print(f"Dimensiones del embedding: {len(query_embedding)}")
print(f"Primeros 5 valores: {query_embedding[:5]}")

Para documentos individuales, puedes usar el método específico:

# Embedding para un documento
documento = """
La inteligencia artificial está transformando múltiples sectores,
desde la medicina hasta la educación, proporcionando herramientas
que mejoran la eficiencia y precisión en tareas complejas.
"""

doc_embedding = embeddings.embed_documents([documento])[0]
print(f"Embedding generado con {len(doc_embedding)} dimensiones")

La idea es crear embeddings de los documentos que hemos obtenido en anteriores lecciones:

Procesamiento por lotes

Una de las ventajas principales de usar OpenAIEmbeddings es su capacidad para procesar múltiples documentos de forma eficiente:

documentos = [
    "La programación funcional enfatiza el uso de funciones puras.",
    "Los algoritmos de machine learning requieren grandes datasets.",
    "La ciberseguridad es fundamental en aplicaciones web modernas.",
    "El desarrollo ágil mejora la colaboración en equipos de software."
]

# Generar embeddings para todos los documentos
doc_embeddings = embeddings.embed_documents(documentos)

print(f"Procesados {len(doc_embeddings)} documentos")
for i, embedding in enumerate(doc_embeddings):
    print(f"Documento {i+1}: {len(embedding)} dimensiones")

Configuración avanzada

El modelo text-embedding-3-large permite personalizar varios parámetros para optimizar el rendimiento según tus necesidades específicas:

embeddings_configurado = OpenAIEmbeddings(
    model="text-embedding-3-large",
    dimensions=1536,  # Reducir dimensionalidad para menor costo
    chunk_size=1000,  # Documentos por lote
    max_retries=3,    # Reintentos en caso de error
    request_timeout=60  # Timeout en segundos
)

La opción dimensions es particularmente útil cuando necesitas equilibrar rendimiento y costo. Reducir las dimensiones de 3072 a 1536 puede disminuir significativamente los costos de almacenamiento y procesamiento manteniendo una calidad aceptable.

Manejo de errores y límites

Es importante implementar manejo robusto de errores cuando trabajas con APIs externas:

from langchain_core.exceptions import LangChainException

def generar_embeddings_seguro(textos, embeddings_model):
    try:
        embeddings_resultado = embeddings_model.embed_documents(textos)
        return embeddings_resultado
    except LangChainException as e:
        print(f"Error de LangChain: {e}")
        return None
    except Exception as e:
        print(f"Error inesperado: {e}")
        return None

# Uso seguro
textos_ejemplo = ["Texto de prueba", "Otro texto de ejemplo"]
resultado = generar_embeddings_seguro(textos_ejemplo, embeddings)

if resultado:
    print(f"Embeddings generados exitosamente: {len(resultado)} vectores")

Comparación de modelos OpenAI

OpenAI ofrece diferentes modelos de embeddings con características distintas:

# Modelo más económico
embeddings_small = OpenAIEmbeddings(model="text-embedding-3-small")

# Modelo de alta calidad
embeddings_large = OpenAIEmbeddings(model="text-embedding-3-large")

texto_prueba = "Ejemplo de texto para comparar modelos"

# Comparar dimensionalidades
small_embedding = embeddings_small.embed_query(texto_prueba)
large_embedding = embeddings_large.embed_query(texto_prueba)

print(f"text-embedding-3-small: {len(small_embedding)} dimensiones")
print(f"text-embedding-3-large: {len(large_embedding)} dimensiones")

El modelo text-embedding-3-large ofrece mayor precisión semántica a costa de un mayor costo computacional y de almacenamiento. La elección entre modelos depende de tus requisitos específicos de precisión y presupuesto disponible.

HuggingFaceEmbeddings como alternativa gratuita

Para proyectos con restricciones presupuestarias o que requieren procesamiento completamente local, HuggingFace ofrece una amplia gama de modelos de embeddings gratuitos que pueden ejecutarse sin depender de APIs externas. Estos modelos proporcionan una alternativa viable a los servicios de pago, especialmente útil durante el desarrollo y prototipado.

Configuración de HuggingFaceEmbeddings

La integración con HuggingFace en LangChain se realiza a través de la clase HuggingFaceEmbeddings, que descarga y ejecuta modelos localmente:

from langchain_huggingface import HuggingFaceEmbeddings

# Inicializar con el modelo recomendado
embeddings_hf = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-mpnet-base-v2"
)

El modelo all-mpnet-base-v2 es una opción equilibrada que ofrece buen rendimiento en tareas de búsqueda semántica con un tamaño razonable. La primera ejecución descargará el modelo automáticamente y lo almacenará en caché local.

Uso básico con documentos

Una vez inicializado, el uso es idéntico a OpenAIEmbeddings, manteniendo la consistencia de la interfaz de LangChain:

# Procesar una consulta
consulta = "¿Cómo implementar autenticación en aplicaciones web?"
embedding_consulta = embeddings_hf.embed_query(consulta)

print(f"Dimensiones del embedding: {len(embedding_consulta)}")

# Procesar múltiples documentos
documentos_tecnicos = [
    "JWT tokens proporcionan autenticación stateless en APIs REST.",
    "OAuth 2.0 es el estándar para autorización en aplicaciones modernas.",
    "La autenticación multifactor mejora significativamente la seguridad.",
    "Los hash bcrypt son recomendados para almacenar contraseñas."
]

embeddings_docs = embeddings_hf.embed_documents(documentos_tecnicos)
print(f"Procesados {len(embeddings_docs)} documentos localmente")

Configuración avanzada y optimización

HuggingFaceEmbeddings permite personalizar varios aspectos del procesamiento para optimizar rendimiento y uso de recursos:

embeddings_optimizado = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-mpnet-base-v2",
    model_kwargs={
        'device': 'cpu',  # o 'cuda' si tienes GPU
        'trust_remote_code': False
    },
    encode_kwargs={
        'normalize_embeddings': True,  # Normalizar vectores
        'batch_size': 32,             # Tamaño de lote
        'show_progress_bar': True     # Mostrar progreso
    }
)

La normalización de embeddings es especialmente útil cuando planeas usar métricas de similitud coseno, ya que simplifica los cálculos posteriores.

Modelos alternativos según casos de uso

HuggingFace Hub contiene cientos de modelos especializados para diferentes idiomas y dominios:

# Para textos en español
embeddings_es = HuggingFaceEmbeddings(
    model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
)

# Para código fuente
embeddings_code = HuggingFaceEmbeddings(
    model_name="microsoft/codebert-base"
)

# Modelo más ligero para recursos limitados
embeddings_light = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

Cada modelo tiene características específicas en términos de dimensionalidad, idiomas soportados y rendimiento en diferentes tipos de texto.

Integración con Ollama para embeddings locales

Para usuarios que prefieren máximo control sobre sus modelos, LangChain también soporta embeddings a través de Ollama:

from langchain_ollama import OllamaEmbeddings

# Requiere tener Ollama instalado y el modelo descargado
embeddings_ollama = OllamaEmbeddings(
    model="nomic-embed-text"
)

# Uso idéntico a otras implementaciones
texto_ejemplo = "Ejemplo de procesamiento local con Ollama"
embedding_local = embeddings_ollama.embed_query(texto_ejemplo)

Ejemplo ollama:

Comparación de rendimiento y recursos

Es importante evaluar el trade-off entre diferentes opciones según tus necesidades específicas:

import time

def comparar_modelos(texto_prueba):
    modelos = {
        "HuggingFace MPNet": HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-mpnet-base-v2"
        ),
        "HuggingFace MiniLM": HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
    }
    
    for nombre, modelo in modelos.items():
        inicio = time.time()
        embedding = modelo.embed_query(texto_prueba)
        tiempo = time.time() - inicio
        
        print(f"{nombre}:")
        print(f"  Dimensiones: {len(embedding)}")
        print(f"  Tiempo: {tiempo:.3f}s")
        print()

# Ejecutar comparación
texto_test = "La computación cuántica promete revolucionar el procesamiento de información."
comparar_modelos(texto_test)

Consideraciones para producción

Cuando uses HuggingFaceEmbeddings en producción, considera estos aspectos importantes:

# Configuración robusta para producción
embeddings_produccion = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-mpnet-base-v2",
    cache_folder="./models_cache",  # Directorio específico para modelos
    model_kwargs={
        'device': 'cpu',
        'torch_dtype': 'float32'  # Precisión específica
    },
    encode_kwargs={
        'normalize_embeddings': True,
        'batch_size': 16,  # Ajustar según memoria disponible
        'convert_to_tensor': False
    }
)

Los modelos de HuggingFace requieren espacio de almacenamiento local y pueden consumir memoria RAM significativa durante la ejecución. Sin embargo, ofrecen la ventaja de procesamiento completamente offline y sin costos por uso, lo que los convierte en una opción atractiva para muchos casos de uso.