Playbook de Fine-Tuning

O que “adaptação” significa para modelos de linguagem de grande porte (LLMs)

Os Modelos de Linguagem de Grande Porte (LLMs) modernos são sistemas de uso geral treinados para prever texto (ou tokens (tokens)) em corpora massivos. Quando você quer que um modelo de linguagem de grande porte tenha bom desempenho no seu caso de uso — seu domínio, tom, políticas ou tarefas — em geral você o adapta usando uma (ou mais) destas estratégias:

Construção de prompts (prompting): Forneça instruções e exemplos no tempo de inferência (inference time).
Geração Aumentada por Recuperação (Retrieval-Augmented Generation, RAG): Forneça conhecimento externo no tempo de inferência, recuperando documentos/trechos relevantes.
Ajuste fino (fine-tuning): Atualize os parâmetros do modelo para que o comportamento desejado fique “incorporado”.

Este artigo é um guia prático para escolher entre elas e combiná-las de forma eficaz.

Um modelo mental útil:

Construção de prompts muda o que você pede ao modelo para fazer.
Geração aumentada por recuperação muda o que o modelo sabe em tempo de execução.
Ajuste fino muda o que o modelo é (seu comportamento padrão e padrões internalizados).

O espectro de adaptação (rápido para lento, barato para caro)

Pense nas escolhas de adaptação ao longo de um espectro:

Construção de prompts (minutos–dias)
Menor custo, iteração mais rápida, porém menos confiável em escala e limitado pela janela de contexto (context window).
Geração aumentada por recuperação (dias–semanas)
Adiciona complexidade de engenharia, mas torna as respostas fundamentadas nas suas fontes e mantém o conhecimento atualizado.
Ajuste fino (semanas+)
Maior custo inicial e sobrecarga de governança, mas entrega formatação, tom e comportamento de tarefa consistentes — muitas vezes com menor latência e prompts mais curtos.

Na prática, muitos sistemas bem-sucedidos são híbridos: prompt + ferramentas, geração aumentada por recuperação + ajuste fino, ou as três.

Construção de prompts vs geração aumentada por recuperação vs ajuste fino: a decisão central

Uma regra simples de decisão:

Use construção de prompts quando…

Você precisa de direcionamento comportamental: tom, papel, formatação, procedimentos passo a passo.
Você consegue acomodar instruções e alguns exemplos na janela de contexto.
A tarefa não é extremamente sensível a pequenos desvios (ou você pode adicionar etapas de verificação).
Você quer iterar rapidamente com infraestrutura mínima.

Exemplos:

“Escreva notas de versão no nosso estilo.”
“Extraia campos de e-mails para JSON.”
“Siga nosso roteiro de entrevista.”

Veja também: Construção de Prompts

Use geração aumentada por recuperação quando…

O modelo precisa de conhecimento factual, proprietário ou que muda com frequência.
Você precisa de fundamentação em fontes, citações ou proveniência auditável.
Você não pode (ou não deve) incorporar conhecimento ao modelo (por exemplo, políticas que mudam semanalmente).
Você quer reduzir alucinações (hallucinations) restringindo respostas às fontes recuperadas.

Exemplos:

Respostas de suporte ao cliente a partir de um manual do produto e histórico de tickets.
Perguntas e respostas legais/de políticas com citações para documentos internos.
“Qual é a escala de plantão (on-call rotation) atual?” ou “O que diz nossa página de preços (pricing page) mais recente?”

Veja também: Recuperação e Ferramental

Use ajuste fino quando…

Você precisa de comportamento consistentemente confiável em muitos prompts e usuários.
Você precisa que o modelo aprenda um novo estilo, esquema (schema) ou política de decisão que a construção de prompts não consegue impor bem.
Você precisa de menor latência e custo por requisição ao encurtar prompts (comum em alto volume).
Você quer que o modelo seja melhor em linguagem específica do domínio (por exemplo, anotações médicas, jargão interno).
Você quer melhorar o desempenho em uma tarefa com muitos exemplos rotulados (classificação, extração, roteamento, geração estruturada).

Exemplos:

Extração de dados estruturados que deve corresponder a um esquema rígido em 99%+ das vezes.
Formatos de invocação de ferramentas por agentes (agentic tool invocation) que precisam ser estáveis.
Voz de marca (brand voice) consistente em muitos tipos de conteúdo.

Um seletor prático: “conhecimento vs comportamento” e “atualidade vs estabilidade”

Uma forma forte de decidir é separar suas necessidades em conhecimento e comportamento:

Se o problema é principalmente conhecimento

Pergunte: “O modelo falha porque não sabe algo?”

Se o conhecimento faltante é dinâmico (muda com frequência): prefira geração aumentada por recuperação.
Se o conhecimento faltante é estático (raramente muda) e amplamente reutilizável: considere pré-treinamento contínuo (continued pretraining) ou ajuste fino, mas com cautela — geração aumentada por recuperação costuma ser mais segura e mais auditável.

Se o problema é principalmente comportamento

Pergunte: “O modelo conhece os fatos, mas não segue as instruções de forma consistente?”

Comece com construção de prompts (instruções claras + exemplos + restrições).
Se o comportamento precisa ser altamente confiável, especialmente sob mudança de distribuição (distribution shift), considere ajuste fino (muitas vezes com métodos leves como adaptação de baixa ordem (Low-Rank Adaptation, LoRA)/adaptadores (adapters)).
Se o comportamento depende de documentos internos de política, combine geração aumentada por recuperação + construção de prompts (e só faça ajuste fino se necessário).

Matriz de decisão (regra prática)

Requisito	Construção de prompts	Geração aumentada por recuperação	Ajuste fino
Iteração rápida	Excelente	Bom	Moderado–Lento
Fatos atualizados	Fraco	Excelente	Fraco (a menos que seja retreinado com frequência)
Fundamentação em conhecimento proprietário + citações	Fraco	Excelente	Moderado (mas não auditável)
Formato de saída consistente em escala	Moderado	Moderado	Excelente
Menor latência / prompts mais curtos	Fraco	Moderado	Excelente
Governança/auditabilidade	Moderado	Forte (rastreia fontes)	Exige governança forte de aprendizado de máquina (ML governance)
Risco de memorização de dados sensíveis	Baixo	Baixo–Moderado	Maior (precisa de controles)
Complexidade de engenharia	Baixa	Média	Média–Alta

Guia de construção de prompts (faça isso primeiro, quase sempre)

Antes de construir infraestrutura, esgote as opções baratas.

Padrões que melhoram a confiabilidade

Contratos explícitos de saída: “Retorne JSON válido com as chaves …”
Exemplos few-shot (few-shot examples): 2–10 exemplos representativos frequentemente superam instruções longas.
Checklists: “Antes de responder, verifique: (1)… (2)…”
Etapa de auto-verificação (self-verification step): Peça uma validação breve (mas não dependa disso cegamente).
Separação de ferramentas (tool separation): Coloque ferramentas e restrições em mensagens de sistema/desenvolvedor (quando aplicável), mantenha o conteúdo do usuário separado.

Exemplo de padrão de prompt (extração estruturada):

System: You extract structured data. Output must be valid JSON and match the schema exactly.

User: Extract {invoice_number, date, total_usd} from the following email:
<email>...</email>

Assistant: {"invoice_number": "...", "date": "YYYY-MM-DD", "total_usd": 123.45}

Quando a construção de prompts bate no teto

A construção de prompts tem dificuldades quando:

Você precisa de aderência muito consistente a um esquema em entradas diversas.
O modelo “entende”, mas ainda assim deriva (chaves extras, campos faltando, tom inconsistente).
Prompts longos ficam caros e ainda assim não resolvem totalmente a confiabilidade.

É aí que o ajuste fino (comportamento) ou a geração aumentada por recuperação (conhecimento) geralmente ajuda.

Guia de geração aumentada por recuperação (quando conhecimento é o gargalo)

A geração aumentada por recuperação é melhor vista como um problema de engenharia de sistemas: a qualidade da recuperação frequentemente importa mais do que o gerador.

Pipeline mínimo de geração aumentada por recuperação

Divida documentos em chunks (chunk documents) (passagens de tamanho razoável)
Crie representações vetoriais (embeddings)
Armazene em um índice vetorial (vector index)
Recupere os k melhores (top-k) chunks por consulta
Forneça o texto recuperado ao modelo com instruções para citá-lo/usá-lo

Principais alavancas:

Estratégia de chunking: chunking semântico frequentemente supera chunks de tamanho fixo.
Filtragem por metadados: produto/versão, controle de acesso, intervalo de tempo.
Recuperação híbrida (hybrid retrieval): combine busca por palavra-chave + busca vetorial.
Re-ranqueamento (re-ranking): um pequeno reclassificador por codificador cruzado (cross-encoder re-ranker) pode melhorar dramaticamente a relevância.
Instruções de fundamentação (grounding instructions): “Use apenas o contexto fornecido; se estiver faltando, diga isso.”

Exemplo de prompt de “resposta fundamentada”:

System: Answer using only the provided context. If the context is insufficient, say "I don't know from the provided documents."

User:
Question: How do I rotate API keys?
Context:
[1] ...internal doc excerpt...
[2] ...runbook excerpt...

Modos de falha comuns da geração aumentada por recuperação

Recuperação ruim → alucinações apesar da “fundamentação”
Sobrecarga de contexto (context overload) → o modelo perde o trecho-chave
Injeção de prompt (prompt injection) em documentos recuperados (por exemplo, texto malicioso embutido nas fontes)
Documentos desatualizados ou conflitantes sem versionamento

Mitigações para geração aumentada por recuperação:

Use fontes em allowlist, sanitize HTML e trate o texto recuperado como entrada não confiável (untrusted input).
Adicione versionamento de documentos e lógica de “a política mais recente prevalece”.
Avalie a recuperação separadamente da geração.

Guia de ajuste fino (quando o comportamento precisa ser aprendido)

O ajuste fino ajusta os pesos do modelo para que o comportamento desejado vire o padrão. Conceitualmente, ainda é otimizar um objetivo de verossimilhança (e variantes) via Descida do Gradiente (Gradient Descent) sobre uma Arquitetura Transformer (Transformer Architecture), mas as perguntas práticas são sobre dados, método e avaliação.

Tipos de ajuste fino (comuns na prática de 2024–2026)

1) Ajuste fino supervisionado (Supervised Fine-Tuning, SFT)

Treine com pares (entrada → saída ideal).

Melhor para:

Formatação consistente e saídas estruturadas
Estilo de escrita específico do domínio
Habilidades específicas de tarefa (estilo de sumarização, extração)

Risco:

Pode superajustar (overfit) padrões estreitos se o conjunto de dados for pequeno ou repetitivo.

2) Pré-treinamento contínuo (continued pretraining) (também conhecido como pré-treinamento adaptativo ao domínio (domain-adaptive pretraining))

Treine com grandes quantidades de texto não rotulado do domínio.

Melhor para:

Fluência na linguagem do domínio (terminologia, jargão)
Melhorar a competência geral em um domínio (por exemplo, texto biomédico)

Trade-off:

Exige muitos dados e é mais caro; pode não impor comportamentos específicos.

3) Ajuste por preferências (preference tuning) (estilo DPO/IPO)

Treine a partir de comparações (A preferido a B). Muitas vezes mais barato e mais estável do que aprendizado por reforço com feedback humano (RLHF).

Melhor para:

Alinhar saídas com preferências humanas (tom, utilidade, estilo de recusa)
Melhorias “tipo ranking” sem modelos de recompensa complexos

Relacionado conceitualmente a abordagens de alinhamento como aprendizado por reforço com feedback humano (veja Aprendizado por Reforço (Reinforcement Learning) para fundamentos de RL).

4) Ajuste fino eficiente em parâmetros (Parameter-efficient fine-tuning, PEFT: LoRA/adapters)

Em vez de atualizar todos os pesos, treine pequenos módulos adaptadores.

Melhor para:

Menor custo, iteração mais rápida
Mais fácil manter múltiplas “personalidades” ou domínios
Qualidade frequentemente comparável em muitas tarefas corporativas

Quando ajuste fino é a escolha certa (indicadores de alto sinal)

O ajuste fino tende a valer a pena quando:

Você tem centenas a dezenas de milhares de exemplos de alta qualidade (às vezes menos para tarefas estreitas de formatação).
Sua saída desejada é altamente regular (esquemas, templates, chamadas de ferramentas).
Você consegue definir avaliação objetiva (correspondência exata, validade do esquema, rubricas avaliadas por humanos).
Você espera alto volume de consultas, tornando a economia de prompt significativa.

Quando ajuste fino é a escolha errada

Evite ajuste fino se:

Seu maior problema é fatos faltantes ou que mudam (geração aumentada por recuperação é melhor).
Você não consegue produzir de forma confiável alvos de treinamento limpos.
Você precisa de auditabilidade e citações (ajuste fino não vai dizer “de onde” veio uma resposta).
O domínio envolve dados sensíveis e você não tem controles fortes de privacidade (risco de memorização).

Dados: o fator decisivo

Como são dados “bons” para ajuste fino

Representativos do tráfego real (incluindo casos de borda)
Saídas “ouro” claras (idealmente escritas por especialistas)
Regras de formatação consistentes
Inclui exemplos negativos quando apropriado (por exemplo, “recuse se…”)
Captura todo o contexto de instrução que o modelo verá em produção

De quanto dado você precisa?

Regras práticas (bem aproximadas):

Formatação / aderência a esquema JSON: 200–2.000 exemplos podem ajudar muito.
Transformação de estilo do domínio: 1.000–20.000 exemplos.
Políticas de decisão complexas / tarefas amplas: 10.000+ exemplos mais avaliação forte.

Dados sintéticos: poderosos, mas arriscados

Usar dados gerados por modelo pode iniciar conjuntos de dados (bootstrap), mas também pode criar ciclos de feedback e amplificar erros. Use para expandir cobertura e depois valide com humanos e logs do mundo real.

Veja também: Dados Sintéticos para IA Generativa (GenAI)

Um “Guia de Ajuste Fino” passo a passo (fluxo de trabalho recomendado)

1) Defina o comportamento-alvo com precisão

Escreva uma especificação:

Entradas permitidas
Esquema de saída / formatação
Restrições de segurança e comportamento de recusa
Exemplos de saídas corretas vs incorretas

Isso vira sua rubrica de avaliação e template de dados de treinamento.

2) Construa cedo um arcabouço de avaliação

Você quer:

Um conjunto de teste estático (separado para teste (held-out)) com casos representativos
Checagens automatizadas: validade de JSON, conformidade com esquema, regras de regex
Avaliação humana para dimensões subjetivas (tom, utilidade)
Métricas específicas da tarefa (por exemplo, correspondência exata, acurácia de citação)

3) Faça uma linha de base com construção de prompts

Crie:

Um prompt de sistema forte
3–10 exemplos few-shot
Restrições claras de saída

Se você conseguir atingir suas metas de qualidade com construção de prompts, pare aqui.

4) Adicione geração aumentada por recuperação se for necessário fundamentar conhecimento

Meça separadamente:

Recall@k da recuperação (buscamos o documento certo?)
Fidelidade da resposta (a resposta corresponde ao texto recuperado?)

5) Faça ajuste fino apenas depois de identificar modos de falha persistentes

Alvos típicos de ajuste fino:

Deriva na formatação de saída
Conformidade inconsistente com políticas
Fraseado ou classificações específicas do domínio
Formatos de invocação de ferramentas

6) Escolha um método de ajuste

Comece com ajuste fino eficiente em parâmetros (LoRA/adaptadores) por custo e velocidade de iteração.
Use ajuste fino supervisionado para tarefas “faça X dado Y” com alvos claros.
Use ajuste por preferências (DPO) quando você tiver rótulos de preferência ou conseguir criá-los de forma confiável.
Use pré-treinamento contínuo apenas se você realmente precisar de fluência mais profunda no domínio e tiver muito texto do domínio.

7) Treine, avalie e faça testes de estresse

Avalie:

Robustez dentro e fora do domínio
Casos extremos de cauda longa
Comportamentos de segurança (recusas, temas sensíveis)
Regressão em relação às capacidades da linha de base

8) Implante com monitoramento e rollback

Boas práticas em produção:

Implantação canário (canary rollout)
Monitorar validade do esquema, taxas de recusa, relatos de alucinação
Capturar feedback do usuário e exemplos de falhas para a próxima iteração

Exemplos práticos

Exemplo 1: Assistente de suporte ao cliente para um produto SaaS

Problema: O assistente responde perguntas sobre funcionalidades e políticas do produto.

Tentativa só com prompt:
Funciona para o tom, mas erra detalhes (políticas mudaram) e alucina funcionalidades.
Solução com geração aumentada por recuperação:
Indexar docs do help center + guias operacionais internos; exigir citações.
Ajuste fino (opcional):
Adicionar ajuste fino para estrutura de resposta consistente:
- Sempre pedir ID da conta quando necessário
- Sempre fornecer um template de troubleshooting passo a passo
- Sempre incluir uma seção “Próximos passos”

Conclusão: Geração aumentada por recuperação para correção, ajuste fino para fluxo de trabalho e estrutura consistentes.

Exemplo 2: Extração de faturas em alto volume para JSON

Problema: Extrair campos de e-mails e PDFs bagunçados (após OCR). A saída deve corresponder a um esquema rígido.

A construção de prompts chega a ~90–95% de JSON válido, mas falhas ocasionais são caras.
Geração aumentada por recuperação não ajuda muito (a tarefa não é “conhecimento”, é “formato e mapeamento”).
Ajuste fino com 1.000–5.000 exemplos rotulados melhora:
- Aderência ao esquema
- Normalização de campos (datas, moedas)
- Menor verbosidade

Conclusão: Ajuste fino é ideal para predição estruturada repetida com requisitos rigorosos.

Exemplo 3: Bot interno de “como fazer” para engenharia

Problema: Engenheiros perguntam sobre procedimentos internos de deploy.

Só com construção de prompts: inconsistente, às vezes inventa passos.
Ajuste fino: risco de incorporar procedimentos que mudam com frequência.
Melhor abordagem: geração aumentada por recuperação com guias operacionais, mais uma instrução para “citar comandos exatos” e “se estiver faltando, fazer perguntas de esclarecimento”.

Conclusão: Quando procedimentos mudam, prefira geração aumentada por recuperação em vez de ajuste fino.

Combinando estratégias de forma eficaz (arquiteturas vencedoras comuns)

Construção de prompts + geração aumentada por recuperação

Padrão corporativo mais comum:

O prompt define comportamento e segurança
A geração aumentada por recuperação fornece a verdade-base
Ferramentas opcionais (criação de chamado (ticket), consultas) oferecem ações estruturadas

Ajuste fino + construção de prompts

Faça ajuste fino para internalizar o “estilo da casa (house style)” e o esquema; mantenha o prompt mínimo:

Menor latência
Menos fragilidade de engenharia de prompt
Ainda flexível para instruções por requisição

Ajuste fino + geração aumentada por recuperação

Use ajuste fino para:

Ensinar o modelo a usar corretamente o contexto recuperado
Impor formato de citação e “não responda se não estiver no contexto”
Melhorar reescrita de consultas para recuperação

Ressalva: Mesmo com ajuste fino, você ainda precisa de avaliação de recuperação; ajuste fino não corrige recuperação ruim.

Considerações de custo, latência e governança

Custo e latência

Os custos de construção de prompts escalam com tamanho do prompt e tamanho da saída.
A geração aumentada por recuperação adiciona latência de recuperação (frequentemente dezenas a centenas de ms) e aumenta tokens de entrada.
O ajuste fino aumenta o custo inicial, mas pode reduzir o custo por requisição ao encurtar prompts e melhorar a taxa de sucesso na primeira tentativa.

Privacidade e conformidade

O ajuste fino pode memorizar inadvertidamente strings sensíveis. Use:
- Minimização de dados
- Redação de PII
- Filtragem no momento do treinamento
- Controles de acesso e auditorias

A geração aumentada por recuperação frequentemente fornece melhor auditabilidade: você pode registrar fontes recuperadas e mostrar citações.

Manutenção

Prompts são fáceis de atualizar.
Índices de geração aumentada por recuperação exigem pipelines contínuos de documentos e checagens de qualidade.
Modelos com ajuste fino exigem versionamento, testes de regressão e retreinamento periódico.

Armadilhas comuns (e como evitá-las)

Ajuste fino para corrigir erros factuais: geralmente é a ferramenta errada; use geração aumentada por recuperação.
Treinar com saídas bagunçadas: o modelo vai aprender a bagunça. Padronize os alvos.
Sem conjunto de avaliação separado (held-out): você não saberá se melhorou ou apenas superajustou.
Ignorar avaliação de recuperação: o sucesso da geração aumentada por recuperação depende de encontrar o contexto certo.
Exagerar em exemplos few-shot: pode inflar prompts; considere ajuste fino se padrões estáveis se repetirem.
Ciclos de feedback com dados sintéticos: mantenha um conjunto âncora de “dados reais” e revisão humana.

Checklist rápido: escolhendo sua estratégia de adaptação

Faça estas perguntas em ordem:

A falha se deve a conhecimento faltante ou que muda?
Sim → Geração aumentada por recuperação.
Não → continue.
Um prompt mais claro + exemplos consegue impor o comportamento de forma confiável?
Sim → Construção de prompts.
Não → continue.
Você precisa de formatação/conformidade com política consistente em escala, com alvos mensuráveis?
Sim → Ajuste fino (comece com ajuste fino eficiente em parâmetros/ajuste fino supervisionado; considere ajuste por preferências se aplicável).
Você também precisa de citações / fundamentação em fontes?
Sim → Geração aumentada por recuperação + (construção de prompts ou ajuste fino).

Perspectiva final

Um bom “guia de ajuste fino” tem menos a ver com truques de treinamento e mais a ver com escolher a intervenção mais simples que ataca o verdadeiro gargalo:

Se você precisa de instruções melhores, melhore o prompt.
Se você precisa de conhecimento melhor, adicione recuperação.
Se você precisa de melhor comportamento padrão, faça ajuste fino — com cuidado, dados de alta qualidade e avaliação rigorosa.

Quando bem executadas, essas estratégias se complementam: a construção de prompts define a intenção, a geração aumentada por recuperação fornece a verdade, e o ajuste fino faz o sistema se comportar de forma confiável como você quer em produção.