What actually happens inside AI?

A language model cannot read letters or words directly. It works with numbers, so the first step is to cut the text into pieces called tokens and to replace each piece with an integer ID taken from a fixed vocabulary.

A token may be a whole word, a part of a word, a single character, a punctuation mark, or a word together with its leading space. Most modern models use subword tokenization, for example byte-pair encoding (BPE). The vocabulary is built by starting from small units and repeatedly merging the pairs that occur most often in a large sample of text. Frequent words usually become a single token; rare or long words are split into several pieces. This keeps the vocabulary at a manageable size (typically tens of thousands to a few hundred thousand entries) while still allowing any text to be represented, often by falling back to individual bytes.

Why this matters in practice:

• The context window and, for many services, the price are counted in tokens, not words. In English, one token is on average a bit less than one word (a common rule of thumb is about three quarters of a word), but the ratio varies. Languages that are less represented in a tokenizer's training text, such as Albanian, often need more tokens per word.
• Numbers, code and unusual spellings can split in unexpected ways. This is one reason why models can struggle with tasks such as counting the letters in a word.
• Token IDs belong to one tokenizer. The same text receives different IDs in different models, and an ID has no meaning on its own. The next step turns it into a vector.

Simplification: the splits and IDs in the visualization are illustrative. Real tokenizers use their own vocabularies and rules.

After tokenization, each token ID is used to look up one row in a large table called the embedding matrix. That row is a vector, a list of numbers (768 numbers in GPT-2 small, thousands in larger models), and it is the model's starting representation of that token. The values in the table are parameters learned during training, not designed by hand.

Training pushes tokens that are used in similar ways toward similar vectors, so directions in this space often reflect aspects of meaning or grammar. This is why "cat" and "dog" tend to end up closer to each other than to "carburetor". The classic illustration is the analogy king − man + woman ≈ queen, reported for word embeddings such as word2vec (Mikolov et al., 2013). Treat it as an illustration, not a law: in those experiments the words from the question are normally excluded from the candidate answers, results vary, and the input embeddings of modern language models do not behave so neatly.

Two important points:

1. 1. The embedding of a token is the same wherever it appears. "Bank" starts from the same vector in "river bank" and in "bank account". It is the later layers, above all attention, that make the representation depend on context.
2. 2. Real embedding spaces have hundreds to thousands of dimensions. The 2D picture is a projection made for human eyes, and it loses information.

Simplification: positions in the visualization are illustrative, not coordinates from a real model.

A weight is a number that controls how strongly one value influences another. In a single artificial neuron, each input is multiplied by its weight, the results are added together, a bias (another learned number) is added, and the total is passed through an activation function:

output = f(w₁x₁ + w₂x₂ + … + b)

A large positive weight means the input pushes the result up, a negative weight pushes it down, and a weight near zero means the input barely matters. Looking at one weight tells you almost nothing. The behavior of a network emerges from millions or billions of weights working together.

Weights are the main kind of parameter that a model learns. Training adjusts them in many small steps so that the model's predictions improve. After training, the weights are fixed: they do not change while you chat with the model.

Weights are not facts stored as sentences. Knowledge in a network is spread across many weights, and there is no simple table where a fact can be looked up.

Simplification: the visualization shows one multiplication (input × weight). A full neuron also sums many such products, adds a bias and applies an activation function.

A layer of a neural network has many neurons, and each one needs a sum of products. Matrix multiplication computes all of them at once.

If A has m rows and n columns, and B has n rows and p columns, then C = AB has m rows and p columns. Each entry C[i][j] is the dot product of row i of A with column j of B: multiply the matching entries and add the results. The "inner" sizes (n) must match.

In a neural layer, the input vector x is multiplied by a weight matrix W, a bias vector is added, and the result goes through an activation function: y = f(xW + b).

Two reasons this matters:

• Speed. Graphics processors (GPUs) are built to perform huge numbers of these multiplications in parallel. Most of the computation in a transformer is matrix multiplication.
• Meaning of the dot product. A dot product is larger when two vectors point in a similar direction. This idea is at the heart of attention (sections 09 and 10).

Note that the order matters: in general AB is not the same as BA.

Simplification: the matrices here are tiny. In real models they have thousands of rows and columns.

A matrix can be seen as a function that moves every point of space. In two dimensions, a 2×2 matrix tells you where the two basic arrows go: its first column is where the arrow (1, 0) lands, and its second column is where (0, 1) lands. Every other point follows from these two.

Transformations of this kind include rotation, scaling, shearing, reflection and projection. They are called linear because they keep the origin fixed, keep straight lines straight, and keep grid lines parallel and evenly spaced. (When a bias is added, the operation is called affine.)

The determinant tells you by what factor areas change. A negative determinant means the orientation is flipped. A determinant of zero means the plane has been squashed onto a line or a point; information has been lost and the transformation cannot be undone.

Why this matters: the weight matrix of a layer applies a linear transformation to its input vector, in hundreds or thousands of dimensions rather than two. Layer after layer, these transformations reshape the space in which the model represents information. But several linear transformations in a row are equivalent to a single one, which is why networks also need the non-linear step explained next.

Without activation functions, a stack of layers would collapse into one single linear transformation, no matter how many layers it had. An activation function applies a simple non-linear function to each number, and this is what lets networks learn curved, complex relationships.

• ReLU: f(x) = max(0, x). Negative values become zero; positive values pass unchanged. Simple and fast.
• Sigmoid: f(x) = 1 / (1 + e^(−x)). Squashes any number into the range 0 to 1.
• Tanh: squashes numbers into the range −1 to 1.

Sigmoid and tanh become very flat for large positive or negative inputs, which can slow learning. ReLU avoids this for positive inputs, but a neuron can get stuck outputting zero for everything.

Large transformer models mostly use smoother variants. GPT-2 and BERT use GELU, and many recent models use gated variants such as SwiGLU. The principle is the same: a non-linear step after each linear one.

Attention lets each token gather information from other tokens. For every position, the model computes a set of weights over the positions it is allowed to look at (the weights are non-negative and add up to 1) and builds a new representation as a weighted mix of the information found there.

Consider "The animal didn't cross the street because it was too tired." To represent "it" usefully, the model needs information from "animal". Attention is the learned mechanism that makes this possible. In decoder-only models such as GPT, each token can look only at itself and the tokens before it (the causal mask), because the model generates text from left to right.

One caution: attention weights show where a head reads from, but they are not a complete explanation of why the model produced an output. Research has shown that a high attention weight does not always mean the token was decisive (Jain & Wallace, 2019; Wiegreffe & Pinter, 2019). Also, a real model has many heads in many layers; one heatmap shows just one slice.

Simplification: the sentence and weights in the visualization are illustrative.

Each token's vector x is multiplied by three different learned matrices to produce three vectors:

• Query q = x·W_Q: what this position is looking for.
• Key k = x·W_K: what this position offers for matching.
• Value v = x·W_V: the information this position passes on if it is selected.

The match between position i and position j is the dot product q_i · k_j. A higher score means more attention. The dot product equals |q|·|k|·cos θ, so it depends on both the angle and the lengths of the vectors. In the slider above the lengths are kept fixed, which is why only the angle matters there. In real models the lengths matter too.

The scores are divided by √d_k (section 10), turned into weights with softmax, and used to mix the value vectors: the output at position i is Σ_j weight(i, j) · v_j.

Why three separate matrices? Because what a token is looking for does not have to be the same as what it offers or what it passes on. This gives the model flexibility.

"Query", "key" and "value" are helpful metaphors. In reality they are just learned linear projections, and what they encode must be found out by analysing the trained model.

The whole operation is one formula:

Attention(Q, K, V) = softmax( Q Kᵀ / √d_k + M ) V

where M is the mask: 0 for allowed positions and −∞ for forbidden ones. The steps in the walk-through are:

1. 1. Input X: one row per token.
2. 2. Projections: Q = X·W_Q, K = X·W_K, V = X·W_V.
3. 3. Transpose K, so that the multiplication works.
4. 4. Scores S = Q Kᵀ: an n × n table; entry (i, j) is how well query i matches key j.
5. 5. Scaling by √d_k. Dot products of long vectors tend to grow with their dimension d_k (if the entries are independent with variance 1, the variance of the dot product is d_k). Large scores push softmax toward an almost one-hot result with tiny gradients. Dividing by √d_k keeps the scores in a good range.
6. 6. Causal mask: −∞ is added to the forbidden (future) positions, so they receive weight exactly 0 after softmax.
7. 7. Softmax on each row: every row becomes weights that add up to 1.
8. 8. Multiply by V: each output row is a weighted average of the value rows.

Shapes: Q and K are n × d_k, V is n × d_v, the score table is n × n, and the output is n × d_v. Because of the n × n table, the cost of attention grows with the square of the sequence length, which is why long contexts are expensive.

Simplification: the numbers in this example are small and made up so that you can follow them by hand. GPT-2 small, for example, uses d_k = 64 per head.

Instead of one attention operation, a transformer layer runs several in parallel, called heads. Each head has its own matrices W_Q, W_K and W_V, which project the vectors to a smaller size (usually d_model divided by the number of heads; in GPT-2 small, 12 heads × 64 = 768). The outputs of all heads are put together and mixed by an output matrix W_O, and the result is added to the residual stream (section 13).

Why several heads? Each head can learn to look at different positions with a different pattern. Research has found heads that mostly look at the previous token, heads that help the model copy repeated patterns (induction heads), and heads that seem to track syntactic relations. But not every head has a clean, human-readable role, many look redundant, and what a head does can differ between models.

Simplification: the roles shown in the visualization are examples for intuition, not fixed roles proven for every model.

Attention on its own has no sense of order. If the input tokens were permuted and nothing else changed, the outputs would simply be permuted in the same way. But order carries meaning ("the dog bit the man" is not "the man bit the dog"), so models add positional information.

• The original 2017 Transformer added fixed sinusoidal position signals to the token embeddings.
• GPT-2 added learned position embeddings, one learned vector for each position up to its limit of 1,024.
• Many recent models use rotary position embeddings (RoPE), which rotate the query and key vectors by an angle that depends on position, so that attention scores depend on how far apart two tokens are.
• Other schemes exist. The choice affects how well a model handles texts longer than those it saw during training.

In decoder-only models, the causal mask can also let the model infer some positional information implicitly. The details differ from model to model, but the shared idea is that position must be supplied, because attention does not provide it by itself.

A transformer is a stack of identical blocks. The original 2017 design had an encoder and a decoder; GPT-style chat models use only the decoder part ("decoder-only"). Each block has two sublayers: multi-head self-attention and a feed-forward network (MLP).

• Residual connections. The output of each sublayer is added to its input instead of replacing it. This gives every position a running vector, the residual stream, that each layer reads from and adds to. It also makes deep networks much easier to train.
• Layer normalization. Rescales each token's vector to keep the numbers in a stable range. The 2017 design applied it after each sublayer; GPT-2 and most later models apply it before ("pre-LN"), which tends to make training more stable.
• Attention sublayer. Moves information between positions.
• MLP sublayer. Two linear layers with a non-linear activation between them. It first widens the vector (typically by a factor of four: 768 to 3,072 in GPT-2 small) and then narrows it again. It is applied to each position separately. Research suggests that MLP layers act partly like stores of learned associations (Geva et al., 2021), although this is an active area of research.

After the last block, a final normalization and the unembedding matrix turn the vector of the last position into one score for every token in the vocabulary (section 14). GPT-2 small has 12 blocks and about 124 million parameters; larger models have more blocks and wider vectors.

Simplification: the diagram shows the main parts. Real models differ in details such as the normalization type, activation function and position scheme.

The final vector at the last position is multiplied by the unembedding matrix. The result is one score, called a logit, for every token in the vocabulary (50,257 in GPT-2). Logits can be any real numbers; they are not probabilities.

Softmax turns them into probabilities: p_i = e^(z_i) / Σ_j e^(z_j). All results are positive and add up to 1. Only differences between logits matter: adding the same number to all of them changes nothing.

Temperature (T) divides the logits before softmax. With T below 1 the distribution becomes sharper, so likely tokens become even more likely. With T above 1 it becomes flatter and less likely tokens get more chance. As T approaches 0, the choice approaches always taking the top token, and implementations treat T = 0 as "always pick the highest". Temperature does not change what the model knows; it changes how it samples from its own distribution. Very high temperatures often produce incoherent text.

Common sampling strategies:

• Greedy: always take the most probable token.
• Top-k: keep only the k most probable tokens, renormalize, and sample.
• Top-p (nucleus) sampling: keep the smallest set of tokens whose probabilities add up to at least p, and sample from it (Holtzman et al., 2019).

Chat products usually choose such settings for you.

A language model produces text one token at a time:

1. 1. Take the current text (the context) and run it through the model.
2. 2. Get a probability distribution over the next token.
3. 3. Choose a token (by sampling or by taking the most probable one).
4. 4. Append it to the text and repeat.

Generation stops when the model produces a special end-of-sequence token or reaches a length limit. Because every token depends on the ones before it, early choices influence everything that follows, and because choosing usually involves randomness, the same prompt can give different answers.

This is also why longer answers take longer: each new token needs another pass through the model. In practice, implementations store the keys and values of earlier tokens (the KV cache, see the Advanced track) so they do not have to be recomputed each time.

Simplification: the simulator lets you pick from a few candidate tokens. A real model computes a probability for every token in its vocabulary.

The context window is the maximum number of tokens the model can take into account at once. It includes your prompt, the earlier conversation, and the model's own answer so far. GPT-2 had a window of 1,024 tokens; modern models range from thousands to hundreds of thousands of tokens or more, depending on the model.

Limits exist because attention compares each token with all the earlier ones, so its cost grows with the square of the length in a straightforward implementation, and because the stored keys and values take memory.

What happens when the text does not fit depends on the application. It may refuse, cut off the oldest messages, or summarize them. Some architectures use sliding-window attention, where each token can see only a recent window.

Two further points:

• Fitting into the window does not guarantee that the model uses all the information equally well. Studies have found that models can be worse at using information placed in the middle of a long context (Liu et al., 2023).
• The model does not remember earlier, separate conversations unless the application stores information and supplies it again in the context.

The main goal in pretraining a language model is to predict the next token. The model sees a large amount of text. For each position, it receives the text before it and outputs a probability for the true next token. The loss (cross-entropy) is −log p(true token): small when the model gave the right token a high probability, large when it gave it a low one.

The loss is averaged over many positions. Backpropagation computes how the loss would change if each parameter changed slightly (the gradient), and an optimizer changes every parameter a little in the direction that lowers the loss. This is repeated for an enormous number of steps.

Notice that nothing in this objective says "be truthful" or "be helpful". A pretrained base model is a text continuer. Assistants such as ChatGPT go through further stages (section 20).

Training is the expensive part. Inference, the use of a trained model, only runs the forward pass with fixed weights. The model does not learn from your chat by changing its weights.

Simplification: the visualization updates a single weight to make the idea clear. Real training updates billions of parameters at once.

Imagine the loss as a function of all the parameters, a "landscape". The gradient points in the direction in which the loss increases fastest. To reduce the loss, the parameters take a small step in the opposite direction:

new value = old value − learning rate × gradient

The learning rate sets the step size: too small and training is slow; too large and it overshoots or becomes unstable.

Real training uses small random groups of examples (mini-batches, hence "stochastic" gradient descent), usually with adaptive optimizers such as Adam or AdamW and a schedule that changes the learning rate over time.

The ball rolling down a hill is a metaphor with limits. Real loss landscapes have billions of dimensions and do not look like a single smooth bowl.

Parameters are all the numbers a model learns: embedding matrices, attention matrices, MLP weights, biases and normalization scales. "7B" means about 7 billion of them.

Size has a concrete cost. If each parameter is stored in 16 bits (2 bytes), 7 billion parameters take about 14 GB and 70 billion take about 140 GB, just for the weights. Techniques such as quantization (Advanced track) reduce this.

More parameters usually give a model more capacity, but quality also depends on the amount and quality of training data, the amount of training computation, the architecture and the later training stages. Studies of scaling laws (Kaplan et al., 2020; Hoffmann et al., 2022) found that the loss falls in a predictable way as parameters, data and computation grow, and that for a fixed budget the model size and the amount of data should be increased together. Some earlier large models were trained on too little data for their size.

In mixture-of-experts models (Advanced track), the total number of parameters is larger than the number used for each token.

A model that has only been pretrained continues text. It does not follow instructions reliably. Assistants are usually built in several stages:

1. 1. Pretraining: predicting the next token on a very large collection of text. This gives the model broad knowledge of language and the world, and also its mistakes and biases.
2. 2. Supervised fine-tuning: further training on examples of good responses to instructions or questions, usually written or curated by people.
3. 3. Preference training: people (or models guided by rules) compare alternative answers, and the model is trained to produce the preferred kind. One approach is reinforcement learning from human feedback (RLHF): a reward model is learned from the comparisons and then used to improve the assistant (Ouyang et al., 2022). Direct preference optimization (DPO) is a simpler alternative (Rafailov et al., 2023).
4. 4. Deployment: the application adds instructions (system prompts), safety measures and sometimes tools such as search.

The exact methods vary between companies and are not always published. These stages change behavior, such as tone, helpfulness and refusals, but they do not turn the model into a database of verified facts (section 21).

A hallucination is fluent output that is false or unsupported by facts. The model was trained to produce plausible continuations, and nothing in the basic process checks claims against reality. When information is rare, missing or ambiguous, the model may still produce a confident-sounding guess. This is not lying: the model has no intention to deceive.

Later training stages can reduce hallucinations, but they do not remove them. A confident tone is not evidence that something is correct. Invented references and quotations are a well-known example.

What helps:

• Ask for sources and check them, since a model can invent sources.
• Put the relevant text in the prompt and ask the model to answer from it.
• Use systems that retrieve information from documents (retrieval-augmented generation, RAG) or use tools such as search and calculators.
• Verify important facts, especially in medicine, law, finance and safety.

A prompt is the text you give the model. The model does not change when you write a prompt; the prompt only changes the context it works from. Prompts that tend to work well contain:

• A clear task: what exactly you want done.
• Relevant context: the background the model cannot know.
• The desired format and length: list, table, number of words, language, tone.
• Examples when the style matters (known as few-shot prompting; Brown et al., 2020).
• The audience: who the answer is for.

For tasks that need several steps, asking for the steps to be shown can help, although this varies between models. If the first result is not right, improve the prompt and try again. There is no universal magic wording, and results can vary between models and between runs.

Note: the scores in this lab are a teaching rubric (clarity, context, format). They are not the output of a live model.

This walk-through follows a single token from input to output:

1. 1. The text is split into tokens, and each becomes an ID.
2. 2. The ID is looked up in the embedding table to get a vector.
3. 3. Position information is added.
4. 4. The vector passes through the blocks. In each block, attention gathers information from earlier positions and the MLP processes it, with the results added to the residual stream.
5. 5. A final normalization is applied, and the unembedding turns the last vector into logits.
6. 6. Softmax gives probabilities, and one token is chosen.
7. 7. That token is appended, and the process repeats for the next one.

Simplification: the numbers are illustrative. The order of operations matches real models.

• 1943: McCulloch and Pitts publish a mathematical model of a neuron.
• 1958: Frank Rosenblatt introduces the perceptron.
• 1986: Rumelhart, Hinton and Williams popularize backpropagation for training multi-layer networks.
• 1997: Hochreiter and Schmidhuber introduce the LSTM, a network for sequences.
• 2012: AlexNet wins the ImageNet competition by a large margin, a breakthrough for deep learning in vision.
• 2013: word2vec popularizes learned word embeddings.
• 2017: the Transformer is introduced in "Attention Is All You Need".
• 2018: GPT (OpenAI) and BERT (Google) show the power of pretraining transformers.
• 2019: GPT-2 shows strong text generation from a larger model.
• 2020: GPT-3 (175 billion parameters) shows that a large model can learn tasks from examples in the prompt.
• 2022: InstructGPT (March) shows how human feedback makes models follow instructions; ChatGPT is released publicly (30 November).
• 2023: GPT-4 is released (March), and open-weight models such as LLaMA spread widely.