ScalingIntelligence/picojoule-benchmark-results

Picojoule benchmark results

Model × quantization-scheme × benchmark accuracy and per-query energy telemetry collected by the Picojoule model-to-silicon compiler pipeline. This dataset is the quantization accept/reject evidence for Picojoule's chip-design work: for each target model we burn to transistor ROM, we need to show that our chosen quantization scheme preserves the model's behavior across realistic workloads (MCQ knowledge benchmarks today; agentic coding / tool-use / long-horizon benchmarks as they come online).

Source repo: jonsaadfalcon/picojoule @ 68cb567 This dataset is regenerated from that repo via scripts/push_benchmark_results_to_hf.py.

How the data is generated

Each row in this dataset corresponds to one query in one benchmark run, or in summary.parquet to one aggregate over such a run. The full generation pipeline is:

1. Serve the model at a given precision scheme via vLLM on an OpenAI-compatible endpoint:

   # FP16 baseline
   CUDA_VISIBLE_DEVICES=6 python -m vllm.entrypoints.openai.api_server \
       --model google/gemma-4-31b-it --port 8000 --dtype bfloat16 \
       --max-model-len 8192 --trust-remote-code
   
   # FP8 (AutoFP8 dynamic per-tensor, H100 FP8 tensor cores)
   CUDA_VISIBLE_DEVICES=7 python -m vllm.entrypoints.openai.api_server \
       --model google/gemma-4-31b-it --port 8001 --dtype bfloat16 \
       --quantization fp8 --max-model-len 8192 --trust-remote-code
   
   # INT4/INT8 via bitsandbytes (--enforce-eager; vLLM 0.19 torch.compile
   # doesn't handle Gemma 4's heterogeneous attention cadence under bnb)
   

2. Run the benchmark via intelligence-per-watt's CLI, pointing at the pre-started server. For MCQ (no tools):

   ipw profile --client openai-server \
       --client-base-url http://localhost:8000/v1 --client-param api_key=EMPTY \
       --model google/gemma-4-31b-it --dataset mmlu-pro \
       --max-queries 500 --warmup-queries 3 \
       --eval-model gpt-5-mini \
       --output-dir results/quantization/gemma4_31b_ipw_fp16_mmlu_pro
   

   For agentic (tool-use, multi-turn — GAIA, Tau-Bench, TerminalBench, SWE-Bench Verified):

   ipw bench --agent openhands --client openai-server \
       --vllm-url http://localhost:8000/v1 --api-key EMPTY \
       --model google/gemma-4-31b-it --dataset gaia --limit 500 \
       --per-action --output results/quantization/gemma4_31b_ipw_fp16_gaia
   

3. Judge: gpt-5-mini via the OpenAI API, invoked by IPW for open-generation tasks (GSM8K-style, GAIA, Tau-Bench, SWE-Bench). MCQ tasks use deterministic letter extraction.

4. Per-query telemetry: IPW's Rust energy monitor samples GPU power at 50 ms cadence via NVML, integrates to joules per query, and records tokens, latencies, prefill/decode phase breakdowns.

5. Harvest: scripts/push_benchmark_results_to_hf.py walks results/quantization/* in the source repo, reads IPW's per-run summary.json + analysis/accuracy.json + per-query .arrow dataset, normalizes to the schema below, writes parquets, uploads.

Earlier runs used EleutherAI's lm-evaluation-harness with bare-prompt MCQ (no chat template). Those rows are retained here tagged harness = "lm_eval" for provenance, but the harness = "ipw" rows are the ones we cite — they use proper chat-templated prompting which is the correct path for an instruction-tuned model.

Configurations and splits

Two loadable configs:

1. summary — aggregate metrics per run

One row per (harness, model, scheme, benchmark) combination.

Column	Type	Description
harness	str	ipw or lm_eval
model	str	HuggingFace model ID
scheme	str	fp16, fp8, int8, int4
benchmark	str	canonical benchmark name — mmlu_pro, supergpqa, gaia, tau_bench, terminalbench, swebench, or older mmlu/hellaswag/arc_easy/arc_challenge/gsm8k
accuracy	float	0–1
n_queries	int	number scored (null for lm_eval where query count isn't in results.json)
correct, incorrect, failed	int	counts (IPW only)
total_energy_j	float	total joules across all queries (IPW only)
avg_per_query_energy_j	float	IPW only
avg_power_w	float	mean GPU power during eval (IPW only)
intelligence_per_joule, intelligence_per_watt	float	IPW's derived metrics
generated_at	ISO-8601 str	run timestamp
source_dir	str	directory name in the source repo for traceback

2. per_query — per-sample traces

One row per query per run. Only IPW runs produce per-query data (lm-eval sample JSONLs are gitignored in the source repo because they balloon to hundreds of MB per sweep).

Partitioned by benchmark: per_query/mmlu_pro.parquet, per_query/supergpqa.parquet, per_query/gaia.parquet, etc.

Column	Type	Description
harness, model, scheme, benchmark	str	same as summary
query_idx	int	index within this run
question	str	prompt / problem text
expected	str	ground truth answer
generated	str	model's response
is_correct	bool
subject	str?	benchmark subcategory (MMLU-Pro subject, SuperGPQA field, etc.)
energy_j	float?	total GPU energy for this query
power_gpu_w_avg	float?	mean GPU power during this query
latency_s	float?	wall-clock query time
tokens_in, tokens_out	int?
source_dir	str	source run directory

Current coverage (35 runs)

benchmark	harness	scheme	accuracy	n_queries
arc_challenge	lm_eval	fp16	0.2184	-
arc_challenge	lm_eval	int4	0.2193	-
arc_easy	lm_eval	fp16	0.3123	-
arc_easy	lm_eval	int4	0.3085	-
gaia	ipw	fp16	0.1030	165
gaia	ipw	fp16	0.0364	165
gaia	ipw	fp8	0.1394	165
gaia	ipw	fp8	0.0182	165
gsm8k	lm_eval	fp16	0.7051	-
gsm8k	lm_eval	int4	0.7225	-
hellaswag	lm_eval	fp16	0.3255	-
hellaswag	lm_eval	int4	0.3164	-
mmlu	lm_eval	fp16	0.4680	-
mmlu	lm_eval	int4	0.4549	-
mmlu	lm_eval	int8	0.4689	-
mmlu_humanities	lm_eval	fp16	0.4806	-
mmlu_humanities	lm_eval	int4	0.4699	-
mmlu_humanities	lm_eval	int8	0.4799	-
mmlu_other	lm_eval	fp16	0.4326	-
mmlu_other	lm_eval	int4	0.4229	-
mmlu_other	lm_eval	int8	0.4358	-
mmlu_pro	ipw	fp16	0.8880	500
mmlu_pro	ipw	fp16	0.7621	500
mmlu_pro	ipw	fp8	0.8840	500
mmlu_pro	ipw	fp8	0.7335	500
mmlu_social_sciences	lm_eval	fp16	0.5096	-
mmlu_social_sciences	lm_eval	int4	0.4842	-
mmlu_social_sciences	lm_eval	int8	0.5125	-
mmlu_stem	lm_eval	fp16	0.4434	-
mmlu_stem	lm_eval	int4	0.4355	-
mmlu_stem	lm_eval	int8	0.4424	-
supergpqa	ipw	fp16	0.7039	500
supergpqa	ipw	fp16	0.4706	500
supergpqa	ipw	fp8	0.6917	500
supergpqa	ipw	fp8	0.4597	500

This table grows as more runs complete. Wave 1 (MCQ: MMLU-Pro + SuperGPQA) is underway; Wave 2 (agentic: GAIA, Tau-Bench, TerminalBench 2.1 Hard, SWE-Bench Verified via OpenHands) follows once Wave 1 is done.

Loading

Aggregate summary

from datasets import load_dataset

summary = load_dataset(
    "ScalingIntelligence/picojoule-benchmark-results",
    "summary",
    split="train",
)
print(summary.to_pandas().head())

Per-query data for one benchmark

mmlu_pro = load_dataset(
    "ScalingIntelligence/picojoule-benchmark-results",
    data_files="per_query/mmlu_pro.parquet",
    split="train",
)

# Filter to just FP8 rows
fp8 = mmlu_pro.filter(lambda r: r["scheme"] == "fp8")

Per-query data across all benchmarks

per_query = load_dataset(
    "ScalingIntelligence/picojoule-benchmark-results",
    data_files="per_query/*.parquet",
    split="train",
)

Direct parquet read (faster, supports predicate pushdown)

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download

path = hf_hub_download(
    repo_id="ScalingIntelligence/picojoule-benchmark-results",
    filename="per_query/mmlu_pro.parquet",
    repo_type="dataset",
)
table = pq.read_table(path, filters=[("scheme", "=", "fp8")])
df = table.to_pandas()

Acceptance-bar analysis (the primary paper query)

Picojoule's plan requires each quantized scheme to retain ≥ 96% of FP16 accuracy on the primary benchmark metric. Compute the ratios from summary:

import pandas as pd
from datasets import load_dataset

df = load_dataset(
    "ScalingIntelligence/picojoule-benchmark-results",
    "summary", split="train",
).to_pandas()

# Use IPW rows (correct prompting protocol) when available
ipw = df[df.harness == "ipw"].copy()

base = ipw[ipw.scheme == "fp16"].set_index(["model","benchmark"])["accuracy"]
ipw["fp16_accuracy"] = ipw.set_index(["model","benchmark"]).index.map(base)
ipw["ratio"] = ipw["accuracy"] / ipw["fp16_accuracy"]
ipw["pass_96pct"] = ipw["ratio"] >= 0.96

print(ipw[["model","scheme","benchmark","accuracy","ratio","pass_96pct"]]
      .sort_values(["benchmark","scheme"])
      .to_string(index=False))

Reproducibility

All runs are reproducible from the source repo at the commit listed above. The recipe is captured in docs/QUANT_BENCHMARK_RUNBOOK.md.

For bit-exact reproducibility of generation outputs, the serving path uses seed=0, greedy decoding, and IPW's warmup_queries=3 burn-in. Minor variability in GPU energy readings (±1–2 %) is inherent to NVML sampling and cannot be fully eliminated.

License

• Harness code + pipeline scripts: Apache-2.0 (from the Picojoule repo).
• Model responses in generated / per_query rows are derivative works of their respective base models. Llama-family rows are subject to the Llama 3.1 Community License. Gemma rows are subject to Gemma's terms of use. MMLU-Pro / SuperGPQA / GAIA / SWE-Bench Verified / Tau-Bench / TerminalBench questions carry their upstream licenses (see each dataset's HF page).