AI Engineering Academy · Pelajaran

Metrik Pengambilan: Kadar Hit, MRR dan NDCG

Pelajaran 2 daripada 413 langkah

Metrik Pengambilan: Kadar Hit, MRR dan NDCG ialah pelajaran AI Engineering Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran AI Engineering Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Mengapa Metrik Capaian Semula Berbeza?

Kadar hit memberitahu anda sama ada bahagian yang berkaitan muncul di mana-mana dalam hasil teratas-K, tetapi tidak memberitahu kedudukannya dalam susunan. Sistem yang sentiasa meletakkan bahagian terbaik pada kedudukan 5 adalah lebih teruk daripada sistem yang secara konsisten meletakkannya pada kedudukan 1, walaupun kedua-duanya mempunyai kadar hit yang sama. Metrik yang lebih terperinci seperti MRR dan NDCG menangkap kualiti penyusunan, serta memberi ganjaran kepada sistem yang meletakkan bahagian paling berkaitan di bahagian teratas, tempat LLM dan pengguna paling berkemungkinan menggunakannya.

Kadar Hit @K: Ulasan dan Pelaksanaan

Kadar hit@K ialah metrik paling mudah: bagi berapakah pecahan pertanyaan sekurang-kurangnya satu bahagian yang berkaitan muncul dalam hasil teratas-K? Ia memberikan isyarat binari bagi setiap pertanyaan dan mudah ditafsirkan. Kira metrik ini dengan menyemak persilangan set antara ID yang dicapai semula dengan ID berkaitan yang diketahui. Gunakan K=5 sebagai lalai kerana kebanyakan sistem RAG mencapai semula 5 bahagian. Bandingkan kadar hit@1, @3 dan @5 untuk memahami perubahan kepekaan apabila anda meluaskan tetingkap capaian semula.

def hit_rate_at_k(golden_dataset, retriever, k=5):
    hits = 0
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=k)
        retrieved_ids = [r['id'] for r in retrieved[:k]]
        relevant_ids = set(item['relevant_chunk_ids'])
        if any(rid in relevant_ids for rid in retrieved_ids):
            hits += 1
    return hits / len(golden_dataset)

for k in [1, 3, 5, 10]:
    hr = hit_rate_at_k(golden_dataset, retriever, k=k)
    print(f'Hit rate@{k}: {hr:.1%}')

Purata Kedudukan Saling Balik (MRR)

MRR (Purata Kedudukan Saling Balik) mengukur purata nilai saling balik kedudukan tempat bahagian berkaitan yang pertama muncul. Jika bahagian berkaitan berada pada kedudukan 1, kedudukan saling balik ialah 1/1 = 1.0. Pada kedudukan 2, nilainya ialah 0.5, manakala pada kedudukan 5 nilainya ialah 0.2. MRR dipuratakan untuk semua pertanyaan. MRR yang lebih tinggi bermakna sistem capaian semula secara konsisten meletakkan bahagian berkaitan berhampiran bahagian teratas, yang penting kerana LLM memberikan lebih perhatian kepada konteks yang diletakkan lebih awal dalam arahan.

def mean_reciprocal_rank(golden_dataset, retriever, top_k=10):
    reciprocal_ranks = []
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=top_k)
        retrieved_ids = [r['id'] for r in retrieved]
        relevant_ids = set(item['relevant_chunk_ids'])

        rr = 0.0
        for rank, rid in enumerate(retrieved_ids, start=1):
            if rid in relevant_ids:
                rr = 1.0 / rank
                break  # only the first relevant result counts
        reciprocal_ranks.append(rr)

    mrr = sum(reciprocal_ranks) / len(reciprocal_ranks)
    print(f'MRR@{top_k}: {mrr:.3f}')
    return mrr

Mentafsir Skor MRR

Skor MRR mempunyai tafsiran yang intuitif: MRR = 1.0 bermakna bahagian berkaitan yang pertama sentiasa berada pada kedudukan 1 (sempurna). MRR = 0.5 bermakna bahagian itu biasanya berada pada kedudukan 2. MRR = 0.25 bermakna bahagian itu biasanya berada pada kedudukan 4 — maklumat berkaitan muncul cukup jauh ke bawah sehingga mungkin dipotong daripada konteks. Bagi RAG, sasarkan MRR > 0.7 untuk memastikan bahagian paling berkaitan anda secara konsisten berada dalam dua kedudukan pertama.

# MRR interpretation table
mrr_interpretations = {
    1.0:  'Perfect — relevant chunk always at rank 1',
    0.5:  'Good — typically at rank 2',
    0.33: 'Acceptable — typically at rank 3',
    0.25: 'Weak — typically at rank 4',
    0.1:  'Poor — relevant chunk rarely near the top'
}

for score, description in mrr_interpretations.items():
    print(f'MRR {score:.2f}: {description}')

Kejituan @K

Kejituan@K mengukur pecahan daripada K bahagian yang dicapai semula yang benar-benar berkaitan. Berbeza daripada kadar hit (yang bersifat binari), kejituan@K mengukur nisbah isyarat kepada hingar dalam hasil capaian semula anda. Kejituan yang rendah bermakna LLM menerima konteks yang tidak berkaitan bersama-sama bahagian yang berkaitan, lalu meningkatkan risiko kekeliruan atau suntikan arahan. Bagi RAG, kejituan@5 > 0.6 ialah sasaran yang baik.

def precision_at_k(golden_dataset, retriever, k=5):
    precisions = []
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=k)
        retrieved_ids = [r['id'] for r in retrieved[:k]]
        relevant_ids = set(item['relevant_chunk_ids'])

        relevant_retrieved = sum(
            1 for rid in retrieved_ids if rid in relevant_ids
        )
        precision = relevant_retrieved / k
        precisions.append(precision)

    mean_precision = sum(precisions) / len(precisions)
    print(f'Precision@{k}: {mean_precision:.3f}')
    return mean_precision

Keuntungan Terkumpul Terdiskaun (DCG)

DCG ialah metrik penilaian senarai tersusun yang memberikan ganjaran kerana meletakkan bahagian yang lebih berkaitan di kedudukan lebih tinggi. Metrik ini menjumlahkan skor perkaitan bahagian yang dicapai semula, tetapi mendiskaunkannya secara logaritma mengikut kedudukan: kedudukan 1 menerima kredit penuh, kedudukan 2 menerima diskaun log(2), dan seterusnya. Bahagian yang lebih berkaitan di bahagian atas menghasilkan DCG yang lebih tinggi. Versi dinormalkan (NDCG) membahagikan nilai tersebut dengan DCG ideal (susunan terbaik yang mungkin) untuk menghasilkan skor antara 0 dan 1.

import math

def dcg_at_k(relevances, k):
    '''relevances[i] = 1 if chunk at rank i+1 is relevant, else 0'''
    dcg = 0.0
    for i, rel in enumerate(relevances[:k]):
        # rank is i+1, discount is log2(rank + 1)
        dcg += rel / math.log2(i + 2)
    return dcg

def ndcg_at_k(retrieved_ids, relevant_ids, k):
    relevances = [1 if rid in relevant_ids else 0
                  for rid in retrieved_ids[:k]]
    actual_dcg = dcg_at_k(relevances, k)
    ideal_dcg = dcg_at_k([1] * min(len(relevant_ids), k), k)
    return actual_dcg / ideal_dcg if ideal_dcg > 0 else 0.0

Mengira NDCG Merentas Set Data

NDCG@K ialah metrik piawai emas bagi capaian semula sistem carian. Metrik ini menangkap perkaitan dan kedudukan dalam susunan secara serentak. NDCG@5 sebanyak 0.85 bermakna sistem capaian semula anda mencapai 85% daripada susunan terbaik teori secara purata. NDCG mengendalikan kes yang mempunyai beberapa bahagian berkaitan bagi setiap pertanyaan (setiap satu menerima skor perkaitan) dan menghukum sistem yang menemukan bahagian berkaitan tetapi meletakkannya terlalu rendah dalam susunan.

def mean_ndcg_at_k(golden_dataset, retriever, k=5):
    ndcg_scores = []
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=k)
        retrieved_ids = [r['id'] for r in retrieved[:k]]
        relevant_ids = set(item['relevant_chunk_ids'])
        score = ndcg_at_k(retrieved_ids, relevant_ids, k)
        ndcg_scores.append(score)
    mean = sum(ndcg_scores) / len(ndcg_scores)
    print(f'NDCG@{k}: {mean:.4f}')
    return mean

# Compute all retrieval metrics together
hit_rate = hit_rate_at_k(golden_dataset, retriever, k=5)
mrr = mean_reciprocal_rank(golden_dataset, retriever, top_k=5)
ndcg = mean_ndcg_at_k(golden_dataset, retriever, k=5)

Menggunakan RAGAS untuk Metrik Automatik

Pustaka RAGAS menyediakan rangka kerja penilaian yang sedia untuk pengeluaran bagi sistem RAG. Pustaka ini melaksanakan metrik kejituan konteks, dapatan semula konteks, kesetiaan dan perkaitan jawapan menggunakan pendekatan LLM sebagai penilai. Hantarkan soalan, jawapan, konteks yang dicapai semula dan jawapan rujukan anda kepada RAGAS untuk menerima laporan penilaian penuh dengan skor bagi setiap metrik. Ini ialah cara terpantas untuk menyediakan pipeline penilaian RAG yang menyeluruh.

from ragas import evaluate
from ragas.metrics import (
    context_precision,
    context_recall,
    faithfulness,
    answer_relevancy
)
from datasets import Dataset

eval_data = Dataset.from_list([
    {
        'question': item['question'],
        'answer': item['generated_answer'],
        'contexts': item['retrieved_texts'],
        'ground_truth': item['expected_answer']
    }
    for item in golden_dataset_with_answers
])

results = evaluate(
    eval_data,
    metrics=[context_precision, context_recall, faithfulness, answer_relevancy]
)
print(results)

Membahagikan Metrik Mengikut Kategori Pertanyaan

Metrik purata keseluruhan menyembunyikan corak penting. Bahagikan set data emas anda kepada kategori — carian fakta, perbandingan, soalan prosedur cara melakukan sesuatu dan soalan di luar skop — kemudian kira metrik secara berasingan bagi setiap kategori. Anda mungkin mendapati bahawa kadar hit ialah 95% untuk carian fakta tetapi hanya 60% untuk perbandingan berbilang lompatan. Metrik pada peringkat kategori mendedahkan mod kegagalan khusus yang disembunyikan oleh skor agregat.

from collections import defaultdict

def evaluate_by_category(golden_dataset, retriever):
    by_category = defaultdict(list)
    for item in golden_dataset:
        category = item.get('category', 'unknown')
        retrieved = retriever.retrieve(item['question'], top_k=5)
        retrieved_ids = {r['id'] for r in retrieved}
        hit = bool(retrieved_ids & set(item['relevant_chunk_ids']))
        by_category[category].append(hit)

    print('Hit rate by category:')
    for cat, hits in sorted(by_category.items()):
        hr = sum(hits) / len(hits)
        print(f'  {cat}: {hr:.1%} ({sum(hits)}/{len(hits)})')

Apabila Metrik Tidak Selaras

Kadangkala metrik memberikan isyarat yang bercanggah. Anda mungkin meningkatkan NDCG (susunan yang lebih baik) sementara kadar hit kekal sama (bilangan kegagalan yang sama). Hal ini berlaku apabila pengoptimuman mengalihkan bahagian berkaitan daripada kedudukan 6 ke kedudukan 2 tanpa membawa pertanyaan yang sebelum ini gagal ke dalam lima teratas. Dalam keadaan sedemikian, semak sama ada pengoptimuman anda membantu pertanyaan yang sudah berjaya tetapi mengabaikan pertanyaan yang gagal. Sentiasa teliti contoh kegagalan individu di samping metrik agregat.

def analyze_failures(golden_dataset, retriever, top_k=5):
    failures = []
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=top_k)
        retrieved_ids = {r['id'] for r in retrieved}
        relevant_ids = set(item['relevant_chunk_ids'])
        if not (retrieved_ids & relevant_ids):
            failures.append({
                'question': item['question'],
                'expected_chunks': list(relevant_ids),
                'retrieved_chunks': [r['id'] for r in retrieved],
                'top_score': retrieved[0]['score'] if retrieved else None
            })
    print(f'Failures: {len(failures)}/{len(golden_dataset)}')
    return failures

Dapatan Semula @K: Kesempurnaan Capaian Semula

Dapatan semula@K mengukur pecahan semua bahagian berkaitan yang dicapai semula dalam hasil teratas-K. Jika sesuatu soalan mempunyai 3 bahagian berkaitan dalam indeks dan sistem capaian semula anda mengembalikan 2 daripadanya dalam lima teratas, dapatan semula@5 ialah 2/3 = 0.67. Dapatan semula yang tinggi penting apabila LLM memerlukan beberapa bukti untuk mensintesis jawapan yang lengkap — kehilangan walaupun satu bahagian utama boleh menyebabkan jawapan tidak lengkap. Seimbangkan kejituan dan dapatan semula dengan melaraskan K: K yang lebih besar meningkatkan dapatan semula tetapi mengurangkan kejituan.

def recall_at_k(golden_dataset, retriever, k=5):
    recalls = []
    for item in golden_dataset:
        retrieved = retriever.retrieve(item['question'], top_k=k)
        retrieved_ids = set(r['id'] for r in retrieved[:k])
        relevant_ids = set(item['relevant_chunk_ids'])
        if not relevant_ids:
            continue  # skip items with no annotated relevant chunks
        retrieved_relevant = retrieved_ids & relevant_ids
        recall = len(retrieved_relevant) / len(relevant_ids)
        recalls.append(recall)
    mean_recall = sum(recalls) / len(recalls)
    print(f'Recall@{k}: {mean_recall:.3f}')
    return mean_recall

Semakan Pantas

Uji pemahaman anda tentang konsep Kejuruteraan AI daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari: kadar hit@K sebagai metrik kehadiran binari, MRR untuk mengukur purata kedudukan bahagian berkaitan yang pertama, kejituan@K untuk mengukur nisbah isyarat kepada hingar capaian semula, NDCG@K sebagai metrik susunan piawai emas, dan pustaka RAGAS untuk mengautomatikkan penilaian RAG dengan kejituan konteks, dapatan semula, kesetiaan dan perkaitan jawapan. Seterusnya, kita akan mendalami metrik penjanaan dan pengukuran kesetiaan.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Metrik Pengambilan: Kadar Hit, MRR dan NDCG” percuma?

Ya — teks penuh “Metrik Pengambilan: Kadar Hit, MRR dan NDCG” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus AI Engineering Academy, tingkat taraf kepada CoddyKit PRO. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Metrik Pengambilan: Kadar Hit, MRR dan NDCG”?

Bina set data piawai yang mengandungi pertanyaan dan dokumen berkaitan, kemudian kira kadar hit, kedudukan timbal balik min dan NDCG untuk mengukur kekerapan pengambil anda menemui bahagian yang betu… Anda berlatih AI Engineering Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan AI Engineering Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran AI Engineering Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Metrik Pengambilan: Kadar Hit, MRR dan NDCG” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Sebab Penilaian Penting dalam RAG
Metrik Pengambilan: Kadar Hit, MRR dan NDCG
Metrik Penjanaan: Kesetiaan dan Perkaitan Jawapan
Membina Abah-abah Penilaian Automatik

← Kembali ke AI Engineering Academy