Mac LLM/VLM Post-training Testing
November 18, 2026 · Apple M5 MacBook Pro, 16 GB · MLX · 9 of 9 runs finished · 0.8B, GSM8K
Code on GitHub · report.html source · Companion: math-story post · inference repo · inference post
Our companion post measured how far a 16 GB MacBook goes at running Qwen3.5. This one asks the harder question: how far does it go at training it?
Running a model streams weights through the chip once per token. Training does that and more: it keeps activations for the backward pass, gradients, optimizer state, and for reinforcement learning (RL) it also has to generate whole batches of answers before it can learn from them. On a laptop where macOS alone takes about 6.5 GB of the 16, each of those costs matters.
We set out to compare four post-training methods on the same task: SFT (imitate reference solutions), and three critic-free RL methods, GRPO, RLOO and GSPO (learn from the model's own answers, rewarded when correct). All on the Qwen3.5-0.8B, with LoRA adapters and (for the RL methods) with full fine-tuning; we also tried two gentler SFT recipes after the first one failed. The task is GSM8K grade-school math: 500 training questions for 5 epochs, scored on 100 held-out test questions, with one line per (model, method, adapter) in Weights & Biases and every rollout kept.
All planned runs have finished. A good deal of what broke on the way turned out to be the most informative part, so this post tells that story as well as the final scores. The larger models (2B, 4B) were planned but not trained: see the memory chapter for why we expect them not to fit as configured. A companion post repeats the experiment on a dataset with much shorter answers.
All RL methods here are critic-free and have no reference-model KL penalty, so only one model sits in memory. Each RL step uses 4 prompts x 4 rollouts at temperature 1.0 and up to 640 new tokens. The learning rates are 2e-5 (SFT, LoRA), 1e-5 (SFT, full), 2e-6 (RL, LoRA) and 1e-6 (RL, full). All runs use the full 500 samples x 5 epochs on the 0.8B. The gentler SFT variants use 5e-6 for 2 epochs ("SFT gentle") and rejection-sampled, self-generated correct answers ("SFT self-distilled"). Full-fine-tuning SFT was not completed.
Qwen3.5 is not a plain transformer. Most of its layers are "gated delta" linear-attention layers, and MLX ships a fast Metal kernel for them that has no backward pass.
The first training step crashed with Primitive::vjp not implemented for CustomKernel. The library's pure-operations fallback works, but it loops over tokens in Python: 50 seconds for one step on two short sequences, which would have made the whole project impossible. We wrote a chunk-parallel, matmul-based version of the recurrence (pt/gdn.py) that autograd can differentiate. It went through two bugs on the way (a numerically unstable matrix inverse that produced garbage on real, correlated keys, replaced by forward substitution) and now matches the reference: 4% relative error in the gradients on the real model, the same loss at step 1 (1.09 on both paths), and about 1 second per SFT step.
On the 0.8B, LoRA SFT took accuracy from 54% to 22% after five epochs (it was 17% after the first and peaked at 29% in between), while the training loss fell to about 0.01. The model memorised the 500 reference solutions and lost the stronger, more verbose reasoning style it already had.
Our first attempt, at a learning rate of 1e-4, was far worse: accuracy collapsed from 54% to 4% with degenerate repeated output. LoRA with scale 20 is very sensitive; 2e-5 trains stably but still lowers accuracy. A reasonable reading: Qwen3.5 already reasons well in its own style, and 500 terse human-written solutions over five epochs pull it toward a style it cannot execute as well. That is a finding, not a bug: it is exactly the situation RL is supposed to improve on, because RL trains on the model's own outputs.
Both of our early GRPO failures were the same disease: the model found a way to get reward without being correct, or was pushed too hard by noise.
The first GRPO run collapsed from 54% to 1% accuracy within the first epoch. The reason is in the reward. We capped generation at 400 tokens, and this model is verbose: 44% of rollouts were truncated and scored 0. A short, wrong answer in the right format earned a 0.1 format bonus, which beat 0. Within 50 steps the policy had learned that skipping the reasoning pays: completion length fell from 288 to about 35 tokens and every group looked the same. Fix: reward correctness only (the format flag is logged but not rewarded) and allow 640 tokens.
The second attempt no longer collapsed in length, but reward and format rate drifted down steadily (0.42 to 0.1 and 0.89 to 0.39 over 25 steps) at a learning rate of 5e-6. With only 16 rollouts per step, and about half the groups carrying no signal, small noisy updates accumulate quickly under LoRA scale 20. At 2e-6 the run is stable. We verified the gradient code against the reference before blaming the hyperparameters.
discarded) and under runs_discarded/.Accuracy is one number. The answers themselves change too: their format, length and style, and some of those changes are side effects nobody asked for.
The clearest example is the answer format. Our prompt ends with "End with a final line: 'The answer is: <number>'", and the untrained model follows it almost always. During RL we stopped rewarding that format (after it had been exploited, chapter 4). The result: in the sampled training rollouts the share ending with "The answer is: N" fell from about 0.8 to about 0.13 over the first two to three epochs, and on the greedy test answers it fell from 86% to 56% by epoch 2 (so far, in the GRPO run), while accuracy did not suffer, because the evaluator reads the last number in the answer. The model silently stopped following a formatting instruction that nothing rewarded any more. That is harmless for this benchmark and could be a real problem in a pipeline that parses the format. GRPO also gradually dropped LaTeX (80% of answers at epoch 0, 36% at epoch 2) while keeping its markdown headers.
SFT changes the style far more. After SFT the model stops writing the long, markdown-heavy, LaTeX-heavy step-by-step answers it started with (95% and 80% of answers) and writes terse plain-text solutions like the GSM8K references: mean length falls from 347 to about 90 tokens and markdown and LaTeX disappear entirely. It follows the "The answer is:" format more reliably (99-100%), but gets fewer answers right, and in the first epochs it sometimes degenerates into a repeating arithmetic loop that runs to the token cap (see the example below). So the SFT story is as much about style as about accuracy: the model traded its own, stronger way of reasoning for a shorter one it executes worse.
Test question 14; the end of the answer at epoch 0 (untrained) and at epoch 5.
…porary}) = 55\%$$
So, 55% of the total students are in hip-hop dance.
**Step 4: Calculate the percentage of the entire students.**
We know the total number of students is 20.
$$55\% \text{ of } 20 = 0.55 \times 20 = 11$$
So, 11 students are in hip-hop dance.
**Step 5: Calculate the percentage of the entire students.**
$$\frac{11}{20} = 0.55$$
Converting to a percentage:
$$0.55 \times 100 = 55\%$$
The answer is: 55…x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x 16 = 10 - 10 x 25% x 16 = 10 - 25% x 16 = 10 - 4 x 25% x
Test question 85; the end of the answer at epoch 0 (untrained) and at epoch 2.
…ock."
Therefore, the number of blocks per vacation is 1.
$$ \text{Blocks per vacation} = 1 $$
3. **Calculate the total number of blocks:**
To find the total number of blocks, multiply the number of vacations by the number of blocks per vacation.
$$ \text{Total blocks} = \text{Number of vacations} \times \text{Blocks per vacation} $$
$$ \text{Total blocks} = 11 \times 1 = 11 $$
The answer is: 11…since he was 23 years old, so he has been on 11 vacations. He has been on vacation since he was 23 years old, so he has been on 11 vacations. He has been on vacation since he was 23 years old, so he has been on 11 vacations. He has been on vacation since he was 23 years old, so he has been on 11 vacations. He has been on vacation since he was 23 years old, so he has been on 11 vacations. He has been on vacation since
Test question 8; the end of the answer at epoch 0 (untrained) and at epoch 2.
…s} - 2.5 \text{ hours} = 1.5 \text{ hours}$
* **Speed:** 80 mph
* **Distance:** $1.5 \text{ hours} \times 80 \text{ mph} = 120 \text{ miles}$
**Step 4: Calculate the total distance**
* Total Distance = (Distance from Step 1) + (Distance from Step 2) + (Distance from Step 3)
* Total Distance = $0 \text{ miles} + 15 \text{ miles} + 120 \text{ miles}$
* Total Distance = $135 \text{ miles}$
The answer is: 135…ies to get home in 4 hours but spends the first 2 hours in standstill traffic."
* Does he drive the *remaining* 4 hours in the fourth segment?
* Time spent driving so far: 3 hours + 0.5 hours = 3.5 hours.
* Total time available: 4 hours.
* Remaining time to drive: $4 \text{ hours} - 3.5 \text{ hours} = 0.5 \text{ hours}$.
* So, the fourth segment is indeed 0.5 hours at 80 mphTest question 4; the end of the answer at epoch 0 (untrained) and at epoch 5.
…{ cups} $$
**Step 3: Calculate the total feed needed for the final meal.**
To find the total amount needed for the final meal, we add the morning feed and the afternoon feed.
$$ \text{Total Feed} = \text{Morning Feed} + \text{Afternoon Feed} $$
$$ \text{Total Feed} = 15 + 25 $$
$$ \text{Total Feed} = 40 \text{ cups} $$
Wendi needs to give her chickens 40 cups of feed in the final meal of the day.
The answer is: 40… her chickens in the **final meal** of the day?" Let's re-parse the timeline: 1. **Morning:** 15 cups. 2. **Afternoon:** 25 cups. 3. **Total given:** 15 + 25 = 40 cups. 4. **Number of meals:** 3. 5. **Cups per meal:** 3 cups (per chicken). So, 40 cups total for 3 meals = 13.33 cups per meal. The question asks for the amount in the **final meal**. Total meals = 3 Total cups = 40 Cups per meal = 40 / 3 = 13.33
Test question 0; the end of the answer at epoch 0 (untrained) and at epoch 5.
…the number of eggs remaining.**
Subtract the eaten and baked eggs from the total laid.
$$16 \text{ (total)} - 3 \text{ (eaten)} - 4 \text{ (baked)} = 9 \text{ eggs remaining}$$
**Step 4: Calculate the revenue from the remaining eggs.**
She sells the remainder at $2 per fresh duck egg.
$$9 \text{ eggs} \times \$2/\text{egg} = \$18$$
**Conclusion:**
Janet makes $18 every day at the farmers' market.
The answer is: 18…Step 8: Calculate the number of ducks.**
She has 9 eggs remaining. Therefore, she sells 9 ducks.
**Step 9: Calculate the total revenue.**
She sells 9 ducks at $2 per egg.
Total = $9 \times 2 = 18$ dollars.
**Summary of the day:**
- 16 eggs laid.
- 3 eaten (breakfast).
- 4 baked.
- 9 left.
**Calculation:**
$16 - 3 - 4 = 9$.
**Revenue:**
9 ducks $\times$ $2 = $18.
The answer is 18.
**Final line:** 18.
\boxed{18}Test question 0; the end of the answer at epoch 0 (untrained) and at epoch 5.
…the number of eggs remaining.**
Subtract the eaten and baked eggs from the total laid.
$$16 \text{ (total)} - 3 \text{ (eaten)} - 4 \text{ (baked)} = 9 \text{ eggs remaining}$$
**Step 4: Calculate the revenue from the remaining eggs.**
She sells the remainder at $2 per fresh duck egg.
$$9 \text{ eggs} \times \$2/\text{egg} = \$18$$
**Conclusion:**
Janet makes $18 every day at the farmers' market.
The answer is: 18…y**: 16 eggs.
2. **Eaten for breakfast**: 3 eggs.
3. **Baked muffins**: 4 muffins (muffins do not produce eggs, so they don't count towards the market sales).
4. **Remaining eggs**: $16 - 3 - 4 = 9$ eggs.
5. **Price per egg**: $2 per fresh duck egg.
6. **Total revenue from market**: $9 \text{ (eggs)} \times \$2 \text{ (price per egg)} = \$18$.
The answer is that Janet makes $18 every day at the farmers' market.Test question 5; the end of the answer at epoch 0 (untrained) and at epoch 5.
…oup: $5 \times 8 = 40$ * Cost of second group: $3 \times 8 = 24$ Total Cost = $40 + 24 = 64$ **Alternative Method (Summing the arithmetic series):** The cost of the first group is an arithmetic sequence: $5, 5, 5, \dots, 5$ (8 terms). Sum = $8 \times 5 = 40$. The cost of the second group is an arithmetic sequence: $3, 3, 3, \dots, 3$ (8 terms). Sum = $8 \times 3 = 24$. Total = $40 + 24 = 64$. The answer is: 64
…applies to "every second glass". Indices $2, 4, 6, 8, 10, 12, 14, 16$ are multiples of 2. For these indices, the price is $60\%$ of $5 = 3$. For indices $1, 3, 5, 7, 9, 11, 13, 15$, the price is $5$. 5. Calculate the sum: Sum = (price for 1st) + (price for 2nd) + ... + (price for 16th). Count of multiples of 2 is 8. Number of non-multiples is $8$. Sum = $8 \times 3 + 8 \times 5 = 24 + 40 = 64$. 6
Test question 0; the end of the answer at epoch 0 (untrained) and at epoch 5.
…the number of eggs remaining.**
Subtract the eaten and baked eggs from the total laid.
$$16 \text{ (total)} - 3 \text{ (eaten)} - 4 \text{ (baked)} = 9 \text{ eggs remaining}$$
**Step 4: Calculate the revenue from the remaining eggs.**
She sells the remainder at $2 per fresh duck egg.
$$9 \text{ eggs} \times \$2/\text{egg} = \$18$$
**Conclusion:**
Janet makes $18 every day at the farmers' market.
The answer is: 18…:
$$
16 - 3 = 13 \text{ eggs remaining}
$$
These **13 eggs** are used to bake muffins for her friends every day with **4 muffins per day**.
Now, calculate how many eggs remain after baking muffins:
$$
13 - 4 = 9 \text{ eggs remaining}
$$
These **9 eggs** are sold at the farmers' market for **$\$2$ per egg**.
To find the total daily income from selling the remainder:
$$
9 \times 2 = 18
$$
The answer is: **18**Test question 5; the end of the answer at epoch 0 (untrained) and at epoch 5.
…oup: $5 \times 8 = 40$ * Cost of second group: $3 \times 8 = 24$ Total Cost = $40 + 24 = 64$ **Alternative Method (Summing the arithmetic series):** The cost of the first group is an arithmetic sequence: $5, 5, 5, \dots, 5$ (8 terms). Sum = $8 \times 5 = 40$. The cost of the second group is an arithmetic sequence: $3, 3, 3, \dots, 3$ (8 terms). Sum = $8 \times 3 = 24$. Total = $40 + 24 = 64$. The answer is: 64
…Pair 3 (Glasses 5 and 6)**: - Glass 5: $5 \times 0.60 = 3$ - Glass 6: $3$ - **Pair 4 (Glasses 7 and 8)**: - Glass 7: $5 \times 0.60 = 3$ - Glass 8: $3$ - **Pair 5 (Glasses 9 and 10)**: - Glass 9: $5 \times 0.60 = 3$ - Glass 10: $3$ - **Pair 6 (Glasses 11 and 12)**: - Glass 11: $5 \times 0.60 = 3$ - Glass 12: $3$ - **Pair 7 (Glasses 13 and 14)**: - Glass 13: $5 \times 0.60 = 3$ - Glass 14: $3$ - **Pair 8 (Glasses
| Model | Method | Adapter | Epoch | Accuracy | Truncated | Mean tokens | "The answer is:" | \boxed{} | Markdown bold/headers | LaTeX |
|---|---|---|---|---|---|---|---|---|---|---|
| 0.8B | SFT | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | SFT | lora | 1 | 17% | 22% | 166 | 78% | 0% | 0% | 0% |
| 0.8B | SFT | lora | 2 | 29% | 8% | 120 | 91% | 0% | 0% | 0% |
| 0.8B | SFT | lora | 3 | 27% | 0% | 87 | 100% | 0% | 0% | 0% |
| 0.8B | SFT | lora | 4 | 24% | 1% | 89 | 99% | 0% | 0% | 0% |
| 0.8B | SFT | lora | 5 | 22% | 1% | 92 | 99% | 0% | 0% | 0% |
| 0.8B | SFT gentle | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | SFT gentle | lora | 1 | 32% | 6% | 110 | 94% | 0% | 0% | 0% |
| 0.8B | SFT gentle | lora | 2 | 37% | 1% | 88 | 99% | 0% | 0% | 0% |
| 0.8B | SFT self-distilled | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | SFT self-distilled | lora | 1 | 46% | 10% | 323 | 90% | 0% | 97% | 76% |
| 0.8B | SFT self-distilled | lora | 2 | 54% | 10% | 343 | 90% | 0% | 97% | 78% |
| 0.8B | GRPO | full | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | GRPO | full | 1 | 48% | 5% | 194 | 95% | 0% | 89% | 71% |
| 0.8B | GRPO | full | 2 | 57% | 15% | 291 | 84% | 0% | 100% | 23% |
| 0.8B | GRPO | full | 3 | 60% | 10% | 313 | 88% | 0% | 100% | 1% |
| 0.8B | GRPO | full | 4 | 62% | 15% | 320 | 83% | 0% | 100% | 8% |
| 0.8B | GRPO | full | 5 | 68% | 15% | 322 | 83% | 0% | 100% | 4% |
| 0.8B | GRPO | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | GRPO | lora | 1 | 56% | 8% | 289 | 92% | 0% | 95% | 67% |
| 0.8B | GRPO | lora | 2 | 56% | 27% | 377 | 56% | 0% | 99% | 36% |
| 0.8B | GRPO | lora | 3 | 63% | 20% | 347 | 18% | 7% | 75% | 39% |
| 0.8B | GRPO | lora | 4 | 63% | 15% | 336 | 0% | 85% | 94% | 35% |
| 0.8B | GRPO | lora | 5 | 64% | 13% | 339 | 0% | 87% | 95% | 43% |
| 0.8B | RLOO | full | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | RLOO | full | 1 | 57% | 5% | 274 | 95% | 0% | 95% | 84% |
| 0.8B | RLOO | full | 2 | 51% | 13% | 318 | 27% | 0% | 89% | 100% |
| 0.8B | RLOO | full | 3 | 62% | 10% | 265 | 0% | 0% | 86% | 89% |
| 0.8B | RLOO | full | 4 | 61% | 13% | 288 | 0% | 0% | 88% | 83% |
| 0.8B | RLOO | full | 5 | 68% | 14% | 291 | 0% | 0% | 88% | 82% |
| 0.8B | RLOO | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | RLOO | lora | 1 | 48% | 6% | 217 | 96% | 0% | 0% | 11% |
| 0.8B | RLOO | lora | 2 | 57% | 6% | 220 | 93% | 0% | 67% | 19% |
| 0.8B | RLOO | lora | 3 | 66% | 17% | 300 | 84% | 0% | 97% | 26% |
| 0.8B | RLOO | lora | 4 | 60% | 17% | 316 | 83% | 0% | 99% | 14% |
| 0.8B | RLOO | lora | 5 | 67% | 12% | 295 | 89% | 0% | 98% | 14% |
| 0.8B | GSPO | full | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | GSPO | full | 1 | 59% | 3% | 214 | 93% | 4% | 57% | 96% |
| 0.8B | GSPO | full | 2 | 72% | 5% | 209 | 94% | 0% | 3% | 81% |
| 0.8B | GSPO | full | 3 | 61% | 8% | 255 | 9% | 10% | 95% | 99% |
| 0.8B | GSPO | full | 4 | 65% | 10% | 272 | 8% | 5% | 100% | 100% |
| 0.8B | GSPO | full | 5 | 70% | 10% | 238 | 4% | 2% | 100% | 100% |
| 0.8B | GSPO | lora | 0 | 54% | 14% | 347 | 86% | 0% | 95% | 80% |
| 0.8B | GSPO | lora | 1 | 52% | 2% | 187 | 98% | 0% | 37% | 95% |
| 0.8B | GSPO | lora | 2 | 53% | 12% | 282 | 88% | 0% | 93% | 99% |
| 0.8B | GSPO | lora | 3 | 62% | 8% | 295 | 93% | 0% | 100% | 99% |
| 0.8B | GSPO | lora | 4 | 66% | 7% | 318 | 93% | 0% | 100% | 99% |
| 0.8B | GSPO | lora | 5 | 59% | 12% | 321 | 88% | 0% | 100% | 98% |
A training step that peaked at almost 16 GB on a model with 1.6 GB of weights.
While the second GRPO attempt was running, system swap climbed to 5 GB and step times swung between 11 and 46 seconds. Profiling one forward and backward pass explained it: without gradient checkpointing, the activations of the 0.8B for a batch of two 800-token sequences needed almost the entire 16 GB. Turning on checkpointing (recomputing activations in the backward pass) cut that to 6.9 GB at the cost of some speed, and the restarted GRPO run peaked at 6.8 GB.
tests/profile_memory.py). Batch size and gradient checkpointing change it by 2-3x.This is the number to carry to the larger models, and it is not reassuring. Even with checkpointing, the 0.8B needs about 5 GB of working memory on top of its 1.6 GB of weights. The 4B has 8.5 GB of weights and bigger activations, so as configured it very likely does not fit in the ≈9.5 GB we have: it would need a micro-batch of 1, shorter sequences, or a more memory-efficient backward pass for the gated-delta layers. We therefore did not train the 2B or 4B: with RL at roughly 3 hours per 0.8B run, the time cost alone would have been days per run, on top of the memory risk.
SFT is cheap; RL is generation-bound and slow.
An SFT step (4 sequences) takes about a second, so five epochs of 500 questions finish in roughly 15 minutes. An RL step must first generate 16 answers of up to 640 tokens at decode speeds of a few hundred tokens/s, then train on them: 15-45 seconds on the 0.8B. A 625-step RL run took roughly 3-4 hours with LoRA and about 3 hours with full fine-tuning on the 0.8B; larger models would be several times slower.
Accuracy is only half of a benchmark. This chapter reads the system counters logged at every step to see what the machine did while it trained: where the time went, how busy the GPU and CPU were, and whether the laptop ever slowed down.
All numbers below are from the 0.8B runs on GSM8K: 500 questions for 5 epochs (2 for the gentle SFT variants), one run at a time on the 16 GB MacBook.
Across 9 runs (20 hours of training in total) the GPU was busy 81% of the time on average and the CPU only 12%: training is a GPU job, and the CPU mostly feeds it. The thermal speed limit never dropped below 100%, so the laptop never throttled, even through multi-hour runs on a plugged-in laptop.
Each RL step first samples 16 answers and then trains on them. Sampling took 64-73% of the step time (68% on average). Sampling is memory-bandwidth bound exactly as in the inference benchmark, so the lever that matters is how many tokens you generate, not how clever the optimiser is. Batching helps a lot: 16 sequences decoded together reach 381-516 tokens/s in total, against about 72 tokens/s for a single stream on the same model.
GPU utilisation sat between 71% and 94% for every run, while the CPU stayed at 9-21%. Full fine-tuning kept the GPU less busy than LoRA in the RL runs (73% vs 85%): a likely reason is memory pressure: with roughly 11 GB of MLX memory there is less room to keep the GPU fed (we did not isolate the cause).
System RAM read 13.4-14.0 GB in every run, almost the whole 16 GB, and the swap file held 2.5-7.9 GB. This is mostly macOS using memory for caches and other apps, so it says more about the machine than about training, but it also means there is no slack: the runs that peaked at 11.1 GB of MLX memory had only a few GB of headroom. The steady swap use did not visibly slow the runs. The one real slow-down we saw came from a different cause, an activation footprint too large for memory before we turned on gradient checkpointing (chapter 6).
| Run | Steps | Hours | s / step | Sampling share | Gen tok/s | Train tok/s | GPU | CPU | Peak MLX GB | RAM GB | Swap GB | Gain (pts) | Pts / hour |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| SFT lora | 625 | 0.3 | 1.3 | – | – | 295 | 86% | 21% | 9.8 | 13.9 | 3.6 | -32 | -113.2 |
| SFT gentle lora | 250 | 0.1 | 1.6 | – | – | 233 | 81% | 17% | 4.4 | 13.4 | 2.5 | -17 | -116.9 |
| SFT self-distilled lora | 268 | 0.3 | 3.7 | – | – | 352 | 94% | 13% | 7.1 | 13.6 | 3.5 | +0 | +0.0 |
| GRPO full | 625 | 3.0 | 17.1 | 64% | 516 | 424 | 74% | 11% | 11.1 | 14.0 | 4.5 | +14 | +4.6 |
| GRPO lora | 625 | 3.8 | 21.6 | 70% | 427 | 425 | 86% | 9% | 6.8 | 14.0 | 4.1 | +10 | +2.6 |
| RLOO full | 625 | 2.8 | 15.8 | 66% | 500 | 413 | 74% | 9% | 11.1 | 14.0 | 4.6 | +14 | +5.0 |
| RLOO lora | 625 | 3.4 | 18.9 | 73% | 381 | 407 | 85% | 9% | 6.9 | 13.9 | 7.9 | +13 | +3.9 |
| GSPO full | 625 | 2.8 | 16.0 | 65% | 488 | 424 | 71% | 10% | 11.1 | 14.0 | 4.4 | +16 | +5.6 |
| GSPO lora | 625 | 3.1 | 17.5 | 71% | 396 | 462 | 83% | 9% | 6.8 | 14.0 | 3.6 | +5 | +1.6 |
Gain is final minus untrained test accuracy in points; points per hour divides it by the wall-clock hours of the whole run, evaluations included (one evaluation of the test set takes about 44 s). Energy and battery use were not measured: that needs administrator access to the power counters.
Small models, comfortably, with LoRA; the full fine-tune of even the smallest model is a stretch.
| Model | Training mode | State GB (est.) | On this Mac (usable ≈9.5 GB) | How estimated |
|---|---|---|---|---|
| 0.8B | LoRA (bf16) | ≈2.0 | fits | bf16 weights + LoRA + activations (measured activations dominate for small models) |
| 0.8B | full fine-tune | ≈11.1 | does not fit | bf16 weights 2 + fp32 master 4 + Adam m,v 8 = 14 bytes/param + activations |
| 2B | LoRA (bf16) | ≈4.5 | fits | bf16 weights + LoRA + activations (measured activations dominate for small models) |
| 2B | full fine-tune | ≈28.5 | does not fit | bf16 weights 2 + fp32 master 4 + Adam m,v 8 = 14 bytes/param + activations |
| 4B | LoRA (bf16) | ≈8.9 | tight (swap) | bf16 weights + LoRA + activations (measured activations dominate for small models) |
| 4B | full fine-tune | ≈59.3 | does not fit | bf16 weights 2 + fp32 master 4 + Adam m,v 8 = 14 bytes/param + activations |
| 9B | LoRA on 4-bit base | ≈6.0 | fits | 4-bit base + LoRA (--quantize-base 4) |
| 9B | LoRA (bf16) | ≈18.5 | does not fit | bf16 weights + LoRA + activations (measured activations dominate for small models) |
Estimates are weights plus optimizer state and a 0.5 GB allowance; activations come on top and, as chapter 5 shows, can dominate. Treat "fits" as "should fit with small batches and checkpointing".
Test accuracy is on 100 questions (about ±10 points) with one seed per setup; learning rates were corrected after the failures above rather than swept, so the method comparison is not a tuned head-to-head; power draw and batteries are untested.
Multiple seeds and a larger test set would tighten the method comparison; SFT with full fine-tuning and the 2B model are the obvious missing runs. The inference-side companion post covers running these same models.
| Model | Method | Adapter | Status | Baseline acc | Final acc | Best acc | Gain | Trainable | LR | Step s | Peak GB | Swap GB | Hours |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0.8B | SFT | lora | done | 54% | 22% | 54% | -32 pts | 10.8M | 2e-05 | 1.3 | 9.8 | 3.6 | 0.3 |
| 0.8B | SFT gentle | lora | done | 54% | 37% | 54% | -17 pts | 10.8M | 5e-06 | 1.6 | 4.4 | 2.5 | 0.1 |
| 0.8B | SFT self-distilled | lora | done | 54% | 54% | 54% | +0 pts | 10.8M | 5e-06 | 3.7 | 7.1 | 3.5 | 0.3 |
| 0.8B | GRPO | full | done | 54% | 68% | 68% | +14 pts | 498.1M | 1e-06 | 17.1 | 11.1 | 4.5 | 3.0 |
| 0.8B | GRPO | lora | done | 54% | 64% | 64% | +10 pts | 10.8M | 2e-06 | 21.6 | 6.8 | 4.1 | 3.8 |
| 0.8B | RLOO | full | done | 54% | 68% | 68% | +14 pts | 498.1M | 1e-06 | 15.8 | 11.1 | 4.6 | 2.8 |
| 0.8B | RLOO | lora | done | 54% | 67% | 67% | +13 pts | 10.8M | 2e-06 | 18.9 | 6.9 | 7.9 | 3.4 |
| 0.8B | GSPO | full | done | 54% | 70% | 72% | +16 pts | 498.1M | 1e-06 | 16.0 | 11.1 | 4.4 | 2.8 |
| 0.8B | GSPO | lora | done | 54% | 59% | 66% | +5 pts | 10.8M | 2e-06 | 17.5 | 6.8 | 3.6 | 3.1 |
| Model | Method | Adapter | Peak MLX GB | Max RAM GB | Max swap GB | Step s | Train tok/s | Rollout tok/s |
|---|---|---|---|---|---|---|---|---|
| 0.8B | SFT | lora | 9.8 | 13.9 | 3.6 | 1.3 | 295 | – |
| 0.8B | SFT gentle | lora | 4.4 | 13.4 | 2.5 | 1.6 | 233 | – |
| 0.8B | SFT self-distilled | lora | 7.1 | 13.6 | 3.5 | 3.7 | 352 | – |
| 0.8B | GRPO | full | 11.1 | 14.0 | 4.5 | 17.1 | 424 | 516 |
| 0.8B | GRPO | lora | 6.8 | 14.0 | 4.1 | 21.6 | 425 | 427 |
| 0.8B | RLOO | full | 11.1 | 14.0 | 4.6 | 15.8 | 413 | 500 |
| 0.8B | RLOO | lora | 6.9 | 13.9 | 7.9 | 18.9 | 407 | 381 |
| 0.8B | GSPO | full | 11.1 | 14.0 | 4.4 | 16.0 | 424 | 488 |
| 0.8B | GSPO | lora | 6.8 | 14.0 | 3.6 | 17.5 | 462 | 396 |
runs/ (model weights were deleted locally after the runs; re-run train.py to regenerate them), the discarded attempts under runs_discarded/; W&B project macbook-posttrain has one line per (model, method, adapter).Copyright © 2022-2026 Azmine Toushik Wasi. All rights reserved.