This course exists to answer one question the site has never actually answered: what is happening, mechanically, inside the model between a prompt going in and a response coming out? Not how to phrase the prompt well — that's already covered, thoroughly, elsewhere.

What This Course Is Not

prompt1 and claude-adv1 already own the practical territory in full — this course doesn't re-teach either one. It sits underneath both, the same way imgai1 sat underneath image-generation prompting: that course didn't teach how to phrase an image prompt well either — it explained diffusion, the actual mechanism a prompt gets fed into. This course is the direct textual analogue.

Delivering on nlp1-10's Own Three Claims

nlp1-10's own capstone closed the NLP course by naming three real differences between its own hand-built pipelines and an LLM — scale, self-supervised pretraining taken further, and one flexible architecture instead of many task-specific pipelines. That chapter asserted all three honestly, but didn't have the room to prove any of them mechanically. This course does exactly that, one claim at a time.

Unpacking the Name — Large Language Model

• Large — a real, measurable claim about parameter count and training data volume, not marketing language. llm1-8 covers exactly what "large" buys you and why.
• Language — trained primarily on text (many current models are genuinely multimodal too, an honest scope note this course doesn't chase further).
• Model — a function that computes a probability distribution over what token comes next, not a database. This is a genuine, important contrast with nlp1-9's own GloVe: GloVe is a fixed lookup table — look up a word, get back a static vector, nothing more. An LLM is a function with billions of learned parameters that computes a fresh answer for every input; nothing is looked up, everything is computed.

A First, Deliberately Incomplete Preview

Take the prompt "The capital of France is". At a high level, without yet explaining any of the mechanics: the text is broken into pieces (llm1-2), each piece is converted into a vector that also encodes its position in the sequence (llm1-3), those vectors pass through many stacked layers that let every piece attend to every other piece (llm1-4/llm1-5), and the model ultimately produces a probability distribution over every possible next piece — with "Paris" receiving, if training went well, the highest probability of all. This entire path is deliberately left abstract here — the capstone (llm1-11) walks it in full, once every piece has been built.

Why This Actually Helps With Prompting, Without Re-Teaching It

Knowing this mechanism doesn't replace prompt1's own techniques — it explains why they work. Few-shot examples help because the model is a pattern-continuation engine at its core (llm1-7 makes this precise). Chain-of-thought helps because generation is genuinely sequential — each token really does depend on every token generated before it (llm1-11's own trace makes this concrete). This course is a companion to prompt1, not a replacement for it.

Hands-On Exercises

nlp1-9 named a real, honest limitation of pretrained embeddings: a fixed vocabulary, with genuine gaps. This chapter shows how LLMs close that gap for good — not by building a bigger vocabulary, but by changing what the vocabulary is made of.

A Genuinely Different Philosophy From nlp1-1's Own Pipeline

nlp1-1's preprocessing pipeline split text into whole words, stripped stopwords, and reduced words to their lemma — a linguistically-informed process, built around what a word "means." Byte-Pair Encoding (BPE) abandons that framing entirely. It doesn't ask what a word means — it asks what sequences of characters appear together often enough, across a massive corpus, to be worth their own token. No stopword removal, no lemmatization: raw frequency statistics decide what counts as a unit.

The BPE Algorithm

BPE started life as a data-compression algorithm and was repurposed for tokenization. The core loop:

1. Start with a vocabulary of individual characters (or bytes).
2. Count every adjacent pair of symbols across the training corpus.
3. Merge the single most frequent pair into one new symbol; add it to the vocabulary.
4. Repeat, thousands of times, until the vocabulary reaches a target size.

# simplified BPE training loop
vocab = set(all_characters_in_corpus)
corpus = split_into_characters(training_text)

for step in range(num_merges):
    pairs = count_adjacent_pairs(corpus)
    best_pair = max(pairs, key=pairs.get)     # the single most frequent pair
    vocab.add(merge(best_pair))               # e.g. ("t", "ion") -> "tion"
    corpus = apply_merge(corpus, best_pair)    # replace every occurrence

Common fragments like "tion", "ing", or "un" earn their own token early, since they occur constantly across a large corpus. Rare words never get merged into single tokens at all — they stay broken into smaller, more common pieces.

A Worked Example

Resolving nlp1-9's Own Gap, For Good

Byte-Level BPE

GPT-2 and its successors operate on raw UTF-8 bytes rather than Unicode characters — a further guarantee. Since every possible string, in every script, emoji included, is representable as a sequence of bytes, byte-level BPE never encounters a character it fundamentally cannot represent, even before any merges are learned. This is what makes the "no true out-of-vocabulary input" guarantee absolute rather than merely "very good in practice."

Vocabulary Size — A Real Trade-Off

Real models settle in the tens of thousands to roughly one hundred thousand tokens — large enough that common words and word-fragments get their own single token, small enough that the vocabulary itself stays learnable.

An Honest Limitation: Tokens Aren't Meaning Units

Hands-On Exercises

nlp1-8 closed with an honest, deliberately unresolved gap: self-attention has no inherent sense of token order. This chapter delivers the fix in full — and along the way, revisits what an "embedding" even means once it's trained as part of one enormous model rather than as a separate step.

Token Embeddings — Trained End-to-End, Not Frozen

Every token ID produced by llm1-2's own BPE vocabulary maps to a learned vector through an embedding lookup table — mechanically similar to nlp1-5's own trainable nn.Embedding. The real difference is what trains it: nlp1-9's own GloVe vectors were pretrained separately and then either frozen or fine-tuned as a distinct step. An LLM's own token embeddings are trained jointly, from the very start, alongside every other parameter in the entire network — there is no separate embedding-training phase at all.

The Problem This Chapter Actually Solves

Per nlp1-8: swap two tokens in a sequence, and self-attention computes the exact same set of pairwise relationships either way. Nothing about the raw token embeddings, on their own, encodes where in the sequence a token appears. Positional encoding exists to inject that missing information before attention ever runs.

Sinusoidal Positional Encoding — The Original Fix

The original Transformer paper's own solution: a fixed, non-learned pattern of sine and cosine waves, one pair of frequencies per pair of embedding dimensions, added directly to each token's embedding based on its position.

PE(pos, 2i)   = sin(pos / 10000^(2i/d))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d))

# pos = the token's position in the sequence (0, 1, 2, ...)
# i   = which pair of embedding dimensions this is
# d   = the total embedding dimension

Each position gets a unique, deterministic "fingerprint" — no two positions ever produce the same pattern. The specific choice of sine/cosine pairs has a genuinely elegant mathematical property: the encoding for any fixed relative offset (position p+k relative to position p) can be expressed as a simple linear transformation of the encoding at position p, which makes it easier for the model to learn to attend by relative position, not just absolute position.

Learned Positional Embeddings — GPT's Own Approach

GPT and many later models take a simpler route: instead of a fixed formula, learn a separate embedding vector for each position index (0 through some maximum), trained jointly with everything else, exactly like the token embeddings themselves.

Combining Token and Position

token_embedding = embedding_table[token_id]           # llm1-2's token, looked up
position_embedding = positional_encoding[position]     # sinusoidal or learned
input_vector = token_embedding + position_embedding     # what actually enters layer 1

Revisit nlp1-4's own "dog bites man" vs. "man bites dog" example. Before any attention runs at all, "dog" at position 0 and "dog" at position 2 (in the reversed sentence) now receive genuinely different input vectors, purely because their positional components differ — the exact information self-attention alone could never supply on its own, now supplied directly at the input.

Hands-On Exercises

nlp1-8 introduced attention conceptually — a score, a softmax weight, a blended context vector. That was enough to explain why attention works. This chapter shows how it's actually computed, with real matrices.

Recap: nlp1-8's Own Conceptual Version

# nlp1-8's own conceptual attention score
scores = [dot(decoder_state, encoder_state_i) for encoder_state_i in encoder_states]
weights = softmax(scores)
context = sum(w * s for w, s in zip(weights, encoder_states))

That version compared one decoder state against a set of encoder states. Self-attention needs something more general: every token comparing itself against every other token in the same sequence, including itself. This is where Query, Key, and Value come in.

Query, Key, Value — What Each One Actually Is

For every input vector (from llm1-3 — a token embedding plus its positional encoding), the model computes three separate vectors by multiplying it against three separate, learned weight matrices:

Q = X @ W_Q    # Query — "what am I looking for?"
K = X @ W_K    # Key    — "what do I contain, for others to match against?"
V = X @ W_V    # Value  — "what do I actually offer, if attended to?"

Every single token produces all three — its own Query, its own Key, its own Value — using the exact same three weight matrices (W_Q, W_K, W_V), shared across the whole sequence and learned during training like every other parameter.

Scaled Dot-Product Attention

scores = (Q @ K.T) / sqrt(d_k)    # every Query compared against every Key
weights = softmax(scores, axis=-1)  # normalized per row — one weight distribution per token
output = weights @ V                 # weighted blend of every token's Value

Q @ K.T computes a similarity score between every token's Query and every other token's Key, in one matrix multiplication — nlp1-8's own single dot-product score, generalized to every pair at once. Dividing by sqrt(d_k) (the square root of the Key dimension) keeps the scores from growing too large as dimensionality increases, which would otherwise push softmax into regions with vanishingly small gradients. Softmax turns each token's own row of scores into a proper probability distribution — exactly nlp1-8's own attention weights, generalized from one decoder step to every token simultaneously. The final multiplication by V blends every token's Value according to those weights, producing one output vector per token.

Why Three Separate Matrices, Not One

Self-Attention, Specifically

This is called self-attention because Q, K, and V are all derived from the same sequence — every token attends to every token in its own input, itself included. This is the exact mechanism nlp1-8 introduced conceptually as "applying attention within a single sequence," now written out as real matrix operations rather than described in prose.

Hands-On Exercises

nn1-9 and nlp1-8 each previewed self-attention and each explicitly deferred "the full multi-head, multi-layer Transformer" to this course. This is that chapter — the single largest deferred-technical-depth thread either course carried.

Why One Attention Computation Isn't Enough

llm1-4's own self-attention computes one set of relationships per sequence — one Query, Key, and Value projection, one resulting pattern of attention weights. Real language has many kinds of relationships happening at once inside the same sentence: which word a pronoun refers to, which verb a subject belongs to, which adjective modifies which noun. Forcing a single attention computation to capture all of these simultaneously is a real constraint — exactly the kind llm1-4's own finding-box already flagged for forcing Query and Key into one shared vector.

Multi-Head Attention

The fix: split the embedding dimension into several smaller heads, each with its own independent set of learned W_Q/W_K/W_V matrices, each computing llm1-4's own scaled dot-product attention independently and in parallel.

heads = []
for i in range(num_heads):
    Q_i = X @ W_Q[i]      # each head gets its own learned projections
    K_i = X @ W_K[i]
    V_i = X @ W_V[i]
    heads.append(scaled_dot_product_attention(Q_i, K_i, V_i))

multi_head_output = concat(heads) @ W_O    # concatenate, then project back down

Each head is free to specialize — one might learn to track subject-verb agreement, another might learn coreference (which noun a pronoun points back to), another might attend mostly to nearby, local context. Concatenating every head's own output and projecting it back through W_O combines all these specialized views into a single vector per token, richer than any one head could produce alone.

The Feed-Forward Sublayer

Attention's own job is mixing information across tokens — deciding what each token should attend to. After attention, every token's own resulting vector independently passes through a small two-layer network, applied identically and separately to each position:

FFN(x) = max(0, x @ W1 + b1) @ W2 + b2   # (or GELU instead of the ReLU shown here)

This is where genuine non-linear transformation of each token's own representation happens, independent of every other token — attention decides what to look at; the feed-forward layer decides what to do with it, position by position.

Residual Connections

Real Transformers stack dozens of these blocks — GPT-3 uses 96 layers. Very deep stacks risk exactly the kind of degraded gradient flow nn1-6's own training material warned about for deep networks generally. The fix here: each sublayer's output is added to its own input, rather than replacing it outright.

x = x + MultiHeadAttention(x)
x = x + FeedForward(x)

Layer Normalization

Each sublayer's input is also normalized — rescaled to have stable mean and variance across its own feature dimension, per token — keeping training numerically well-behaved at depth. Most modern models apply this normalization before each sublayer (Pre-LN) rather than after (Post-LN, the original Transformer paper's own choice), since Pre-LN has proven more stable to train at very large depth.

Assembling One Full Transformer Block

def transformer_block(x):
    x = x + multi_head_attention(layer_norm(x))
    x = x + feed_forward(layer_norm(x))
    return x

for _ in range(num_layers):        # dozens of these, stacked
    x = transformer_block(x)

This is the complete picture: llm1-3's own embedded, position-encoded input vectors enter at the bottom, pass through this exact block repeated dozens of times, and emerge the other end having been repeatedly reshaped by multi-head attention and per-token feed-forward transformation, with residual connections and layer norm keeping the whole stack trainable.

Hands-On Exercises

llm1-5 built one Transformer block. The 2017 "Attention Is All You Need" paper nlp1-8 already cited actually proposed stacking these blocks into an encoder-decoder pair, for machine translation specifically — nlp1-8's own real motivating task. This chapter surveys the three architecture families that emerged from arranging Transformer blocks differently, and explains why one of them became dominant.

Three Families, Three Attention Patterns

Encoder-Only: BERT's Bidirectionality

BERT (2018) stacks only encoder-style Transformer blocks, where every token can attend freely to every other token in the sequence, in both directions. This is the exact Transformer-era counterpart of nlp1-7's own bidirectional LSTM — both exist to let a token's own representation be informed by context on both sides, not just what came before. BERT trains via masked language modeling: randomly hide some tokens in the input and predict them using the full surrounding context, generalizing nlp1-5's own context-prediction training signal to a full Transformer stack.

Encoder-Decoder: T5 and the Original Transformer

This is the architecture nlp1-8 already introduced conceptually — an encoder reads the entire input sequence (bidirectionally), and a decoder generates the output sequence one token at a time, at each step cross-attending back to the encoder's own output. T5 generalizes this into a "text-to-text" framing, treating every task — translation, summarization, classification — as converting one string of text into another.

Decoder-Only: Causal Masking

GPT's own family uses no separate encoder at all — one single stack of Transformer blocks, with a critical modification to llm1-4's own attention formula: a causal mask that forces each token to attend only to itself and tokens before it, never tokens that come later.

scores = (Q @ K.T) / sqrt(d_k)
scores = scores.masked_fill(future_positions, -inf)   # block attention to later tokens
weights = softmax(scores, axis=-1)                      # -inf becomes exactly 0 after softmax
output = weights @ V

Setting future-position scores to negative infinity before softmax guarantees their resulting attention weight is exactly zero — a token generating its own prediction can never "peek" at tokens that haven't been generated yet. This single change is what makes autoregressive generation coherent: predicting each next token uses only what has genuinely already been produced.

Why Decoder-Only Became the Dominant General-Purpose Shape

This also explains the simplicity advantage: one stack, one training objective (predict the next token), rather than BERT's separate masked-prediction objective or T5's split encoder/decoder training. Because generating a coherent next token requires the model to have effectively "understood" everything so far, useful general-purpose representations emerge as a side effect of the generative objective alone — no separate understanding-specific objective needs to be designed in.

The GPT Lineage

This decoder-only, causally-masked architecture is the actual mechanism behind historyai3-7's own GPT-1 through GPT-3 lineage namecheck — the architecture story, not yet the training story. How pretraining at real scale actually works is llm1-7's own job; how GPT-3 became ChatGPT through fine-tuning and RLHF is llm1-9's.

Hands-On Exercises

llm1-6 named next-token prediction as GPT's own training objective without unpacking it. This chapter does — and delivers, with real numbers, nlp1-10's own "self-supervised pretraining taken further" claim.

The Self-Supervised Thread, Traced From nlp1-5

nlp1-5's word2vec and nlp1-9's GloVe both trained on a self-supervised signal — predict a word from its surrounding context, with no hand-labeled data required. LLM pretraining is the same underlying idea, scaled from "predict one missing word in a local window" to "predict every next token across an entire corpus," using the full Transformer stack llm1-5 built rather than a shallow lookup table.

Causal Language Modeling — The Actual Objective

Given a training sequence, the model's job at every single position is to predict the token that actually comes next, using only the tokens before it — exactly the constraint llm1-6's own causal masking enforces.

sequence = ["The", "capital", "of", "France", "is", "Paris"]

# one training sequence yields a prediction target at every position:
# "The"                                  -> predict "capital"
# "The capital"                          -> predict "of"
# "The capital of"                       -> predict "France"
# "The capital of France"                -> predict "is"
# "The capital of France is"             -> predict "Paris"

A single sequence of N tokens yields N separate next-token training signals, all computable in one forward pass — because llm1-6's own causal mask already prevents any position from seeing ahead, every position's prediction can be trained simultaneously, in parallel, rather than one at a time. This is a genuine efficiency advantage over nlp1-6's own strictly sequential LSTM training, where each step had to wait for the one before it.

The Loss Function

At each position, the model produces a probability distribution over the entire vocabulary (llm1-2's own tens of thousands of subword tokens) via softmax, and cross-entropy loss compares that distribution against the actual next token.

Contrast: Causal LM vs. BERT's Masked LM

This is the concrete, mechanical reason llm1-6's own architecture split holds: BERT's bidirectional context is exactly what makes coherent left-to-right generation impossible for it — predicting a token using information from tokens that come after it has no equivalent at real generation time, when those later tokens don't exist yet. GPT's causal objective has no such mismatch.

What "Scale" Actually Means

Real pretraining corpora span hundreds of billions to trillions of tokens — web text, books, code, and more. Real models range from hundreds of millions to hundreds of billions of parameters. This is nlp1-10's own "scale" claim, given its first real numbers; llm1-8 covers why more of each helps, and by how much, in a predictable way.

An Honest Note: This Produces a Base Model, Not an Assistant

A model trained purely on next-token prediction learns to continue text plausibly — it has no built-in notion of "follow this instruction" or "refuse this harmful request." Turning a raw pretrained base model into something that behaves like an assistant is llm1-9's own job: fine-tuning and RLHF.

Hands-On Exercises

llm1-7 gave real numbers for what "scale" means — but not why more of it helps, or by how much. This chapter closes that gap: scale isn't a vague intuition, it's a measured, predictable relationship.

Loss Improves as a Power Law, Not a Guess

As model size (parameters, N), dataset size (tokens, D), and training compute (C) each increase, the cross-entropy loss from llm1-7's own training objective decreases smoothly, following a power-law relationship:

Loss(N) ≈ (N_c / N) ^ alpha_N

# plotted on a log-log axis, this relationship is a straight line —
# loss keeps falling predictably as N grows, across many orders of magnitude

This is what "scaling laws" literally means: laws, discovered empirically (Kaplan et al., 2020), that govern how scale relates to performance. Not a diminishing-returns cliff, not a random walk — a genuinely predictable curve.

Why Predictability Is the Practically Important Part

Kaplan (2020) vs. Chinchilla (2022) — A Real Correction

Kaplan et al.'s original 2020 scaling laws suggested that, for a fixed compute budget, model size should be scaled up much faster than dataset size — leading to very large models trained on comparatively modest amounts of data. GPT-3 is a real example of this era's approach. DeepMind's 2022 Chinchilla paper (Hoffmann et al.) found this was actually suboptimal.

The real finding: for a given compute budget, there's an optimal ratio of model size to dataset size — not "bigger model always wins," and not "more data always wins," but a genuine balance. Many large models from the Kaplan-influenced era were significantly undertrained relative to their own parameter count.

Completing nlp1-10's "Scale" Claim

nlp1-10 asserted that scale matters; llm1-7 gave it real numbers; this chapter supplies the actual mathematical relationship — a measured power law, with a real, historically-corrected understanding of how to spend a compute budget wisely across model size and data size, rather than "throw more of everything at it."

An Honest Debate: Emergent Abilities

Some capabilities — multi-step arithmetic, certain reasoning tasks — appear to show up suddenly at a scale threshold, rather than improving gradually. This was initially presented as evidence that scale produces genuinely new, qualitatively different capabilities in a discontinuous way.

What Scaling Laws Don't Cover

Scaling laws describe how pretraining loss improves with scale — next-token-prediction accuracy, nothing more. They say nothing directly about usefulness as an assistant, safety, or alignment with human intent. A model with excellent pretraining loss is still, per llm1-7's own honest note, only a base model. Turning predictable loss improvement into a genuinely useful, well-behaved assistant is llm1-9's own job.

Hands-On Exercises

llm1-7 ended with an honest note: pretraining alone produces a base model — a raw next-token predictor with no notion of following an instruction or refusing a harmful request. This chapter covers the real, three-step mechanism that turns a base model into an assistant — the actual process behind historyai3-7's own GPT-3-to-ChatGPT narrative.

Resolving nlp1-9's Own Distinction, at Full Scale

Step 1: Supervised Fine-Tuning (SFT)

Humans write high-quality examples of what a good response to an instruction looks like — a much smaller, carefully curated dataset than llm1-7's own massive raw pretraining corpus. The base model continues training on these prompt/response pairs, using the identical next-token-prediction objective from llm1-7 — nothing about the architecture changes (llm1-6's own flexibility point resurfaces here), only the data being trained on.

# same objective as llm1-7, different data
# pretraining data:     raw internet text, books, code
# SFT data:              curated (instruction, ideal_response) pairs

SFT shifts the model's own behavior toward instruction-following, but it only teaches imitation of the specific examples shown — it can't, by itself, capture the subtler, harder-to-write-down human preferences about what makes one otherwise-reasonable response genuinely better than another.

Step 2: Reward Modeling

To capture those preferences, a separate model is trained. The SFT model generates several different responses to the same prompt; humans rank them by preference; a reward model is trained to predict that ranking — given a prompt and a response, output a single scalar score estimating how much a human would prefer it.

responses = [sft_model.generate(prompt) for _ in range(k)]   # several candidate responses
ranking = human_rank(responses)                                # humans order them by preference
reward_model.train(prompt, responses, ranking)                  # learn to predict the ranking

Step 3: Reinforcement Learning from Human Feedback (RLHF)

The SFT model is fine-tuned further, this time via reinforcement learning: it generates a response, the trained reward model scores it, and the model's own parameters are updated (via Proximal Policy Optimization, PPO) to increase the likelihood of generating higher-reward responses in the future.

The Actual Mechanism Behind the ChatGPT Moment

historyai3-7 already named the real, historical November 2022 ChatGPT launch and its RLHF namecheck. This three-step pipeline — SFT, then reward modeling, then RLHF/PPO — is that mechanism, made concrete: GPT-3 (a base model, exactly per llm1-7's own honest note) became ChatGPT through this pipeline, not through additional pretraining or additional scale. llm1-8's own scaling laws describe how pretraining loss improves with scale — a completely separate axis from this chapter's own instruction-following and preference-alignment transformation.

An Honest Limitation

Hands-On Exercises

llm1-3 flagged, and deferred, exactly why a context window has a hard limit. This chapter delivers that in full — and gives two of the most commonly hand-waved LLM behaviors, hallucination and knowledge cutoff, real mechanical explanations instead.

What a Context Window Actually Is

The maximum number of tokens (llm1-2's own BPE tokens) a model can process in one forward pass. Two genuinely separate mechanisms both cap this number:

1. Positional encoding's own limit — llm1-3's own deferred warning: a learned positional embedding table simply has no entry beyond whatever maximum position it was trained with.
2. The computational cost of self-attention itself — this chapter's own new material, and the deeper, more fundamental constraint.

Quadratic Attention Cost

Recall llm1-4's own scaled dot-product attention: Q @ K.T computes a similarity score between every pair of tokens. For a sequence of length N, that's an N × N matrix of scores — both the compute and the memory required scale with N², not N.

Hallucination, Explained Mechanically

Per llm1-7, a model is trained to predict the most probable next token given context — nothing more. It has no built-in mechanism for verifying factual truth, only for producing plausible-sounding continuations shaped by patterns learned during pretraining.

Knowledge Cutoff, Explained Mechanically

Per llm1-7, pretraining uses a fixed, finite corpus, collected up to some point in time. Everything the model "knows" is entirely encoded in its trained parameters, shaped exclusively by whatever text existed in that corpus. Nothing about the pretraining process gives the model any live, ongoing access to information published after its own training data was collected — there is no built-in internet connection, no update mechanism running in the background.

Anything that happened after the corpus's own collection date is simply absent from the patterns the model learned — not because the model is vaguely "unaware," but because that information never existed in any data used to shape its parameters at all. Retrieval-augmented generation, already covered in claude-adv1, works around this by injecting live external information directly into the prompt at inference time — a way of supplying missing context, not a way of updating the model's own trained parameters.

Closing the Loop Back to Chapter 1

llm1-1 opened by claiming this course would explain why prompt1's own techniques work, not replace them. Techniques like providing sources in a prompt, or explicitly instructing a model to say "I don't know" when uncertain, work precisely because of the mechanisms covered in this chapter — they compensate for a model with no built-in fact-checker and no live knowledge feed, exactly as described here, mechanically, rather than as an unexplained quirk.

Hands-On Exercises

llm1-1 opened with a deliberately incomplete preview of "The capital of France is", promising the full trace would wait until every piece was built. Every piece is now built. Here is the full trace.

Step 1 — Tokenization (llm1-2)

prompt = "The capital of France is"
tokens = ["The", " capital", " of", " France", " is"]   # BPE subword tokens
token_ids = [464, 3139, 286, 4881, 318]                    # looked up in the vocabulary

llm1-2's own Byte-Pair Encoding breaks the raw prompt string into subword tokens, each mapped to an integer ID in the model's fixed vocabulary — no out-of-vocabulary risk, per that chapter's own byte-level fallback guarantee.

Step 2 — Embedding & Positional Encoding (llm1-3)

x = embedding_table[token_ids]              # each token ID -> its learned vector
x = x + positional_encoding[0:5]              # position 0..4 added, per token

Each token ID is looked up in the jointly-trained embedding table, then combined with its own positional encoding — the exact mechanism that gives the model any sense of order at all, resolving nlp1-8's own deferred gap. This produces the actual vectors that enter the first Transformer block.

Step 3 — Multi-Head Self-Attention Across Stacked Layers (llm1-4 / llm1-5 / llm1-6)

for layer in range(num_layers):                     # dozens of stacked blocks
    x = x + multi_head_attention(layer_norm(x), causal_mask=True)
    x = x + feed_forward(layer_norm(x))

At every layer, each token's own vector is reshaped by causally-masked (llm1-6) multi-head attention (llm1-5), built from the Query/Key/Value mechanism (llm1-4). The token at position 4 (" is") can attend to itself and every earlier token — never anything later, since nothing later exists yet in this generation step. By the final layer, its own vector has been shaped by learned relevance to "The", "capital", "of", and "France", repeatedly, across every stacked block.

Step 4 — Next-Token Prediction (llm1-7 / llm1-8)

logits = final_layer_output[-1] @ output_projection    # project to vocabulary size
probabilities = softmax(logits)
# probabilities["Paris"] ≈ highest, if pretraining (llm1-7) at sufficient scale (llm1-8) went well

The final vector at the last position is projected into a probability distribution over the entire vocabulary — llm1-7's own causal language modeling objective, at generation time. If the model was pretrained on enough data, at enough scale, following llm1-8's own measured power-law relationship, "Paris" receives the highest probability of any token in the vocabulary.

Step 5 — The Autoregressive Loop (llm1-6)

The predicted token is appended to the sequence, and the entire process — embed, attend across every layer, predict — repeats to generate the token after that, one token at a time, each one causally valid given only what has genuinely been generated so far.

An Honest Aside: Real Deployments Aren't Raw Completions

Chapter Attribution Table

Closing the Loop on nlp1-10's Three Claims

This is also the LLM analogue of what imgai1 did for image models, exactly as llm1-1 set out — a full mechanism, traced end to end, sitting underneath prompt1's and claude-adv1's own practical territory rather than replacing it.

Hands-On Exercises

Scope Note — What This Course Deliberately Doesn't Cover