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
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
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.
Aprendizajes de esta lección
- Comprender la diferencia entre HuggingFacePipeline (ejecución local) y HuggingFaceEndpoint (servicio en la nube).
- Aprender a instalar y configurar HuggingFacePipeline para ejecutar modelos localmente con PyTorch y Transformers.
- Saber crear y configurar pipelines y endpoints para tareas de generación de texto y chat.
- Conocer cómo ajustar parámetros de generación para controlar la creatividad y determinismo de las respuestas.
- Integrar HuggingFacePipeline y HuggingFaceEndpoint con LangChain Expression Language para crear cadenas de procesamiento complejas.
Completa LangChain y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs