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.
- Isso é uma solução alternativa para uma restrição, não uma abordagem recomendada.
Um modelo 70B, que normalmente precisa de mais de 40 GB de VRAM, pode rodar em uma placa de 24 GB usando quantização agressiva Q2-Q3 e offloading de camadas, mas o resultado é lento, apenas 3-5 tokens por segundo -- impraticável para chat em tempo real, mas utilizável para trabalhos em lote ou experimentação.
Tecnicamente dá para encaixar um modelo 70B em uma placa de vídeo de 24 GB, mas isso é um paliativo, não uma boa experiência. O modelo é fortemente comprimido e a GPU precisa trocar partes constantemente dentro e fora da memória, então as respostas saem aos poucos. Tudo bem se você deixar rodando durante a noite ou só quiser testar se o modelo funciona, mas não serve para uma conversa ao vivo.
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) | 140 GB | Não |
| Q8 (8 bits) | 70 GB | Não |
| Q5 (5 bits) | 43,75 GB | Não |
| Q4 (4 bits) | 35 GB | Não (com offloading: talvez) |
| Q3 (3 bits) | 26 GB | Não (por pouco) |
| Q2 (2 bits) | 17,5 GB | 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