Inspect AI: Framework Evaluasi LLM dari UK AI Safety Institute yang Wajib Kamu Coba

Temen-temen, kalau kamu udah mulai serius ngoding aplikasi yang pakai large language model, cepat atau lambat kamu bakal ketemu satu pertanyaan yang bikin pusing: "Model mana sih yang sebenernya paling bagus buat kasus aku?" Atau yang lebih spesifik lagi: "Setelah aku ganti prompt, hasilnya jadi lebih bagus atau malah lebih jelek?" Selama ini banyak dari kita jawab pertanyaan itu pakai cara yang jujur aja agak asal: coba beberapa contoh manual, lihat outputnya, terus bilang "kayaknya sih udah oke". Padahal "kayaknya" itu bukan jawaban yang bisa dipertanggungjawabkan.

Nah, di tutorial ini aku mau ngenalin kamu ke sebuah tool yang menurutku ngubah cara aku ngukur kualitas kerjaan LLM: namanya Inspect AI. Ini framework open-source yang dibikin sama UK AI Safety Institute, jadi institusi resmi pemerintah Inggris yang tugasnya emang ngurusin keamanan dan evaluasi AI. Karena lahir dari lembaga yang serius soal evaluasi, framework ini didesain buat bikin proses evaluasi LLM jadi terstruktur, bisa diulang, dan bisa diaudit. Bukan lagi "kayaknya oke", tapi angka yang jelas: model A dapet 78 persen, model B dapet 84 persen, di dataset yang sama, dengan cara scoring yang sama.

Aku bakal ajak kamu dari nol: mulai dari instalasi, paham konsep intinya (Task, Dataset, Solver, Scorer), nulis task pertama, pakai berbagai solver dan scorer, jalanin lewat CLI inspect eval, sampai ngeliat hasilnya di log viewer yang keren. Semua pakai contoh Python yang bisa langsung kamu jalanin. Santai aja, kita jalan pelan-pelan. Siap? Yuk kita mulai.

Introduction: Kenapa Inspect AI Itu Penting

Sebelum masuk ke koding, aku mau kamu paham dulu masalah apa yang mau diselesain sama Inspect AI. Ini penting biar kamu ngerti kenapa tool ini worth banget buat dipelajari.

Bayangin kamu lagi bikin fitur customer service yang jawab pertanyaan pelanggan pakai LLM. Kamu udah nulis prompt yang bagus, udah pilih model, dan hasilnya kelihatan oke waktu kamu coba lima atau sepuluh pertanyaan. Tapi coba pikir: aplikasi kamu bakal ngadepin ribuan pertanyaan yang beda-beda. Gimana kamu tau model kamu bener-bener jawab dengan benar di mayoritas kasus? Terus waktu ada model baru keluar, atau kamu mau turunin biaya dengan pakai model yang lebih kecil, gimana kamu bandingin secara adil?

Cara manual jelas nggak scalable. Kamu nggak mungkin ngetes seribu pertanyaan satu-satu tiap kali ada perubahan kecil. Yang kamu butuhin adalah sistem yang bisa: nyimpen kumpulan soal beserta jawaban benernya, jalanin model ke semua soal itu secara otomatis, nilai jawaban model secara konsisten, dan kasih kamu laporan yang jelas. Persis inilah yang dikasih Inspect AI.

Inspect AI punya empat konsep inti yang harus kamu pahami dulu. Kalau kamu udah paham empat ini, kamu udah paham 80 persen framework-nya:

Coba lihat gimana empat konsep ini nyambung dalam satu alur: Inspect ambil tiap Sample dari Dataset, kasih ke Solver buat diproses model, terus hasilnya dinilai sama Scorer, dan semua itu dibungkus dalam satu Task. Sesederhana itu konsepnya, tapi kekuatannya luar biasa karena semua bagian bisa kamu ganti-ganti sesuai kebutuhan.

Yang bikin aku suka banget sama Inspect AI dibanding bikin script evaluasi sendiri: dia udah nyediain log viewer visual yang bagus, dukungan banyak provider model (OpenAI, Anthropic, Google, model lokal via Ollama, dan lain-lain), penanganan paralel yang efisien biar evaluasi cepat, dan struktur kode yang rapi jadi evaluasi kamu bisa di-share dan diulang orang lain. Oke, cukup teorinya. Yuk kita install.

Instalasi

Instalasi Inspect AI gampang banget karena dia paket Python biasa. Syaratnya kamu punya Python 3.10 atau lebih baru. Aku sangat saranin kamu bikin virtual environment dulu biar bersih dan nggak tabrakan sama proyek lain.

# Bikin virtual environment
python -m venv venv

Aktifkan (Linux/Mac)
source venv/bin/activate

Aktifkan (Windows)
venv\Scripts\activate

Install Inspect AI
pip install inspect-ai

Nah itu udah cukup buat framework intinya. Tapi karena Inspect AI butuh ngobrol sama model, kamu juga perlu install SDK dari provider yang mau kamu pakai. Misalnya kalau kamu mau pakai model OpenAI atau Anthropic:

# Kalau mau pakai OpenAI
pip install openai

Kalau mau pakai Anthropic (Claude)
pip install anthropic

Kalau mau pakai Google Gemini
pip install google-generativeai

Setelah itu, kamu perlu set API key sebagai environment variable. Inspect AI otomatis baca key dari environment sesuai provider yang kamu pakai. Ini caranya:

# Untuk OpenAI
export OPENAIAPIKEY="sk-xxxxxxxxxxxx"

Untuk Anthropic
export ANTHROPICAPIKEY="sk-ant-xxxxxxxxxxxx"

Untuk Google
export GOOGLEAPIKEY="xxxxxxxxxxxx"

Kalau kamu males ngetik export tiap kali buka terminal, kamu bisa taruh key-nya di file .env di folder proyek kamu. Inspect AI otomatis baca file .env itu, jadi praktis banget:

# File: .env
OPENAIAPIKEY=sk-xxxxxxxxxxxx
ANTHROPICAPIKEY=sk-ant-xxxxxxxxxxxx

Buat mastiin instalasi kamu berhasil, coba jalanin perintah ini di terminal:

inspect --version

Kalau muncul nomor versi, berarti Inspect AI udah keinstall dengan benar dan CLI-nya siap dipakai. Perintah inspect ini nanti bakal jadi teman kamu buat jalanin evaluasi, ngeliat log, dan macem-macem hal lain. Sekarang kita udah siap nulis task pertama.

Basic Usage: Nulis Task Pertama Kamu

Oke, sekarang bagian yang seru. Kita bakal bikin evaluasi sederhana buat ngetes seberapa jago model jawab pertanyaan pengetahuan umum. Aku bakal jelasin tiap baris biar kamu bener-bener paham, bukan cuma copas.

Bikin file baru namanya evalpengetahuan.py, terus tulis kode berikut:

from inspectai import Task, task
from inspectai.dataset import Sample

from inspectai.solver import generate
from inspectai.scorer import match



@task
def pengetahuanumum():
    # 1. Dataset: kumpulan soal beserta jawaban benernya
    dataset = [
        Sample(
            input="Apa ibu kota Indonesia?",
            target="Jakarta",
        ),
        Sample(
            input="Berapa hasil dari 12 dikali 8?",
            target="96",
        ),
        Sample(
            input="Siapa presiden pertama Indonesia?",
            target="Soekarno",
        ),
    ]

    # 2. Gabungkan jadi Task: Dataset + Solver + Scorer
    return Task(
        dataset=dataset,
        solver=generate(),
        scorer=match(location="any"),
    )

Yuk kita bedah kode ini pelan-pelan. Di baris import, kita ambil Task dan task dari inspectai. Yang huruf kecil task itu decorator, yang huruf besar Task itu class-nya. Terus kita ambil Sample buat bikin item dataset, generate sebagai solver, dan match sebagai scorer.

Decorator @task itu penting banget. Dia nandain fungsi pengetahuanumum() sebagai sebuah task yang bisa dikenali sama CLI inspect eval. Jadi nanti kamu tinggal panggil nama fungsi ini dari terminal.

Di dalam fungsi, aku bikin dataset berupa list dari tiga Sample. Tiap Sample punya input (pertanyaannya) dan target (jawaban benernya). Ini bagian paling penting: target inilah yang jadi acuan buat nilai jawaban model nanti.

Terus kita return sebuah Task yang nyatuin tiga hal: dataset yang barusan kita bikin, solver=generate() yang artinya "suruh model generate jawaban dari input", dan scorer=match(location="any") yang artinya "nilai bener kalau target muncul di mana aja dalam jawaban model". Aku pakai location="any" karena model biasanya jawab dengan kalimat lengkap, bukan cuma satu kata. Jadi kalau model jawab "Ibu kota Indonesia adalah Jakarta", scorer tetep nganggep bener karena kata "Jakarta" ada di dalamnya.

Sekarang, gimana cara jalaninnya? Di sinilah CLI inspect eval masuk. Buka terminal, terus ketik:

inspect eval evalpengetahuan.py --model openai/gpt-4o-mini

inspect eval evalpengetahuan.py --model anthropic/claude-3-5-sonnet-20241022

Kalau kamu mau pakai model lokal via Ollama:

inspect eval evalpengetahuan.py --model ollama/llama3.1

# Cuma jalanin 2 sample pertama buat cek cepat
inspect eval evalpengetahuan.py --model openai/gpt-4o-mini --limit 2

Jalanin dengan 5 sample paralel biar cepet
inspect eval evalpengetahuan.py --model openai/gpt-4o-mini --max-connections 5

Solver generate() polos itu langsung ngasih input mentah ke model. Tapi seringkali kamu mau ngasih instruksi tambahan atau format prompt tertentu. Buat itu, Inspect AI punya solver systemmessage() dan prompttemplate() yang bisa kamu gabung jadi rantai (chain).

from inspectai import Task, task
from inspectai.dataset import Sample

from inspectai.solver import generate, systemmessage, prompttemplate
from inspectai.scorer import match



@task
def pengetahuandenganinstruksi():

    dataset = [
        Sample(input="Apa ibu kota Jepang?", target="Tokyo"),
        Sample(input="Apa ibu kota Prancis?", target="Paris"),
    ]

    return Task(
        dataset=dataset,
        solver=[
            systemmessage(
                "Kamu asisten geografi. Jawab dengan SATU kata saja, "
                "yaitu nama kotanya. Jangan tambahkan penjelasan apa pun."
            ),
            prompttemplate("Pertanyaan: {prompt}\nJawaban:"),

            generate(),
        ],
        scorer=match(location="any"),
    )

Perhatiin di sini solver bukan lagi satu fungsi, tapi sebuah list. Ini yang disebut solver chain. Inspect AI jalanin solver-solver ini berurutan. Pertama systemmessage() nambahin instruksi sistem yang nyuruh model jawab satu kata. Terus prompttemplate() mbungkus input kita pakai template, di mana {prompt} bakal diganti otomatis sama input dari Sample. Terakhir generate() yang benerannya manggil model. Dengan rantai ini, kamu punya kontrol penuh atas gimana prompt disusun sebelum sampai ke model.

Buat kasus kayak gini, Inspect AI punya modelgradedqa(). Ide dasarnya cerdas: kita pakai LLM lain sebagai juri buat nilai apakah jawaban model udah benar dan sesuai. Ini disebut LLM-as-a-judge.

from inspectai import Task, task
from inspectai.dataset import Sample

from inspectai.solver import generate
from inspectai.scorer import modelgradedqa



@task
def evaluasipenjelasan():
    dataset = [
        Sample(
            input="Jelaskan secara singkat kenapa langit berwarna biru.",
            target=(
                "Karena hamburan Rayleigh: molekul udara menghamburkan "
                "cahaya biru yang panjang gelombangnya lebih pendek lebih "
                "kuat daripada cahaya merah."
            ),
        ),
        Sample(
            input="Jelaskan apa itu fotosintesis dalam satu kalimat.",
            target=(
                "Proses tumbuhan mengubah cahaya matahari, air, dan "
                "karbon dioksida menjadi glukosa dan oksigen."
            ),
        ),
    ]

    return Task(
        dataset=dataset,
        solver=generate(),
        scorer=modelgradedqa(
            instructions=(
                "Nilai apakah jawaban peserta secara faktual benar dan "
                "menyampaikan inti yang sama dengan jawaban acuan. "
                "Abaikan perbedaan gaya bahasa."
            ),
            model="openai/gpt-4o",
        ),
    )

Di sini modelgradedqa() punya dua argumen penting. instructions adalah panduan buat si juri gimana cara nilai. Aku bilang ke juri buat fokus ke kebenaran faktual dan inti jawaban, bukan gaya bahasa. Terus model adalah model yang jadi jurinya. Aku sengaja pakai model yang lebih kuat (gpt-4o) sebagai juri, sementara model yang dites bisa model yang lebih kecil. Ini praktik umum: juri sebaiknya model yang pinter biar penilaiannya akurat.

Waktu kamu jalanin task ini, alurnya jadi begini: model yang dites ngejawab pertanyaan, terus jawaban itu plus target dikirim ke model juri, dan juri mutusin apakah jawaban itu benar atau salah. Keren kan? Kamu bisa nilai jawaban terbuka secara otomatis dan konsisten.

Bikin Custom Scorer Sendiri

Kadang scorer bawaan nggak cukup dan kamu butuh logika penilaian sendiri. Inspect AI ngizinin kamu bikin scorer custom pakai decorator @scorer. Misalnya kamu mau nilai berdasarkan apakah jawaban model mengandung angka yang benar dalam toleransi tertentu:

from inspectai.scorer import scorer, accuracy, stderr, Score, Target
from inspectai.solver import TaskState
import re


@scorer(metrics=[accuracy(), stderr()])
def angkadalamtoleransi(toleransi: float = 0.01):
    async def score(state: TaskState, target: Target) -> Score:
        # Ambil jawaban model dan target
        jawaban = state.output.completion
        targetnilai = float(target.text)


        # Cari angka pertama di jawaban model
        angka = re.findall(r"-?\d+\.?\d*", jawaban)
        if not angka:
            return Score(value="I", explanation="Tidak ada angka di jawaban")

        nilaimodel = float(angka[0])
        benar = abs(nilaimodel - targetnilai) <= toleransi

        return Score(
            value="C" if benar else "I",
            answer=str(nilaimodel),

            explanation=f"Model: {nilaimodel}, Target: {targetnilai}",

        )

    return score

inspect view

Perintah ini bakal ngejalanin web server lokal (biasanya di http://localhost:7575) dan buka tampilan visual di browser kamu. Di sana kamu bisa liat tiap Sample satu per satu: apa pertanyaannya, apa jawaban model, apa targetnya, dan kenapa scorer ngasih nilai benar atau salah. Buat kasus modelgradedqa, kamu bahkan bisa liat alasan si juri kenapa dia nilai begitu. Ini super berguna buat debugging. Kalau model kamu banyak salah, kamu bisa langsung liat pola kesalahannya di sini.

# Buka log dari folder tertentu
inspect view --log-dir ./logs

Kadang kamu mau jalanin di port lain
inspect view --port 8080

from inspectai.dataset import csvdataset, jsondataset

Load dari CSV dengan kolom 'input' dan 'target'
dataset = csvdataset("soal.csv")


Atau dari JSON
dataset = jsondataset("soal.json")

# Jalanin tiap sample 3 kali, ambil rata-ratanya
inspect eval eval_pengetahuan.py --model openai/gpt-4o-mini --epochs 3

Conclusion

Oke temen-temen, kita udah jalan jauh banget di tutorial ini. Kita mulai dari nol, paham empat konsep inti Inspect AI (Dataset, Solver, Scorer, Task), install framework-nya, nulis task pertama, sampai pakai solver dan scorer yang canggih kayak prompt template dan model-graded QA. Kita juga belajar bikin custom scorer sendiri dan ngeliat hasil detail di log viewer.

Yang aku harap kamu bawa pulang dari tutorial ini bukan cuma sintaksnya, tapi mindset-nya. Evaluasi LLM itu bukan hal yang boleh kamu lakuin dengan "kayaknya oke". Kalau kamu serius bikin produk yang pakai LLM, kamu perlu cara yang terstruktur, bisa diulang, dan bisa diaudit buat ngukur kualitas. Inspect AI ngasih kamu semua itu dalam paket yang rapi dan open-source, dibikin sama institusi yang emang ahli di bidang evaluasi AI.

Langkah selanjutnya yang aku saranin: coba bikin dataset kecil dari kasus nyata di proyek kamu sendiri, mungkin sepuluh atau dua puluh soal yang mewakili apa yang bener-bener ditanya user kamu. Terus bikin task buat evaluasi model yang lagi kamu pakai. Dari situ kamu bakal dapet angka baseline. Setelah itu, tiap kali kamu ganti prompt atau ganti model, jalanin lagi evaluasinya dan bandingin. Kamu bakal kaget berapa banyak keputusan yang selama ini kamu ambil berdasarkan "feeling" ternyata bisa dibuktikan pakai angka.

Inspect AI juga masih punya banyak fitur yang belum kita bahas: dukungan tools dan agent, evaluasi multi-turn conversation, sandbox buat kode, dan integrasi sama berbagai dataset benchmark populer. Tapi fondasi yang udah kamu pelajari di sini cukup buat kamu mulai. Pelan-pelan aja, eksplorasi sisanya sambil jalan.

Selamat nyoba, temen-temen. Semoga tutorial ini bikin kamu lebih pede buat ngukur kualitas kerjaan LLM kamu pakai data, bukan cuma perasaan. Kalau kamu bikin sesuatu yang keren pakai Inspect AI, aku seneng banget kalau kamu share. Sampai ketemu di tutorial berikutnya. Semangat terus belajarnya ya.