RAG (Retrieval-Augmented Generation) meleset bukan karena LLM-nya bodoh. Sembilan dari sepuluh kali, akar masalahnya ada di retrieval: chunk yang diambil tidak relevan, terpotong di tengah kalimat, atau tidak pernah muncul sama sekali di hasil pencarian. Kalau Anda hanya menilai jawaban akhir, Anda tidak akan pernah tahu chunk mana yang rusak.

Masalahnya, banyak tim langsung lari ke framework evaluasi berat—RAGAS, TruLens, DeepEval—lengkap dengan LLM judge yang mahal, lambat, dan tidak deterministik. Padahal untuk mendeteksi chunk buruk, Anda cuma butuh dua metrik klasik dari dunia information retrieval: Recall@k dan MRR. Tanpa framework, tanpa LLM judge, tanpa API key tambahan.

Kalau chunk yang benar tidak masuk ke top-k, sehebat apa pun LLM-nya, jawaban tetap salah. Ukur retrieval dulu, baru ukur generasi.

📌 Baca Juga (Machine Learning): RAG untuk Pemula: Membangun Knowledge Base dari Dokumen Anda

Kenapa Evaluasi RAG Tanpa Framework Justru Lebih Tajam

LLM judge punya tiga kelemahan struktural untuk tugas ini. Pertama, tidak deterministik—query yang sama bisa dinilai berbeda tiap run, sehingga Anda tidak bisa membandingkan konfigurasi chunking secara adil. Kedua, mahal dan lambat—50 pertanyaan × beberapa konfigurasi = ratusan panggilan API hanya untuk mengukur hal yang sebenarnya bisa dihitung dengan aritmetika sederhana. Ketiga, opaque—ketika skor turun, Anda tidak tahu apakah karena retrieval atau generasi.

Evaluasi retrieval murni bersifat deterministik, gratis, dan jalan dalam hitungan detik. Anda mengisolasi satu variabel: apakah chunk yang relevan berhasil diambil? Itu saja. Sisanya—kualitas jawaban—baru dinilai setelah retrieval terbukti sehat.

Langkah 1: Susun 50 Pertanyaan Emas

Pertanyaan emas (golden questions) adalah himpunan query uji yang mewakili pola pemakaian nyata, masing-masing dipetakan ke satu atau lebih chunk_id yang seharusnya diambil. Kunci: labelnya dibuat manual, bukan hasil generate LLM. Ini yang membuat evaluasi Anda punya ground truth.

Komposisi 50 Pertanyaan yang Sehat

  • 20 pertanyaan faktual tunggal — jawaban ada di satu chunk jelas. Contoh: "Berapa lama masa garansi produk X?"
  • 10 pertanyaan parafrase — maksud sama, kata berbeda. Menguji ketahanan embedding terhadap variasi bahasa.
  • 8 pertanyaan multi-hop — butuh 2–3 chunk sekaligus. Menguji apakah top-k cukup lebar.
  • 6 pertanyaan lintas-dokumen — jawaban tersebar di beberapa sumber.
  • 4 pertanyaan negatif — jawabannya memang tidak ada di korpus. Ground truth = himpunan kosong. Menguji apakah retriever memaksa mengambil chunk sampah.
  • 2 pertanyaan ambigu — sengaja tidak jelas, untuk melihat perilaku fallback.

Simpan dalam JSON sederhana. Tidak perlu database.

[
  {
    "id": "q01",
    "query": "Berapa lama masa garansi produk X?",
    "gold_chunks": ["doc_produk#sec3"],
    "type": "factual"
  },
  {
    "id": "q02",
    "query": "Bagaimana prosedur klaim garansi kalau barang rusak?",
    "gold_chunks": ["doc_produk#sec3", "doc_kebijakan#sec1"],
    "type": "multi_hop"
  }
]

Aturan penting: satu pertanyaan boleh punya lebih dari satu chunk emas. Jangan paksa satu-satu—itu justru menciptakan penalti palsu saat chunk yang benar-benar relevan terpecah jadi dua.

Langkah 2: Hitung Recall@k dan MRR

Dua metrik ini menangkap dua jenis kegagalan yang berbeda.

Recall@k — Apakah Jawabannya Ada di Top-k?

Recall@k mengukur proporsi chunk emas yang muncul dalam k hasil teratas. Nilai 1.0 berarti semua chunk relevan berhasil diambil; 0.0 berarti semuanya meleset.

Recall@k = (jumlah chunk emas di top-k) / (jumlah chunk emas)

Gunakan k yang sama dengan yang dipakai di produksi. Kalau sistem Anda mengambil top_k=5, maka ukur Recall@5. Mengukur Recall@20 saat produksi hanya pakai 5 adalah ilusi.

MRR — Seberapa Cepat Chunk Benar Muncul?

MRR (Mean Reciprocal Rank) mengukur posisi kemunculan chunk relevan pertama. Chunk benar di peringkat 1 memberi skor 1.0; di peringkat 5 memberi 0.2. MRR merata-ratakan ini di semua query.

MRR = rata-rata dari (1 / rank chunk relevan pertama)

Recall@k memberi tahu apakah Anda menemukannya. MRR memberi tahu seberapa tinggi kualitas pemeringkatannya. Retriever dengan Recall@5 tinggi tapi MRR rendah artinya chunk benar selalu ada di hasil—tapi terkubur di bawah chunk sampah. Itu masalah reranker, bukan masalah chunking.

Implementasi Tanpa Framework

import json

def recall_at_k(ranked_ids, gold_ids, k):
    top = set(ranked_ids[:k])
    if not gold_ids:
        return 1.0 if not top else 0.0   # query negatif
    return len(top & set(gold_ids)) / len(gold_ids)

def reciprocal_rank(ranked_ids, gold_ids):
    gold = set(gold_ids)
    for i, cid in enumerate(ranked_ids, 1):
        if cid in gold:
            return 1.0 / i
    return 0.0

def evaluate(retriever, questions, k=5):
    rows = []
    for q in questions:
        ranked = retriever(q["query"], k=k)   # list chunk_id, urut skor
        rows.append({
            "id": q["id"],
            "type": q["type"],
            "recall": recall_at_k(ranked, q["gold_chunks"], k),
            "rr": reciprocal_rank(ranked, q["gold_chunks"]),
        })
    n = len(rows)
    return {
        "recall@k": sum(r["recall"] for r in rows) / n,
        "mrr": sum(r["rr"] for r in rows) / n,
        "detail": rows,
    }

if __name__ == "__main__":
    qs = json.load(open("golden_questions.json"))
    # retriever = fungsi Anda sendiri
    # hasil = evaluate(retriever, qs, k=5)
    # assert 0.0 <= hasil["mrr"] <= 1.0

Total dependensi: json dari stdlib. Itu saja. Jalankan, simpan hasil per konfigurasi chunking, bandingkan.

Langkah 3: Baca Hasil, Deteksi Chunk Buruk

Angka agregat hanya pintu masuk. Yang membongkar chunk buruk adalah breakdown per pertanyaan. Sortir hasil berdasarkan skor terendah, lalu periksa pola.

Pola Diagnosis

  • Recall@k rendah merata di semua tipe — masalah embedding atau chunking terlalu kecil/besar. Cek ukuran chunk dulu.
  • Recall@k rendah hanya di tipe parafrase — model embedding lemah secara semantik. Ganti model, bukan chunk.
  • Recall@k rendah hanya di multi-hop — top-k terlalu sempit. Naikkan k atau tambahkan query expansion.
  • MRR rendah tapi Recall@k tinggi — chunk benar ada tapi bercampur sampah. Butuh reranker atau perbaikan metadata.
  • Query negatif mengambil chunk acak dengan skor tinggi — retriever tidak punya abstain. Tambahkan threshold skor minimum.

Chunk yang Tidak Pernah Muncul

Yang paling berharga: hitung frekuensi kemunculan setiap chunk_id di seluruh hasil retrieval. Chunk yang tidak pernah muncul di 50 query padahal ada di korpus adalah kandidat mati—entah isinya duplikat, terpotong, atau terlalu generik. Sebaliknya, chunk yang muncul di hampir semua query tapi bukan chunk emas adalah noise magnet: biasanya header navigasi, footer, atau daftar isi yang ikut terindeks.

Dua daftar ini—dead chunks dan noise chunks—adalah output paling actionable dari seluruh proses. Hapus yang pertama, pisahkan atau beri filter metadata untuk yang kedua. Sering kali Recall@5 langsung naik 15–30 poin hanya dari pembersihan ini, tanpa menyentuh model sama sekali.

Jebakan yang Sering Ditemui

Pertanyaan emas dibuat oleh LLM. Ini melingkar: LLM membuat pertanyaan dari chunk, lalu Anda menguji apakah chunk itu terambil. Hasilnya selalu bagus dan tidak bermakna. Tulis manual, atau minimal verifikasi manual.

Mengukur dengan k berbeda dari produksi. Sudah disebut di atas, tapi ini kesalahan paling umum. Metrik harus mencerminkan jalur nyata.

Mengabaikan query negatif. Sistem RAG yang tidak bisa bilang "saya tidak tahu" akan berhalusinasi. Query negatif adalah satu-satunya cara mengukur kemampuan abstain.

Menganggap MRR 0.7 itu buruk. Untuk korpus besar dengan banyak chunk mirip, MRR 0.6–0.8 sudah wajar. Bandingkan dengan baseline Anda sendiri, bukan dengan angka absolut dari blog orang lain.

💡 Baca Juga & Rekomendasi Jaringan AI Network:

  • Gunakan racikan prompt profesional di SolusiAI.my.id (Rekomendasi Tools & Otomatisasi AI).
  • Pelajari tutorial skrip dan otomatisasi teknis di PromptHack.my.id (Kumpulan AI Prompt & Content Growth).

Kesimpulan

RAG yang meleset hampir selalu bisa dilacak ke chunk yang buruk, dan chunk yang buruk bisa dideteksi tanpa framework mahal. Resepnya: 50 pertanyaan emas yang ditulis manual dan mencakup faktual, parafrase, multi-hop, lintas-dokumen, negatif, dan ambigu; lalu ukur Recall@k untuk tahu apakah jawaban berhasil diambil, dan MRR untuk tahu seberapa bersih pemeringkatannya.

Dua fungsi Python di atas—total di bawah 30 baris, nol dependensi eksternal—sudah cukup untuk membandingkan konfigurasi chunking secara deterministik dan gratis. Setelah itu, lihat breakdown per pertanyaan dan daftar frekuensi chunk untuk menemukan dead chunks dan noise chunks. Bersihkan keduanya, jalankan ulang evaluasi, dan lihat sendiri lompatan Recall@5-nya.

Baru setelah retrieval terbukti sehat, bicara soal LLM judge dan kualitas generasi. Mengukur generasi di atas retrieval yang rusak sama saja menilai riasan pada wajah yang salah arah.

Post a Comment

Lebih baru Lebih lama