add phase05.md

results/phase05.md

@@ -0,0 +1,213 @@
+# Phase 05 — post-training a 12.6M-parameter model
+
+Mid-training, supervised fine-tuning, and a 50-prompt evaluation scored on three
+axes separately. **The headline is the dissociation:** the model learns the chat
+protocol well (72%) and learns to answer badly (38%), and those two numbers moving
+independently is the finding.
+
+## Exit criteria
+
+| Criterion | Result | |
+|---|---|---|
+| Mid-training complete, forgetting trade measured on both validation sets | −2.5222 nats conversational, **+0.5544** TinyStories | ✅ |
+| SFT masking test passes | gated before any GPU time, on this run's own tokenizer and data | ✅ |
+| SFT complete | 465 steps, 3 epochs, 2,488 examples | ✅ |
+| 50-prompt evaluation, three rates reported separately | 72% / 72% / 38% | ✅ |
+| Base vs SFT on identical prompts | all three models, byte-identical prompts | ✅ |
+| `results/phase05.md` states plainly what the model can and cannot do | this document | ✅ |
+
+## The three rates
+
+50 instructions across 8 categories, temperature 0.8, top-p 0.9, fixed seed, at
+most 240 new tokens. Every model saw byte-identical prompts.
+
+| model | format | stopped at `<\|end\|>` | **responsive** | leaked a role token | mean new tokens |
+|---|---|---|---|---|---|
+| base (Phase 03, step 6000) | 0% | 0% | 14% | 0% | 240 |
+| mid-trained (step 500) | 0% | 0% | 16% | 0% | 240 |
+| **SFT (step 507)** | **72%** | **72%** | **38%** | 0% | 128 |
+
+`format` requires a well-formed assistant turn: content, then `<|end|>`, and no
+other role token anywhere. `responsive` is **hand-scored** — see the rubric below.
+
+**This is the dissociation the phase predicts, and it is clean.** Format
+compliance goes 0% → 0% → 72%: nothing but SFT produces the protocol, and it
+produces it in three epochs over 2,488 examples. Responsiveness goes 14% → 16% →
+38%: it more than doubles, but it starts from a floor that is not zero and ends
+well below format. Instruction-following *format* and instruction-following
+*capability* are separable, and only the second is still missing at this scale.
+
+**Zero role-token leakage across all 150 generations.** The masking held. That was
+the failure the phase doc singles out — a model that writes its own user turns —
+and it is the one thing here that went right first time.
+
+### Why the base model scores 14% rather than 0% on responsiveness
+
+Because it is *continuing text*, and the prompt is in its context. Asked
+`What do bees make?` it emits `"I smell honey," said the bee.` — on topic, and
+entirely accidental. That is worth stating rather than rounding to zero: it sets
+the floor any responsiveness number has to beat, and a phase that reported
+"0% → 38%" would be claiming 14 points it did not earn.
+
+## Mid-training, and the forgetting trade
+
+20,137,800 tokens of filtered SmolTalk, 500 steps at 49,152 tokens/step (1.22
+epochs), constant learning rate at Phase 03's `min_lr` of 4e-5 with no new warmup.
+Both validation sets scored on byte-identically seeded batches, before and after.
+
+| held-out set | before | after | delta |
+|---|---|---|---|
+| conversational | 5.4059 | 2.8836 | **−2.5222 nats** |
+| TinyStories | 1.5732 | 2.1276 | **+0.5544 nats** |
+
+Conversational loss falls by 2.5 nats; TinyStories loss rises by 0.55. Against
+Phase 04's measured seed noise floor of 0.0146 nats, that degradation is **38× the
+floor** — this is not drift, it is the model trading one distribution for another.
+**Catastrophic forgetting, measured, in six minutes of T4 time.**
+
+The `before` TinyStories loss of 1.5732 sits within 0.002 of Phase 03's reported
+1.5763, which is an independent check that the right checkpoint was loaded.
+
+In bits per byte, each split converted with **its own** tokens-per-byte (see the
+correction below): TinyStories **0.5540 → 0.7493**, conversational **2.3780 →
+1.2685**. The conversational figure stays far above the TinyStories one because
+the corpus is well out of domain — a tokenizer learned on TinyStories spends
+**0.3049 tokens per byte** on SmolTalk against **0.2441** on TinyStories, **24.9%
+more** of the context window for the same text. That ratio is the out-of-domain
+cost, stated as a number rather than as an adjective.
+
+**The template tokens never appear in this corpus.** Conversations are rendered as
+plain speaker-prefixed prose (`User: …` / `Assistant: …`). That was deliberate, and
+it is what makes the 72% attributable to SFT alone: after mid-training the model
+has met dialogue but not the protocol. You can see it working in the mid-trained
+model's outputs, which are full of `Assistant:` and `User:` in plain text and
+contain no `<|end|>` at all.
+
+## SFT
+
+2,488 short instruction pairs, 3 epochs, 465 steps, LR 3e-5 cosine to 3e-6 with 20
+warmup steps, loss on assistant content only.
+
+| | |
+|---|---|
+| Validation loss (response tokens only) | 4.0842 → **1.9476** (−2.1366) |
+| Wall clock | 73 seconds |
+| Peak memory | 1,894 MB of 15,637 |
+
+That loss is not comparable with any pretraining loss in this project: different
+token population, different denominator. It says the model learned something. It
+does not say the model follows instructions — which is the entire reason the
+evaluation is separate.
+
+## Two measurement errors found in this phase
+
+Both are the same species: the instrument was wrong in a way that looked like a
+result.
+
+### The 80-token budget was measuring itself
+
+The first evaluation reported **36%** format compliance. Then `stopped` (36%) and
+`ran_to_limit` (64%) were noticed to sum to exactly 100% — meaning *every*
+generation that failed to emit `<|end|>` had simply been truncated at the budget.
+The measurement could not distinguish a model that will not stop from a budget that
+never let it finish.
+
+Measuring the trained response lengths gave a defensible budget rather than merely
+a bigger one: p50 **9** tokens, p90 104, p99 155, max 248, and 21% exceed 80. At
+240 tokens — about 1.5× p99 — format compliance is **72%**, and `ran_to_limit`
+falls to 28%. Half the reported failure was the instrument.
+
+What remains is real: 28% still run past 240 tokens while only ~1% of trained
+responses are that long, so the model generates well beyond the length distribution
+it was taught. That is now measurable instead of confounded.
+
+### Bits per byte was per-token loss in disguise
+
+Found here, but it originated in Phase 03 and it **reversed a Phase 04 finding**.
+`bits_per_byte(loss, n_tokens, n_bytes)` was called everywhere with the tokens the
+evaluation had *scored* against the byte count of the *whole* held-out split. For
+the vocabulary ablation both are identical across arms, so BPB was per-token loss
+times one shared constant — preserving exactly the artifact it exists to remove.
+
+| vocab | mean loss | tokens/byte | reported bpb | **correct bpb** |
+|---|---|---|---|---|
+| 2,048 | 1.6804 | 0.2777 | 0.0775 | **0.6732** |
+| 8,192 | 1.8112 | 0.2441 | 0.0835 | **0.6378** |
+| 32,768 | 1.8099 | 0.2418 | 0.0835 | **0.6314** |
+
+Phase 04 reported *"vocab 2048 better by 0.0060 bits/byte"*. Corrected, **vocab
+2,048 is the worst of the three** — 0.0354 bpb behind 8,192 and 0.0418 behind
+32,768, at 3.8× and 4.5× the largest seed spread. And 8,192 versus 32,768, reported
+as tied, is 0.0064 apart against a 0.0092 spread: **not measured**. Details and the
+full post-mortem are in FAILURES.md 017; Phase 04's tables on the Hub have been
+regenerated from the stored losses, with no GPU time required.
+
+## What this model can and cannot do
+
+**Can:** produce a syntactically correct chat turn and stop, 72% of the time.
+Answer a handful of very simple questions — *"What colour is the sky?"*, *"Is the
+sun hot or cold?"* → `The sun is warm and hot.`, *"Describe what a park looks
+like"* → `The park has a slide, swings, and a sandbox.`, *"What is your name?"* →
+`My name is Sarah.` Hold a conversational register.
+
+**Cannot:** arithmetic of any kind (0/5). Follow a constraint — *"Answer with only
+yes or no"*, *"Say hello in one word"*, *"Name three animals"* all fail. Recall a
+fact — *"What is the capital city of France?"* → `The cap screen of Aance is a
+beautiful town`. Avoid degeneration: *"What season comes after summer?"* →
+`The season season season is one of the season season, and the season season is a
+basil.`
+
+Of the 19 responsive generations, roughly 9 would be accepted by a reader and about
+4 are factually right. **A 12.6M-parameter model trained on 295M tokens of
+children's stories can be taught the shape of an answer and cannot be taught the
+answer.** This is what the Phase 04 scaling curve predicted and what Phase 09 will
+measure against the benchmark floor.
+
+## How responsiveness was scored
+
+Not automatable at this quality level: a heuristic for "is this answer relevant" is
+itself a language model, and using one would report the heuristic's opinion as a
+measurement. So all 150 generations were read.
+
+**Criterion, applied identically to every model:** the content addresses the
+instruction *and* reads as an attempt to answer it. Not correctness — a wrong
+answer that engages with the question counts; on-topic text that never attempts an
+answer does not. So `The week is 7500.` counts for *"How many days are in a week?"*
+and a formula salad does not.
+
+Scored by Claude (the assistant that built this phase), by index, recorded in
+`results/phase05_scores.jsonl` alongside the exact generation each score belongs
+to. A score is dropped automatically if the text it was given for ever changes, and
+`--score-only` recomputes the rates from the stored generations without a GPU, so
+re-scoring by a second reader costs nothing. **Until a generation is scored the
+column reads `unscored`, never 0** — zero is a finding, absent is an absence.
+
+## Artifacts
+
+- `Dhevenddra/slm-lab-chat-15m` — mid-trained checkpoints, `midtrain_results.json`
+- `Dhevenddra/slm-lab-sft-15m` — SFT checkpoints, `sft_results.json`,
+  `generations.jsonl`
+- `Dhevenddra/slm-lab-data` — `chat_8192_v2_*` corpus, `sft_v2_*.jsonl`,
+  `results/phase05_eval.json`, `results/phase05_generations.md`,
+  `results/phase05_scores.jsonl`, `results/PHASE05_COMPLETE`
+
+Config hashes: mid-training `d61efcdb4a2f`, SFT `8a091c5b81a7`. Total cost about
+1.4 T4-hours across two runs, roughly 2 compute units.
+
+## What the re-run bought
+
+The first run mid-trained on **0.6M** tokens because one over-strict filter — a
+600-character per-turn limit meant for SFT — was also applied to the packed
+mid-training stream, where long turns cost nothing. `cap_steps_to_corpus` correctly
+refused to loop it and mid-training got 19 steps.
+
+| | run A (0.6M tokens) | run B (20.1M tokens) |
+|---|---|---|
+| conversational delta | −1.7632 | **−2.5222** |
+| TinyStories delta | +0.0739 | **+0.5544** |
+| SFT val loss | 2.3591 | **1.9476** |
+| format compliance | 36% at 80 tokens | **72%** at 240 |
+
+Run A's forgetting was only 5× the noise floor; run B's is 38×. Both are real, and
+the pair is the more useful result: it shows how much of "catastrophic" forgetting
+is a function of how much shifted data you actually train on.