La afinación de modelos de lenguaje de gran tamaño (LLM) ha dejado de ser un privilegio exclusivo de quienes disponen de clústeres con GPUs empresariales. Hoy, gracias a la combinación de Unsloth y Ollama, es posible realizar un ajuste fino local de un modelo de 8 mil millones de parámetros en una GPU de consumo con menos de 8 GB de memoria de video (VRAM), convertir el modelo al formato GGUF y servirlo en la propia máquina con un solo comando de línea de comandos. Este flujo de trabajo, que se completa en menos de 30 minutos, representa un avance significativo para desarrolladores, científicos de datos y empresas que buscan independencia de las costosas API en la nube.
¿Por qué es relevante hoy?
El costo de los tokens en servicios de LLM en la nube puede escalar rápidamente, especialmente para proyectos con alto volumen de consultas. Además, la privacidad de los datos es una preocupación creciente. La posibilidad de entrenar y ejecutar modelos localmente, sin depender de infraestructura externa, no solo reduce gastos, sino que también mantiene la información sensible dentro de la propia organización. Esta noticia es de interés para la comunidad tecnológica de México y Latinoamérica, donde el acceso a hardware de alto rendimiento puede ser limitado, pero el talento para aprovechar recursos locales es abundante.
Unsloth, una biblioteca de optimización, reescribe las capas de atención de PyTorch y las funciones de pérdida de entropía cruzada en núcleos Triton de OpenAI hechos a mano. Esto permite entrenar modelos de 8B parámetros en GPUs de 16 GB o 24 GB sin los frecuentes errores de memoria agotada (OOM) que ocurren con los pipelines estándar de Hugging Face. Por su parte, Ollama facilita la ejecución local de modelos en formato GGUF con una interfaz de línea de comandos sencilla.
Requisitos previos
Antes de comenzar, es necesario contar con un sistema Linux o WSL2 con CUDA instalado, y una GPU de consumo con al menos 8 GB de VRAM. También se deben obtener los recursos de los repositorios oficiales de Unsloth y Ollama. A continuación, se detallan los pasos para configurar el entorno.
Instalación de Ollama y entorno virtual
El primer paso es instalar Ollama en el sistema. Se puede descargar desde su sitio oficial y seguir las instrucciones para Linux. Luego, se crea un entorno virtual de Python aislado para evitar conflictos de dependencias. Dentro de este entorno, se instala Unsloth junto con las dependencias de PyTorch. Un ejemplo de comandos sería:
python -m venv unsloth_env
source unsloth_env/bin/activate
pip install unsloth
pip install torch --extra-index-url https://download.pytorch.org/whl/cu118
Es importante asegurarse de que la versión de CUDA sea compatible con la GPU disponible.
Preparación del conjunto de datos
Para este tutorial, se utilizará un conjunto de datos de atención al cliente con pares de instrucción-respuesta. El objetivo es afinar el modelo Llama 3 8B Instruct para que responda de manera personalizada a consultas de soporte. El conjunto de datos debe estar en formato JSON o CSV, con campos claros para la instrucción y la respuesta.
Proceso de afinación con Unsloth
Se crea un script de entrenamiento llamado train.py. En él, se carga el modelo pre-cuantizado a 4 bits directamente desde Hugging Face y se inyectan los parámetros LoRA. Gracias a las optimizaciones de Unsloth, el entrenamiento se realiza en pasos rápidos y con bajo consumo de memoria. Un fragmento representativo del código es:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/llama-3-8b-instruct-bnb-4bit",
max_seq_length = 2048,
dtype = None,
load_in_4bit = True,
)
model = FastLanguageModel.get_peft_model(
model,
r = 16,
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"],
lora_alpha = 16,
lora_dropout = 0,
bias = "none",
)
Luego, se utiliza el SFTTrainer para entrenar sobre los pares instrucción-respuesta durante 60 pasos. La biblioteca Unsloth acelera el proceso y evita la compilación manual de llama.cpp.
Exportación a GGUF
Al finalizar el entrenamiento, se exporta el modelo directamente a formato GGUF con cuantización de 4 bits (q4_k_m). Esto se logra con una línea adicional en el script:
model.save_pretrained_gguf("custom_model", tokenizer, quantization_method = "q4_k_m")
Este comando genera los pesos cuantizados y un archivo Modelfile configurado automáticamente en el directorio ./custom_model.
Ejecución local con Ollama
Una vez exportado el modelo, se indica a Ollama que apunte a la carpeta generada y se lanza el modelo con un solo comando:
ollama create mi_modelo -f ./custom_model/Modelfile
ollama run mi_modelo
Con esto, el modelo afinado queda disponible para consultas locales, sin necesidad de conexión a internet ni de enviar datos a servidores externos.
Ventajas de este flujo de trabajo
- Entrenamiento local en 15-30 minutos: Gracias a las optimizaciones de Unsloth, el tiempo de ajuste se reduce drásticamente.
- Eliminación de dependencias de API externas: No más gastos recurrentes por tokens ni latencia de red.
- Privacidad de los datos: Toda la información propietaria permanece dentro de la infraestructura propia.
- Bajo consumo de recursos: Funciona en GPUs de consumo con menos de 8 GB de VRAM, democratizando el acceso a la IA.
Este enfoque es especialmente valioso para startups y equipos de desarrollo en América Latina, donde el acceso a hardware de gama alta puede ser restringido. La combinación de Unsloth y Ollama abre la puerta a la personalización de modelos de lenguaje sin grandes inversiones.
Conclusión
La afinación y ejecución local de LLM ya no es un sueño lejano. Con las herramientas adecuadas y una guía clara, cualquier desarrollador con una GPU de consumo puede entrenar un modelo de 8B parámetros en menos de media hora y ejecutarlo sin depender de servicios en la nube. Esta noticia marca un hito en la democratización de la inteligencia artificial, y sin duda impulsará la innovación en la región.
