AI Engineering Academy · Pelajaran

Pola LLM sebagai Penilai

Pola LLM sebagai Penilai adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Mengapa Evaluasi Otomatis Diperlukan

Mengevaluasi keluaran LLM secara manual membutuhkan waktu dan biaya besar. Tim penilai manusia mungkin hanya dapat mengevaluasi beberapa ratus keluaran per minggu, sedangkan sistem produksi menghasilkan ribuan keluaran per hari. LLM-sebagai-penilai menggunakan model bahasa yang kuat untuk mengevaluasi kualitas keluaran LLM lain dalam skala besar, sehingga memungkinkan pengujian regresi otomatis dan pemantauan kualitas berkelanjutan tanpa harus mempekerjakan banyak anotator.

Gagasan Inti: Satu LLM Mengevaluasi LLM Lain

Dalam LLM-sebagai-penilai, Anda mengirim perintah sistem yang mendefinisikan kriteria evaluasi, pertanyaan asli, jawaban model, dan, secara opsional, jawaban referensi kepada model penilai (biasanya GPT-4o atau Claude). Penilai mengembalikan skor numerik, label, atau peringkat. Hal ini dapat dilakukan karena model-model tercanggih cukup memahami konsep kualitas seperti kebenaran, kebermanfaatan, dan koherensi.

JUDGE_SYSTEM_PROMPT = '''
You are an expert evaluator of AI-generated responses.
Given a question and an AI-generated answer, score the answer on:
- Correctness (0-5): Is the information factually accurate?
- Completeness (0-5): Does it fully address the question?
- Clarity (0-5): Is it easy to understand?
Return a JSON object with scores and a brief rationale.
'''

Menulis Perintah Penilai

Perintah penilai yang baik menentukan rubrik eksplisit dengan definisi skor, bukan istilah samar seperti 'baik' atau 'buruk'. Tentukan secara konkret arti skor 5, 3, dan 1 untuk setiap kriteria. Berikan pertanyaan, jawaban yang dinilai, dan, secara opsional, jawaban referensi. Minta alasan sebelum skor (rantai pemikiran) untuk mengurangi pemberian skor secara sembarangan.

def build_judge_prompt(question: str, answer: str, reference: str = None) -> str:
    ref_section = f'Reference answer:\n{reference}\n\n' if reference else ''
    return f'''
Question: {question}

{ref_section}Answer to evaluate:
{answer}

Score this answer on correctness (1-5) where:
5 = Completely accurate, no factual errors
3 = Mostly accurate with minor errors
1 = Contains significant factual errors

First explain your reasoning, then provide the score as JSON:
{{"correctness": <1-5>, "rationale": "..."}}
'''

Memanggil Model Penilai

Panggil model penilai dengan perintah evaluasi Anda. Uraikan respons JSON untuk mengambil skor. Selalu gunakan keluaran terstruktur atau mode JSON agar penilai mengembalikan data yang dapat diuraikan. Menggunakan model yang sama sebagai sistem yang diuji dan sebagai penilai dapat menimbulkan bias — sebaiknya gunakan model yang berbeda atau setidaknya konfigurasi yang berbeda untuk penilai.

from pydantic import BaseModel
import instructor
from openai import OpenAI

class JudgeScore(BaseModel):
    correctness: int
    completeness: int
    clarity: int
    rationale: str

judge_client = instructor.from_openai(OpenAI())

def judge(question: str, answer: str) -> JudgeScore:
    return judge_client.chat.completions.create(
        model='gpt-4o',  # Use stronger judge than the model being tested
        response_model=JudgeScore,
        messages=[
            {'role': 'system', 'content': JUDGE_SYSTEM_PROMPT},
            {'role': 'user', 'content': build_judge_prompt(question, answer)}
        ]
    )

Penilaian Tanpa Referensi vs Berbasis Referensi

Ada dua mode penilaian LLM. Penilaian tanpa referensi meminta penilai mengevaluasi kualitas tanpa jawaban kebenaran dasar — berguna ketika jawaban kebenaran dasar tidak ada, seperti dalam percakapan terbuka. Penilaian berbasis referensi menyediakan jawaban standar emas dan menanyakan apakah jawaban model sesuai dengannya — lebih baik untuk menjawab pertanyaan faktual yang jawabannya diketahui. Gunakan penilaian berbasis referensi jika Anda memiliki kumpulan data pengujian berlabel.

# Reference-free: good for open-ended generation
judge_result = judge(question='What is machine learning?', answer=model_answer)

# Reference-based: better for factual QA
judge_result = judge(
    question='What year was Python created?',
    answer=model_answer,
    reference='Python was created by Guido van Rossum and released in 1991.'
)

Mengendalikan Bias Penilai

Penilai LLM memiliki bias yang telah diketahui: mereka lebih menyukai jawaban yang lebih panjang (bias kebertele-telean), jawaban yang terdengar percaya diri, dan jawaban yang sesuai dengan gaya data pelatihannya. Kurangi bias kebertele-telean dengan secara eksplisit memberikan penalti untuk panjang yang tidak perlu dalam rubrik Anda. Kurangi bias posisi dalam perbandingan berpasangan dengan mengacak jawaban yang muncul lebih dahulu dan merata-ratakan skor dari kedua urutan tersebut.

# Anti-verbosity note in rubric:
ANTI_VERBOSITY_CLAUSE = '''
Note: A concise, accurate answer should score higher than a long,
rambling answer that happens to contain the correct information.
Do not reward length for its own sake.
'''

# Position-debiasing for pairwise comparison:
async def debiased_pairwise(q, a, b):
    score_ab = await compare(q, answer_a=a, answer_b=b)
    score_ba = await compare(q, answer_a=b, answer_b=a)
    # A wins if it wins in both orderings
    a_wins = (score_ab == 'A' and score_ba == 'B')
    return 'A' if a_wins else 'B' if (score_ab == 'B' and score_ba == 'A') else 'tie'

Mengelompokkan Evaluasi untuk Mempercepat Proses

Jalankan evaluasi penilai secara paralel untuk mengevaluasi kumpulan data pengujian yang besar dengan cepat. Dengan asyncio dan semaphore, Anda dapat mengevaluasi ratusan keluaran per menit. Sediakan anggaran batas laju terpisah untuk panggilan penilai (panggilan tersebut juga menggunakan token) dan pertimbangkan untuk menggunakan model penilai yang lebih kecil tetapi tetap mumpuni seperti GPT-4o-mini untuk kriteria yang tidak memerlukan penalaran mendalam, sehingga GPT-4o dapat digunakan untuk kriteria yang paling kritis.

import asyncio

async def batch_judge(qa_pairs: list, concurrency: int = 20) -> list:
    sem = asyncio.Semaphore(concurrency)

    async def judge_one(item):
        async with sem:
            return await async_judge(item['question'], item['answer'])

    return await asyncio.gather(
        *[judge_one(item) for item in qa_pairs],
        return_exceptions=True
    )

Menggabungkan Skor Penilai

Setelah mengevaluasi kumpulan data pengujian, gabungkan skor menjadi statistik ringkasan: mean, median, dan persentase respons yang skornya di atas ambang kualitas (seperti correctness ≥ 4). Bandingkan hasil gabungan ini antara versi model atau variasi perintah. Penurunan lebih dari 5% pada tingkat yang melampaui ambang seharusnya memicu peninjauan sebelum versi baru diterapkan.

import statistics

def summarize_judge_results(scores: list) -> dict:
    correctness = [s.correctness for s in scores if isinstance(s, JudgeScore)]
    return {
        'n': len(correctness),
        'mean_correctness': round(statistics.mean(correctness), 2),
        'median_correctness': statistics.median(correctness),
        'pct_above_4': round(100 * sum(1 for s in correctness if s >= 4) / len(correctness), 1)
    }

Membandingkan Versi LLM dengan Penilai

Gunakan LLM-sebagai-penilai untuk membandingkan dua versi sistem Anda — misalnya, sebelum dan sesudah perubahan perintah. Jalankan kedua versi pada kumpulan pertanyaan pengujian yang sama, nilai semua keluaran, lalu hitung tingkat kemenangan: persentase kasus ketika versi B memperoleh skor lebih tinggi daripada versi A. Tingkat kemenangan di atas 55% pada lebih dari 100 sampel biasanya cukup signifikan secara statistik untuk membenarkan penerapan versi baru.

async def ab_compare(test_questions: list, version_a, version_b) -> dict:
    a_wins = b_wins = ties = 0
    for q in test_questions:
        answer_a = await version_a.answer(q)
        answer_b = await version_b.answer(q)
        winner = await debiased_pairwise(q, answer_a, answer_b)
        if winner == 'A': a_wins += 1
        elif winner == 'B': b_wins += 1
        else: ties += 1
    total = len(test_questions)
    return {'a_win_rate': a_wins/total, 'b_win_rate': b_wins/total, 'tie_rate': ties/total}

Mengalibrasi Skor Penilai terhadap Manusia

Validasi penilai Anda dengan membandingkan skornya dengan penilaian manusia pada kumpulan kalibrasi yang terdiri atas 50–200 contoh. Hitung korelasi Pearson antara skor penilai dan skor manusia. Korelasi di atas 0,7 menunjukkan bahwa penilai tersebut dapat diandalkan. Jika korelasinya rendah, audit perintah penilai untuk melihat bagian yang tidak disepakati penilai dengan manusia, lalu tambahkan contoh atau klarifikasi ke dalam rubrik. Jangan pernah menerapkan penilai tanpa kalibrasi.

from scipy.stats import pearsonr

def calibrate_judge(human_scores: list, judge_scores: list) -> dict:
    corr, p_value = pearsonr(human_scores, judge_scores)
    mean_abs_error = sum(abs(h - j) for h, j in zip(human_scores, judge_scores)) / len(human_scores)
    return {
        'pearson_r': round(corr, 3),
        'p_value': round(p_value, 4),
        'mean_abs_error': round(mean_abs_error, 2),
        'reliable': corr >= 0.7
    }

Kapan Tidak Menggunakan LLM-sebagai-Penilai

LLM-sebagai-penilai tidak sesuai untuk setiap skenario evaluasi. Hindari penggunaannya ketika: kriterianya memerlukan keahlian bidang yang tidak dimiliki model penilai (akurasi diagnosis medis, kepatuhan hukum), Anda memerlukan evaluasi yang dapat dipertanggungjawabkan secara hukum (peninjauan manusia diperlukan), Anda mengevaluasi model yang lebih kuat daripada penilai (penilai tidak dapat menilai keluaran yang tidak mampu dihasilkannya secara andal), atau anggaran evaluasi terlalu terbatas untuk menanggung biaya API tambahan. Dalam kasus ini, gunakan evaluasi manusia atau metrik deterministik.

# Appropriate uses of LLM-as-judge:
# YES: General helpfulness, clarity, tone, factual accuracy (general knowledge)
# YES: Code correctness for common languages
# YES: Translation quality comparison
# YES: Content safety classification
#
# NOT appropriate:
# NO: Medical/legal/financial accuracy (needs domain expert)
# NO: Evaluating GPT-4o with GPT-4o (same capability ceiling)
# NO: Formal compliance audits (non-deterministic judge)
# NO: Streaming quality at individual token level

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola evaluasi LLM-sebagai-penilai.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa LLM-sebagai-penilai menggunakan model yang kuat untuk mengevaluasi kualitas dalam skala besar dengan rubrik eksplisit, mode tanpa referensi dan berbasis referensi sesuai untuk skenario evaluasi yang berbeda, dan kalibrasi terhadap penilaian manusia memvalidasi keandalan penilai sebelum digunakan di lingkungan produksi. Selanjutnya, kita akan menerapkan strategi evaluasi titik per titik dan berpasangan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola LLM sebagai Penilai” gratis?

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

Apa yang akan aku pelajari di “Pola LLM sebagai Penilai”?

Pahami cara memberikan perintah kepada LLM yang kuat untuk menilai atau membandingkan keluaran berdasarkan kriteria seperti ketepatan, kebermanfaatan, dan nada, serta alasan pendekatan ini lebih muda… Kamu berlatih AI Engineering Academy 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 Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy 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 1 dari 4.

Berapa lama pelajaran “Pola LLM sebagai Penilai” 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 Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy 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

Pola LLM sebagai Penilai
Evaluasi Per Respons dan Berpasangan
Mengalibrasi Model Penilai terhadap Manusia
Membangun Alur Kerja Evaluasi Berkelanjutan

← Kembali ke AI Engineering Academy