logic65/whittle-distill-qwen3.8-27b

Whittle distillation set: Qwen3.8-27B traces with top-20 logprobs

☕ Support this work

Whittle is built by one person on a grocery budget and rented GPU hours, and this dataset was generated and released from that budget. If it is useful to you, or you want to see the work continue: ko-fi.com/davida81328. Every hour of GPU time goes into the next release, and every trace, table and log lands in these repos.

About 25,000 complete, quality-filtered answers from Qwen3.8-27B (thinking on), each with the teacher's top-20 log-probabilities at every answer token. It is built for logit-level knowledge distillation: a student can match the teacher's full per-token distribution, not just its sampled text. We use it to train Whittle-Qwen-3.8-35B-A3B.

• 25,178 rows, 78.0M tokens, of which 25.4M are answer tokens with top-20 logprobs (about 507M token/logprob pairs).
• Covers maths, grade-school maths, code review and explanation, open chat, strict JSON extraction, long-document reading, and agentic tool use. Agent episodes were executed in a sandbox and kept only when hidden unit tests passed.
• Every trace is complete: it stopped by itself, closed its thinking block and ended on <|im_end|>. It is correct wherever it could be graded.

from datasets import load_dataset
ds = load_dataset("logic65/whittle-distill-qwen3.8-27b", split="train")
row = ds[0]
row["kind"], row["prompt"][:200], row["reasoning"][:200], row["answer"][:200]
# logit-level targets: for answer position j (predicting input_ids[answer_start + j])
#   candidates = row["topk_ids"][j]; logprobs = row["topk_logprobs"][j]   (20 each, highest first; renormalise before use)

Status

Published 28 Sep 2026. It is the Phase-2 training data of Whittle-Qwen-3.8-35B-A3B (Phase 2 ran 28–30 Sep 2026). Per that model's card, its root (Phase-2 step 32010) trained once on the 22,950 rows that fit its 4,096-token window; the 1,470 longctx rows were not used yet.

Files

• data/train-00000-of-00051.parquet … data/train-00050-of-00051.parquet: the whole set as 51 Parquet shards, read by the default config as its single train split (see the front matter).

---

Columns

Column	Type	Meaning
id	string	stable id (kind-#####; agent episode turns get /turnN)
kind	string	math, gsm, code, chat, json, longctx, agent1 (single tool step), agentx (turn of an executed agent episode)
source	string	where the prompt came from (see Sources)
prompt	string	the full prompt as rendered with the Whittle / Qwen chat template (system, tools, earlier turns), ending with `<
response	string	the teacher's full raw answer: reasoning, </think>, visible answer or tool calls, `<
reasoning	string	the thinking part only
answer	string	the visible answer only (empty when the turn is only a tool call)
tool_calls	string (JSON)	parsed tool calls [{"name": ..., "arguments": {...}}], if any
input_ids	list[int32]	exact token ids of prompt + response
answer_start	int32	index in input_ids where the response begins
topk_ids	list[list[int32]]	[n_answer_tokens][20]: teacher's top-20 candidate token ids at each answer position, highest first
topk_logprobs	list[list[float32]]	[n_answer_tokens][20]: their raw log-probabilities (before temperature / top-p)
n_prompt_tokens, n_answer_tokens	int32	lengths

topk_*[j] is the teacher's distribution predicting input_ids[answer_start + j]. The token actually sampled is always among the 20; we checked every row. Tokenizer: logic65/Whittle-Qwen-3.8-35B-A3B (the Qwen3.8 tokenizer, 248,320 tokens, <|im_end|> = 248046).

---

Composition

Kind	Rows	Median answer tokens	Source	Content
math	4,013	671	MATH train, levels 2–5	step-by-step solutions, graded \boxed{} answer
gsm	1,443	264	GSM8K train	word problems, graded final number
code	4,487	2,160	open-source files	review, explain, write tests, edge cases, refactor
chat	1,334	1,283	oasst2	open-ended questions (mostly English)
json	2,000	144	synthetic	strict schema extraction, exact typed fields
longctx	1,470	197	open-source files	find one function in a 24k–139k-character file (prompts up to ~42k tokens)
agent1	2,409	145	synthetic	one next step in a Claude-Code-style tool session
agentx	8,022 turns (1,495 episodes)	81 per turn	synthetic, executed	multi-turn coding episodes with real Read / Write / Edit / Bash results

The GSM8K test split is not included, nor are any held-out evaluation problems.

---

How it was made

• Teacher: Qwen/Qwen3.8-27B-FP8 (official block-128 FP8 build) on vLLM 0.30.
  • Checked against the bf16 teacher on 69,922 answer positions: 98.1% top-1 agreement, total variation 0.016 over the top-20, 98.2% shared probability mass.
• Sampling: thinking on, temperature 0.6, top-p 0.95, top-k 20.
  • Reasoning effort was the teacher template's maximum (xhigh) for all kinds except code. Code used the default effort with focused instructions, because open-ended code requests at xhigh ran past 16k tokens without finishing.
  • Maximum answer length: 16,384 tokens (8,192 for grade-school maths, JSON and agent turns).
• Context distillation. The teacher answered with its xhigh "reason carefully" instruction. The prompt column is rendered without it, so a student trained on these rows learns careful reasoning by default.
• Filtering: 19,500 prompts went in and 18,651 (96%) were kept. A trace is kept only if all of these hold:
  1. it finished with its own end-of-turn token;
  2. the think block is closed;
  3. no tool markup leaked into the answer;
  4. it is not degenerate (minimum lengths);
  5. every sampled token appears in its own top-20;
  6. the answer is correct:
     • maths: normalised \boxed{} comparison;
     • GSM: final number;
     • JSON: exact fields with strict types;
     • long-context: exact file and parameters;
     • single agent steps: the right action (e.g. fix the implementation, never the test);
     • agent episodes: hidden unit tests pass and the original tests still pass.
• Agent episodes: the teacher's Read / Write / Edit / Bash calls ran against a real sandbox, with Claude-Code-style tool results and a command allowlist, for up to 16 rounds. Every assistant turn of a passing episode is its own row. In half of the rows, earlier turns keep their reasoning; in the other half it is stripped, as many clients do.
• Privacy scan: every row was scanned for credentials, tokens and private network addresses before release. No rows needed removal.

---

Sources and licences

Source	Kinds	Licence
MATH (Hendrycks et al.), train split	math	MIT
GSM8K, train split	gsm	MIT
OpenAssistant oasst2 (first turns)	chat	Apache-2.0
Permissively licensed open-source code (licence-checked)	code, longctx	each file's own permissive licence
Synthetic (generated by our scripts)	json, agent1, agentx	released with this dataset
Qwen3.8-27B outputs	all answers and logprobs	Apache-2.0 (Qwen model licence)

The sources are mixed, so the dataset is marked license: other. Check each source's terms for your use.

---

Limitations

• FP8 teacher: 98.1% top-1 agreement with bf16, not 100%.
• Top-20 only: the long tail of the distribution is not stored.
• Grader strictness: a few correct answers were filtered out, for example (e)-style letter answers. Maths or chat answers that hit the 16k cap were dropped, so the very longest reasoning is slightly under-represented.
• Synthetic agent tasks are small single-file Python projects. They teach tool discipline, not large-codebase navigation.
• Prompt rendering: prompts use the Qwen chat template with thinking on. If your student uses a different template, re-render from reasoning / answer / tool_calls. The logprobs belong to the teacher's tokenisation of response.

Citation

@misc{whittle-distill-2026,
  title  = {Whittle distillation set: Qwen3.8-27B reasoning traces with top-20 logprobs},
  author = {logic65},
  year   = {2026},
  url    = {https://huggingface.co/datasets/logic65/whittle-distill-qwen3.8-27b}
}