Optimizar la velocidad de Ollama

Qué cubre este artículo sobre la velocidad de Ollama

• Factores que ralentizan Ollama.
• Flash Attention y optimizaciones ggml.
• KV-Cache y sus efectos.
• Cuantización y tamaño del modelo.
• Configuración práctica y comandos.

Introducción: Optimizar la velocidad de Ollama

Ollama es fácil de usar, pero quien quiera extraer el máximo rendimiento de su hardware necesita comprender algunos detalles. Las bajas velocidades en tokens por segundo suelen deberse a una cuantización subóptima, contextos innecesariamente grandes, ejecución en CPU en lugar de GPU, u optimizaciones faltantes como Flash Attention. Con la configuración correcta es posible lograr mejoras significativas en muchos casos.

Este artículo muestra qué palancas tienes disponibles para hacer Ollama más rápido.

Conceptos clave

• Flash Attention: Cálculo de atención eficiente en memoria.
• KV-Cache: Buffer para pares clave-valor.
• Cuantización: Reducción de la precisión del modelo.
• num_gpu: Número de capas del modelo ejecutadas en GPU.
• num_thread: Threads de CPU.
• batch_size: Cantidad de tokens procesados simultáneamente.
• mlock: Reserva de RAM para evitar swapping.
• f16_kv: KV-Cache en formato half-float.

Palancas principales

Usar GPU en lugar de CPU

ollama run llama3.1

Si Ollama se ejecuta en CPU, verifica:

nvidia-smi

o

rocm-smi

Ollama debe ser detectado con CUDA o ROCm.

Forzar más capas en GPU

ollama run llama3.1 --verbose

En la llamada a la API:

{
  "options": {
    "num_gpu": 50
  }
}

num_gpu define cuántas capas del modelo se cargan en la GPU.

Activar Flash Attention

Ollama usa Flash Attention cuando es compatible. Algunos modelos necesitan compilación especial o una compilación ggml con soporte para Flash Attention. Las versiones recientes de Ollama a menudo lo activan automáticamente.

Reducir la cuantización

Una cuantización menor significa menos VRAM y cálculos más rápidos:

• Q4_0: rápido, baja calidad.
• Q4_K_M: buen compromiso.
• Q5_K_M: mejor calidad.
• Q8_0: archivo grande, alta calidad.

ollama run llama3.1:8b-instruct-q4_K_M

Reducir el contexto

PARAMETER num_ctx 4096

Más contexto significa más lentitud. No lo hagas más grande de lo necesario.

Limitar num_predict

PARAMETER num_predict 512

Esto evita respuestas demasiado largas y limita el tiempo de cálculo.

Ajustar threads de CPU

Para ejecución pura en CPU:

ollama run llama3.1

O mediante Modelfile:

PARAMETER num_thread 8

Usar mlock

Evita que Ollama se intercambie en disco:

PARAMETER use_mlock true

Medir la memoria

Observa durante la ejecución:

watch -n 1 nvidia-smi

Si la VRAM está llena, reduce el tamaño del modelo, la cuantización o el contexto.

Batch size

Las entradas más largas se procesan más rápido al aumentar num_batch:

PARAMETER num_batch 512

Pero no todos los modelos y backends se benefician por igual.

Temperatura en 0

Para pruebas reproducibles y algo más rápidas:

PARAMETER temperature 0

Actualizar Ollama

ollama -v

Las nuevas versiones suelen incluir mejoras de rendimiento.

Ejemplo práctico de Modelfile

FROM llama3.1:8b-instruct-q4_K_M

PARAMETER num_ctx 4096
PARAMETER num_gpu 50
PARAMETER num_predict 512
PARAMETER use_mlock true
PARAMETER num_batch 512
PARAMETER temperature 0.7

Consejos

• Siempre verifica primero si se usa GPU.
• Elige la cuantización más pequeña que sea adecuada.
• No sobredimensiones el contexto.
• Mantén Ollama actualizado.
• Ejecuta benchmarks antes y después de la optimización.
• Monitorea la temperatura del hardware.

Tropiezos típicos

• Se ejecuta en CPU en lugar de GPU: Problema con drivers u instalación de Ollama.
• num_ctx demasiado alto: La memoria se agota, el rendimiento cae.
• Cuantización no soportada: El modelo regresa a CPU.
• KV-Cache demasiado grande: Evaluación de prompt más lenta.
• Versión antigua de Ollama: Flash Attention no disponible.
• Limitación térmica: Más lento después de carga prolongada.

Enlaces e información adicional

• BotServ.de Benchmarks de modelos Ollama
• BotServ.de Rendimiento de Ollama
• BotServ.de Longitud del contexto Ollama
• BotServ.de Cuantización Ollama en la práctica

Preguntas frecuentes: velocidad de Ollama

¿Por qué es lento Ollama? Normalmente ejecución en CPU, modelo demasiado grande, contexto alto o limitación térmica.

¿Cuál es la mejor forma de acelerar Ollama? Usar GPU, cuantización más pequeña, reducir contexto, mantener Ollama actualizado.

¿Flash Attention aporta mucho? Sí, especialmente con contextos largos, pero no siempre disponible.

¿Debo cambiar num_gpu? Puede ayudar si tienes problemas con la distribución automática.

¿Ayuda más RAM a la CPU? Solo si realiza cálculos en CPU. Para GPU es más importante la VRAM.

Fuentes y lecturas adicionales

• Ollama Performance: https://github.com/ollama/ollama/blob/main/docs/troubleshooting.md
• Flash Attention: https://github.com/Dao-AILab/flash-attention
• llama.cpp: https://github.com/ggerganov/llama.cpp

Resumen: Optimizar la velocidad de Ollama

El rendimiento de Ollama mejora significativamente mediante el uso de GPU, cuantización adecuada, reducción del contexto y optimizaciones de cache. Flash Attention y versiones recientes de Ollama ayudan además. Quien realiza benchmarks regularmente y ajusta parámetros como num_ctx, num_predict y num_batch encontrará el equilibrio óptimo para su hardware y caso de uso.