Tutorial Lengkap LM Evaluation Harness: Framework Standar untuk Evaluasi Model Bahasa Besar
Evaluasi model bahasa besar (LLM) merupakan tahap krusial dalam siklus pengembangan AI. Tanpa evaluasi yang sistematis, kita tidak dapat mengukur seberapa baik performa model, membandingkan model satu dengan lainnya, atau memastikan bahwa fine-tuning yang dilakukan memberikan peningkatan nyata. LM Evaluation Harness (lm-eval) oleh EleutherAI telah menjadi standar de facto untuk evaluasi LLM, digunakan oleh peneliti, praktisi, dan organisasi besar di seluruh dunia.
Tutorial ini akan membahas secara mendalam cara menggunakan lm-eval untuk mengevaluasi berbagai model bahasa, mulai dari instalasi hingga pembuatan benchmark kustom.
Apa Itu LM Evaluation Harness?
LM Evaluation Harness adalah framework open-source yang dikembangkan oleh EleutherAI untuk mengevaluasi model bahasa generatif secara konsisten dan reproducible. Framework ini menyediakan ratusan benchmark standar seperti MMLU, HellaSwag, GSM8K, ARC, dan banyak lagi.
Keunggulan utama lm-eval meliputi:
- Standarisasi: Ratusan benchmark terintegrasi dengan implementasi yang konsisten
- Reprodusibilitas: Hasil evaluasi dapat direproduksi dengan konfigurasi yang sama
- Fleksibilitas: Mendukung model dari HuggingFace, API OpenAI, Anthropic, vLLM, dan lainnya
- Ekstensibilitas: Mudah menambahkan benchmark dan model baru
- Komunitas: Digunakan secara luas oleh komunitas riset AI global
Instalasi dan Setup
Instalasi Dasar
Cara tercepat untuk menginstal lm-eval adalah menggunakan pip:
pip install lm-eval
Instalasi dari Source
Untuk mendapatkan versi terbaru dengan semua fitur:
git clone https://github.com/EleutherAI/lm-evaluation-harness.git
cd lm-evaluation-harness
pip install -e ".[all]"
Instalasi dengan Dependencies Tambahan
Jika Anda ingin menggunakan model dari provider tertentu:
# Untuk model HuggingFace dengan quantisasi
pip install lm-eval[gptq,awq]
Untuk API-based models
pip install lm-eval[api]
Untuk vLLM backend
pip install lm-eval[vllm]
Untuk semua dependencies
pip install lm-eval[all]
Verifikasi Instalasi
lmeval --help
Jika perintah di atas menampilkan daftar opsi, instalasi berhasil.
Penggunaan Dasar
Evaluasi Model HuggingFace
Contoh paling sederhana adalah mengevaluasi model dari HuggingFace Hub:
lmeval --model hf \
--modelargs pretrained=microsoft/phi-2 \
--tasks hellaswag \
--batchsize 8 \
--device cuda:0
Parameter yang digunakan:
--model hf: Menggunakan backend HuggingFace Transformers--modelargs: Argumen spesifik model, termasuk nama model di Hub--tasks: Benchmark yang akan dijalankan--batchsize: Ukuran batch untuk inference--device: Device yang digunakan (cuda:0, cpu, dll.)
Evaluasi Beberapa Benchmark Sekaligus
Anda dapat mengevaluasi model pada beberapa benchmark secara bersamaan:
lmeval --model hf \
--model
args pretrained=meta-llama/Llama-3.1-8B \
--tasks hellaswag,mmlu,arceasy,arcchallenge,winogrande \
--batchsize auto \
--device cuda:0 \
--outputpath results/llama3-8b/
Parameter --batchsize auto akan secara otomatis menentukan batch size optimal berdasarkan memori GPU yang tersedia.
Menyimpan Hasil Evaluasi
Hasil evaluasi dapat disimpan dalam format JSON:
lmeval --model hf \
--modelargs pretrained=Qwen/Qwen2.5-7B \
--tasks mmlu \
--batchsize auto \
--outputpath results/qwen25-7b/ \
--logsamples
Flag --logsamples akan menyimpan detail setiap sampel evaluasi, berguna untuk analisis error.
Benchmark Populer
MMLU (Massive Multitask Language Understanding)
MMLU menguji pengetahuan model di 57 domain, dari matematika hingga hukum:
lmeval --model hf \
--modelargs pretrained=mistralai/Mistral-7B-v0.3 \
--tasks mmlu \
--numfewshot 5 \
--batchsize auto
Parameter --numfewshot 5 memberikan 5 contoh sebelum pertanyaan aktual (standar untuk MMLU).
HellaSwag
Benchmark untuk menguji kemampuan common-sense reasoning:
lmeval --model hf \
--model
args pretrained=microsoft/phi-2 \
--tasks hellaswag \
--numfewshot 10 \
--batchsize auto
GSM8K (Grade School Math)
Menguji kemampuan penalaran matematis:
lmeval --model hf \
--model
args pretrained=meta-llama/Llama-3.1-8B \
--tasks gsm8k \
--numfewshot 5 \
--batchsize auto
ARC (AI2 Reasoning Challenge)
Soal sains tingkat sekolah dasar dan menengah:
lmeval --model hf \
--model
args pretrained=google/gemma-2-9b \
--tasks arceasy,arcchallenge \
--numfewshot 25 \
--batchsize auto
TruthfulQA
Menguji apakah model menghasilkan jawaban yang benar dan tidak menyesatkan:
lmeval --model hf \
--model
args pretrained=meta-llama/Llama-3.1-8B \
--tasks truthfulqamc2 \
--numfewshot 0 \
--batchsize auto
Menjalankan Suite Benchmark Lengkap
Untuk evaluasi komprehensif, jalankan beberapa benchmark sekaligus:
lmeval --model hf \
--modelargs pretrained=meta-llama/Llama-3.1-8B \
--tasks mmlu,hellaswag,arceasy,arcchallenge,winogrande,truthfulqamc2,gsm8k \
--numfewshot 5 \
--batchsize auto \
--outputpath results/llama3-8b-full/
Evaluasi Model dengan Berbagai Backend
Evaluasi Model GGUF dengan llama.cpp
Untuk model yang telah dikuantisasi dalam format GGUF:
lmeval --model gguf \
--modelargs baseurl=http://localhost:8080 \
--tasks hellaswag,mmlu \
--batchsize 1
Pastikan server llama.cpp sudah berjalan terlebih dahulu.
Evaluasi Model via vLLM
vLLM menyediakan inference yang lebih cepat:
lmeval --model vllm \
--modelargs pretrained=meta-llama/Llama-3.1-8B,tensorparallelsize=2 \
--tasks mmlu,hellaswag \
--batchsize auto
Evaluasi Model via OpenAI API
Untuk mengevaluasi model GPT:
export OPENAIAPIKEY="sk-your-api-key"
lmeval --model openai-completions \
--modelargs model=gpt-3.5-turbo \
--tasks hellaswag,mmlu \
--batchsize 1
Untuk model chat:
lmeval --model openai-chat-completions \
--modelargs model=gpt-4 \
--tasks mmlu \
--batchsize 1 \
--applychattemplate
Evaluasi Model Quantized (GPTQ, AWQ)
# Model GPTQ
lmeval --model hf \
--modelargs pretrained=TheBloke/Llama-2-7B-GPTQ,gptq=True \
--tasks hellaswag \
--batchsize auto
Model AWQ
lmeval --model hf \
--modelargs pretrained=TheBloke/Llama-2-7B-AWQ,awq=True \
--tasks hellaswag \
--batchsize auto
Penggunaan Python API
Selain CLI, lm-eval juga menyediakan Python API yang fleksibel:
import lmeval
results = lm
eval.simpleevaluate(
model="hf",
model
args="pretrained=microsoft/phi-2",
tasks=["hellaswag", "mmlu"],
numfewshot=5,
batchsize="auto",
device="cuda:0",
)
Akses hasil
for taskname, taskresult in results["results"].items():
print(f"\n{taskname}:")
for metric, value in taskresult.items():
if isinstance(value, (int, float)):
print(f" {metric}: {value:.4f}")
Evaluasi dengan Konfigurasi Lanjutan
import lmeval
from lm
eval.models.huggingface import HFLM
Inisialisasi model dengan konfigurasi khusus
model = HFLM(
pretrained="meta-llama/Llama-3.1-8B",
dtype="float16",
batchsize="auto",
device="cuda:0",
maxlength=4096,
)
Jalankan evaluasi
results = lmeval.simpleevaluate(
model=model,
tasks=["mmlu", "hellaswag", "gsm8k"],
numfewshot=5,
logsamples=True,
)
Simpan hasil
import json
with open("evaluationresults.json", "w") as f:
json.dump(results["results"], f, indent=2)
Membandingkan Beberapa Model
import lmeval
import json
modelstocompare = [
"microsoft/phi-2",
"google/gemma-2-2b",
"Qwen/Qwen2.5-3B",
]
tasks = ["hellaswag", "arceasy", "mmlu"]
allresults = {}
for modelname in modelstocompare:
print(f"\nEvaluating {modelname}...")
results = lmeval.simpleevaluate(
model="hf",
modelargs=f"pretrained={modelname}",
tasks=tasks,
numfewshot=5,
batchsize="auto",
device="cuda:0",
)
allresults[modelname] = results["results"]
Cetak tabel perbandingan
print("\n" + "=" 80)
print(f"{'Model':<30} {'HellaSwag':<15} {'ARC-Easy':<15} {'MMLU':<15}")
print("=" 80)
for modelname, result in allresults.items():
hellaswag = result.get("hellaswag", {}).get("accnorm,none", 0)
arc = result.get("arceasy", {}).get("accnorm,none", 0)
mmlu = result.get("mmlu", {}).get("acc,none", 0)
shortname = modelname.split("/")[-1]
print(f"{shortname:<30} {hellaswag:<15.4f} {arc:<15.4f} {mmlu:<15.4f}")
Membuat Benchmark Kustom
Struktur Task YAML
Anda dapat membuat benchmark kustom menggunakan format YAML:
# mycustomtask.yaml
task: mycustombenchmark
datasetpath: json
datasetkwargs:
datafiles: mytestdata.jsonl
outputtype: multiplechoice
trainingsplit: null
validationsplit: null
testsplit: train
doctotext: "Pertanyaan: {{question}}\nJawaban:"
doctotarget: "{{answer}}"
metriclist:
- metric: acc
aggregation: mean
higherisbetter: true
numfewshot: 0
Membuat Dataset Evaluasi
Siapkan data dalam format JSONL:
{"question": "Apa ibu kota Indonesia?", "choices": ["Jakarta", "Surabaya", "Bandung", "Medan"], "answer": 0}
{"question": "Siapa penemu telepon?", "choices": ["Edison", "Bell", "Tesla", "Marconi"], "answer": 1}
{"question": "Planet terbesar di tata surya?", "choices": ["Mars", "Venus", "Jupiter", "Saturnus"], "answer": 2}
Task dengan Format Generatif
Untuk evaluasi teks generatif (bukan pilihan ganda):
# generativetask.yaml
task: my
generativetask
dataset
path: json
datasetkwargs:
datafiles: gentestdata.jsonl
outputtype: generateuntil
trainingsplit: null
testsplit: train
doctotext: "Translate to English: {{indonesian}}\nTranslation:"
doctotarget: "{{english}}"
generationkwargs:
maxgentoks: 256
temperature: 0.0
dosample: false
metriclist:
- metric: bleu
aggregation: mean
higherisbetter: true
- metric: exactmatch
aggregation: mean
higherisbetter: true
numfewshot: 3
Menjalankan Task Kustom
lmeval --model hf \
--modelargs pretrained=meta-llama/Llama-3.1-8B \
--tasks mycustombenchmark \
--includepath /path/to/custom/tasks/ \
--batchsize auto
Filter dan Post-Processing
Menggunakan Filter Bawaan
lm-eval menyediakan beberapa filter untuk memproses output model:
task: filteredtask
datasetpath: json
datasetkwargs:
datafiles: testdata.jsonl
outputtype: generateuntil
doctotext: "{{question}}"
doctotarget: "{{answer}}"
generationkwargs:
maxgentoks: 512
until:
- "\n\n"
- "Question:"
filterlist:
- name: getanswer
filter:
- function: regex
regexpattern: "The answer is (\\w+)"
- function: takefirst
metriclist:
- metric: exactmatch
aggregation: mean
higherisbetter: true
Evaluasi Model Fine-tuned
Salah satu penggunaan paling umum lm-eval adalah membandingkan model sebelum dan sesudah fine-tuning:
import lmeval
tasks = ["mmlu", "hellaswag", "gsm8k"]
Evaluasi model base
print("Evaluating base model...")
baseresults = lmeval.simpleevaluate(
model="hf",
modelargs="pretrained=meta-llama/Llama-3.1-8B",
tasks=tasks,
numfewshot=5,
batchsize="auto",
device="cuda:0",
)
Evaluasi model fine-tuned
print("Evaluating fine-tuned model...")
ftresults = lmeval.simpleevaluate(
model="hf",
modelargs="pretrained=./my-finetuned-llama",
tasks=tasks,
numfewshot=5,
batchsize="auto",
device="cuda:0",
)
Bandingkan hasil
print("\n" + "=" 60)
print(f"{'Task':<20} {'Base Model':<20} {'Fine-tuned':<20}")
print("=" 60)
for task in tasks:
baseacc = baseresults["results"].get(task, {}).get("acc,none", 0)
ftacc = ftresults["results"].get(task, {}).get("acc,none", 0)
delta = ftacc - baseacc
sign = "+" if delta > 0 else ""
print(f"{task:<20} {baseacc:<20.4f} {ftacc:.4f} ({sign}{delta:.4f})")
Tips Optimasi Performa
Menggunakan batchsize auto
lmeval --model hf \
--modelargs pretrained=meta-llama/Llama-3.1-8B \
--tasks mmlu \
--batchsize auto:4
Angka setelah auto: menentukan faktor maksimum untuk auto-sizing.
Menggunakan Model Parallelism
Untuk model yang sangat besar:
lmeval --model hf \
--model
args pretrained=meta-llama/Llama-3.1-70B,parallelize=True \
--tasks hellaswag \
--batchsize 4
Menggunakan Quantisasi untuk Efisiensi
lmeval --model hf \
--modelargs pretrained=meta-llama/Llama-3.1-8B,loadin4bit=True \
--tasks mmlu,hellaswag \
--batchsize auto
Membatasi Jumlah Sampel
Untuk testing cepat:
lmeval --model hf \
--model
args pretrained=microsoft/phi-2 \
--tasks mmlu \
--limit 100 \
--batchsize auto
Best Practices
1. Konsistensi dalam Evaluasi
Selalu gunakan parameter yang sama saat membandingkan model:
EVALCONFIG = {
"tasks": ["mmlu", "hellaswag", "arcchallenge", "winogrande", "gsm8k"],
"numfewshot": 5,
"batchsize": "auto",
}
resultsa = lmeval.simpleevaluate(
model="hf",
modelargs="pretrained=model-a",
EVALCONFIG,
)
resultsb = lmeval.simpleevaluate(
model="hf",
modelargs="pretrained=model-b",
EVALCONFIG,
)
2. Dokumentasikan Konfigurasi Evaluasi
Simpan konfigurasi evaluasi bersama hasilnya:
import json
from datetime import datetime
evalrecord = {
"timestamp": datetime.now().isoformat(),
"model": "meta-llama/Llama-3.1-8B",
"lmevalversion": lmeval.version,
"tasks": ["mmlu", "hellaswag"],
"numfewshot": 5,
"results": results["results"],
}
with open("evalrecord.json", "w") as f:
json.dump(evalrecord, f, indent=2)
3. Pilih Benchmark yang Tepat
Sesuaikan benchmark dengan kebutuhan evaluasi:
- Pengetahuan umum: MMLU, ARC
- Penalaran: HellaSwag, WinoGrande
- Matematika: GSM8K, MATH
- Coding: HumanEval, MBPP
- Kebenaran fakta: TruthfulQA
- Bahasa Indonesia: Gunakan task kustom dengan dataset lokal
4. Gunakan Few-shot yang Standar
Ikuti standar few-shot untuk setiap benchmark:
| Benchmark | Standard Few-shot |
|-----------|------------------|
| MMLU | 5 |
| HellaSwag | 10 |
| ARC | 25 |
| WinoGrande | 5 |
| GSM8K | 5 |
| TruthfulQA | 0 |
5. Evaluasi Secara Berkala
Integrasikan evaluasi ke dalam pipeline CI/CD Anda:
#!/bin/bash
evalpipeline.sh
MODELPATH=$1
OUTPUTDIR="evalresults/$(date +%Y%m%d%H%M%S)"
mkdir -p $OUTPUTDIR
lmeval --model hf \
--modelargs pretrained=$MODELPATH \
--tasks mmlu,hellaswag,arcchallenge,gsm8k \
--numfewshot 5 \
--batchsize auto \
--outputpath $OUTPUTDIR \
--logsamples
echo "Results saved to $OUTPUTDIR"
Integrasi dengan Tools Lain
Integrasi dengan Weights & Biases
import lmeval
import wandb
wandb.init(project="llm-evaluation", name="llama3-8b-eval")
results = lm
eval.simpleevaluate(
model="hf",
model
args="pretrained=meta-llama/Llama-3.1-8B",
tasks=["mmlu", "hellaswag", "gsm8k"],
numfewshot=5,
batchsize="auto",
)
for taskname, taskresult in results["results"].items():
for metric, value in taskresult.items():
if isinstance(value, (int, float)):
wandb.log({f"{taskname}/{metric}": value})
wandb.finish()
Integrasi dengan MLflow
import lmeval
import mlflow
mlflow.set
experiment("llm-evaluation")
with mlflow.startrun(runname="llama3-8b-eval"):
results = lmeval.simpleevaluate(
model="hf",
modelargs="pretrained=meta-llama/Llama-3.1-8B",
tasks=["mmlu", "hellaswag"],
numfewshot=5,
batchsize="auto",
)
mlflow.logparam("model", "meta-llama/Llama-3.1-8B")
mlflow.logparam("tasks", "mmlu,hellaswag")
for taskname, taskresult in results["results"].items():
for metric, value in taskresult.items():
if isinstance(value, (int, float)):
mlflow.logmetric(f"{taskname}_{metric}", value)
Kesimpulan
LM Evaluation Harness adalah alat yang sangat penting dalam toolkit setiap praktisi AI/ML yang bekerja dengan model bahasa besar. Dengan ratusan benchmark bawaan, dukungan untuk berbagai backend model, dan kemampuan untuk membuat evaluasi kustom, lm-eval menyediakan fondasi yang solid untuk evaluasi LLM yang sistematis dan reproducible.
Poin-poin utama yang perlu diingat:
Dengan menguasai lm-eval, Anda dapat membuat keputusan yang lebih informasi tentang model mana yang terbaik untuk kebutuhan spesifik Anda, serta mengukur dampak dari fine-tuning dan optimasi yang dilakukan.