Carga de Modelos Open Source con Langchain y Hugging Face
Resumen
¿Cómo elegir y utilizar modelos de lenguaje de diferentes proveedores?
Explorar y seleccionar modelos de lenguaje de diferentes proveedores es una actividad crucial para los desarrolladores de inteligencia artificial. Con herramientas como Langchain, podemos facilitar este proceso al homogenizar el uso de estos modelos. Esto significa que, independientemente de la fuente del modelo, utilizamos un mismo objeto y clase para cargarlos, lo que simplifica su manejo y su integración en producción. Aquí veremos cómo utilizar modelos open source del Hub de Hugging Face a través de pasos específicos.
¿Cómo instalar y preparar el entorno para Langchain?
Para comenzar a trabajar con los modelos de Hugging Face, lo primero es preparar tu entorno. Aquí hay algunos pasos que seguir para instalar y configurar las herramientas necesarias:
Instalación de Langchain: Utiliza el comando pip install langchain en Google Colab.
Paquetes adicionales: Dependiendo del proveedor de modelos, requerirás instalar diferentes librerías. En este caso, debemos instalar:
Transformers, esencial para la inteligencia artificial.
InOps.
Accelerate, que mejora la eficiencia al cargar modelos en hardware específico como GPU o CPU.
Estos componentes permiten que el entorno esté listo para cargar y utilizar modelos.
¿Cómo se cargan modelos open source de Hugging Face?
Una vez que tenemos nuestro entorno configurado, podemos proceder a cargar los modelos deseados. Para ello, utilizamos las librerías de Transformers para importar AutoTokenizer y Pipeline. Vamos a detallar el proceso:
AutoTokenizer: Se encarga de tokenizar nuestro texto para el modelo.
Pipeline: Ayuda a cargar, descargar y utilizar el modelo fácilmente.
Como parte práctica, seleccionamos un modelo de generación de texto, como el Falcon de 7 billones de parámetros, que es más pequeño y adaptable para Google Colab.
Código de ejemplo para cargar un modelo:
from transformers importAutoTokenizer, pipeline
# Cargar el tokenizador y pipeline del modelo Falcon de 7 billones
tokenizer =AutoTokenizer.from_pretrained("nombre_del_modelo")text_generation =pipeline("text-generation", model="nombre_del_modelo", tokenizer=tokenizer)
¿Cómo integrar el modelo con Langchain?
Para maximizar la utilidad del modelo y su integración con otros sistemas, lo conectamos al ecosistema de Langchain:
Importar desde Langchain: Utilizamos HuggingFacePipeline de Langchain para conectar el pipeline del modelo.
Código para integrar el modelo en Langchain:
from langchain importHuggingFacePipeline# DefinirHuggingFacePipeline en Lanchainllm_falcon =HuggingFacePipeline(pipeline=text_generation, model_kwargs={"temperature":0})
Esta integración nos permite manipular con facilidad los parámetros del modelo (como temperatura, longitud máxima, etc.), y garantiza que el modelo sea utilizado de manera eficiente.
¿Cuáles son las ventajas y desafíos de utilizar modelos open source?
Los modelos open source, como los de Hugging Face, ofrecen gran flexibilidad y control. Por ejemplo:
Ventajas:
Control total y posibilidad de personalización.
Mayor privacidad, al no depender de servidores externos para su ejecución.
Desafíos:
Descarga y tiempo de procesamiento pueden ser elevados.
Requieren infraestructura para su manejo, ya sea en la nube o local.
La riqueza de estos modelos es vasta, y explorar diferentes opciones te permitirá identificar cuál se ajusta mejor a tus necesidades. Modelos de otros idiomas, como español de Stability AI, también están disponibles. Es recomendable experimentar con varios modelos para descubrir su potencial.
Prueba y optimización
Finalmente, te animamos a experimentar con diferentes modelos del Hub de Hugging Face. Descarga modelos para pruebas en otros idiomas y amplía tu capacidad de prueba. Si decides utilizar Colab, recuerda gestionar el entorno para evitar saturar tu máquina. Tu capacidad para elegir e implementar modelos será determinante en el éxito de tus proyectos de inteligencia artificial.
Tengan ojo cuando y donde corren esto. Como se daran cuenta esta utilizando una cuenta PRO de google colab. En mi caso ni usando un colab normal ni un deepnote funcionara el código. A mi me funciono solo usando un pc con mas recursos en Azure AI
🤓 En Google Colab normal sí funciona. Solo hay que tener cuidado qué modelo cargamos.
Por ejemplo el falcon de 7B sí funciona en Google Colab normal, pero el de 40b no porque necesita más RAM.
OJO también: que la memoria de Google Colab puede verse rebasada si corren varias veces el pipeline de carga del modelo.
Ahora entiendo perfectamente porque murió mi Colab... Muchas gracias :D
Yo estou creando un proyecto para desarrollar modelos de código abierto afinándolos para que interpreten mejor español si les gustaría contribuir me escriben. Este curso esta buenísimo
ok
Miguel, Me interesa colaborar
para Jan 2025, este es el código para cargar el modelo:
Como recomendación personal para que puedan ejecutarlo en casi cualquier computadora!.
Lo difícil de este código es cargar el modelo, cada modelo tiene un peso distinto que se ira a la RAM de sus ordenadores y por tanto entre más grande y pesado el modelo. Más recursos va a consumir.
Hace unos días qwen lanzo su nueva familia de modelos, la versión 3. Entre los cuales se encuentra uno muy interesante: Qwen/Qwen3-0.6B-Base · Hugging Face
El cual es un modelo muy pequeño, que solo requiere de 1GB de RAM así que es posible ejecutarlo incluso en dispositivos móviles.
Podemos cambiar el modelo de la clase por este modelo y con eso podríamos correr el programa en casi cualquier dispositivo.
Terrible como esta desactualizado, y solo son las primeras clases
La mayoría de modelos genera lo que se le da la gana, en algunos casos nada que ver con la entrada
Ejemplo:
usando el model "datificate/gpt2-small-spanish" Genera:
llm_neo ("que es ai?")
que es ai? y sin embargo, como todos estos se refieren mucho más a un episodio de "Uncanny Lips" en la que se ve que "The New Yorker" se puede describir, el show tiene la oportunidad de mostrar
llm_neo ("que es ia?")
que es ia? - ¿por qué? - por qué, o por qué no? "Ephanax" está escrito aproximadamente como: ""Mantea, Mantea, Mantea, Mantea, Memoe
llm_neo ("que es inteligencia artificial?")
que es inteligencia artificial? El científico Paul Martin, nacido con el nombre de Paul Martin, es un neurocientífico experto en la estructura de los sistemas neuronales artificiales que se basan en la investigación de los patrones de un cerebro y las propiedades de esos patrones..
Y si le quitamos el signo de pregunta?? jajaj aun mas loco:
llm_neo ("que es inteligencia artificial")
que es inteligencia artificial. También se encuentra la capacidad de crear seres inteligentes y los cuales, aunque son incipientes y nunca causan daños, son capaces de crear seres humanos. También se encuentra la capacidad de transformar humanos en cuerpos de agua; aunque pueden
En fin... Las IA
Nov 2025, para que me funcionara el código tuve que instalar:
!pip install langchain-community
y luego:
from langchain_community.llms import HuggingFacePipeline
Ejemplo para Jan 2026:
from transformers import AutoTokenizer, pipeline, AutoModelForCausalLM
import torch
# model = "tiiuae/falcon-40b-instruct"# model = "stabilityai/stablelm-tuned-alpha-3b"# model = "tiiuae/falcon-7b-instruct"model_id ="stabilityai/stablelm-tuned-alpha-3b"tokenizer = AutoTokenizer.from_pretrained(model_id)model = AutoModelForCausalLM.from_pretrained(model_id)# create the pipeline from text generationpipeline = pipeline("text-generation", model=model, tokenizer=tokenizer, dtype=torch.bfloat16,# memory optimization, trust_remote_code=True,# if model needs it device_map="auto"# Multi cpu/gpu audo-split)
from langchain_huggingface import HuggingFacePipeline
# wrap in langchain LLmllm = HuggingFacePipeline( pipeline=pipeline,# modelkwargs override defaults during llm.invoke() calls. model_kwargs={'temperature':0,'max_length':200,# Max total tokens in output (prompt + generation); prevents runaway generation'do_sample':True,# enables probabilistic sampling (False = greedy decoding, always picks highest prob token)'top_k':10,# Sample from only top 10 most likely tokens at each step (reduces low-prob "weird" tokens)'num_return_sequences':1,# Generate 1 output sequence (higher = beam search with multiple candidates)'eos_token_id': tokenizer.eos_token_id # Explicit end-of-sequence token ID (helps model know when to stop cleanly)})
Al parecer muchas cosas han cambiado en este código. Aquí les dejo como lo implemente para el modelo de Qwen/Qwen3-0.6B.
Espero que a alguien le sirva.
//Para este modelo se requiere generar un token de huggingface y configurarlo en el entorno de google colab
!pip install -U langchain-huggingface
!pip install -q transformers einops accelerate
from transformers import AutoTokenizer, pipeline
import torch
model = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model)
// La configuración del pipeline se hace aquí
pipeline = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
dtype=torch.bfloat16,
trust_remote_code=True,
device_map="auto",
max_new_tokens=200,
do_sample=True,
top_k=10,
temperature=0.1,
eos_token_id=tokenizer.eos_token_id,
pad_token_id=tokenizer.eos_token_id
)
type(pipeline)
llm_qwen
llm_qwen.invoke("What is AI?") // Se requiere el método invoke
Los tokenizers son herramientas que convierten texto en una secuencia de tokens, que son unidades de significado, como palabras o subpalabras. Esto permite que los modelos de lenguaje procesen texto de manera más efectiva.
Los transformers son arquitecturas de modelos de aprendizaje profundo que utilizan mecanismos de atención para procesar secuencias de datos, como texto. Estos modelos son especialmente potentes para tareas de generación y análisis de texto.
El código que mencionas se descompone así:
tokenizer = AutoTokenizer.from_pretrained(model): Carga un tokenizer preentrenado asociado al modelo especificado. Este tokenizer es responsable de convertir texto a tokens.
pipeline = pipeline(...): Crea un objeto de procesamiento que se utilizará para la generación de texto. Los parámetros especifican:
"text-generation": tipo de tarea.
model=model: el modelo que se usará para la generación.
tokenizer=tokenizer: el tokenizer previamente cargado.
torch_dtype=torch.bfloat16: especifica el tipo de dato para optimizar la memoria.
trust_remote_code=True: permite la ejecución de código remoto.
device_map="auto": distribuye automáticamente la carga del modelo en el hardware disponible.
Esto permite utilizar el modelo para generar texto de manera eficiente y simplificada.
Estoy siguiendo los pasos pero al dia de la fecha hay muchos inconvenientes con las librerias, modelos y demas... quedó muy desactualizado me parece
Consulta, ¿tienen planeado alguna actualización del contenido?, langchain ha cambiado bastante en las últimas versiones, creo que algunos ejemplos se rompen por la nueva ubicación de modulos ModuleNotFoundError.
cual es el maximo de top_k y los otros parametros?
Creo que es importante mencionar también que existen limitaciones de ciertos modelos que se quieran usar para fines comerciales, muchos de los modelos más famosos tienen esa restricción.
Para los que tenian la duda sobre porque no usan tokenizer en las clases anteriores.
En Creación de un sistema de preguntas y respuestas con LangChain, la idea principal es hacer RAG: primero buscar buen contexto en documentos y luego responder.
Por eso el flujo es: PDFs -> chunks -> embeddings -> base vectorial -> retriever -> respuesta del modelo.
En Carga de Modelos Open Source con Langchain y Hugging Face, el foco cambia: aquí vemos más la ejecución directa del modelo (prompt -> tokenizer -> modelo -> respuesta), sin que el paso central sea recuperar contexto desde una base vectorial.
Un punto clave: en ambos casos hay tokenización.
La diferencia es que en el primer enfoque casi no la vemos porque está abstraída por LangChain/Ollama, y en el segundo la vemos más explícita porque trabajamos más cerca de Hugging Face.
En resumen:
Embeddings: sirven para encontrar contexto relevante.
Tokenizer: sirve para convertir texto a tokens para que el modelo lo procese.
Se complementan, no son alternativas.
Creo que este curso esta un poco desactualizado por que actalmente me eh encontrado con varios problemas de que algunas libreias estan deprecated
AYUDAAAA e intentado de todas las maneras pero no logro incrementar el largo de la respuesta, estoy usando otro modelo llamado zephyr pero lo mismo me pasaba con falcon
%%capture
%pip install langchain
%pip install git+https://github.com/huggingface/transformers.git
%pip install accelerate einops
from transformers import pipeline, AutoTokenizer
import torch
# model = "tiiuae/falcon-40b-instruct"# model = "stabilityai/stablelm-tuned-alpha-3b"# model = "tiiuae/falcon-7b-instruct"model ='HuggingFaceH4/zephyr-7b-alpha'# model = 'gpt2'tokenizer = AutoTokenizer.from_pretrained(model)# Configura el pipeline para generación de textopipeline = pipeline("text-generation", model=model, tokenizer=tokenizer, trust_remote_code=True, torch_dtype=torch.bfloat16,# Usa torch.bfloat16 para el tipo de datos de PyTorch device_map="auto")from langchain import HuggingFacePipeline
llm = HuggingFacePipeline( pipeline=pipeline,# Asigna el objeto pipeline aquí model_kwargs={'temperature':0,# Controla la aleatoriedad en la generación de texto'max_new_tokens':10000,# Controla la longitud máxima del texto generado'do_sample':True,# Indica si se utiliza muestreo aleatorio para generar texto'top_k':10,# Controla la cantidad de tokens considerados durante el muestreo'max_length':500,'num_return_sequences':1,# Especifica cuántas secuencias de texto se deben generar'eos_token_id': tokenizer.eos_token_id # El ID del token de fin de oración (EOS) en el vocabulario del tokenizer})
Hugging Face Model Hub alberga más de 120.000 modelos, 20.000 conjuntos de datos y 50.000 aplicaciones de demostración (Spaces), todas de código abierto y disponibles públicamente, en una plataforma en línea donde las personas pueden colaborar fácilmente y desarrollar ML juntas.
me sale un error ModuleNotFoundError Traceback (most recent call last)
<ipython-input-6-4214136b1134> in <cell line: 1>()
----> 1 from langchain import HuggingFacePipeline
2
3 llm_falcon = HuggingFacePipeline(
4 pipeline = pipeline,
5 model_kwargs = {
Añade una nueva celda por encima de esa y añade la instrucción
%%capture!pip install langchain-community langchain-core --upgrade langchain
Esto debería funcionarte
Buena respuesta, si me funcionó!
Me esta saliendo este error cuando corro llm_falcon('What is AI?'):
The following model_kwargs are not used by the model: ['trust_remote'] (note: typos in the generate arguments will also show up in this list)
