README.md

metadata

license: other
license_name: mixed-open
license_link: LICENSE.md
language:
  - multilingual
pretty_name: Qwen3.8-27B Quantization Challenge
size_categories:
  - 10M<n<100M
tags:
  - quantization
  - calibration
  - kl-divergence
  - gptq
  - hessian
  - long-context
  - agentic
configs:
  - config_name: calib
    data_files: corpus/calib.jsonl
  - config_name: public
    data_files: corpus/public.jsonl

Qwen3.8-27B Quantization Challenge

Quantize Qwen/Qwen3.8-27B and stay as close to it as possible. Entries are scored by the KL divergence of their next-token distribution from the BF16 model's, teacher-forced over a private 10M-token corpus. That corpus is drawn the same way as the two published here:

	calib	public	private (not released)
tokens	10,259,331	10,287,924	10,324,055
documents	4,789	4,760	4,748
256K-token agentic traces	8	8	8

• calib is for calibration: GPTQ, AWQ, imatrix, QAT, anything. It comes with the BF16 model's Hessian of every linear's input over the whole corpus (257 files) and its golden distributions.
• public is for scoring yourself. Its golden distributions use exactly the format and settings that score the private corpus.
• private has the same mix, sampled with a different seed stream and disjoint from both. Its sha256 is in corpus/manifest.json, so the scoring corpus is fixed before any entry exists.

How the references were made

• Model: Qwen3.8-27B in BF16, every weight as released.
• Engine: radiance on 2x AMD Radeon AI PRO R9700 (tensor parallel 2).
• KV cache: BF16. Tensor-parallel wire: exact (BF16 partial sums, never an 8-bit wire).
• Teacher forcing: every document goes through prefill once, with the prefix cache and speculation off. Each position's full 248,320-token distribution is computed in f32.
• The official FP8 checkpoint was scored with the same settings, run from its own weights byte for byte.

Corpus

Each line of corpus/<split>.jsonl is {"source", "category", "kind", "tokens", "prompt"}. prompt is the exact text the model reads: plain text, or a conversation already rendered with Qwen3.8's chat template (kind: chat). tokens counts the Qwen3.8 tokenizer's tokens, with no BOS. Every token is scored from the first.

Tokens by category:

category	calib	public	private
long-agentic	1,980,045	1,974,467	1,992,019
agentic	1,089,833	1,032,356	1,064,965
code	1,007,333	1,004,962	1,008,026
web	900,144	900,135	901,666
reasoning	714,092	710,288	712,599
chat	704,539	708,451	700,808
multilingual	656,900	650,380	669,740
science	604,894	621,240	617,742
books	559,476	554,954	560,684
math	502,916	502,530	504,829
long	421,934	510,956	475,772
tools	410,310	412,341	410,778
encyclopedic	301,326	301,085	300,719
qa	300,166	301,388	300,175
legal	105,423	102,391	103,533

Documents are capped at 8K-100K tokens depending on the source (the long category runs to 100K). They are deduplicated by content hash across all three splits and dealt round-robin, so each split has the same mix. Chat, reasoning, tool-calling and agentic sources keep their assistant turns, including thinking blocks.

The 256K-token agentic traces

Each split holds 8 agentic coding sessions of about 250K tokens, generated for this challenge by Qwen3.8-27B itself (the official FP8 checkpoint, its default sampling settings). Each session works on a real open-source repository pinned to a commit, inside an offline sandbox. It has bash, read_file, write_file and edit_file tools and works through a queue of engineering tasks: orientation, running and fixing the tests, code review, edge-case and property tests, a small feature, a refactor, a benchmark, error handling, documentation, typing, git archaeology and a final self-review. It runs until it reaches 245K tokens. The whole session is one document, rendered with the chat template, tool definitions included: what the model read before its last turn, plus that turn. Each split uses different repositories.

split	repository	commit	tokens	turns
calib	attrs	ee66e72748	246,898	157
calib	click	2247b35ea1	245,120	172
calib	cobra	adbc881390	245,199	125
calib	express	1c6f1b0fe4	253,163	134
calib	lua	8cb93bada5	248,066	142
calib	requests	611c6162cb	245,667	166
calib	rich	9d8f9a372c	250,158	169
calib	ripgrep	6892bc2b7e	245,774	126
public	cjson	6d9f2443ab	247,353	164
public	flask	d086db856b	245,423	177
public	gin	0f09c3a9b4	246,768	114
public	httpx	b5addb64f0	246,459	176
public	more-itertools	4aeb4338ae	248,470	188
public	redis	c039dd784c	248,830	185
public	serde-json	8c535a260c	245,866	149
public	tqdm	9cf5a12b1f	245,298	116

Sources

dataset	revision	licence
HuggingFaceFW/fineweb-edu	87f09149ef	ODC-By 1.0
epfml/FineWeb2-HQ	c0c06e94fd	ODC-By 1.0
wikimedia/wikipedia	b04c8d1ceb	CC BY-SA 3.0 / GFDL
common-pile/wikimedia_filtered	0641bb84bd	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/arxiv_papers_filtered	033cf7f53f	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/peS2o_filtered	297747513b	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/pubmed_filtered	c156f0569a	openly licensed, each record's licence in its metadata (Common Pile v0.1)
HuggingFaceTB/finemath	e92b25a616	ODC-By 1.0
common-pile/libretexts_filtered	70388bca52	openly licensed, each record's licence in its metadata (Common Pile v0.1)
emozilla/pg19	c021754c8e	public-domain books (PG-19)
common-pile/project_gutenberg_filtered	3cdf6879c8	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/doab_filtered	defb24ca72	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/caselaw_access_project_filtered	50e1961a5e	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/stackexchange_filtered	c0ac737383	openly licensed, each record's licence in its metadata (Common Pile v0.1)
common-pile/stackv2_edu_filtered	c354dbe884	openly licensed, each record's licence in its metadata (Common Pile v0.1)
bigcode/the-stack-smol-xl	e782ebf35c	permissively licensed source files (each file's own licence)
allenai/WildChat-4.8M	c827c6df8f	ODC-By 1.0
HuggingFaceTB/smoltalk2	fc6cc2103c	see the source's card
open-thoughts/OpenThoughts3-1.2M	61bcf9d4eb	Apache 2.0
NousResearch/hermes-function-calling-v1	dae3e1d28c	Apache 2.0
glaiveai/glaive-function-calling-v2	e7f4b64560	Apache 2.0
nvidia/When2Call	0582f7749d	CC BY 4.0
nebius/SWE-rebench-openhands-trajectories	35455389ab	CC BY 4.0
nvidia/Nemotron-SWE-v1	0fe17a965b	CC BY 4.0
SWE-bench/SWE-smith-trajectories	08e109b4a5	MIT
agent traces (this dataset)	generated	Apache 2.0 (the model's output); repository content keeps its own licence

Filtering per source: language and quality filters where the source offers them, a prose check on book and web text, and an article filter on Wikimedia. Each source's scanned, accepted and skipped counts are in corpus/manifest.json under datasets.sources.

Golden distributions: golden/<split>/ (42.2 GB + -)

The BF16 model's next-token distribution at every scored position, stored sparse: the 512 most likely tokens exactly, plus the mass of the rest.

file	layout
kld.json	format (radiance-kld-top-1), n_vocab, top (512), rows, and docs: one {source, tokens, score_from, row0} per document
tokens.i32	every document's tokens, concatenated, int32
top.bin	[rows, 512] of {int32 id, float32 log p}, most likely first
rows.f32	[rows, 3] float32: the reference's NLL of the true next token, its entropy (nats), and the tail mass 1 - sum(exp(top lp)) summed from the full row

Document d has tokens - 1 - score_from rows, starting at row0. Row row0 + j is the distribution after token score_from + j, predicting token score_from + j + 1.

The score

Per position, the candidate's distribution q is coarsened onto the reference's 513 cells (its 512 tokens and one tail cell holding the rest of q's mass), and

KL(p || q) = sum_i p_i (log p_i - log q_i) over the 513 cells.

This is a lower bound on the full-vocabulary KL. At 512 tokens the tail mass is small: its median per position is below 1e-6. Mean KL over all positions ranks the leaderboard. The leaderboard also shows the median, p99 and p99.9 KL, top-1 agreement (argmax match), the perplexity ratio, and the mean KL over the 256K-token traces alone.

Every position is scored, user and tool turns of a conversation included. There the BF16 model is often confidently wrong (it expects the turn to end), so the per-position KL has a heavy tail: a candidate that moves a near-certain wrong guess pays for it. llama.cpp running the Q8_0 GGUF reproduces these reference distributions (median KL 0.0004, top-1 agreement 98.4%), so the tail is the model's, not the engine's.

Hessians: hessians/<split>/ (50.4 GB + -)

H = sum over tokens of x x^T for the whole input x of every linear in the text model. That is the matrix GPTQ / OBQ / LDLQ start from, accumulated over every token of the corpus. One safetensors file per input. Linears that read the same input share one file: q/k/v (or the delta net's in-projections) share the layer input, and gate/up share the post-attention input.

• hessian_upper: f32 [k (k + 1) / 2], the upper triangle packed row by row (row i's entries j = i .. k-1 after row i-1's).
• metadata: k, rows (tokens summed), linears (the checkpoint tensors that read this input).
• H is the raw sum: divide by rows for the second moment. Under tensor parallelism the inputs split by column (o_proj, out_proj, down_proj) were gathered to their full width first, so every file holds the whole matrix, cross terms included.

import numpy as np, safetensors.numpy as st
t = st.load_file("hessians/calib/model.language_model.layers.3.mlp.down_proj.input.safetensors")["hessian_upper"]
k = int((np.sqrt(8 * t.size + 1) - 1) / 2)
H = np.zeros((k, k), np.float32); H[np.triu_indices(k)] = t; H = H + np.triu(H, 1).T

Scoring an entry yourself

• GGUF (llama.cpp): tools/llama_kld.cpp is a single-file scorer that builds against llama.cpp (see its header). It reads golden/public/ and writes the same report and score as the leaderboard, with a BF16 KV cache and flash attention.
• radiance: radiance --model ENTRY.rad --tp 2 --kv-cache-dtype bf16 --tp-wire exact --max-model-len 262144 --kld-ref golden/public --kld-out report.json.
• Anything else: compute your model's log-softmax at every row's position, coarsen onto the row's 512 ids plus the tail, and average. tools/score.py is a reference implementation in numpy; its score_rows takes a document a slice of positions at a time, since a 256K-token document's full logits fit nowhere.

Every engine must reproduce the corpus tokens exactly: feed tokens.i32, never re-tokenize prompt.

Leaderboard (private corpus)

The initial entries are scored on a fixed subset of the private corpus: every 8th document and 2 of its 256K-token traces. The official FP8 is also scored on the whole private corpus, which shows how closely the subset tracks it. All entries were measured with a BF16 KV cache. Sizes and bits per weight count the text model only (embeddings, 64 layers, lm_head), so formats that ship the vision tower or the MTP head are not charged for them.

(being scored)