Cálculo de VRAM

Toda pregunta de «¿correrá esto en mi tarjeta?» es aritmética, no
folclore. La VRAM total son los pesos, más la caché KV, más una losa fija
de activaciones y sobrecarga del motor. Si sabes multiplicar parámetros
por bits, puedes dimensionar una máquina antes de gastar nada en ella.
Esta página da la fórmula, tablas resueltas y un recorrido de 16 GB que
puedes copiar para cualquier tarjeta.

La fórmula

VRAM total   = pesos + caché KV + sobrecarga
pesos (GB)   = parámetros (B) × bits por peso ÷ 8
caché KV     = bytes por token × longitud de contexto   (véase [caché KV](/guide/kv-cache))
sobrecarga   ≈ 1–2 GB (activaciones, contexto del driver, búferes, fragmentación)

Bits efectivos por peso para las cuantizaciones GGUF comunes: Q4_K_M ≈ 4.8,
Q5_K_M ≈ 5.7, Q6_K ≈ 6.6, Q8_0 ≈ 8.5. Multiplica los parámetros por eso,
divide entre 8, y estás a unos pocos por ciento del tamaño del archivo en
disco.

Reglas rápidas que vale la pena memorizar, en GB por cada mil millones de
parámetros:

• Q4_K_M ≈ 0.6 GB — el caballo de batalla diario
• Q5_K_M ≈ 0.7 GB
• Q6_K ≈ 0.8 GB — casi sin pérdida para la mayoría de los ojos
• Q8_0 ≈ 1.1 GB — transparente, más o menos el doble del coste de Q4
• fp16/bf16 = 2.0 GB — territorio de entrenamiento y ajuste fino serio

Ejemplos resueltos

El tamaño de la caché KV depende de la arquitectura. Los modelos GQA
modernos rondan los 128–256 KB por token con KV fp16 para las clases
8B–32B, y unos 320 KB para la clase 70B. La fórmula exacta vive en
caché KV; aquí simplemente la sumamos. La sobrecarga
está presupuestada en 1.5 GB por fila.

Q4_K_M (~4.8 bits por peso):

Q6_K (~6.6 bits por peso):

Dos patrones para interiorizar. Q6_K cuesta ~35–40% más que Q4_K_M —
muchas veces la diferencia entre un nivel de GPU y el siguiente. Y el KV
a contexto de 32k no es un error de redondeo: en modelos pequeños
rivaliza con los propios pesos. Los diseños MHA antiguos (era Llama-2)
cargaban cachés KV 4–8× más grandes, y por eso el contexto de 32k solía
exigir hardware exótico y los modelos GQA no.

OOM al cargar vs OOM en mitad de la generación

• Al cargar: los pesos solos superan la VRAM libre. El motor se
  niega a arrancar, o pasa capas a la CPU y se arrastra. Honesto,
  inmediato, fácil de diagnosticar.
• En mitad de la generación: los pesos caben, pero la caché KV crece
  token a token. Una sesión fresca funciona bien; cuarenta turnos
  después, tras un volcado de RAG o un archivo pegado, la caché se come
  tu margen y el proceso muere en mitad de la respuesta. Este es el
  traicionero — dimensiona siempre para el contexto que de verdad vas a
  alcanzar, no para el primer prompt.

Obsérvalo en vivo:

watch -n1 nvidia-smi --query-gpu=memory.used,memory.total --format=csv

Hoja de dimensionamiento: el recorrido de 16 GB

1. Presupuesto utilizable: 16 GB × 0.85 ≈ 13.6 GB. El escritorio, el
   navegador y el driver ya reservan 0.5–1 GB; dejar 10–20% de margen es
   la regla, no un lujo.
2. Sueño: 32B Q4_K_M — 19.2 GB de pesos solos. Muerto a la llegada.
3. Realista: 14B Q4_K_M con contexto de 8k: 8.4 + 1.6 + 1.5 = 11.5 GB.
   Cabe con ~15% de margen. Adelante.
4. Ahora quieres contexto de 32k: 8.4 + 6.4 + 1.5 = 16.3 GB. Fuera de
   presupuesto.
5. Tres arreglos — elige uno o combina:
   • Cuantiza la caché KV a q8_0: 6.4 → 3.2 GB, total 13.1 GB. Dentro.
   • Baja los pesos a Q4_K_S o IQ4_XS, ahorrando otros ~0.5–1 GB.
   • Baja a 8B Q6_K: 6.6 + 4.2 + 1.5 = 12.3 GB, holgado.

Los mismos cinco pasos sirven para una tarjeta de 8 GB, una de 24 GB o
una caja de doble GPU con 48 GB. Presupuesta, sueña, resta, ajusta.

Deja margen, siempre

Los motores asignan búferes de trabajo por hueco de lote, la
fragmentación se acumula en un servidor de larga vida, y la concurrencia
multiplica el KV por petición activa. Una configuración que «justo cabe»
en una prueba de banco puntual hará OOM en producción. Dejar 10–20%
libres es el impuesto por mantenerse en pie. Para qué cabe en cada nivel
de tarjeta en la práctica, véase niveles de GPU;
para por qué los bits de cuantización son los que son, véase
Cuantización.

Relacionados: Cuantización · caché KV ·
niveles de GPU