How Large Language Models Work: A Clear Technical Explanation

How Large Language Models Work: A Clear Technical Explanation

A large language model (LLM) is a neural network trained to predict the next word in a sequence, at a scale large enough that the skill generalizes into writing, reasoning, and code. "It's trained on lots of text" explains an LLM the way "the piano was pressed repeatedly" explains a sonata — technically true, completely uninformative.

This guide walks through the real mechanics: tokenization, the transformer architecture, training, and alignment — no PhD required, nothing oversimplified to the point of being wrong.

Step 1: Text as Numbers (Tokenization)

Tokenization converts text into a sequence of integer IDs, because neural networks operate on numbers, not letters. Think of it as a translator that turns every sentence into a string of ID numbers pulled from a fixed dictionary of roughly 50,000 entries.

# Using OpenAI's tiktoken library (same tokenizer as GPT-4)
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4")

text = "The transformer architecture changed everything."
tokens = enc.encode(text)
print(f"Token IDs: {tokens}")
# [791, 43678, 18112, 5614, 4395, 13]

# Decode back
decoded = [enc.decode([t]) for t in tokens]
print(f"Token strings: {decoded}")
# ['The', ' transformer', ' architecture', ' changed', ' everything', '.']

print(f"Token count: {len(tokens)}")

Modern LLMs use subword tokenization (Byte Pair Encoding or SentencePiece):

• Common words collapse to one token — "the" becomes a single ID, [791].
• Rare words split into pieces — "cryptocurrency" breaks into ["crypto", "currency"].
• Any input stays representable, even invented words, while the vocabulary stays a manageable ~50K entries.

The model processes tokens, not words or characters. That's why GPT-4's cost, speed, and context window are all measured in tokens, not words — a word isn't always one unit of billing.

Step 2: Embeddings (Tokens as Vectors)

An embedding is a list of numbers that represents a token's meaning as a point in space. Picture a map where every word gets a coordinate, and words with related meanings end up as neighbors.

Vocabulary size: 50,000 tokens
Embedding dimension: 768 (BERT-base) to 12,288 (GPT-4 estimated)

Token "king"     → [0.42, -0.73, 0.15, 0.88, ...]  (768 numbers)
Token "queen"    → [0.39, -0.71, 0.18, 0.85, ...]  (similar direction)
Token "man"      → [0.11, -0.82, 0.55, 0.72, ...]
Token "woman"    → [0.08, -0.80, 0.58, 0.69, ...]

Famous example:
king - man + woman ≈ queen  (vector arithmetic captures semantic relationships)

The model learns these embeddings during training — no one hand-codes them. Afterward, "cat" and "feline" sit close together in this space; "cat" and "spaceship" sit far apart.

Step 3: The Transformer Architecture

The transformer is the architecture behind every modern LLM. Unlike older RNNs, which read one token at a time in sequence, a transformer processes an entire sequence in parallel and uses attention to figure out which words matter to which.

Self-Attention

Self-attention is the mechanism where every token weighs how relevant every other token in the sequence is to understanding it. It's the same thing a reader does when a pronoun appears — scanning back to figure out what "it" refers to.

Input: "The bank approved the loan for the river bank"
                                           ↑
"bank" (position 8) attends to all other tokens:
- "bank" (position 2): high attention (same word, disambiguation context)
- "river" (position 7): high attention (context: this bank is a riverbank)
- "loan" (position 5): low attention (this sentence is about a different bank)
- "The" (position 1): low attention (not informative for disambiguation)

Result: the embedding for "bank" at position 8 incorporates context
        showing it means a landform, not a financial institution

Mathematically, attention computes three vectors from each token's embedding:

• Query (Q): "What am I looking for?"
• Key (K): "What do I contain?"
• Value (V): "What information do I carry?"

Attention score = softmax(Q · Kᵀ / √d) · V

Multi-Head Attention

Multi-head attention runs several attention mechanisms in parallel, each specializing in a different kind of relationship. It's like having several editors read the same sentence — one checks grammar, another checks references, another checks meaning — all at once.

Head 1: Tracks syntactic dependencies (subject-verb agreement)
Head 2: Resolves coreference ("it" refers to "the model")
Head 3: Identifies semantic relationships (synonyms, antonyms)
Head 4-8: Other patterns the model discovered during training

Transformer Layer Stack

A transformer model is dozens to hundreds of these attention layers stacked on top of each other, each refining the representation the last one produced.

Input tokens
    ↓
Token Embeddings + Positional Encoding
    ↓
[Layer 1]
  Multi-Head Self-Attention → Add & Normalize
  Feed-Forward Network → Add & Normalize
    ↓
[Layer 2]
  Multi-Head Self-Attention → Add & Normalize
  Feed-Forward Network → Add & Normalize
    ↓
[... N layers ...]
    ↓
[Layer N]
    ↓
Output head (predict next token probabilities)

GPT-3 has 96 layers; GPT-4 is estimated at several hundred. Early layers capture surface features like grammar, later layers capture abstract meaning — the same progression a student goes through from spelling to argument structure.

Step 4: Pre-Training (Learning from Text)

Pre-training is the stage where a model learns language and world knowledge purely by predicting the next word, across hundreds of billions of examples, with no human labels involved.

Given: "The capital of France is"
Predict: "Paris"

Given: "Paris is a city located in"
Predict: "Europe" or "France" or "western"

Training on hundreds of billions of examples like this, the model learns:
- Language patterns (grammar, syntax)
- World knowledge (facts, relationships)
- Reasoning patterns (if-then, cause-effect)
- Coding patterns (syntax, algorithms)
- And much more

The training data scale is staggering:

• GPT-3: ~300 billion tokens
• LLaMA 2: 2 trillion tokens
• GPT-4: estimated 10+ trillion tokens
• Gemini 1.5: estimated 10+ trillion tokens

One trillion tokens is roughly 750 billion words — about 5 million books' worth of text.

With enough data and parameters, emergent behaviors appear: capabilities nobody explicitly trained for, but that surface from the sheer complexity of the learned representations. Reasoning, translation, code generation, and multi-step problem solving all emerged this way — nobody wrote a "reasoning module."

Step 5: Instruction Fine-Tuning

Instruction fine-tuning turns a raw text-predictor into an assistant that follows commands instead of just continuing a sentence. A base model given "Write a poem about the ocean" might continue with more prompt text instead of a poem — fine-tuning teaches it what a prompt actually wants.

Training examples for instruction fine-tuning:

[Instruction]: Summarize this article in 3 bullet points.
[Article]: [long article text]
[Response]:
• First key point...
• Second key point...
• Third key point...

[Instruction]: Write a Python function that reverses a string.
[Response]: 
def reverse_string(s):
    return s[::-1]

This teaches the model the instruction-following format: treat text between [Instruction] and [Response] as a directive, not as text to continue.

Step 6: RLHF (Reinforcement Learning from Human Feedback)

RLHF (Reinforcement Learning from Human Feedback) is the training stage where human preference ratings teach a model to be helpful, not just coherent. It's the difference between a model that writes grammatically correct nonsense and one that actually answers your question well.

Stage 1: Supervised Fine-Tuning (SFT)
- Human demonstrators write high-quality responses to prompts
- Model fine-tuned to mimic these responses

Stage 2: Reward Model Training
- Model generates multiple responses to the same prompt
- Human raters rank the responses (which is better?)
- A separate reward model trains on these preferences
- Reward model learns to score responses like humans would

Stage 3: PPO (Proximal Policy Optimization)
- The fine-tuned model generates responses
- Reward model scores each response
- Model is updated to generate higher-scoring responses
- Constraint: don't deviate too far from the SFT model (prevents reward hacking)

RLHF is what makes models:

• More helpful — the reward model pushes toward useful, actionable answers instead of technically-correct-but-useless ones.
• Less harmful — responses that risk dangerous information get penalized during training.
• More honest — admitting uncertainty gets rewarded over confidently making things up.

Why LLMs Hallucinate

A hallucination is a confident, fluent, factually wrong statement — the predictable output of a model with no built-in fact-checker. It generates text token by token by sampling from a probability distribution, not by looking anything up.

Incorrect mental model: LLM → lookup database → retrieve fact → state fact
Correct mental model:   LLM → predict what text is statistically likely 
                                given the preceding context

Ask about a rare fact — a specific paper's authors, a small company's founding date — and the model generates whatever would plausibly complete that sentence, based on training patterns, not lookup. The result reads exactly as confident as a correct answer.

• RAG grounds the answer in real documents — retrieve relevant text before generating, instead of relying on memorized patterns.
• Tool use replaces guessing with lookup — let the model call an API or database for the actual fact.
• Prompting for uncertainty reduces false confidence — explicitly instructing "say so if you're not sure" measurably helps.
• Citations force traceability — requiring a source per claim makes fabrication easier to catch.

Key Concepts at a Glance

The Bottom Line

LLMs are pattern-completion machines, not databases and not reasoning engines in the traditional sense. They generate text statistically consistent with their training — and that alone produces remarkably capable behavior across writing, code, and analysis.

Three pieces explain why capability exploded after 2017: the transformer architecture, training at massive scale, and RLHF alignment on top. Understanding all three tells you exactly where these models are strong (pattern completion at scale) and where they break (facts outside the pattern).

For how these models compare in practical use, see our GPT-4 vs Claude vs Gemini comparison. For building applications with LLMs, see our AI development guides.

Further Reading

• AI Hallucination Explained: Why LLMs Make Things Up (and How to Fix It)
• Embeddings Explained: How AI Converts Words to Numbers That Mean Something
• Fine-Tuning LLMs: When to Do It and How to Do It Right
• GPT-4 vs Claude vs Gemini: Which AI Model Is Best in 2025?
• LLM Context Window Explained: Why It Matters and How to Use It
• 20 ChatGPT Prompts for E-commerce Product Descriptions
• The Mega Prompt Method: Getting Entire Projects Done in One AI Session
• ChatGPT for Copywriting: AIDA, PAS, and Beyond