É possível fazer fine-tuning em uma GPU comum?

Sim, com o modelo base quantizado. QLoRA carrega os pesos em 4 bits e treina apenas um adaptador de posto baixo em precisão maior, o que derruba a memória a ponto de o ajuste caber em placa de consumo. Os autores treinaram um modelo de 65B numa única GPU de 48 GB preservando o desempenho do ajuste em 16 bits¹.

O método é o LoRA com uma mudança no que está embaixo: em vez de congelar os pesos base na precisão original, ele os congela em 4 bits. Como eles já estavam congelados, guardá-los com menos precisão não interfere no que o treino move.

O que muda é a fronteira do que você consegue treinar sem alugar um nó de oito placas. Antes de chegar aqui, vale conferir se algum outro método da família resolve o seu caso com menos peça móvel, porque quantização acrescenta uma superfície de erro que não existia.

De onde a memória some

A memória de um treino tem três parcelas, e elas somem em ordens diferentes.

A primeira é o estado do otimizador. Num treino de precisão mista com Adam, cada parâmetro treinável carrega gradiente e dois momentos, algo em torno de 16 bytes por parâmetro. Para 7 bilhões, ultrapassa 100 GB. É a parcela que o adaptador de posto baixo elimina quase inteira, porque só alguns milhões de parâmetros recebem gradiente.

A segunda é o modelo em si, e o LoRA não toca nela. Um modelo de 7B em bf16 ocupa 14 GB antes de qualquer treino. Depois que o otimizador saiu da conta, essa vira a parcela dominante, e é exatamente onde a quantização entra.

A terceira são as ativações do lote, que crescem com o tamanho do lote e o comprimento da sequência. Nenhum dos dois métodos ataca essa parcela, e ela é a que mais surpreende quem calculou só as duas primeiras e mesmo assim estourou a placa.

Onde a quantização entra

O ponto que mais confunde: os 4 bits são formato de armazenamento, não de cálculo. Os pesos ficam guardados em NF4 na memória da placa, mas cada bloco volta para bf16 no instante em que participa de uma multiplicação, e a conta acontece em precisão cheia.

O gradiente atravessa esses pesos desquantizados para chegar ao adaptador, mas não atualiza nenhum deles. Só A e B mudam, e eles nunca foram quantizados.

O paper introduz três peças¹:

• NF4, um tipo de dado de 4 bits desenhado para pesos com distribuição próxima da normal. Os autores o descrevem como ótimo do ponto de vista da informação para essa distribuição, o que é diferente de espaçar os níveis uniformemente como faria um inteiro de 4 bits.
• Quantização dupla, que quantiza as próprias constantes de quantização. Cada bloco de pesos guarda uma constante de escala, e em bloco pequeno essas constantes viram uma fração não desprezível do total.
• Otimizadores paginados, que usam memória unificada para absorver os picos de memória que derrubariam o treino em sequências longas.

A escolha do 4 bits não é arbitrária. Um trabalho anterior dos mesmos autores investigou a troca entre número de bits e tamanho do modelo na inferência e argumentou que 4 bits fica no ponto certo dessa curva para a maioria dos casos².

Quanta VRAM cada tamanho pede

A tabela abaixo é aritmética, não medição: multiplica parâmetros por bytes e soma uma folga para adaptador e otimizador. As ativações ficam de fora porque dependem do seu lote e do comprimento de sequência, e é comum elas somarem vários gigabytes.

modelo	pesos em bf16	pesos em NF4	ordem prática com QLoRA
7B	~14 GB	~4 GB	cabe em 12 a 16 GB
13B	~26 GB	~7 GB	cabe em 16 a 24 GB
34B	~68 GB	~17 GB	pede 24 a 40 GB
70B	~140 GB	~35 GB	pede 48 GB ou mais

O ponto de referência publicado é o de 65B numa placa de 48 GB¹. A linha de 70B acima é consistente com ele e não é a mesma medição, então trate como estimativa.

Compare com o ajuste completo para ver a distância: o mesmo modelo de 7B pediria os 14 GB dos pesos mais algo acima de 100 GB de gradiente e estado de otimizador, o que não cabe em placa nenhuma de consumo, com ou sem quantização.

QLoRA ou LoRA

A escolha é de restrição de hardware, não de qualidade, e o critério é direto: use LoRA se o modelo base cabe na sua placa em bf16, e QLoRA quando não cabe.

Quantizar tem custo. O treino fica mais lento porque cada bloco precisa ser desquantizado a cada passo, e você acrescenta uma aproximação entre o modelo que avaliou e o modelo que treinou. Nenhum dos dois compensa se você tinha memória sobrando.

A conta de “cabe” é simples de fazer errado, porque quase todo mundo esquece as ativações. Um 7B em bf16 são 14 GB de pesos numa placa de 24 GB, o que parece folgado até o lote e a sequência somarem seus próprios gigabytes. Se a margem ficou abaixo de uns 30%, quantizar sai mais barato que descobrir o estouro no meio da terceira época.

Há um caso intermediário que costuma passar batido: carregar o base em 8 bits. Perde menos precisão que 4 bits, corta metade da memória de pesos, e resolve vários casos em que o 4 bits seria exagero³.

Como rodar a primeira vez

1. Carregue o modelo em 4 bits com NF4 e computação em bf16. Nas bibliotecas atuais isso é configuração de carregamento, não mudança no laço de treino.
2. Ligue a quantização dupla. O ganho é pequeno em proporção e vem de graça; não há razão para deixar desligada.
3. Comece com posto 16 e escala 32, aplicando o adaptador às projeções de atenção. É o mesmo ponto de partida de um LoRA comum.
4. Meça o baseline antes de treinar, com o modelo base quantizado e o melhor prompt que você tem. Sem isso você não separa o efeito do treino do efeito da quantização.
5. Reduza o comprimento de sequência antes de reduzir o lote quando estourar a memória. As ativações crescem mais rápido com sequência do que com lote em boa parte das configurações.
6. Some o adaptador na versão em precisão cheia, não na quantizada, quando for servir. Somar sobre os pesos de 4 bits introduz erro que não existia durante o treino.

O passo 6 é o que mais gera bug silencioso. O modelo continua respondendo, só que pior do que respondia na avaliação, e a causa não se parece com um erro de código.

O que fazer depois que o treino termina

O treino em 4 bits acaba e sobra uma decisão que quase ninguém planeja: em que precisão o modelo vai servir.

São três caminhos, e eles não são equivalentes. O primeiro é somar o adaptador aos pesos em precisão cheia e servir o modelo resultante em bf16. Você recupera a qualidade máxima e volta a precisar dos 14 GB, o que faz sentido quando treino e inferência acontecem em máquinas diferentes.

O segundo é servir o base quantizado com o adaptador aplicado por cima, sem fundir. É o que mais se parece com a condição de treino, e é o único caminho que permite trocar de adaptador por requisição. Custa uma operação a mais por camada.

O terceiro é quantizar de novo depois de fundir, gerando um modelo de 4 bits já com o comportamento embutido. É o mais econômico para servir e o mais arriscado, porque a segunda quantização acontece sobre pesos que o treino não viu nessa forma. Avalie antes de assumir que ficou igual.

O erro que aparece com mais frequência é fundir o adaptador diretamente nos pesos de 4 bits. A operação não falha e o modelo continua respondendo, então nada acusa o problema até alguém comparar com a avaliação e notar a diferença.

Quando a memória estourar

Alguns sintomas têm causa previsível, e reconhecê-los economiza horas.

Estoura no primeiro passo. O problema é o modelo, não o treino. Confira se a quantização foi aplicada de fato — carregar em 4 bits sem passar a configuração certa carrega em 16 bits silenciosamente em algumas versões de biblioteca.

Estoura depois de alguns passos. São as ativações, e a variável é o comprimento da sequência mais longa do lote. Ordenar os exemplos por tamanho ou truncar o topo da distribuição resolve mais rápido do que reduzir o lote.

Estoura só na avaliação. A avaliação costuma rodar sem gradiente mas com lote maior, e a geração acumula cache de chave-valor. Reduza o lote de avaliação em separado, sem mexer no de treino.

Estoura de forma intermitente. É o caso que os otimizadores paginados resolvem, e vale confirmar que estão ligados antes de mexer em qualquer outra coisa.

Onde falha

A avaliação do paper é fraca no ponto mais citado. O número que circula é o Guanaco atingindo 99,3% do desempenho do ChatGPT no benchmark Vicuna¹. Esse benchmark usa um modelo como juiz e tem poucos prompts, o que o torna ruim para sustentar uma afirmação de paridade. Os próprios autores discutem limitações de avaliação no texto.

Quantização e ensino de capacidade nova se somam mal. O adaptador já aprende menos que o ajuste completo quando a tarefa exige mudança grande⁴, e quantizar o base acrescenta uma aproximação por cima disso. Para estilo e formato, o efeito é pequeno; para ensinar um domínio novo, meça antes de assumir.

O treino fica mais lento. Desquantizar bloco a bloco a cada passo tem custo, e ele aparece em tempo de época. Você trocou tempo por memória, o que só compensa quando a alternativa é não treinar.

Nem toda quantização é NF4. Carregar em 4 bits com um esquema genérico não é QLoRA, e o resultado pode ser bem pior. O formato foi escolhido pela distribuição dos pesos, e isso é a parte que sustenta a alegação de preservar qualidade.

A placa precisa suportar bf16 de forma decente. Em hardware mais antigo, a desquantização para bf16 pode ser lenta o suficiente para o ganho de memória não compensar.

O que custa

O custo de GPU deixa de ser o item dominante, e isso muda a conta do projeto inteiro. Uma placa de 24 GB alugada por hora resolve um ajuste de 7B ou 13B, e o paper reporta a melhor família deles saindo de 24 horas numa placa só¹.

O que não muda é o resto. Curadoria do conjunto, definição da avaliação e manutenção do modelo ao longo do tempo continuam custando o mesmo, e continuam sendo a maior parte do trabalho. Baratear o treino aumenta a proporção do esforço que vai para os dados, em vez de reduzir o esforço total.

Footnotes

1. Dettmers et al. (2023) ajustaram um modelo de 65B numa GPU de 48 GB com NF4, quantização dupla e otimizadores paginados, relatando preservação do desempenho do ajuste em 16 bits. ↩ ↩² ↩³ ↩⁴ ↩⁵

2. Dettmers e Zettlemoyer (2022) estudaram a troca entre número de bits e tamanho do modelo e argumentaram a favor de 4 bits na maioria dos casos. ↩

3. Dettmers et al. (2022) mostraram inferência em 8 bits sem degradação em transformers grandes, tratando separadamente as dimensões de ativação atípicas. ↩

4. Biderman et al. (2024) encontraram o adaptador abaixo do ajuste completo em programação e matemática nos postos usuais. ↩