Dynamische few-shot-selectie
Voorbeelden per query ophalen
Dynamische few-shot-selectie is een gratis AI-promptengineering-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.
Van statische naar dynamische voorbeelden
Statische few-shot gebruikt voor elke query dezelfde voorbeelden. Dynamische few-shot haalt per query de meest relevante voorbeelden op uit een verzameling en stemt het model af op voorbeelden die lijken op de huidige invoer.
Dit is retrieval-augmented in-context learning: het verhoogt de relevantie van voorbeelden, een van de sterkste knoppen voor de kwaliteit van ICL, vooral bij heterogeen verkeer.
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]De voorbeeldverzameling embedden
Bereken vooraf embeddings voor elk kandidaatvoorbeeld en sla ze op in een index voor benaderende naaste buren (FAISS, HNSW of een vector-database). Embed tijdens een query de invoer één keer en haal de beste overeenkomsten op.
Kies een embeddingmodel dat aansluit bij de semantiek van je taak; een generieke embedder kan clusteren op oppervlakkige kenmerken in plaats van op de dimensie die het juiste label voorspelt.
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 indexkNN-prompting
De canonieke methode (Liu et al., 2022) haalt de k naaste buren van de query op uit de gelabelde verzameling en gebruikt die als voorbeelden. Selectie op basis van ophalen verslaat willekeurige selectie consequent, omdat relevante voorbeelden de taak beter afbakenen en de juiste labelruimte leveren.
De opgehaalde labels fungeren ook als een voorafkans voor een zachte kNN-classificator en sturen het model subtiel richting de antwoorden van de buren.
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)Diversiteitsbewust ophalen
Een zuivere top-k-selectie kan bijna-duplicaten opleveren, waardoor context wordt verspild. Pas MMR of clustering toe op de opgehaalde kandidaten om relevantie te behouden en er tegelijk voor te zorgen dat de gekozen voorbeelden verschillende aspecten van de query afdekken.
Dit is vooral belangrijk voor compositional inputs, waarbij elk deelaspect een representatief voorbeeld nodig heeft.
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 + diversityLatentie en het ophaalbudget
Dynamische selectie voegt aan elk verzoek een embeddingaanroep en een ANN-opzoeking toe. Houd hier rekening mee: cache query-embeddings voor herhaalde invoer, bundel het ophalen en houd de index in het geheugen.
Voor systemen met een hoge QPS moet de ophaalstap minder dan een milliseconde duren; anders wordt de winst in relevantie tenietgedaan door de extra staartlatentie.
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 prefetchSpanning tussen cachen en dynamische voorbeelden
Dynamische voorbeelden doorbreken het cachen van het promptvoorvoegsel, omdat het voorbeeldblok per query verandert. Beperk dit door een stabiele gecachte inleiding te behouden (instructies plus enkele universele voorbeelden) en alleen de opgehaalde, queryspecifieke voorbeelden erachter te plaatsen.
Zo herstel je het grootste deel van de cachebesparing en behoud je relevantie per query in het staartgedeelte.
prompt = (
STATIC_PREAMBLE # cached: instructions + anchor demos
+ render(diverse_retrieve(query, selector, k)) # dynamic tail
+ format_query(query)
)Lekken tussen training en test vermijden
Als de query zelf in de verzameling staat (wat tijdens evaluatie vaak voorkomt), kan het ophalen het exacte antwoord teruggeven, waardoor de metrieken kunstmatig hoger uitvallen. Sluit de query uit en sluit tijdens evaluatie ook nagenoeg identieke buren boven een similariteitsdrempel uit.
Ontdubbel de verzameling in productie en voorkom dat je eerdere invoer van een gebruiker als voorbeeld aan diezelfde gebruiker teruggeeft.
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]Koude start en groei van de verzameling
In het begin is de verzameling klein en levert het ophalen mogelijk zwakke overeenkomsten op. Begin met een zorgvuldig samengestelde statische set en breid de verzameling uit met geverifieerde productietraces; embed en indexeer die opnieuw volgens een vast schema.
Houd het gebruik en de uitkomst per voorbeeld bij, zodat je voorbeelden met weinig waarde of verouderde voorbeelden kunt verwijderen en de index compact kunt houden.
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))Selectie voorbij similariteit
Relevantie op basis van naaste buren is een sterke standaardkeuze, maar niet altijd optimaal. Geavanceerde selectoren wegen informatiewaarde (verduidelijkt het voorbeeld de onduidelijkheid in de query?), diversiteit en labeldekking mee. Sommige methoden leren een selectiebeleid dat de uiteindelijke nauwkeurigheid maximaliseert in plaats van de ruwe similariteit.
Zie selectie als het kiezen van de verzameling voorbeelden die de onzekerheid van het model over deze query het meest vermindert.
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]]Een dynamische pijplijn evalueren
Vergelijk dynamische systemen met statische en willekeurige basislijnen op achtergehouden gegevens waarbij lekken is beheerst. Rapporteer de nauwkeurigheid, de verdeling van ophaalsimilariteiten, de latentie van begin tot eind en het cachetrefferpercentage.
Een dynamisch systeem dat wint op nauwkeurigheid maar het hergebruik van de cache sterk vermindert, kan per saldo duurder uitvallen; evalueer de volledige doelstelling en niet alleen de kwaliteit.
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(),
}Referentiearchitectuur
Van begin tot eind: een geverifieerde verzameling voorbeelden, een embeddingmodel, een ANN-index in het geheugen, een selector die lekken voorkomt en diversiteit en ordening op similariteit toepast, een stabiele gecachte inleiding en een feedbacklus die de verzameling uitbreidt en opschoont.
Deze architectuur maakt van few-shot-prompting een ophaalsysteem met de operationele discipline die daarbij hoort.
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 outSnelle controle
Diagnosticeer een misleidend sterk evaluatieresultaat.
Samenvatting
Belangrijkste punten:
- Dynamische few-shot haalt per query voorbeelden op en verslaat willekeurige of statische selectie door de relevantie te verhogen.
- Embed de verzameling in een ANN-index; kNN-prompting is de sterke standaardkeuze, geordend op oplopende similariteit.
- Voeg diversiteit toe (MMR) en overweeg selectoren op basis van informatiewaarde en onzekerheidsvermindering.
- Voorkom lekken bij het ophalen, beheer de latentie en behoud een gecachte statische inleiding met een dynamisch staartgedeelte.
- Breid de verzameling uit en snoei die op basis van geverifieerde traces; evalueer nauwkeurigheid, latentie en cachetreffers gezamenlijk.
Leer AI-promptengineering met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 53
- Lessen
- 199
Veelgestelde vragen
Is de les “Dynamische few-shot-selectie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Dynamische few-shot-selectie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.
Wat leer ik in “Dynamische few-shot-selectie”?
Voorbeelden per query ophalen Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-promptengineering te beginnen?
Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Dynamische few-shot-selectie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?
Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Zero-, one- en few-shot
- Effectieve voorbeelden ontwerpen
- Volgorde en actualiteit van voorbeelden
- Dynamische few-shot-selectie