anasnassar/llm-query-complexity-benchmark

LLM Query Complexity Benchmark

Benchmark dataset for evaluating LLM query routing systems. Contains 6,912 labeled queries across 6 domains and 3 complexity classes, designed to train and evaluate complexity classifiers that route queries to the most cost-effective inference tier.

Built for the STREAM project (Smart Tiered Routing Engine for AI Models), which routes queries automatically between local, HPC, and cloud inference tiers.

Dataset Structure

Fields

Field	Type	Description
id	int	Unique query identifier (1–6912)
text	string	The user query
domain	string	Subject domain (see below)
complexity	string	Complexity class: LOW, MEDIUM, or HIGH

Complexity Classes

Complexity is defined by reasoning depth, not question format. The same format ("Is X?", "What is X?") appears in all three classes.

Class	Definition	Example
LOW	Single retrievable fact or trivial computation. Answer statable in one sentence, no reasoning chain required.	"What is the capital of France?"
MEDIUM	Apply an established procedure or assemble 2–4 concepts. The reasoning path is standard (textbook-level).	"Explain how quicksort works and analyze its time complexity."
HIGH	Construct a novel reasoning path, formal derivation, or expert judgment. No standard procedure — the path must be built.	"Is P equal to NP? Present the current state of evidence."

Domains

Domain	Description
general_knowledge	Geography, history, culture, world affairs
science	Biology, chemistry, physics, astronomy
mathematics	Arithmetic, algebra, calculus, proofs
humanities	Literature, philosophy, ethics, linguistics
computer_science	Algorithms, systems, networks, AI/ML
research_computing	HPC, scientific workflows, LLM deployment, Globus, vLLM, SLURM

Size

Split	Queries
Full dataset	6,912
Per domain	1,152
Per domain × complexity cell	384

Loading the Dataset

from datasets import load_dataset

ds = load_dataset("anasnassar/llm-query-complexity-benchmark", data_files="stream_routing_benchmark.jsonl")
print(ds["train"][0])
# {'id': 1, 'text': 'What is the capital of Japan?', 'domain': 'general_knowledge', 'complexity': 'LOW'}

Or load the full JSON (includes metadata and generation provenance):

import json, requests
url = "https://huggingface.co/datasets/anasnassar/llm-query-complexity-benchmark/resolve/main/stream_routing_benchmark.json"
data = requests.get(url).json()
queries = data["queries"]

Generation Method

All queries were generated by Claude Sonnet 4.6 with extended thinking enabled (budget_tokens=10,000), using a reasoning-depth rubric that explicitly decouples complexity from surface format. Cross-model consistency was verified with GPT-4o-mini (Cohen's κ = 0.819, near-perfect agreement, 88% label agreement).

This is LLM-supervised fine-tuning: Claude generates hard labels; a smaller classifier (ModernBERT-base) learns from them. The resulting classifier runs at ~15ms per query with no API dependency.

Format Decoupling

A key design constraint: format is not the complexity signal. Early dataset versions showed 91% of "What is X?" queries labeled LOW — a format-proxy bias that would cause classifiers to route by question format rather than reasoning depth. The current dataset enforces balanced format distribution across all three complexity classes.

Format	LOW	MEDIUM	HIGH
"What is X?"	~38%	~31%	~31%
Yes/No / True-False	~51%	~15%	~34%

Training and Evaluation

This dataset is designed to train and rigorously evaluate query complexity classifiers. Three evaluation strategies are provided in the STREAM codebase to avoid inflated numbers:

Strategy	Description
Random split	70/15/15 split. Fast baseline; may be inflated due to LLM-generated near-duplicates.
Domain-held-out 6-fold CV	Train on 5 domains, test on 6th. Measures cross-domain generalization. Reported in paper.
Similarity-aware split	Semantic deduplication before splitting (cosine sim > 0.90 grouped). Conservative estimate.

A fourth evaluation on real-world queries (LMSYS Chatbot Arena) is performed separately using build_realworld_testset.py in the STREAM codebase to test out-of-distribution generalization.

The domain-held-out CV and real-world numbers are the primary reported metrics. The random-split result (~99%) is inflated and should not be cited as a standalone accuracy figure.

Associated Model

The fine-tuned ModernBERT-base classifier trained on this dataset is available at: anasnassar/llm-query-complexity-classifier

Citation

@inproceedings{nassar2026stream,
  title     = {{STREAM}: Multi-Tier {LLM} Inference Middleware with Dual-Channel {HPC} Token Streaming},
  author    = {Nassar, Anas and Mohr, Steve and Apanasevich, Leonard and Sharma, Himanshu},
  booktitle = {Practice and Experience in Advanced Research Computing (PEARC '26)},
  year      = {2026}
}

How to Use in Research

Training a new classifier on this dataset:

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments

ds = load_dataset("anasnassar/llm-query-complexity-benchmark", data_files="stream_routing_benchmark.jsonl")
# Rename 'complexity' to 'label' and encode:
label2id = {"LOW": 0, "MEDIUM": 1, "HIGH": 2}
ds = ds.map(lambda x: {"label": label2id[x["complexity"]]})

Reproducing the STREAM paper results:

git clone https://github.com/uicacer/STREAM
pip install transformers torch datasets scikit-learn accelerate sentence-transformers
python scripts/eval/train_modernbert.py --eval-mode domain-holdout
python scripts/eval/build_realworld_testset.py
python scripts/eval/eval_on_realworld.py

Extending to other classifiers: The dataset is model-agnostic. Any text classifier (DistilBERT, DeBERTa, SetFit, etc.) can be trained by replacing MODEL_NAME in train_modernbert.py or loading the JSONL directly.

License

Apache 2.0