Equipos para IA · Inferencia
Inferencia de LLM en local: VRAM, KV cache, tokens/s y cuantización
Cuánta memoria pide un modelo (pesos + KV cache), por qué los tokens por segundo salen del ancho de banda y no de los TFLOPS, y qué cambia con la cuantización, los MoE y el offload.
Correr un modelo de lenguaje en tu equipo se reduce a dos preguntas. Si cabe: los pesos más la memoria de contexto tienen que entrar en la VRAM o en la memoria unificada. Y a qué velocidad lo recorres: cada token nuevo obliga a leer el modelo entero, así que los tokens por segundo salen de dividir el ancho de banda entre los gigabytes del modelo. Los TFLOPS de la ficha apenas intervienen. Cuantización, MoE, offload y contexto son formas de mover esas dos cifras.
Cuánta memoria piden los pesos
Un modelo es una lista de parámetros y cada uno ocupa un número fijo de bytes según la precisión en que esté guardado. Casi todos se publican en BF16, dos bytes por parámetro. Llama 3.1 8B tiene 8 030 millones: 16,1GB. Llama 3.3 70B tiene 70 550 millones: 141GB. Ninguna GPU de consumo carga el segundo tal cual, y el primero ya se come dos tercios de una tarjeta de 24 GB antes de escribir una palabra.
Memoria de los pesos
GB ≈ parámetros (miles de millones) × bytes por parámetro
Llama 3.3 70B: 70,55 × 2 (BF16) = 141,1 GB · 70,55 × 0,6 (Q4_K_M) ≈ 42,5 GB
El fichero real Q4_K_M de Llama 3.1 70B ocupa 42,5GB: 4,82 bits por parámetro de media, porque las escalas de cuantización y algunas capas que se dejan en más bits se suman al 4 del nombre. Para Q8_0 la media es 8,5 bits (75GB). Regla rápida: 2 bytes en BF16, 1 en FP8 o Q8, unos 0,6 en Q4_K_M, 0,56 en NVFP4.
A los pesos hay que sumar entre un 10 y un 20 % de sobrecarga: buffers de activaciones, contexto CUDA o Metal, kernels y fragmentación del asignador. Un modelo de 20 GB necesita 22 o 23 GB libres antes de contar el contexto. La calculadora de VRAM hace la suma completa.
| Equipo | Parámetros (B) | Activos (B) | Capas | KV heads | Dim. cabeza | Contexto máx. |
|---|---|---|---|---|---|---|
| Llama 3.1 8B Instruct | 8,03 | 8,03 | 32 | 8 | 128 | 131 072 |
| Llama 3.3 70B Instruct | 70,5 | 70,5 | 80 | 8 | 128 | 131 072 |
| Qwen3 32B | 32,8 | 32,8 | 64 | 8 | 128 | 40 960 |
| Gemma 3 27B IT | 27,4 | 27,4 | 62 | 16 | 128 | 131 072 |
| Mistral Small 3.2 24B Instruct 2506 | 24 | 24 | 40 | 8 | 128 | 131 072 |
| gpt-oss-120b | 117 | 5,1 | 36 | 8 | 64 | 131 072 |
| Qwen3 235B-A22B | 235 | 22 | 94 | 4 | 128 | 40 960 |
| DeepSeek-R1 | 671 | 37 | 61 | 128 | 192 | 163 840 |
Arquitectura de los modelos abiertos habituales en local, leída de sus config.json (fuente: src/data/llm-models.json). Parámetros totales y activos coinciden en los densos; en los MoE (gpt-oss, Qwen3 235B, DeepSeek) no.
El KV cache: la memoria que crece con el contexto
El segundo sumando no está en el modelo sino en la conversación. Para no recalcular la atención sobre todo el texto anterior en cada token, el motor guarda por capa y por token procesado dos vectores, la clave (K) y el valor (V): el KV cache. Crece con el contexto y con la anchura de la atención del modelo, y en contextos largos puede pesar más que los pesos.
KV cache por token
bytes/token = 2 (K y V) × capas × cabezas KV × dim. de cabeza × bytes por valor
Llama 3.3 70B en FP16: 2 × 80 × 8 × 128 × 2 = 327 680 B = 320 KiB por token
Con 8 192 tokens de contexto son 2,68GB; con 32 768, 10,7GB; con el máximo de 131 072, 42,9GB, más que los pesos en Q4. La cifra depende de las cabezas KV, no de las de atención: Llama 70B tiene 64 cabezas de consulta pero solo 8 de clave-valor (GQA), y eso divide el cache por 8 respecto a un modelo antiguo con atención completa.
- Llama 3.3 70B (320 KiB/token)
- Qwen3 32B (256 KiB/token)
- Llama 3.1 8B (128 KiB/token)
- DeepSeek-V3 MLA (68,6 KiB/token)
Dos consecuencias prácticas. La primera: el contexto que fijas al arrancar (el num_ctx de Ollama, el -c de llama.cpp) reserva esa memoria aunque la conversación sea corta; un 32B en Q4 que «cabe» en 24 GB deja de caber si pides 32 000 tokens. La segunda: la arquitectura pesa tanto como el tamaño. Qwen3 32B gasta 256 KiB por token; gpt-oss-120b, con 117 000 millones de parámetros, solo 36 KiB, porque la mitad de sus capas usan una ventana de 128 tokens y las globales tienen cabezas de 64 dimensiones. El KV cache también se cuantiza (Q8 lo deja a la mitad casi sin pérdida; Q4 se nota en contextos largos).
Decode: tokens por segundo salen del ancho de banda
Generar un token es multiplicar la activación actual por todos los pesos, capa a capa. Cada parámetro se lee una vez y se usa en una sola multiplicación-suma: dos FLOP por cada 2 bytes en BF16. Es la carga con menor intensidad aritmética que existe, y por eso en generación (decode) con una sola conversación la GPU es, a todos los efectos, su ancho de banda de memoria.
Techo de tokens por segundo en decode (batch 1)
tokens/s ≈ ancho de banda (GB/s) ÷ (bytes de pesos + bytes de KV cache leídos por token)
M4 Max 128 GB con Llama 3.3 70B Q4_K_M: 546 ÷ 42,5 ≈ 12,8 tokens/s de techo
Es un techo, no una predicción: lo real se queda entre el 60 y el 80 % por la latencia de cada kernel, el muestreo y la lectura del KV cache. Medido en llama.cpp con Llama 3.1 8B en Q4_0 (unos 4,7 GB), un M4 Max de 40 núcleos genera 83 tokens/s frente a un techo de unos 116: un 72 %. En una RTX 5090 el 8B en Q4_K_M (4,92 GB) tiene un techo de 364 tokens/s; el 70B en Q4 no cabe en sus 32 GB, así que su cifra es cero.
Llama 3.3 70B Q4_K_M: tokens/s de techo
Techo = GB/s ÷ 42,5 GB. Lo medido suele ser el 60-80 % de esta cifra.
Lo importante del gráfico no es el orden sino la forma. Una RTX 5090 tiene 1 792 GB/s y no está; un Mac con 128 GB está, a un tercio de la velocidad. La capacidad decide si juegas y el ancho de banda a qué ritmo. Por eso la memoria unificada tiene sentido para el 70B y ninguno para el 8B, que cabe en cualquier tarjeta de 8 GB donde la GDDR7 gana por goleada.
Prefill: la única fase en que cuentan los TFLOPS
Antes de generar, el modelo procesa el prompt entero. En esa fase, el prefill, los tokens de entrada se multiplican por los pesos todos a la vez, como un batch grande: una lectura de memoria sirve para miles de tokens y la intensidad sube a miles de FLOP por byte. Aquí manda el cálculo. Es el tiempo hasta la primera palabra, y crece con lo que envías: un documento largo, un historial de chat, el contexto de un agente de código.
Tiempo de prefill
segundos ≈ 2 × parámetros × tokens del prompt ÷ FLOPS efectivos
Llama 3.1 8B, prompt de 8 192 tokens, RTX 5090 (419 TFLOPS FP16 dense): 2 × 8,03 × 10⁹ × 8 192 ÷ 419 × 10¹² ≈ 0,31 s
Ese 0,31 s supone el pico de la ficha; los kernels rinden entre el 30 y el 60 % y el prefill de 8 000 tokens tarda entre medio segundo y uno. En un M4 Max, llama.cpp mide 886 tokens/s de prefill con el 8B en Q4_0: el mismo prompt tarda unos nueve segundos. Es el precio de la memoria unificada que no aparece en los tokens por segundo de generación. En CPU pura, con contextos largos, el prefill es inusable.
Los dos regímenes explican por qué dos equipos con los mismos tokens por segundo se sienten distintos: un Mac genera al mismo ritmo que una GPU discreta modesta, pero tarda mucho más en arrancar con un prompt largo. Los servidores (vLLM, SGLang, TensorRT-LLM) aplican el mismo principio al decode: atienden decenas de conversaciones a la vez, leen los pesos una sola vez por paso y multiplican el caudal; el límite pasa a ser el KV cache de todas las secuencias en vuelo.
Cuantizar: menos bytes por token
Cuantizar es guardar los pesos con menos bits. Como el decode está limitado por bytes leídos, cada bit que quitas se convierte casi linealmente en velocidad y en memoria libre. En la tabla de llama.cpp para Llama 3.1 8B, pasar de F16 (14,96 GiB) a Q4_K_M (4,58 GiB) sube la generación de 29 a 72 tokens/s en el mismo equipo. Ningún FLOPS ha cambiado.
| Formato | Bits/parámetro reales | Llama 3.1 70B | Motor típico | Qué se pierde |
|---|---|---|---|---|
| BF16 / FP16 | 16 | 141,1 GB | Transformers, vLLM | Nada (es el original) |
| FP8 (E4M3) | 8 | ~70 GB | vLLM, TensorRT-LLM (Ada, Hopper, Blackwell) | Casi nada; cálculo nativo en FP8 |
| Q8_0 (GGUF) | 8,5 | 74,98 GB | llama.cpp, Ollama, LM Studio | Indistinguible del original |
| Q6_K (GGUF) | 6,56 | 57,89 GB | llama.cpp | Muy poco |
| Q4_K_M (GGUF) | 4,89 (8B) · 4,82 (70B) | 42,52 GB | llama.cpp | Poco; el equilibrio habitual |
| AWQ / GPTQ 4 bits | ~4,25-4,5 | ~40 GB | vLLM, ExLlama (solo GPU) | Similar a Q4_K_M |
| NVFP4 / MXFP4 | 4,5 / 4,25 | 39,4 GB / ~37 GB | vLLM, TensorRT-LLM (Blackwell) | Poco; cálculo nativo en 4 bits |
| Q3_K_M / Q2_K (GGUF) | 4,0 / 3,16 | 34,27 GB / 26,38 GB | llama.cpp | Se nota; crece deprisa por debajo de 4 bits |
Los bits «reales» superan al nombre porque cada grupo de 32 a 128 pesos lleva una escala que hay que almacenar, y porque los formatos K de llama.cpp guardan en más bits las capas sensibles. La pérdida se mide en perplejidad o divergencia KL frente al original, y la regla es estable: Q8 no se distingue, Q5 y Q4_K_M pierden poco, y por debajo de 4 bits la degradación crece deprisa. Los modelos grandes aguantan mejor: un 70B en Q4 suele ser mejor que un 32B en Q8 aunque ocupen parecido; un 8B en Q2 se nota en cualquier conversación.
GGUF, AWQ y GPTQ son formatos de almacenamiento: el kernel descuantiza a FP16 antes de multiplicar, así que funcionan en cualquier GPU y aceleran la lectura, no el cálculo. FP8 (Ada, Hopper, Blackwell) y NVFP4 o MXFP4 (Blackwell) se multiplican en el formato reducido y acortan también el prefill y el batching. Para una conversación en local la diferencia es pequeña; para servir muchas, grande.
MoE: parámetros totales, parámetros activos y lo que cuesta cada uno
Un modelo Mixture of Experts reparte cada capa en decenas de expertos y un enrutador elige unos pocos por token. gpt-oss-120b tiene 117 000 millones de parámetros, 128 expertos por capa y activa 4: cada token usa 5 100 millones. DeepSeek-V3 y R1 tienen 671 000 millones y activan 37 000 millones. Qwen3 235B-A22B, 235 000 millones y 22 000 millones activos.
La memoria la fijan los parámetros totales: todos los expertos tienen que estar cargados, porque el enrutador elige otros en cada token y en cada capa. gpt-oss-120b ocupa unos 61 GB en MXFP4; DeepSeek-R1, 671 GB en su FP8 nativo y unos 390 GB en Q4. Los bytes leídos por token los fijan los parámetros activos: el 120b lee unos 2,7 GB por token (5,1 × 10⁹ × 0,53 B), no 61.
gpt-oss-120b en DGX Spark: 273 GB/s ÷ 2,7 GB/token ≈ 100 tok/s de techo (memoria); medido, del orden de 30-40Por eso los MoE han invadido la memoria unificada: un 120B denso a 273 GB/s daría 4 tokens/s; el MoE se mueve decenas de veces más rápido con el mismo ancho de banda. La contrapartida es la capacidad: gpt-oss-120b no cabe en ninguna GeForce, y sí en un Strix Halo, un DGX Spark o un Mac Studio de 128 GB. Fíjate en que lo medido queda más lejos del techo que en un denso: el enrutado y los expertos dispersos en memoria rompen la lectura secuencial que la fórmula supone.
Y ojo con el marketing que anuncia solo los activos: Qwen3 30B-A3B activa 3 300 millones por token y en decode va cinco o más veces más rápido que un 32B denso, pero en Q4_K_M ocupa unos 18 GB, no 2. Los activos dicen la velocidad; los totales, la memoria. Para comprar hardware lee los dos.
Offload: lo que no cabe se paga en velocidad
Cuando el modelo no cabe, llama.cpp y sus derivados dejan parte de las capas en la RAM y las procesan en la CPU. Es la única manera de probar un 70B en una tarjeta de 24 o 32 GB. El coste: cada token sigue leyendo el modelo entero, y la parte que vive en RAM se lee a la velocidad de la RAM. Con DDR5-5600 en doble canal son 89,6 GB/s, veinte veces menos que la VRAM de una RTX 5090.
Tiempo por token con offload
s/token ≈ GB en VRAM ÷ GB/s de la VRAM + GB en RAM ÷ GB/s de la RAM
70B Q4_K_M en RTX 5090 + DDR5-5600: 28 ÷ 1 792 + 14,5 ÷ 89,6 = 0,016 + 0,162 = 0,178 s → 5,6 tok/s
Con 28 GB en la tarjeta (quedan 4 GB para KV cache y sobrecarga) y 14,5 GB en RAM, el 91 % del tiempo de cada token se va en la RAM aunque solo aloje un tercio del modelo. Entero en una RTX PRO 6000 de 96 GB, el techo es de 42 tokens/s: siete veces más. Un tercio fuera de la VRAM no cuesta un tercio de la velocidad; cuesta casi toda.
Con los MoE la cuenta cambia: los motores recientes dejan en VRAM la atención y los expertos más usados y sacan el resto a RAM. Como cada token toca pocos expertos, el tráfico con la RAM es una fracción del modelo y el castigo baja mucho; es lo que hace usable DeepSeek-R1 en Q4 en una workstation con 512 GB de RAM y una GPU, a pocos tokens por segundo. Para un denso la conclusión es tajante: si no cabe entero, compra memoria o baja de tamaño.
Qué motor para qué
- llama.cpp es el motor de referencia para GGUF: CUDA, Metal, ROCm, Vulkan y CPU, con reparto de capas entre GPU y RAM. Ollama y LM Studio son envoltorios sobre él (LM Studio añade MLX en Mac); su parámetro de contexto es el que reserva el KV cache.
- vLLM y SGLang son servidores: batching continuo, PagedAttention, FP8 y NVFP4 nativos, tensor parallel. Brillan con muchas peticiones a la vez; para una conversación en una GPU no van más rápido que llama.cpp.
- ExLlama (EXL2, EXL3) es CUDA puro con bits fraccionarios por capa: lo más rápido en una GeForce para un modelo que cabe entero. No hace offload.
- Con varias GPU, el reparto por capas rinde como una sola tarjeta; el tensor parallel sí suma ancho de banda, a cambio de cargar PCIe en cada capa.
Antes de comprar, pasa el modelo y el contexto por la calculadora de VRAM y por tokens por segundo; el comparador de GPU ordena las candidatas por GB y por GB/s, las dos columnas que importan.
Lo que debes recordar
- Memoria = parámetros × bytes por parámetro + KV cache + 10-20 % de sobrecarga. Los bytes por parámetro son 2 en BF16, 1 en FP8/Q8, unos 0,6 en Q4_K_M.
- KV cache por token = 2 × capas × cabezas KV × dim. de cabeza × bytes. Llama 70B: 320 KiB; a 32 000 tokens, 10,7 GB. El contexto que reservas se paga entero.
- Tokens/s en decode ≈ ancho de banda ÷ bytes leídos por token; lo medido es el 60-80 % de eso. Los TFLOPS solo cuentan en el prefill y al servir muchas peticiones.
- En un MoE los totales fijan la memoria y los activos la velocidad. Los dos importan.
- El offload a RAM lee esa parte a 90 GB/s en vez de a 1 800: un tercio fuera de la VRAM cuesta casi toda la velocidad. En denso, o cabe entero o cambia de modelo.
Para mirar en una ficha técnica
- Capacidad de memoria (GB): decide qué modelos caben, con su KV cache. Trampa: «corre en 16 GB» habla de los pesos en la cuantización más agresiva y con contexto mínimo.
- Ancho de banda (GB/s): dividido por los GB del modelo da el techo de tokens/s. Trampa: los TFLOPS y «AI TOPS», que casi no intervienen en decode.
- Parámetros totales y activos: memoria y velocidad, respectivamente. Trampa: anunciar solo los activos.
- Cabezas KV y capas del config.json: fijan los KiB por token del KV cache. Trampa: comparar contextos máximos sin mirar lo que cuesta cada token.
- Bits por peso reales: 4,8-4,9 en Q4_K_M, 8,5 en Q8_0. Trampa: un fichero «4 bits» con un 20 % más de bytes de lo calculado.
Fuentes
- llama.cpp — tools/quantize/README.md — bits por peso, tamaño en GiB y tokens/s de Llama 3.1 8B por tipo de cuantización (F16 29,17; Q4_K_M 71,93 tokens/s).
- bartowski — Meta-Llama-3.1-70B-Instruct-GGUF — tamaños de fichero reales del 70B: Q8_0 74,98 GB, Q6_K 57,89, Q5_K_M 49,95, Q4_K_M 42,52, Q3_K_M 34,27, Q2_K 26,38 GB.
- llama.cpp — Performance of llama.cpp on Apple Silicon M-series (discusión #4167) — medición de 83 tokens/s en generación y 886 en prefill con Llama 8B Q4_0 en un M4 Max de 40 núcleos; M3 Ultra 92 tokens/s.
- Meta — Llama-3.1-70B-Instruct (config.json) — 80 capas, 64 cabezas, 8 cabezas KV, hidden 8 192, contexto 131 072; misma arquitectura que Llama 3.3 70B.
- Meta — Llama-3.1-8B-Instruct (config.json) — 32 capas, 8 cabezas KV, head_dim 128: 128 KiB de KV por token.
- Qwen — Qwen3-32B y Qwen3-235B-A22B — 64 capas / 8 KV heads en el 32B; 94 capas, 4 KV heads, 128 expertos y 8 por token en el 235B-A22B.
- OpenAI — gpt-oss-120b — 117 000 M totales / 5 100 M activos, 36 capas alternando ventana de 128 tokens y atención global, pesos MXFP4, «cabe en una GPU de 80 GB».
- DeepSeek — DeepSeek-V3 (config.json e informe técnico) — 671 000 M / 37 000 M activos, MLA con kv_lora_rank 512 + rope 64 = 576 elementos por token y capa, pesos FP8 nativos.
- Google — Gemma 3 27B IT — 62 capas (10 globales + 52 locales con ventana 1 024), 16 cabezas KV.
- NVIDIA — GeForce RTX 5090, especificaciones — 32 GB GDDR7, 1 792 GB/s; FP16 dense 419 TFLOPS del whitepaper Blackwell.
- NVIDIA — DGX Spark — 128 GB LPDDR5X unificados a 273 GB/s.
- Apple — Mac Studio, especificaciones — M4 Max 546 GB/s con 128 GB; M3 Ultra 819 GB/s con hasta 512 GB.