Attention weighting
Each token assigns weights to other tokens so it can mix relevant information.
TOKENS WEIGH TOKENSNOTE / 00
Demonstration input notice
Important: the raw notes below are DEMONSTRATION inputs used to showcase the reusable prompt. They are not verified source material and should not be treated as a citation or authority for any technical claim.
DEMONSTRATION RAW NOTES (inputs only, not verified source):
- Transformer attention lets each token weigh information from other tokens.
- Each token is projected into Query, Key, and Value vectors.
- Attention scores are QK^T divided by sqrt(d_k), followed by softmax.
- The softmax weights form a weighted sum of the Value vectors.
- Multi-head attention runs several attention operations in parallel so different relationships can be represented.
- Positional information is required because attention alone does not encode word order.
- Causal masking prevents a language model from reading future tokens during generation.
- Attention is powerful but has quadratic time and memory cost with sequence length.
- Common misunderstandings: attention weights are not guaranteed explanations; a head does not always have one human-readable role; attention is not the same thing as understanding.
"Here are my raw notes: [paste]. Turn them into a clean study guide broken into concepts, definitions, diagrams, examples, and 'things students always misunderstand.' Make it impossible to forget."
The reusable prompt is from an X post by @aiwithmayank (Mayank Vora), 2025-12-09: https://x.com/aiwithmayank/status/1998334446379188696. This is provenance for the reusable PROMPT only and is explicitly NOT verification of any technical claim in this study guide.
By the end of this guide, you will be able to…
- Explain why attention lets each token gather information from other tokens.
- Identify the role of Query, Key, and Value vectors.
- Walk through scaled dot-product attention: scores, scaling, softmax, weighted sum.
- Describe why multi-head attention can represent several relationships at once.
- Explain why positional information and causal masking are needed.
- Recognize the quadratic cost of full attention as sequence length grows.
Q/K/V projection
The same token representation is linearly projected into Query, Key, and Value views.
QUERY ASKS · KEY MATCHES · VALUE CARRIESScaled dot-product
Compute QK^T / sqrt(d_k), then apply softmax to convert scores into weights.
SCORE · SCALE · SOFTMAXWeighted sum of Values
Use the softmax weights to average Value vectors into the attention output.
BLEND THE VALUESMulti-head attention
Run several attention computations in parallel, then combine them.
MANY READERS · ONE SUMMARYPositional encoding
Add or otherwise supply position information because attention alone is permutation-insensitive.
ORDER MUST BE TOLDCausal masking
Block future positions so an autoregressive model cannot read tokens it has not generated yet.
NO PEEKING AHEADQuadratic cost
Full attention compares token pairs, so time and memory scale roughly with sequence length squared.
PAIRS GROW AS n²- Query
- The vector representing what a token is looking for.
- Key
- The vector representing what a token offers for matching.
- Value
- The vector carrying the information that will be mixed into the output.
- Attention score
- A similarity value, often from a query-key dot product, before normalization.
- Softmax
- A function that turns scores into positive weights that sum to one.
- Multi-head attention
- Several attention operations run in parallel with separate learned projections.
- Positional encoding
- Information that tells the model where tokens occur in the sequence.
- Causal mask
- A mask that prevents a position from attending to future positions.
- Quadratic complexity
- Growth proportional to n², caused here by comparing many token pairs.
The Query asks what it needs, Keys determine matches, and Values carry the content that gets blended into the output.
Tiny numeric walkthrough
- Suppose token A has scores against tokens A, B, C:
[2, 1, 0]after the query-key dot products and scaling. - Softmax turns these into approximate weights
[0.67, 0.24, 0.09]. - If the Value vectors are simplified as
V_A = 10,V_B = 20,V_C = 30, then the output is approximately 0.67×10 + 0.24×20 + 0.09×30 = 14.2. - Interpretation: token A mostly uses its own Value, borrows some from token B, and only a little from token C.
Multi-head intuition
- One head might strongly connect a pronoun to a nearby noun.
- Another head might track syntax or punctuation boundaries.
- Another might distribute attention broadly for context.
- But do not overclaim: heads are learned components and are not guaranteed to have a single human-readable job.
MISREAD / 01
“Attention weights are explanations.”
Corrective: They can be informative, but they are not guaranteed explanations of model behavior.
MISREAD / 02
“Each head has one clean human-readable role.”
Corrective: A head can behave differently across layers, tokens, contexts, and training runs.
MISREAD / 03
“Attention is the same as understanding.”
Corrective: Attention is a mechanism for routing information; understanding is a broader behavioral claim.
Q/K/V = search engine
Query is the search phrase, Keys are the index entries, Values are the pages you actually read.
Softmax = attention budget
It turns raw scores into a budget that must add up to 100%.
Mask = exam divider
In generation, the model cannot peek at future answers.
Multi-head = study group
Several readers inspect the same sentence for different patterns, then combine notes.
Quadratic cost = everyone interviews everyone
Double the tokens and the number of pairwise comparisons grows much faster.
What are Query, Key, and Value in one sentence each?
Query is what a token is looking for, Key is what a token offers for matching, and Value is the information that gets blended into the output.
Why divide by sqrt(d_k) before softmax?
Scaling keeps the dot-product scores from growing too large as dimensionality increases, which keeps softmax gradients stable rather than saturated.
What does the softmax step produce?
Positive attention weights that sum to one, used to form a weighted average of the Value vectors.
Why does a language model need a causal mask?
So each position cannot attend to future tokens it has not generated yet, preserving autoregressive generation.
Why is full attention described as quadratic?
It compares every token pair, so time and memory scale roughly with the square of the sequence length (n²).
Name one misconception about attention weights.
That attention weights are guaranteed explanations of model behavior — they can be informative but are not proof of how the model reasons.
- Attention lets tokens mix information from other tokens.
- Queries compare against Keys to create scores.
- Scores are scaled, softmaxed, and used to weight Values.
- Multi-head attention repeats this in parallel.
- Positional information and causal masks handle order and generation constraints.
- Full attention is powerful but expensive because token pairs grow quadratically.
Ask with Q. Match with K. Carry with V.