Prática guia · 10 min de leitura

# Fazendo fine-tuning de um modelo de 70B em uma placa.

O QLoRA transforma um job de treinamento que precisa de um rack em um que precisa de apenas uma GPU de 48 GB. Aqui está o que cabe, quanto custa por mês, e onde a técnica para de funcionar.

A resposta curta

- **QLoRA em 70B:** ~61 GB — cabe em uma placa de 48 GB com comprimentos de sequência curtos, e folgadamente em uma de 80 GB
- **Fine-tuning completo de 70B:** ~1,232 GB — um cluster multi-nó, que não alugamos
- **A proporção:** Aproximadamente **20×** menos memória, para uma técnica que alcança a maior parte da qualidade na maioria das tarefas
- **Quanto custa aqui:** A partir de $286/mês, com a placa sua pelo mês inteiro, não só pela execução

## O que realmente cabe

O LoRA congela o modelo e treina um pequeno par de matrizes de rank baixo ao lado de cada matriz de pesos. O QLoRA vai além e mantém os pesos congelados em 4 bits. O que você precisa manter em memória muda completamente como resultado.

Pesos congelados 4 bits por parâmetro 35 GB para um modelo de 70B. Lidos em cada passo, nunca atualizados, então nunca precisam de gradiente.

Adaptadores Cerca de 1–2% dos parâmetros Um ou dois gigabytes em BF16. Esses são os únicos pesos que mudam, e a única coisa que você guarda no final.

Estado do otimizador Adam, só nos adaptadores Dois momentos por parâmetro treinado. Este é o termo que domina o fine-tuning completo e quase desaparece aqui.

Ativações A parte variável Escala com o batch size e o comprimento da sequência. O gradient checkpointing troca cerca de 30% mais computação por uma redução grande — a alavanca de sempre quando uma execução não cabe.

## Por que o fine-tuning completo não

O fine-tuning completo em BF16 precisa de cerca de 16 bytes por parâmetro: 2 para o peso, 2 para o gradiente, e 8 para os dois momentos do Adam em FP32, mais a cópia mestra. É um multiplicador fixo, e é brutal.

**Memória de treinamento: QLoRA comparado com fine-tuning completo**

| Modelo | QLoRA | Fine-tuning completo | Proporção | O que isso significa |
|---|---|---|---|---|
| Llama 3.1 8B 8B de parâmetros | 13 GB | 141 GB | 11× | Uma placa de 24 GB Completo: um nó de 8 GPUs |
| Gemma 3 27B 27B de parâmetros | 27 GB | 475 GB | 17× | Uma placa de 48 GB Completo: um nó de 8 GPUs |
| Qwen 3 32B 32B de parâmetros | 31 GB | 563 GB | 18× | Uma placa de 48 GB Completo: um nó de 8 GPUs |
| Llama 3.3 70B 70B de parâmetros | 61 GB | 1,232 GB | 20× | Uma placa de 80 GB Completo: mais de um nó |

Estes são valores de ordem de grandeza, com uma folga modesta para ativações — suficientes para escolher uma máquina, não para prometer uma execução específica. O comprimento de sequência e o tamanho do lote alteram consideravelmente a coluna QLoRA; a coluna de fine-tuning completo quase não se move, porque é dominada pelos 16 bytes fixos por parâmetro.

## Modelo por modelo

O nó mais barato do nosso catálogo que consegue treinar cada modelo com QLoRA, ao lado da máquina que você precisaria para servir o resultado.

**Nó mais barato para treinar com QLoRA, e para servir o resultado**

| Modelo | Memória de treinamento | Nó mais barato para treinar | Nó mais barato para servir |
|---|---|---|---|
| Llama 3.1 8B | 13 GB | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) 24 GB por placa · $125/mês | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês |
| Mistral Small 24B | 25 GB | [NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) 48 GB por placa · $286/mês | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês |
| Gemma 3 27B | 27 GB | [NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) 48 GB por placa · $286/mês | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês |
| Qwen 3 32B | 31 GB | [NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) 48 GB por placa · $286/mês | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês |
| Llama 3.3 70B | 61 GB | [NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-80gb) 80 GB por placa · $1,091/mês | [2 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $285/mês |

O treinamento quer memória; o serving quer memória *e* largura de banda. É comum que a placa certa para treinamento seja uma placa barata e com muita memória, e que a placa certa para serving seja uma placa cara e rápida — e, como aqui as duas são mensais, rodar as duas em máquinas diferentes costuma sair mais barato do que abrir mão de uma delas.

## Executando

O Axolotl vem pré-instalado como uma das imagens no configurador. Esta é uma execução completa em uma única placa, a partir de uma máquina vazia.

Uma execução de QLoRA em uma placa

```
$ mkdir -p /scratch/ft && cd /scratch/ft
$ cat > qlora.yml <<'YAML'
base_model: meta-llama/Llama-3.3-70B-Instruct
load_in_4bit: true
adapter: qlora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
lora_target_linear: true

sequence_len: 2048
sample_packing: true
gradient_checkpointing: true
micro_batch_size: 1
gradient_accumulation_steps: 16
num_epochs: 2
learning_rate: 0.0001
optimizer: paged_adamw_8bit
bf16: true

datasets:
  - path: /scratch/ft/data.jsonl
    type: chat_template
output_dir: /scratch/ft/out
YAML

$ docker run --rm --gpus all --ipc=host --shm-size=16g \
    -v /scratch/ft:/workspace -v /scratch/models:/root/.cache/huggingface \
    -e HF_TOKEN="$HF_TOKEN" \
    axolotlai/axolotl:main-latest \
    axolotl train /workspace/qlora.yml
```

Observe a memória, não a loss, nos primeiros dois minutos

```
$ nvidia-smi dmon -s um

# If memory sits just under the card's total, you are one long batch
# away from an out-of-memory error four hours into the run.
# Lower sequence_len or micro_batch_size now, not then.
```

## As configurações que importam

lora_r 16 to 64 O rank, o principal controle entre qualidade e memória. 16 é um padrão sensato; ir acima de 64 raramente vale a pena, a menos que você esteja ensinando conhecimento genuinamente novo, e não um formato ou um estilo.

lora_target_linear true Adapta cada camada linear em vez de só a atenção. Custa pouco e supera de forma consistente o padrão de atenção apenas.

sequence_len A maior alavanca de memória As ativações escalam com isso. Reduzir pela metade reduz aproximadamente pela metade a parte variável da sua memória. Defina o valor para o comprimento que os seus dados realmente têm, não para o máximo do modelo.

gradient_checkpointing true, quase sempre Cerca de 30% mais lento, e é isso que torna possível treinar um modelo de 70B em uma única placa. Desative apenas quando sobrar memória.

micro_batch_size & acumulação Trocar um pelo outro O batch efetivo é o produto dos dois. Mantenha o micro-batch em 1 e aumente o accumulation quando a memória estiver apertada — mesmo gradiente, menos pico de memória, um pouco mais lento.

otimizador paged_adamw_8bit Estados do otimizador em oito bits, com paginação para CPU como válvula de segurança. Isso absorve os picos que, de outra forma, encerrariam a execução na quarta hora.

## Quanto custa um mês

O motivo pelo qual o mensal importa mais para treinamento do que para serving: um projeto de fine-tuning não é uma única execução. É uma primeira execução que falha por um bug nos dados, uma segunda que sofre overfitting, uma terceira que funciona, e depois mais cinco com ranks diferentes.

**Custo de um projeto de fine-tuning, por máquina**

| Máquina | Memória da placa | Por mês | Indicado para |
|---|---|---|---|
| [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) 300 GB/s | 24 GB | $125/mês | QLoRA até 8B |
| [NVIDIA RTX 5090](https://gpuserver.io/pt/gpu/rtx-5090) 1,792 GB/s | 32 GB | $335/mês | QLoRA até 32B |
| [NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-40gb) 1,555 GB/s | 40 GB | $392/mês | QLoRA até 32B |
| [NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) 768 GB/s | 48 GB | $286/mês | QLoRA até 32B |
| [NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-80gb) 1,935 GB/s | 80 GB | $1,091/mês | QLoRA até 70B |

Compare isso com a cobrança por hora ao longo de um projeto, e não de uma única execução: o [guia de ponto de equilíbrio](https://gpuserver.io/pt/guides/monthly-vs-hourly) faz as contas. Uma máquina que existe por três semanas enquanto você itera é exatamente o caso em que a cobrança por hora custa mais do que um prazo.

## Onde o LoRA para de funcionar

É uma técnica muito boa com um limite real, e vale a pena saber de que lado dele você está antes de alugar qualquer coisa.

**Ensinar um domínio genuinamente novo.** O LoRA adapta bem o comportamento e adiciona mal o conhecimento. Um modelo que nunca viu a sua área não vai aprendê-la a partir de um adaptador de rank baixo.

**Mudar o vocabulário ou o tokenizer.** Tokens novos precisam de embeddings treinados, o que fica fora do que um adaptador altera.

**Pré-treinamento contínuo em bilhões de tokens.** Isso é fine-tuning completo, e precisa da máquina na coluna da direita da tabela acima — que é mais de um nó, e mais do que alugamos.

**Espremer os últimos dois pontos de um benchmark.** O fine-tuning completo ainda vence na margem. Se é essa margem que você está sendo pago para entregar, o LoRA é a ferramenta errada.

Para tudo o mais — um tom, um formato, um esquema, um domínio que o modelo base já conhece parcialmente — o QLoRA em uma única placa alcança a maior parte da qualidade por uma fração da máquina. Essa é a troca, e, nos modelos que a maioria das pessoas realmente ajusta, é uma boa troca.

## Escolha a placa, fique com ela pelo projeto inteiro.

Toda configuração é mensal, com acesso root e sem cobrança por hora — que é exatamente o que iterar em um fine-tune precisa.

[Explorar o catálogo](https://gpuserver.io/pt/#catalog) [Ler os guias](https://gpuserver.io/pt/guides)

## Outros guias

- [Pagamento · 8 min Pagando um servidor em cripto O que realmente acontece entre clicar em pagar e receber o root, qual moeda escolher, e os quatro erros que fazem perder dinheiro no primeiro pagamento. Ler o guia](https://gpuserver.io/pt/guides/pay-in-crypto)
- [Dimensionamento · 9 min Quanta VRAM um modelo realmente precisa A aritmética por trás de “será que cabe”: pesos, cache KV, e os dois pontos em que uma regra prática erra por um fator de três. Ler o guia](https://gpuserver.io/pt/guides/vram-sizing)
- [Dimensionamento · 7 min NVLink ou PCIe: de qual seu trabalho precisa Quando o link entre placas decide seu throughput, quando não muda nada, e como saber em qual caso você está antes de pagar pelo nó errado. Ler o guia](https://gpuserver.io/pt/guides/nvlink-vs-pcie)

---

Fonte: https://gpuserver.io/pt/guides/lora-finetune/. Este arquivo é gerado a partir dos mesmos dados que o site; se um número aqui divergir de uma página, a página prevalece e este arquivo está desatualizado — a fonte canônica é https://gpuserver.io/.