Key Takeaways
- Modelos 7B: mínimo 8 GB (Q4), cómodo con 10 GB (Q5), 14 GB para Q8 precisión completa.
- Modelos 13B: mínimo 10 GB (Q4), cómodo con 12-14 GB (Q5), 16 GB para Q8.
- Modelos 70B: mínimo 24 GB (Q4), 32 GB+ para Q5/Q8 o configuración multiusuario.
- La cuantización (Q4, Q5, Q8) reduce la VRAM un 50-75% respecto a la precisión completa (FP32).
- Siempre sobredimensiona 1-2 GB para el overhead (caché KV, estado del optimizador, sistema operativo).
- El batch size ≠ VRAM por inferencia. La inferencia única usa la misma VRAM sin importar el batch (el batch procesa secuencialmente).
- Más VRAM no acelera la inferencia de un solo prompt. Solo ayuda en configuraciones multiusuario/multi-petición.
Regla general de VRAM — Referencia rápida
¿No tienes tiempo para la fórmula? Usa estas reglas simples:
Una vez que conozcas tu presupuesto de VRAM, consulta qué GPUs se adaptan a cada nivel →
- Modelos 3B (Phi, StableLM): mínimo 4 GB de VRAM
- Modelos 7B (Llama, Mistral, Qwen): 8 GB de VRAM (Q4), 10 GB (Q5)
- Modelos 13B (Llama 3.1, Mistral): mínimo 12 GB de VRAM (Q4)
- Modelos 22B (Qwen2.5, Gemma): 16 GB de VRAM (Q4)
- Modelos 70B (Llama 3.3, Qwen 3.6): 24–32 GB de VRAM (Q4–Q5)
- Modelos MoE: usa solo los parámetros activos. Ejemplo: Llama 4 Scout tiene 17B activos = ~9 GB de VRAM, no 44 GB
# Quick VRAM formula (memorize this)
VRAM (GB) ≈ Model Size (B) ÷ 8 # at Q4 quantization
# Examples:
7B ÷ 8 = 0.875 GB per billion ≈ 8 GB total
70B ÷ 8 = 8.75 GB per billion ≈ 48 GB total
# For other quantizations:
Q8 (8-bit): Model Size ÷ 4
Q5 (5-bit): Model Size ÷ 5
FP32 (full): Model Size × 4¿Cuál es la fórmula de VRAM para LLMs?
VRAM (GB) = (Tamaño del modelo en miles de millones × 4 bytes × Factor de cuantización)
- Tamaño del modelo: Número de parámetros (7B, 13B, 70B, etc.)
- 4 bytes: precisión FP32 (1 byte = 8 bits)
- Factor de cuantización: 1.0 (FP32), 0.5 (Q8), 0.25 (Q4)
Ejemplo: Llama 3 70B, FP32, sin cuantización:
70 mil millones × 4 bytes = 280 GB. Impracticable.
Llama 3 70B, cuantización Q4 (4 bits):
70 mil millones × 4 bytes × 0.25 = 70 GB asignados, ~24 GB utilizados tras la compresión.
Modelos MoE (Dispersos): Usa solo el recuento de parámetros activos. Ejemplo: Llama 4 Scout tiene 109B de parámetros totales pero solo 17B activos a la vez. VRAM = 17B × 0.5 bytes (Q4) ≈ 9 GB — no los 44 GB que sugeriría un cálculo ingenuo de parámetros totales.
¿Cuánta VRAM necesita cada tamaño de modelo?
| Tamaño del modelo | FP32 (sin cuantización) | Q8 (8 bits) | Q5 (5 bits) | Q4 (4 bits) | GPU recomendada |
|---|---|---|---|---|---|
| 3B (Phi, StableLM) | 12 GB | 6 GB | 4 GB | 3 GB | RTX 2060 6 GB o RTX 5070 12 GB |
| 7B (Llama 2, Mistral) | 28 GB | 14 GB | 9 GB | 7 GB | RTX 3060 12 GB o RTX 5070 12 GB |
| 13B (Llama 2, Mistral) | 52 GB | 26 GB | 17 GB | 13 GB | RTX 3090 24 GB o RTX 5080 16 GB |
| 22B (Qwen, Gemma) | 88 GB | 44 GB | 28 GB | 22 GB | RTX 4090 24 GB (Q4) o RTX 5090 32 GB |
| 70B (Llama 3, Qwen) | 280 GB | 140 GB | 88 GB | 70 GB | 2× RTX 4090 (24 GB c/u), o 1× H100 80 GB |
| Qwen 3.6 35B-A3B (3B activos, MoE)* | 12 GB | 3 GB | 2 GB | 2 GB | RTX 2060 6 GB o RTX 5070 12 GB |
| DeepSeek V4-Flash (13B activos / 284B total, MoE)* | 52 GB | 13 GB | 8 GB | 7 GB | RTX 3060 12 GB o RTX 5070 12 GB |
| Llama 4 Scout (17B activos / 109B total, MoE)* | 68 GB | 17 GB | 11 GB | 9 GB | RTX 3090 24 GB o RTX 5080 16 GB |
| Kimi K2.6 (42B activos / 1T total, MoE)* | 168 GB | 42 GB | 27 GB | 21 GB | 2× RTX 4090 o RTX 5090 32 GB (solo Q4) |
* Modelos MoE: la VRAM se calcula solo a partir de los parámetros activos, no del tamaño total del modelo.
Los modelos MoE necesitan mucha menos VRAM de lo que su tamaño sugiere
Los modelos Mixture-of-Experts (MoE) distribuyen sus parámetros entre muchas sub-redes "expertas" y activan solo una fracción para cada token. La VRAM depende de los parámetros activos — el subconjunto cargado durante la inferencia — no del total de parámetros.
Regla para modelos densos: VRAM = parámetros_totales × bytes_por_parámetro
Regla para modelos MoE: VRAM = parámetros_activos × bytes_por_parámetro
Ejemplo: Llama 4 Scout tiene 109B de parámetros totales pero solo 17B se activan por token. Con cuantización Q4: 17B × 0.5 bytes ≈ 9 GB — ejecutable en una sola RTX 3090, frente a los ~55 GB que necesitaría un modelo denso de 109B.
Qwen 3.6 35B-A3B es aún más extremo: con 3B activos de 35B totales, tiene la huella de VRAM de un pequeño modelo denso de 3B mientras ofrece la calidad de un modelo de 35B.
¿Cómo reduce la cuantización los requisitos de VRAM?
La cuantización reduce el número de bits necesarios para representar cada parámetro del modelo.
- FP32 (float de 32 bits): Precisión completa. 1 parámetro = 4 bytes. Sin pérdida. Más lento.
- Q8 (8 bits): 1 parámetro = 1 byte. ~6% de pérdida de precisión. 75% de ahorro de VRAM.
- Q5 (5 bits): 1 parámetro = 0.625 bytes. ~2% de pérdida de precisión. 84% de ahorro de VRAM.
- Q4 (4 bits): 1 parámetro = 0.5 bytes. ~1% de pérdida de precisión. 87.5% de ahorro de VRAM.
Para la mayoría de los usuarios, Q4 es el punto óptimo: pérdida de precisión imperceptible, huella de VRAM un 87% menor.
A partir de abril de 2026, Q4 es el estándar. Q5 y Q8 están disponibles si tienes VRAM de sobra y quieres ganancias marginales de calidad.
La VRAM determina el tamaño del modelo, pero el diseño del prompt determina la calidad de la salida. Técnicas como chain-of-thought y few-shot prompting pueden cerrar la brecha de calidad entre modelos más pequeños y más grandes. Explora el completo toolkit de prompt engineering para sacar más partido a los modelos que soporta tu hardware. Si tienes 12–16 GB de VRAM y quieres una carga de trabajo de programación concreta para probar ese toolkit, Reemplazar GitHub Copilot con un LLM local mapea el stack Continue.dev + Ollama + Qwen3-Coder exactamente a esos niveles de VRAM.
¿Qué hay del batch size y la inferencia multiusuario?
El batch size afecta el rendimiento (tokens por segundo), no la latencia de una inferencia individual.
Un solo usuario que pregunta "¿Cuánto es 2+2?" usa la misma VRAM sin importar si el batch size es 1 o 32.
Batch size = 32 significa procesar 32 prompts en paralelo. Esto usa ~32× más VRAM, pero genera 32 respuestas más rápido.
Para usuario único (uso típico de LLM local): Batch size = 1. La VRAM es el tamaño del modelo + 1-2 GB de overhead.
Para servidor multiusuario: Asigna batch size × VRAM del modelo. Un modelo 70B con batch=4 necesita ~96 GB (24 GB × 4).
¿Necesitas más VRAM que el tamaño del modelo?
Sí. Más allá de los pesos del modelo, añade:
- Caché KV (caché clave-valor para el contexto): ~5-10% de VRAM adicional.
- Estado del optimizador (si se hace fine-tuning): 2-4× el tamaño del modelo (solo relevante para entrenamiento, no para inferencia).
- Overhead del sistema (SO, drivers, runtime de Ollama/LM Studio): ~1-2 GB.
Regla: Un modelo 70B Q4 (20 GB) + caché KV (2 GB) + sistema (2 GB) = ~24 GB asignados.
Siempre compra GPUs con al menos 1-2 GB de margen por encima de los mínimos teóricos.
Errores comunes sobre VRAM
- Más VRAM = inferencia más rápida. Falso. El tamaño de VRAM no afecta la velocidad. El ancho de banda de memoria (GB/seg) sí, y es fijo por GPU.
- El batch size = límite secuencial de tokens. Falso. Batch size = peticiones en paralelo. La inferencia individual usa batch=1 sin importar el tamaño de VRAM.
- Necesitas 24 GB para cualquier modelo 70B. Falso. Q4 necesita 24 GB. Q8 necesita 48 GB. Depende de la cuantización.
Calculadora de VRAM
Selecciona el tamaño de tu modelo y la cuantización para estimar los requisitos de VRAM.
Popular Models
Base Model
6.50 GB
Context OH
1.50 GB
Batch OH
0.00 GB
System OH
1.00 GB
Total Minimum
9.00 GB
Recommended (with 25% safety margin)
11.25 GB
👉 Look for a GPU with at least 11.25 GB VRAM
Compatible GPUs
RTX 3060 (12 GB)
0.8 GB headroom
RTX 4070 (12 GB)
0.8 GB headroom
RTX 4070 Ti (12 GB)
0.8 GB headroom
RTX 4080 (16 GB)
4.8 GB headroom
RTX 4090 (24 GB)
12.8 GB headroom
Mac mini M5 (16 GB) (16 GB)
4.8 GB headroom
Mac mini M4 (16 GB) (16 GB)
4.8 GB headroom
MacBook Pro (24 GB) (24 GB)
12.8 GB headroom
M3 Max (36 GB) (36 GB)
24.8 GB headroom
💡 Pro Tips:
- Always use the "with safety margin" figure when buying a GPU
- Q4 gives 90-95% quality with 25% size reduction. Q5 is better if you have room
- Context overhead grows with conversation length. Budget 1-3 GB for typical usage
- Batch size matters for multi-user APIs. Single-user chat can ignore batch overhead
📋 Share this configuration:
FAQ
¿Puedo ejecutar Mistral 7B en una GPU de 6 GB?
Con dificultad, en Q4 con overhead ajustado. En la práctica, no. Compra al menos 8 GB. Tendrás errores de OOM con 6 GB.
¿Cuánta VRAM necesito para hacer fine-tuning de un modelo 7B?
Para LoRA: 12-16 GB. Fine-tuning completo: 28 GB+. El fine-tuning requiere estado del optimizador (2-4× la VRAM del modelo), no solo la inferencia.
¿Son suficientes 12 GB para Llama 3 13B?
En Q4, apenas. En Q5 o Q8, no. 12 GB es muy ajustado. 16 GB es cómodo.
¿Necesito 24 GB para un modelo 70B?
En Q4, sí. En Q5+, no. Una cuantización más alta (Q5, Q8) necesita 32 GB+ para 70B.
¿Aumentar el batch size reduce la VRAM para inferencia individual?
No. La inferencia individual siempre usa la VRAM de batch=1. El batch size solo ayuda al rendimiento (escenarios multiusuario).
¿Cuál es la mejor cuantización para la precisión?
Q8 tiene una pérdida casi imperceptible. Q5 tiene ~2% de pérdida. Q4 tiene ~1% de pérdida. Para la mayoría, Q4 es el punto óptimo.
¿Puedo descargar parte de la VRAM a la RAM de la CPU?
Sí, mediante la división de capas (NVLink). Llama.cpp y Ollama lo soportan. El rendimiento cae un 30-50% pero funciona. ¿Menos de 8 GB de VRAM? Consulta **qué modelos corren más rápido en tu nivel exacto de hardware** — benchmarks con números reales de tok/seg para solo CPU, 4 GB, 6 GB y 8 GB de VRAM.
Fuentes
- Documentación de la arquitectura de memoria CUDA y el modelo de memoria compartida de NVIDIA
- Documentación oficial de Ollama y LM Studio: requisitos de VRAM para modelos y especificaciones de cuantización
- Proyecto llama.cpp en GitHub: niveles de cuantización (Q4, Q5, Q8) y cálculos de memoria