0Pricing
AI Prompt Engineering · Aula

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 index

Solicitaçã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 + diversity

Latê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 prefetch

Tensã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 out

Verificaçã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

  1. Zero, um e poucos exemplos
  2. Criando exemplos eficazes
  3. Ordenação e atualidade dos exemplos
  4. Seleção dinâmica de poucos exemplos
← Voltar para AI Prompt Engineering