Seleção dinâmica de poucos exemplos
Recupere exemplos para cada consulta.
Seleção dinâmica de poucos exemplos é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 4 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.
De Exemplos Estáticos a Dinâmicos
O aprendizado com poucos exemplos estático usa os mesmos exemplos para todas as consultas. O aprendizado dinâmico com poucos exemplos recupera, para cada consulta, as demonstrações mais relevantes de um conjunto, condicionando o modelo com exemplos semelhantes à entrada atual.
Isso é aprendizado no contexto aumentado por recuperação: aumenta a relevância das demonstrações, um dos fatores de maior impacto na qualidade do ICL, especialmente em tráfego heterogêneo.
class DynamicSelector:
def __init__(self, pool, embedder, index):
self.pool = pool # candidate demonstrations
self.embed = embedder
self.index = index # ANN index over pool embeddings
def select(self, query, k):
q = self.embed(query)
ids = self.index.search(q, k)
return [self.pool[i] for i in ids]Vetorização do Conjunto de Exemplos
Pré-calcule vetores de representação para cada demonstração candidata e armazene-os em um índice de vizinhos mais próximos aproximados (FAISS, HNSW ou um banco de dados vetorial). No momento da consulta, faça embed da entrada uma vez e recupere as correspondências mais próximas.
Escolha um modelo de vetorização alinhado à semântica da sua tarefa; um modelo genérico pode agrupar com base em características superficiais, e não na dimensão que prevê o rótulo correto.
import numpy as np
def build_index(pool, embed):
vecs = np.stack([embed(d.input) for d in pool]).astype('float32')
vecs /= np.linalg.norm(vecs, axis=1, keepdims=True) # cosine via dot
index = HNSW(dim=vecs.shape[1])
index.add(vecs)
return indexSolicitação com kNN
O método canônico (Liu et al., 2022) recupera os k vizinhos mais próximos da consulta no conjunto rotulado e os utiliza como demonstrações. A seleção baseada em recuperação supera consistentemente a seleção aleatória, pois as demonstrações relevantes identificam melhor a tarefa e fornecem o espaço de rótulos adequado.
Os rótulos recuperados também atuam como um conhecimento prévio suave do classificador kNN, direcionando o modelo para as respostas dos vizinhos.
def knn_prompt(query, selector, k, build):
demos = selector.select(query, k)
demos = order_by_similarity(embed(query), demos) # most similar last
return build(demos, query)Recuperação Consciente da Diversidade
Uma seleção simples dos k primeiros resultados pode retornar quase duplicatas, desperdiçando contexto. Aplique MMR ou agrupamento aos candidatos recuperados para manter a relevância e, ao mesmo tempo, garantir que os exemplos escolhidos cubram aspectos distintos da consulta.
Isso é especialmente importante para entradas composicionais, nas quais diferentes subaspectos precisam de uma demonstração representativa.
def diverse_retrieve(query, selector, k, pool_n=30, lam=0.7):
cand = selector.select(query, pool_n)
q = embed(query)
return mmr_against_query(cand, q, k, lam) # relevance + diversityLatência e Orçamento de Recuperação
A seleção dinâmica acrescenta uma chamada de vetorização e uma consulta a um índice ANN a cada solicitação. Planeje esse custo: armazene em cache os vetores de consultas repetidas, agrupe as recuperações e mantenha o índice na memória.
Em sistemas com QPS alto, a etapa de recuperação deve levar menos de um milissegundo; caso contrário, o ganho de relevância será consumido pelo aumento da latência da cauda.
from functools import lru_cache
@lru_cache(maxsize=50_000)
def cached_embed(text):
return embed(text)
# Plus: warm in-RAM HNSW, batched search, async prefetchTensão entre Armazenamento em Cache e Exemplos Dinâmicos
Exemplos dinâmicos interrompem o armazenamento do prefixo da solicitação em cache porque o bloco de exemplos muda a cada consulta. Reduza esse efeito mantendo um preâmbulo estável armazenado em cache (instruções e alguns exemplos universais) e acrescentando depois dele apenas os exemplos recuperados e específicos da consulta.
Isso recupera a maior parte da economia proporcionada pelo armazenamento em cache, preservando a relevância por consulta na cauda.
prompt = (
STATIC_PREAMBLE # cached: instructions + anchor demos
+ render(diverse_retrieve(query, selector, k)) # dynamic tail
+ format_query(query)
)Evitando Vazamento entre Treino e Teste
Se a própria consulta estiver no conjunto (algo comum durante a avaliação), a recuperação poderá retornar a resposta exata, inflando as métricas. Sempre exclua a consulta e os vizinhos quase idênticos acima de um limiar de similaridade durante a avaliação.
Em produção, elimine duplicatas do conjunto e evite repetir a entrada anterior do próprio usuário como demonstração.
def leak_safe_select(query, selector, k, sim_cap=0.97):
cand = selector.select(query, k + 5)
q = embed(query)
cand = [d for d in cand if cos(q, d.emb) < sim_cap]
return cand[:k]Inicialização a Frio e Crescimento do Conjunto
No início, o conjunto é pequeno e a recuperação pode retornar correspondências fracas. Comece com um conjunto estático selecionado e depois aumente o conjunto usando registros de produção verificados, recalculando os vetores e reindexando em intervalos programados.
Acompanhe o uso e o resultado de cada demonstração para poder remover exemplos de baixo valor ou desatualizados e manter o índice enxuto.
def maybe_add_to_pool(trace, verified):
if verified and novelty(trace, index) > THRESH:
emb = embed(trace.input)
index.add(emb)
pool.append(Demo(trace.input, trace.output, trace.meta))Seleção Além da Similaridade
A relevância dos vizinhos mais próximos é um bom padrão, mas nem sempre é ideal. Seletores avançados ponderam a informatividade (a demonstração resolve a ambiguidade da consulta?), a diversidade e a cobertura de rótulos. Alguns métodos aprendem uma política de seleção que maximiza a acurácia posterior, em vez da similaridade bruta.
Considere a seleção como a escolha do conjunto de demonstrações que mais reduz a incerteza do modelo sobre esta consulta.
def select_by_uncertainty_reduction(query, pool, k):
base = entropy(model_probs(build([], query)))
gains = []
for d in pool:
h = entropy(model_probs(build([d], query)))
gains.append((d, base - h)) # info gain per demo
return [d for d, _ in sorted(gains, key=lambda x: -x[1])[:k]]Avaliando um Fluxo Dinâmico
Compare o sistema dinâmico com referências estáticas e aleatórias usando dados reservados e controlados contra vazamentos. Informe a acurácia, a distribuição das similaridades de recuperação, a latência de ponta a ponta e a taxa de acertos do cache.
Um sistema dinâmico que vence em acurácia, mas prejudica a reutilização do cache, pode ter impacto negativo no custo; avalie o objetivo completo, não apenas a qualidade.
def eval_pipeline(eval_set):
return {
'acc_dynamic': run(dynamic, eval_set),
'acc_static': run(static, eval_set),
'acc_random': run(random_sel, eval_set),
'p95_latency': latency_p95(),
'cache_hit': cache_hit_rate(),
}Arquitetura de Referência
De ponta a ponta: um conjunto verificado de exemplos, um modelo de vetorização, um índice ANN na memória, um seletor que aplica proteções contra vazamento, diversidade e ordenação por similaridade, um preâmbulo estável armazenado em cache e um ciclo de feedback que aumenta e reduz o conjunto.
Essa arquitetura transforma a solicitação com poucos exemplos em um sistema de recuperação com o rigor operacional que isso exige.
def answer(query):
demos = leak_safe_select(query, selector, k=4)
demos = mmr_against_query(demos, embed(query), 4)
demos = order_by_similarity(embed(query), demos)
prompt = STATIC_PREAMBLE + render(demos) + format_query(query)
out = llm(prompt)
log_for_pool_growth(query, out)
return outVerificação Rápida
Diagnostique um resultado de avaliação enganosamente forte.
Recapitulação
Principais conclusões:
- O aprendizado dinâmico com poucos exemplos recupera demonstrações para cada consulta, superando as abordagens aleatória e estática ao aumentar a relevância.
- Vetorialize o conjunto em um índice ANN; a solicitação por kNN é o padrão mais forte, ordenada por similaridade crescente.
- Adicione diversidade (MMR) e considere seletores de informatividade e redução de incerteza.
- Proteja-se contra vazamentos na recuperação, gerencie a latência e mantenha um preâmbulo estático armazenado em cache com uma cauda dinâmica.
- Aumente e reduza o conjunto usando registros verificados; avalie acurácia, latência e acertos do cache em conjunto.
Perguntas Frequentes
A aula “Seleção dinâmica de poucos exemplos” é grátis?
Sim — o texto completo de “Seleção dinâmica de 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 “Seleção dinâmica de poucos exemplos”?
Recupere exemplos para cada consulta. 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 4 de 4.
Quanto tempo leva a aula “Seleção dinâmica de 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