Zero, um e poucos exemplos
Escolha a quantidade de exemplos.
Zero, um e poucos exemplos é uma aula grátis de AI Prompt Engineering 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 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 espectro de exemplos
Exemplos indicam o número de demonstrações rotuladas inseridas na instrução antes da consulta em tempo real. A abordagem sem exemplos depende inteiramente dos conhecimentos prévios pré-treinados do modelo; a abordagem com poucos exemplos condiciona o modelo a uma pequena distribuição específica da tarefa no momento da inferência, sem atualizar nenhum peso.
Isso é o aprendizado em contexto (ICL): o transformador trata os exemplos como parte da sequência e realiza implicitamente uma espécie de regressão baseada em meta-aprendizado sobre eles. A escolha de k, o número de exemplos, é um hiperparâmetro que você ajusta empiricamente, não uma prática recomendada fixa.
from dataclasses import dataclass
@dataclass
class ICLConfig:
k: int # number of demonstrations
selection: str # 'static' | 'dynamic'
order: str # 'random' | 'similarity' | 'curriculum'
# Zero-shot is simply k=0
cfg = ICLConfig(k=0, selection='static', order='random')Quando o aprendizado sem exemplos vence
Prefira a abordagem sem exemplos quando a tarefa estiver bem representada no pré-treinamento (resumo, tradução e classificação comum) e quando os exemplos puderem influenciar o formato da saída. Para modelos ajustados para seguir instruções, uma instrução direta e clara acompanhada de um esquema de saída geralmente supera exemplos que ancoram sutilmente o estilo.
A abordagem sem exemplos também minimiza o custo de tokens e a latência, além de evitar o viés do rótulo majoritário, no qual o modelo prevê em excesso a classe que domina seus exemplos.
# Zero-shot with explicit schema beats vague few-shot
PROMPT = (
'Classify sentiment as POSITIVE, NEGATIVE, or NEUTRAL.\n'
'Respond with only the label.\n\n'
'Text: ' + user_text + '\nLabel:'
)Um exemplo como âncora de formato
A abordagem com um exemplo é especialmente eficaz quando a tarefa é conceitualmente clara, mas o formato da saída é incomum ou rigoroso. Uma única demonstração ensina o formato exato (chaves JSON, delimitadores e uso de maiúsculas e minúsculas) com muito mais confiabilidade do que uma descrição em prosa.
Use um exemplo quando quiser restringir a estrutura sem gastar tokens nem correr o risco da assimetria na distribuição de rótulos introduzida por vários exemplos.
ONE_SHOT = (
'Extract entities as JSON.\n\n'
'Input: Apple released the iPhone in Cupertino.\n'
'Output: {"org": ["Apple"], "product": ["iPhone"], "loc": ["Cupertino"]}\n\n'
'Input: ' + query + '\nOutput:'
)Poucos exemplos e a curva de k
O desempenho em relação a k raramente é monotônico. Normalmente ele aumenta, atinge um platô e depois piora à medida que os exemplos ocupam o contexto, diluem a atenção e afastam a consulta ativa do foco de recência do modelo.
Faça empiricamente uma varredura de k em {1, 2, 4, 8, 16} usando um conjunto reservado para validação. O k ideal depende da complexidade da tarefa, do comprimento dos exemplos e do aproveitamento efetivo do contexto pelo modelo, que geralmente fica muito abaixo da janela anunciada.
def sweep_k(eval_set, candidates, ks=(1,2,4,8,16)):
results = {}
for k in ks:
acc = evaluate(build_prompt(candidates[:k]), eval_set)
results[k] = acc
return max(results, key=results.get)Por que o ICL funciona: inferência implícita
As pesquisas descrevem o ICL como o modelo realizando inferência bayesiana implícita: as demonstrações ajudam a localizar o conceito latente da tarefa que o modelo já aprendeu durante o pré-treinamento. Os exemplos funcionam como evidências que restringem a distribuição posterior sobre as tarefas, e não como conhecimento novo.
Isso explica uma descoberta contraintuitiva: até mesmo rótulos incorretos nas demonstrações podem preservar grande parte da precisão, porque o sinal dominante é o formato e o espaço de rótulos, não o mapeamento entre entrada e rótulo em si.
# Min, Lyu et al. (2022): label correctness matters less than
# - the input distribution
# - the label space (which classes exist)
# - the format / structure
# Implication: invest in representative inputs + valid label setOrçamento de tokens e compromissos de custo
Cada exemplo consome contexto e dinheiro. Com demonstrações longas, quatro exemplos podem ser muito maiores do que a consulta. Calcule uma métrica de custo por ponto de precisão: se k=8 proporcionar 0,5% a mais do que k=4 ao custo do dobro de tokens, k=4 será melhor em produção.
Para fluxos de processamento de alta vazão, prefira armazenar em cache o bloco estático de exemplos da instrução, para que demonstrações repetidas sejam cobradas e processadas uma única vez.
def cost_efficiency(acc_by_k, tokens_by_k, price_per_1k):
return {
k: acc_by_k[k] / (tokens_by_k[k] / 1000 * price_per_1k)
for k in acc_by_k
}
# Pick the k maximizing accuracy per dollar, not raw accuracyViés do rótulo majoritário e da posição
As instruções com poucos exemplos carregam vieses ocultos. O viés do rótulo majoritário faz o modelo favorecer a classe mais frequente nos exemplos. O viés de recência dá peso excessivo ao último exemplo. O viés de tokens comuns favorece tokens que aparecem com frequência.
Técnicas de calibração, como a calibração contextual, estimam a distribuição prévia do modelo em uma entrada sem conteúdo (por exemplo, o token N/A) e a eliminam por divisão, estabilizando drasticamente os classificadores com poucos exemplos.
# Contextual calibration (Zhao et al. 2021)
p_cf = model_probs(prompt_with_input('N/A')) # content-free prior
W = 1.0 / p_cf # diagonal correction
def calibrated(probs):
return normalize(W * probs)Equilibrando o conjunto de exemplos
Para combater o viés do rótulo majoritário, equilibre as classes nas demonstrações e varie a ordem delas. Para k=4 em uma classificação binária, use 2 exemplos positivos e 2 negativos, embaralhados, em vez de uma proporção de 3:1.
Em tarefas de geração, equilibre as dimensões importantes (comprimento, tom e dificuldade) para que o modelo não se restrinja a um único padrão que tenha visto com mais frequência.
import random
def balanced_demos(pool, k, label_fn):
by_label = {}
for ex in pool:
by_label.setdefault(label_fn(ex), []).append(ex)
per = k // len(by_label)
picks = [e for lst in by_label.values() for e in random.sample(lst, per)]
random.shuffle(picks)
return picksPoucos exemplos versus ajuste fino
Usar poucos exemplos é a ferramenta certa quando a tarefa muda com frequência, os dados são escassos ou não é possível hospedar um modelo ajustado. O ajuste fino é melhor quando você tem milhares de exemplos, precisa da menor latência por chamada ou quer incorporar o formato ao modelo para manter as instruções curtas.
Um caminho comum em produção é: criar um protótipo com poucos exemplos, coletar as trajetórias bem-sucedidas e então destilá-las em um modelo ajustado para eliminar completamente os tokens dos exemplos.
# Decision heuristic
if num_labeled < 500 or task_volatility == 'high':
strategy = 'few-shot ICL'
elif latency_budget_ms < 200 or prompt_token_cost_dominant:
strategy = 'fine-tune + zero-shot'
else:
strategy = 'few-shot now, distill later'Tarefas de raciocínio exigem mais do que exemplos
Para raciocínio em várias etapas, pares brutos de pergunta e resposta com poucos exemplos podem prejudicar: o modelo aprende a saltar diretamente para uma resposta que não consegue justificar. Combine poucos exemplos com demonstrações de cadeia de raciocínio que mostrem a trajetória do raciocínio, e não apenas o rótulo final.
A quantidade de exemplos interage com a profundidade do raciocínio; com frequência, 2 exemplos de cadeia de raciocínio de alta qualidade superam 8 exemplos que mostram apenas respostas em avaliações de aritmética e lógica.
COT_SHOT = (
'Q: A shop had 23 apples, used 20, bought 6 more. How many now?\n'
'A: Start 23, minus 20 leaves 3, plus 6 is 9. Answer: 9\n\n'
'Q: ' + question + '\nA:'
)Uma estrutura de avaliação para k
Trate a seleção da quantidade de exemplos como uma busca empírica apoiada por uma estrutura de avaliação. Separe um conjunto de validação, controle a ordem dos exemplos usando várias sementes e informe a média e a variância, pois a precisão com poucos exemplos pode variar vários pontos apenas por causa da ordem.
Registre as contagens de tokens e a latência para cada k, para que a escolha final otimize o objetivo completo, e não apenas a precisão.
def harness(pool, val, ks, seeds=5):
report = {}
for k in ks:
accs = []
for s in range(seeds):
demos = balanced_demos(pool, k, label_fn)
accs.append(evaluate(build_prompt(demos), val))
report[k] = (mean(accs), stdev(accs))
return reportVerificação rápida
Teste sua compreensão da seleção da quantidade de exemplos e do viés do ICL.
Recapitulação
Principais conclusões:
ké um hiperparâmetro ajustável; faça uma varredura dele e observe a curva de aumento, platô e queda.- A abordagem sem exemplos é adequada para tarefas conhecidas; um exemplo ancora formatos rigorosos; poucos exemplos condicionam o modelo a uma distribuição de tarefas.
- O ICL funciona localizando uma tarefa pré-treinada, portanto o formato e o espaço de rótulos predominam sobre a correção dos rótulos.
- Combata os vieses do rótulo majoritário, de recência e de tokens comuns equilibrando, embaralhando e aplicando calibração contextual.
- Otimize a precisão por unidade monetária, combine tarefas de raciocínio com exemplos de cadeia de raciocínio e destile instruções estáveis com poucos exemplos em modelos ajustados.
Perguntas Frequentes
A aula “Zero, um e poucos exemplos” é grátis?
Sim — o texto completo de “Zero, um e poucos exemplos” é 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 “Zero, um e poucos exemplos”?
Escolha a quantidade de exemplos. 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 1 de 4.
Quanto tempo leva a aula “Zero, um e poucos exemplos”?
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
- Zero, um e poucos exemplos
- Criando exemplos eficazes
- Ordenação e atualidade dos exemplos
- Seleção dinâmica de poucos exemplos