AI Prompt Engineering · Pelajaran

Kompresi Konteks

Memangkas konteks hingga menyisakan hal yang penting.

Kompresi Konteks adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Mengapa Konteks Perlu Dikompresi

Potongan yang diambil mengandung banyak gangguan: potongan yang relevan mungkin sebagian besar hanya berisi teks baku dengan satu kalimat penting. Kompresi konteks memangkas teks yang diambil menjadi bagian yang benar-benar menjawab kueri sebelum teks tersebut mencapai generator.

Manfaatnya terakumulasi: biaya token lebih rendah, latensi berkurang, lebih sedikit pengalih perhatian, serta berkurangnya dampak informasi yang hilang di tengah karena konteks yang harus diproses model menjadi lebih kecil.

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]

Ekstraktif vs Abstraktif

Kompresi ekstraktif memilih rentang teks secara verbatim (kalimat, bagian teks) yang relevan dengan kueri, sambil mempertahankan kata-kata persis dan asal-usulnya. Kompresi abstraktif memparafrasakan atau meringkas, sehingga menghasilkan kompresi yang lebih tinggi tetapi berisiko kehilangan informasi dan menambahkan kesalahan.

Untuk RAG faktual dengan sitasi, utamakan ekstraktif agar klaim dapat ditelusuri ke sumber; gunakan abstraktif hanya jika kesetiaannya dapat diverifikasi.

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 empty

Pemfilteran Tingkat Kalimat

Teknik yang ringan dan tangguh: nilai setiap kalimat dari setiap potongan terhadap kueri menggunakan pengode silang kecil atau kemiripan embedding, lalu buang kalimat dengan skor rendah. Teknik ini mempertahankan kalimat bernilai tinggi sekaligus membuang teks tambahan.

Pertahankan konteks minimum untuk setiap potongan agar kalimat di sekitarnya, yang memberikan makna pada suatu fakta, tidak ikut terhapus.

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 order

Kompresi Kontekstual Berbasis LLM

LLM dapat mengompresi setiap potongan: berikan perintah untuk mengekstrak hanya bagian dari suatu teks yang relevan dengan kueri, lalu mengembalikan potongan yang dipangkas secara verbatim atau penanda kosong jika tidak ada bagian yang relevan.

Ini adalah pola ContextualCompressionRetriever dari LangChain. Teknik ini lebih akurat daripada filter embedding, tetapi menambahkan satu panggilan LLM untuk setiap potongan, jadi gunakan untuk pipeline yang berisiko tinggi atau lakukan secara berkelompok.

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 out

Pemangkasan Tingkat Token (LLMLingua)

Metode seperti LLMLingua melakukan kompresi pada tingkat token menggunakan model kecil untuk memperkirakan keinformatifan token, lalu membuang token yang informasinya rendah. Metode ini dapat mencapai rasio kompresi besar sambil mempertahankan sinyal yang dibutuhkan model besar.

Komprominya: teks yang dikompresi menjadi kurang mudah dibaca manusia, sehingga pendekatan ini cocok untuk konteks khusus mesin, bukan untuk tampilan yang dilihat pengguna.

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)

Berbasis Kueri vs Tidak Bergantung pada Kueri

Kompresi berbasis kueri mempertahankan hal-hal yang relevan untuk kueri ini dan menghasilkan konteks yang paling ringkas, tetapi harus dijalankan untuk setiap permintaan. Kompresi yang tidak bergantung pada kueri (ringkasan potongan yang telah dihitung sebelumnya) lebih murah saat permintaan berlangsung, tetapi tidak dapat berfokus pada pertanyaan tertentu.

Pendekatan hibrida menyimpan versi potongan yang telah dipadatkan secara luring dan menerapkan pemangkasan ringan berbasis kueri secara daring.

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

Melindungi dari Kehilangan Informasi

Kompresi agresif dapat menghapus satu klausa yang ternyata penting. Lindungi proses dengan pemeriksaan perolehan kembali: pastikan konteks terkompresi masih mengandung jawaban, atau pertahankan cadangan berupa potongan yang tidak dikompresi ketika kompresor menghasilkan teks yang sangat sedikit secara mencurigakan.

Jangan pernah membiarkan kompresi mengosongkan suatu potongan ketika pemeringkat ulang menilainya sangat relevan; itu menandakan kegagalan kompresor, bukan ketidakrelevanan.

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.text

Mempertahankan Asal-Usul

Kompresi harus mempertahankan atribusi sumber. Tandai setiap rentang teks yang dipertahankan dengan ID potongan dan dokumennya agar generator dapat memberikan sitasi. Jika metadata ikut dikompresi, Anda kehilangan kemampuan untuk memverifikasi dan mendeteksi halusinasi.

Teruskan ID melalui pipeline sebagai kolom terstruktur, jangan sebagai teks bebas yang mungkin dihapus oleh kompresi.

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 preserved

Kompresi dan Anggaran Token

Kompresi memungkinkan Anda mengambil lebih banyak kandidat untuk meningkatkan perolehan kembali, sambil menjaga perintah akhir tetap kecil. Tetapkan anggaran token untuk jendela konteks dan masukkan secara rakus rentang terkompresi yang paling bernilai hingga anggaran tercapai.

Hal ini memisahkan jumlah yang diambil dari jumlah yang dibelanjakan untuk pembuatan jawaban, sehingga menjadi pengungkit efisiensi yang penting.

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 packed

Mengukur Kualitas Kompresi

Lacak tiga angka: rasio kompresi (token yang dihemat), akurasi jawaban (apakah kualitas tetap terjaga), dan kesetiaan (apakah kompresor menghindari perubahan fakta). Tujuannya adalah rasio tertinggi yang tidak mengubah akurasi jawaban.

Uji berbagai tingkat agresivitas kompresi dan pilih titik Pareto yang memenuhi target biaya tanpa kehilangan kualitas.

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
    }

Pipeline yang Sadar Kompresi

Dari awal hingga akhir: lakukan pengambilan secara luas, pemeringkatan ulang, kompresi setiap potongan yang tersisa (ekstraktif atau berbasis LLM) beserta asal-usulnya, lindungi dari pemangkasan berlebihan, masukkan hingga mencapai anggaran token, lalu buat jawaban dengan sitasi.

Kompresi adalah lapisan yang membuat pengambilan dengan cakupan tinggi tetap terjangkau dan menjaga generator berfokus pada hal-hal penting.

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)

Pemeriksaan Singkat

Pilih pendekatan kompresi yang tepat untuk sistem RAG faktual dengan sitasi.

Rangkuman

Hal-hal penting:

Kompresi memangkas potongan yang diambil menjadi konten yang relevan dengan kueri, sehingga mengurangi biaya, latensi, dan pengalih perhatian.
Untuk RAG faktual dengan sitasi, utamakan ekstraktif (verbatim dan dapat ditelusuri) daripada abstraktif; pemangkasan tingkat token cocok untuk konteks khusus mesin.
Kompresi berbasis kueri menghasilkan konteks paling ringkas, tetapi harus dilakukan untuk setiap permintaan; gabungkan dengan ringkasan luring demi efisiensi.
Lindungi dari kehilangan informasi dan pertahankan asal-usul potongan/dokumen untuk sitasi.
Gunakan kompresi untuk mengambil data secara luas sekaligus menjaga perintah tetap kecil; sesuaikan agar rasio maksimum tercapai tanpa kehilangan akurasi jawaban.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kompresi Konteks” gratis?

Ya — teks lengkap “Kompresi Konteks” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Kompresi Konteks”?

Memangkas konteks hingga menyisakan hal yang penting. Kamu berlatih AI Prompt Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Prompt Engineering?

Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Kompresi Konteks” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Prompt Engineering ini?

Ya. Setiap pelajaran AI Prompt Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke AI Prompt Engineering