AI Engineering Academy · Pelajaran

Membangun Alur Kerja Evaluasi Berkelanjutan

Integrasikan evaluasi LLM-as-judge ke dalam alur kerja CI/CD agar setiap perubahan prompt atau model dievaluasi secara otomatis terhadap rangkaian tes regresi sebelum diterapkan.

Membangun Alur Kerja Evaluasi Berkelanjutan adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 4 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 Harus Berkelanjutan

Evaluasi satu kali saat penerapan tidaklah cukup. Kualitas LLM dapat menurun secara diam-diam: penyedia model memperbarui model mereka, perubahan perintah sistem terlewatkan, kualitas pengambilan berubah seiring bertambahnya korpus dokumen, dan distribusi pertanyaan pengguna berubah dari waktu ke waktu. Pipeline evaluasi berkelanjutan menjalankan rangkaian evaluasi yang sama pada setiap perubahan dan sesuai jadwal sehingga kemunduran kualitas dapat diketahui dalam hitungan jam, bukan minggu.

Komponen Inti Pipeline

Pipeline evaluasi berkelanjutan memiliki lima komponen: kumpulan data pengujian (pertanyaan yang dikurasi beserta keluaran yang diharapkan), pelaksana sistem (memanggil pipeline LLM Anda untuk setiap pertanyaan pengujian), penilai (memberi skor pada setiap respons), penyimpanan hasil (basis data atau penyimpanan deret waktu untuk metrik historis), dan lapisan pelaporan (dasbor dan peringatan). Setiap komponen dapat ditingkatkan secara independen.

# Pipeline architecture:
#
# test_dataset.json
#       |
#       v
# system_runner.py  --> calls your LLM pipeline
#       |
#       v
# judge.py          --> scores each (question, answer) pair
#       |
#       v
# results_db        --> stores timestamped metric history
#       |
#       v
# dashboard + alert --> Grafana / Slack notification

Menyusun Kumpulan Data Pengujian

Simpan kumpulan pengujian evaluasi Anda sebagai file JSON atau YAML berversi di repositori. Setiap entri berisi pertanyaan, kategori (faktual, prosedural, di luar cakupan), dan secara opsional jawaban referensi. Beri versi pada kumpulan pengujian secara terpisah dari kode — menambahkan kasus pengujian baru merupakan perubahan yang kompatibel ke belakang, sedangkan menghapus kasus dapat menyembunyikan regresi. Usahakan memiliki 200–500 kasus yang mencakup semua kategori yang relevan.

# eval/test_set_v3.json
# {
#   'version': '3.0',
#   'created': '2026-06-01',
#   'cases': [
#     {
#       'id': 'faq_001',
#       'category': 'factual',
#       'question': 'What is the cancellation policy?',
#       'reference': 'Cancellations must be made 24 hours in advance.',
#       'min_correctness': 4
#     },
#     ...
#   ]
# }

Menjalankan Rangkaian Evaluasi

Pelaksana evaluasi memanggil sistem produksi Anda (atau versi pementasan) untuk setiap kasus pengujian, lalu mencatat respons dan metadatanya. Tandai setiap proses evaluasi dengan ID eksekusi unik, SHA commit yang memicunya, stempel waktu, dan versi kumpulan pengujian. Dengan demikian, Anda dapat membandingkan proses secara tepat dan mendiagnosis perubahan kode mana yang menyebabkan regresi.

import asyncio
import uuid
from datetime import datetime

async def run_eval_suite(system, test_set: list, commit_sha: str) -> dict:
    run_id = str(uuid.uuid4())
    results = []
    for case in test_set:
        response = await system.answer(case['question'])
        score = await judge(case['question'], response, case.get('reference'))
        results.append({
            'run_id': run_id,
            'commit_sha': commit_sha,
            'case_id': case['id'],
            'category': case['category'],
            'response': response,
            'score': score.model_dump(),
            'evaluated_at': datetime.utcnow().isoformat()
        })
    return {'run_id': run_id, 'results': results}

Menyimpan dan Mengkueri Metrik Historis

Simpan setiap hasil proses evaluasi secara permanen ke basis data. Tabel eval_results sederhana dengan bidang run_id, commit_sha, case_id, dan score sudah memadai. Kueri skor agregat berdasarkan ID eksekusi untuk menghitung metrik per proses. Bandingkan proses saat ini dengan proses terakhir yang berhasil pada cabang utama untuk mendeteksi regresi. Basis data deret waktu seperti InfluxDB cocok untuk pemantauan berkelanjutan.

-- PostgreSQL schema
CREATE TABLE eval_runs (
    run_id UUID PRIMARY KEY,
    commit_sha TEXT NOT NULL,
    test_set_version TEXT NOT NULL,
    triggered_by TEXT,  -- 'ci', 'scheduled', 'manual'
    started_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE eval_results (
    id SERIAL PRIMARY KEY,
    run_id UUID REFERENCES eval_runs(run_id),
    case_id TEXT NOT NULL,
    category TEXT,
    correctness INT,
    overall INT,
    response TEXT
);

CREATE INDEX idx_run_id ON eval_results(run_id);

Mendeteksi Regresi Secara Otomatis

Setelah setiap proses evaluasi, bandingkan skor agregat dengan acuan (proses terakhir dari cabang utama yang disetujui secara manual). Regresi didefinisikan sebagai salah satu dimensi skor yang turun lebih dari 5% di bawah acuan, atau skor rata-rata kategori mana pun yang turun di bawah batas minimum yang tegas. Regresi harus menghentikan penerapan dan memicu peringatan kepada tim. Peningkatan dapat disetujui secara otomatis.

def detect_regression(current: dict, baseline: dict, threshold_pct: float = 5.0) -> dict:
    regressions = []
    for metric in ['correctness', 'helpfulness', 'clarity']:
        delta_pct = (current[metric] - baseline[metric]) / baseline[metric] * 100
        if delta_pct < -threshold_pct:
            regressions.append({
                'metric': metric,
                'baseline': baseline[metric],
                'current': current[metric],
                'delta_pct': round(delta_pct, 1)
            })
    return {'has_regression': len(regressions) > 0, 'regressions': regressions}

Mengintegrasikan dengan CI/CD

Tambahkan rangkaian evaluasi sebagai langkah CI yang dijalankan pada setiap pull request. Pipeline CI memanggil sistem pementasan Anda, menjalankan penilai, menyimpan hasil, dan memeriksa regresi. Jika terdeteksi regresi, langkah CI gagal dan penggabungan PR diblokir. Tambahkan ini sebagai pemeriksaan status wajib di GitHub atau GitLab agar tidak ada yang dapat melewatinya. Pertahankan waktu proses evaluasi di bawah 10 menit dengan menggunakan sebagian kecil yang terdiri dari 50–100 kasus untuk pemeriksaan PR.

# .github/workflows/eval.yml
# name: LLM Quality Evaluation
# on: [pull_request]
# jobs:
#   eval:
#     runs-on: ubuntu-latest
#     steps:
#       - uses: actions/checkout@v4
#       - name: Run eval suite
#         run: python eval/run_suite.py --commit $GITHUB_SHA --mode pr
#         env:
#           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
#       - name: Check for regressions
#         run: python eval/check_regression.py --run-id $EVAL_RUN_ID

Proses Evaluasi Lengkap Terjadwal

Selain pemeriksaan PR, jalankan rangkaian evaluasi lengkap (semua 300+ kasus) setiap hari terhadap sistem produksi. Cara ini menangkap penurunan kualitas bertahap yang tidak disebabkan oleh satu perubahan tertentu — misalnya, jika daya ingat basis data vektor menurun seiring penambahan dokumen, atau jika penyedia LLM diam-diam memperbarui modelnya. Proses lengkap harian menghasilkan deret waktu kualitas yang membuat tren terlihat.

# Separate eval modes:
EVAL_CONFIGS = {
    'pr_check': {
        'test_cases': 'eval/test_set_core_100.json',
        'target': 'staging',
        'max_runtime_min': 8
    },
    'nightly': {
        'test_cases': 'eval/test_set_full_350.json',
        'target': 'production',
        'max_runtime_min': 30
    },
    'weekly_deep': {
        'test_cases': 'eval/test_set_full_350.json',
        'target': 'production',
        'include_pairwise': True,
        'max_runtime_min': 90
    }
}

Memberi Peringatan atas Penurunan Kualitas

Konfigurasikan peringatan ketika tren metrik melewati ambang peringatan dan kritis. Penurunan rata-rata ketepatan sebesar 3% selama 7 hari terakhir memicu peringatan. Penurunan sebesar 10% dalam satu proses memicu peringatan segera. Arahkan peringatan biasa ke kanal Slack tim dan peringatan kritis ke PagerDuty. Sertakan analisis regresi, tautan ke dasbor evaluasi, dan informasi git blame untuk perubahan terbaru dalam setiap pesan peringatan.

import httpx

def send_regression_alert(regression_report: dict, webhook_url: str):
    regressions = regression_report['regressions']
    blocks = [{
        'type': 'section',
        'text': {'type': 'mrkdwn', 'text': '*LLM Quality Regression Detected*'}
    }]
    for r in regressions:
        blocks.append({
            'type': 'section',
            'text': {'type': 'mrkdwn',
                     'text': f'*{r["metric"]}*: {r["baseline"]} -> {r["current"]} ({r["delta_pct"]}%)'}
        })
    httpx.post(webhook_url, json={'blocks': blocks})

Mengelola Perluasan Kumpulan Pengujian

Terus kembangkan kumpulan pengujian berdasarkan kegagalan nyata dalam sistem produksi. Saat pengguna melaporkan respons yang buruk, tambahkan pertanyaan tersebut (anonimkan jika diperlukan) ke kumpulan pengujian beserta jawaban yang diharapkan dan telah diverifikasi manusia. Dengan demikian, rangkaian evaluasi mencerminkan kebutuhan pengguna yang sebenarnya, bukan kasus hipotetis. Perlakukan kumpulan pengujian sebagai dokumen yang terus berkembang dan tinjau setiap kuartal untuk menghapus kasus yang sudah usang.

def add_to_test_set(question: str, reference_answer: str, category: str,
                    source: str, test_set_path: str):
    import json, uuid
    with open(test_set_path, 'r') as f:
        test_set = json.load(f)
    test_set['cases'].append({
        'id': f'user_report_{uuid.uuid4().hex[:8]}',
        'category': category,
        'question': question,
        'reference': reference_answer,
        'source': source,  # 'user_report', 'regression', 'manual'
        'added': '2026-06-21'
    })
    with open(test_set_path, 'w') as f:
        json.dump(test_set, f, indent=2)

Memvisualisasikan Tren Kualitas dari Waktu ke Waktu

Buat dasbor kualitas sederhana yang memplot metrik utama dari waktu ke waktu: skor rata-rata ketepatan, rasio cache hit, latensi p95, dan biaya per kueri. Gunakan rata-rata bergerak mingguan untuk menghaluskan gangguan akibat ukuran sampel yang kecil. Bagan tren membuat penurunan kualitas langsung terlihat — penurunan bertahap sebesar 3% selama enam minggu tidak terlihat dalam laporan proses individual, tetapi jelas pada bagan deret waktu. Grafana atau bahkan skrip Python matplotlib sederhana dapat digunakan dengan baik untuk ini.

import matplotlib.pyplot as plt
import pandas as pd

def plot_quality_trend(eval_history: list):
    df = pd.DataFrame(eval_history)
    df['date'] = pd.to_datetime(df['evaluated_at'])
    df = df.sort_values('date')
    # 7-day rolling average
    df['score_ma7'] = df['mean_correctness'].rolling(window=7).mean()
    plt.figure(figsize=(12, 4))
    plt.plot(df['date'], df['mean_correctness'], alpha=0.3, label='Daily')
    plt.plot(df['date'], df['score_ma7'], label='7-day avg', linewidth=2)
    plt.axhline(y=4.0, color='r', linestyle='--', label='Min threshold')
    plt.legend()
    plt.title('LLM Answer Quality Over Time')
    plt.savefig('quality_trend.png')

Pemeriksaan Singkat

Uji pemahaman Anda tentang pipeline evaluasi berkelanjutan untuk aplikasi LLM.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa pipeline evaluasi berkelanjutan menjalankan pemeriksaan kualitas otomatis pada setiap PR dan setiap hari untuk mendeteksi regresi sejak dini, deteksi regresi membandingkan skor saat ini dengan acuan dan menghentikan penerapan jika kualitas menurun, serta perluasan kumpulan pengujian berdasarkan kegagalan nyata menjaga agar rangkaian evaluasi tetap berlandaskan kebutuhan pengguna yang sebenarnya. Selanjutnya, kita akan mengklasifikasikan mode kegagalan agen dan merancang strategi pemulihan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Alur Kerja Evaluasi Berkelanjutan” gratis?

Ya — teks lengkap “Membangun Alur Kerja Evaluasi Berkelanjutan” 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 “Membangun Alur Kerja Evaluasi Berkelanjutan”?

Integrasikan evaluasi LLM-as-judge ke dalam alur kerja CI/CD agar setiap perubahan prompt atau model dievaluasi secara otomatis terhadap rangkaian tes regresi sebelum diterapkan. 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 4 dari 4.

Berapa lama pelajaran “Membangun Alur Kerja Evaluasi Berkelanjutan” 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