AI Prompt Engineering · Pelajaran

Mengurutkan Ulang Potongan yang Diambil

Pengurutan ulang dengan penyandi silang.

Mengurutkan Ulang Potongan yang Diambil adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 2 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 Perlu Pemeringkatan Ulang

Pengambilan tahap pertama (padat atau renggang) mengoptimalkan perolehan kembali dalam skala besar: dapatkan potongan acuan di suatu posisi dalam 50 teratas. Proses ini cepat tetapi kasar. Kemudian, pemeringkat ulang tahap kedua mengurutkan kembali daftar pendek tersebut untuk meningkatkan presisi, sehingga potongan yang benar-benar relevan muncul di posisi teratas.

Pola mengambil secara luas lalu melakukan pemeringkatan ulang secara presisi ini merupakan tulang punggung RAG lanjutan.

def two_stage(query, k_retrieve=50, k_final=5):
    candidates = first_stage_retrieve(query, k_retrieve)  # high recall
    reranked = rerank(query, candidates)                  # high precision
    return reranked[:k_final]

Bi-Encoder versus Cross-Encoder

Bi-encoder mengodekan kueri dan dokumen secara terpisah menjadi vektor, lalu membandingkannya berdasarkan kosinus; prosesnya cepat dan dapat diindeks, tetapi interaksi antara kueri dan dokumen hilang. Cross-encoder memasukkan kueri dan kandidat secara bersama-sama ke dalam model, lalu menghasilkan skor relevansi yang menangkap interaksi secara terperinci.

Cross-encoder jauh lebih akurat tetapi tidak dapat dihitung sebelumnya, sehingga hanya dijalankan pada daftar pendek.

# Bi-encoder: score = cos(enc(q), enc(d))     -> precomputable
# Cross-encoder: score = model(q, d) -> 0..1   -> per-pair, no index
def cross_encode(query, doc):
    return cross_encoder.predict([(query, doc)])[0]  # joint attention

Satu Lintasan Pemeringkatan Ulang Cross-Encoder

Pemeringkat ulang menilai setiap kandidat terhadap kueri, lalu mengurutkannya secara menurun. Karena cross-encoder memperhatikan kueri dan dokumen secara bersamaan, model ini menyelesaikan relevansi yang lebih halus yang terlewat oleh bi-encoder: negasi, kebutuhan pencocokan tepat, dan perbedaan antara jawaban dan topik.

Tahap ini biasanya meningkatkan akurasi jawaban lebih besar daripada peningkatan RAG tunggal lainnya.

def rerank(query, candidates):
    pairs = [(query, c.text) for c in candidates]
    scores = cross_encoder.predict(pairs)        # batched
    for c, s in zip(candidates, scores):
        c.rerank_score = s
    return sorted(candidates, key=lambda c: c.rerank_score, reverse=True)

LLM sebagai Pemeringkat Ulang

Jika tidak ada cross-encoder terlatih yang sesuai dengan domain Anda, LLM dapat melakukan pemeringkatan ulang. Prompt berbasis daftar meminta model mengurutkan daftar bagian berdasarkan relevansi dalam satu pemanggilan; penilaian berbasis titik menilai setiap bagian secara independen.

Pendekatan berbasis daftar menangkap perbandingan relatif dan hemat token, tetapi waspadai bias posisi dan pastikan penguraian keluaran tetap tangguh terhadap kemungkinan model menghilangkan atau menggandakan ID.

def llm_listwise(query, candidates):
    passages = '\n'.join(
        '[' + str(i) + '] ' + c.text for i, c in enumerate(candidates)
    )
    prompt = (
        'Rank the passages by relevance to the query. '
        'Return only IDs, most relevant first.\nQuery: ' + query +
        '\n' + passages
    )
    order = parse_ids(llm(prompt, temperature=0))
    return [candidates[i] for i in order]

Latensi dan Ukuran Daftar Pendek

Biaya pemeringkatan ulang bertambah seiring ukuran daftar pendek. Cross-encoder pada 50 kandidat jauh lebih murah daripada pada 500 kandidat. Pilih k tahap pertama yang cukup besar untuk menangkap potongan acuan (validasi recall@k), tetapi cukup kecil agar dapat diperingkat ulang dalam anggaran latensi Anda.

Kelompokkan penilaian pasangan dan jalankan pada perangkat keras yang dipercepat; cross-encoder dapat diparalelkan dengan baik di antara pasangan.

def tune_shortlist(eval_set, ks=(20, 50, 100, 200)):
    # find smallest k where recall@k saturates -> rerank fewer pairs
    return {k: (recall_at_k(eval_set, k), rerank_latency(k)) for k in ks}

Tahap Pertama Hibrida dengan Pemeringkatan Ulang

Perolehan kembali terkuat berasal dari tahap pertama hibrida (dense + BM25 yang digabungkan), yang memasukkan daftar pendek tanpa duplikasi ke satu pemeringkat ulang. Dense memulihkan parafrasa; sparse memulihkan pengenal yang persis; lalu pengode silang mengurutkan gabungan tersebut berdasarkan relevansi sebenarnya.

Kombinasi ini tangguh untuk berbagai jenis kueri, mulai dari pertanyaan dalam bahasa alami hingga pencarian literal.

def hybrid_then_rerank(query, k_final=6):
    dense = dense_retrieve(query, 50)
    sparse = bm25_retrieve(query, 50)
    fused = dedup(rrf(dense, sparse))     # reciprocal rank fusion
    return rerank(query, fused)[:k_final]

Ambang Skor dan Batas

Skor pemeringkat ulang dapat dikalibrasi. Alih-alih selalu mengambil n teratas, terapkan ambang relevansi: pertahankan potongan yang melampaui suatu skor, dan jika tidak ada yang memenuhi syarat, kembalikan jawaban yang jujur bahwa jawabannya tidak tersedia. Ini mencegah pengisian perintah dengan teks tambahan yang relevansinya lemah.

Sesuaikan ambang pada set validasi untuk menyeimbangkan cakupan yang dapat dijawab dengan masuknya pengalih perhatian.

def threshold_select(reranked, tau=0.3, max_n=8):
    kept = [c for c in reranked if c.rerank_score >= tau][:max_n]
    if not kept:
        return None        # signal: no sufficiently relevant context
    return kept

Keberagaman Setelah Pemeringkatan Ulang

Pengurutan berdasarkan relevansi murni dapat mengembalikan beberapa potongan yang hampir identik dari dokumen yang sama sehingga memboroskan anggaran konteks. Terapkan MMR atau batas per dokumen setelah pemeringkatan ulang untuk memastikan set akhir mencakup aspek dan sumber yang berbeda.

Hal ini penting untuk pertanyaan multi-langkah yang jawabannya tersebar di beberapa dokumen.

def diversify(reranked, max_per_doc=2, k=6):
    out, per_doc = [], {}
    for c in reranked:
        d = c.meta['doc_id']
        if per_doc.get(d, 0) < max_per_doc:
            out.append(c)
            per_doc[d] = per_doc.get(d, 0) + 1
        if len(out) == k:
            break
    return out

Pengurutan untuk Generator

Setelah memilih potongan teratas, tempatkan potongan tersebut untuk memanfaatkan perhatian model. Mengingat fenomena informasi yang hilang di tengah, letakkan satu potongan dengan skor tertinggi di awal atau akhir konteks, bukan terkubur di antara potongan lainnya.

Beberapa pipeline mengurutkan potongan berdasarkan relevansi menaik agar potongan terbaik berada paling dekat dengan pertanyaan, meniru strategi kemutakhiran few-shot.

def order_for_llm(chunks):
    chunks = sorted(chunks, key=lambda c: c.rerank_score)  # ascending
    return chunks                 # most relevant chunk ends up last,
                                  # nearest the trailing question

Mengevaluasi Pemeringkat Ulang

Ukur pemeringkat ulang dengan metrik pemeringkatan, terutama NDCG dan MRR, berdasarkan relevansi kueri-potongan berlabel, lalu ukur akurasi jawaban pada tahap berikutnya. Pemeringkat ulang yang meningkatkan NDCG tetapi tidak meningkatkan jawaban mungkin hanya mengurutkan ulang potongan yang sudah dapat ditangani generator.

Selalu evaluasi kualitas tugas akhir secara menyeluruh, bukan hanya metrik pemeringkatan.

import math

def ndcg_at_k(relevances, k):
    dcg = sum(r / math.log2(i + 2) for i, r in enumerate(relevances[:k]))
    ideal = sorted(relevances, reverse=True)
    idcg = sum(r / math.log2(i + 2) for i, r in enumerate(ideal[:k]))
    return dcg / idcg if idcg else 0.0

Pipeline Pemeringkatan Ulang untuk Produksi

Dari awal hingga akhir: lakukan pengambilan hibrida untuk mendapatkan daftar pendek berisi 50 kandidat, hapus duplikasi, lakukan pemeringkatan ulang dengan pengode silang, terapkan ambang skor, tingkatkan keberagaman berdasarkan dokumen, urutkan untuk perhatian model, lalu buat jawaban dengan sitasi. Gunakan ambang sebagai gerbang untuk mengembalikan jawaban jujur bahwa tidak ada jawaban.

Cache embedding dan skor pemeringkat ulang untuk setiap (kueri, potongan) ketika lalu lintas berulang, agar biaya berkurang.

def pipeline(query):
    shortlist = hybrid_then_rerank(query, k_final=20)
    kept = threshold_select(shortlist, tau=0.3, max_n=8)
    if kept is None:
        return 'No relevant information found.'
    ctx = order_for_llm(diversify(kept))
    return generate_with_citations(query, ctx)

Pemeriksaan Singkat

Pilih arsitektur pemeringkatan ulang yang tepat.

Rangkuman

Hal-hal penting:

Lakukan pengambilan secara luas untuk memperoleh cakupan, lalu lakukan pemeringkatan ulang pada daftar pendek untuk meningkatkan ketepatan.
Pengode silang menilai pasangan kueri-dokumen secara bersama-sama (akurat, tetapi tidak dapat diindeks); pengode ganda cepat, tetapi kasar.
Pemeringkatan ulang berbasis daftar/titik oleh LLM adalah pilihan cadangan; perhatikan bias posisi dan penguraian.
Sesuaikan ukuran daftar pendek agar perolehan kembali mencapai titik jenuh dalam anggaran latensi; gabungkan dengan pengambilan tahap pertama hibrida.
Terapkan ambang skor, tingkatkan keberagaman berdasarkan dokumen, urutkan potongan untuk perhatian model, dan evaluasi dengan NDCG serta akurasi jawaban pada tahap berikutnya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengurutkan Ulang Potongan yang Diambil” gratis?

Ya — teks lengkap “Mengurutkan Ulang Potongan yang Diambil” 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 “Mengurutkan Ulang Potongan yang Diambil”?

Pengurutan ulang dengan penyandi silang. 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 2 dari 4.

Berapa lama pelajaran “Mengurutkan Ulang Potongan yang Diambil” 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