AI Prompt Engineering · Pelajaran

Penulisan Ulang Kueri dan HyDE

Meningkatkan perolehan kembali dalam pengambilan.

Penulisan Ulang Kueri dan HyDE adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 4 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.

Kueri Adalah Titik Lemah

Kualitas pengambilan dibatasi oleh kueri. Kueri mentah dari pengguna sering kali pendek, ambigu, penuh kata ganti, atau dirumuskan secara berbeda dari dokumen. Transformasi kueri mengubah bentuk kueri sebelum pengambilan untuk meningkatkan perolehan kembali dan ketepatan.

Ini adalah salah satu peningkatan termurah dengan dampak terbesar dibandingkan RAG naif: perbaiki kuerinya, dan setiap tahap berikutnya akan memperoleh manfaat.

def transform_query(raw, history):
    # Resolve references, expand, decompose, or hypothesize
    # BEFORE embedding and retrieving.
    return rewrite(raw, history)

Penulisan Ulang Kueri

Transformasi paling sederhana: LLM menulis ulang kueri pengguna menjadi bentuk yang lebih jelas, mandiri, dan ramah terhadap pengambilan. Teknik ini memperbaiki kesalahan ketik, memperluas singkatan, dan menghapus gangguan percakapan.

Hal ini sangat penting dalam percakapan multi-giliran ketika pesan terbaru tidak dapat dipahami tanpa konteks (Bagaimana dengan yang kedua?).

def rewrite_query(raw):
    prompt = (
        'Rewrite the user question into a clear, standalone search '
        'query optimized for document retrieval. Keep key entities.\n'
        'Question: ' + raw
    )
    return llm(prompt, temperature=0).strip()

Pemadatan Percakapan

Dalam RAG percakapan, padatkan dialog dan giliran baru menjadi satu pertanyaan mandiri. Tanpa langkah ini, kata ganti dan elipsis membuat embedding tidak bermakna dan pengambilan runtuh.

Teruskan giliran sebelumnya agar penulis ulang dapat mengubahnya, itu, dan yang sebelumnya menjadi entitas eksplisit yang dapat dicocokkan oleh pengambil.

def condense(history, follow_up):
    prompt = (
        'Given the conversation, rewrite the follow-up as a standalone '
        'question with all references resolved.\nConversation:\n' +
        render(history) + '\nFollow-up: ' + follow_up
    )
    return llm(prompt, temperature=0).strip()

Perluasan Kueri

Perluasan menghasilkan sinonim, istilah terkait, atau susunan kata alternatif untuk memperluas cakupan leksikal dan semantik. Teknik ini mengatasi ketidakcocokan kosakata: dokumen mengatakan membatalkan keabsahan, sedangkan pengguna mengatakan mencabut.

Lakukan perluasan untuk pengambilan, lalu ambil dengan gabungan hasilnya; jangan tampilkan bentuk yang diperluas kepada pengguna. Waspadai perluasan berlebihan yang dapat menarik hasil di luar topik.

def expand(query, n=3):
    prompt = (
        'List ' + str(n) + ' alternative phrasings of this query using '
        'synonyms and domain terms, one per line.\n' + query
    )
    variants = parse_lines(llm(prompt, temperature=0.5))
    return [query] + variants

Pengambilan Multi-Kueri

Buat beberapa perumusan ulang yang beragam, lakukan pengambilan untuk masing-masing, lalu gabungkan daftar hasil tersebut (penggabungan peringkat timbal balik). Susunan kata yang berbeda menampilkan potongan relevan yang berbeda; penggabungan memadukan keunggulannya dan menstabilkan perolehan kembali.

Pendekatan ini menukar tambahan panggilan pengambilan dengan ketangguhan terhadap satu perumusan yang buruk.

def multi_query(raw, n=4):
    queries = expand(raw, n)
    rankings = [dense_retrieve(q, 30) for q in queries]
    fused = rrf(*rankings)
    return dedup(fused)

Dekomposisi Kueri

Pertanyaan kompleks dan multi-langkah memerlukan dekomposisi menjadi subpertanyaan, yang masing-masing diambil secara terpisah, lalu digabungkan. Pertanyaan seperti CEO perusahaan yang mengakuisisi X lebih tua daripada siapa... tidak dapat dijawab dengan satu pengambilan.

Lakukan dekomposisi, ambil data untuk setiap subpertanyaan, lalu biarkan generator menggabungkan bukti yang terkumpul.

def decompose_and_retrieve(question):
    subs = parse_lines(llm(
        'Break this into independent sub-questions, one per line.\n' +
        question, temperature=0))
    evidence = {s: rerank(s, dense_retrieve(s, 30))[:3] for s in subs}
    return evidence  # generator synthesizes the final answer

HyDE: Gagasan Inti

HyDE (Hypothetical Document Embeddings, Gao dkk., 2022) membalikkan masalahnya. Alih-alih melakukan embedding pada kueri pendek, pendekatan ini meminta LLM untuk menghasilkan dokumen jawaban hipotetis, lalu melakukan embedding pada dokumen tersebut dan menggunakannya untuk pengambilan.

Dokumen hipotetis berada dalam ragam bahasa yang sama dengan dokumen nyata, sehingga embedding-nya lebih dekat dengan jawaban asli dan memperbaiki ketidakcocokan kueri-dokumen.

def hyde(query):
    hypo = llm(
        'Write a short passage that would answer this question, as if '
        'from a reference document.\nQuestion: ' + query,
        temperature=0.3)
    return dense_retrieve_by_vector(embed(hypo), k=30)  # embed the answer

Mengapa HyDE Meningkatkan Perolehan Kembali

Pertanyaan dan jawabannya dirumuskan secara berbeda; pertanyaan dan jawaban palsu tetapi masuk akal dirumuskan secara mirip dengan jawaban nyata. HyDE memanfaatkan prior generatif LLM untuk menjembatani kesenjangan tersebut, meskipun dokumen hipotetisnya mengandung kesalahan faktual.

Ketepatan dokumen hipotetis tidak terlalu penting: dokumen tersebut hanya perlu memiliki kosakata dan struktur yang tepat agar berada dekat dengan dokumen sebenarnya dalam ruang embedding.

# Robustness: average several hypothetical docs to reduce variance
def hyde_avg(query, n=3):
    vecs = [embed(llm(HYDE_PROMPT + query, temperature=0.5))
            for _ in range(n)]
    centroid = sum(vecs) / n
    return dense_retrieve_by_vector(centroid, 30)

Kompromi dan Mode Kegagalan HyDE

HyDE menambahkan pembuatan oleh LLM sebelum pengambilan, sehingga meningkatkan latensi dan biaya, serta dapat berhalusinasi menghasilkan dokumen hipotetis yang menyimpang dari topik. Hal ini dapat menurunkan perolehan kembali untuk kueri khusus atau di luar distribusi yang tidak dikenal model.

Kurangi dampaknya dengan menggabungkan pengambilan vektor HyDE dengan pengambilan kueri mentah melalui penggabungan, sehingga dokumen hipotetis yang buruk tidak dapat sepenuhnya menjatuhkan perolehan kembali.

def hyde_hybrid(query):
    a = dense_retrieve_by_vector(embed(hyde_doc(query)), 30)
    b = dense_retrieve(query, 30)          # raw-query fallback
    return dedup(rrf(a, b))                 # robust to bad hypotheticals

Memilih dan Menggabungkan Teknik

Transformasi-transformasi ini saling melengkapi. Gunakan pemadatan untuk percakapan, perluasan/multi-kueri untuk kesenjangan kosakata, dekomposisi untuk pertanyaan multi-langkah, dan HyDE untuk ketidakcocokan ragam bahasa pertanyaan-dokumen. Banyak susunan sistem produksi menjalankan pemadatan, kemudian HyDE, lalu menggabungkannya dengan kueri mentah, dan akhirnya melakukan pemeringkatan ulang.

Setiap transformasi tambahan membutuhkan satu panggilan LLM, jadi gunakan berdasarkan jenis kueri, bukan selalu menjalankan semuanya.

def route_transform(query, history, qtype):
    q = condense(history, query) if history else query
    if qtype == 'multi_hop': return decompose_and_retrieve(q)
    if qtype == 'mismatch':  return hyde_hybrid(q)
    if qtype == 'vocab_gap': return multi_query(q)
    return dense_retrieve(q, 30)

Mengevaluasi Transformasi

Ukur setiap transformasi berdasarkan peningkatan recall@k pada perolehan dan akurasi jawaban akhir dibandingkan dengan kueri mentah, menggunakan kumpulan data yang bebas kebocoran. Lacak latensi tambahan dan biaya LLM agar Anda hanya mempertahankan transformasi yang sepadan dengan biayanya.

Waspadai bahwa transformasi yang meningkatkan perolehan tetapi menambahkan pengalih perhatian dapat menurunkan akurasi jawaban jika tidak dipasangkan dengan pemeringkatan ulang dan kompresi.

def eval_transform(name, fn, eval_set):
    return {
        'recall@10': recall_at_k(eval_set, retriever=fn, k=10),
        'answer_acc': answer_accuracy(eval_set, retriever=fn),
        'extra_latency_ms': transform_latency(fn),
    }

Pemeriksaan Singkat

Jelaskan alasan HyDE dapat berfungsi meskipun hipotetisnya tidak sempurna.

Ringkasan

Hal-hal penting:

Perolehan dibatasi oleh kueri; mengubahnya merupakan peningkatan RAG yang murah dan berdampak besar.
Penulisan ulang/kondensasi membuat kueri percakapan dapat berdiri sendiri; perluasan dan multi-kueri mengatasi kesenjangan kosakata.
Dekomposisi menangani pertanyaan multi-langkah dengan melakukan perolehan untuk setiap subpertanyaan.
HyDE menyematkan jawaban hipotetis untuk menjembatani ketidaksesuaian ragam bahasa antara pertanyaan dan dokumen; hipotetis tersebut tidak harus benar.
Gabungkan transformasi berdasarkan jenis kueri, padukan dengan kueri mentah untuk ketahanan, lalu evaluasi perolehan, akurasi jawaban, latensi, dan biaya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penulisan Ulang Kueri dan HyDE” gratis?

Ya — teks lengkap “Penulisan Ulang Kueri dan HyDE” 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 “Penulisan Ulang Kueri dan HyDE”?

Meningkatkan perolehan kembali dalam pengambilan. 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 4 dari 4.

Berapa lama pelajaran “Penulisan Ulang Kueri dan HyDE” 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