islam-kamel/MBPP-Thinking-Gate-1k

MBPP Thinking-Gate SFT Dataset

This package contains two related assets:

1. Ready 1,000-row MBPP-style dataset (all.jsonl, train.jsonl, validation.jsonl). It is synthetic and designed to test/train autonomous routing between <DIRECT> and <THINK>.
2. Official-MBPP builder (build_from_official_mbpp.py). Run this to create the production dataset from the official Google Research MBPP source.

Why two response modes?

The training target starts with one of two routing tokens:

• <DIRECT> — simple transformation / lookup / short implementation. The answer goes directly to code.
• <THINK> — algorithmic work where planning, state, an invariant, recursion, dynamic programming, search, or non-trivial control flow materially helps. The target contains a compact structured plan, then code.

The prompt does not tell the model which mode to choose. The target teaches the mode decision.

For <THINK> examples, the dataset stores a structured program plan (sequence / branch / loop-or-recursion / invariant), not a private hidden chain-of-thought transcript.

Ready dataset

• 1,000 rows total
• 900 train / 100 validation
• 500 <THINK> / 500 <DIRECT>
• train: 450 / 450
• validation: 50 / 50
• validation uses whole held-out problem families
• every generated solution/test pair is executed during dataset creation

Main schema

id
split
source
source_family
thinking_mode
gate_token
difficulty
instruction
tests[]
reasoning_summary
code
messages[]     # ChatML-style role/content records
approx_tokens
recommended_max_seq_length
provenance

Long-context >1900-token version

Because the requested dataset also targets examples above ~1900 tokens, the package includes:

train_long_1900.jsonl
validation_long_1900.jsonl
all_long_1900.jsonl
stats_long_1900.json

These rows are not padded with meaningless prose. Each target task is preceded by alternating <DIRECT> and <THINK> solved routing demonstrations from training families until the tokenizer-independent estimate is at least 1950 tokens.

This follows the few-shot demonstration idea behind CoT prompting while keeping <THINK> content as compact structured program plans.

Important: approx_tokens >= 1950 is an estimate. Use validate_tokens.py with your exact model tokenizer for a hard 1900-token guarantee.

Build the production version from official MBPP

python build_from_official_mbpp.py --output-dir official_dataset

The builder downloads the official Google Research mbpp.jsonl and uses only task IDs 601–974, which are the official training split. It never trains on the official MBPP prompt, validation, or test tasks.

It creates:

official_dataset/train.jsonl        # 900
official_dataset/validation.jsonl   # 100
official_dataset/all.jsonl          # 1000
official_dataset/stats.json

The split is done by original source_task_id before augmentation, so the same MBPP problem cannot leak across train and validation.

Token limit: 1900

Token counts depend on the exact tokenizer. approx_tokens is only a rough estimate.

For an exact check with the target model tokenizer:

pip install transformers
python validate_tokens.py official_dataset/all.jsonl \
  --tokenizer YOUR_MODEL_OR_TOKENIZER_ID \
  --limit 1900

For training, a max_seq_length around 2048 gives room around a 1900-token content target. Do not lengthen short MBPP samples with fake reasoning merely to hit a token count; that teaches verbosity rather than useful deliberation.

Recommended SFT behavior

At inference, keep the same routing contract in the system prompt. The model should emit the gate token itself:

<DIRECT>
...code...

or

<THINK>
Structured plan:
...
...code...

You can later strip the gate token in your serving layer, or map <THINK> to a dedicated reasoning path.

Evaluation rule

Keep MBPP task IDs 11–510 untouched as the official test set. Do not include them in SFT data if you want a meaningful post-training MBPP score.

Attribution

Official MBPP source:

• Google Research, Mostly Basic Python Problems (MBPP)
• Released with Program Synthesis with Large Language Models (Austin et al.)
• Source dataset is commonly distributed under CC-BY-4.0; retain attribution when redistributing a derivative.

Research basis:

• Wei et al., Chain-of-Thought Prompting Elicits Reasoning in Large Language Models, arXiv:2201.11903.
• Li et al., Structured Chain-of-Thought Prompting for Code Generation, arXiv:2305.06599.
• The supplied Gamma document was listed by the requester as a reference; the build does not depend on fetching it.