Capítulo 1: Introdução ao PEFT

Tornando o Fine-Tuning Acessível

Parameter-Efficient Fine-Tuning (PEFT) é um conjunto de técnicas que permite o fine-tuning de grandes modelos de linguagem utilizando apenas uma fração dos recursos necessários para o fine-tuning completo.

---

O Problema que o PEFT Resolve

Desafios do Fine-Tuning Completo

• Modelo 7B: Precisa de ~60-80GB de VRAM para fine-tuning completo
• Modelo 13B: Precisa de ~110-160GB de VRAM
• Modelo 70B: Precisa de ~600GB+ de VRAM

Isso impede que a maioria dos profissionais faça fine-tuning em modelos maiores.

---

A Solução PEFT

Principal Insight

A maior parte do conhecimento do modelo está nos pesos pré-treinados. Só precisamos fazer pequenos ajustes para novas tarefas.

Como Funciona

Em vez de atualizar todos os parâmetros:

# Fine-Tuning Completo (todos os parâmetros)
for param in model.parameters():
    param.requires_grad = True  # Atualiza tudo

# PEFT (somente adapters)
for name, param in model.named_parameters():
    param.requires_grad = False  # Congela o modelo base
    
# Adiciona pequeno adapter treinável
adapter = LoRAAdapter(rank=16)  # ~0.1% dos parâmetros

---

Benefícios do PEFT

1. Redução Dramática de Memória

Modelo	Full FT	PEFT	Economia
7B	~80GB	~6-14GB	82-92%
13B	~160GB	~10-26GB	84-94%
70B	~600GB	~48-140GB	77-92%

2. Treinamento Mais Rápido

Full FT: 100% dos parâmetros atualizados por etapa
PEFT: Menos de 1% dos parâmetros atualizados por etapa
→ Cálculo de gradiente mais rápido
→ Atualização de pesos mais rápida
→ Menor uso de banda de memória

3. Sem Esquecimento Catastrófico

# Modelo base congelado = conhecimento original preservado
base_weights = model.get_base_weights()  # Nunca modificados
adapter_weights = model.get_adapter_weights()  # Apenas estes mudam

4. Múltiplos Adapters

# Um modelo base, múltiplos adapters para diferentes tarefas
model.load_adapter("customer-support")  # Tarefa 1
model.load_adapter("code-generation")   # Tarefa 2
model.load_adapter("summarization")     # Tarefa 3
# Basta trocar o adapter em tempo de execução!

---

Conceitos Centrais

Parâmetros Congelados

Parâmetros que não recebem atualizações de gradiente durante o treinamento.

# Congelar um parâmetro
param.requires_grad = False

# Verificar parâmetros treináveis
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"Trainable: {name}")

Parâmetros Treináveis

Apenas o pequeno conjunto de parâmetros que são atualizados durante o treinamento com PEFT.

Adapters

Módulos adicionais adicionados ao modelo congelado que contêm os parâmetros treináveis.

---

A Biblioteca PEFT

A biblioteca PEFT da Hugging Face oferece acesso unificado a todos os principais métodos de PEFT:

from peft import (
    LoraConfig,
    PrefixTuningConfig,
    PromptTuningConfig,
    IA3Config,
    AdaLoraConfig,
    get_peft_model,
    PeftModel,
)

# Configurar PEFT
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
)

# Aplicar ao modelo
model = get_peft_model(base_model, peft_config)

# Verificar parâmetros treináveis
model.print_trainable_parameters()
# Output: trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.0622

Funções Principais

Função	Finalidade
get_peft_model()	Envelopa o modelo base com PEFT
print_trainable_parameters()	Mostra a contagem de treináveis
save_pretrained()	Salva apenas o adapter
merge_and_unload()	Mescla o adapter ao modelo base
load_adapter()	Carrega um adapter salvo

---

Comparação de Parâmetros

from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model

# Carregar modelo base
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

# Contar parâmetros do modelo base
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")  # ~8,000,000,000

# Aplicar LoRA
lora_config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, lora_config)

# Contar treináveis
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Trainable: {trainable:,}")  # ~4,000,000
print(f"Percentage: {100 * trainable / total_params:.4f}%")  # ~0.05%

---

Benefícios de Armazenamento

Salvando Apenas o Adapter

# Modelo completo: ~15GB (modelo 7B em fp16)
model.save_pretrained("./full-model")

# Apenas o adapter LoRA: ~10-50MB
model.save_pretrained("./lora-adapter", save_embedding_layers=False)

Múltiplos Adapters = Armazenamento Mínimo

Modelo Base:     15GB (compartilhado)
Adapter A:       20MB (tarefa 1)
Adapter B:       20MB (tarefa 2)
Adapter C:       20MB (tarefa 3)
Total:           15,06GB para 3 modelos especializados

vs Full FT:      45GB para 3 modelos separados

---

Exemplo Rápido

Treinamento completo com PEFT em menos de 50 linhas:

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer
from datasets import load_dataset

# Carregar modelo e tokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer.pad_token = tokenizer.eos_token

# Configurar LoRA
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)

# Aplicar PEFT
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# Carregar dataset
dataset = load_dataset("databricks/dolly-15k", split="train[:1000]")

# Treinar
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=512,
)
trainer.train()

# Salvar adapter
model.save_pretrained("./my-lora-adapter")

---

Principais Pontos

✅ PEFT treina menos de 1% dos parâmetros mantendo a qualidade

✅ Economia de memória de 80-95% em comparação ao fine-tuning completo

✅ Pesos do modelo base permanecem congelados, evitando esquecimento

✅ Múltiplos adapters podem compartilhar um único modelo base

✅ A biblioteca PEFT oferece acesso unificado a todos os métodos

✅ Arquivos de adapter são pequenos (~10-50MB) vs modelos completos (~15GB+)

---

Próximos Passos

Continue para Capítulo 2: PEFT vs Fine-Tuning Completo para entender os trade-offs em detalhes.

---

Verificação Rápida

Antes de seguir, certifique-se de que você consegue responder:

1. Qual a porcentagem de parâmetros que o PEFT normalmente treina?
2. Por que o PEFT não causa esquecimento catastrófico?
3. Qual é a principal função para criar um modelo PEFT?