SmolThinker

SmolLM2-1.7B-Instruct fine-tuned to emit its reasoning inside literal <think> ... </think> blocks, so chat UIs that render collapsible reasoning (Open WebUI, Ollama, LM Studio) display it as a proper thinking section rather than dumping it into the answer.

Reasoning is deliberately brief, around three short lines. The goal is reliable tag emission and visible working, not long deliberation.

Output format

<think>
I need to subtract 305 from 701.
Break 305 into 300 and 5.
701 - 300 = 401.
401 - 5 = 396.
</think>
701 - 305 = 396.

Usage

llama-cli -hf sbussiso/SmolThinker --jinja

The --jinja flag matters. It uses the embedded ChatML template, which is what the model was trained against.

For Ollama, ChatML turn format with both markers as stops:

PARAMETER stop "<|im_start|>"
PARAMETER stop "<|im_end|>"

Prompt format

ChatML, inherited from SmolLM2:

<|im_start|>system
You are a helpful AI assistant.<|im_end|>
<|im_start|>user
What is 47 + 68?<|im_end|>
<|im_start|>assistant

Works with or without a system prompt. Roughly 40% of training rows carried no system turn, so the template's injected default is in distribution; the rest used generic prompts naming no model.

Multi-turn works too. About 11% of training rows are 2 to 3 turn conversations where each follow-up depends on an earlier turn, so the model reads prior context rather than treating every message as fresh.

Training data

sbussiso/SmolThinker-Synthetic-Low-Reasoning, 2,593 rows.

Source	Rows
Templated single-turn, 26 task families	1,800
Templated multi-turn	200
Hand-written single-turn	514
Hand-written multi-turn	79

593 rows are authored individually rather than generated. 100% of assistant turns carry a think block, including greetings, so there is no example anywhere of answering without one.

Training configuration

LoRA adapter on a 16-bit base, trained with Unsloth Studio on a single NVIDIA L4.

method:            LoRA (16-bit base)
num_epochs:        2
max_seq_length:    2048
learning_rate:     2e-4
lr_scheduler:      linear
warmup_steps:      50
batch_size:        2
grad_accumulation: 4          # effective batch 8
optimizer:         adamw_8bit
weight_decay:      0.001
packing:           false
train_on_completions: true    # loss on assistant turns only
random_seed:       3407

lora_r:            16
lora_alpha:        16
lora_dropout:      0
target_modules:    q_proj k_proj v_proj o_proj gate_proj up_proj down_proj

614 steps, 762,325 tokens, 11m45s. Final training loss 0.639, final evaluation loss approximately 0.600, final gradient norm 0.414.

Why two epochs

Three runs were compared. At three epochs the model overfits: evaluation loss bottoms around step 591 and then climbs while training loss keeps falling.

Run	Config	Final train loss	Final eval loss	Overfit
1	3 epochs, rank 32	0.452	~0.645	yes, 0.050
2	3 epochs, rank 16	0.517	~0.621	yes, 0.030
3	2 epochs, rank 16	0.639	~0.600	none

Both three-epoch runs turned upward at the same step regardless of rank, so the cause was epoch count against a 2,453-row training split rather than adapter capacity. Run 3 is this release: higher training loss with the lowest evaluation loss, and a gradient norm that stays flat instead of climbing, which is what generalisation rather than memorisation looks like.

Design notes

The tags are ordinary text tokens, not special tokens. On the SmolLM2 tokenizer <think> is ['<', 'think', '>'] and </think> is ['</', 'think', '>'], tokenizing identically in every training row. This is deliberate: registering them via add_special_tokens() would give them untrained embeddings and, more importantly, skip_special_tokens=True on decode would strip them from the output, which is the usual reason a reasoning fine-tune produces correct reasoning with no visible tags. Qwen3 makes the same choice, adding them to the vocab but marking them special=False.

embedding_learning_rate was left unset for the same reason: the tags are ordinary tokens and the embedding layer does not need to move.

Evaluation

This release has not been evaluated yet. The numbers below are from the previous version, trained on v1 of the dataset, and are recorded here as the baseline this release is meant to beat rather than as a description of it.

Suite	Previous version
Format compliance, well-formed	70.0%
Format compliance, usable	90.0%
Held-out accuracy	88.3%

The previous version emitted a spurious trailing </think> on 20% of open-ended prompts and no think block at all on a further 5%, traced to every training answer being a single short clause. The dataset was revised to address that. Whether it worked is not yet measured.

This section will be replaced with measured results.

Limitations

Training data is largely templated and synthetic, so phrasing diversity in that portion is bounded and the task set is deliberately narrow. This teaches the shape of reasoning and reliable tag emission, not general reasoning ability. Expect arithmetic to degrade outside the ranges seen in training, and expect confident-looking traces on problems the model gets wrong.

The 593 hand-written rows are a finite set, so some memorisation of them is possible.

Not evaluated on GSM8K or any public benchmark, so there is no measurement of whether fine-tuning helped or harmed general math ability relative to the base model.

If you consume the output programmatically, strip any stray </think> after the first closing tag rather than assuming exactly one.

Built with Unsloth.