AI Engineering Academy · Pelajaran

Mengalibrasi Model Penilai terhadap Manusia

Kumpulkan dataset dasar kebenaran berisi penilaian preferensi manusia, ukur kesepakatan antara penilai dan manusia dengan Kappa Cohen, lalu sesuaikan prompt penilai untuk mengurangi bias sistematis.

Pelajaran 3 dari 413 langkah

Mengalibrasi Model Penilai terhadap Manusia adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 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 Kalibrasi Tidak Dapat Ditawar

Penilai LLM yang belum dikalibrasi mungkin secara sistematis memberikan skor keluaran lebih tinggi atau lebih rendah daripada manusia, lebih menyukai gaya penulisan tertentu, atau gagal menangani kasus batas yang tidak diantisipasi oleh rubrik Anda. Jika Anda menggunakan penilai semacam itu untuk mengambil keputusan penerapan, berarti Anda mempercayai instrumen yang bias. Kalibrasi memvalidasi penilai terhadap kebenaran dasar dari manusia dan mengukur seberapa besar skor tersebut dapat dipercaya sebelum digunakan dalam produksi.

Membangun Kumpulan Data Kalibrasi

Buat kumpulan kalibrasi yang terdiri dari 100–500 contoh respons yang telah dinilai oleh manusia. Usahakan keberagaman: sertakan respons berkualitas tinggi (skor 5), berkualitas sedang (skor 3), dan jelas buruk (skor 1). Minta 3–5 penilai manusia independen menilai setiap contoh untuk mengukur kesepakatan antarpenilai dan menghitung skor kebenaran dasar konsensus dengan mengambil rata-rata atau modus.

# Calibration dataset structure:
# [
#   {
#     'question': 'What causes inflation?',
#     'response': '...',
#     'human_scores': [4, 4, 3, 5, 4],  # 5 raters
#     'human_consensus': 4,              # mean or mode
#     'rater_ids': ['r1', 'r2', 'r3', 'r4', 'r5']
#   },
#   ...
# ]

# Typical calibration set composition:
# 30% excellent responses (score 4-5)
# 40% adequate responses (score 2-4)
# 30% poor responses (score 1-2)
# Include adversarial / edge cases

Mengukur Kesepakatan Antarpenilai

Sebelum mempercayai skor manusia sebagai kebenaran dasar, pastikan para penilai manusia saling sepakat. Kappa Cohen mengukur kesepakatan antara dua penilai di luar kesepakatan yang terjadi secara kebetulan: di atas 0,6 dapat diterima, sedangkan di atas 0,8 sangat baik. Untuk skala 5 poin, hitung kappa berbobot (bobot linear). Kesepakatan antarpenilai yang rendah berarti tugas tersebut didefinisikan secara ambigu — perbaiki panduan penilai sebelum menggunakan skor untuk mengalibrasi penilai.

from sklearn.metrics import cohen_kappa_score
import numpy as np

def measure_inter_rater_agreement(rater1_scores: list, rater2_scores: list) -> dict:
    kappa = cohen_kappa_score(rater1_scores, rater2_scores, weights='linear')
    exact_agreement = sum(a == b for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
    adjacent_agreement = sum(abs(a - b) <= 1 for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
    return {
        'weighted_kappa': round(kappa, 3),
        'exact_agreement': round(exact_agreement, 3),
        'adjacent_agreement': round(adjacent_agreement, 3),
        'acceptable': kappa >= 0.6
    }

Menjalankan Penilai pada Data Kalibrasi

Jalankan penilai LLM pada setiap contoh dalam kumpulan kalibrasi menggunakan perintah yang sama dengan yang akan Anda gunakan dalam produksi. Kumpulkan skor penilai untuk setiap contoh bersama skor konsensus manusia. Pertahankan agar kedua daftar ini tetap sejajar sehingga Anda dapat membandingkannya elemen demi elemen. Perbandingan ini mengungkap bias sistematis dan perbedaan rentang skor.

async def run_judge_on_calibration(calibration_set: list) -> list:
    pairs = []
    for item in calibration_set:
        judge_result = await async_judge(item['question'], item['response'])
        pairs.append({
            'question': item['question'],
            'human': item['human_consensus'],
            'judge': judge_result.correctness,
            'judge_rationale': judge_result.rationale
        })
    return pairs

Menghitung Korelasi Penilai dan Manusia

Hitung korelasi Pearson antara skor penilai dan skor konsensus manusia. Ini mengukur kesesuaian linear: korelasi 1,0 berarti penilai mengikuti peringkat manusia dengan sempurna. Hitung juga galat absolut rata-rata (MAE) untuk memahami selisih skor rata-rata. Korelasi di atas 0,7 dan MAE di bawah 0,8 poin pada skala 5 poin biasanya menunjukkan penilai yang cukup andal untuk digunakan dalam produksi.

from scipy.stats import pearsonr, spearmanr
import numpy as np

def calibration_metrics(pairs: list) -> dict:
    humans = [p['human'] for p in pairs]
    judges = [p['judge'] for p in pairs]
    pearson_r, p_val = pearsonr(humans, judges)
    spearman_r, _ = spearmanr(humans, judges)
    mae = np.mean([abs(h - j) for h, j in zip(humans, judges)])
    return {
        'pearson_r': round(pearson_r, 3),
        'spearman_r': round(spearman_r, 3),
        'p_value': round(p_val, 5),
        'mae': round(mae, 3),
        'reliable': pearson_r >= 0.7 and mae <= 0.8
    }

Mengidentifikasi Bias Sistematis

Selain korelasi, carilah bias sistematis: apakah penilai secara konsisten memberikan skor terlalu tinggi atau terlalu rendah? Buat grafik skor penilai terhadap skor manusia dan cari garis regresi yang tidak melalui titik asal. Jika penilai memberikan skor 4 saat manusia rata-rata memberikan skor 3, berarti penilai tersebut memiliki bias inflasi. Perbaiki hal ini dengan menyesuaikan rubrik atau menerapkan transformasi kalibrasi linear pada skor mentah.

import numpy as np
from scipy import stats

def detect_score_bias(pairs: list) -> dict:
    humans = np.array([p['human'] for p in pairs])
    judges = np.array([p['judge'] for p in pairs])
    slope, intercept, r, p, se = stats.linregress(judges, humans)
    bias = np.mean(judges - humans)  # positive = judge over-scores
    return {
        'mean_bias': round(bias, 3),  # > 0 means judge inflates
        'calibration_slope': round(slope, 3),
        'calibration_intercept': round(intercept, 3),
        # Corrected score = slope * judge_score + intercept
        'correction_formula': f'human_score ≈ {slope:.2f} * judge + {intercept:.2f}'
    }

Menerapkan Koreksi Kalibrasi

Setelah memperoleh regresi kalibrasi (kemiringan dan intersep), terapkan regresi tersebut untuk mengubah skor penilai mentah menjadi skor terkalibrasi yang lebih sesuai dengan penilaian manusia. Koreksi linear ini sederhana dan efektif. Batasi skor yang telah dikoreksi ke rentang yang valid (1–5) untuk mencegah nilai di luar rentang akibat regresi. Simpan skor mentah dan skor yang telah dikoreksi agar dapat dibandingkan kembali seiring bertambahnya data kalibrasi.

def calibrate_score(raw_judge_score: float, slope: float, intercept: float,
                    min_score: int = 1, max_score: int = 5) -> float:
    corrected = slope * raw_judge_score + intercept
    return max(min_score, min(max_score, round(corrected, 1)))

# Example: if judge inflates by 0.5 points on average
# slope=0.85, intercept=0.3
# raw_score=4 -> corrected = 0.85*4 + 0.3 = 3.7

Menemukan Pola Kesalahan Sistematis

Kelompokkan kesalahan kalibrasi berdasarkan jenis pertanyaan, panjang respons, dan bidang topik untuk menemukan kegagalan berpola. Penilai mungkin tidak andal pada pertanyaan pengodean teknis, tetapi akurat pada pertanyaan faktual. Penilai mungkin memberikan skor terlalu tinggi pada respons yang sangat panjang, tetapi terlalu rendah pada jawaban singkat dan padat. Pola-pola ini membantu menyempurnakan rubrik secara terarah atau membuat perintah penilai khusus topik untuk bidang yang kalibrasinya paling lemah.

from collections import defaultdict

def error_by_category(pairs: list) -> dict:
    by_cat = defaultdict(list)
    for p in pairs:
        error = abs(p['judge'] - p['human'])
        by_cat[p.get('category', 'unknown')].append(error)
    return {
        cat: {
            'mean_error': round(sum(errs)/len(errs), 2),
            'max_error': max(errs),
            'n': len(errs)
        }
        for cat, errs in by_cat.items()
    }

Mengalibrasi Ulang Seiring Bertambahnya Data

Kalibrasi bukanlah pekerjaan satu kali. Seiring Anda mengumpulkan lebih banyak penilaian manusia dan pembaruan model mengubah perilaku penilai, jalankan kembali kalibrasi setiap tiga bulan. Pantau metrik kalibrasi dari waktu ke waktu — jika korelasi Pearson turun di bawah 0,7, selidiki apakah pembaruan model mengubah distribusi skor penilai. Otomatiskan pipeline kalibrasi agar menjalankannya kembali cukup dengan satu perintah yang menghasilkan koefisien koreksi terbaru.

def run_calibration_pipeline(calibration_data: list) -> dict:
    # 1. Measure human inter-rater agreement
    ira = measure_inter_rater_agreement(
        [d['rater_1'] for d in calibration_data],
        [d['rater_2'] for d in calibration_data]
    )
    # 2. Run judge on all items
    pairs = run_judge_on_calibration(calibration_data)
    # 3. Compute correlation metrics
    metrics = calibration_metrics(pairs)
    # 4. Detect bias
    bias = detect_score_bias(pairs)
    return {'ira': ira, 'metrics': metrics, 'bias': bias}

Mendokumentasikan Konfigurasi Penilai

Dokumentasikan model penilai, versi perintah, ukuran dan tanggal kumpulan data kalibrasi, metrik kalibrasi, serta koefisien koreksi apa pun dalam file konfigurasi penilai yang disimpan dalam pengendalian versi. Hal ini membuat jejak audit sehingga anggota tim di masa mendatang memahami alasan skor terlihat seperti itu dan Anda dapat mengetahui apakah perubahan metrik disebabkan oleh konfigurasi ulang penilai atau perubahan kualitas yang sebenarnya.

# judge_config.yaml
# judge_model: gpt-4o-2025-01-01
# judge_prompt_version: v3.2
# calibration_date: 2026-05-15
# calibration_set_size: 312
# calibration_metrics:
#   pearson_r: 0.81
#   spearman_r: 0.79
#   mae: 0.54
# bias_correction:
#   slope: 0.88
#   intercept: 0.45
# next_recalibration: 2026-08-15

Perintah Penilai Khusus Dimensi

Satu perintah penilai yang memberikan skor untuk beberapa dimensi sekaligus sering menghasilkan skor yang berkorelasi — penilai memberikan skor ketepatan tinggi karena sebelumnya memberikan skor kejelasan tinggi, dengan berpatokan pada kesan pertamanya. Perintah khusus dimensi mengevaluasi setiap kriteria secara independen dalam panggilan API terpisah. Cara ini lebih mahal, tetapi menghasilkan skor yang lebih andal dan benar-benar merupakan pengukuran yang independen. Gunakan perintah terpisah untuk dimensi yang skornya diperkirakan bervariasi secara independen.

async def multi_dimension_judge(question: str, answer: str) -> dict:
    # Run each dimension as a separate judge call
    correctness, helpfulness, clarity = await asyncio.gather(
        judge_single_dimension(question, answer, 'correctness'),
        judge_single_dimension(question, answer, 'helpfulness'),
        judge_single_dimension(question, answer, 'clarity')
    )
    return {
        'correctness': correctness,
        'helpfulness': helpfulness,
        'clarity': clarity,
        'composite': 0.5 * correctness + 0.3 * helpfulness + 0.2 * clarity
    }

Pemeriksaan Singkat

Uji pemahaman Anda tentang pengalibrasian model penilai LLM terhadap penilaian manusia.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa kumpulan data kalibrasi dengan skor konsensus manusia menyediakan kebenaran dasar untuk mengukur keandalan penilai, korelasi Pearson dan MAE mengukur seberapa baik penilai mengikuti penilaian manusia, dan koreksi bias linear menyesuaikan pemberian skor yang secara sistematis terlalu tinggi atau terlalu rendah. Selanjutnya, kita akan membangun pipeline evaluasi berkelanjutan yang terintegrasi dengan CI/CD.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengalibrasi Model Penilai terhadap Manusia” gratis?

Ya — teks lengkap “Mengalibrasi Model Penilai terhadap Manusia” 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 “Mengalibrasi Model Penilai terhadap Manusia”?

Kumpulkan dataset dasar kebenaran berisi penilaian preferensi manusia, ukur kesepakatan antara penilai dan manusia dengan Kappa Cohen, lalu sesuaikan prompt penilai untuk mengurangi bias sistematis. 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 3 dari 4.

Berapa lama pelajaran “Mengalibrasi Model Penilai terhadap Manusia” 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