Capítulo 3: Panorama do Fine-Tuning
Visão Geral de Métodos, Ferramentas e Requisitos
O panorama do fine-tuning evoluiu rapidamente, oferecendo múltiplas abordagens adequadas para diferentes necessidades e recursos. Este capítulo fornece uma visão abrangente para ajudá-lo a navegar pelas suas opções.
Visão Geral dos Métodos de Fine-Tuning
Comparação de Métodos
| Método | Parâmetros Treinados | Uso de Memória | Qualidade | Melhor Para |
|---|---|---|---|---|
| Full Fine-Tuning | 100% | Muito Alta | Máxima | Máxima customização |
| LoRA | ~0,1-1% | Média | Alta | Fine-tuning geral |
| QLoRA | ~0,1-1% | Baixa | Alta | GPUs de consumidor |
| Prefix Tuning | ~0,1% | Baixa | Boa | Tarefas específicas |
| IA3 | ~0,01% | Muito Baixa | Boa | Mudanças mínimas |
Full Fine-Tuning
O que é
Atualização de todos os parâmetros do modelo durante o treinamento.
Vantagens
- Máxima flexibilidade e customização
- Pode alcançar os melhores resultados para tarefas complexas
- Controle total sobre o comportamento do modelo
Desvantagens
- Requer muita memória de GPU (modelo 7B precisa de ~28GB+ para treinar)
- Maior risco de esquecimento catastrófico
- Alto custo computacional
Quando Usar
- Quando você tem recursos computacionais abundantes
- Para aplicações críticas que exigem máxima qualidade
- Quando métodos PEFT não atingem o resultado desejado
# Full fine-tuning example
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
fp16=True, # Mixed precision to save memory
)
trainer = Trainer(
model=model, # All parameters trainable
args=training_args,
train_dataset=dataset,
)
LoRA (Low-Rank Adaptation)
O que é
Adição de pequenas matrizes treináveis aos pesos congelados do modelo.
Como Funciona
Original: W (frozen)
LoRA: W + BA (onde B e A são pequenas matrizes treináveis)
Principais Parâmetros
- Rank (r): Dimensionalidade das matrizes de baixa rank (ex: 8, 16, 32)
- Alpha: Fator de escala para as contribuições do LoRA
- Target Modules: Em quais camadas aplicar o LoRA (q_proj, v_proj, etc.)
Vantagens
- Redução de memória acima de 90%
- Treinamento rápido
- Adaptador pode ser trocado ou mesclado
- Sem perda de qualidade na maioria das tarefas
Desvantagens
- Limite de qualidade um pouco menor que o full fine-tuning
- Necessidade de ajuste de hiperparâmetros (rank, alpha)
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q_proj", "v_proj"],
lora_dropout=0.05,
task_type="CAUSAL_LM",
)
model = get_peft_model(base_model, lora_config)
QLoRA (Quantized LoRA)
O que é
Combinação de quantização em 4 bits com LoRA para máxima eficiência de memória.
Como Funciona
- Carrega o modelo base em precisão de 4 bits
- Adiciona adaptadores LoRA em precisão mais alta
- Treina apenas os parâmetros do LoRA
Comparação de Memória
| Tamanho do Modelo | Full FT | LoRA | QLoRA |
|---|---|---|---|
| 7B | ~28GB | ~14GB | ~6GB |
| 13B | ~52GB | ~26GB | ~10GB |
| 70B | ~280GB | ~140GB | ~48GB |
Vantagens
- Treine modelos de 70B em GPUs de consumidor
- Perda de qualidade mínima comparado ao LoRA
- Muito econômico
Desvantagens
- Treinamento um pouco mais lento
- Requer a biblioteca bitsandbytes
- Possíveis artefatos de quantização
from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
"model_name",
quantization_config=bnb_config,
)
Métodos de Alinhamento
RLHF (Reinforcement Learning from Human Feedback)
- Treina um modelo de recompensa a partir de preferências humanas
- Usa RL (PPO) para otimizar o modelo de linguagem
- Complexo, mas poderoso
DPO (Direct Preference Optimization)
- Simplifica o RLHF removendo o modelo de recompensa
- Otimiza diretamente em pares de preferência
- Muito mais simples de implementar
ORPO (Odds Ratio Preference Optimization)
- Combina SFT e alinhamento em um único passo
- Ainda mais simples que o DPO
- Novo, mas com resultados promissores
# DPO example with TRL
from trl import DPOTrainer
trainer = DPOTrainer(
model=model,
ref_model=reference_model,
train_dataset=preference_dataset,
beta=0.1, # KL penalty weight
)
Ecossistema de Ferramentas
Stack Hugging Face
| Ferramenta | Finalidade |
|---|---|
| transformers | Carregamento de modelos, tokenização, treinamento |
| peft | Fine-tuning eficiente em parâmetros |
| trl | Treinadores SFT, DPO, RLHF |
| datasets | Carregamento e processamento de datasets |
| accelerate | Treinamento distribuído |
| bitsandbytes | Quantização |
Frameworks Alternativos
| Ferramenta | Ponto Forte | Caso de Uso |
|---|---|---|
| Axolotl | Configuração fácil | Experimentos rápidos |
| LLaMA-Factory | Interface unificada | Múltiplos métodos |
| Unsloth | 2x mais rápido, menos memória | Iteração rápida |
Requisitos Computacionais
Diretrizes de Memória de GPU
Memória Necessária ≈ (Parâmetros do Modelo × Bytes de Precisão × Multiplicador)
Onde Multiplicador:
- Inferência: 1x
- Treinamento LoRA: 2-3x
- Full Fine-Tuning: 4-6x
GPUs Recomendadas
| Orçamento | GPU | VRAM | Indicado Para |
|---|---|---|---|
| Gratuito | Colab T4 | 15GB | QLoRA em 7B |
| $ | RTX 3090/4090 | 24GB | QLoRA em 13B |
| $$ | A100-40GB | 40GB | LoRA em 70B |
| $$$ | A100-80GB | 80GB | Full FT em 13B |
| $$$$ | H100 | 80GB | Full FT em 70B |
Estimativas de Tempo de Treinamento
| Modelo | Método | GPU | Tempo para 1K Exemplos |
|---|---|---|---|
| 7B | QLoRA | A100-40GB | ~30 min |
| 7B | LoRA | A100-40GB | ~20 min |
| 7B | Full FT | A100-80GB | ~45 min |
| 70B | QLoRA | A100-80GB | ~3 horas |
Escolhendo Seu Caminho
Matriz de Decisão
Recomendações por Cenário
| Cenário | Método Recomendado |
|---|---|
| Aprendizado/Experimentação | QLoRA no Colab |
| Produção (sensível a custo) | QLoRA em GPU na nuvem |
| Produção (qualidade crítica) | LoRA ou Full FT |
| Pesquisa | Full FT com checkpoints |
| Iteração rápida | Unsloth + QLoRA |
O Curso Adiante
Nos próximos módulos, vamos aprofundar em cada método:
| Módulo | Foco |
|---|---|
| Módulo 2 | Detalhes do Full Fine-Tuning |
| Módulo 3 | Conceitos de PEFT |
| Módulo 4 | LoRA em detalhes |
| Módulo 5 | QLoRA e quantização |
| Módulo 6 | Preparação de dados |
| Módulo 7 | Treinamento com Hugging Face |
| Módulo 8 | Técnicas avançadas (DPO, ORPO) |
| Módulo 9 | Avaliação e mesclagem |
| Módulo 10 | Deploy em produção |
Principais Pontos
✅ Existem múltiplos métodos de fine-tuning para diferentes níveis de recursos
✅ Métodos PEFT (LoRA, QLoRA) tornam o fine-tuning acessível em hardware de consumidor
✅ O ecossistema Hugging Face fornece todas as ferramentas necessárias
✅ A escolha do método depende do orçamento computacional e dos requisitos de qualidade
✅ Comece com QLoRA para aprender e escale conforme necessário
Próximos Passos
Teste seu conhecimento com o Quiz do Módulo 1, depois continue para o Módulo 2: Full Fine-Tuning.
Verificação Rápida
Antes de avançar, certifique-se de que consegue responder:
- Qual a principal diferença entre LoRA e QLoRA?
- Quanta memória seria necessária para aplicar QLoRA em um modelo 7B?
- Qual a diferença entre DPO e RLHF?