🎓 Fine-tuning & Training — Todas as formas de adaptar um modelo

🟢 Prioridade C — visão completa. Da prompt engineering (zero training) ao full fine-tuning.

---

Espectro: zero training → full training

---

1. Prompt Engineering — zero training

O que é: Adaptar o modelo apenas através do texto do prompt. Nenhum peso é alterado.

Tipos

• Zero-shot — Só a instrução. "Traduz para inglês: [texto]"
• Few-shot — 1-5 exemplos input→output no prompt. O modelo infere o padrão.
• Chain-of-Thought (CoT) — "Pensa passo a passo" ou exemplos com raciocínio.
• Structured output — Instruções para formato (JSON, markdown).
• Role prompting — "És um especialista em X" — afeta tom e estilo.

Vantagens: Grátis, instantâneo, iterável. Limitações: Conhecimento fixo no treino, formato pode variar.

Quando usar: Sempre primeiro. Resolve 80% dos casos.

---

2. RAG — conhecimento sem treinar o LLM

O que é: Recuperar documentos e injetar no prompt. O LLM não é treinado — recebe contexto em runtime.

Treino envolvido: Nenhum no LLM. Opcionalmente: treinar embedding model ou reranker para o domínio.

Quando usar: Conhecimento que muda (docs, FAQs, dados internos). Evita retreinar para atualizar.

---

3. Prompt Tuning (Soft Prompts)

O que é: Em vez de texto fixo, aprender embeddings de prompt. Os "tokens" do prompt são vetores treináveis.

Como funciona: Congelar o modelo. Só treinar os embeddings que representam o prompt. Loss: tarefa (ex: classificação).

Vantagens: Muito poucos parâmetros (só os embeddings do prompt). Rápido, poucos dados.

Quando usar: Tarefa muito específica, poucos dados, quer consistência sem few-shot no prompt.

---

4. LoRA, QLoRA e PEFT — Diferenciar e quando usar

LoRA (Low-Rank Adaptation)

O que é: Em vez de atualizar todos os pesos W (milhões de parâmetros), adiciona duas matrizes pequenas A e B em paralelo. A atualização é ΔW = B×A, onde A tem dimensão (d×r) e B tem (r×k). r = rank (típico 8-64).

Fórmula: output = W·x + (B·A)·x. W fica congelado; só treinas A e B.

Porquê funciona: A atualização efetiva tem rank r. Muitas adaptações de domínio são "low-rank" — não precisam de alterar toda a matriz. r=8 já captura muita informação.

Vantagens: ~0.1% dos parâmetros. Llama 7B: 7B params, LoRA ~7M treináveis. Uma GPU 24GB chega. Múltiplos adapters = trocar tarefas sem retreinar.

Quando usar: Comportamento, estilo, formato. 500-5000 exemplos. Tens GPU com memória para o modelo em fp16/bf16.

---

QLoRA (Quantized LoRA)

O que é: LoRA + quantização do modelo base. O modelo é carregado em 4-bit (ou 8-bit) em vez de fp16. Reduz memória em ~4×.

Como: bitsandbytes faz quantização (NF4, FP4). O modelo base fica congelado e quantizado; só os adapters LoRA são fp16 e treinados.

Vantagem principal: Treinar Llama 7B numa GPU 10-12GB. Ou Llama 70B numa A100 40GB. Democratiza fine-tuning.

Tradeoff: Ligeira perda de qualidade vs LoRA em fp16 (modelo base quantizado). Para muitos casos, impercetível.

Quando usar: Não tens GPU grande. Queres treinar 7B+ numa máquina consumer. Protótipos rápidos.

---

PEFT (Parameter-Efficient Fine-Tuning)

O que é: Biblioteca da Hugging Face que implementa LoRA, QLoRA, Adapters, Prefix Tuning, etc. Não é um método — é o toolkit.

O que inclui:

• LoRA — LoraConfig, get_peft_model
• QLoRA — LoRA + BitsAndBytesConfig (4-bit)
• Adapters — módulos em camadas (AdaLoRA, etc.)
• Prefix Tuning — vetores treináveis no início do prompt

Uso típico:

from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(r=8, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, lora_config)

Quando usar: Sempre que fazes LoRA/QLoRA em Hugging Face. PEFT é o padrão.

---

Resumo: LoRA vs QLoRA vs PEFT

Árvore de decisão: Tens GPU 24GB+? → LoRA. GPU 10-12GB? → QLoRA. Usas Hugging Face? → PEFT.

---

4b. LoRA vs outros métodos — diferenças, porquê e quando usar cada um

Comparação direta: o que cada método faz

---

LoRA vs Full Fine-tuning

Diferença: Full fine-tuning atualiza todos os 7B (ou mais) parâmetros. LoRA congela o modelo e adiciona apenas matrizes low-rank — treinas ~7M parâmetros.

Porquê LoRA em vez de Full:

• Custo: Full precisa de múltiplas GPUs ou muito tempo. LoRA corre numa GPU 24GB.
• Catastrophic forgetting: Full pode "esquecer" capacidades gerais. LoRA preserva o modelo base; os adapters são aditivos.
• Múltiplas tarefas: Com LoRA podes ter adapter A (relatórios clínicos), adapter B (emails) — trocas em runtime. Full = um modelo por tarefa.
• Overfitting: Com 500–2000 exemplos, Full overfita facilmente. LoRA generaliza melhor.

Quando usar Full em vez de LoRA: Domínio muito diferente do pré-treino (ex: médico, jurídico), dezenas de milhares de exemplos, e LoRA não atinge a qualidade necessária. Raro em prática.

---

LoRA vs Prompt Tuning

Diferença: Prompt Tuning aprende vetores que representam o prompt — não mexe nas camadas do modelo. LoRA injeta matrizes nas camadas (attention, etc.).

Porquê LoRA em vez de Prompt Tuning:

• Expressividade: LoRA altera o comportamento interno do modelo. Prompt Tuning só "guia" pelo input — limitado para mudanças profundas.
• Formato rígido: Se precisas de output estruturado consistente (ex: JSON com campos fixos), LoRA adapta melhor. Prompt Tuning pode não garantir.

Quando usar Prompt Tuning em vez de LoRA: Muito poucos dados (100–500), tarefa simples (ex: classificação), e não tens GPU. Mais barato e rápido.

---

LoRA vs Adapters tradicionais (Houlsby, etc.)

Diferença: Adapters tradicionais adicionam camadas completas (feed-forward pequeno) após cada sub-layer. LoRA usa decomposição low-rank nas matrizes existentes.

Porquê LoRA em vez de Adapters:

• Inferência: LoRA pode fundir A×B na matriz W — zero overhead em produção. Adapters adicionam camadas extra = mais latência.
• Parâmetros: LoRA tipicamente usa menos parâmetros para mesma qualidade.
• Ecosistema: LoRA é o padrão de facto; PEFT, Axolotl, Unsloth otimizam para LoRA.

Quando usar Adapters: Casos muito específicos (ex: multilingual com muitos adapters por língua). LoRA cobre a maioria.

---

LoRA vs Instruction Tuning (SFT)

Não são exclusivos. SFT é o tipo de dados (pares instrução→resposta); LoRA é o método de treino (como atualizas os pesos).

Combinação típica: Instruction Tuning com LoRA — dataset de instruções + treino com LoRA. O modelo aprende a seguir instruções sem full fine-tuning.

Quando SFT com Full: Modelo base muito "burro" (não segue instruções) e tens muitos dados. Na prática, SFT + LoRA resolve na maioria dos casos.

---

LoRA vs RAG

Não competem — resolvem problemas diferentes.

Usar os dois: RAG para conhecimento + LoRA para o modelo seguir melhor instruções no teu domínio. Ex: RAG com docs da empresa + LoRA para formato de resposta consistente.

---

Árvore de decisão: qual método escolher?

1. O problema é conhecimento que muda? → RAG (não é fine-tuning)

2. O problema é formato/estilo/consistência?
   → Prompt (few-shot) resolve? → SIM: Prompt Engineering
   → NÃO: continua

3. Tens 500+ exemplos (input, output)?
   → NÃO: Prompt Tuning ou gera mais dados
   → SIM: continua

4. Tens GPU com memória?
   → 10–12 GB: QLoRA
   → 24 GB+: LoRA (fp16)
   → Nenhuma: considera API (OpenAI fine-tuning) ou cloud

5. LoRA não chega (domínio muito específico, 50K+ exemplos)?
   → Full Fine-tuning (raro)

---

Resumo: quando usar cada um

---

5. Full Fine-tuning

O que é: Atualizar todos os pesos do modelo no dataset do domínio.

Vantagens: Máxima adaptação. Desvantagens: Custo alto (GPU, tempo), risco de overfitting, catastrophic forgetting.

Quando usar: Domínio muito específico, muitos dados (dezenas de milhares+), e prompt engineering + LoRA não chegam.

Mitigação: Learning rate baixo, early stopping, gradual unfreezing (camadas finais primeiro).

---

6. Instruction Tuning (SFT)

O que é: Treinar com pares (instrução, resposta desejada). Ensina o modelo a seguir instruções.

Formato de dados: {"instruction": "...", "input": "...", "output": "..."}

Pipeline: Base model → SFT em dataset de instruções → modelo que segue pedidos.

Quando usar: Modelo base que não segue instruções bem. Ou formato de output muito específico.

---

7. RLHF e DPO — alinhamento com preferências

RLHF (Reinforcement Learning from Human Feedback):

1. Base model
2. SFT em instruções
3. Reward model — treinado em comparações humanas (A melhor que B)
4. RL (PPO) — otimizar policy para maximizar reward

DPO (Direct Preference Optimization): Simplificação. Em vez de reward model + RL, loss direta em pares (preferido, rejeitado). Mais estável, menos complexo.

Quando usar: Alinhamento de comportamento, segurança, estilo de resposta. ChatGPT, Claude usam.

---

8. Treinar Embedding Models (para RAG)

O que é: Fine-tune um modelo de embeddings (sentence-transformers, BGE) no teu domínio.

Porquê: Embeddings genéricos podem não capturar termos técnicos, jargão, relações do domínio.

Como: Pares (query, doc relevante) ou triplets (query, pos, neg). Loss: contrastive (ex: InfoNCE).

Dados: 1000+ pares query-doc. Pode usar LLM para gerar synthetic.

Quando usar: RAG com domínio muito específico onde retrieval genérico falha.

---

9. Treinar Rerankers (cross-encoder)

O que é: Modelo que recebe (query, doc) e devolve score de relevância. Treinar em pares (query, doc, label).

Pipeline RAG: Bi-encoder (retrieval) → top 20 → Cross-encoder (rerank) → top 5 → LLM.

Dados: Pares (query, doc, 0/1 relevante). Cohere, BGE têm modelos pré-treinados.

Quando usar: Retrieval com muitos falsos positivos. Reranker customizado para o domínio.

---

10. Preparação de dados para treino

Formato

• SFT: {"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
• Instruction: instruction, input, output
• Preference: chosen, rejected (para DPO)

Qualidade

• Diversidade — cobrir casos edge, não só exemplos fáceis
• Consistência — mesmo critério de qualidade em todo o dataset
• Deduplicação — evitar duplicados que causam overfitting
• Balanceamento — se multi-classe, não 99% numa classe

Tamanho mínimo (ordem de grandeza)

• Prompt tuning: 100-500 exemplos
• LoRA: 500-5000 exemplos
• Full fine-tuning: 10K+ exemplos
• Embedding fine-tune: 1000+ pares

---

11. Quando usar o quê — árvore de decisão

Precisas de conhecimento novo/atualizável? → RAG
Precisas só de formato/estilo? → Prompt engineering (few-shot, instruções)
Prompt engineering não chega? → LoRA (comportamento específico)
Domínio muito nicho, muitos dados? → Full fine-tuning
Precisas de alinhamento (segurança, preferências)? → RLHF/DPO
Retrieval fraco no domínio? → Fine-tune embedding ou reranker

---

12. Ferramentas

---

Resumo para entrevista

Há um espectro: prompt engineering (zero custo) → RAG (conhecimento) → LoRA (comportamento, poucos params) → full fine-tuning (máxima adaptação). Escolho pelo problema: conhecimento que muda = RAG. Comportamento/estilo = LoRA. Sempre começo por prompt engineering.