0Pricing
AI Prompt Engineering · Lección

Selección dinámica de ejemplos few-shot

Recupere ejemplos para cada consulta.

Selección dinámica de ejemplos few-shot es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.

De las demostraciones estáticas a las dinámicas

El aprendizaje few-shot estático utiliza los mismos ejemplos para cada consulta. El few-shot dinámico recupera las demostraciones más relevantes para cada consulta desde un conjunto, de modo que el modelo se condiciona con ejemplos parecidos a la entrada actual.

Esto es aprendizaje en contexto aumentado por recuperación: aumenta la relevancia de las demostraciones, uno de los factores que más influyen en la calidad del ICL, especialmente con tráfico 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]

Generación de embeddings del conjunto de demostraciones

Calcule previamente los embeddings de cada demostración candidata y almacénelos en un índice de vecinos más cercanos aproximados (FAISS, HNSW o una base de datos vectorial). En el momento de la consulta, genere el embedding de la entrada una sola vez y recupere las coincidencias principales.

Elija un modelo de embeddings alineado con la semántica de su tarea; un embedder genérico puede agrupar según características superficiales en lugar de hacerlo según la dimensión que predice la etiqueta correcta.

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

Prompting kNN

El método canónico (Liu et al., 2022) recupera los k vecinos más cercanos de la consulta desde el conjunto etiquetado y los utiliza como demostraciones. La selección basada en recuperación supera sistemáticamente a la selección aleatoria porque las demostraciones relevantes ayudan a identificar mejor la tarea y proporcionan el espacio de etiquetas adecuado.

Las etiquetas recuperadas también actúan como una distribución previa suave de un clasificador kNN, orientando al modelo hacia las respuestas de los vecinos.

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)

Recuperación consciente de la diversidad

Un top-k puro puede devolver duplicados casi idénticos y desperdiciar contexto. Aplique MMR o agrupación a los candidatos recuperados para conservar la relevancia y, al mismo tiempo, garantizar que las demostraciones elegidas cubran aspectos distintos de la consulta.

Esto es especialmente importante en entradas compositivas, donde cada subaspecto necesita una demostración 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

Latencia y presupuesto de recuperación

La selección dinámica añade una llamada para generar embeddings y una consulta al índice ANN en cada solicitud. Planifique este coste: almacene en caché los embeddings de consultas repetidas, agrupe las recuperaciones y mantenga el índice en memoria.

En sistemas con un QPS alto, el paso de recuperación debe tardar menos de un milisegundo; de lo contrario, la ganancia de relevancia queda anulada por el aumento de la latencia de cola.

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

Tensión entre la caché y las demostraciones dinámicas

Las demostraciones dinámicas impiden el almacenamiento en caché del prefijo del prompt porque el bloque de ejemplos cambia con cada consulta. Mitigue este efecto manteniendo un preámbulo estable en caché (instrucciones más algunos ejemplos universales) y añadiendo después únicamente las demostraciones recuperadas y específicas de la consulta.

Así recuperará la mayor parte del ahorro de la caché y conservará la relevancia específica de cada consulta en la parte final.

prompt = (
    STATIC_PREAMBLE          # cached: instructions + anchor demos
    + render(diverse_retrieve(query, selector, k))  # dynamic tail
    + format_query(query)
)

Cómo evitar la fuga entre entrenamiento y prueba

Si la propia consulta está en el conjunto (algo habitual durante la evaluación), la recuperación puede devolver la respuesta exacta e inflar las métricas. Durante la evaluación, excluya la consulta y los vecinos casi idénticos cuya similitud supere un umbral.

En producción, elimine los duplicados del conjunto y evite devolver como demostración la propia entrada anterior de un usuario.

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]

Arranque en frío y crecimiento del conjunto

Al principio, el conjunto es pequeño y la recuperación puede devolver coincidencias débiles. Inicialícelo con un conjunto estático seleccionado y, después, amplíelo a partir de trazas de producción verificadas, generando de nuevo los embeddings y reindexando según un calendario.

Registre el uso y el resultado de cada demostración para poder eliminar ejemplos de poco valor u obsoletos y mantener el índice optimizado.

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))

Selección más allá de la similitud

La relevancia de los vecinos más cercanos es un buen valor predeterminado, pero no siempre es óptima. Los selectores avanzados ponderan la capacidad informativa (¿resuelve la demostración la ambigüedad de la consulta?), la diversidad y la cobertura de etiquetas. Algunos métodos aprenden una política de selección que maximiza la exactitud posterior en lugar de la similitud bruta.

Plantee la selección como la elección del conjunto de demostraciones que más reduce la incertidumbre del 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]]

Evaluación de una canalización dinámica

Compare el método dinámico con referencias estáticas y aleatorias usando datos retenidos, con control de fugas. Informe de la exactitud, la distribución de las similitudes de recuperación, la latencia de extremo a extremo y la tasa de aciertos de la caché.

Un sistema dinámico que gana en exactitud, pero reduce drásticamente la reutilización de la caché, puede tener un balance negativo en términos de coste; evalúe el objetivo completo, no solo la calidad.

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(),
    }

Arquitectura de referencia

De extremo a extremo: un conjunto verificado de demostraciones, un modelo de embeddings, un índice ANN en memoria, un selector que aplica controles contra fugas, diversidad y ordenación por similitud, un preámbulo estable en caché y un ciclo de retroalimentación que amplía y depura el conjunto.

Esta arquitectura convierte el prompting few-shot en un sistema de recuperación con la disciplina operativa que ello implica.

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

Comprobación rápida

Diagnostique un resultado de evaluación engañosamente sólido.

Resumen

Conclusiones principales:

  • El few-shot dinámico recupera demostraciones para cada consulta y supera a los métodos aleatorios o estáticos al aumentar la relevancia.
  • Genere embeddings del conjunto en un índice ANN; el prompting kNN es un buen valor predeterminado, ordenado por similitud ascendente.
  • Añada diversidad (MMR) y considere selectores basados en la capacidad informativa o la reducción de incertidumbre.
  • Evite las fugas de recuperación, gestione la latencia y mantenga un preámbulo estático en caché con una parte final dinámica.
  • Amplíe y depure el conjunto a partir de trazas verificadas; evalúe conjuntamente la exactitud, la latencia y los aciertos de la caché.

Preguntas frecuentes

¿La lección «Selección dinámica de ejemplos few-shot» es gratis?

Sí — el texto completo de «Selección dinámica de ejemplos few-shot» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Selección dinámica de ejemplos few-shot»?

Recupere ejemplos para cada consulta. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Prompt Engineering?

No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Selección dinámica de ejemplos few-shot»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?

Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Zero-shot, one-shot y few-shot
  2. Diseño de ejemplos eficaces
  3. Orden y actualidad de los ejemplos
  4. Selección dinámica de ejemplos few-shot
← Volver a AI Prompt Engineering