Tutorial Lengkap LM Evaluation Harness: Framework Standar untuk Evaluasi Model Bahasa Besar

# 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 ya...

By Ruby Abdullah · · tutorial
LLM EvaluationLM EvalBenchmarkingEleutherAIMachine Learning

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 \

--modelargs 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 \

--modelargs pretrained=microsoft/phi-2 \

--tasks hellaswag \

--numfewshot 10 \

--batchsize auto

GSM8K (Grade School Math)

Menguji kemampuan penalaran matematis:

lmeval --model hf \

--modelargs 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 \

--modelargs 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 \

--modelargs 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 = lmeval.simpleevaluate(

model="hf",

modelargs="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 lmeval.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: mygenerativetask

datasetpath: 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:"
filter
list:

  • name: getanswer
filter:

  • function: regex
regex
pattern: "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 \

--modelargs 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 \

--modelargs 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 = lmeval.simpleevaluate(

model="hf",

modelargs="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.setexperiment("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:

  • Selalu gunakan konfigurasi evaluasi yang konsisten saat membandingkan model
  • Pilih benchmark yang sesuai dengan use case Anda
  • Gunakan few-shot standar untuk setiap benchmark agar hasil comparable
  • Dokumentasikan setiap sesi evaluasi untuk reprodusibilitas
  • Integrasikan evaluasi ke dalam pipeline pengembangan model Anda
  • 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.

    Artikel Terkait

    AutoGluon: Tutorial Lengkap Library AutoML dari AWS untuk Machine Learning Otomatis

    Tutorial Lengkap AutoGluon: Library AutoML dari AWS untuk Machine Learning Otomatis AutoGluon adalah library open-source...

    Tutorial CatBoost: Gradient Boosting untuk Data Tabular dengan Penanganan Fitur Kategorikal Otomatis

    Tutorial CatBoost: Gradient Boosting untuk Data Tabular dengan Penanganan Fitur Kategorikal Otomatis CatBoost (Categoric...

    Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet

    Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet Hugging Face AutoTrain adalah platform dan lib...

    Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End

    Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End MLflow adalah platform open-source yang dikembangkan oleh D...