Calculadora de VRAM para fine-tuning (LoRA, QLoRA, completo)

Ver resultados · 11,9 GB

Configuração do treino

Método

A base congelada fica em NF4 de 4 bits com quantização dupla; só os adaptadores são treinados.

Módulos com LoRA
Pesos do adaptador

O PEFT cria os pesos do adaptador em fp32; o SFTTrainer do TRL os converte para bf16 quando o modelo base está quantizado (QLoRA). Escolha fp32 para PEFT puro.

Otimizador

Memória de GPU estimada

VRAM total
Parâmetros treináveis
41,94 mi (0,52%)
Pesos, gradientes e otimizador
6,2 GB
Ativações
0,8 GB

Menor GPU da lista em que cabe: RTX 3060 12GB (12 GB), com 1,0 GB de folga.

Sem gradient checkpointing: 21,1 GB.

Modelo: 8.030.261.248 parâmetros, 32 camadas, tamanho oculto 4.096, vocabulário 128.256.

O prepare_model_for_kbit_training do PEFT converte os embeddings e a camada de saída para fp32: some 2,1 GB se o seu script chamar essa função.

É uma estimativa, não uma medição: a memória das ativações depende do framework e dos seus kernels. Dados dos modelos e lista de GPUs conferidos em 2026-10-24.

Detalhamento da memória

Detalhamento da memória
ParteRegraMemóriaFatia
Pesos base congelados (NF4 de 4 bits)0.5 B×Ψlin0.5\,\text{B} \times \Psi_{\text{lin}}3,49 GB29,3%
Constantes de quantização0.127 bit×Ψlin0.127\,\text{bit} \times \Psi_{\text{lin}}0,11 GB0,93%
Embeddings e camada de saída (bf16)2 B×Ψemb2\,\text{B} \times \Psi_{\text{emb}}2,10 GB17,6%
Pesos dos adaptadores LoRA2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7%
Gradientes dos adaptadores2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7%
Estados do otimizador (adaptadores)8 B×ΨLoRA8\,\text{B} \times \Psi_{\text{LoRA}}0,34 GB2,8%
Ativações (com checkpointing)2sbhL+34sbh2sbhL + 34sbh0,82 GB6,9%
Logits de saída para a perda10 B×sbV10\,\text{B} \times sbV2,63 GB22%
Contexto e kernels CUDA1.3 GB1.3\,\text{GB}1,30 GB10,9%
Margem de segurança10 %10\,\%0,97 GB8,1%
VRAM total11,92 GB100%

Ψ\Psi é o número de parâmetros, Ψlin\Psi_{\text{lin}} os das camadas lineares, Ψemb\Psi_{\text{emb}} os dos embeddings e da camada de saída e ΨLoRA\Psi_{\text{LoRA}} os dos adaptadores; ss é o comprimento da sequência, bb o micro-batch, hh o tamanho oculto, LL o número de camadas, VV o vocabulário e NN o número de GPUs. B são bytes; GB é um bilhão de bytes.

Em quais GPUs cabe

  • RTX 3060 12GB 12 GB (12,9 GB)1,0 GB livres
  • RTX 4060 Ti 16GB 16 GB (17,2 GB)5,3 GB livres
  • RTX 4080 16 GB (17,2 GB)5,3 GB livres
  • Tesla P100 16GB 16 GB (17,2 GB)5,3 GB livres
  • RTX 3090 24 GB (25,8 GB)13,9 GB livres
  • RTX 4090 24 GB (25,8 GB)13,9 GB livres
  • Tesla P40 24 GB (25,8 GB)13,9 GB livres
  • MI50 32GB 32 GB (34,4 GB)22,5 GB livres
  • RTX 5090 32 GB (34,4 GB)22,5 GB livres
  • Tesla V100 32GB 32 GB (34,4 GB)22,5 GB livres
  • A100 40GB 40 GB (42,9 GB)31,0 GB livres
  • L40S 48 GB (51,5 GB)39,6 GB livres
  • RTX 4090 48GB 48 GB (51,5 GB)39,6 GB livres
  • RTX A6000 48 GB (51,5 GB)39,6 GB livres
  • A100 80GB 80 GB (85,9 GB)74,0 GB livres
  • H100 80GB 80 GB (85,9 GB)74,0 GB livres
  • H100 NVL 94 GB (100,9 GB)89,0 GB livres
  • RTX PRO 6000 96 GB (103,1 GB)91,2 GB livres
  • DGX Spark GB10 128 GB (137,4 GB)125,5 GB livres
  • H200 141 GB (151,4 GB)139,5 GB livres
  • B200 180 GB (193,3 GB)181,4 GB livres

Memória nominal segundo as fichas técnicas dos fabricantes. Os fabricantes contam em gigabytes binários, então uma placa de 24 GB guarda 25,8 bilhões de bytes (entre parênteses); a comparação usa esse número, porque o contexto CUDA já está no total. A MI50 não tem build CUDA do bitsandbytes (QLoRA, AdamW de 8 bits); a V100 e as placas Pascal (P40, P100) não têm bf16, e em fp16 a memória é a mesma.

Sobre esta ferramenta

Fazer fine-tuning de um modelo de linguagem exige muito mais memória de GPU do que rodá-lo. Além dos pesos, a GPU guarda gradientes, estados do otimizador e as ativações de cada camada até a retropropagação. Esta calculadora soma essas partes para ajuste completo, LoRA e QLoRA, com um modelo da lista ou um descrito por você, e mostra quais GPUs comuns têm espaço para o resultado.

Cada parte aparece com a regra e a fonte, porque calculadoras de fine-tuning costumam divergir pelo dobro: uma conta 18 bytes por parâmetro, outra 12, uma esquece os logits, outra pressupõe checkpointing. Aqui cada suposição é uma configuração que você vê e pode mudar.

Como a memória é estimada

O ajuste completo com precisão mista guarda, para cada parâmetro, 2 bytes de pesos em bf16, 2 bytes de gradientes, 4 bytes de cópia mestre em fp32 e 8 bytes de momento e variância do AdamW: 16 bytes, a conta do artigo do ZeRO (Rajbhandari et al., 2020). O AdamW de 8 bits guarda 2 bytes de estado em vez de 8, e o SGD com momento, 4. Os estágios 1, 2 e 3 do ZeRO dividem entre as GPUs primeiro os estados do otimizador, depois os gradientes e depois os pesos.

O LoRA congela o modelo base a 2 bytes por parâmetro e treina duas matrizes pequenas ao lado de cada peso adaptado: um peso de d×kd \times k ganha r(d+k)r(d + k) parâmetros de adaptador (Hu et al., 2021). Só eles têm gradientes e estados do otimizador: o PEFT os cria em fp32 (16 bytes cada com AdamW), e o SFTTrainer do TRL os converte para bf16 em modelos quantizados (12 bytes). O QLoRA guarda as camadas lineares congeladas em NormalFloat de 4 bits com quantização dupla, 4+8/64+32/(64⋅256)≈4,1274 + 8/64 + 32/(64 \cdot 256) \approx 4{,}127 bits por parâmetro (Dettmers et al., 2023), enquanto os embeddings e a camada de saída ficam em bf16.

As ativações dependem dos dados. Cada camada guarda cerca de 34 sbh34\,sbh bytes para comprimento de sequência ss, micro-batch bb e tamanho oculto hh (Korthikanti et al., 2022); o FlashAttention elimina o termo da matriz de atenção. O gradient checkpointing guarda só a entrada de cada camada, 2 sbh2\,sbh, e recalcula uma camada por vez. A perda acrescenta uns 10 bytes por token e entrada do vocabulário para os logits, a menos que um kernel fundido os calcule em partes. Com WW os pesos, GG os gradientes, OO os estados do otimizador e a cópia mestre, AA as ativações e Λ\Lambda os logits, mais 1,3 GB para o contexto CUDA e uma margem de 10%:

M=(W+G+O+A+Λ)×1,1+1,3 GBM = (W + G + O + A + \Lambda) \times 1{,}1 + 1{,}3\ \text{GB}

Por que as calculadoras de fine-tuning divergem e o que fica de fora

Três suposições explicam quase toda a diferença entre calculadoras, e aqui cada uma é uma configuração. Bytes por parâmetro: o guia de treino do Hugging Face conta 18 para AdamW com precisão mista (gradientes em fp32 e uma segunda cópia dos pesos), o artigo do ZeRO, 16, e os "mais de 780 GB" do artigo do QLoRA para o fine-tuning de 16 bits do LLaMA 65B correspondem a 12, sem cópia mestre; desligue os pesos mestres para reproduzir esse número. Logits: com o vocabulário do Llama 3, de 128.256 tokens, os logits de 2.048 tokens ocupam 2,6 GB, o que os kernels fundidos de entropia cruzada evitam. Checkpointing: no Llama 3.1 8B com 2.048 tokens, desligá-lo faz as ativações subirem de 0,8 para 9,1 GB.

Fica de fora: buffers de curta duração dentro de uma operação (o peso desquantizado de uma camada no QLoRA, a camada que o ZeRO-3 reúne), descarga para a CPU e otimizadores paginados, modelos mixture-of-experts, codificadores de visão e treino por preferências como o DPO, que mantém um segundo modelo de referência. Use o resultado para planejar e confira os primeiros passos do treino com torch.cuda.max_memory_allocated().

Exemplo

Conferência com o artigo do QLoRA. O LLaMA 65B tem 65,29 bilhões de parâmetros, 80 camadas e tamanho oculto de 8.192. Com QLoRA, adaptadores de rank 64 em bf16 em todas as camadas lineares, como no artigo, e sequências de 512 tokens: os pesos de 4 bits ocupam 32,38 GB, as constantes de quantização 1,03 GB e os embeddings em bf16 1,05 GB; os 799,5 milhões de parâmetros dos adaptadores ocupam 1,60 GB, seus gradientes 1,60 GB e seus estados do AdamW 6,40 GB; as ativações com checkpointing 0,81 GB e os logits 0,16 GB. São 45,0 GB de tensores, e 50,8 GB com o contexto de 1,3 GB e a margem de 10%. Uma placa de 48 GB guarda 51,5 bilhões de bytes, então cabe em uma única GPU de 48 GB, como no artigo, com 0,7 GB de folga; os otimizadores paginados do artigo dão mais folga, movendo os 6,4 GB de estados do otimizador para a memória da CPU quando falta espaço na GPU.

Conferência com o artigo do ZeRO. Para um modelo de 7,5 bilhões de parâmetros em 64 GPUs, o artigo dá 120 GB de estados do modelo por GPU sem particionamento, 31,4 GB no estágio 1, 16,6 GB no estágio 2 e 1,88 GB no estágio 3. As regras desta página dão 120; 31,41; 16,64 e 1,875 GB.

Llama 3.1 8B. LoRA de rank 16 em todas as camadas lineares (41,9 milhões de parâmetros de adaptador em bf16), 2.048 tokens, micro-batch de 1 e checkpointing: 16,06 GB de pesos congelados, 0,50 GB para os adaptadores com gradientes e estados do otimizador, 0,82 GB de ativações e 2,63 GB de logits, 23,3 GB no total. A Unsloth indica 22 GB como mínimo para LoRA de 16 bits em um modelo de 8B. A mesma execução com QLoRA precisa de 11,9 GB, ou 9,0 GB com uma perda fundida.

Perguntas frequentes

Quanta VRAM preciso para fazer fine-tuning de um modelo de 7B ou 8B?

Com QLoRA, cerca de 9 a 12 GB com 2.048 tokens e micro-batch de 1: 11,9 GB com as configurações padrão e 9,0 GB com uma perda fundida. Uma placa de 12 GB (12,9 bilhões de bytes) comporta no limite; 16 GB deixam folga para sequências mais longas. O LoRA de 16 bits precisa de cerca de 23 GB, ou seja, uma placa de 24 GB. O ajuste completo com AdamW precisa de cerca de 146 GB, ou seja, várias GPUs com ZeRO ou FSDP. Sequências mais longas e lotes maiores acrescentam memória de ativações; a calculadora mostra quanto.

Qual a diferença de memória entre LoRA e QLoRA?

Os dois treinam os mesmos adaptadores pequenos; a diferença está no modelo base congelado. O LoRA o mantém em bf16, a 2 bytes por parâmetro, e o QLoRA em NF4 de 4 bits, a cerca de 0,52 byte. No Llama 3.1 8B são 16,1 GB contra 5,7 GB, embeddings em bf16 incluídos. O QLoRA treina um pouco mais devagar porque cada camada é desquantizada na hora.

Por que o ajuste completo precisa de 16 bytes por parâmetro?

O treino com precisão mista calcula em bf16 (2 bytes de pesos e 2 de gradientes por parâmetro), mas atualiza uma cópia mestre em fp32 (4 bytes), e o AdamW guarda duas estatísticas em fp32 por parâmetro, o momento e a variância (8 bytes). Por isso um modelo de 8B precisa de cerca de 128 GB antes das ativações. O AdamW de 8 bits leva isso a 10 bytes por parâmetro, e o ZeRO ou o FSDP dividem o total entre as GPUs.

O gradient checkpointing reduz a memória?

Sim, reduz a memória das ativações. No Llama 3.1 8B com 2.048 tokens, as ativações caem de 9,1 para 0,8 GB, porque só a entrada de cada camada é guardada e o resto é recalculado na retropropagação. O custo é uma passada para a frente a mais: Korthikanti et al. mediram até 30 a 40% a mais de tempo de treino.

Como dividir o fine-tuning entre várias GPUs?

Com DeepSpeed ZeRO ou PyTorch FSDP. O estágio 1 divide os estados do otimizador, o estágio 2 também os gradientes e o estágio 3 (particionamento completo do FSDP) também os pesos. O ajuste completo do Llama 3.1 8B em oito GPUs no estágio 3 precisa de cerca de 22,8 GB por GPU. As ativações não são divididas: cada GPU processa o próprio micro-batch. Informe o número de GPUs para ver a memória que cada uma precisa.

Fontes

Link com os seus valores

Adicione estes parâmetros ao endereço desta página para abri-la com os valores já preenchidos, por exemplo para compartilhar um cálculo ou criar um link a partir de um assistente de IA. O resultado é calculado no navegador: o HTML da página mostra um exemplo com os valores padrão, e a ferramenta define o atributo data-url-params quando os valores do link são aplicados.

ParâmetroValorSe omitido
methodMétodoum destes: full, lora, qlorapadrão: qlora
architectureModelo personalizadoum destes: preset, custompadrão: preset
modelModeloum destes: llama3.2-1b, llama3.2-3b, qwen3-4b, mistral-7b-v0.3, qwen2.5-7b, llama3.1-8b, qwen3-8b, phi-4, qwen3-14b, qwen3-32b, llama3.3-70b, llama-2-7b, llama-7b, llama-65b; usado com architecture = presetpadrão: llama3.1-8b
parameters_billionsParâmetrosnúmero; permitido 0.01–2000; usado com architecture = customobrigatório
layersCamadasnúmero inteiro; permitido 1–512; usado com architecture = customobrigatório
hidden_sizeTamanho oculto (hidden size)número inteiro; permitido 64–65536; usado com architecture = customobrigatório
vocabulary_sizeTamanho do vocabulárionúmero inteiro; permitido 1–2000000; usado com architecture = customobrigatório
tied_embeddingsEmbeddings compartilhados (tie_word_embeddings)true ou false; usado com architecture = custompadrão: false
optimizerOtimizadorum destes: adamw, adamw_8bit, sgdpadrão: adamw
master_weightsManter uma cópia mestre dos pesos em fp32true ou false; usado com method = fullpadrão: true
lora_rankRank do LoRA (r)número inteiro; permitido 1–1024; usado com method = lora, qlorapadrão: 16
lora_targetsMódulos com LoRAum destes: qv, attention, all; usado com method = lora, qlorapadrão: all
adapter_precisionPesos do adaptadorum destes: fp32, bf16; usado com method = lora, qlorapadrão: bf16
sequence_lengthComprimento da sequência (tokens)número inteiro; permitido 1–1048576padrão: 2048
batch_sizeMicro-batch por GPUnúmero inteiro; permitido 1–1024padrão: 1
gradient_checkpointingGradient checkpointingtrue ou falsepadrão: true
fused_lossKernel fundido de entropia cruzada (Liger, Unsloth)true ou falsepadrão: false
gpu_countNúmero de GPUsnúmero inteiro; permitido 1–1024padrão: 1
zero_stageParticionamento (estágio do ZeRO)um destes: 0, 1, 2, 3padrão: 0

Exemplos

  • ?method=qlora&model=llama-65b&lora_rank=64&adapter_precision=bf16&sequence_length=512
  • ?method=lora&model=llama3.1-8b&lora_rank=16&lora_targets=all&sequence_length=2048&batch_size=1
  • ?method=full&model=llama3.1-8b&gpu_count=8&zero_stage=3
  • ?method=qlora&architecture=custom&parameters_billions=12&layers=48&hidden_size=3840&vocabulary_size=262144&tied_embeddings=true

Escreva decimais com ponto. Codifique um espaço como %20, + como %2B, # como %23 e & como %26.

Elementos do resultado: [data-result-block="fine-tuning-vram"]