Key Takeaways
- Llama 3.3 70B em Q4 = 35 GB (grande demais para 24 GB). Em Q3 = 26 GB (ainda grande demais). Em Q2 = 17 GB (cabe!).
- Compensação: Q2 tem perda de qualidade perceptível. ~70% da qualidade FP16.
- Velocidade: 3-5 tokens/seg com 20 GB descarregados para a RAM do sistema (ultra lento).
- Melhor opção: usar modelo 13B em Q5, ou comprar uma segunda GPU para divisão de camadas.
- A partir de abril de 2026, isso é uma solução alternativa para uma restrição, não uma abordagem recomendada.
A matemática teórica de VRAM
Llama 3.3 70B com várias quantizações:
| Quantização | Tamanho do modelo | Cabe em 24 GB? |
|---|---|---|
| FP16 (base) | — | Não |
| Q8 (8 bits) | — | Não |
| Q5 (5 bits) | — | Não |
| Q4 (4 bits) | — | Não (com offloading: talvez) |
| Q3 (3 bits) | — | Não (por pouco) |
| Q2 (2 bits) | — | Sim |
Quantização agressiva: a ferramenta principal
Para que 70B caiba em 24 GB, você deve usar quantização Q2 ou Q3.
- Q3: 26 GB (ainda 2 GB a mais). Pode descarregar 2 GB para a RAM. Qualidade ligeiramente melhor que Q2.
- Q2: 17,5 GB (cabe!). 70% de qualidade vs FP16. Degradação perceptível, mas utilizável.
Baixe o modelo quantizado: `ollama pull llama3.1:70b-q2` (se disponível) ou use ferramentas de conversão como llama.cpp.
Offloading para a RAM do sistema
Se usar Q4 (35 GB) em uma GPU de 24 GB, você pode descarregar os 11 GB restantes para a RAM do sistema. A penalidade de velocidade é severa (10× mais lento).
Só é prático para processamento em lotes onde você pode esperar horas pelos resultados.
Configuração prática: executar 70B em 24 GB
Passo a passo:
- 1Use quantização Q2: `ollama pull llama3.1:70b-q2` (se disponível; caso contrário, converta com llama.cpp)
- 2Verifique a VRAM: `nvidia-smi` deve mostrar ~18 GB em uso
- 3Execute o modelo: `ollama run llama3.1:70b-q2`
- 4Espere 3-5 tokens/seg (muito lento)
- 5Use apenas para processamento em lotes/offline, não para chat interativo
Expectativas de desempenho realistas
Executar 70B em 24 GB de VRAM é lento:
| Quantização | Velocidade | Latência | Caso de uso |
|---|---|---|---|
| Q2 (24 GB VRAM) | 5-8 tok/seg | 2-4 seg por token | Apenas processamento em lotes |
| Q3 + offload (24 GB) | 3-5 tok/seg | 3-5 seg por token | Extremamente limitado |
| Q4 + offload (24 GB) | 1-3 tok/seg | 5-10 seg por token | Apenas lotes noturnos |
Melhores alternativas ao 70B restrito
Em vez de lutar com 70B com VRAM limitada, considere:
- Usar um modelo 13B (Llama 3.3 13B em Q5 = 8 GB, muito rápido)
- Comprar uma segunda RTX 4090 para divisão de camadas (2× 24 GB = 48 GB, mais de 100 tokens/seg)
- Usar uma API na nuvem (GPT-5.5 para tarefas importantes, local para experimentação)
- Aguardar modelos mais eficientes (menores, mesma qualidade)
Erros comuns com o 70B restrito
- Esperar que Q2 seja utilizável para chat. Não é. A degradação de qualidade é severa demais para interação em tempo real.
- Não medir a velocidade real antes de se comprometer. Teste com um prompt pequeno (10 tokens) e verifique a velocidade antes de executar grandes trabalhos em lotes.
- Assumir que o offloading é "gratuito". A RAM do sistema é 100× mais lenta que a VRAM da GPU. O offloading torna a inferência impraticável.
- Não considerar alternativas. Um modelo 13B é dramaticamente mais rápido e muitas vezes suficiente em qualidade.
Perguntas frequentes
Posso realmente executar um modelo 70B em uma única RTX 4090?
Sim, mas com ressalvas importantes. Com quantização Q2 (17,5 GB), o modelo cabe em 24 GB de VRAM, mas executa a 5-8 tokens/seg e tem ~70% da qualidade FP16. Com Q4 (35 GB), você precisa descarregar 11 GB para a RAM do sistema, reduzindo a velocidade para 1-3 tokens/seg. Nenhuma opção é adequada para chat em tempo real — apenas para processamento em lotes offline.
Qual quantização é necessária para que 70B caiba em 24 GB de VRAM?
A quantização Q2 cabe em 24 GB (17,5 GB de tamanho do modelo). Q3 (26 GB) requer 2 GB de offloading de RAM. Q4 (35 GB) requer 11 GB de offloading e torna a inferência muito lenta. Q5 e superiores não cabem mesmo com offloading em uma GPU de 24 GB. Q2 é a única opção que executa completamente em VRAM.
Quão lento é um modelo 70B em 24 GB de VRAM?
Com Q2 (completamente em VRAM): 5-8 tokens/seg. Com Q3 e 2 GB de offload de RAM: 3-5 tokens/seg. Com Q4 e 11 GB de offload de RAM: 1-3 tokens/seg. Compare com um modelo 13B em Q5 na mesma GPU: 80-100 tokens/seg — 10-20× mais rápido.
É melhor usar um modelo 13B do que um 70B restrito?
Para a maioria das tarefas, sim. Um modelo 13B em quantização Q5 executa a 80-100 tokens/seg em uma RTX 4090. Um modelo 70B em Q2 executa a 5-8 tokens/seg com qualidade degradada. O 13B vence em velocidade e frequentemente em qualidade prática. Use 70B em 24 GB apenas se precisar de capacidades específicas do 70B e puder tolerar uso exclusivamente em lotes.
Qual é o melhor caso de uso para 70B em 24 GB de VRAM?
Processamento em lotes noturno — tarefas onde você envia 100+ prompts e recupera resultados horas depois. Exemplos: análise de documentos, revisões de código em lotes, anotação de conjuntos de dados. Chat em tempo real é impraticável a 1-8 tokens/seg.
Como baixo modelos 70B quantizados em Q2?
Via Ollama: `ollama pull llama3.1:70b-instruct-q2_K` (disponibilidade varia). Via llama.cpp: baixe arquivos GGUF Q2_K do Hugging Face (pesquise "llama-3.1-70b GGUF"). Verifique o modelo com `nvidia-smi` após carregá-lo — o uso de VRAM deve ser ~18-20 GB para Q2.
Fontes
- Quantização llama.cpp -- github.com/ggerganov/llama.cpp/blob/master/gguf-py/gguf/quants.py
- Ficha do modelo: Llama 3.3 70B -- huggingface.co/meta-llama/Llama-3.1-70B