Qual LLM para 32 GB de VRAM ?

#32 GB de VRAM: o que a capacidade muda em relação a 24 GB

Um modelo em Q4 ocupa cerca de 0,6 GB por bilhão de parâmetros, além do cache de contexto, que cresce com a duração da conversa. Com 24 GB, um modelo denso de 27 a 32B em Q4 (16 a 20 GB) cabe, mas o contexto deve permanecer curto. Com 32 GB, restam 12 a 16 GB para o contexto, as ativações e o sistema: é essa memória disponível que permite janelas de 32.000 a 128.000 tokens em um modelo de 27B, ou um MoE de 30-35B com margem confortável.

Esses valores são tamanhos de arquivos, não requisitos totais: a calculadora do site acrescenta o cache para um modelo e um contexto específicos. O cache também pode ser quantizado em q8_0, o que, segundo a FAQ do Ollama, reduz seu tamanho aproximadamente à metade em relação a f16, desde que o Flash Attention esteja ativado.

• Calculadora de memória para um modelo e seu contexto
• Quantizar o cache KV para economizar memória

#Quais placas oferecem 32 GB e por que a largura de banda importa

Duas placas para computadores de mesa se destacam. A GeForce RTX 5090 tem 32 GB de GDDR7 em um barramento de 512 bits, com 1.792 GB/s de largura de banda segundo a NVIDIA. A Radeon AI PRO R9700 da AMD também oferece 32 GB, mas em GDDR6 em um barramento de 256 bits, a 640 GB/s segundo a AMD, para um computador de mesa e uso profissional. A capacidade é idêntica; a velocidade de geração não é.

O limite é calculado dividindo a largura de banda pelos pesos lidos a cada token; ele nunca é atingido completamente, mas a relação permanece válida: para o mesmo modelo, a RTX 5090 gera tokens a uma velocidade mais de duas vezes maior que a da R9700. Para uma placa AMD, o driver e a pilha de software (ROCm, Vulkan) também contam; o guia dedicado às placas AMD detalha as limitações. Cada placa específica tem sua própria página: a da RTX 5090 fornece os detalhes da placa.

Duas outras opções atingem 32 GB. Duas placas de 16 GB dividem um modelo entre si com llama.cpp, mas a conexão PCIe torna as trocas mais lentas e o modelo precisa poder ser dividido adequadamente; o guia multi-GPU explica o método. Um Mac com memória unificada de 32 GB ou mais é uma terceira opção, com largura de banda menor, mas sem limite de VRAM dedicada.

Os preços mudam rápido: o monitoramento do site registra toda segunda-feira e toda quinta-feira o menor preço das placas gráficas para IA local, junto com o preço por GB de VRAM.

• Acompanhamento dos preços das placas de vídeo para IA local
• LLM em RTX 5090
• Configuração multi-GPU com llama.cpp

#Modelos a priorizar com 32 GB

Modelos densos de 27 a 32B

A escolha de qualidade: Qwen 3.5 27B ou 3.8 27B (16 GB em Q4), Gemma 4 31B (18 GB), Qwen 3 32B (19 a 20 GB). Eles deixam espaço para um contexto longo e se adaptam bem a quantificações mais finas (Q5, Q6) se você quiser mais qualidade.

MoE 30–35B

Qwen3-Coder 30B-A3B (19 GB) e Qwen 3.6 35B-A3B (21 GB) ativam apenas cerca de 3 bilhões de parâmetros por token: oferecem a melhor velocidade em relação ao tamanho e são a escolha certa para programação e agentes.

gpt-oss-20b

14 GB na biblioteca Ollama; a página Ollama indica que ele pode rodar em sistemas com pelo menos 16 GB de memória. Em 32 GB, deixa um contexto imenso e permite manter um segundo modelo carregado ao mesmo tempo.

Modelo de código de 24B

Devstral Small 2 24B (14 GB): um especialista em agentes de código que deixa espaço para dois modelos residentes na memória.

Para escolher, faça três perguntas. O modelo precisa lidar com um contexto longo (documentos, repositório de código)? Escolha um modelo denso de 27B em Q4, que deixa 16 GB para o cache. Precisa de velocidade (agentes, loops de ferramentas)? Use o MoE. Quer simplesmente mais qualidade do que com 24 GB? Passe de Q4 para Q6 em um modelo de 27 a 32B: há espaço.

• Modelos MoE explicados
• Escolher sua quantização

#Verificar se o modelo realmente cabe na placa

Um modelo que “carrega” não está necessariamente inteiramente na GPU. O Ollama distribui silenciosamente as camadas entre a placa e a memória RAM quando falta VRAM, e a velocidade cai sem mensagem de erro. A FAQ oficial indica que o comando ollama ps mostra na coluna Processor onde o modelo foi carregado: 100 % GPU significa que ele está inteiramente na GPU; uma distribuição como 30 %/70 % CPU/GPU indica que parte do modelo foi transferida para a RAM.

1. 01
   Carregar o modelo com o contexto pretendido

   Inicie o modelo com o tamanho de contexto que você realmente usa, não com o valor padrão: é o cache de contexto que faz o uso de memória ultrapassar a capacidade disponível.
2. 02
   Ler a coluna Processor

   Execute ollama ps em outro terminal. Busque 100% de GPU; qualquer parcela de processamento na CPU reduz a velocidade.
3. 03
   Reduza se necessário

   Se o modelo ultrapassar o limite, reduza o contexto, ative a quantização do cache em q8_0 com Flash Attention ou passe para uma quantização mais leve.
4. 04
   Verificar a VRAM restante

   No Windows ou Linux, o nvidia-smi exibe a memória usada; mantenha uma margem de um a dois GB para a exibição e os picos.
5. 05
   Medir com base no seu uso

   Compare a taxa de transferência usando um prompt curto e o seu prompt real: é o segundo número que importa.

• Ollama em placas AMD com ROCm
• Solucionar erros de GPU de Ollama

#70B e 123B: por que o offload não torna esses modelos utilizáveis

Llama 3.3 70B pesa 43 GB na biblioteca Ollama, e Mistral Large 123B, 73 GB. Com 32 GB de VRAM, é necessário deixar pelo menos 11 GB do 70B e 41 GB do 123B na memória RAM. A cada token, essas camadas são lidas pelo processador à velocidade da memória do sistema: cerca de 102 GB/s no máximo para DDR5-6400 em dois canais (6.400 MT/s × 8 bytes × 2). Dividindo essa taxa por 41 GB, o limite teórico do 123B é de cerca de 2,5 tokens por segundo; para o 70B, com 11 GB na RAM, de cerca de 9 tokens por segundo. São limites teóricos, não medições: eles mostram principalmente que a taxa de geração não diminui de forma progressiva, mas em degraus, assim que as camadas deixam a placa.

Esse cálculo supõe que a placa mantenha 32 GB de pesos do modelo; na prática, o cache de contexto também ocupa espaço, então uma parcela maior dos pesos vai para a RAM e o limite diminui. Os MoE se comportam melhor: o llama.cpp oferece uma opção para manter os especialistas de determinadas camadas no processador (--n-cpu-moe), para configurações que não conseguem carregar o modelo inteiro na GPU. Essa opção permite executar um modelo que não cabe na GPU, mas um usuário do repositório llama.cpp relata uma perda de velocidade de cerca de 80% ao colocar todos os especialistas na CPU: é uma solução de último recurso.

llama-server -m modele-moe.gguf -ngl 99 -fa --n-cpu-moe 12 -c 16384

O valor de --n-cpu-moe depende da sua memória; é preciso encontrá-lo por tentativa e erro. Para um 70B denso, a resposta certa com 32 GB quase sempre é um modelo menor ou mais memória, não fazer offload.

#Fazer o ajuste fino de um modelo com 32 GB: o que cabe e o que não cabe

O ajuste fino com QLoRA mantém os pesos do modelo em 4 bits e treina apenas pequenos adaptadores. Só os pesos de um modelo de 70B já ocupam 40 GB, então um ajuste fino com QLoRA em um modelo de 70B não cabe em 32 GB. Um modelo de 32B em 4 bits ocupa cerca de 19 a 20 GB: restam 12 GB para as ativações, o otimizador e os adaptadores, o que é viável com um contexto curto e um lote de 1, sem margem de segurança. Um modelo de 7 a 14B roda com folga. São ordens de grandeza a confirmar na ferramenta que você usa.

#32 GB de VRAM ou outra solução: a tabela de decisão

• Qual LLM para 24 GB de VRAM
• Mac Studio com 64 a 512 GB
• Fonte: NVIDIA, anúncio das RTX 50
• Fonte: AMD, Radeon AI PRO R9700
• Fonte: biblioteca Ollama, Mistral Large

#Perguntas frequentes