Datasets:

logic65
/

whittle-distill-qwen3.8-27b

pretty_name: Whittle distillation set (Qwen3.8-27B reasoning traces + top-20 logprobs)
license: other
language:
  - en
task_categories:
  - text-generation
tags:
  - knowledge-distillation
  - teacher-logprobs
  - reasoning
  - chain-of-thought
  - tool-use
  - agentic
  - qwen
size_categories:
  - 10K<n<100K
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*.parquet

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}
}