<!-- agent-source-envelope -->
# How to cook an LLM | posttrainllm

> A hands-on journey from garden to table: gather data, inspect tokens, clean a batch, explore pre-training, then refine and serve. Kitchen and model-building…

Canonical: https://posttrainllm.com/articles/how-to-cook-an-llm
<!-- /agent-source-envelope -->

01 / Harvest

[Harvest](https://posttrainllm.com/articles/how-to-cook-an-llm#ingredients) · [Chop](https://posttrainllm.com/articles/how-to-cook-an-llm#chopping) · [Clean](https://posttrainllm.com/articles/how-to-cook-an-llm#cleaning) · [Cook](https://posttrainllm.com/articles/how-to-cook-an-llm#base-recipe) · [Refine & serve](https://posttrainllm.com/articles/how-to-cook-an-llm#refine) · [Talk](https://posttrainllm.com/articles/how-to-cook-an-llm#chat)

The full reading journey is available below. Enable JavaScript for token
previews, data preparation, and the training illustrations.

[← Back](https://posttrainllm.com/articles/how-to-cook-an-llm#welcome)Choose a scene [Next →](https://posttrainllm.com/articles/how-to-cook-an-llm#ingredients)

01 / In the garden

## Find your ingredients.

Kitchen / harvest what you need

Model / gather training data

A model’s ingredients are text. Walk through the available sources
and choose what belongs in your basket.

You’re collecting material.
**No weights have changed.**

You’re making a three-ingredient dinner without dairy: rice, beans,
and tomatoes. You don’t begin with the stove. You begin by finding
ingredients that can make the dish you want.

Model-building starts the same way. You gather explanations,
conversations, code, or other material from relevant sources. What you
pick shapes what the model will have a chance to learn. These small,
handwritten samples are our teaching harvest.

Your first decision

### What goes in your basket?

Choose which text samples to keep### Rice, beans and tomatoes

Cook rice, warm beans, and add chopped tomatoes. A three-ingredient dinner without dairy.

### Another recipe note

Cook rice, warm beans, and add chopped tomatoes. A three-ingredient dinner without dairy.

### An imported recipe note

Dinner[NUL][replacement character]

### A dinner conversation

User: Suggest a three-ingredient dinner without dairy.
Assistant: Make a bowl with rice, beans, and tomatoes. Cook, warm, and combine.

### A recipe in code

ingredients = ["rice", "beans", "tomatoes"]
assert len(ingredients) == 3

### Creamy rice with cheese

Cook rice with butter, then stir in cheese. A creamy three-ingredient dinner.

### Tomorrow’s forecast

Tomorrow: sunny, 24°C, with a light breeze. Rain is expected on Friday.

Your basket: empty. Nothing has been cleaned or trained yet.

Read the samples before deciding. The sink removes exact repeats and
malformed text. A recipe with cheese or an unrelated forecast can
still be structurally clean; choosing relevant material is your
decision.

[Take your basket insideNext: the cutting board →](https://posttrainllm.com/articles/how-to-cook-an-llm#chopping)

02 / At the cutting board

## Turn text into workable pieces.

Kitchen / cut and portion

Model / inspect preprocessing & tokens

A model processes token IDs. See how a sentence becomes smaller
units it can work with.

You’re changing the representation.
**The model stays unchanged.**

Put a sentence on the board. In our tiny trainer, cutting it into
model inputs means encoding its UTF-8 bytes. Larger LLMs often use
subword pieces instead. The knife is a way to understand tokenization,
not how every tokenizer literally works.

Try the knife / real byte tokenization

Put some text on the cutting boardCut into tokens →

A preview of the tool, not a prepared training batch. Try “café” to
see one character occupy multiple bytes.

We’re inspecting tokenization before preparing the full harvest. In
the actual data pipeline, clean the source text first, then encode the
finished batch. That is what we’ll do at the next stop.

[The pieces still need checkingNext: wash and sort →](https://posttrainllm.com/articles/how-to-cook-an-llm#cleaning)

03 / At the sink

## Wash and sort your batch.

Kitchen / wash, trim, and sort

Model / clean, deduplicate, encode

Inspect the harvest. Remove exact repeats and deliberately broken
samples, then tokenize what remains.

The batch is becoming usable.
**Only the data changes.**

Now your earlier choices matter. Did you pick the same sample twice?
Did a broken one slip into the basket? Clean the text before the final
encoding and inspect what survives.

At the sink / real data preparation

### Wash, sort, and check your batch.

Prepare selected text →

What changed? Nothing yet. Model weights unchanged.

Under the hood: prepared text & actual tokens


```
Choose your text, then prepare a batch.
```





```
No batch prepared yet.
```



This trainer uses one token per UTF-8 byte, with a vocabulary of
256. “Rice” → [82, 105, 99, 101]. Non-ASCII characters can take
several bytes. Larger LLMs commonly use subword tokenizers.

Open this batch in the trainer →Download text

Handwritten teaching samples, not a production dataset. The trainer
will offer an import; it won’t start training automatically. A tiny
batch shows the mechanism, not general assistant capability.

You have ingredients ready for cooking. **You still don’t have a trained model.**

[Carry the prepared batch to the stoveNext: start cooking →](https://posttrainllm.com/articles/how-to-cook-an-llm#base-recipe)

04 / At the stove

## Start cooking the base recipe.

Kitchen / cook, check, adjust

Model / pre-training

Predict the next token. Compare with the text’s actual next token.
Use the error to guide a weight update.

Cook trains on your batch.
**Your model’s weights change here.**

Chopping wasn’t cooking. Washing wasn’t cooking. Pre-training is the
cooking: repeated practice develops the foundation. A generative model
commonly learns by predicting the next token in a sequence.

Your batch → your weights

### Turn on the heat.

Train on your batch, right here in your browser.

Training steps **0 / 256** Prediction loss **—**

Cook my model →Turn off the heatKeep cooking · 256 steps

Prepare your ingredients at the sink first. Nothing trains
automatically.

What is in the pot?


```
No prepared batch yet.
```



One transformer layer, byte tokens, existing WASM trainer. Up to 256 optimizer steps per click, with a 30-second stop. This small recipe
teaches training; it does not create a general assistant.

A real optimizer repeats this cycle across many batches. Lower
training loss is a signal about the objective, not a guarantee of
usefulness. Set aside evaluation data to test whether the learning
carries beyond the training examples.

**What the processes share:** repeated trials can change the
recipe. The difference is that a model learns numerical weights through
an objective; it isn’t a cook understanding the dish.

[The foundation is cooked. Make it fit the brief.Next: taste, refine, and serve →](https://posttrainllm.com/articles/how-to-cook-an-llm#refine)

05 / At the tasting and serving table

## Refine it. Then serve it.

Kitchen / refine, plate, garnish, serve

Model / post-training, then inference

Worked examples and tasting feedback guide further training. A new
order then uses the resulting model.

Refining can change weights.
**Plating and serving do not.**

You’ve developed a base recipe, but the brief is specific: three
ingredients, no dairy, a short answer. Learn from a worked example,
taste two versions, and revise toward that brief. That is the
post-training part of our journey.

### First, learn from a worked recipe.

Supervised fine-tuning continues training on demonstrations of the
desired response. Like practicing a particular recipe, it teaches the
result you want to serve. With LoRA, that update can be carried in
adapter weights while the base stays frozen.

Illustrative checkpoints

Suggest a three-ingredient dinner without dairy. Keep the answer brief.

Authored teaching outputs. No model was trained here.

- Base model
- After SFT
- After preference training

Kitchen

Develop the base recipe

Model

Pre-training

Three ingredients for dinner. Dinner is a meal often served in the evening…

Inspect the example or training objective


```
Raw text → predict the next token → update weights. A base model may continue text rather than follow an instruction.
```



Real run: Weights during pre-training. Here: illustrative output only.

### Then taste two versions.

The tasting table gives you a comparison. Choosing an answer records
a preference; a separate optimization step uses it to change
trainable weights. Both SFT and preference optimization belong
within post-training.

Your turn / become the taste tester

### Which meets the brief?

Suggest a three-ingredient dinner without dairy. Keep the answer brief.

A: Make creamy rice with cheese and beans.

B: Rice, beans, tomatoes: cook, warm, and combine. Dairy-free.

No preference collected. Model weights unchanged.

Your preference tray / collected data


```
Your tray is empty. Choose a response to collect a preference pair.
```



Simulate training →Export pairReset

Illustration only / no model optimized

Pair collected → Optimization step
→ Candidate weights → Held-out evaluation

DPO can optimize on preference pairs directly. RLHF can first fit
a reward model and use it during reinforcement learning. This is a
conceptual illustration of the separation, not a numerical
simulation of either algorithm.

### Finally, plate, garnish, and serve.

A finished recipe can fulfil another order without being rewritten.
That is ordinary inference: fixed weights, a new prompt, a new
response. Garnish is presentation—it can make an answer easier to
read, but presentation alone isn’t post-training.

A last distinction / same answer, different presentation



```
Rice, beans, tomatoes: cook, warm, and combine. Dairy-free.
```


Add a heading / garnish the answer

Illustrative answer, not live generation. Model weights unchanged.

Gather. Prepare. Cook. Refine. Serve. **Now you know which steps change data, weights, or the answer’s
presentation.**

[Your model is ready at the tableTake an order →](https://posttrainllm.com/articles/how-to-cook-an-llm#chat)

Take your harvest into the real lab

### Your next dish can be a real run.

Return to your prepared batch and offer it to the existing browser
trainer. It demonstrates tiny next-token training from scratch, not
the SFT or preference scenes above.

[Return to your batch ↑](https://posttrainllm.com/articles/how-to-cook-an-llm#cleaning)[Explore the trainer →](https://posttrainllm.com/playground)[Real post-training on a Mac →](https://posttrainllm.com/fine-tune-llm-on-mac)

06 / Dinner is served

## Meet the model you cooked.

Kitchen / taste your own dish

Model / your trained weights

Start a sentence. Your model predicts what comes next using what
it learned from your batch.

Same model. Same weights.
**No pretrained assistant behind the curtain.**

Your kitchen model Not cooked yet

This is a tiny byte-level text generator. Short training may produce
fragments or nonsense; more practice can lower training loss without
proving useful generalization. Its weights stay in this tab until
you download them or leave the page.

[Back to the stove →](https://posttrainllm.com/articles/how-to-cook-an-llm#base-recipe)Take my model home ↓

Cook your batch first, then try the model here.

Your own model will be served here.

Start a sentenceUse my batch’s opening

Let it finish →StopClear plate

What is running?

The same isolated WASM worker trained at the stove generates 48
new byte tokens. No external model downloads, no system prompt,
and no canned replies. Download exports the trainer’s .tinygpt
format for the Web Lab. Your existing saved Web Lab model is
untouched. Changing ingredients does not silently retrain or
replace this model.

[Explore a bigger recipeOpen the browser trainer →](https://posttrainllm.com/playground)

## Read the technical sources.

The kitchen is a metaphor. These sources explain the mechanisms.

-
[Hugging Face: pre-training and fine-tuning](https://huggingface.co/learn/llm-course/chapter1/4)

-
[InstructGPT: demonstrations, preferences, and RLHF](https://arxiv.org/abs/2203.02155)

-
[Direct Preference Optimization](https://arxiv.org/abs/2305.18290)

-
[Lesson notes and trainer integration contract](https://posttrainllm.com/docs/learn/llm-kitchen)

-
[Continue with the hands-on learning paths](https://posttrainllm.com/learn)
