Capítulo 3: Visão Geral dos Métodos PEFT

Todos os Principais Métodos de Eficiência de Parâmetros Explicados

Este capítulo apresenta uma visão abrangente de todos os principais métodos PEFT, ajudando você a escolher o mais adequado para seu caso de uso.

---

Taxonomia dos Métodos PEFT

---

1. LoRA (Low-Rank Adaptation)

Como Funciona

LoRA adiciona matrizes treináveis de decomposição de baixa-rank junto aos pesos congelados.

Original: h = Wx
LoRA:     h = Wx + BAx

Onde:
- W é congelado (d × d)
- B é treinável (d × r)
- A é treinável (r × d)
- r é muito menor que d (baixa rank, ex.: 8-64)

Representação Visual

Configuração

from peft import LoraConfig

lora_config = LoraConfig(
    r=16,                    # Rank (capacidade)
    lora_alpha=32,           # Fator de escala
    target_modules=[         # Onde aplicar
        "q_proj",
        "k_proj", 
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_dropout=0.05,       # Regularização
    bias="none",             # Não treinar bias
    task_type="CAUSAL_LM",
)

Prós & Contras

Prós	Contras
Muito eficaz	Necessita ajuste de hiperparâmetros
Bem compreendido	Seleção do rank é importante
Amplamente suportado	Pequena sobrecarga na inferência
Pode ser mesclado	—

---

2. QLoRA (Quantized LoRA)

Como Funciona

Combina quantização em 4 bits com LoRA para eficiência extrema.

1. Carrega o modelo base em 4 bits (formato NF4)
2. Adiciona adaptadores LoRA em fp16/bf16
3. Treina apenas os parâmetros LoRA
4. Gradientes fluem pelos pesos desquantizados

Configuração

from transformers import BitsAndBytesConfig
from peft import LoraConfig

# Configuração de quantização
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,  # Economia extra
)

# Carrega modelo quantizado
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
)

# Aplica LoRA por cima
lora_config = LoraConfig(r=16, lora_alpha=32, ...)
model = get_peft_model(model, lora_config)

Comparação de Memória

Modelo	LoRA	QLoRA	Economia
7B	~14GB	~6GB	57%
13B	~26GB	~10GB	62%
70B	~140GB	~48GB	66%

---

3. Prefix Tuning

Como Funciona

Adiciona "tokens virtuais" treináveis como prefixos aos estados de chave e valor nas camadas de atenção.

Atenção normal: Attention(Q, K, V)
Prefix tuning:  Attention(Q, [P_K; K], [P_V; V])

Onde P_K, P_V são embeddings de prefixo aprendidos

Configuração

from peft import PrefixTuningConfig

prefix_config = PrefixTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=20,      # Número de tokens de prefixo
    prefix_projection=True,     # Usa MLP para projeção
)

Casos de Uso

• Condicionamento específico de tarefa
• Quando não é possível modificar os pesos do modelo
• Otimização contínua de prompt

---

4. Prompt Tuning

Como Funciona

Aprende embeddings contínuos que são adicionados ao início da sequência de entrada.

Normal:       embed("What is AI?")
Prompt Tuning: [learned_prompts] + embed("What is AI?")

Configuração

from peft import PromptTuningConfig

prompt_config = PromptTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=8,
    prompt_tuning_init="TEXT",        # Inicializa a partir de texto
    prompt_tuning_init_text="Classify the following:",
)

Características

• Menor quantidade de parâmetros treináveis
• Funciona bem para classificação
• Menos flexível que LoRA
• Não modifica o interno do modelo

---

5. IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations)

Como Funciona

Aprende a reescalar ativações ao invés de adicionar novos pesos.

Original: h = activation(Wx)
IA3:      h = activation(W(l_v ⊙ x)) * l_k

Onde l_v, l_k são vetores de escala aprendidos

Configuração

from peft import IA3Config

ia3_config = IA3Config(
    task_type="CAUSAL_LM",
    target_modules=["k_proj", "v_proj", "down_proj"],
    feedforward_modules=["down_proj"],
)

Características

• Ainda menos parâmetros que LoRA
• Sobrecarga computacional mínima
• Bom para algumas tarefas, menos versátil
• Adoção em estágio de pesquisa

---

6. AdaLoRA (Adaptive LoRA)

Como Funciona

Aloja dinamicamente o rank para diferentes matrizes de peso com base na importância.

Em vez de: rank fixo r para todas as camadas
AdaLoRA:    rank_i baseado em score de importância

Camadas importantes → rank maior
Menos importantes → rank menor

Configuração

from peft import AdaLoraConfig

adalora_config = AdaLoraConfig(
    init_r=12,           # Rank inicial
    target_r=4,          # Rank médio alvo
    tinit=200,           # Passos de aquecimento
    tfinal=1000,         # Quando parar de adaptar
    deltaT=10,           # Frequência de atualização
    beta1=0.85,
    beta2=0.85,
)

Quando Usar

• Quando não tem certeza sobre o rank ideal
• Para alocação ótima de parâmetros
• Quando aceita trocar complexidade por eficiência

---

Comparação dos Métodos

Parâmetros e Memória

Método	Parâmetros	Memória	Qualidade
LoRA	~0.1-1%	Baixa	⭐⭐⭐⭐⭐
QLoRA	~0.1-1%	Muito baixa	⭐⭐⭐⭐
Prefix	~0.1%	Muito baixa	⭐⭐⭐
Prompt	~0.01%	Muito baixa	⭐⭐⭐
IA3	~0.01%	Muito baixa	⭐⭐⭐
AdaLoRA	Variável	Baixa	⭐⭐⭐⭐

Recomendações por Caso de Uso

Caso de Uso	Método Recomendado
Fine-tuning geral	LoRA
Memória limitada	QLoRA
Múltiplas tarefas similares	Prompt Tuning
Condicionamento de tarefa	Prefix Tuning
Mínimos parâmetros	IA3
Eficiência ótima	AdaLoRA

---

Combinando Métodos

LoRA + Quantização

# Combinação mais comum
bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
model = load_model(quantization_config=bnb_config)
model = get_peft_model(model, lora_config)

Múltiplos Adaptadores LoRA

# Treina adaptadores diferentes
model.add_adapter("task_a", lora_config_a)
model.add_adapter("task_b", lora_config_b)

# Alterna entre eles
model.set_adapter("task_a")
# ou
model.set_adapter("task_b")

---

Como Escolher o Método Certo

---

Principais Pontos

✅ LoRA é o método PEFT mais versátil e amplamente utilizado

✅ QLoRA adiciona quantização para eficiência extrema de memória

✅ Prompt/Prefix tuning funcionam sem modificar os pesos do modelo

✅ IA3 oferece mínimo de parâmetros, mas menos flexibilidade

✅ Escolha com base em restrições de memória e requisitos de qualidade

✅ Métodos podem ser combinados (ex.: QLoRA = Quantização + LoRA)

---

Próximos Passos

Teste seus conhecimentos com o Quiz do Módulo 3, depois aprofunde-se em LoRA no Módulo 4: LoRA em Detalhes.

---

Verificação Rápida

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

1. Qual a principal diferença entre LoRA e QLoRA?
2. Como funciona o Prefix Tuning conceitualmente?
3. Qual método PEFT utiliza o menor número de parâmetros?