Fine-tuning do LLaMA 3 na Nuvem: Passo a Passo

O Que é Fine-tuning?

Fine-tuning é o processo de adaptar um modelo de linguagem pré-treinado (como o LLaMA 3) para uma tarefa ou domínio específico. Em vez de treinar do zero, você continua o treinamento com seus próprios dados, ajustando os pesos do modelo.

**Quando usar:**

LoRA vs QLoRA vs Full Fine-tuning

| Método | VRAM necessária | Velocidade | Qualidade | Custo |

|---|---|---|---|---|

| Full fine-tuning | 160GB+ (70B) | Lento | Máxima | Muito alto |

| LoRA | 40–80GB | Médio | Muito boa | Alto |

| QLoRA | 16–24GB | Médio | Boa | Acessível |

**Recomendação para 2026:** QLoRA na maioria dos casos. Você perde <2% de qualidade comparado ao full fine-tuning com uma fração do custo.

Requisitos de GPU por Tamanho de Modelo

| Modelo | QLoRA | LoRA | Full FT |

|---|---|---|---|

| LLaMA 3 8B | 12GB | 24GB | 80GB |

| LLaMA 3 70B | 48GB | 80GB | 4×80GB |

| Mistral 7B | 10GB | 20GB | 70GB |

Passo a Passo com HuggingFace + PEFT no RunPod

1. Setup no RunPod

2. Instalar Dependências

```bash

pip install transformers peft datasets bitsandbytes accelerate trl

```

3. Código de Fine-tuning com QLoRA

```python

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

from trl import SFTTrainer, SFTConfig

import torch

Configuração 4-bit

bnb_config = BitsAndBytesConfig(

load_in_4bit=True,

bnb_4bit_quant_type="nf4",

bnb_4bit_compute_dtype=torch.bfloat16,

)

model = AutoModelForCausalLM.from_pretrained(

"meta-llama/Meta-Llama-3-8B-Instruct",

quantization_config=bnb_config,

device_map="auto",

)

model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(

r=16, # rank: 8-64, maior = mais parâmetros

lora_alpha=32, # escala: geralmente 2x o rank

target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],

lora_dropout=0.05,

task_type="CAUSAL_LM",

)

model = get_peft_model(model, lora_config)

model.print_trainable_parameters()

Output: trainable params: 6,815,744 || all params: 8,037,408,768 || trainable%: 0.085

trainer = SFTTrainer(

model=model,

train_dataset=dataset,

args=SFTConfig(

output_dir="./llama3-finetuned",

num_train_epochs=3,

per_device_train_batch_size=4,

gradient_accumulation_steps=4,

bf16=True,

logging_steps=10,

save_steps=100,

),

)

trainer.train()

```

4. Estimativa de Custo

| Modelo | GPU | Tempo (1k exemplos) | Custo |

|---|---|---|---|

| LLaMA 3 8B QLoRA | RTX 4090 | ~1,5h | ~$0,66 |

| LLaMA 3 8B LoRA | A100 40GB | ~45min | ~$0,89 |

| LLaMA 3 70B LoRA | A100 80GB | ~8h | ~$15,12 |

5. Avaliando o Modelo

```python

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")

model = PeftModel.from_pretrained(base_model, "./llama3-finetuned/checkpoint-best")

```

Use benchmarks como **MT-Bench** ou seu próprio conjunto de avaliação para comparar com o modelo base.

6. Salvando e Deployando

```python

Mesclar LoRA com o modelo base para deploy mais simples

merged_model = model.merge_and_unload()

merged_model.save_pretrained("./llama3-merged")

Subir para HuggingFace Hub:

merged_model.push_to_hub("seu-usuario/llama3-finetuned")

```

Conclusão

QLoRA tornou o fine-tuning de LLMs acessível para qualquer pessoa com um orçamento modesto. Com menos de $20 você pode adaptar o LLaMA 3 8B para seu caso de uso específico.

Encontrar GPU para fine-tuning → →