Cuantización en la práctica con Ollama

Qué abarca este artículo sobre cuantización en Ollama

• Qué métodos de cuantización existen.
• Cómo cuantizar modelos a GGUF con llama.cpp.
• Diferencias entre Q4_K_M, Q5_K_M, Q8_0 y otros métodos.
• Cómo importar archivos GGUF propios en Ollama.
• Consejos para equilibrar calidad, velocidad y memoria.

Introducción: cuantización en la práctica con Ollama

Ollama ofrece muchos modelos en diferentes cuantizaciones. Sin embargo, a veces necesitas llevar un modelo específico de Hugging Face a un formato adecuado, por ejemplo porque los tags estándar no encajan o porque quieres ajustar el tamaño exacto del archivo. Para eso puedes convertir el modelo a GGUF y luego cuantizarlo. El procedimiento correcto determina cuánta memoria ahorras y cuánta calidad pierdes.

Este artículo te muestra los niveles de cuantización más importantes y el flujo práctico con llama.cpp.

Conceptos clave

• Cuantización: Reducción de la profundidad de bits de los pesos del modelo.
• GGUF: Formato de llama.cpp para modelos almacenados.
• Q4_K_M: Cuantización de 4 bits, K-Quant-Medium, buen equilibrio.
• Q5_K_M: Cuantización de 5 bits, mayor calidad que Q4.
• Q8_0: Cuantización de 8 bits, casi calidad original.
• F16: Precisión media, 16 bits por parámetro.
• FP32: Precisión de punto flotante de 32 bits completa.
• imatrix: Importance Matrix, cuantización mejorada.
• KLD: Método de perplejidad para evaluación de calidad.

Por qué cuantizar

• Los modelos más grandes caben en menos VRAM.
• Múltiples modelos pueden mantenerse simultáneamente en memoria.
• Los tiempos de carga se reducen.
• Las CPUs pueden utilizar modelos en primer lugar.
• El espacio en disco disminuye.

La desventaja es una posible pérdida de calidad. Con 4 bits, la diferencia es pequeña en muchos modelos, pero en tareas muy complejas puede ser notable.

Niveles de cuantización habituales

Nivel	Bits	Requisito de memoria	Calidad	Uso
Q2_K	2	muy bajo	baja	CPU de emergencia
Q3_K_S / Q3_K_M	3	bajo	moderada	VRAM muy limitado
Q4_K_M	4	bueno	buena	Estándar para consumidor
Q5_K_M	5	mayor	muy buena	Mejor calidad
Q8_0	8	alto	casi idéntica	Cuando hay espacio
F16	16	muy alto	original	Fine-tuning o entrenamiento

Requisitos previos

Una opción es utilizar llama.cpp o unsloth:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make

Alternativamente, hay binarios precompilados o imágenes Docker.

Convertir modelo a GGUF

Para modelos de Hugging Face, puedes usar convert_hf_to_gguf.py:

python convert_hf_to_gguf.py /ruta/al/modelo \
  --outfile mi-modelo-f16.gguf \
  --outtype f16

El resultado es un GGUF F16 que aún no está cuantizado.

Cuantizar con llama-quantize

./llama-quantize mi-modelo-f16.gguf mi-modelo-q4_k_m.gguf Q4_K_M

Niveles adicionales:

./llama-quantize mi-modelo-f16.gguf mi-modelo-q5_k_m.gguf Q5_K_M
./llama-quantize mi-modelo-f16.gguf mi-modelo-q8_0.gguf Q8_0

Usar Importance Matrix

Para mejores resultados con Q4 y Q5, puedes calcular una imatrix:

./llama-imatrix -m mi-modelo-f16.gguf -f datos-entrenamiento.txt --output-file mi-modelo.imatrix
./llama-quantize --imatrix mi-modelo.imatrix mi-modelo-f16.gguf mi-modelo-q4_k_m.gguf Q4_K_M

Una imatrix ayuda a cuantizar los pesos importantes con más precisión.

Importar modelo en Ollama

Crea un Modelfile:

FROM ./mi-modelo-q4_k_m.gguf

SYSTEM """
Eres un asistente preciso.
"""

PARAMETER temperature 0.7

Luego importa:

ollama create mi-modelo -f Modelfile

Ofrecer múltiples cuantizaciones

Puedes importar un modelo en diferentes niveles:

ollama create mi-modelo:q4 -f Modelfile.q4
ollama create mi-modelo:q5 -f Modelfile.q5
ollama create mi-modelo:q8 -f Modelfile.q8

Verificar la calidad

Después de cuantizar, debes probar el modelo en tareas conocidas. Las áreas importantes incluyen:

• Resúmenes
• Tareas de programación
• Matemáticas
• Multilingüismo
• Razonamiento lógico

Una comparación con el original F16 muestra cuánta calidad se pierde.

Tamaño y velocidad

• Los modelos cuantizados más pequeños son más rápidos porque requieren menos ancho de banda de memoria.
• Con Q2_K y Q3_K_S, la calidad puede disminuir drásticamente.
• Q4_K_M es el equilibrio estándar para GPUs de consumidor.
• Q8_0 es casi sin pérdida, pero requiere significativamente más memoria.

Consejos

• Usa Q4_K_M para el uso diario.
• Q5_K_M para programación o tareas complejas.
• Usa Q8_0 si tienes suficiente VRAM.
• F16 solo para entrenamiento o casos especiales.
• Calcula imatrix para modelos importantes.
• Compara resultados con el original.

Problemas típicos

• Formato incorrecto: Los modelos de Hugging Face deben convertirse primero a GGUF.
• Arquitectura incompatible: No todos los modelos son soportados por llama.cpp.
• Cuantización demasiado agresiva: Q2_K o Q3_K_M a menudo destruye la calidad.
• Archivos de tokenizador faltantes: La conversión requiere archivos de modelo completos.
• VRAM aún demasiado pequeño: El modelo no cabe aunque esté cuantizado.
• GGUF corrupto: Ejecuta una suma de verificación o una prueba.

Enlaces e información adicional

• BotServ.de Ollama Modelfiles
• BotServ.de Ollama Performance
• BotServ.de Fundamentos de cuantización
• BotServ.de Calculadora de cuantización

Preguntas frecuentes: cuantización en la práctica

¿Qué cuantización es el mejor equilibrio? Para la mayoría de aplicaciones, Q4_K_M.

¿Se pierde mucha calidad? Con Q4_K_M, generalmente poco; con Q8_0, casi nada.

¿Puedo usar modelos de Hugging Face en Ollama? Sí, mediante conversión a GGUF e importación en Ollama.

¿Necesito Linux? llama.cpp funciona en Windows y macOS, pero Linux es el más común.

¿Cuánto tarda la cuantización? Dependiendo del tamaño del modelo y la CPU, desde minutos hasta horas.

Fuentes y lecturas adicionales

• llama.cpp: https://github.com/ggerganov/llama.cpp
• GGUF Format: https://github.com/ggerganov/ggml/blob/master/docs/gguf.md
• TheBloke en Hugging Face: https://huggingface.co/TheBloke

Resumen: cuantización en la práctica con Ollama

La cuantización es esencial para ejecutar modelos grandes en hardware de consumidor. Con llama.cpp puedes convertir modelos de Hugging Face a GGUF y cuantizarlos en niveles como Q4_K_M, Q5_K_M o Q8_0. Para obtener los mejores resultados con memoria limitada, una Importance Matrix es de gran ayuda. Después de importar a través de un Modelfile de Ollama, el modelo cuantizado se puede usar como cualquier otro modelo de Ollama. Lo importante es equilibrar calidad y requisitos de memoria, y elegir el nivel adecuado para tu hardware y tarea específica.