Visualizing transformers and attention | Talk for TNG Big Tech Day '24

Overview

Grant Sanderson explains how GPT-style Transformers turn text into token vectors, use stacked attention and feed-forward layers to build context, and predict the next token. He traces attention through learned query, key, and value matrices, dot products, softmax weights, causal masking, and multi-head updates, then connects the architecture’s parallel computation and self-supervised training to its ability to scale across text, images, and sound.

Key takeaways

A GPT-style Transformer generates text by repeatedly sampling a next-token distribution, appending the selected token, and running the expanded sequence through the model again.
Attention computes query–key dot products, converts them to normalized weights with softmax, and uses those weights to combine value vectors into contextual updates.
Causal masking sets future-token attention scores to negative infinity before softmax, preventing information leakage while preserving normalized attention weights.
Standard self-attention has a quadratic context-length cost, which is why long-context models require more efficient attention variants and why tokenization affects compute requirements.
Multiple independent attention heads can learn different token relationships in parallel, while repeated attention and feed-forward layers progressively enrich token representations.
Next-token prediction enables large-scale self-supervised pretraining without manually labeling every example, and the token-vector framework can also represent image patches and sound segments.

Chapters

0:00 Next-Token Prediction Turns a Language Model into a Chatbot

A GPT-style model assigns probabilities to possible next tokens, then generates text by sampling a token and appending it to the input.
Temperature controls how much randomness enters sampling: choosing only the most likely token can produce stilted text.
A chatbot prompt frames user input as a conversation with a helpful assistant; the model then generates the reply one token at a time.

4:11 From Tokens to Transformer Layers and Training Loss

Text is divided into tokens—often words, word pieces, or punctuation—and each token begins as a learned embedding vector.
Attention lets token vectors exchange contextual information, while multi-layer perceptrons add further transformations; Sanderson notes that most model parameters are in the perceptrons.
GPT-3 has 96 layers; at the end, the final position’s vector is used to produce the next-token distribution.
Training minimizes negative log probability for the actual next token across many examples, adjusting model parameters through gradient-based optimization.

13:30 Word Embeddings Encode Meaning in High-Dimensional Spaces

Learned embeddings tend to place semantically related words near one another; a word like “tower” has neighbors associated with tall structures.
The 2013 word2vec paper demonstrated analogy-like vector arithmetic: woman − man + king can land near queen, though Sanderson notes the result varies with training data.
GPT-3 token embeddings have 12,288 coordinates, allowing vectors to represent both token meaning and context-derived information.
In high dimensions, many vectors can be nearly orthogonal; this helps explain how a vector space can represent far more distinct features than its exact dimension count.

22:20 Why Attention Needs Positional Information and Learned Matrices

Sanderson motivates attention with “a fluffy blue creature”: the creature’s representation should incorporate relevant information from the adjectives.
Token vectors also encode position, so relationships such as which adjective comes before a noun need not rely on sequential processing.
Matrix multiplication provides trainable transformations that work efficiently on GPUs and support gradient-based training.
The attention mechanism uses three learned transformations—query, key, and value—to determine which tokens should influence one another and what information to pass.

25:40 Queries, Keys, and Dot Products Build Attention Scores

A query vector represents what a token is looking for; in the toy example, the noun “creature” seeks adjectives in relevant positions.
A separate key matrix maps every token into the same smaller space as the queries; Sanderson gives 64 or 128 dimensions as common query/key sizes.
Dot products compare each query with each key: positive alignment indicates a match, zero indicates perpendicular vectors, and negative values indicate opposing directions.
The resulting score grid identifies which tokens are relevant to updating each other; in the example, “fluffy” and “blue” score highly for “creature.”

31:45 Softmax, Causal Masking, and the Cost of Long Contexts

Softmax converts attention scores into nonnegative weights that sum to one, assigning larger weights to higher scores; the scores are scaled by the square root of the key dimension.
Causal attention prevents a token from accessing future tokens during next-token training by setting forbidden scores to negative infinity before softmax.
A standard attention pattern grows quadratically with context length, making larger context windows computationally expensive without architectural optimizations.
Tokenization balances context size against learnability: character tokens create longer sequences, while byte-pair encoding combines frequent character sequences into reusable tokens.

39:35 Value Vectors Turn Attention Weights into Contextual Updates

A learned value matrix transforms each token into information that can be added to another token’s representation.
For “a fluffy blue creature,” attention weights combine the adjective values and add their weighted sum to the creature vector.
The attention block adds these updates to the original vectors rather than replacing them, producing context-enriched representations.
Mapping values through a smaller intermediate space reduces parameter count compared with a full embedding-to-embedding transformation.

43:45 Multi-Head Attention Runs Different Relationships in Parallel

Each attention head has its own query, key, and value matrices, allowing it to learn a different pattern of information exchange.
Heads might capture adjective–noun relationships, adverb–verb relationships, or other useful associations; their proposed updates are combined.
Transformer blocks repeat attention and feed-forward operations so token representations can accumulate increasingly rich context.
The many independent computations are designed to run in parallel on GPUs, making a high volume of operations practical.

46:15 Why Transformers Scale Across Data and Modalities

Transformer performance benefits from scale: larger models and more training data can lower prediction loss and yield visible improvements.
Unlike sequential language-processing approaches, attention lets a Transformer process a passage in parallel, increasing GPU throughput.
Next-token prediction supports self-supervised pretraining on large text collections without human labels for every example; human feedback can be added later for chatbot behavior.
The same token-and-vector framework can handle text, image patches, and sound segments, enabling multimodal models without entirely separate architectures.

49:40 Q&A: Interpretability, Residual Connections, and Analog Computing

Sanderson describes consulting interpretability researchers and points to superposition as a research direction for understanding how models represent more features than dimensions.
He says residual connections are built into Transformers: each layer adds changes to existing representations, a design that can aid training stability.
On presentation design, he prioritizes a clear path to understanding over planned joke quotas or a creative team.
On analog computing, he suggests digital matrix-multiplication optimization has a substantial head start, while acknowledging he is not an expert on the trade-offs.

55:45 Q&A: Representing Two-Dimensional Images as Tokens

A common image-token approach divides an image into patches and embeds each patch as a vector.
Positional encodings can include both x- and y-coordinates so the model knows where each image patch appears.
Naively using very small patches can create too many tokens, so practical image Transformers need more efficient ways to manage resolution and attention.
Attention can be structured to reflect image geometry—for example, by processing rows and columns separately.

Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, Grant Sanderson.