Evaluar el desempeño de modelos Ollama

Qué cubre este artículo

• Por qué son importantes los benchmarks.
• Qué métricas se miden.
• Cómo calcular tokens por segundo.
• Cómo medir VRAM y RAM.
• Comparar modelos con diferente cuantización.

Introducción: Evaluar el desempeño de modelos Ollama

Los modelos locales vienen en múltiples tamaños, cuantizaciones y arquitecturas. No todos los modelos se ejecutan con la misma velocidad en cualquier hardware ni ofrecen la misma calidad. Los benchmarks permiten determinar qué modelo se ajusta mejor a un caso de uso específico y a tu infraestructura. Lo que importa es la velocidad, el consumo de memoria y la calidad de las respuestas.

Este artículo muestra cómo evaluar el desempeño de modelos Ollama de forma sencilla.

Conceptos clave

• Throughput: Cantidad de tokens por segundo.
• Latency: Tiempo hasta recibir la primera respuesta.
• TTFT: Time To First Token.
• VRAM: Memoria de video de la GPU.
• Cuantización: Reducción de precisión del modelo.
• Prompt-Tokens: Tokens en el texto de entrada.
• Completion-Tokens: Tokens en el texto de respuesta.
• Perplexity: Medida de incertidumbre del modelo.

Qué deberías medir

• Tokens por segundo (total): Velocidad general.
• Tiempo de evaluación del prompt: Tiempo para procesar el contexto.
• Tiempo de evaluación: Tiempo para generar tokens de respuesta.
• Consumo de VRAM: ¿Hay suficiente memoria disponible?
• Consumo de RAM: En ejecución basada únicamente en CPU.
• Calidad: Revisar respuestas a preguntas predefinidas.

Benchmark simple en Python

import requests
import time

url = "http://localhost:11434/api/generate"

prompt = "Explica brevemente qué es una red neuronal."
model = "llama3.1"

payload = {
    "model": model,
    "prompt": prompt,
    "stream": False,
    "options": {
        "num_predict": 100
    }
}

start = time.time()
response = requests.post(url, json=payload)
end = time.time()

data = response.json()
duration = end - start
tokens = data.get("eval_count", 0)
tps = tokens / duration if duration > 0 else 0

print(f"Duración: {duration:.2f} s")
print(f"Tokens: {tokens}")
print(f"Tokens/s: {tps:.2f}")
print(f"VRAM: verifica con nvidia-smi")

Analizar la respuesta

print(data["response"])

Comparar varios modelos

models = ["llama3.1", "qwen2.5:7b", "mistral:7b"]
prompt = "¿Qué es Docker?"

for model in models:
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False,
        "options": {"num_predict": 100}
    }
    start = time.time()
    r = requests.post(url, json=payload)
    end = time.time()
    data = r.json()
    duration = end - start
    tokens = data.get("eval_count", 0)
    print(f"{model}: {tokens/duration:.2f} tokens/s")

Evaluación del prompt vs. evaluación de completado

Ollama proporciona en modo stream: false campos como prompt_eval_count y eval_count. Estos permiten calcular métricas más detalladas:

• prompt eval time: Tiempo para procesar el contexto.
• eval time: Tiempo para generar la respuesta.

Medir VRAM

nvidia-smi --query-gpu=memory.used --format=csv -l 1

O para AMD:

rocm-smi --showmeminfo vram

Preguntas de prueba para evaluar calidad

Los benchmarks de velocidad no dicen nada sobre calidad. Las preguntas predefinidas ayudan:

• Resumir un texto.
• Explicar un concepto.
• Traducción.
• Generación de código.
• Acertijos lógicos.

Comparar cuantizaciones

Cuant	Tokens/s	Calidad	VRAM
Q4_0	alta	menor	baja
Q4_K_M	alta	buena	baja
Q5_K_M	media	muy buena	media
Q8_0	baja	alta	alta

Recomendación: Busca la cuantización más pequeña con la que la calidad siga siendo suficiente.

Benchmark automatizado

import json
import time
import requests

def benchmark(model, prompt, num_predict=100):
    url = "http://localhost:11434/api/generate"
    start = time.time()
    r = requests.post(url, json={
        "model": model,
        "prompt": prompt,
        "stream": False,
        "options": {"num_predict": num_predict}
    })
    end = time.time()
    data = r.json()
    return {
        "model": model,
        "duration": end - start,
        "tokens": data.get("eval_count", 0),
        "tps": data.get("eval_count", 0) / (end - start)
    }

results = [benchmark(m, "Explica IA en tres oraciones.") for m in ["llama3.1", "qwen2.5"]]
print(json.dumps(results, indent=2))

Consejos

• Reinicia Ollama antes de cada ejecución para evitar que datos antiguos afecten el caché.
• Usa el mismo prompt y el mismo valor de num_predict.
• Ejecuta varios intentos y calcula el promedio.
• Establece la temperatura en 0 para obtener resultados reproducibles.
• Monitorea la temperatura del hardware para evitar limitación de rendimiento.

Tramapas comunes

• El primer intento es más lento: El modelo necesita cargarse.
• Longitud diferente del prompt: Afecta los tiempos.
• Streaming: Difícil medir de forma síncrona.
• Limitación de GPU: Más lento después de carga prolongada.
• Cuantización incorrecta: El modelo no cabe en VRAM.
• Efectos de caché: El modelo permanece en memoria.

Enlaces e información adicional

• BotServ.de Ollama Desempeño
• BotServ.de Ollama Cuantización en la práctica
• BotServ.de Ollama Actualización de modelos
• BotServ.de Ollama Evaluación

FAQ: Benchmarks de Ollama

¿Cuál es una cifra buena de tokens por segundo? Depende del modelo y del hardware. Entre 10 y 30 tokens/s es típico para modelos locales de 7B.

¿Debería usar siempre la cuantización más alta? No, si la calidad es suficiente para tu caso de uso, una cuantización menor es más rápida.

¿Cómo mido VRAM? Con nvidia-smi o rocm-smi durante la ejecución.

¿Por qué el segundo intento es más rápido? Porque el modelo ya está en memoria.

¿Puedo evaluar la calidad automáticamente? Solo de forma limitada. Lo mejor es usar preguntas predefinidas y evaluación manual.

Fuentes y lectura adicional

• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• llama.cpp Benchmarks: https://github.com/ggerganov/llama.cpp/blob/master/examples/perplexity/README.md
• Contar tokens: https://platform.openai.com/tokenizer

Resumen: Evaluar el desempeño de modelos Ollama

Los benchmarks son esenciales para encontrar los modelos Ollama adecuados para tu hardware y casos de uso. Debes medir tokens por segundo, TTFT, consumo de VRAM y RAM, además de la calidad de las respuestas. Con scripts sencillos en Python puedes comparar modelos y cuantizaciones de forma sistemática. Si ejecutas varios intentos con el mismo prompt obtendrás resultados reproducibles y podrás elegir deliberadamente el mejor equilibrio entre velocidad y calidad.