LangChain modelos huggingface

HuggingFacePipeline en langchain

HuggingFacePipeline permite ejecutar modelos de Hugging Face directamente en tu máquina local, sin necesidad de tokens de API ni conexiones externas. Esta aproximación es ideal cuando necesitas control total sobre el modelo, quieres evitar costes por uso o trabajas con datos sensibles que no pueden salir de tu infraestructura.

A diferencia de los proveedores como OpenAI u Ollama que requieren servicios externos, HuggingFacePipeline descarga y ejecuta el modelo completo en tu hardware local. Esto significa que tendrás mayor latencia inicial durante la descarga del modelo, pero después podrás realizar inferencias sin depender de conexiones de red.

Instalación y configuración inicial

Para usar HuggingFacePipeline necesitas instalar el paquete específico de LangChain para Hugging Face:

pip install langchain-huggingface torch transformers

La instalación incluye PyTorch y Transformers, que son las dependencias fundamentales para ejecutar modelos de Hugging Face localmente. Dependiendo de tu hardware, podrías necesitar instalar versiones específicas de PyTorch para aprovechar GPU.

Creación básica de un pipeline

El proceso de creación de un pipeline implica especificar el modelo, la tarea y los parámetros de configuración. 

Lo primero es elegir un modelo, se pueden explorar en HuggingFace models:

Luego utilizarlo en código Python:

from langchain_huggingface import HuggingFacePipeline
import torch

# Crear pipeline con modelo pequeño para pruebas
llm = HuggingFacePipeline.from_model_id(
    model_id="microsoft/DialoGPT-small",
    task="text-generation",
    pipeline_kwargs={
        "max_new_tokens": 100,
        "do_sample": True,
        "temperature": 0.7,
        "torch_dtype": torch.float16,
        "device_map": "auto",
    },
)

# Invocar el modelo directamente
response = llm.invoke("¿Cuál es la capital de España?")
print(response)

El parámetro device_map="auto" permite que Hugging Face distribuya automáticamente el modelo entre CPU y GPU según la memoria disponible. El torch_dtype=torch.float16 reduce el uso de memoria utilizando precisión de 16 bits.

Configuración para modelos de chat

Para usar modelos diseñados específicamente para conversaciones, necesitas combinar HuggingFacePipeline con ChatHuggingFace:

from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
import torch

# Crear el pipeline base
llm = HuggingFacePipeline.from_model_id(
    model_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    task="text-generation",
    pipeline_kwargs={
        "max_new_tokens": 512,
        "do_sample": True,
        "temperature": 0.7,
        "torch_dtype": torch.float16,
        "device_map": "auto",
    },
)

# Envolver en ChatHuggingFace para formato de mensajes
chat = ChatHuggingFace(
    llm=llm,
    model_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0"
)

# Usar formato de mensajes estándar
messages = [
    ("system", "Eres un asistente útil que responde de forma concisa."),
    ("human", "Explica qué es Python en una frase."),
]

result = chat.invoke(messages)
print(result.content)

La clase ChatHuggingFace actúa como un adaptador que convierte el formato de mensajes de LangChain al formato esperado por el modelo de Hugging Face.

Ejemplo:

Optimización de parámetros

Los pipeline_kwargs te permiten ajustar el comportamiento del modelo según tus necesidades:

# Configuración para respuestas más creativas
creative_config = {
    "max_new_tokens": 256,
    "do_sample": True,
    "temperature": 0.9,
    "top_p": 0.95,
    "repetition_penalty": 1.1,
}

# Configuración para respuestas más deterministas
deterministic_config = {
    "max_new_tokens": 128,
    "do_sample": False,
    "temperature": 0.1,
    "repetition_penalty": 1.0,
}

llm_creative = HuggingFacePipeline.from_model_id(
    model_id="microsoft/DialoGPT-medium",
    task="text-generation",
    pipeline_kwargs=creative_config,
)

El parámetro temperature controla la aleatoriedad: valores bajos (0.1-0.3) generan respuestas más predecibles, mientras que valores altos (0.7-1.0) producen respuestas más variadas. El top_p implementa nucleus sampling, limitando las opciones a los tokens más probables.

Integración con LCEL

HuggingFacePipeline se integra perfectamente con LangChain Expression Language para crear cadenas de procesamiento complejas:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Crear prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", "Traduce el siguiente texto al {idioma_destino}:"),
    ("human", "{texto}")
])

# Crear cadena con LCEL
chain = prompt | chat | StrOutputParser()

# Ejecutar la cadena
resultado = chain.invoke({
    "texto": "Hello, how are you today?",
    "idioma_destino": "español"
})

print(resultado)

Esta aproximación te permite combinar el procesamiento local de HuggingFacePipeline con las capacidades de composición de LCEL, creando flujos de trabajo sofisticados sin depender de servicios externos.

Consideraciones de rendimiento

Ejecutar modelos localmente requiere recursos computacionales significativos. Los modelos más pequeños como TinyLlama funcionan bien en hardware modesto, mientras que modelos más grandes pueden necesitar GPUs dedicadas:

# Verificar disponibilidad de GPU
import torch

if torch.cuda.is_available():
    device_config = {"device_map": "auto", "torch_dtype": torch.float16}
    print(f"GPU disponible: {torch.cuda.get_device_name()}")
else:
    device_config = {"device_map": "cpu", "torch_dtype": torch.float32}
    print("Usando CPU")

llm = HuggingFacePipeline.from_model_id(
    model_id="microsoft/DialoGPT-small",
    task="text-generation",
    pipeline_kwargs={
        "max_new_tokens": 100,
        **device_config
    },
)

La primera ejecución será más lenta porque el modelo se descarga y carga en memoria. Las ejecuciones posteriores serán significativamente más rápidas, especialmente si mantienes la instancia del pipeline en memoria.

HuggingFaceEndpoint en langchain

HuggingFaceEndpoint representa la alternativa basada en la nube para acceder a modelos de Hugging Face sin necesidad de ejecutarlos localmente. A diferencia de HuggingFacePipeline que descarga y ejecuta modelos en tu hardware, HuggingFaceEndpoint utiliza la Inference API de Hugging Face para procesar las peticiones en sus servidores.

Esta aproximación elimina los requisitos de hardware local y permite acceder a modelos más grandes que serían impracticables de ejecutar en máquinas personales. Sin embargo, requiere una conexión a internet activa y un token de API válido de Hugging Face.

Configuración del token de API

Para usar HuggingFaceEndpoint necesitas obtener un token de acceso desde tu cuenta de Hugging Face. Ve a huggingface.co/settings/tokens y genera un nuevo token con permisos de lectura.

Crea un archivo .env en tu proyecto para almacenar el token de forma segura:

# .env
HUGGINGFACEHUB_API_TOKEN=hf_tu_token_aqui

Luego carga el token en tu aplicación:

import os
from dotenv import load_dotenv

# Cargar variables de entorno
load_dotenv()

# Verificar que el token está disponible
token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
if not token:
    raise ValueError("Token de Hugging Face no encontrado en variables de entorno")

Uso básico de HuggingFaceEndpoint

La creación de un endpoint es más directa que un pipeline local, ya que no necesitas configurar parámetros de hardware:

from langchain_huggingface import HuggingFaceEndpoint

# Crear endpoint para modelo de generación de texto
llm = HuggingFaceEndpoint(
    repo_id="microsoft/DialoGPT-large",
    max_new_tokens=250,
    temperature=0.7,
    huggingfacehub_api_token=token
)

# Invocar el modelo
response = llm.invoke("¿Cuáles son las ventajas de la programación funcional?")
print(response)

El parámetro repo_id especifica el modelo exacto del Hub de Hugging Face que quieres utilizar. 

Los parámetros como max_new_tokens y temperature se envían directamente a la API de Hugging Face.

Modelos de chat con HuggingFaceEndpoint

Para modelos conversacionales, puedes combinar HuggingFaceEndpoint con ChatHuggingFace de la misma manera que con pipelines locales:

from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint

# Crear endpoint base
llm = HuggingFaceEndpoint(
    repo_id="HuggingFaceH4/zephyr-7b-beta",
    max_new_tokens=512,
    temperature=0.6,
    repetition_penalty=1.1,
    huggingfacehub_api_token=token
)

# Envolver para formato de chat
chat = ChatHuggingFace(
    llm=llm,
    model_id="HuggingFaceH4/zephyr-7b-beta"
)

# Usar con mensajes estructurados
messages = [
    ("system", "Eres un experto en desarrollo web que explica conceptos técnicos de forma clara."),
    ("human", "¿Qué diferencias hay entre REST y GraphQL?"),
]

result = chat.invoke(messages)
print(result.content)

Los modelos como Zephyr están específicamente entrenados para conversaciones y suelen producir respuestas más coherentes que los modelos de generación de texto general.

Configuración avanzada de parámetros

HuggingFaceEndpoint permite ajustar múltiples parámetros para controlar el comportamiento del modelo:

# Configuración para respuestas técnicas precisas
technical_endpoint = HuggingFaceEndpoint(
    repo_id="codellama/CodeLlama-7b-Instruct-hf",
    max_new_tokens=400,
    temperature=0.2,
    top_p=0.9,
    repetition_penalty=1.05,
    do_sample=True,
    huggingfacehub_api_token=token
)

# Configuración para contenido creativo
creative_endpoint = HuggingFaceEndpoint(
    repo_id="mistralai/Mistral-7B-Instruct-v0.1",
    max_new_tokens=600,
    temperature=0.8,
    top_p=0.95,
    repetition_penalty=1.2,
    do_sample=True,
    huggingfacehub_api_token=token
)

El parámetro **do_sample=True** habilita el muestreo probabilístico, mientras que **top_p** implementa nucleus sampling para equilibrar creatividad y coherencia.

Integración con cadenas LCEL

Los endpoints se integran naturalmente con LangChain Expression Language para crear flujos de procesamiento complejos:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Crear endpoint especializado
code_llm = HuggingFaceEndpoint(
    repo_id="codellama/CodeLlama-7b-Instruct-hf",
    max_new_tokens=300,
    temperature=0.1,
    huggingfacehub_api_token=token
)

# Prompt para generación de código
code_prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto programador. Genera código {lenguaje} limpio y bien comentado."),
    ("human", "Tarea: {tarea}")
])

# Crear cadena de procesamiento
code_chain = code_prompt | code_llm | StrOutputParser()

# Ejecutar la cadena
codigo = code_chain.invoke({
    "lenguaje": "Python",
    "tarea": "función que calcule el factorial de un número usando recursión"
})

print(codigo)

Esta aproximación te permite especializar diferentes endpoints para tareas específicas y combinarlos en flujos de trabajo más complejos.

Manejo de errores y límites

La Inference API de Hugging Face tiene límites de uso y puede experimentar latencia variable. Es importante implementar manejo de errores robusto:

from langchain_huggingface import HuggingFaceEndpoint
import time

def crear_endpoint_con_reintentos(repo_id, max_reintentos=3):
    for intento in range(max_reintentos):
        try:
            endpoint = HuggingFaceEndpoint(
                repo_id=repo_id,
                max_new_tokens=200,
                temperature=0.7,
                huggingfacehub_api_token=token
            )
            
            # Probar con una consulta simple
            test_response = endpoint.invoke("Hola")
            return endpoint
            
        except Exception as e:
            print(f"Intento {intento + 1} fallido: {e}")
            if intento < max_reintentos - 1:
                time.sleep(2 ** intento)  # Backoff exponencial
            else:
                raise e

# Usar la función con manejo de errores
try:
    llm = crear_endpoint_con_reintentos("microsoft/DialoGPT-medium")
    response = llm.invoke("¿Qué es machine learning?")
    print(response)
except Exception as e:
    print(f"Error final: {e}")

Comparación de costes y rendimiento

HuggingFaceEndpoint ofrece un modelo de precios diferente al de OpenAI. Muchos modelos en el Hub son gratuitos para uso moderado, mientras que otros requieren suscripciones Pro. La latencia suele ser mayor que OpenAI pero menor que ejecutar modelos grandes localmente.

# Ejemplo de uso eficiente con batch processing
from langchain_huggingface import HuggingFaceEndpoint

endpoint = HuggingFaceEndpoint(
    repo_id="microsoft/DialoGPT-medium",
    max_new_tokens=150,
    temperature=0.6,
    huggingfacehub_api_token=token
)

# Procesar múltiples consultas de forma eficiente
consultas = [
    "¿Qué es Python?",
    "¿Qué es JavaScript?",
    "¿Qué es machine learning?"
]

respuestas = []
for consulta in consultas:
    try:
        respuesta = endpoint.invoke(consulta)
        respuestas.append(respuesta)
        time.sleep(1)  # Evitar límites de rate limiting
    except Exception as e:
        print(f"Error procesando '{consulta}': {e}")
        respuestas.append(None)

# Mostrar resultados
for i, respuesta in enumerate(respuestas):
    if respuesta:
        print(f"Q: {consultas[i]}")
        print(f"A: {respuesta}\n")

Esta aproximación te permite aprovechar la diversidad de modelos disponibles en Hugging Face Hub sin las limitaciones de hardware local, manteniendo la flexibilidad de LangChain para crear aplicaciones sofisticadas.