0Pricing
AI Prompt Engineering · Lektion

Dynamische Few-Shot-Auswahl

Beispiele pro Anfrage abrufen

Dynamische Few-Shot-Auswahl ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Von statischen zu dynamischen Demos

Beim statischen Few-Shot werden für jede Query dieselben Beispiele verwendet. Dynamisches Few-Shot ruft für jede Query die relevantesten Demonstrationen aus einer Sammlung ab und konditioniert das Modell auf Beispiele, die der aktuellen Eingabe ähneln.

Das ist Retrieval-Augmented In-Context Learning: Die Relevanz der Demonstrationen steigt. Das ist einer der stärksten Hebel für die Qualität von ICL, insbesondere bei heterogenem Datenverkehr.

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]

Die Demonstrationssammlung einbetten

Berechnen Sie vorab Embeddings für jede mögliche Demonstration und speichern Sie sie in einem Approximate-Nearest-Neighbor-Index (FAISS, HNSW oder einer Vektordatenbank). Betten Sie die Eingabe zur Anfragezeit einmal ein und rufen Sie die besten Treffer ab.

Wählen Sie ein Embedding-Modell, dessen semantische Ausrichtung zu Ihrer Aufgabe passt. Ein allgemeines Embedder-Modell gruppiert möglicherweise eher nach oberflächlichen Merkmalen als nach der Dimension, die das korrekte Label vorhersagt.

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

kNN-Prompting

Die kanonische Methode (Liu et al., 2022) ruft die k nächsten Nachbarn der Query aus der gelabelten Sammlung ab und verwendet sie als Demonstrationen. Die Auswahl auf Retrieval-Basis ist der zufälligen Auswahl durchgehend überlegen, weil relevante Demos die Aufgabe besser einordnen und den passenden Labelraum bereitstellen.

Die abgerufenen Labels dienen außerdem als weicher Prior eines kNN-Klassifikators und lenken das Modell in Richtung der Antworten der Nachbarn.

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)

Diversitätsbewusstes Retrieval

Eine reine Top-k-Auswahl kann nahezu identische Beispiele liefern und dadurch Kontext verschwenden. Wenden Sie MMR oder Clustering auf die abgerufenen Kandidaten an, um die Relevanz zu erhalten und gleichzeitig sicherzustellen, dass die ausgewählten Demos unterschiedliche Aspekte der Query abdecken.

Das ist besonders bei kompositionellen Eingaben wichtig, bei denen für verschiedene Teilaspekte jeweils eine repräsentative Demonstration benötigt wird.

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

Latenz und Retrieval-Budget

Die dynamische Auswahl fügt jeder Anfrage einen Embedding-Aufruf und eine ANN-Suche hinzu. Planen Sie dies ein: Cachen Sie Query-Embeddings für wiederholte Eingaben, bündeln Sie Retrieval-Anfragen und halten Sie den Index im Arbeitsspeicher.

Bei Systemen mit hohem QPS muss der Retrieval-Schritt weniger als eine Millisekunde dauern. Andernfalls wird der Relevanzgewinn durch die zusätzliche Tail-Latenz aufgezehrt.

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

Spannungsfeld zwischen Caching und dynamischen Demos

Dynamische Demos verhindern das Caching des Prompt-Präfixes, weil sich der Beispielblock für jede Query ändert. Begrenzen Sie die Auswirkungen, indem Sie eine stabil gecachte Präambel (Anweisungen plus einige universelle Beispiele) beibehalten und nur die abgerufenen, Query-spezifischen Demos dahinter anhängen.

So gewinnen Sie den größten Teil der Caching-Einsparungen zurück und erhalten zugleich die Query-spezifische Relevanz des hinteren Teils.

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

Leakage zwischen Training und Test vermeiden

Wenn sich die Query selbst in der Sammlung befindet (bei Evaluationen häufig), kann das Retrieval genau die richtige Antwort liefern und die Metriken künstlich erhöhen. Schließen Sie die Query aus und entfernen Sie bei der Evaluation auch nahezu identische Nachbarn oberhalb eines Ähnlichkeitsschwellenwerts.

Deduplizieren Sie die Sammlung in der Produktion und verhindern Sie, dass die eigene frühere Eingabe eines Benutzers als Demonstration zurückgegeben wird.

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]

Kaltstart und Wachstum der Sammlung

Zu Beginn ist die Sammlung klein, und das Retrieval liefert möglicherweise nur schwache Treffer. Starten Sie mit einem kuratierten statischen Satz und vergrößern Sie die Sammlung anschließend anhand verifizierter Produktionsspuren. Berechnen Sie Embeddings neu und erstellen Sie den Index regelmäßig neu.

Verfolgen Sie die Nutzung und das Ergebnis jeder Demonstration, damit Sie Beispiele mit geringem Wert oder veraltete Beispiele entfernen und den Index schlank halten können.

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

Auswahl über die Ähnlichkeit hinaus

Die Relevanz anhand der nächsten Nachbarn ist eine starke Standardeinstellung, aber nicht immer optimal. Fortgeschrittene Selektoren gewichten Informationsgehalt (löst die Demonstration die Mehrdeutigkeit der Query?), Diversität und Labelabdeckung. Einige Methoden lernen eine Auswahlstrategie, die die nachgelagerte Genauigkeit statt der reinen Ähnlichkeit maximiert.

Betrachten Sie die Auswahl als Suche nach der Demonstrationsmenge, die die Unsicherheit des Modells bezüglich dieser Query am stärksten reduziert.

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

Eine dynamische Pipeline evaluieren

Vergleichen Sie dynamische mit statischen und zufälligen Baselines anhand zurückgehaltener Daten, bei denen Leakage kontrolliert wurde. Geben Sie die Genauigkeit, die Verteilung der Retrieval-Ähnlichkeiten, die End-to-End-Latenz und die Cache-Trefferrate an.

Ein dynamisches System, das bei der Genauigkeit gewinnt, aber die Cache-Wiederverwendung stark verschlechtert, kann unter dem Strich teurer sein. Bewerten Sie das vollständige Ziel und nicht nur die Qualität.

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

Referenzarchitektur

Durchgängiger Aufbau: eine verifizierte Demonstrationssammlung, ein Embedding-Modell, ein ANN-Index im Arbeitsspeicher, ein Selektor mit Schutzmaßnahmen gegen Leakage sowie Diversitäts- und Ähnlichkeitsordnung, eine stabil gecachte Präambel und eine Feedbackschleife, die die Sammlung erweitert und bereinigt.

Diese Architektur macht aus Few-Shot-Prompting ein Retrieval-System mit der dafür erforderlichen betrieblichen Disziplin.

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

Kurze Überprüfung

Analysieren Sie ein irreführend starkes Evaluationsergebnis.

Zusammenfassung

Wichtige Erkenntnisse:

  • Dynamisches Few-Shot ruft für jede Query passende Demonstrationen ab und übertrifft zufällige bzw. statische Verfahren durch höhere Relevanz.
  • Betten Sie die Sammlung in einen ANN-Index ein. kNN-Prompting ist die starke Standardeinstellung und wird nach aufsteigender Ähnlichkeit geordnet.
  • Fügen Sie Diversität hinzu (MMR) und ziehen Sie Selektoren auf Basis von Informationsgehalt bzw. Unsicherheitsreduktion in Betracht.
  • Schützen Sie sich vor Retrieval-Leakage, steuern Sie die Latenz und verwenden Sie eine gecachte statische Präambel mit einem dynamischen hinteren Teil.
  • Erweitern und bereinigen Sie die Sammlung anhand verifizierter Spuren und bewerten Sie Genauigkeit, Latenz und Cache-Trefferrate gemeinsam.

Häufig gestellte Fragen

Ist die Lektion „Dynamische Few-Shot-Auswahl“ kostenlos?

Ja — der vollständige Text von „Dynamische Few-Shot-Auswahl“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Dynamische Few-Shot-Auswahl“?

Beispiele pro Anfrage abrufen Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Dynamische Few-Shot-Auswahl“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Zero-, One- und Few-Shot
  2. Wirksame Beispiele entwerfen
  3. Reihenfolge und Aktualität von Beispielen
  4. Dynamische Few-Shot-Auswahl
← Zurück zu AI Prompt Engineering