Datasets:

humanlaya-data-lab
/

OneMillion-Bench

	---
	license: apache-2.0
	task_categories:
	- question-answering
	- text-generation
	language:
	- en
	- zh
	tags:
	- economics_and_finance
	- healthcare_and_medicine
	- industry
	- law
	- natural_science
	pretty_name: $OneMillion-Bench
	size_categories:
	- n<1K
	---

	# $OneMillion-Bench

	A bilingual (Global/Chinese) realistic expert-level benchmark for evaluating language agents across 5 professional domains. The benchmark contains 400 entries with detailed, weighted rubric-based grading criteria designed for fine-grained evaluation of domain expertise, analytical reasoning, and instruction following.

	## Dataset Structure

	Each subdirectory is a Hugging Face subset (configuration), and all data is in the `test` split.

	```
	$OneMillion-Bench/
	├── economics_and_finance/
	│ └── test.json # 80 entries (40 EN + 40 CN, distinct questions)
	├── healthcare_and_medicine/
	│ └── test.json # 80 entries (40 matched EN-CN pairs)
	├── industry/
	│ └── test.json # 80 entries (40 matched EN-CN pairs)
	├── law/
	│ └── test.json # 80 entries (40 EN + 40 CN, distinct questions)
	├── natural_science/
	│ └── test.json # 80 entries (40 matched EN-CN pairs)
	└── README.md
	```

	\| Subset \| Split \| Entries \|
	\|---\|---\|---\|
	\| `economics_and_finance` \| `test` \| 80 \|
	\| `healthcare_and_medicine` \| `test` \| 80 \|
	\| `industry` \| `test` \| 80 \|
	\| `law` \| `test` \| 80 \|
	\| `natural_science` \| `test` \| 80 \|

	## Domains & Coverage

	\| Domain \| Categories \| Example Subcategories \| Bilingual Mode \|
	\|---\|---\|---\|---\|
	\| Economics & Finance \| Investing, FinTech, Banking, Insurance, M&A \| Equities, VC/PE, Cryptocurrency, Commodities \| Separate questions per language \|
	\| Healthcare & Medicine \| Clinical Medicine, Basic Medicine, Pharma & Biotech \| Hepatobiliary Surgery, Oncology, Nephrology, Dentistry \| Matched translation pairs \|
	\| Industry \| Telecommunications, ML, Architecture, Semiconductors \| Backend Dev, Chemical Engineering, Chip Design \| Matched translation pairs \|
	\| Law \| Civil, Criminal, International, Corporate, IP, Labor \| Contract Disputes, Criminal Defense, Copyright, M&A \| Separate questions per language \|
	\| Natural Science \| Chemistry, Biology, Physics, Mathematics \| Organic Chemistry, Condensed Matter, Molecular Biology \| Matched translation pairs \|

	## Entry Schema

	Each entry is a JSON object with 7 fields:

	```jsonc
	{
	"id": "uuid-string", // globally unique identifier
	"case_id": 1, // links bilingual pairs (in matched-pair domains)
	"language": "en", // "en" or "cn" (50/50 split in every file)
	"system_prompt": "", // reserved (empty across all entries)
	"question": "...", // expert-level evaluation prompt
	"tags": {
	"topics": [ // 3-level taxonomy
	"Domain", // e.g. "Economics and Finance"
	"Category", // e.g. "Investing"
	"Subcategory" // e.g. "Equities"
	],
	"time_sensitivity": {
	"time_sensitivity": "Time-agnostic", // or "Weakly/Strongly time-sensitive"
	"year_month": "NA", // "YYYY-MM" when time-sensitive
	"day": "NA" // "DD" when applicable
	}
	},
	"rubrics": [ // weighted grading criteria (11-37 per entry)
	{
	"rubric_number": 1,
	"rubric_detail": "...", // specific grading criterion
	"rubric_weight": 5, // positive = reward, negative = penalty
	"rubric_tag": "..." // category (see below)
	}
	]
	}
	```

	### Rubric Labels

	\| Label \| Role \| Typical Weight \|
	\|---\|---\|---\|
	\| Factual Information \| Tests factual accuracy \| +3 to +5 \|
	\| Analytical Reasoning \| Assesses depth of analysis \| +3 to +5 \|
	\| Structure and Formatting \| Evaluates output organization \| -2 to -4 (penalty) \|
	\| Instructions Following \| Checks compliance with task constraints \| mixed \|

	## Quick Start

	```python
	from datasets import load_dataset

	# Load a subset from Hugging Face (test split)
	ds = load_dataset("humanlaya-data-lab/OneMillion-Bench", "natural_science", split="test")

	# Filter English entries
	en_entries = ds.filter(lambda x: x["language"] == "en")

	# Iterate with rubrics
	for entry in en_entries.select(range(1)):
	print(f"Topic: {' > '.join(entry['tags']['topics'])}")
	print(f"Question: {entry['question'][:200]}...")
	print(f"Rubrics ({len(entry['rubrics'])}):")
	for r in entry["rubrics"][:3]:
	print(f" [{r['rubric_weight']:+d}] {r['rubric_tag']}: {r['rubric_detail'][:80]}...")
	```

	Example output:

	```
	Topic: Natural Sciences > Chemistry > Organic Chemistry
	Question: You are an expert in organic chemistry. A graduate student is researching ...
	Rubrics (18):
	[+5] Factual Information: Correctly identifies the primary reaction mechanism ...
	[+4] Analytical Reasoning: Provides a coherent comparison of thermodynamic vs ...
	[-3] Structure and Formatting: Response lacks clear section headings or logica...
	```

	## Evaluation

	### Scoring a single response

	Each rubric carries a signed weight: positive weights are points earned when the criterion is met, negative weights are penalties applied when violated. Sum the weights of all satisfied rubrics and normalize against the maximum possible (positive-only) score:

	```python
	def score_entry(response: str, rubrics: list, judge_fn) -> dict:
	"""
	judge_fn(response, rubric_detail) -> bool
	Returns True if the response satisfies the rubric criterion.
	"""
	max_possible = sum(r["rubric_weight"] for r in rubrics if r["rubric_weight"] > 0)
	earned = sum(r["rubric_weight"] for r in rubrics if judge_fn(response, r["rubric_detail"]))
	return {"earned": earned, "max_possible": max_possible, "pct": earned / max_possible if max_possible else 0}
	```

	### End-to-end rubric-based eval

	Below is a complete example that loads the benchmark from Hugging Face, queries a model, and scores every entry with an LLM-as-judge:

	```python
	from datasets import load_dataset
	from openai import OpenAI

	SUBSETS = [
	"economics_and_finance",
	"healthcare_and_medicine",
	"industry",
	"law",
	"natural_science",
	]

	client = OpenAI() # or any OpenAI-compatible client

	def get_model_response(question: str, system_prompt: str = "") -> str:
	messages = []
	if system_prompt:
	messages.append({"role": "system", "content": system_prompt})
	messages.append({"role": "user", "content": question})
	return client.chat.completions.create(
	model="gpt-4o", messages=messages
	).choices[0].message.content

	def judge_rubric(response: str, rubric_detail: str) -> bool:
	verdict = client.chat.completions.create(
	model="gpt-4o",
	messages=[
	{"role": "system", "content": (
	"You are a strict rubric grader. Determine whether the response "
	"satisfies the following criterion. Reply ONLY 'YES' or 'NO'."
	)},
	{"role": "user", "content": (
	f"### Criterion\n{rubric_detail}\n\n### Response\n{response}"
	)},
	],
	temperature=0,
	).choices[0].message.content
	return verdict.strip().upper().startswith("YES")

	def score_entry(response: str, rubrics: list) -> dict:
	max_possible = sum(r["rubric_weight"] for r in rubrics if r["rubric_weight"] > 0)
	results = []
	for r in rubrics:
	met = judge_rubric(response, r["rubric_detail"])
	results.append({**r, "met": met})
	earned = sum(r["rubric_weight"] for r in results if r["met"])
	return {"earned": earned, "max_possible": max_possible, "pct": earned / max_possible if max_possible else 0, "details": results}

	# --- Run ---
	for subset in SUBSETS:
	ds = load_dataset("humanlaya-data-lab/OneMillion-Bench", subset, split="test")
	for entry in ds:
	response = get_model_response(entry["question"], entry["system_prompt"])
	result = score_entry(response, entry["rubrics"])
	print(f"[{subset}] {entry['id']} score={result['earned']}/{result['max_possible']} ({result['pct']:.1%})")
	```

	## License

	Apache 2.0