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.

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.
EquipoParámetros (B)Activos (B)CapasKV headsDim. cabezaContexto máx.
Llama 3.1 8B Instruct8,038,03328128131 072
Llama 3.3 70B Instruct70,570,5808128131 072
Qwen3 32B32,832,864812840 960
Gemma 3 27B IT27,427,46216128131 072
Mistral Small 3.2 24B Instruct 25062424408128131 072
gpt-oss-120b1175,136864131 072
Qwen3 235B-A22B2352294412840 960
DeepSeek-R16713761128192163 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)
0102030401k10k100k1MContexto (tokens) (log)KV cache (GB)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)
KV cache en FP16 según el contexto, calculado con la fórmula anterior a partir del config.json de cada modelo (fuente: src/data/llm-models.json). DeepSeek-V3, con 671 000 M de parámetros, guarda menos KV por token que Llama 3.1 8B gracias a MLA.

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

050100H100 SXM 80 GB (3 350 GB/s)78,8 tok/sRTX PRO 6000 Blackwell 96 GB (1 792 GB/s)42,2 tok/s2 × RTX 3090 24 GB (936 GB/s)22 tok/sM3 Ultra 512 GB (819 GB/s)19,3 tok/sM4 Max 128 GB (546 GB/s)12,8 tok/sDGX Spark 128 GB (273 GB/s)6,4 tok/sRyzen AI Max+ 395 128 GB (256 GB/s)6 tok/stok/s

Techo = GB/s ÷ 42,5 GB. Lo medido suele ser el 60-80 % de esta cifra.

Techo teórico de tokens por segundo con Llama 3.3 70B en Q4_K_M (42,5 GB de pesos, batch 1, sin contar el KV cache). Ancho de banda de la ficha de cada fabricante (fuente: src/data/gpus.json). La RTX 5090 no aparece: 32 GB no bastan para cargarlo. Con 2 × RTX 3090 el modelo se reparte en capas y cada token pasa por las dos tarjetas en secuencia, así que el techo es el de una sola.

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.

RTX 5090 · 8B Q4_K_M364tok/stecho: 1 792 ÷ 4,92 GB
RTX 4090 · 8B Q4_K_M205tok/stecho: 1 008 ÷ 4,92 GB
M4 Max · 8B Q4_083tok/smedido en llama.cpp (techo ≈ 116)
M4 Max · 70B Q4_K_M12,8tok/stecho: 546 ÷ 42,5 GB

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.

8B en RTX 5090: prefill ≈ 0,3-1 s por 8 192 tokens · decode ≈ 250-300 tok/s

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-40

Por 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.

RAMDDR5-5600 · 2 canales · 14,5 GB del modeloCPUcapas descargadasGPURTX 5090 · capas en VRAMVRAM32 GB GDDR7 · 28 GB del modelo89,6 GB/s · 162 ms/tokenPCIe 5.0 ×16 · solo activaciones1 792 GB/s · 16 ms/token
Ruta de un token con offload parcial: la parte del modelo en RAM se lee al ancho de banda de la RAM y domina el tiempo total (fuentes: fichas de NVIDIA y JEDEC para las cifras de ancho de banda; PCIe 5.0 ×16 = 63 GB/s por sentido).

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

  1. 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).
  2. 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.
  3. 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.
  4. 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.
  5. Meta — Llama-3.1-8B-Instruct (config.json) — 32 capas, 8 cabezas KV, head_dim 128: 128 KiB de KV por token.
  6. 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.
  7. 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».
  8. 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.
  9. Google — Gemma 3 27B IT — 62 capas (10 globales + 52 locales con ventana 1 024), 16 cabezas KV.
  10. NVIDIA — GeForce RTX 5090, especificaciones — 32 GB GDDR7, 1 792 GB/s; FP16 dense 419 TFLOPS del whitepaper Blackwell.
  11. NVIDIA — DGX Spark — 128 GB LPDDR5X unificados a 273 GB/s.
  12. Apple — Mac Studio, especificaciones — M4 Max 546 GB/s con 128 GB; M3 Ultra 819 GB/s con hasta 512 GB.

Escribe para buscar en artículos, herramientas y glosario. Esc para cerrar.