Key Takeaways
- Modelos 7B: ~4 GB de pesos en Q4, ~5 GB en Q5, ~7 GB en Q8. Añade 1-2 GB de margen para una recomendación real de 6-8 GB.
- Modelos 13B: ~8 GB de pesos en Q4, ~9 GB en Q5, ~14 GB en Q8. 12 GB de VRAM es cómodo, no "apenas suficiente".
- Modelos 70B: ~42 GB de pesos en Q4, ~50 GB en Q5, ~74 GB en Q8. Reserva más para configuraciones 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): ~2 GB de pesos en Q4, 4 GB de VRAM recomendada con margen
- Modelos 7B (Llama, Mistral, Qwen): ~4 GB de pesos en Q4, 6-8 GB de VRAM recomendada
- Modelos 13B (Llama 3.3, Mistral): ~8 GB de pesos en Q4, 10-12 GB de VRAM recomendada
- Modelos 22B (Qwen3, Gemma): ~13 GB de pesos en Q4, 16 GB de VRAM recomendada
- Modelos 70B (Llama 3.3, Qwen 3.6): ~42 GB de pesos en Q4, 48 GB de VRAM recomendada, 50+ GB en Q5
- Modelos MoE: la VRAM escala con los pesos que debes mantener en memoria. Ejemplo: Qwen 3.6 35B-A3B (3B activos) cabe en una huella diminuta de ~2 GB, mientras que Llama 4 Scout (17B activos / 109B totales) aún necesita ~55 GB en Q4 porque todos los expertos permanecen residentes
# Quick VRAM formula (memorize this)
VRAM (GB) ≈ Model Size (B) × 0.6 # at Q4 quantization
# Examples:
7B × 0.6 = 4.2 GB
70B × 0.6 = 42 GB
# For other quantizations (bytes per parameter):
Q8 (8-bit): Model Size × 1.05
Q5 (5-bit): Model Size × 0.7
FP32 (full): Model Size × 4
# Verified against real GGUF file sizes (Hugging Face):
# Llama-2-7B Q4_K_M = 4.08 GB, Mistral-Small-24B Q4_K_M = 14.33 GB,
# Llama-3.3-70B Q4_K_M = 42.52 GB¿Cuál es la fórmula de VRAM para LLMs?
VRAM (GB) = Tamaño del modelo en miles de millones × Bytes por parámetro
- Tamaño del modelo: Número de parámetros (7B, 13B, 70B, etc.)
- Bytes por parámetro: 4,0 (FP32, precisión completa), ~1,05 (Q8, 8 bits), ~0,7 (Q5, 5 bits), ~0,6 (Q4, 4 bits)
- Estas cifras están verificadas contra tamaños reales de archivos GGUF en Hugging Face, no solo el ancho de bits teórico -- formatos reales como Q4_K_M llevan algo de overhead sobre el mínimo teórico de 4 bits (0,5 bytes/parámetro).
Ejemplo: Llama 3.3 70B, FP32, sin cuantización:
70 mil millones × 4,0 bytes = 280 GB. Impracticable en hardware de consumo.
Llama 3.3 70B, cuantización Q4 (4 bits):
70 mil millones × 0,6 bytes = 42 GB. (El GGUF Q4_K_M real de Llama-3.3-70B-Instruct pesa 42,52 GB.)
Modelos MoE (Dispersos): Los parámetros activos determinan el cómputo, pero todos los expertos deben permanecer cargados en VRAM. Ejemplo: Llama 4 Scout tiene 109B de parámetros totales con 17B activos por token. En Q4 aún necesita ~55 GB de VRAM para mantener todos los expertos — solo entra en una GPU de 24 GB con un quant agresivo de 1.78 bits (~20 tok/s). El cómputo es barato; la memoria es la restricción.
¿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 | 3 GB | 2 GB | 2 GB | RTX 3050 4 GB o RTX 2060 6 GB |
| 7B (Llama 3.3, Mistral) | 28 GB | 7 GB | 5 GB | 4 GB | RTX 4060 8 GB o RTX 3060 12 GB |
| 13B (Llama 3.3, Mistral) | 52 GB | 14 GB | 9 GB | 8 GB | RTX 3060 12 GB o RTX 4070 12 GB |
| 22B (Qwen, Gemma) | 88 GB | 23 GB | 15 GB | 13 GB | RTX 4080 16 GB o RTX 4090 24 GB |
| 70B (Llama 3, Qwen) | 280 GB | 74 GB | 50 GB | 42 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 | 14 GB | 9 GB | 8 GB | RTX 3060 12 GB o RTX 5070 12 GB |
| Llama 4 Scout (17B activos / 109B total, MoE)† | 436 GB | 114 GB | 76 GB | 55 GB | 2× RTX 4090 (48 GB) — entra en 24 GB solo a 1.78 bits (~20 tok/s) |
| gpt-oss:20b (3.6B activos / 21B total, MoE)* | 84 GB | 22 GB | 15 GB | 12 GB | RTX 5070 12 GB o cualquier GPU de 16 GB |
| Kimi K2.6 (32B activos / 1T total, MoE)* | 128 GB | 34 GB | 22 GB | 19 GB | 2× RTX 4090 o RTX 5090 32 GB (solo Q4) |
Las cifras son tamaños de pesos puros, verificados contra tamaños reales de archivos GGUF en Hugging Face (p. ej. Llama-2-7B Q4_K_M = 4,08 GB, Mistral-Small-24B Q4_K_M = 14,33 GB, Llama-3.3-70B Q4_K_M = 42,52 GB) -- añade 1-2 GB de margen para el contexto/caché KV. * Modelos MoE: la VRAM se calcula solo a partir de los parámetros activos, no del tamaño total del modelo. † Llama 4 Scout mantiene los 109B parámetros residentes, por lo que necesita ~55 GB en Q4 pese a tener solo 17B activos por token.
Mejor LLM local por nivel de VRAM
La mayoría ya sabe cuánta VRAM tiene su GPU y quiere la búsqueda inversa: "tengo 12 GB, ¿cuál es el mejor modelo?". Usa esta tabla en lugar de la fórmula.
Haz coincidir la VRAM de tu GPU con el nivel de modelo más grande que soporte en Q4, y luego consulta la tabla de arriba para el modelo exacto.
Si ya sabes cuánta VRAM tiene tu GPU, olvídate de las matemáticas: busca la VRAM de tu tarjeta en la tabla de abajo y usa el nivel de modelo indicado junto a ella.
| Nivel de VRAM | Mejor modelo (Q4) | GPUs de ejemplo | Qué cabe |
|---|---|---|---|
| 4 GB | Llama 3.2 3B o Phi-3.5-mini (~1,5-2 GB) | RTX 3050 4 GB, GTX 1650 | Solo clase 3B — los modelos 7B darán OOM |
| 6 GB | Qwen3 4B, o Llama 3.1 8B en Q4 agresivo (~3-4 GB) | RTX 2060 6 GB, RTX 3050 Ti | 4B con holgura; 8B es justo |
| 8 GB | Llama 3.1 8B o Qwen3 8B (~3,5-5 GB) con margen real | RTX 4060 Ti 8 GB, RTX 3070 | El punto óptimo más común para 7-8B |
| 12 GB | Qwen3 14B (~6,5 GB), o 7-8B en Q5/Q8 para más calidad | RTX 3060 12 GB, RTX 4070 | 14B con holgura, margen para más contexto |
| 16 GB | Qwen3 14B en Q5/Q8, o clase 22B (Gemma, Qwen) en Q4 (~11 GB) | RTX 4060 Ti 16 GB, RTX 4080 | 22B es el techo práctico en este nivel |
| 24 GB | 22-32B con holgura en Q8 completo; 70B solo por debajo de 4 bits con pérdida | RTX 4090, RTX 3090 | 70B necesita ~42 GB reales — este nivel no llega |
| 32 GB | 22-32B a precisión completa, o como una tarjeta en un dual-GPU para 70B | RTX 5090 | Aún corto para un 70B Q4 solo (~42 GB necesarios) |
| 48 GB | 70B con holgura en Q4 (~42 GB), justo en Q5 (~50 GB) | 2× RTX 4090, RTX 6000 Ada | Primer nivel que cabe 70B sin trucos de cuantización con pérdida |
| 64 GB+ (memoria unificada) | 70B con holgura en Q4/Q5, sin necesitar dual-GPU | Mac Studio M5 Max/Ultra (128-256 GB) | Única opción de consumo que cabe 70B sin GPU discreta |
Estas son cifras objetivo en Q4 con overhead realista incluido — consulta la tabla de arriba para los mínimos de cómputo puros por nivel de cuantización. La memoria unificada de Apple Silicon (Mac Studio M5 Max/Ultra) es una alternativa a la GPU discreta para los niveles de 48 GB+ — consulta Ejecutar modelos 70B en Apple Silicon M5 Max para tok/s exactos en cada nivel de cuantización.
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. Los parámetros activos reducen el cómputo y aceleran la inferencia, pero en la mayoría de los modelos MoE todos los expertos deben permanecer cargados en VRAM — así que el uso de memoria sigue al total de parámetros, no a los activos.
Regla para modelos densos: VRAM = parámetros_totales × bytes_por_parámetro
Regla para modelos MoE (cómputo): los parámetros_activos determinan los tokens/seg — pero la VRAM aún escala con los pesos totales residentes.
Ejemplo: Llama 4 Scout tiene 109B de parámetros totales con solo 17B activos por token. Es rápido para su tamaño, pero en Q4 aún necesita ~55 GB de VRAM para mantener todos los expertos — fuera del alcance de una sola GPU de 24 GB salvo con un quant agresivo de 1.78 bits (~20 tok/s en una RTX 4090).
Algunos runtimes pueden transmitir o descargar los expertos inactivos a la RAM del sistema, sacrificando velocidad por una huella de VRAM menor. La conclusión clave: no asumas que un modelo MoE cabe en una VRAM del tamaño de sus parámetros activos — comprueba el tamaño real en disco para tu nivel de cuantización.
¿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 ~160-192 GB (40-48 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 (40-48 GB) + caché KV (4 GB) + sistema (2 GB) = ~46-54 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 solo 24 GB para cualquier modelo 70B. Falso. Q4 necesita 40-48 GB. Q8 necesita 70 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:
Preguntas frecuentes
¿Puedo ejecutar Mistral Small en una GPU de 6 GB?
No. Mistral Small es un modelo de 22-24B -- incluso en Q4 necesita unos 13-14 GB de VRAM solo para los pesos. Una GPU de 6 GB u 8 GB dará error de OOM. Reserva 16 GB para un margen cómodo, o baja a un modelo de 7B-8B para una tarjeta de 6-8 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?
Sí, con margen de sobra. Un modelo 13B necesita unos 8 GB en Q4, así que 12 GB deja margen real. En Q5 (~9 GB) sigue siendo cómodo; en Q8 (~14 GB) va ajustado.
¿Necesito 24 GB para un modelo 70B?
No. Un modelo 70B necesita 40-48 GB en Q4. En Q5+, necesitas 50 GB+. 24 GB no es suficiente para ningún modelo 70B en ningún nivel de cuantización.
¿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