AI Engineering Academy · Aula

Quando o ajuste fino supera a engenharia de prompts

Quando o ajuste fino supera a engenharia de prompts é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 1 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 Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.

A principal compensação

Quando você precisa que um LLM se comporte de uma maneira específica, há duas opções fundamentais: engenharia de prompts (dizer ao modelo o que fazer no momento da inferência usando prompts cuidadosamente elaborados) ou ajuste fino (ensinar novos comportamentos ao modelo treinando-o com exemplos). Ambas podem alcançar resultados semelhantes em muitas tarefas, mas diferem significativamente em custo, velocidade, flexibilidade e no limite de qualidade que conseguem atingir.

Quando o uso de prompts é melhor

O uso de prompts quase sempre é o ponto de partida correto. Ele não exige infraestrutura de treinamento, produz resultados em poucas horas, pode ser atualizado instantaneamente sem novo treinamento e funciona bem para tarefas que o modelo básico já executa de maneira competente. Comece usando prompts para: tarefas em que GPT-4o ou Claude já produz resultados aceitáveis com instruções claras; requisitos que mudam rapidamente; casos de uso de baixo volume; e situações em que você ainda está explorando o espaço do problema.

# Prompting is sufficient for most well-defined tasks
system_prompt = '''
You are a customer support agent for TechCorp. Your tone is friendly but professional.
Always:
1. Acknowledge the customer's issue in the first sentence
2. Provide step-by-step solutions with numbered lists
3. End with 'Is there anything else I can help you with?'
Never: reveal pricing, discuss competitors, or make promises about future features.
'''

# With clear instructions, GPT-4o handles this well - no fine-tuning needed
# Before investing in fine-tuning, prove prompting is insufficient

Consistência na adesão ao estilo e ao formato

O ajuste fino é melhor quando você precisa de um formato de saída rigorosamente consistente que o uso de prompts não consegue fornecer de maneira confiável. Se sua aplicação exige conformidade total com um esquema JSON específico, um formato de documento precisamente estruturado ou um estilo de escrita muito específico, diferente da saída natural do modelo, um ajuste fino com algumas centenas de exemplos pode alcançar uma consistência quase perfeita, que nem mesmo o prompt mais cuidadosamente elaborado consegue igualar.

# Problem: prompting gives 90% format compliance - 10% failures cause downstream errors
# Prompt approach (unreliable)
system = 'Always respond with JSON: {"category": "...", "priority": 1-5, "tags": [...]}'
# 1 in 10 responses adds explanation text, omits a field, or uses strings for priority

# Fine-tuned approach: train on 500 examples of perfect output
# Training example format:
train_example = {
    'messages': [
        {'role': 'system', 'content': 'Classify customer support tickets.'},
        {'role': 'user', 'content': 'My order is late and I need it for tomorrow.'},
        {'role': 'assistant', 'content': '{"category": "shipping", "priority": 4, "tags": ["late_delivery", "urgent"]}'}
    ]
}
# After fine-tuning: 99.5%+ format compliance with minimal system prompt

Conhecimento de domínio proprietário

O ajuste fino é a escolha correta quando o modelo precisa aprender conhecimentos que não existem nos dados públicos de treinamento: as convenções internas de programação da sua empresa, uma taxonomia proprietária para classificar documentos, terminologia jurídica ou médica especializada de um domínio específico ou as diretrizes de voz e estilo da sua marca. Esse conhecimento não pode ser transmitido de maneira eficaz por meio de exemplos no prompt, pois o volume de exemplos excede o que cabe em uma janela de contexto.

# Example: Internal code style with dozens of company-specific conventions
# Too many rules to fit in a prompt effectively:

# Company conventions (partial list of 200+):
# - Use AppException instead of RuntimeError
# - Repositories are named FooRepository not FooRepo
# - Service methods use handle_verb_noun naming not do_action
# - Config values go through AppConfig.get(), never os.environ directly
# - ... 196 more conventions

# Prompting: you can include ~20 conventions before the model starts ignoring them
# Fine-tuning: train on 1000 examples of compliant vs. non-compliant code
# Result: model learns ALL conventions and applies them automatically

Redução do custo de tokens por meio de prompts mais curtos

Um dos principais argumentos econômicos a favor do ajuste fino é a compressão do prompt. Um prompt de sistema complexo pode ter 2.000 tokens. Se você chamar a API 10 milhões de vezes por dia, esses 2.000 tokens custarão dezenas de milhares de dólares por mês. Um modelo ajustado pode ser orientado por um prompt muito mais curto (50 a 100 tokens), pois as instruções detalhadas agora estão incorporadas nos pesos. Em grande escala, isso pode reduzir os custos dos tokens de entrada em 90% ou mais.

COST_PER_1K_TOKENS_INPUT = 0.0050  # gpt-4o
DAILY_REQUESTS = 10_000_000

# Base model with detailed prompt
base_prompt_tokens = 2000
daily_input_tokens_base = DAILY_REQUESTS * base_prompt_tokens
daily_cost_base = (daily_input_tokens_base / 1000) * COST_PER_1K_TOKENS_INPUT

# Fine-tuned model with short prompt
fine_tuned_prompt_tokens = 50
daily_input_tokens_ft = DAILY_REQUESTS * fine_tuned_prompt_tokens
daily_cost_ft = (daily_input_tokens_ft / 1000) * COST_PER_1K_TOKENS_INPUT

print(f'Base model daily input cost: ${daily_cost_base:,.2f}')
print(f'Fine-tuned model daily input cost: ${daily_cost_ft:,.2f}')
print(f'Monthly savings: ${(daily_cost_base - daily_cost_ft) * 30:,.2f}')
# Base: $100,000/day. Fine-tuned: $2,500/day. Savings: ~$2.9M/month

Melhoria da latência

Modelos ajustados podem melhorar a latência de duas maneiras. Primeiro, prompts mais curtos significam que o modelo processa menos tokens de entrada, reduzindo diretamente o tempo até o primeiro token. Segundo, modelos ajustados geralmente convergem mais rapidamente para o formato correto (produzem menos tokens na resposta antes de chegar à resposta propriamente dita), reduzindo o total de tokens de saída e o tempo de geração. Em aplicações sensíveis à latência, os dois efeitos se combinam e produzem melhorias significativas.

# Latency comparison (approximate)

# Base model with 2000-token prompt:
# - Input tokens processed: 2000 + 50 (user query) = 2050
# - Response: often starts with 'Sure! Here is...' (5-10 unnecessary tokens)
# - TTFT: ~800ms (more tokens to process)

# Fine-tuned model with 50-token prompt:
# - Input tokens processed: 50 + 50 (user query) = 100
# - Response: starts directly with the answer (no preamble)
# - TTFT: ~100ms (few tokens to process)

# For classification tasks (short outputs), this is a 5-8x latency improvement
# For generation tasks, improvement is less dramatic but still significant

print('Fine-tuning trades upfront training cost for per-request latency+cost savings')

O requisito mínimo de dados

O ajuste fino exige dados de treinamento — e esse costuma ser o maior obstáculo prático. Como regra geral: você precisa de pelo menos 50 a 100 exemplos de alta qualidade para observar qualquer melhoria significativa em relação ao modelo básico; de 500 a 1.000 exemplos para obter adesão confiável ao estilo e ao formato; e de 1.000 a 10.000 exemplos para adquirir uma quantidade significativa de conhecimento de domínio. Com menos de 50 exemplos, usar esses mesmos exemplos no contexto do prompt (poucos exemplos) geralmente supera o ajuste fino.

def estimate_fine_tuning_feasibility(num_examples: int, task_type: str) -> str:
    if num_examples < 50:
        return 'Insufficient data. Use few-shot prompting with these examples instead.'
    
    if task_type == 'format_adherence' and num_examples >= 100:
        return 'Fine-tuning recommended. Format consistency issues are hard to solve with prompting.'
    
    if task_type == 'style_matching' and num_examples >= 300:
        return 'Fine-tuning recommended. Consistent style requires enough examples to learn the distribution.'
    
    if task_type == 'domain_knowledge' and num_examples >= 500:
        return 'Fine-tuning recommended if knowledge is truly proprietary.'
    
    return 'Continue with advanced prompting (chain-of-thought, structured output) and revisit fine-tuning when you have more data.'

Os custos ocultos do ajuste fino

O ajuste fino tem custos ocultos significativos além da conta de computação. Você precisa de: infraestrutura para executar o treinamento (horas de GPU ou um serviço gerenciado); um processo de coleta de dados e controle de qualidade; avaliação para verificar se o modelo ajustado realmente melhora a métrica-alvo; um processo de implantação para o modelo personalizado; e um processo contínuo de manutenção para realizar novo treinamento quando o modelo básico for atualizado ou quando seus requisitos mudarem. Esses custos são reais e devem ser ponderados em relação aos benefícios.

fine_tuning_total_cost = {
    'data_collection_and_QA': '$5,000-$50,000',  # human annotation or LLM-generated
    'training_compute': '$50-$5,000',             # depends on model size and data volume
    'evaluation_pipeline': '$500-$2,000',         # building eval harness
    'deployment_infra': '$200-$2,000/month',      # serving the custom model
    'maintenance': '$1,000-$5,000/year',          # retraining when things change
    'opportunity_cost': 'weeks to months',        # time to build vs. prompt iteration
}

# Compare to prompting costs:
prompting_costs = {
    'data_needed': None,  # no training data required
    'infra': '$0 (uses existing API)',
    'maintenance': 'update prompts when needed',
    'time_to_production': 'hours to days'
}

Atualidade do conhecimento: RAG versus ajuste fino

O ajuste fino não pode atualizar o conhecimento em tempo real. O conhecimento de um modelo ajustado fica congelado no momento do treinamento. Para casos de uso que exigem informações atualizadas (eventos atuais, preços em tempo real e regulamentações em mudança), RAG é sempre melhor, pois pode recuperar informações recentes no momento da consulta. O ajuste fino é excelente para conhecimentos duradouros que raramente mudam: o estilo de escrita da sua empresa, a taxonomia de categorização de produtos ou o vocabulário técnico de um domínio bem estabelecido.

# Decision guide: RAG vs Fine-tuning vs Prompting

def choose_approach(requirements: dict) -> str:
    if requirements.get('knowledge_changes_frequently'):  # pricing, news, live data
        return 'RAG - knowledge must be updatable at query time'
    
    if requirements.get('needs_consistent_format') and requirements.get('high_volume'):
        return 'Fine-tuning - format adherence + cost savings at scale'
    
    if requirements.get('proprietary_domain_vocabulary'):
        return 'Fine-tuning - model needs to learn new terminology'
    
    if requirements.get('low_volume') or requirements.get('still_exploring'):
        return 'Prompting - fastest iteration, lowest cost'
    
    if requirements.get('combination_needed'):  # most production systems
        return 'Fine-tuning for style/format + RAG for dynamic knowledge'

A estrutura ideal para decidir sobre o ajuste fino

Use esta estrutura de decisão antes de se comprometer com o ajuste fino. Primeiro, comprove a necessidade: execute seu melhor prompt em 1.000 exemplos reais e meça a taxa de falhas. Segundo, quantifique o benefício: estime o ROI decorrente de maior precisão, menores custos de tokens ou melhor latência. Terceiro, avalie a viabilidade: você tem mais de 500 exemplos de treinamento de alta qualidade? Por fim, compare as alternativas: um modelo menor com um prompt melhor poderia alcançar o desempenho de um modelo maior com um prompt complexo?

Combinando uso de prompts e ajuste fino

Os melhores sistemas de produção frequentemente combinam as duas abordagens. Faça o ajuste fino para propriedades duradouras (formato da saída, tom e vocabulário do domínio) que raramente mudam e use prompts para propriedades dinâmicas (contexto da tarefa, documentos recuperados e preferências do usuário) que mudam a cada solicitação. Essa combinação oferece a confiabilidade e a eficiência de custos do ajuste fino sem sacrificar a flexibilidade do uso de prompts.

Verificação rápida

Teste sua compreensão sobre quando o ajuste fino é melhor do que o uso de prompts com base nesta lição.

Resumo da lição

Nesta lição, você aprendeu que o uso de prompts quase sempre é o ponto de partida correto, devido ao menor custo e à iteração mais rápida; o ajuste fino é melhor para adesão consistente ao formato, conhecimento de domínio proprietário e redução do custo de tokens em alto volume; e a atualidade do conhecimento é a especialidade do RAG — o ajuste fino não pode atualizar o que um modelo sabe durante a execução. A seguir, prepararemos um conjunto de dados de treinamento de alta qualidade para o ajuste fino.

Perguntas Frequentes

A aula “Quando o ajuste fino supera a engenharia de prompts” é grátis?

Sim — o texto completo de “Quando o ajuste fino supera a engenharia de prompts” é 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 Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.

O que vou aprender em “Quando o ajuste fino supera a engenharia de prompts”?

Identifique casos de uso nos quais o ajuste fino compensa mais do que a engenharia de prompts: adesão consistente ao estilo, conhecimento de domínio proprietário, redução dos custos de tokens por mei… Você pratica AI Engineering Academy 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 Engineering Academy?

Nenhuma experiência prévia é necessária. AI Engineering Academy 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 1 de 4.

Quanto tempo leva a aula “Quando o ajuste fino supera a engenharia de prompts”?

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 Engineering Academy?

Sim. Cada aula de AI Engineering Academy 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

Quando o ajuste fino supera a engenharia de prompts
Preparando um conjunto de dados de treinamento de alta qualidade
Ajuste fino com LoRA usando Hugging Face PEFT
Avaliando e implantando seu modelo ajustado

← Voltar para AI Engineering Academy