Key Takeaways
- Llama 3.3 70B en Q4 = 35 GB (demasiado grande para 24 GB). En Q3 = 26 GB (todavía demasiado grande). En Q2 = 17 GB (¡cabe!).
- Compensación: Q2 tiene una pérdida de calidad notable. ~70% de la calidad FP16.
- Velocidad: 3-5 tokens/seg con 20 GB descargados a la RAM del sistema (ultra lento).
- Mejor opción: usar un modelo 13B en Q5, o comprar una segunda GPU para división de capas.
- Esto es una solución a una restricción, no un enfoque recomendado.
Un modelo de 70B, que normalmente necesita más de 40 GB de VRAM, puede ejecutarse en una tarjeta de 24 GB usando cuantización agresiva Q2-Q3 y offloading de capas, pero el resultado es lento, solo 3-5 tokens por segundo -- impráctico para chat en tiempo real pero utilizable para trabajos por lotes o experimentación.
Técnicamente puedes meter un modelo de 70B en una tarjeta gráfica de 24 GB, pero es una solución de emergencia, no una buena experiencia. El modelo se comprime mucho y la GPU tiene que intercambiar partes constantemente dentro y fuera de la memoria, así que las respuestas salen a cuentagotas. Está bien si lo dejas corriendo toda la noche o solo quieres probar si el modelo funciona, pero no para una conversación en vivo.
Las matemáticas teóricas del VRAM
Llama 3.3 70B con varias cuantizaciones:
| Cuantización | Tamaño del modelo | ¿Cabe en 24 GB? |
|---|---|---|
| FP16 (base) | — | No |
| Q8 (8 bits) | — | No |
| Q5 (5 bits) | — | No |
| Q4 (4 bits) | — | No (con offloading: quizás) |
| Q3 (3 bits) | — | No (por poco) |
| Q2 (2 bits) | — | Sí |
Cuantización agresiva: la herramienta principal
Para que 70B quepa en 24 GB, debes usar cuantización Q2 o Q3.
- Q3: 26 GB (todavía 2 GB de más). Se pueden descargar 2 GB a la RAM. Calidad ligeramente mejor que Q2.
- Q2: 17,5 GB (¡cabe!). 70% de calidad frente a FP16. Degradación notable pero utilizable.
Descarga el modelo cuantizado: `ollama pull llama3.1:70b-q2` (si está disponible) o usa herramientas de conversión como llama.cpp.
Offloading a la RAM del sistema
Si usas Q4 (35 GB) en una GPU de 24 GB, puedes descargar los 11 GB restantes a la RAM del sistema. La penalización de velocidad es severa (10× más lento).
Solo es práctico para el procesamiento por lotes donde puedes esperar horas para obtener resultados.
Configuración práctica: ejecutar 70B en 24 GB
Paso a paso:
- 1Usa cuantización Q2: `ollama pull llama3.1:70b-q2` (si está disponible; de lo contrario, convierte con llama.cpp)
- 2Verifica el VRAM: `nvidia-smi` debería mostrar ~18 GB en uso
- 3Ejecuta el modelo: `ollama run llama3.1:70b-q2`
- 4Espera 3-5 tokens/seg (muy lento)
- 5Úsalo solo para procesamiento por lotes/sin conexión, no para chat interactivo
Expectativas de rendimiento realistas
Ejecutar 70B en 24 GB de VRAM es lento:
| Cuantización | Velocidad | Latencia | Caso de uso |
|---|---|---|---|
| Q2 (24 GB VRAM) | 5-8 tok/seg | 2-4 seg por token | Solo procesamiento por lotes |
| Q3 + offload (24 GB) | 3-5 tok/seg | 3-5 seg por token | Extremadamente limitado |
| Q4 + offload (24 GB) | 1-3 tok/seg | 5-10 seg por token | Solo lotes nocturnos |
Mejores alternativas al 70B restringido
En lugar de luchar con un 70B con VRAM limitada, considera:
- Usar un modelo 13B (Llama 3.3 13B en Q5 = 8 GB, muy rápido)
- Comprar una segunda RTX 4090 para división de capas (2× 24 GB = 48 GB, más de 100 tokens/seg)
- Usar una API en la nube (GPT-5.5 para tareas importantes, local para experimentación)
- Esperar modelos más eficientes (más pequeños, misma calidad)
Errores comunes con el 70B restringido
- Esperar que Q2 sea utilizable para chat. No lo es. La degradación de calidad es demasiado severa para la interacción en tiempo real.
- No medir la velocidad real antes de comprometerse. Prueba con un prompt pequeño (10 tokens) y verifica la velocidad antes de ejecutar trabajos por lotes grandes.
- Asumir que el offloading es "gratuito". La RAM del sistema es 100× más lenta que la VRAM de la GPU. El offloading hace que la inferencia sea impráctica.
- No considerar alternativas. Un modelo 13B es dramáticamente más rápido y a menudo suficiente en calidad.
Preguntas frecuentes
¿Realmente puedo ejecutar un modelo 70B en una sola RTX 4090?
Sí, pero con advertencias importantes. Con cuantización Q2 (17,5 GB), el modelo cabe en 24 GB de VRAM pero funciona a 5-8 tokens/seg y tiene ~70% de la calidad FP16. Con Q4 (35 GB), necesitas descargar 11 GB a la RAM del sistema, lo que reduce la velocidad a 1-3 tokens/seg. Ninguna opción es adecuada para el chat en tiempo real — solo para el procesamiento por lotes sin conexión.
¿Qué cuantización se necesita para que 70B quepa en 24 GB de VRAM?
La cuantización Q2 cabe en 24 GB (17,5 GB de tamaño de modelo). Q3 (26 GB) requiere 2 GB de offloading de RAM. Q4 (35 GB) requiere 11 GB de offloading y hace que la inferencia sea muy lenta. Q5 y superiores (44-70 GB) no pueden caber incluso con offloading en una GPU de 24 GB. Q2 es la única opción que funciona completamente en VRAM.
¿Qué tan lento es un modelo 70B en 24 GB de VRAM?
Con Q2 (completamente en VRAM): 5-8 tokens/seg. Con Q3 y 2 GB de offload de RAM: 3-5 tokens/seg. Con Q4 y 11 GB de offload de RAM: 1-3 tokens/seg. Compara con un modelo 13B en Q5 en la misma GPU: 80-100 tokens/seg. La configuración 70B restringida es 10-20× más lenta que un modelo más pequeño del tamaño adecuado.
¿Es mejor usar un modelo 13B que un 70B restringido?
Para la mayoría de las tareas, sí. Un modelo 13B con cuantización Q5 funciona a 80-100 tokens/seg en una RTX 4090 y ofrece gran calidad. Un modelo 70B en Q2 funciona a 5-8 tokens/seg con calidad degradada. El 13B gana en velocidad y a menudo en calidad práctica debido a la degradación de Q2. Solo usa 70B-en-24GB si necesitas capacidades específicas del 70B y puedes tolerar un uso exclusivamente por lotes.
¿Cuál es el mejor caso de uso para 70B en 24 GB de VRAM?
Procesamiento por lotes nocturno — tareas en las que envías 100+ prompts y recuperas resultados horas después. Ejemplos: análisis de documentos, revisiones de código por lotes, anotación de conjuntos de datos. El chat en tiempo real es impráctíco a 1-8 tokens/seg. Para uso interactivo, una segunda RTX 4090 ($2.000–$2.600 mercado de segunda mano) con división de capas alcanza ~100 tokens/seg — una inversión mucho mejor.
¿Cómo descargo modelos 70B cuantizados en Q2?
A través de Ollama: `ollama pull llama3.1:70b-instruct-q2_K` (la disponibilidad varía). A través de llama.cpp: descarga archivos GGUF Q2_K desde Hugging Face (busca "llama-3.1-70b GGUF"). TheBloke y bartowski publican versiones cuantizadas. Verifica el modelo con `nvidia-smi` después de cargarlo — el uso de VRAM debería ser ~18-20 GB para Q2.
Fuentes
- Cuantización llama.cpp -- github.com/ggerganov/llama.cpp/blob/master/gguf-py/gguf/quants.py
- Ficha del modelo: Llama 3.3 70B -- huggingface.co/meta-llama/Llama-3.1-70B