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 ganha 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, 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 bytes para comprimento de sequência , micro-batch e tamanho oculto (Korthikanti et al., 2022); o FlashAttention elimina o termo da matriz de atenção. O gradient checkpointing guarda só a entrada de cada camada, , 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 os pesos, os gradientes, os estados do otimizador e a cópia mestre, as ativações e os logits, mais 1,3 GB para o contexto CUDA e uma margem de 10%:
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
- Rajbhandari et al. (2020), ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
- Hu et al. (2021), LoRA: Low-Rank Adaptation of Large Language Models
- Dettmers et al. (2023), QLoRA: Efficient Finetuning of Quantized LLMs
- Korthikanti et al. (2022), Reducing Activation Recomputation in Large Transformer Models
- Hugging Face Transformers: GPU memory usage in training
- Hugging Face PEFT: LoRA developer guide
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âmetro | Valor | Se omitido |
|---|---|---|
methodMétodo | um destes: full, lora, qlora | padrão: qlora |
architectureModelo personalizado | um destes: preset, custom | padrão: preset |
modelModelo | um 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 = preset | padrão: llama3.1-8b |
parameters_billionsParâmetros | número; permitido 0.01–2000; usado com architecture = custom | obrigatório |
layersCamadas | número inteiro; permitido 1–512; usado com architecture = custom | obrigatório |
hidden_sizeTamanho oculto (hidden size) | número inteiro; permitido 64–65536; usado com architecture = custom | obrigatório |
vocabulary_sizeTamanho do vocabulário | número inteiro; permitido 1–2000000; usado com architecture = custom | obrigatório |
tied_embeddingsEmbeddings compartilhados (tie_word_embeddings) | true ou false; usado com architecture = custom | padrão: false |
optimizerOtimizador | um destes: adamw, adamw_8bit, sgd | padrão: adamw |
master_weightsManter uma cópia mestre dos pesos em fp32 | true ou false; usado com method = full | padrão: true |
lora_rankRank do LoRA (r) | número inteiro; permitido 1–1024; usado com method = lora, qlora | padrão: 16 |
lora_targetsMódulos com LoRA | um destes: qv, attention, all; usado com method = lora, qlora | padrão: all |
adapter_precisionPesos do adaptador | um destes: fp32, bf16; usado com method = lora, qlora | padrão: bf16 |
sequence_lengthComprimento da sequência (tokens) | número inteiro; permitido 1–1048576 | padrão: 2048 |
batch_sizeMicro-batch por GPU | número inteiro; permitido 1–1024 | padrão: 1 |
gradient_checkpointingGradient checkpointing | true ou false | padrão: true |
fused_lossKernel fundido de entropia cruzada (Liger, Unsloth) | true ou false | padrão: false |
gpu_countNúmero de GPUs | número inteiro; permitido 1–1024 | padrão: 1 |
zero_stageParticionamento (estágio do ZeRO) | um destes: 0, 1, 2, 3 | padrã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¶meters_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"]