Dynamisk few-shot-utvalg
Hente eksempler for hver spørring.
Dynamisk few-shot-utvalg er en gratis leksjon i AI-prompt engineering på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-prompt engineering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-prompt engineering inneholder totalt 4 leksjoner.
Fra statiske til dynamiske demonstrasjoner
Statisk few-shot bruker de samme eksemplene for hver spørring. Dynamisk few-shot henter de mest relevante demonstrasjonene fra en samling for hver spørring, slik at modellen betinges på eksempler som ligner på det aktuelle inputet.
Dette er retrieval-augmented in-context learning: Det øker relevansen til demonstrasjonene, som er en av de sterkeste faktorene for kvaliteten på ICL, særlig ved heterogen trafikk.
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]Vektorisering av demonstrasjonspoolen
Beregn embedding-representasjoner på forhånd for alle mulige demonstrasjoner, og lagre dem i en approximate nearest neighbor-indeks (FAISS, HNSW eller en vektordatabase). Ved spørringstidspunktet beregner du embedding for inputet én gang og henter de beste treffene.
Velg en embedding-modell som samsvarer med semantikken i oppgaven. En generell embedder kan gruppere etter overfladiske trekk i stedet for den dimensjonen som forutsier riktig etikett.
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
Den kanoniske metoden (Liu et al., 2022) henter de k nærmeste naboene til spørringen fra den etiketterte samlingen og bruker dem som demonstrasjoner. Utvalgsmetoder basert på henting slår konsekvent tilfeldig utvalg, fordi relevante demonstrasjoner gjør oppgaven tydeligere og gir riktig etikettområde.
De hentede etikettene fungerer også som en myk prior for en kNN-klassifikator og trekker modellen i retning av naboenes svar.
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)Mangfoldsbevisst henting
Ren top-k-henting kan returnere nesten identiske eksempler og sløse med konteksten. Bruk MMR eller clustering blant de hentede kandidatene for å beholde relevansen og samtidig sikre at de valgte demonstrasjonene dekker ulike sider av spørringen.
Dette er særlig viktig for komposisjonelle input, der ulike delaspekter trenger hver sin representative demonstrasjon.
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 + diversityVentetid og hentebudsjettet
Dynamisk utvalg legger til et embedding-kall og et ANN-oppslag for hver forespørsel. Ta høyde for dette: Bufre embedding-representasjoner av gjentatte input, grupper henteoperasjoner i batcher, og hold indeksen i minnet.
I systemer med høy QPS må henteoperasjonen ta under ett millisekund. Ellers spises relevansgevinsten opp av økt tail latency.
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 prefetchBufringskonflikt med dynamiske demonstrasjoner
Dynamiske demonstrasjoner bryter bufring av prompt-prefikset fordi eksempelblokken endres for hver spørring. Dette kan begrenses ved å beholde et stabilt bufret forord (instruksjoner samt noen få universelle eksempler) og bare legge de hentede, spørringsspesifikke demonstrasjonene til etter dette.
På den måten gjenvinner du det meste av bufringsbesparelsene, samtidig som halen beholder relevansen for den enkelte spørringen.
prompt = (
STATIC_PREAMBLE # cached: instructions + anchor demos
+ render(diverse_retrieve(query, selector, k)) # dynamic tail
+ format_query(query)
)Unngå lekkasje mellom trening og test
Hvis selve spørringen finnes i samlingen, noe som er vanlig under evaluering, kan henting returnere det eksakte svaret og blåse opp måltallene. Utelat alltid spørringen og nesten identiske naboer over en gitt likhetsterskel under evaluering.
I produksjon bør du deduplisere samlingen og hindre at brukerens eget tidligere input gjengis som en demonstrasjon.
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]Kaldstart og vekst i samlingen
I starten er samlingen liten, og henting kan gi svake treff. Start med et kuratert statisk sett, og utvid samlingen deretter med verifiserte produksjonsspor. Beregn embedding-representasjoner og bygg indeksen på nytt etter en fast plan.
Følg med på bruk og utfall per demonstrasjon, slik at du kan fjerne eksempler med lav verdi eller som er utdatert, og holde indeksen slank.
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))Utvalg utover likhet
Relevans basert på nærmeste naboer er et godt standardvalg, men er ikke alltid optimalt. Avanserte utvalgsmetoder veier informasjonsverdi (løser demonstrasjonen opp tvetydigheten i spørringen?), mangfold og etikettdekning. Noen metoder lærer en utvalgsstrategi som maksimerer nøyaktigheten nedstrøms i stedet for rå likhet.
Se på utvalget som et valg av det demonstrasjonssettet som reduserer modellens usikkerhet om denne spørringen mest.
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]]Evaluering av en dynamisk pipeline
Sammenlign dynamiske metoder med statiske og tilfeldige baseliner på data som er holdt utenfor treningen og kontrollert for lekkasje. Rapporter nøyaktighet, fordelingen av hentede likheter, ventetid fra ende til ende og treffraten for hurtigbufferen.
Et dynamisk system som vinner på nøyaktighet, men ødelegger gjenbruket av hurtigbufferen, kan gi høyere totalkostnad. Evaluer hele målet, ikke bare kvaliteten.
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(),
}Referansearkitektur
Fra ende til ende består løsningen av en verifisert demonstrasjonspool, en embedding-modell, en ANN-indeks i minnet, en utvalgsmetode som bruker lekkasjesperrer, mangfold og likhetsbasert rekkefølge, et stabilt bufret forord og en tilbakekoblingssløyfe som utvider og beskjærer samlingen.
Denne arkitekturen gjør few-shot-prompting om til et hentesystem med den driftsmessige disiplinen dette innebærer.
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 outSjekk deg selv
Finn årsaken til et misvisende sterkt evalueringsresultat.
Oppsummering
Viktigste poenger:
- Dynamisk few-shot henter demonstrasjoner for hver spørring og slår tilfeldig eller statisk utvalg ved å øke relevansen.
- Beregn embedding-representasjoner av samlingen i en ANN-indeks. kNN-prompting er et godt standardvalg, sortert etter stigende likhet.
- Legg til mangfold med MMR, og vurder utvalgsmetoder basert på informasjonsverdi eller reduksjon av usikkerhet.
- Beskytt mot lekkasje ved henting, håndter ventetid, og behold et bufret statisk forord med en dynamisk hale.
- Utvid og beskjær samlingen med utgangspunkt i verifiserte spor, og evaluer nøyaktighet, ventetid og treffrate for hurtigbufferen samlet.
Lær deg AI-prompt engineering med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 53
- Leksjoner
- 199
Ofte stilte spørsmål
Er leksjonen «Dynamisk few-shot-utvalg» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien AI-prompt engineering, inkludert «Dynamisk few-shot-utvalg», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i AI-prompt engineering inneholder totalt 4 leksjoner.
Hva lærer jeg i «Dynamisk few-shot-utvalg»?
Hente eksempler for hver spørring. Du øver på AI-prompt engineering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med AI-prompt engineering?
Ingen tidligere erfaring er nødvendig. AI-prompt engineering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Dynamisk few-shot-utvalg»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne AI-prompt engineering-leksjonen?
Ja. Alle AI-prompt engineering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Zero-, one- og few-shot
- Utforming av effektive eksempler
- Rekkefølge og aktualitet for eksempler
- Dynamisk few-shot-utvalg