AI Prompt Engineering · Aula

Quando fazer ajuste fino

Identifique os sinais de que as solicitações chegaram ao limite.

Quando fazer ajuste fino é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O ajuste fino é uma decisão baseada em evidências

O ajuste fino só é justificável quando você consegue apontar dados mostrando que o uso de instruções atingiu um limite. O gatilho nunca é um palpite — é uma avaliação com dados separados na qual a melhor instrução possível, sem artifícios, estabiliza abaixo do seu padrão de qualidade apesar de você subir a escada de otimização.

O ajuste troca flexibilidade por consistência, menor custo por chamada e comportamento aprendido
O custo inclui um fluxo de dados, infraestrutura de avaliação e reajustes à medida que o modelo base muda
Você precisa conseguir identificar a falha específica que o uso de instruções não conseguiu corrigir

Sinal 1: o platô das instruções

O sinal mais claro é um platô em um conjunto de avaliação congelado. Você adiciona exemplos, decompõe a tarefa e adiciona verificadores — e a pontuação para de melhorar enquanto os erros permanecem sistemáticos, não aleatórios.

Erros residuais sistemáticos (o modelo lida incorretamente de forma consistente com a mesma estrutura) significam que é difícil obter esse comportamento por meio de instruções. Esse é um problema adequado para ajuste. Erros aleatórios e dispersos geralmente significam que a instrução ou os dados ainda contêm ruído — continue iterando.

# Track eval score vs prompt-iteration; flat tail = plateau
scores = [0.62, 0.71, 0.78, 0.79, 0.795, 0.796]  # diminishing returns
def plateaued(scores, window=3, eps=0.01):
    tail = scores[-window:]
    return (max(tail) - min(tail)) < eps

print(plateaued(scores))  # True -> prompting has stalled

Sinal 2: o comprimento da instrução se torna o produto

Quando a instrução cresce para milhares de tokens de exemplos e regras apenas para manter a qualidade, você está arcando com uma penalidade de latência e custo em cada chamada para simular um comportamento aprendido.

Se esses tokens codificam um comportamento estável e repetitivo (um formato fixo, um estilo consistente ou uma decisão de roteamento), o ajuste fino pode incorporá-los aos pesos — reduzindo a instrução em uma ordem de grandeza e preservando o comportamento. Isso é a destilação de instruções, o caso de uso legítimo mais comum do ajuste.

Sinal 3: limite rígido de latência ou custo

Se você precisa que um modelo menor, mais rápido e mais barato reproduza o comportamento de um modelo maior em uma tarefa específica, o ajuste é a ferramenta adequada. Você destila as saídas do modelo grande em um modelo pequeno ajustado.

Isso se justifica quando: o volume está acima do ponto de equilíbrio, o orçamento de latência é apertado e a tarefa é específica o suficiente para que um modelo pequeno consiga dominá-la. Fora dessas condições, o custo adicional de engenharia não compensa.

# Distillation data: teacher (big model) labels -> student (small) trains
def make_distill_pair(prompt, teacher_fn):
    completion = teacher_fn(prompt)  # high-quality big-model output
    return {'messages': [
        {'role': 'user', 'content': prompt},
        {'role': 'assistant', 'content': completion},
    ]}

Sinal 4: formato ou estilo idiossincrático

Algumas saídas são tão específicas que descrevê-las custa mais do que demonstrá-las em grande escala: uma DSL proprietária, uma voz de escrita própria da empresa com milhares de microrregras ou um esquema de domínio rígido com inúmeros campos condicionais.

Quando a conformidade com o formato precisa ser quase perfeita e há regras demais para enumerar em uma instrução, centenas de exemplos ensinam o padrão com mais confiabilidade do que um texto em prosa. O ajuste é excelente para internalizar estruturas implícitas que resistem a instruções explícitas.

Sinal 5: comportamento ao qual o modelo resiste

Às vezes, um modelo entra em conflito com uma instrução: continua adicionando ressalvas que você proibiu, recusa uma tarefa inofensiva ou volta ao estilo padrão sob carga. Se instruções fortes e repetidas, juntamente com exemplos, não conseguem suprimir o comportamento de forma confiável, essa resistência é uma predisposição incorporada aos pesos base.

O ajuste pode substituir essas predisposições. Mas confirme primeiro que a resistência é genuína e não um problema de clareza da instrução — atribuir a causa errada à resistência leva a execuções de treinamento desnecessárias.

Antissinais: quando NOT ajustar

É igualmente importante reconhecer falsos alarmes. NÃO faça ajuste fino quando:

A lacuna é de conhecimento — recupere-o; o ajuste incorpora fatos desatualizados e com perdas
A especificação ainda está mudando semanalmente — você terá de treinar novamente o tempo todo
Você tem menos de algumas centenas de exemplos limpos — pouco sinal e alto risco de sobreajuste
Os erros são aleatórios, não sistemáticos — os dados ou a instrução ainda contêm ruído
Você não possui uma estrutura de avaliação — não é possível saber se o ajuste ajudou

Critério de prontidão dos dados

A qualidade do ajuste fino é limitada pela qualidade dos dados. Antes de se comprometer, passe por uma verificação de prontidão: exemplos suficientes, equilibrados entre os casos importantes para você, rótulos consistentes entre si e ausência de vazamentos que inflacionem as pontuações da avaliação.

Algumas centenas de exemplos meticulosamente selecionados valem mais do que dezenas de milhares de exemplos com ruído. Se seus rótulos discordarem entre si, o modelo aprenderá o ruído.

def data_ready(examples, min_n=300, max_dupe_ratio=0.05):
    n = len(examples)
    texts = [e['messages'][0]['content'] for e in examples]
    dupe_ratio = 1 - (len(set(texts)) / n)
    return n >= min_n and dupe_ratio <= max_dupe_ratio

# Returns False until you have enough deduped, curated examples

Escolha o método de ajuste

Nem todo ajuste envolve treinamento com todos os pesos. Relacione o método ao sinal:

LoRA / adaptadores — baratos, rápidos e reversíveis; ideais para destilação de estilo e formato
Ajuste fino completo — mais pesado; para mudanças comportamentais profundas em modelos abertos capazes
Ajuste por preferência (no estilo DPO) — quando você tem avaliações pareadas de bom/ruim, em vez de respostas corretas de referência

Comece pelo método mais leve exigido pelo sinal. Os adaptadores no estilo LoRA abrangem a maioria dos casos de produção por uma fração do custo.

Protocolo de compromisso prévio

Antes de iniciar uma execução de treinamento, defina o experimento para que o resultado seja interpretável:

Congele um conjunto de avaliação separado que o modelo nunca verá durante o treinamento
Registre a melhor pontuação de referência usando apenas instruções nesse conjunto
Estabeleça antecipadamente a melhoria-alvo e o teto de custo
Defina a reversão: se o modelo ajustado não superar a linha de base pela melhoria-alvo, coloque a instrução em produção

Sem uma linha de base e um alvo definidos previamente, você não consegue provar que o ajuste compensou seu custo.

Reunindo os sinais

Combine os sinais em um único critério de prosseguir ou não prosseguir. O ajuste só deve avançar quando as instruções tiverem plateaued AND os dados estiverem prontos AND a lacuna for de comportamento — não quando um único sinal aparecer isoladamente.

def should_fine_tune(plateaued, data_ready, gap_is_behavior,
                     spec_stable, has_eval_harness):
    return all([
        plateaued,        # prompting stalled on frozen eval
        data_ready,       # enough clean, deduped examples
        gap_is_behavior,  # not a knowledge gap (else use RAG)
        spec_stable,      # task definition has settled
        has_eval_harness, # can measure the lift
    ])

print(should_fine_tune(True, True, True, True, True))  # True -> proceed

Verificação rápida

Em um conjunto de avaliação congelado, os erros de um modelo são aleatórios e dispersos entre muitos tipos diferentes de entrada, e a pontuação ainda aumenta quando você ajusta os exemplos. O que isso indica sobre a prontidão para o ajuste fino?

Recapitulação

Faça ajuste fino com base em evidências, não em intuição. Os sinais legítimos são: um platô verdadeiro com erros sistemáticos, um comprimento de instrução que se tornou o produto, um limite rígido de latência ou custo, formatos idiossincráticos ou um comportamento ao qual o modelo base resiste.

Antissinais: lacunas de conhecimento, especificações em mudança, poucos dados, erros aleatórios e ausência de uma estrutura de avaliação
Passe por um critério de prontidão dos dados antes do treinamento — a qualidade limita o resultado
Escolha primeiro o método mais leve (no estilo LoRA) exigido pelo sinal
Defina previamente uma avaliação congelada, uma linha de base, uma melhoria-alvo e uma reversão
Prossiga somente quando houver um platô AND os dados estiverem prontos AND houver uma lacuna de comportamento

Perguntas Frequentes

A aula “Quando fazer ajuste fino” é grátis?

Sim — o texto completo de “Quando fazer ajuste fino” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Quando fazer ajuste fino”?

Identifique os sinais de que as solicitações chegaram ao limite. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Quando fazer ajuste fino”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para AI Prompt Engineering