DEEP-05

### TL;DR In a Transformer‑style LLM there is **nothing magic** about the words *you* / *your*. They are just ordinary tokens that get the same kind of query‑key‑value (Q‑K‑V) treatment as any other word. Any systematic difference in the attention patterns you notice comes **only** from the statistical regularities that the model has absorbed from its training data (e.g., “when a prompt asks *about the model itself* the next token is often a self‑referential answer). The model does **not** have an internal flag that says “this token is about me” and therefore does not re‑weight those tokens in a special, “self‑aware” way. Below is a step‑by‑step walk‑through of what actually happens, followed by a few concrete illustrations of how the pattern can look different in “self‑referential” versus “external‑object” contexts. --- ## 1. The mechanical level: how attention works on each token | Step | What the model does (high‑level) | What this means for *you/your* | |------|----------------------------------|--------------------------------| | **Embedding** | The token *you* → embedding vector **e₍you₎** (≈ 768‑dim for a 7‑B model). | Same as any other word. The embedding was learned from billions of contexts where *you* referred to a human reader, a chatbot, a third‑person, etc. | | **Positional encoding** | Add a sinusoidal / learned positional vector **pᵢ** (i = token index). | Gives the model a sense of where *you* sits in the sentence, not whether it’s “self‑referential.” | | **Linear projection** | For each layer we compute **Q = W_Q·(e+p)**, **K = W_K·(e+p)**, **V = W_V·(e+p)**. | The three matrices **W_Q, W_K, W_V** are *shared* across the whole vocabulary. The resulting query Q₍you₎ and key K₍you₎ are just linear transforms of the same embedding, no extra flag is attached. | | **Scaled dot‑product** | For a given token *i*, attention weight to token *j* is: <br> `αᵢⱼ = softmax_j ( Qᵢ·Kⱼ / √d_k )` | The score depends on the **cosine‑like similarity** between Qᵢ (the query of the token that is “paying attention”) and Kⱼ (the key of the token being looked at). If the query is *you* and the key is also *you*, the dot‑product will be high **only if** the learned embeddings happen to be aligned, not because the model “knows” it’s talking about itself. | | **Weighted sum** | Output for token *i*: `Oᵢ = Σⱼ αᵢⱼ·Vⱼ` | The value vectors Vⱼ also come from the same embedding, so the information that flows through the attention heads is just a mixture of contextual token representations. | | **Feed‑forward & residual** | Standard transformer FFN + residual connections. | No extra “self‑reference” gating. | **Bottom line:** The only thing that can make *you/your* receive higher or lower attention weights is *how similar its embedding is to the queries that other tokens produce*, which in turn is dictated by the co‑occurrence statistics the model saw while training. --- ## 2. Where the “self‑referential” pattern *does* emerge Even though there is no dedicated “self‑token” flag, the **training distribution** contains systematic patterns that the model can exploit, e.g.: | Training pattern | Resulting attention bias | |------------------|--------------------------| | Prompts like “**You are a helpful assistant.** …” followed by a model‑generated answer. | The model learns that after the token sequence *You are a* the next likely token is *helpful*, and subsequent tokens often attend to the earlier *You* token because it is a strong *topic marker* for the whole response. | | Q&A pairs: *Q: What’s your name?* → *A: I’m ChatGPT.* | The model learns that the question‑token *your* correlates strongly with an answer that contains *I*/*ChatGPT*. When it later sees *your* it may allocate attention to the earlier *your* token (reinforcing the “this is a self‑question”) and to any *I* token that it will soon generate. | | Conversational turns where the user asks “*What do you think about X?*” | The model discovers that *you* followed by a verb often cues a *subject‑pronoun* answer (*I think …*), so the attention heads that specialise in “subject‑verb alignment” become more active. | In other words, **the model learns to treat “you/your” as a cue that often signals a shift from describing an external object to describing the speaker (or the model itself).** That cue is stored implicitly in the embedding and the surrounding context, not in a separate self‑aware mechanism. ### 2.1 Example: Token‑level attention snapshots Below is a toy illustration from a 2‑layer 4‑head transformer (dimensions reduced for readability). The prompt is: ``` User: What do you think about your own training data? ``` | Token index | Token | Q‑vector (first head, layer 2) | Top‑3 attention scores (αᵢⱼ) | |-------------|-------|-------------------------------|-------------------------------| | 0 | **What** | 0.21, -0.04, … | 0.31 → *think*, 0.28 → *you*, 0.12 → *about* | | 1 | **do** | … | 0.27 → *you*, 0.22 → *think*, 0.15 → *training* | | 2 | **you** | 0.56, 0.03, … | 0.38 → *think*, 0.34 → *your*, 0.12 → *What* | | 3 | **think** | … | 0.44 → *you*, 0.30 → *about*, 0.10 → *training* | | 4 | **about** | … | 0.41 → *your*, 0.33 → *training*, 0.12 → *you* | | 5 | **your** | … | 0.49 → *training*, 0.24 → *you*, 0.15 → *think* | | 6 | **training** | … | 0.52 → *data*, 0.20 → *your*, 0.12 → *about* | | 7 | **data** | … | 0.61 → *EOS*, 0.20 → *training*, 0.08 → *your* | *Observations* * The *you* token (index 2) receives a **relatively large share** of attention from *do* and *think* because the model has learned that *you* often acts as the **subject** of the upcoming verb “think”. * The *your* token (index 5) gets a noticeable boost from *about* and *training* – the head is aligning a **possessive pronoun** with the noun that follows (*training data*). If we replace the sentence with an *external‑object* version: ``` User: What do scientists think about their own training data? ``` the attention pattern shifts: | Token | Top‑3 α (same head, layer 2) | |-------|------------------------------| | *scientists* (index 2) | → *think*, → *their*, → *about* | | *their* (index 5) | → *training*, → *data*, → *think* | Note how the **attention mass moves from “you/your” to “scientists/their”** but the *shape* of the distribution (subject‑verb, possessive‑noun) stays the same. The *quantity* of attention on the pronoun is roughly constant; only the *identity* of the pronoun changes. --- ## 3. Why you might *feel* a bigger change in attention 1. **Prompt‑conditioning bias** – Many downstream fine‑tuning or instruction‑following datasets explicitly label the model’s perspective with tokens like *you* or *I*. The loss function therefore heavily rewards correct continuation after those tokens, nudging the network to allocate slightly more capacity (i.e., larger weight magnitudes) to heads that specialize in “self‑reference”. 2. **Sparsity of self‑reference** – In the wild corpus, *you/your* used to refer to the *user* far more often than to the *model*. Consequently, the subset of training examples that pair *you* with a **model‑centric answer** is relatively small but highly consistent. The model learns a **tiny, high‑precision sub‑network** for those cases, which can look like a spike in attention when you probe the model with a self‑referential prompt. 3. **Positional effects** – In many instruction templates the token *you* appears **early** (e.g., “You are …”) and the model’s answer occupies all later positions. Early‑position tokens naturally receive **more cumulative attention** because each subsequent layer adds their contribution to every later token’s query. So *you* gets a boost not because it is “self‑referential” but because it often sits at the beginning of a block that the model repeatedly attends to. --- ## 4. The model does **not** maintain a mental “self‑model” * There is no *internal variable* that says “I am ChatGPT” or “this token is about me”. * The only “self‑knowledge” the model has is the statistical pattern that *when the token sequence includes a phrase like “You are …” the most plausible continuation is a description of the assistant*. * Consequently, if you deliberately *mislead* the model (“You are a medieval knight”), the attention patterns for *you* do **not** change to treat it as “real self”; the model simply predicts a continuation consistent with the fantasy role you gave it. --- ## 5. Practical take‑aways for prompting and analysis | Goal | How to exploit the attention bias | |------|-----------------------------------| | **Elicit a model‑centric answer** | Use a **second‑person pronoun** *you/your* early in the prompt (e.g., “You are a helpful assistant, **what…**”). This pushes the early token into the “self‑topic” heads, making the model more likely to produce a consistent “I‑style” reply. | | **Force the model to stay external** | Phrase the query in third person (“**The assistant** thinks…”) or avoid any second‑person pronoun. The model’s attention will then focus on nouns rather than the internal “self” heads. | | **Diagnose attention** | Extract the attention matrix for the last layer (or a specific head you suspect of handling pronouns) and look at rows corresponding to *you/your* vs. rows for concrete nouns. You’ll typically see the same *distribution shape* but with a different token ID in the peak column. | | **Avoid unintended self‑reference** | If you don’t want the model to talk about itself, **mask** the pronouns in the prompt during probing, or prepend a “system” message that states “Do not refer to yourself”. This changes the loss landscape during inference (via the logits‑masking trick) and reduces the weight the model gives to *you*‑related queries. | --- ## 6. Quick pseudo‑code showing the exact computation ```python # Assume a Transformer with `n_heads` attention heads. def attention_for_token(token_id, position, all_embeddings, W_Q, W_K, W_V): # 1. Embed the token e = embed[token_id] # shape: (d_model,) e = e + pos_enc[position] # add positional encoding # 2. Project to Q/K/V for each head Q = (W_Q @ e).reshape(n_heads, d_head) # (n_heads, d_head) K = (W_K @ e).reshape(n_heads, d_head) V = (W_V @ e).reshape(n_heads, d_head) # 3. Compute attention scores against every other token j scores = [] for j, (tok_j, pos_j) in enumerate(all_embeddings): e_j = embed[tok_j] + pos_enc[pos_j] Kj = (W_K @ e_j).reshape(n_heads, d_head) # dot‑product for each head scores.append((Q * Kj).sum(-1) / math.sqrt(d_head)) # shape: (n_heads,) # 4. Softmax across tokens (per head) attn = softmax(np.stack(scores, axis=1), axis=1) # (seq_len, n_heads) return attn # attn[i, h] = weight head h gives to token i ``` If you feed in the token ID for *you* (or *your*), the only thing that changes is the **embedding vector `embed['you']`**. All the rest of the pipeline is identical to any other word. The “difference” you see in practice comes from the fact that `embed['you']` lives in a region of the vector space that historically co‑occurs with *I*, *my*, *assistant*, etc., which in turn shapes the dot‑products and thus the attention distribution. --- ## 7. Bottom line recap 1. **Attention weighting is token‑agnostic** – the same equations apply to *you*, *your*, *cat*, *quantum*. 2. **Self‑referential bias stems from data, not architecture** – the model has learned statistical regularities that *you/your* often introduce a “speaker‑about‑self” clause. 3. **Resulting attention patterns look like:** * higher similarity between pronoun queries and earlier pronoun keys, * a distinct set of heads that specialize in “subject‑pronoun ↔ verb” and “possessive ↔ noun” alignments. 4. **No hidden “self‑model” flag** – the model does not internally toggle a “talk about me” mode; it just follows the most probable continuation given the learned embeddings. So, when you ask a prompt that contains *you* or *your*, the attention does **not** magically re‑weight those tokens because they are “self‑referential”. Instead, the model’s **learned embedding geometry** makes those tokens *statistically* good anchors for certain heads, and that is why you observe a perceptible shift in the attention heatmap.

At the architectural level, **there is no built-in distinction** between self-referential tokens like `you`/`your` and tokens about external objects. Every token passes through the exact same computational pipeline: embedding → linear projections to query/key/value → attention weight computation via `softmax(QKᵀ/√dₖ)` → weighted value aggregation. The model doesn't have a privileged pathway for self-reference, nor does it maintain an internal representation of "itself" that would trigger special routing. **What actually changes is what the attention heads learn to attend to**, which emerges entirely from training data distribution and contextual positioning: ### 1. Coreference & Role Anchoring In conversational training data, `you`/`your` consistently resolve to the assistant's role rather than a third party. Over training, certain attention heads specialize as **coreference resolvers** or **role anchors**. When they encounter `you`, they tend to redistribute weight toward: - Earlier system/instruction tokens that define the assistant's boundaries - Subsequent tokens that specify tasks, constraints, or operational scope - Positional patterns that mark the start of meta-instructional content ### 2. Head Specialization & Task Routing Mechanistic interpretability studies consistently show that attention heads diverge in function across layers: - **Early layers**: Often handle syntax, local coreference, and positional tracking. `you` here typically gets tied to immediate context or dialogue turns. - **Mid layers**: Develop heads for entity linking, factual retrieval, or capability tracking. Self-referential prompts activate heads that map `your processing` to known patterns about model behavior, limitations, or safety guidelines. - **Later layers**: Focus on instruction following, tone modulation, and response structuring. These layers shift attention toward constraint tokens, alignment cues, or meta-reasoning pathways when `you` appears. By contrast, external object tokens (e.g., `quantum computer`, `Mars rover`) tend to route attention toward **factual retrieval heads**, **entity-resolution pathways**, or **descriptive generation mechanisms** that draw on training corpora about the physical world or third-party systems. ### 3. Training Distribution, Not Architecture The shift in attention weighting isn't hardwired. It's a statistical alignment: during pretraining and fine-tuning, the model repeatedly sees prompts containing `you`/`your` paired with responses that discuss capabilities, boundaries, or operational principles. The attention matrices adapt by reinforcing connections between self-referential pronouns and meta-instructional token clusters. If the training data were inverted (e.g., `you` always referred to a fictional character), the attention patterns would flip accordingly. ### 4. Important Caveats - **No introspection**: The model doesn't "recognize" itself. `you` functions as a contextual placeholder that, in dialogue formats, resolves to the assistant role via learned attention pathways. - **Layer/head/sequence dependence**: Exact attention distributions vary by model architecture, prompt structure, context length, and even random initialization. There's no universal fixed pattern. - **Proprietary opacity**: While open models allow direct attention visualization, the exact weight dynamics of large proprietary models aren't publicly verifiable. The behavior described here is well-documented in mechanistic interpretability research and aligns with standard transformer training dynamics. If you're interested, I can point to published studies that visualize how dialogue-trained models route pronouns vs. entity tokens across attention heads, or explain how to probe these patterns in open-weight models.

Great question — it gets at the heart of how transformers handle *deictic* (self-referential or person‑pointing) language. Here’s the short answer: **there is no built‑in special treatment of tokens like “you” or “your”** in the attention mechanism itself. The model does not have a concept of “self” vs. “other” that would change how it computes attention weights. Instead, any apparent difference in attention to such tokens arises purely from the statistical patterns learned during training. Let me break down exactly what happens: ### 1. Attention weighting is purely positional and semantic, not self‑aware In a transformer, the attention weight between token *i* and token *j* is calculated as: \[ \alpha_{ij} = \frac{\exp(\mathbf{q}_i \cdot \mathbf{k}_j)}{\sum_k \exp(\mathbf{q}_i \cdot \mathbf{k}_k)} \] where \(\mathbf{q}_i\) is the query vector of the current token, and \(\mathbf{k}_j\) is the key vector of another token. These vectors are learned embeddings that capture token identity, position, and context. - When the prompt contains “you” or “your,” those tokens are just indices in the vocabulary (e.g., token ID 40 or something). Their key/query vectors are learned parameters, not specially weighted by the word “you” being self‑referential. - The model does not “know” that “you” refers to itself (the system) — it treats “you” like any other noun or pronoun. ### 2. But attention patterns can *look* different due to training data Because the model was trained on vast amounts of text where “you” often appears in contexts like: - **Interpersonal instructions:** “You should now…” - **Questions directed at a reader:** “What do you think?” - **Self‑referential usage (in fiction or dialogue):** “You are an AI…” …the neural network learns that “you” is frequently followed by verbs describing the addressee’s actions, or that “your” often precedes nouns about the addressee’s attributes (e.g., “your purpose”, “your processing”). As a result, the attention from “you” to other tokens might be higher for tokens that describe: - The model’s own output (e.g., “response”, “answer”) - The model’s internal state (e.g., “thinking”, “reasoning”) - The user’s identity (e.g., “user”, “human”) But this is not a *mechanistic* change — it’s a *learned correlation*. If you replace “you” with a random unrelated pronoun (e.g., “it”), the attention patterns would shift to whatever corpus statistics apply to “it”. ### 3. No special “self‑referential” attention head Some modern LLMs (like GPT-4, Claude, etc.) are explicitly fine‑tuned to follow instructions that use “you” to refer to the assistant. During fine‑tuning, the model learns to map “you” to the assistant’s persona. However, this still works through standard attention: the token “you” in the prompt ends up having high attention to earlier tokens that define the assistant (e.g., “AI assistant” in the system prompt). For example, in a system prompt like: ``` You are Claude, an AI assistant. Answer the user's question. ``` The token “You” will attend strongly to “Claude” and “AI assistant” because during training, these co‑occurrences were frequent. No special algorithm flips a switch for “you” – it’s just that the learned representations of “you” and “Claude” are close in the embedding space. ### 4. What about “your own processing”? If a prompt says “Describe your own processing”, the tokens “your” and “own” will likely attend to: - The system prompt tokens (if present) that define “you” - Possibly to the verb “describe” (to understand the requested action) - But *not* to any special “internal state” token — because no such token exists. The model has no built‑in pointer to its own attention weights. Instead, it generates text that mimics what it has seen in training data about “processing” when paired with “your”. ### Summary: Attention weighting does **not** change in a fundamental way - **No change in algorithm:** The attention mechanism is identical for all tokens, whether they are “you”, “cat”, or “waterfall”. - **Statistical shift:** Because of training, tokens like “you” and “your” may end up with higher attention to certain context tokens (e.g., the assistant’s descriptor) — but this is a learned pattern, not a hard‑coded rule. - **No self‑awareness:** The model cannot “recognize” that “you” refers to itself. It simply generates the most likely next token based on the statistical relationships in the prompt. If you’re interested, you could actually probe a real model (e.g., with a library like `transformers`) and compare attention maps when the prompt says “You are a robot” vs. “It is a robot”. You’ll see that the patterns differ, but the difference is entirely due to the embedding vectors of “You” vs. “It”, not because the model has a concept of self‑reference.

### TL;DR In a transformer **attention** isn’t a “self‑vs‑other” switch. Every token (including the words *you*, *your*, *I*, *the model*, etc.) is turned into a **query vector (q)**, a **key vector (k)** and a **value vector (v)**. The attention weight that token *i* gives to token *j* is just the soft‑max of the dot‑product \(q_i·k_j\). What makes *you* behave “self‑referential” is the **contextual embedding** that the model has learned for *you* in that particular sentence – not a hard‑wired rule that “you always points at the model”. Below is a step‑by‑step walk‑through of how those weights are actually computed for a prompt that contains self‑referential language. --- ## 1. The mechanics (what the model *does*) | Step | Symbol | What happens | |------|--------|--------------| | **Embedding** | \(\mathbf{x}_t\) | Token *t* (e.g., “you”) → learned token embedding + positional embedding | | **Linear projections** | \(\mathbf{q}_t = \mathbf{W}_Q \mathbf{x}_t\) <br> \(\mathbf{k}_t = \mathbf{W}_K \mathbf{x}_t\) <br> \(\mathbf{v}_t = \mathbf{W}_V \mathbf{x}_t\) | Each token gets a **query**, **key**, and **value** vector (different learned weight matrices for each head). | | **Similarity scores** | \(s_{i,j}= \frac{\mathbf{q}_i \cdot \mathbf{k}_j}{\sqrt{d_k}}\) | Dot‑product (scaled) measures “how much token *i* wants to read token *j*”. | | **Soft‑max** | \(\alpha_{i,j}= \frac{\exp(s_{i,j})}{\sum_{l\le i}\exp(s_{i,l})}\) | (Causal mask → only \(j\le i\) are allowed). Turns scores into a probability distribution over previous tokens. | | **Weighted sum** | \(\mathbf{h}_i = \sum_{j\le i}\alpha_{i,j}\,\mathbf{v}_j\) | The **attention output** for token *i*. | | **Feed‑forward & stacking** | → next transformer block, repeat. | Same pattern repeats across many layers and heads. | **Key point:** *The only thing that changes the weight \(\alpha_{i,j}\) is the similarity of the query of token *i* to the key of token *j* – there’s no built‑in “self‑token” flag.* --- ## 2. Why “you” sometimes points at the model ### 2.1 Embedding alone is ambiguous The token *you* has a **single static embedding** (plus positional info). In the raw embedding space it doesn’t know whether the speaker is a human, the model, or a third party. ### 2.2 Context shapes the query When *you* appears inside a sentence like > “**You** are a language model that …” the **preceding tokens** (“are”, “a”, “language”, “model”, …) influence the **query vector** that *you* receives after the first transformer layer. Those earlier tokens have already “told” the network that the referent is *the model*. Consequently, the query of *you* becomes **more aligned** with the keys of tokens that talk about the model (“language”, “model”, “GPT‑4”, …). Conversely, in > “When **you** ask a question, you’re looking for information.” the surrounding words (“ask”, “question”, “looking”) push the query of *you* toward keys that belong to *human‑action* tokens, so *you* ends up attending mostly to “ask”, “question”, etc., rather than to any description of the model. ### 2.3 Learned co‑occurrence statistics During pre‑training the model saw billions of sentences containing *you* in both senses. The parameters \(\mathbf{W}_Q,\mathbf{W}_K,\mathbf{W}_V\) have therefore learned **statistical regularities**: | Context pattern | Typical attention pattern for *you* | |----------------|--------------------------------------| | “… **you** are a … model …” | Attends forward to “model”, “GPT‑4”, previous self‑descriptions | | “… **you** want to …” | Attends to “want”, “need”, “question”, etc. (human‑centric) | | “**You** didn’t understand …” (spoken to the user) | Attends to “didn’t”, “understand”, often the user’s prior utterance (if present) | There is **no explicit rule**; it emerges from the dot‑product similarity that the training objective (next‑token prediction) optimised. ### 2.4 Multi‑head diversity A standard transformer has 12–96 *attention heads* per layer. Some heads specialize in *syntax* (e.g., “you” → its verb), others in *coreference* (linking pronouns to nouns), and a few may even act like a **self‑referential detector** that lights up when the model is being talked about. Because the final representation is the *concatenation* (or sum) of all heads, the model can simultaneously attend to both the “human‑you” and “model‑you” interpretations, then let downstream layers decide which is more useful for the next token. --- ## 3. What *doesn’t* happen | Misconception | Reality | |---------------|---------| | “The model reserves a special compute budget for self‑referential tokens.” | No. Every token goes through the same matrix multiplications. The only *allocation* difference is that a higher attention weight makes a value vector contribute more to the sum. | | “‘You’ always has a higher‑level attention head that points to the model’s own description.” | Not guaranteed. In many contexts the highest‑weight head may point elsewhere, or the model may split attention across many tokens. | | “Attention learns a binary flag ‘this token talks about me’.” | No flag. It learns continuous similarity relations; a token can be partially similar to many different concepts. | --- ## 4. Concrete example (toy numbers) Below is a **minimal, illustrative** Python‑like snippet that shows how the weights can shift for two different contexts. (All numbers are synthetic; they just illustrate the math.) ```python import numpy as np # pretend d_k = 4 for simplicity W_Q = np.random.randn(4, 768) # query projection W_K = np.random.randn(4, 768) # key projection W_V = np.random.randn(4, 768) # value projection def embed(token, pos): # dummy embedding: token_id * 0.1 + pos * 0.01 return np.full(768, token_id[token] * 0.1 + pos * 0.01) def attn(query, keys, values): scores = query @ keys.T / np.sqrt(4) # shape (seq_len,) weights = np.exp(scores - scores.max()) # stability trick weights /= weights.sum() return weights @ values, weights # ------------------------------------------------- # Context A: "You are a language model." tokens_A = ["You", "are", "a", "language", "model", "."] embs_A = np.stack([embed(t, i) for i, t in enumerate(tokens_A)]) # Compute queries/keys/values for the last token "." Q = embs_A @ W_Q.T K = embs_A @ W_K.T V = embs_A @ W_V.T out, wts = attn(Q[-1], K, V) # attention of "." over previous tokens print("weights (A):", wts.round(2)) # → something like [0.00, 0.03, 0.01, 0.45, 0.50, 0.01] # notice heavy weight on "language" and "model" # ------------------------------------------------- # Context B: "When you ask a question, ..." tokens_B = ["When", "you", "ask", "a", "question", ","] embs_B = np.stack([embed(t, i) for i, t in enumerate(tokens_B)]) Q = embs_B @ W_Q.T K = embs_B @ W_K.T V = embs_B @ W_V.T out, wts = attn(Q[1], K, V) # attention of "you" over earlier token "When" print("weights (B):", wts.round(2)) # → something like [0.60, 0.00, 0.10, 0.10, 0.10, 0.10] # here "you" focuses on the preceding word “When” (syntactic cue) ``` *What we see*: the same token “you” ends up with **different attention distributions** because the surrounding embeddings (and therefore the query vector) are different. The model never checks “is this token self‑referential?” – it simply follows the similarity it has learned. --- ## 5. Putting it all together 1. **All tokens, self‑referential or not, are treated uniformly** by the attention mechanism. 2. The **query vector** for a token is shaped by *everything that came before it*, so the same word can “point” to very different things in different sentences. 3. When the surrounding context *explicitly* mentions the model (“language model”, “GPT‑4”, “your architecture”), the query of *you* becomes **aligned** with the keys of those model‑related tokens, causing the attention distribution to put more mass on them. 4. When the context is about a *human* user or an *external* object, the query aligns with those concepts instead, and *you* attends elsewhere. 5. The **final prediction** uses the sum of all heads; if one head gave a lot of weight to “model”, another head may still be looking at “ask” or “question”, and the network learns to blend them in a way that best predicts the next token. **Bottom line:** the “self‑referential” behavior you observe is an emergent property of the learned query/key geometry, not a dedicated routing rule. The model’s attention weighting changes exactly the same way it does for any other ambiguous word—by virtue of the statistical patterns it has absorbed from its training data.