Machine learning in one lesson

In traditional software, a person writes the rules: "if the payment is over 1,000, send it for review." In machine learning (ML), nobody writes the rules; the system works them out from examples. So its behavior depends on its data, on how its mistakes were measured, and on whether anyone checked it on cases it has never seen.

This lesson covers the ideas the rest of the course builds on: how a model learns from examples, what trainingTraining Adjusting model weights from data so its predictions improve. does, why training and answering requests are separate jobs, how to tell learning from memorizing, and what a language model is underneath. Adapta is the case study because it keeps these pieces visibly separate.

Learning from examples

Think of a spam filter. Instead of writing rules, you collect thousands of messages already marked "spam" or "not spam" and let the system find the patterns.

The thing that learns is a model: picture a machine with a huge number of adjustable knobs. The knobs are its parameters, or weights, plain numbers, sometimes billions of them.

Each example pairs an input, such as a support ticket, with the correct answer, its label, such as "billing". A collection of pairs is a dataset. When every example comes with its answer, this is supervised learning, the case this lesson covers. Language models learn in a similar way, but nobody writes their labels: the "answer" at each point is simply the next piece of the text.

Training: measuring mistakes and correcting them

Training means finding knob settings that make the model's answers match the labels. First, it needs a score for mistakes. The loss is one number that says how badly the model did: lower is better. The usual loss for classifiers and language models punishes confident mistakes hardest: being "90% sure" of the wrong answer costs far more than a hesitant wrong guess.

Second, it needs a way to improve. Gradient descent is like walking downhill in fog: you can't see the valley, but you can feel the slope. For each knob, the math says which direction lowers the loss, and the model takes a small step that way, over and over. The step size is the learning rate; one full pass over the data is an epoch.

Training is not serving

When training ends, the knobs are frozen and the model starts answering requests. That phase is inferenceInference Running a trained model to produce an output for a new input., or serving. The two phases look very different:

Serving has its own lesson: Serving models.

Learning versus memorizing

A student who memorizes last year's exam can ace it and fail a new one. Models do the same. What matters is generalizationGeneralization A model performing well on data it did not see during training.: being right on new data of the same kind. So the data is split, and each part has one job:

• Training set: adjusts the parameters.
• Validation set: compares settings and decides when to stop.
• Test set: used once, at the end, to estimate real performance. If it keeps influencing decisions, the system slowly gets tuned to it and it stops being a test.

OverfittingOverfitting A model memorizing its training data instead of learning patterns that generalize. is memorizing instead of learning: the loss on training data keeps falling while the loss on validation data starts rising. Underfitting is the opposite: the model hasn't even learned the training data. In the sketch below, look at where the two lines part ways.

loss
 |\
 | \        ___ validation
 |  \______/
 |   \
 |    \______ training
 +------------------ time spent training
        ^ stop around here

Metrics and comparisons are covered in Evaluating models.

Neural networks and transformers

A neural network is a model built from layers. Each layer does a simple calculation and passes the result on. Stacked, simple layers can capture very complex patterns, and gradient descent tunes them all at once.

A transformerTransformer The 2017 neural network design behind today's LLMs, built around attention and able to process all the tokens of a text at once. is the kind of network behind today's large language models (LLMsLLM A large language model: a neural network trained to predict the next token, then tuned to follow instructions.). Its key idea is attentionAttention The mechanism that lets a model decide, for each token, how much to draw on every other token in the text.: for each word it processes, the model weighs how much every earlier word matters. That is how it links "it" back to the right noun. An LLM is a transformer trained to predict the next tokenToken A small chunk of text, often part of a word, that a model reads and writes and that providers charge by., a word or piece of a word. Generating text is repeating that prediction, one token at a time.

Pretraining means training a model from scratch on a huge amount of text; it takes GPU clusters and budgetsBudget A hard limit on tokens, calls, time or money, enforced before the resource is spent. few organizations have, and produces a base model. Fine-tuningFine-tuning Further training a pretrained model on your own examples to change how it behaves. continues training a base model on a small dataset to change its behavior: format, tone, or how it classifies. Almost no product team pretrains. The realistic options are good promptsPrompt Everything sent to the model in one call: instructions, conversation messages and any tool definitions., handing the model knowledge when a question arrives (Embeddings and RAG), or efficient fine-tuning (Fine-tuning, LoRA and QLoRA).

Putting it into practice

• Decide who owns the evaluation data. If the people who train also pick and reuse the test set, results inflate without anyone lying.
• Keep a versioned held-out set, never used for training or tuning, and measure the unchanged model on it as a baselineBaseline The reference result a new model or change must beat to count as an improvement..
• Write the pass criterion before training, not after seeing the numbers.

Go deeper

Adapta's own documentation covers these foundations with its code as the example:

• Learning the system explains from first principles what a language model is, why training runs in a separate worker, and how the evaluation gate decides whether a new model may serve.
• Architecture maps Adapta's containers and follows a training job step by step, from the queue to a live endpoint.
• Stack and decisions explains why each component was chosen, including the training libraries, the job queue and the evaluation gate.

Key takeaways

• A model is a set of parameters fitted to examples; its behavior depends on the data as much as on the code.
• Training lowers a loss step by step; serving uses the frozen result. They differ in hardware, cost and how they fail.
• Only performance on data the model never trained on shows whether it generalizes.
• An LLM is a transformer trained to predict the next token; it aims for plausible, not true.
• Almost nobody pretrains: the choice is between prompting, RAG and fine-tuning a base model.

Check yourself