Evaluations¶

เฟรมเวิร์กการประเมินผลของ OpenJarvis (openjarvis.evals) วัด ความถูกต้องและความแม่นยำ ของโมเดลบนชุดข้อมูลเชิงวิชาการ มันมาพร้อมกับ แพ็กเกจ openjarvis หลัก (ที่ src/openjarvis/evals/) และออกแบบมาเฉพาะ สำหรับเวิร์กโฟลว์การวิจัยที่คุณต้องการการประเมินคุณภาพแบบขับเคลื่อนด้วย ชุดข้อมูลที่ทำซ้ำได้

Evals เทียบกับ Benchmarks

OpenJarvis มีระบบการวัดที่แตกต่างกันสองระบบที่เสริมกัน:

ระบบ	โมดูล	วัดอะไร	Entry Point
Evaluations	`openjarvis.evals`	ความถูกต้องบนชุดข้อมูลเชิงวิชาการ (ความแม่นยำ, อัตราผ่าน)	`jarvis eval`
Benchmarks	`openjarvis.bench`	ประสิทธิภาพของ engine (latency, throughput)	`jarvis bench`

ใช้ evaluation เพื่อตอบคำถาม "โมเดลนี้ตอบถูกไหม?" และใช้ benchmark เพื่อตอบคำถาม "โมเดลนี้ตอบเร็วแค่ไหน?" ดู คู่มือ Benchmarks สำหรับระบบวัดประสิทธิภาพ

เคล็ดลับ: LLM-guided spec search ใช้โครงสร้างพื้นฐาน eval เดียวกันนี้เพื่อคัดกรองการแก้ไขเทียบกับ benchmark ส่วนตัวของคุณ ดู LLM-guided spec search

การติดตั้ง¶

เฟรมเวิร์กการประเมินผลเป็นส่วนหนึ่งของแพ็กเกจ openjarvis หลัก — ไม่ต้อง ติดตั้งแยกหรือใช้ extra ใดๆ การตั้งค่า dev มาตรฐานก็เพียงพอ:

uv sync --extra dev

Dependency หลักของเฟรมเวิร์ก (click, datasets, rich) เป็น dependency พื้นฐานของ openjarvis อยู่แล้ว มี extra เสริมสองตัวที่เปิดใช้งานการผสาน กับระบบติดตามการทดลอง:

uv sync --extra dev --extra eval-wandb     # Weights & Biases run tracking
uv sync --extra dev --extra eval-sheets    # Google Sheets results export

TauBench ต้องการ Python 3.12 หรือใหม่กว่า และแพ็กเกจ tau2 ต้นน้ำเพิ่มเติม ติดตั้ง revision ที่ pin ไว้อย่างชัดเจนก่อนรัน benchmark นั้น:

uv pip install "tau2 @ git+https://github.com/sierra-research/tau2-bench.git@fc0055dc4e0a316c3f83133267fbd6faaa770992"

OpenJarvis จะไม่ติดตั้งแพ็กเกจของบุคคลที่สามให้อัตโนมัติเมื่อมีการ import หรือรัน evaluation

ข้อกำหนดเวอร์ชัน Python

Python 3.10 ต้องการแพ็กเกจ tomli สำหรับการ parse config แบบ TOML openjarvis ประกาศไว้เป็น conditional dependency จึงถูกติดตั้งให้อัตโนมัติ

Entry Point¶

มี entry point ที่เทียบเท่ากันสองแบบ ที่เปิดใช้เฟรมเวิร์กนี้:

คำสั่ง	ขอบเขต
`jarvis eval {list,run,compare,report}`	CLI มาตรฐาน `run` ครอบคลุมตัวเลือกทั่วไป; `compare` และ `report` ประมวลผลไฟล์ผลลัพธ์ต่อ
`python -m openjarvis.evals {list,run,run-all,summarize,reparse-judge}`	ขอบเขตงานวิจัยแบบเต็ม รวมถึงการตั้งค่า judge, ตัวรันแบบ agentic และโหมด episode

Console script openjarvis-eval เป็น alias ของ python -m openjarvis.evals — คำสั่งและตัวเลือกเดียวกัน คู่มือนี้ใช้ jarvis eval ทุกครั้งที่ชุดตัวเลือก เพียงพอ และใช้รูปแบบ module สำหรับตัวเลือกเฉพาะงานวิจัย

ชุดข้อมูล¶

เฟรมเวิร์กนี้มาพร้อม benchmark ที่ลงทะเบียนไว้ 40 ตัว ครอบคลุมการให้ เหตุผลเชิงวิชาการ, งานเชิงตัวแทน, การเขียนโค้ด, การดึงข้อมูล, คุณภาพการ สนทนา และ benchmark กรณีใช้งานจริง จัดกลุ่มตามหมวดหมู่ด้านล่าง; uv run python -m openjarvis.evals list จะแสดง registry ที่ถูกต้องที่สุด

Benchmark กรณีใช้งานจริง¶

Benchmark เหล่านี้ประเมินโมเดลบนงานจริงที่สะท้อนกรณีใช้งาน OpenJarvis จริง

ชุดข้อมูล	Key	คำอธิบาย
CodingAssistant	`coding_assistant`	ผู้ช่วยเขียนโค้ดแก้บั๊ก (อิงเทสต์)
SecurityScanner	`security_scanner`	ตัวสแกนช่องโหว่ความปลอดภัย
DailyDigest	`daily_digest`	การสร้างบรีฟประจำวัน
DocQA	`doc_qa`	QA อิงเอกสารพร้อมการอ้างอิง
BrowserAssistant	`browser_assistant`	การวิจัยเว็บพร้อมตรวจสอบข้อเท็จจริง
EmailTriage	`email_triage`	การจำแนกและร่างคำตอบคัดกรองอีเมล
MorningBrief	`morning_brief`	การสร้างบรีฟตอนเช้า
ResearchMining	`research_mining`	การสังเคราะห์งานวิจัย + ความแม่นยำ
KnowledgeBase	`knowledge_base`	QA แบบดึงข้อมูลอิงเอกสาร
CodingTask	`coding_task`	การสร้างโค้ดระดับฟังก์ชัน

Benchmark เชิงวิชาการ¶

Benchmark เหล่านี้วัดการให้เหตุผลและความรู้บนชุดข้อมูลเชิงวิชาการที่ยอมรับ กันทั่วไป

ชุดข้อมูล	Key	หมวดหมู่	คำอธิบาย
SuperGPQA	`supergpqa`	reasoning	คำถามปรนัยระดับบัณฑิตศึกษาข้ามสาขาวิทยาศาสตร์
GPQA	`gpqa`	reasoning	คำถามปรนัยระดับบัณฑิตศึกษา (แบบ Diamond, Extended, Main)
MMLU-Pro	`mmlu-pro`	reasoning	คำถามปรนัย MMLU แบบเสริม
MATH-500	`math500`	reasoning	โจทย์คณิตศาสตร์ระดับแข่งขัน
NaturalReasoning	`natural-reasoning`	reasoning	การให้เหตุผลด้วยภาษาธรรมชาติ
HLE	`hle`	reasoning	ความท้าทายระดับยากของ Humanity's Last Exam
LiveResearchBench	`liveresearchbench`	reasoning	ความเข้าใจงานวิจัยล่าสุด (Salesforce)
SimpleQA	`simpleqa`	chat	การถาม-ตอบข้อเท็จจริงแบบสั้น
IPW	`ipw`	chat	Benchmark ผสม Intelligence Per Watt

Benchmark เชิงเอเจนต์¶

Benchmark เหล่านี้ทดสอบความสามารถของเอเจนต์แบบหลายขั้นตอน รวมถึงการใช้ tool, การสร้างโค้ด และการวางแผนระยะยาว

ชุดข้อมูล	Key	หมวดหมู่	คำอธิบาย
GAIA	`gaia`	agentic	งานหลายขั้นตอนที่มี file I/O, การคำนวณ, การค้นหาเว็บ
SWE-bench	`swebench`	agentic	Patch โค้ด GitHub จากงานจริง
SWEfficiency	`swefficiency`	agentic	งานปรับปรุงประสิทธิภาพซอฟต์แวร์
TerminalBench	`terminalbench`	agentic	การทำงานให้เสร็จบนเทอร์มินัล
TerminalBench Native	`terminalbench-native`	agentic	TerminalBench พร้อม Docker แบบเนทีฟ
TerminalBench V2.1	`terminalbench-v2.1`	agentic	งาน TB v2.1 แบบ Harbor Docker
PinchBench	`pinchbench`	agentic	งานเอเจนต์จากโลกจริง
TauBench	`taubench`	agentic	บริการลูกค้าแบบหลายรอบ
DeepResearchBench	`liveresearch`	agentic	การสร้างรายงานวิจัยเชิงลึก
DeepResearchBench (alias)	`deepresearch`	agentic	Benchmark เดียวกับ `liveresearch`
ToolCall-15	`toolcall15`	agentic	Benchmark การเรียกใช้ tool
LifelongAgent	`lifelong-agent`	agentic	การเรียนรู้งานตามลำดับข้าม session
PaperArena	`paperarena`	agentic	การวิเคราะห์บทความวิชาการ
DeepPlanning	`deepplanning`	agentic	การวางแผนภายใต้เงื่อนไขการช้อปปิ้ง
LogHub	`loghub`	agentic	การตรวจจับความผิดปกติใน log
AMA-Bench	`ama-bench`	agentic	การประเมิน memory ของเอเจนต์
WebChoreArena	`webchorearena`	agentic	งานจุกจิกบนเว็บ
WorkArena	`workarena`	agentic	เวิร์กโฟลว์องค์กรของ WorkArena++

ทั้ง liveresearch และ deepresearch เป็นคีย์ที่ลงทะเบียนไว้สำหรับ benchmark การสร้างรายงานของ DeepResearchBench

Benchmark การเขียนโค้ด¶

ชุดข้อมูล	Key	หมวดหมู่	คำอธิบาย
LiveCodeBench	`livecodebench`	coding	การเขียนโปรแกรมเชิงแข่งขัน

Benchmark การดึงข้อมูล¶

ชุดข้อมูล	Key	หมวดหมู่	คำอธิบาย
FRAMES	`frames`	rag	การดึงข้อเท็จจริงแบบ multi-hop ข้ามบทความ Wikipedia

Benchmark การสนทนา¶

ชุดข้อมูล	Key	หมวดหมู่	คำอธิบาย
WildChat	`wildchat`	chat	คุณภาพบทสนทนาผู้ใช้จริง (LLM judge แบบ pairwise)

รายละเอียดชุดข้อมูล¶

SuperGPQA คือ benchmark ปรนัยขนาดใหญ่ ครอบคลุมคำถามระดับบัณฑิตศึกษาข้าม สาขาวิทยาศาสตร์ แต่ละ sample มีคำถาม, ชุดตัวเลือกที่มีตัวอักษรกำกับ และ คำตอบอ้างอิงเป็นตัวอักษร

GAIA คือ benchmark เชิงเอเจนต์ที่ต้องการให้โมเดลทำงานหลายขั้นตอนให้ สำเร็จ ซึ่งอาจเกี่ยวข้องกับการอ่านไฟล์, การคำนวณ และการค้นหาเว็บ คำถามมา จากชุด GAIA challenge ปี 2023

FRAMES ทดสอบการดึงข้อเท็จจริงแบบ multi-hop แต่ละคำถามต้องสังเคราะห์ ข้อมูลข้ามบทความ Wikipedia หลายบทความ ทำให้เป็นตัวทดสอบความสามารถ retrieval-augmented generation ที่ดี

WildChat ใช้บทสนทนาผู้ใช้จริงที่กรองเฉพาะการแลกเปลี่ยนภาษาอังกฤษแบบ รอบเดียว คำตอบอ้างอิงคือคำตอบดั้งเดิมของผู้ช่วยจากชุดข้อมูล; โมเดลที่ถูก ประเมินจะถูกเปรียบเทียบกับมันโดย LLM judge

การเข้าถึงชุดข้อมูล GAIA

ชุดข้อมูล GAIA ต้องการบัญชี HuggingFace และการยอมรับเงื่อนไขการใช้งานของชุดข้อมูล Loader จะดาวน์โหลด snapshot ของชุดข้อมูลทั้งหมดในการใช้งานครั้งแรก และ cache ไว้ที่ ~/.cache/gaia_benchmark/ การรันครั้งถัดไปจะใช้ cache ในเครื่อง

Config Eval สำหรับกรณีใช้งาน¶

เฟรมเวิร์กนี้มี config สำเร็จรูปสองแบบสำหรับประเมินโมเดลบน benchmark กรณี ใช้งานหลักห้าตัว (coding_assistant, security_scanner, daily_digest, doc_qa, browser_assistant)

โมเดล Cloud¶

uv run jarvis eval run --config src/openjarvis/evals/configs/use_case_v2_cloud.toml

Config นี้ประเมิน โมเดล cloud 6 ตัว (Claude Opus 4.6, Claude Haiku 4.5, Gemini 3.1 Pro, Gemini 3.1 Flash Lite, GPT-5.4, GPT-5 Mini) เทียบกับ benchmark กรณีใช้งานทั้ง 5 ตัว โดยใช้ 30 sample ต่อตัว สร้าง matrix 6x5 = 30 การรัน ผลลัพธ์ถูกเขียนไปที่ results/use-cases-v2-cloud/

โมเดลในเครื่อง¶

uv run jarvis eval run --config src/openjarvis/evals/configs/use_case_v2_local.toml

Config นี้ประเมิน โมเดลในเครื่อง 5 ตัว ผ่าน Ollama (Qwen3.5 122B-A10B, GPT-OSS 120B, GLM4, Qwen3.5 35B-A3B, GLM-4.7-Flash) เทียบกับ benchmark 5 ตัว เดียวกัน สร้าง matrix 5x5 = 25 การรัน ใช้ 2 worker (เหมาะกับการตั้งค่า single-GPU) ผลลัพธ์ถูกเขียนไปที่ results/use-cases-v2-local/

ปรับแต่ง Eval กรณีใช้งาน

คัดลอก config use_case_v2_*.toml ตัวใดตัวหนึ่งแล้วแก้ไข entry [[models]] เพื่อประเมินโมเดลของคุณเอง benchmark กรณีใช้งานทั้งห้าตัวใช้ชุดข้อมูล synthetic (ไม่ต้องดาวน์โหลดจาก HuggingFace) และรันเร็วด้วย 30 sample ต่อตัว

Inference Backend¶

การรัน evaluation ทุกครั้งจัดเส้นทางการเรียกโมเดลผ่าน backend สี่ตัวใดตัวหนึ่ง:

Backend	Key	คำอธิบาย
jarvis-direct	`jarvis-direct`	Inference ระดับ engine ผ่าน `SystemBuilder` ใช้ได้กับโมเดลในเครื่อง (Ollama, vLLM, llama.cpp) และ cloud
jarvis-agent	`jarvis-agent`	Inference ระดับเอเจนต์พร้อมการเรียก tool ใช้ `JarvisSystem.ask()` พร้อมเอเจนต์และ tool ที่ระบุ
hermes	`hermes`	Hermes Agent จริง (Nous Research) ผ่าน subprocess ต้องมี `--base-url` และ `--api-key`
openclaw	`openclaw`	OpenClaw จริง ผ่าน Node subprocess ต้องมี `--base-url` และ `--api-key`

ใช้ jarvis-direct สำหรับ evaluation ส่วนใหญ่ ใช้ jarvis-agent เมื่อ benchmark ต้องการการใช้ tool — เช่น งาน GAIA ที่อ้างอิงไฟล์ที่ต้องอ่านด้วย file_read หรืองานคำนวณที่ได้ประโยชน์จาก calculator

Backend hermes และ openclaw เรียกใช้เฟรมเวิร์กเอเจนต์ภายนอกและต้องการ endpoint ที่เข้ากันได้กับ OpenAI สำหรับการเรียกโมเดล: ส่ง --base-url/--api-key, ตั้งค่า environment variable JARVIS_BACKEND_BASE_URL/JARVIS_BACKEND_API_KEY หรือเพิ่มหมวด [backend.external] ใน config ของคุณ (ดู Config Reference)

TerminalBench Native

jarvis eval run --backend ยังรับ terminalbench-native ด้วย ซึ่งเป็น backend การรันแบบ Docker ที่ใช้โดย benchmark TerminalBench Native

การใช้งานผ่าน CLI¶

แสดงรายการ Benchmark และ Backend ที่มี¶

uv run python -m openjarvis.evals list

ผลลัพธ์แบบย่อ (40 benchmark, 4 backend):

                         Available Benchmarks
┌──────────────────────┬───────────┬───────────────────────────────────┐
│ Name                 │ Category  │ Description                       │
├──────────────────────┼───────────┼───────────────────────────────────┤
│ supergpqa            │ reasoning │ SuperGPQA multiple-choice         │
│ gpqa                 │ reasoning │ GPQA graduate-level MCQ           │
│ ...                  │ ...       │ ...                               │
│ livecodebench        │ coding    │ LiveCodeBench competitive progr.  │
│ toolcall15           │ agentic   │ ToolCall-15 tool calling benchmark│
└──────────────────────┴───────────┴───────────────────────────────────┘
                         Available Backends
┌───────────────┬──────────────────────────────────────────────────┐
│ jarvis-direct │ Engine-level inference (local or cloud)          │
│ jarvis-agent  │ Agent-level inference with tool calling          │
│ hermes        │ Real Hermes Agent (Nous Research) via subprocess │
│ openclaw      │ Real OpenClaw via Node subprocess                │
└───────────────┴──────────────────────────────────────────────────┘

jarvis eval list แสดงตารางคล้ายกันแต่ปัจจุบันแสดงเพียง subset ที่คัดสรร ของ registry; รูปแบบ module ด้านบนคือรายการที่ถูกต้องที่สุด

รัน Benchmark เดียว¶

# Evaluate qwen3:8b on SuperGPQA (engine-level, 10 samples)
uv run jarvis eval run -b supergpqa -m qwen3:8b -n 10

# Evaluate GPT-5 Mini on GAIA using the agent backend with tools
uv run jarvis eval run -b gaia -m gpt-5-mini --backend jarvis-agent \
    --agent orchestrator --tools calculator,file_read -n 50

# Run FRAMES with the vLLM engine, write output to a file
uv run jarvis eval run -b frames -m llama3:70b -e vllm \
    -o results/frames_llama70b.jsonl

# Run WildChat with a higher temperature for chat quality
uv run jarvis eval run -b wildchat -m qwen3:8b --temperature 0.7 -n 100

เอกสารอ้างอิงตัวเลือกของ `jarvis eval run`¶

ตัวเลือก	ย่อ	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`--config`	`-c`	path	—	ไฟล์ config แบบ TOML; เมื่อระบุแล้ว ไม่จำเป็นต้องมี `-b` และ `-m`
`--benchmark`	`-b`	str	จำเป็น*	คีย์ benchmark ที่ลงทะเบียนไว้ใดๆ (ดู `... list`)
`--model`	`-m`	str	จำเป็น*	Identifier ของโมเดล (เช่น `qwen3:8b`, `gpt-5-mini`)
`--max-samples`	`-n`	int	ทั้งหมด	จำกัดจำนวน sample ที่ประเมิน
`--backend`		choice	`jarvis-direct`	`jarvis-direct`, `jarvis-agent`, `hermes`, `openclaw` หรือ `terminalbench-native`
`--base-url`		str	—	URL endpoint ที่เข้ากันได้กับ OpenAI (env: `JARVIS_BACKEND_BASE_URL`)
`--api-key`		str	—	API key สำหรับ endpoint (env: `JARVIS_BACKEND_API_KEY`)
`--agent`		str	—	ชื่อเอเจนต์สำหรับ backend `jarvis-agent` (เช่น `orchestrator`)
`--engine`	`-e`	str	อัตโนมัติ	คีย์ engine (`ollama`, `vllm`, `cloud`, ...)
`--tools`		str	`""`	ชื่อ tool คั่นด้วยคอมมา (เช่น `calculator,file_read`)
`--telemetry/--no-telemetry`		flag	ปิด	เปิดการเก็บ telemetry ระหว่าง eval
`--gpu-metrics/--no-gpu-metrics`		flag	ปิด	เปิดการ poll metric ของ GPU
`--seed`		int	`42`	Seed สุ่มสำหรับการสับชุดข้อมูล
`--temperature`		float	`0.0`	Temperature ของการ generate
`--max-tokens`		int	`2048`	จำนวน output token สูงสุด
`--model-filter`		str	—	กรองโมเดลด้วย substring ของชื่อ (config หลายโมเดล)
`--output`	`-o`	path	สร้างอัตโนมัติ	Path ของไฟล์ผลลัพธ์ JSONL
`--wandb-project` / `--wandb-entity` / `--wandb-tags` / `--wandb-group`		str	`""`	การติดตามด้วย Weights & Biases
`--sheets-id` / `--sheets-worksheet` / `--sheets-creds`		str	`""`	Export ไปยัง Google Sheets
`--verbose`	`-v`	flag	ปิด	เปิด debug logging

*จำเป็นเมื่อไม่ได้ระบุ --config

ตัวเลือกเฉพาะงานวิจัย (`python -m openjarvis.evals run`)¶

Module CLI รับตัวเลือกทั้งหมดข้างต้น บวกกับตัวเลือกระดับงานวิจัยที่ jarvis eval run ไม่มี:

ตัวเลือก	ย่อ	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`--max-workers`	`-w`	int	`4`	Worker การประเมินแบบขนาน
`--judge-model`		str	`gpt-5-mini-2025-08-07`	LLM ที่ใช้ให้คะแนนแบบ judge (ดู `--help` สำหรับค่าเริ่มต้นปัจจุบัน)
`--judge-engine`		str	`cloud`	คีย์ engine สำหรับ LLM judge; ใช้ `vllm` เพื่อ judge ในเครื่อง
`--split`		str	ค่าเริ่มต้นของชุดข้อมูล	Override split ของชุดข้อมูล
`--compact`		flag	ปิด	ผลลัพธ์แบบตารางเดียวกระชับ
`--trace-detail`		flag	ปิด	รายการ trace แบบเต็มต่อขั้นตอน
`--agentic`		flag	ปิด	ใช้ `AgenticRunner` สำหรับการรันเอเจนต์แบบหลายรอบ
`--episode-mode`		flag	ปิด	ประมวลผล episode ตามลำดับพร้อม lifelong learning (จำเป็นสำหรับ `lifelong-agent` และ benchmark ที่คล้ายกัน)
`--concurrency`		int	`1`	การรันคำถามแบบขนาน (เฉพาะ AgenticRunner)
`--query-timeout`		float	—	Timeout แบบ wall-clock ต่อคำถาม เป็นวินาที (เฉพาะ AgenticRunner)

หมายเหตุ: ตัวเลือก --backend ของ module CLI ครอบคลุม jarvis-direct, jarvis-agent, hermes และ openclaw; terminalbench-native ในฐานะ backend มีให้ใช้ผ่าน jarvis eval run และ config แบบ TOML

รัน Benchmark ทั้งหมดพร้อมกัน¶

คำสั่ง run-all (เฉพาะ module CLI) ประเมินโมเดลเดียวเทียบกับ benchmark ที่ลงทะเบียนไว้ทั้งหมด ตามลำดับ และเขียนผลลัพธ์ไปยังไดเรกทอรี ผลลัพธ์:

uv run python -m openjarvis.evals run-all -m qwen3:8b

# With options
uv run python -m openjarvis.evals run-all -m gpt-5-mini -n 100 --output-dir results/gpt5mini/

ไฟล์ผลลัพธ์ถูกเขียนเป็น {output_dir}/{benchmark}_{model-slug}.jsonl model slug จะแทนที่ / และ : ด้วย - ดังนั้น qwen3:8b จะกลายเป็น qwen3-8b

สรุปผลลัพธ์¶

หลังการรัน ตรวจสอบไฟล์ผลลัพธ์ JSONL:

uv run python -m openjarvis.evals summarize results/supergpqa_qwen3-8b.jsonl

ผลลัพธ์:

File:      results/supergpqa_qwen3-8b.jsonl
Benchmark: supergpqa
Model:     qwen3:8b
Total:     200
Scored:    198
Correct:   143
Accuracy:  0.7222
Errors:    2

Module CLI ยังมี reparse-judge ซึ่ง parse ผลลัพธ์ judge ที่เก็บไว้ในไฟล์ ผลลัพธ์ใหม่ และกู้คืน record ที่ verdict ของ judge parse ไม่สำเร็จในตอนแรก — มีประโยชน์หลังจากปรับปรุง parser ผลลัพธ์ judge โดยไม่ต้องรัน inference ใหม่

เปรียบเทียบและสร้างรายงาน¶

jarvis eval มีคำสั่งประมวลผลไฟล์ผลลัพธ์เพิ่มเติมสองคำสั่ง:

# Side-by-side metric comparison across runs
uv run jarvis eval compare results/supergpqa_qwen3-8b.jsonl results/supergpqa_gpt-5-mini.jsonl

# Detailed report (accuracy, latency, cost, per-subject breakdown) for one run
uv run jarvis eval report results/supergpqa_qwen3-8b.jsonl

การประเมิน Endpoint ที่กำลังรันอยู่แล้ว¶

หากคุณมีเซิร์ฟเวอร์ที่เข้ากันได้กับ OpenAI กำลังรันอยู่แล้ว — jarvis serve, vLLM, SGLang, เซิร์ฟเวอร์ของ llama.cpp หรือ endpoint แบบ hosted — ชี้ evaluation ไปที่มันตรงๆ ด้วย --base-url และ --api-key:

# A vLLM server is already serving Qwen/Qwen3-8B on a GPU node:
#   vllm serve Qwen/Qwen3-8B --port 8000
uv run jarvis eval run -b supergpqa -m Qwen/Qwen3-8B \
    --base-url http://gpu-node:8000/v1 \
    --api-key local-key \
    -n 50

ค่า -m ต้องตรงกับ model id ที่เซิร์ฟเวอร์รายงานที่ GET /v1/models ทั้งสอง flag fallback ไปที่ environment variable JARVIS_BACKEND_BASE_URL และ JARVIS_BACKEND_API_KEY ดังนั้นงาน CI ตั้งค่าครั้งเดียวได้:

export JARVIS_BACKEND_BASE_URL=http://gpu-node:8000/v1
export JARVIS_BACKEND_API_KEY=local-key
uv run jarvis eval run -b gaia -m Qwen/Qwen3-8B --backend jarvis-agent -n 25

สำหรับ backend ภายนอก hermes และ openclaw ค่าเหล่านี้ จำเป็น (เฟรมเวิร์กภายนอกต้องการ endpoint เพื่อส่งการเรียกโมเดล)

ทางเลือกระดับ Engine สำหรับ vLLM

Engine ของ vLLM ยังเคารพ environment variable VLLM_HOST ด้วย (ค่าเริ่มต้น http://localhost:8000):

VLLM_HOST=http://gpu-node:8000 uv run python -m openjarvis.evals run \
    -b supergpqa -m Qwen/Qwen3-8B -e vllm -n 50

VLLM_HOST เป็นแบบ process-global — หากทั้งผู้เข้าแข่งขันและ judge ใช้ engine vllm ทั้งคู่ จะแชร์ endpoint เดียวกัน ใช้ --base-url เมื่อคุณต้องการแยกกัน

ระบบ Config แบบ TOML¶

สำหรับเวิร์กโฟลว์การวิจัยที่เปรียบเทียบหลายโมเดลข้ามหลาย benchmark ใช้ไฟล์ config แบบ TOML เพื่อกำหนด evaluation เป็น matrix ของโมเดล x benchmark นี่คือแนวทางที่แนะนำสำหรับการประเมินอย่างเป็นระบบ

รันจาก Config¶

uv run jarvis eval run --config src/openjarvis/evals/configs/full-suite.toml

เมื่อระบุ --config แล้ว ไม่จำเป็นต้องมีตัวเลือก -b/--benchmark และ -m/--model การตั้งค่าทั้งหมดมาจากไฟล์ config CLI จะขยาย matrix, พิมพ์ ตารางความคืบหน้า และเขียนผลลัพธ์ไปยัง output_dir ที่ตั้งค่าไว้

รูปแบบไฟล์ Config¶

ไฟล์ config มีหกหมวด: [meta], [defaults], [judge], [run], [[models]] และ [[benchmarks]] มีเพียง [[models]] และ [[benchmarks]] เท่านั้นที่จำเป็น — หมวดอื่นทั้งหมดเป็นตัวเลือกเสริมและ fallback ไปใช้ค่า เริ่มต้นในตัว

src/openjarvis/evals/configs/full-suite.toml

# Suite-level metadata (optional)
[meta]
name = "full-suite-v1"
description = "Evaluate all benchmarks against production models"

# Default generation parameters (optional)
[defaults]
temperature = 0.0
max_tokens = 2048

# LLM judge configuration (optional)
[judge]
model = "gpt-4o"
temperature = 0.0
max_tokens = 1024

# Execution settings (optional)
[run]
max_workers = 4
output_dir = "results/"
seed = 42

# --- Models (one [[models]] block per model) ---

[[models]]
name = "qwen3:8b"
engine = "ollama"
temperature = 0.3    # overrides [defaults] for this model
max_tokens = 4096

[[models]]
name = "gpt-4o"
provider = "openai"  # uses cloud engine

[[models]]
name = "llama3:70b"
engine = "vllm"
temperature = 0.1

# --- Benchmarks (one [[benchmarks]] block per benchmark) ---

[[benchmarks]]
name = "supergpqa"
backend = "jarvis-direct"
max_samples = 200
split = "train"

[[benchmarks]]
name = "gaia"
backend = "jarvis-agent"
agent = "orchestrator"
tools = ["file_read", "calculator"]
max_samples = 50
judge_model = "claude-sonnet-4-20250514"  # override judge for this benchmark

[[benchmarks]]
name = "frames"
backend = "jarvis-direct"
max_samples = 100

[[benchmarks]]
name = "wildchat"
backend = "jarvis-direct"
max_samples = 150
temperature = 0.7   # override temperature for this benchmark

Config นี้สร้าง 3 โมเดล x 4 benchmark = 12 การรัน evaluation

ลำดับความสำคัญของการรวมค่า¶

การตั้งค่าถูก resolve ตามลำดับความสำคัญนี้ จากสูงไปต่ำ:

benchmark-level  >  model-level  >  [defaults]  >  built-in defaults

ตัวอย่างเช่น temperature ถูก resolve ดังนี้: ใช้ [defaults].temperature (0.0) ก่อน จากนั้นใช้ [[models]].temperature หากตั้งไว้ (0.3 สำหรับ qwen3:8b) แล้ว override ด้วย [[benchmarks]].temperature หากตั้งไว้ (0.7 สำหรับ wildchat) การรัน WildChat กับ qwen3:8b จึงรันที่ temperature = 0.7

Config แบบขั้นต่ำ¶

Config ต้องการเพียง entry [[models]] และ [[benchmarks]] อย่างละหนึ่ง รายการ:

src/openjarvis/evals/configs/minimal.toml

[[models]]
name = "qwen3:8b"

[[benchmarks]]
name = "supergpqa"

สิ่งนี้รัน SuperGPQA เทียบกับ qwen3:8b โดยใช้การตั้งค่าเริ่มต้นทั้งหมด ใช้ เป็นจุดเริ่มต้นเมื่อทำงานวนซ้ำกับโมเดลหรือชุดข้อมูลเดียว

Config สำหรับการรันเดียวพร้อมตัวเลือกครบ¶

src/openjarvis/evals/configs/single-run.toml

[meta]
name = "single-run-example"
description = "Evaluate SuperGPQA with a single model and full configuration"

[defaults]
temperature = 0.0
max_tokens = 2048

[judge]
model = "gpt-4o"
temperature = 0.0
max_tokens = 1024

[run]
max_workers = 4
output_dir = "results/"
seed = 42

[[models]]
name = "qwen3:8b"
engine = "ollama"
temperature = 0.3
max_tokens = 4096

[[benchmarks]]
name = "supergpqa"
backend = "jarvis-direct"
max_samples = 100
split = "train"

เอกสารอ้างอิง Config¶

`[meta]`¶

Metadata ระดับ suite ทั้งสองฟิลด์ไม่ส่งผลต่อพฤติกรรมการประเมิน ทั้งคู่ใช้ใน ผลลัพธ์ CLI และไฟล์สรุป

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`name`	str	`""`	ชื่อ suite ที่แสดงในผลลัพธ์ CLI
`description`	str	`""`	คำอธิบายที่มนุษย์อ่านได้

`[defaults]`¶

พารามิเตอร์การ generate เริ่มต้น ใช้กับทุกการรัน เว้นแต่จะ override ที่ระดับ โมเดลหรือ benchmark

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`temperature`	float	`0.0`	Temperature ของ sampling
`max_tokens`	int	`2048`	จำนวน output token สูงสุด

`[judge]`¶

Configuration สำหรับ LLM ที่ใช้เป็น judge ในการให้คะแนน GAIA, FRAMES และ WildChat

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`model`	str	`"gpt-5-mini-2025-08-07"`	Identifier ของโมเดล judge
`engine`	str	`None`	คีย์ engine สำหรับ judge (เช่น `"vllm"` เพื่อ judge ในเครื่อง; ค่าเริ่มต้นคือ cloud)
`provider`	str	`None`	Override provider (เช่น `"openai"`)
`temperature`	float	`0.0`	Temperature ของการ sampling ของ judge
`max_tokens`	int	`1024`	จำนวน output token สูงสุดของ judge

ต้นทุนของโมเดล Judge

ทุก sample ที่ต้องการการให้คะแนนแบบ LLM จะเรียกโมเดล judge แยกต่างหาก สำหรับการรันขนาดใหญ่ที่มีหลายร้อย sample ต้นทุน judge อาจสูงกว่าต้นทุนการประเมินเอง GAIA, FRAMES และ WildChat ต้องมี judge ทั้งหมด; SuperGPQA ใช้ LLM ในการดึงตัวอักษรคำตอบ แล้วเทียบกับค่าอ้างอิงโดยไม่ต้องเรียก judge แยก

`[run]`¶

การตั้งค่าการรันที่ใช้กับทั้ง suite

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`max_workers`	int	`4`	จำนวน thread การประเมินแบบขนาน
`output_dir`	str	`"results/"`	ไดเรกทอรีที่เขียนไฟล์ JSONL และไฟล์สรุป
`seed`	int	`42`	Seed สุ่มสำหรับการสับชุดข้อมูล
`telemetry`	bool	`false`	เปิดการเก็บ GPU telemetry (พลังงาน, กำลังไฟ, การใช้งาน, throughput)
`gpu_metrics`	bool	`false`	เปิดการ poll metric GPU ผ่าน `pynvml` (ต้องมี `pynvml` หรือ `nvidia-ml-py`)
`warmup_samples`	int	`0`	Sample warmup ที่ไม่จับเวลา ก่อนการวัดผล
`energy_vendor`	str	`""`	Override ผู้ให้บริการพลังงาน GPU
`max_turns`	int	`None`	จำนวนรอบเอเจนต์สูงสุดต่อคำถาม
`wandb_project` / `wandb_entity` / `wandb_tags` / `wandb_group`	str	`""`	การติดตามด้วย Weights & Biases
`sheets_spreadsheet_id` / `sheets_worksheet` / `sheets_credentials_path`	str	`""` / `"Results"` / `""`	Export ไปยัง Google Sheets

`[backend.external]`¶

การตั้งค่า endpoint สำหรับ backend hermes และ openclaw Environment variable จะ override ค่า TOML

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`base_url`	str	`None`	URL endpoint ที่เข้ากันได้กับ OpenAI (env: `JARVIS_BACKEND_BASE_URL`)
`api_key`	str	`None`	API key สำหรับ endpoint (env: `JARVIS_BACKEND_API_KEY`)

`[[models]]`¶

หนึ่งหมวดต่อโมเดล ฟิลด์ name จำเป็นต้องมี

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`name`	str	จำเป็น	Identifier ของโมเดล (เช่น `"qwen3:8b"`, `"gpt-5-mini"`)
`engine`	str	`None`	คีย์ engine ที่จะใช้ (`"ollama"`, `"vllm"`, `"cloud"`, ...)
`provider`	str	`None`	Override provider สำหรับโมเดล cloud (เช่น `"openai"`)
`temperature`	float	`None`	Override `[defaults].temperature` สำหรับโมเดลนี้
`max_tokens`	int	`None`	Override `[defaults].max_tokens` สำหรับโมเดลนี้
`param_count_b`	float	`0.0`	จำนวนพารามิเตอร์รวมของโมเดล เป็นพันล้าน (สำหรับคำนวณ MFU/MBU)
`active_params_b`	float	`None`	พารามิเตอร์ที่ active ต่อ token เป็นพันล้าน (สำหรับโมเดล MoE; ค่าเริ่มต้นคือ `param_count_b`)
`gpu_peak_tflops`	float	`0.0`	TFLOPS สูงสุดแบบ FP16 ของ GPU (เช่น 312.0 สำหรับ A100 SXM)
`gpu_peak_bandwidth_gb_s`	float	`0.0`	Bandwidth หน่วยความจำสูงสุดของ GPU เป็น GB/s (เช่น 2039.0 สำหรับ A100 SXM)
`num_gpus`	int	`1`	จำนวน GPU ที่ใช้ (สำหรับ inference แบบ tensor-parallel)

`[[benchmarks]]`¶

หนึ่งหมวดต่อ benchmark ฟิลด์ name จำเป็นต้องมี

ฟิลด์	ชนิด	ค่าเริ่มต้น	คำอธิบาย
`name`	str	จำเป็น	คีย์ benchmark ที่ลงทะเบียนไว้ใดๆ (ดู `uv run python -m openjarvis.evals list`)
`backend`	str	`"jarvis-direct"`	`jarvis-direct`, `jarvis-agent`, `hermes`, `openclaw` หรือ `terminalbench-native`
`max_samples`	int	`None`	จำกัดจำนวน sample; `None` ประเมินทั้งชุดข้อมูล
`split`	str	`None`	Override split เริ่มต้นของชุดข้อมูล
`subset`	str	`None`	Subset/variant ของชุดข้อมูล (เฉพาะ benchmark)
`record_ids`	list[str]	`None`	ประเมินเฉพาะ record id เหล่านี้
`agent`	str	`None`	ชื่อเอเจนต์สำหรับ backend `jarvis-agent` (เช่น `"orchestrator"`)
`tools`	list[str]	`[]`	ชื่อ tool สำหรับ backend `jarvis-agent`
`judge_model`	str	`None`	Override `[judge].model` สำหรับ benchmark นี้เท่านั้น
`temperature`	float	`None`	Override temperature สำหรับ benchmark นี้ (ความสำคัญสูงสุด)
`max_tokens`	int	`None`	Override max tokens สำหรับ benchmark นี้ (ความสำคัญสูงสุด)

รูปแบบผลลัพธ์¶

ไฟล์ผลลัพธ์ JSONL¶

แต่ละ sample ที่ทำเสร็จจะถูกต่อเข้าไปในไฟล์ผลลัพธ์ JSONL ทันทีหลังให้คะแนน Path ของไฟล์ระบุด้วย -o/--output หรือสร้างอัตโนมัติเป็น {output_dir}/{benchmark}_{model-slug}.jsonl

แต่ละบรรทัดเป็น object JSON ที่มีฟิลด์ดังนี้:

results/supergpqa_qwen3-8b.jsonl (one line per sample)

{
  "record_id": "supergpqa-42",
  "benchmark": "supergpqa",
  "model": "qwen3:8b",
  "backend": "jarvis-direct",
  "model_answer": "The answer is C because...",
  "is_correct": true,
  "score": 1.0,
  "latency_seconds": 1.34,
  "prompt_tokens": 187,
  "completion_tokens": 12,
  "cost_usd": 0.0,
  "error": null,
  "scoring_metadata": {"reference_letter": "C", "candidate_letter": "C"},
  "ttft": 0.0,
  "energy_joules": 140792.95,
  "power_watts": 893.0,
  "gpu_utilization_pct": 47.4,
  "throughput_tok_per_sec": 36.6,
  "mfu_pct": 0.0176,
  "mbu_pct": 26.89,
  "ipw": 0.00112,
  "ipj": 0.000007
}

ฟิลด์	ชนิด	คำอธิบาย
`record_id`	str	Identifier ของ sample แบบไม่ซ้ำกัน
`benchmark`	str	ชื่อ benchmark
`model`	str	Identifier ของโมเดล
`backend`	str	Backend ที่ใช้
`model_answer`	str	ผลลัพธ์ดิบของโมเดล
`is_correct`	bool หรือ null	ผลการให้คะแนน (`null` หากไม่ได้ให้คะแนน)
`score`	float หรือ null	คะแนนตัวเลข (1.0 ถูก, 0.0 ผิด, `null` ไม่ได้ให้คะแนน)
`latency_seconds`	float	Latency ของ inference
`prompt_tokens`	int	Token input ที่ใช้ไป
`completion_tokens`	int	Token output ที่สร้างขึ้น
`cost_usd`	float	ต้นทุนโดยประมาณเป็น USD
`error`	str หรือ null	ข้อความ error หาก sample ล้มเหลว
`scoring_metadata`	dict	รายละเอียดเฉพาะ scorer (ตัวอักษรที่ดึงออกมา, ผลลัพธ์ judge ฯลฯ)
`ttft`	float	เวลาจนถึง token แรก เป็นวินาที (0.0 หากไม่มีข้อมูล)
`energy_joules`	float	พลังงาน GPU ที่ใช้ไปสำหรับ sample นี้ (จูล)
`power_watts`	float	กำลังไฟ GPU เฉลี่ยระหว่าง inference (วัตต์)
`gpu_utilization_pct`	float	เปอร์เซ็นต์การใช้งาน GPU เฉลี่ย
`throughput_tok_per_sec`	float	Throughput ของ output token (token/วินาที)
`mfu_pct`	float	เปอร์เซ็นต์ Model FLOPs Utilization (ต้องมีพารามิเตอร์ฮาร์ดแวร์ของโมเดล)
`mbu_pct`	float	เปอร์เซ็นต์ Memory Bandwidth Utilization (ต้องมีพารามิเตอร์ฮาร์ดแวร์ของโมเดล)
`ipw`	float	Intelligence Per Watt: `accuracy / power_watts` (0 หากผิดหรือไม่มีข้อมูลกำลังไฟ)
`ipj`	float	Intelligence Per Joule: `accuracy / energy_joules` (0 หากผิดหรือไม่มีข้อมูลพลังงาน)

ไฟล์ JSON สรุป¶

หลังจากทุก sample เสร็จสิ้น ไฟล์สรุปจะถูกเขียนควบคู่กับ JSONL ที่ {output_path}.summary.json:

results/supergpqa_qwen3-8b.jsonl.summary.json

{
  "benchmark": "supergpqa",
  "category": "reasoning",
  "backend": "jarvis-direct",
  "model": "qwen3:8b",
  "total_samples": 200,
  "scored_samples": 198,
  "correct": 143,
  "accuracy": 0.7222,
  "errors": 2,
  "mean_latency_seconds": 1.4821,
  "total_cost_usd": 0.0,
  "per_subject": {
    "chemistry": {"accuracy": 0.74, "total": 50.0, "scored": 50.0, "correct": 37.0},
    "mathematics": {"accuracy": 0.68, "total": 50.0, "scored": 49.0, "correct": 33.0}
  },
  "started_at": 1708789200.0,
  "ended_at": 1708789496.3,
  "accuracy_stats": {"mean": 0.72, "median": 1.0, "min": 0.0, "max": 1.0, "std": 0.45},
  "energy_stats": {"mean": 140792.95, "median": 135112.79, "min": 3926.17, "max": 1806568.12, "std": 156038.54},
  "power_stats": {"mean": 892.98, "median": 898.19, "min": 811.50, "max": 1104.90, "std": 42.65},
  "gpu_utilization_stats": {"mean": 47.41, "median": 47.45, "min": 42.38, "max": 56.23, "std": 2.72},
  "throughput_stats": {"mean": 36.55, "median": 37.22, "min": 26.22, "max": 45.03, "std": 5.00},
  "mfu_stats": {"mean": 0.0176, "median": 0.0179, "min": 0.0126, "max": 0.0216, "std": 0.0024},
  "mbu_stats": {"mean": 26.89, "median": 27.38, "min": 19.29, "max": 33.13, "std": 3.68},
  "ipw_stats": {"mean": 0.00113, "median": 0.00112, "min": 0.00100, "max": 0.00123, "std": 0.00005},
  "ipj_stats": {"mean": 0.00003, "median": 0.00001, "min": 0.000002, "max": 0.00021, "std": 0.00004},
  "total_energy_joules": 28158590.26
}

เมื่อตั้งค่า telemetry = true และ gpu_metrics = true ใน [run] ไฟล์ สรุปจะมี MetricStats (mean, median, min, max, std) สำหรับ telemetry metric ทุกตัว บวกกับ total_energy_joules สถิติเหล่านี้จะเป็น null เมื่อ ไม่มีค่าสำหรับ metric นั้น

รายละเอียด per_subject จัดกลุ่มผลลัพธ์ตามฟิลด์ subject หรือ category ของ ชุดข้อมูล ซึ่งแตกต่างกันไปตาม benchmark:

SuperGPQA: subfield, field หรือ discipline
GAIA: ระดับความยาก (level_1, level_2, level_3)
FRAMES: ประเภทการให้เหตุผล (เช่น temporal, intersection)
WildChat: เป็น "conversation" เสมอ

วิธีการให้คะแนน¶

แต่ละ benchmark ใช้ scorer ที่ปรับให้เข้ากับรูปแบบคำตอบของมัน

SuperGPQA: การดึงตัวเลือกปรนัยด้วย LLM¶

คำตอบของ SuperGPQA เป็นข้อความอิสระที่ต้องมีตัวอักษรตัวเลือกที่ถูกต้องตัวใด ตัวหนึ่ง (A, B, C, D, ...) Scorer ใช้ judge LLM เพื่อดึงตัวอักษรคำตอบสุดท้าย จากคำตอบของโมเดล แล้วเทียบกับตัวอักษรอ้างอิงด้วยการจับคู่สตริงแบบตรงเป๊ะ

Judge ได้รับโจทย์ต้นฉบับและคำตอบของโมเดล แล้วถูกขอให้คืนเพียงตัวอักษรเดียว วิธีนี้จัดการกับกรณีที่โมเดลให้เหตุผลอย่างละเอียดก่อนระบุคำตอบสุดท้าย

is_correct = extracted_letter == reference_letter

Metadata การให้คะแนนรวมถึง: reference_letter, candidate_letter และ valid_letters

GAIA: การจับคู่แบบตรงเป๊ะที่ Normalize แล้ว พร้อม LLM Fallback¶

คำตอบของ GAIA มักเป็นตัวเลข, วลีสั้นๆ หรือรายการคั่นด้วยคอมมา Scorer ทำการ normalize ก่อนเปรียบเทียบ:

ตัวเลข: ตัด $, %, , ออก แล้วแปลงเป็น float เพื่อเปรียบเทียบ
รายการ: แบ่งด้วย ,/; และเปรียบเทียบทีละสมาชิก (พร้อมตรวจจับ type ของแต่ละสมาชิก)
สตริง: แปลงเป็นตัวพิมพ์เล็ก, ตัดช่องว่างและเครื่องหมายวรรคตอน

หากการจับคู่แบบ normalize แล้วล้มเหลว Scorer จะ fallback ไปที่ judge LLM ซึ่งคืนคำตอบแบบมีโครงสร้างพร้อม extracted_final_answer, reasoning และ correct: yes/no LLM fallback จัดการกรณีอย่างหน่วยที่ต่างกัน, การใช้ถ้อยคำ ทางเลือก และคำตอบที่เทียบเท่ากันแต่รูปแบบต่างกัน

FRAMES: LLM-as-judge (ความถูกต้องเชิงข้อเท็จจริง)¶

FRAMES ใช้ judge LLM ที่ประเมินความเทียบเท่าเชิงความหมายระหว่างคำตอบของ โมเดลกับความจริงพื้นฐาน judge ได้รับคำถาม, ความจริงพื้นฐาน และคำตอบที่ คาดการณ์ไว้ แล้วตอบกลับด้วย verdict แบบมีโครงสร้าง:

extracted_final_answer: <extracted answer>
reasoning: <brief explanation>
correct: yes / no

Scorer parse บรรทัด correct: และ fallback ไปที่การมีอยู่ของ token TRUE/FALSE หากรูปแบบมีโครงสร้างขาดหายไป

WildChat: การเปรียบเทียบแบบ Pairwise ด้วย LLM¶

WildChat ไม่มีคำตอบ "ถูก" เดียว — มันวัดคุณภาพคำตอบของแชท Scorer รันการ เปรียบเทียบแบบ pairwise สองครั้ง:

Judge ประเมิน (คำตอบของโมเดลเป็น A, คำตอบอ้างอิงเป็น B) และคืน verdict token เช่น [[A>>B]], [[A>B]], [[A=B]], [[B>A]] หรือ [[B>>A]]
Judge ประเมินอีกครั้ง (คำตอบอ้างอิงเป็น A, คำตอบของโมเดลเป็น B) และคืน verdict อีกอัน

โมเดลถือว่าผ่าน (is_correct = True) หากชนะหรือเสมอในการเปรียบเทียบใด เปรียบเทียบหนึ่ง การเปรียบเทียบสองรอบช่วยลด bias เชิงตำแหน่งของ judge

Judge ใช้ rubric แบบหลายขั้นตอนที่แยกคำถามเชิงอัตวิสัย (ให้คะแนนตามความ ถูกต้อง, ประโยชน์, ความเกี่ยวข้อง, ความกระชับ และความสร้างสรรค์) จากคำถาม เชิงวัตถุวิสัย/เทคนิค (ให้คะแนนตามความถูกต้องอย่างเดียว)

ตีความความแม่นยำของ WildChat

คะแนนความแม่นยำ WildChat ที่ 0.50 หมายความว่าโมเดลเทียบเท่าหรือดีกว่าคำตอบอ้างอิงในครึ่งหนึ่งของการเปรียบเทียบ เนื่องจากคำตอบอ้างอิงมาจากชุดข้อมูลดั้งเดิม (ซึ่งอาจรวมคำตอบจากโมเดลที่มีความสามารถสูง) คะแนนที่สูงกว่า 0.50 บ่งชี้คุณภาพแชทที่แข็งแกร่งสำหรับชุด sample นั้น

การรันแบบขนาน¶

EvalRunner ประมวลผล sample พร้อมกันด้วย ThreadPoolExecutor ผลลัพธ์ถูก flush ลงไฟล์ JSONL แบบเพิ่มทีละส่วนทันทีที่แต่ละ sample เสร็จ ทำให้คุณตรวจ สอบผลลัพธ์บางส่วนระหว่างการรันที่ใช้เวลานานได้

# Use more workers for faster evaluation (if the engine supports concurrent requests)
uv run python -m openjarvis.evals run -b supergpqa -m qwen3:8b -w 8 -n 500

จำนวน Worker และภาระของ Engine

จำนวน worker ที่มากขึ้นเพิ่ม throughput ได้ก็ต่อเมื่อ inference engine จัดการคำขอพร้อมกันได้ Ollama ในเครื่องมักจัดการคำขอพร้อมกันได้ 1-2 คำขอ Cloud API (OpenAI, Anthropic) จัดการ concurrency ได้สูงกว่า ตั้งค่า -w ตาม parallelism จริงของ engine ของคุณ

ดูเพิ่มเติม¶

Benchmarks — วัด latency และ throughput ของ inference engine
Telemetry & Traces — บันทึกและวิเคราะห์ metric ของ inference จากการใช้งานจริง
Agents — ตั้งค่า OrchestratorAgent ที่ใช้โดย backend jarvis-agent
Tools — Tool ที่มีสำหรับ evaluation ที่ใช้เอเจนต์
Python SDK — การเข้าถึง inference และเอเจนต์ของ OpenJarvis เชิงโปรแกรม