Kontextkomprimering
Beskär kontexten till det som är relevant.
Kontextkomprimering är en gratis lektion i AI-promptteknik på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för AI-promptteknik, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-promptteknik innehåller totalt 4 lektioner.
Varför kontext ska komprimeras
Hämtade chunkar är brusiga: en relevant chunk kan till största delen bestå av standardtext med en enda avgörande mening. Kontextkomprimering beskär den hämtade texten till det som faktiskt besvarar frågan innan den når generatorn.
Fördelarna förstärks: lägre tokenkostnad, minskad latens, färre distraktioner och mindre påverkan från lost-in-the-middle genom att den kontext som modellen måste gå igenom blir mindre.
def compress(query, chunks):
# Goal: keep only spans that bear on the query,
# dropping boilerplate, navigation, and off-topic sentences.
return [extract_relevant(query, c) for c in chunks]Extraktiv kontra abstraktiv
Extraktiv komprimering väljer ordagranna textavsnitt (meningar, stycken) som är relevanta för frågan och bevarar exakt ordalydelse och proveniens. Abstraktiv komprimering parafraserar eller sammanfattar, vilket ger högre komprimering men medför risk för informationsförlust och nya fel.
För faktabaserad RAG med citeringar bör extraktiv komprimering föredras så att påståenden kan spåras till källan. Använd abstraktiv komprimering endast när faktatroheten kan verifieras.
def extractive(query, chunk):
sents = split_sentences(chunk.text)
scored = [(s, relevance(query, s)) for s in sents]
kept = [s for s, r in scored if r > TAU]
return ' '.join(kept) or top1(scored) # never return emptyFiltrering på meningsnivå
En enkel och robust teknik är att poängsätta varje mening i varje chunk mot frågan med en liten cross-encoder eller embeddingslikhet och ta bort meningar med låg poäng. Då bevaras meningarna med högt värde medan utfyllnad rensas bort.
Behåll en minsta mängd kontext i varje chunk för att inte ta bort den omgivande meningen som ger ett faktum dess betydelse.
def sentence_filter(query, chunk, keep_ratio=0.4):
sents = split_sentences(chunk.text)
scores = embed_sim_batch(query, sents)
n_keep = max(1, int(len(sents) * keep_ratio))
idx = sorted(range(len(sents)), key=lambda i: -scores[i])[:n_keep]
return ' '.join(sents[i] for i in sorted(idx)) # keep original orderLLM-baserad kontextuell komprimering
Ett LLM kan komprimera varje chunk: instruera det att extrahera endast de delar av ett textavsnitt som är relevanta för frågan och returnera chunken ordagrant men beskuren, eller en tom markör om inget är relevant.
Detta är mönstret LangChain ContextualCompressionRetriever. Det är träffsäkrare än embeddingfilter men lägger till ett LLM-anrop per chunk, så reservera det för pipelines med höga krav eller kör anropen i batch.
def llm_compress(query, chunk):
prompt = (
'Extract ONLY sentences from the passage relevant to the query. '
'If none are relevant, output NONE. Do not paraphrase.\n'
'Query: ' + query + '\nPassage: ' + chunk.text
)
out = llm(prompt, temperature=0).strip()
return None if out == 'NONE' else outTokenbaserad gallring (LLMLingua)
Metoder som LLMLingua komprimerar på tokennivå med hjälp av en liten modell som uppskattar tokeners informationsvärde och tar bort token med låg informationshalt. De kan uppnå stora komprimeringsgrader samtidigt som signalen som den stora modellen behöver bevaras.
Kompromissen är att den komprimerade texten blir mindre lättläst för människor. Detta lämpar sig därför för kontext som endast ska användas av maskiner, inte för visning för användare.
def token_prune(context, target_ratio=0.3):
# small LM estimates per-token information (perplexity-based);
# drop the least informative tokens down to target_ratio length
scores = small_lm_token_importance(context)
return keep_top_fraction(context, scores, target_ratio)Frågeanpassad kontra frågeagnostisk
Frågeanpassad komprimering behåller det som är relevant för den här frågan och ger den mest koncentrerade kontexten, men måste köras för varje begäran. Frågeagnostisk komprimering (förberäknade chunksammanfattningar) är billigare vid själva begäran men kan inte fokusera på den specifika frågan.
En hybridlösning lagrar kondenserade chunkversioner offline och tillämpar lätt frågeanpassad beskärning online.
# Offline: precompute a dense summary per chunk (query-agnostic)
chunk.summary = summarize(chunk.text)
# Online: query-aware trim over summaries (cheap) then verify on full
ctx = [sentence_filter(query, Chunk(c.summary)) for c in top_chunks]Skydd mot informationsförlust
Aggressiv komprimering kan ta bort den enda sats som hade betydelse. Skydda detta med en recall-kontroll: verifiera att den komprimerade kontexten fortfarande stödjer svaret, eller behåll en reservversion av den okomprimerade chunken när komprimeraren returnerar misstänkt lite innehåll.
Låt aldrig komprimeringen göra en chunk tom när re-rankern har bedömt den som mycket relevant. Det signalerar ett fel hos komprimeraren, inte irrelevans.
def safe_compress(query, chunk):
out = llm_compress(query, chunk)
if out is None and chunk.rerank_score > 0.7:
return chunk.text # trust re-ranker over compressor
return out or chunk.textBevara proveniens
Komprimeringen måste bevara källhänvisningen. Märk varje bevarat textavsnitt med dess chunk- och dokument-ID så att generatorn kan citera det. Om metadata komprimeras bort förlorar ni verifierbarheten och möjligheten att upptäcka hallucinationer.
För ID:n genom hela pipelinen som strukturerade fält, aldrig som fritext som komprimeringen kan ta bort.
def compress_with_ids(query, chunks):
out = []
for c in chunks:
span = safe_compress(query, c)
out.append({'id': c.id, 'doc': c.meta['doc_id'], 'text': span})
return out # generator cites id; provenance preservedKomprimering och tokenbudgeten
Komprimering gör att ni kan hämta fler kandidater för hög recall samtidigt som den slutliga prompten hålls liten. Sätt en tokenbudget för kontextfönstret och packa de komprimerade textavsnitten med högst värde först tills budgeten är nådd.
Detta frikopplar hur mycket som hämtas från hur mycket som spenderas på generering, vilket är en viktig effektivitetsfaktor.
def pack(spans, budget_tokens, tok):
spans = sorted(spans, key=lambda s: -s['score'])
used, packed = 0, []
for s in spans:
t = tok(s['text'])
if used + t > budget_tokens:
continue
packed.append(s); used += t
return packedMätning av komprimeringskvalitet
Följ tre värden: komprimeringsgrad (sparade token), svarsträffsäkerhet (bibehölls kvaliteten?) och faktatrohet (undvek komprimeraren att ändra fakta?). Målet är den högsta komprimeringsgrad som inte försämrar svarsträffsäkerheten.
Testa olika nivåer av komprimering och välj den Pareto-punkt som uppfyller kostnadsmålet utan kvalitetsförlust.
def eval_compression(eval_set, levels):
return {
lvl: {
'ratio': mean_ratio(eval_set, lvl),
'acc': answer_accuracy(eval_set, lvl),
'faith': faithfulness(eval_set, lvl),
} for lvl in levels
}En komprimeringsmedveten pipeline
Från början till slut: hämta brett, re-ranka, komprimera varje kvarvarande chunk (extraktivt eller LLM-baserat) med bevarad proveniens, skydda mot överbeskärning, packa till en tokenbudget och generera med citeringar.
Komprimering är lagret som gör retrieval med hög recall ekonomiskt hållbar och håller generatorn fokuserad på det som är viktigt.
def pipeline(query):
top = rerank(query, hybrid_retrieve(query, 50))[:12]
spans = compress_with_ids(query, top)
spans = [s for s in spans if s['text']]
packed = pack(spans, budget_tokens=2000, tok=count_tokens)
return generate_with_citations(query, packed)Snabbtest
Välj rätt komprimeringsmetod för ett faktabaserat RAG-system med citeringar.
Sammanfattning
Viktiga slutsatser:
- Komprimering beskär hämtade chunkar till frågerelevant innehåll och minskar kostnad, latens och distraktioner.
- Föredra extraktiv komprimering (ordagrann och spårbar) framför abstraktiv för citeringsbaserad faktabaserad RAG; tokenbaserad gallring lämpar sig för kontext som endast ska användas av maskiner.
- Frågeanpassad komprimering ger den mest koncentrerade kontexten men måste köras för varje begäran; kombinera den med offlinesammanfattningar för effektivitet.
- Skydda mot informationsförlust och bevara chunkens och dokumentets proveniens för citeringar.
- Använd komprimering för att hämta brett men hålla prompten liten; justera den för maximal komprimeringsgrad utan att förlora svarsträffsäkerhet.
Lär dig AI-promptteknik med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 53
- Lektioner
- 199
Vanliga frågor
Är lektionen ”Kontextkomprimering” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen AI-promptteknik, inklusive ”Kontextkomprimering”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i AI-promptteknik innehåller totalt 4 lektioner.
Vad lär jag mig i ”Kontextkomprimering”?
Beskär kontexten till det som är relevant. Ni övar på AI-promptteknik med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig AI-promptteknik?
Du behöver inga förkunskaper. Utbildningen i AI-promptteknik på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Kontextkomprimering”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här AI-promptteknik-lektionen?
Ja. Varje AI-promptteknik-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Bortom naiv RAG
- Omrankning av hämtade textblock
- Kontextkomprimering
- Omskrivning av frågor och HyDE