yuqing-wu/sodl-sft-data

SFT data by difficulty: Qwen3-8B solutions to DeepScaleR problems

Supervised fine-tuning data for Qwen3-1.7B-Base at three difficulty levels. Each problem has one correct solution written by Qwen3-8B (thinking mode off). Training sets are the same size at every level (954 problems), so the levels differ in difficulty, not in amount of data.

The problems, their difficulty levels and their splits come from yuqing-wu/sodl-difficulty-bins. A course project (NYU, Science of Deep Learning, Fall 2026) on how training-problem difficulty affects SFT and RL. Code: the project's GitHub repository, step 2 (src/generate_teacher_solutions).

Files

File	Rows	What it is
easy_train.parquet, medium_train.parquet, hard_train.parquet	954 each	SFT training data
easy_val.parquet, medium_val.parquet, hard_val.parquet	99, 91, 84	SFT validation data
responses.parquet	8,259	every attempt the teacher made, correct or not
settings.json		the teacher's sampling settings

from datasets import load_dataset
hard = load_dataset("yuqing-wu/sodl-sft-data", "hard")   # hard["train"], hard["validation"]
attempts = load_dataset("yuqing-wu/sodl-sft-data", "responses", split="train")

{level}_{split}.parquet (the SFT data)

Column	Type	Meaning
id	str	the problem, e.g. dsr_06014; joins with problems.parquet in the difficulty-bins dataset (problem text, reference answer, base-model score)
bin	str	easy, medium or hard
split	str	train or val
prompt	str	the full prompt in Qwen chat format, ending with `<
response	str	the teacher's solution: the SFT target. It doesn't include the closing `<
n_tokens	int	solution length in tokens

The prompt is the same one the student model is scored and evaluated with:

<|im_start|>user
{problem}
Please reason step by step, and put your final answer within \boxed{}.<|im_end|>
<|im_start|>assistant

For TRL's SFTTrainer, rename response to completion and it trains on the solution only.

Median solution length: easy 431 tokens, medium 880, hard 1,318.

responses.parquet (every attempt)

Column	Type	Meaning
id	str	the problem
sample	int	attempt number, 0-7
response	str	the teacher's full answer
answer	str	the reference answer
n_tokens	int	length in tokens
truncated	bool	cut off at 4,096 tokens before finishing
correct	bool	final \boxed{} answer matches the reference (math-verify)

How it was made

1. Which problems: every train and val problem from the difficulty-bins dataset (1,200 train and 100 val per level). Test and never-solved problems got no solutions.
2. Rejection sampling: attempt 0 for every problem. Then each further attempt only for problems with no usable answer yet, up to 8 attempts. Usable means correct, not truncated, and no <think> block.
3. One solution per problem: the earliest usable attempt. Attempts are independent draws, so this is the same as picking a correct one at random.
4. Equal training sets: every level's train set is cut at random (seed 0) to the smallest level's count, 954. Validation sets are kept whole.

Teacher sampling: Qwen/Qwen3-8B, thinking mode off, temperature 0.7, top-p 0.8, top-k 20 (the Qwen3 model card's non-thinking settings), at most 4,096 tokens, seed + attempt number as the seed.

Problems with a usable solution:

level	train	val
easy	1,184 of 1,200	99 of 100
medium	1,099 of 1,200	91 of 100
hard	954 of 1,200	84 of 100

Share of attempts that were correct: 72% at attempt 0, falling to 6-9% by attempts 5-7, since only the problems the teacher keeps failing are left.

Caveats

• Hard training problems are easier than hard test problems. Hard problems the teacher couldn't solve in 8 attempts (about 20%) aren't in the training set, but the test set has all of them.
• A correct answer doesn't mean correct reasoning. Some solutions reach the right answer by luck or with flawed steps, more often on hard problems. They haven't been checked by hand.
• Hard solutions are longer, so with the same number of problems, SFT on hard sees about 2.7 times as many tokens as SFT on easy.

References

• Qwen Team (2025). Qwen3 Technical Report. arXiv:2505.09388.
• Luo et al. (2025). DeepScaleR: Surpassing O1-Preview with a 1.5B Model by Scaling RL.
• Tong et al. (2024). DART-Math: Difficulty-Aware Rejection Tuning for Mathematical Problem-Solving. arXiv:2407.13690.
• Yuan et al. (2023). Scaling Relationship on Learning Mathematical Reasoning with Large Language Models. arXiv:2308.01825.