\n Tokens (${tokens.length} · ratio: ${(text.length / Math.max(1, tokens.length)).toFixed(2)} chars per token):\n

\n ${tokens.map(t => {\n const visText = t.text.replace(/ /g, '·').replace(/\\n/g, '⏎');\n return `

${escapeHtml(visText)}id ${t.id}

`;\n }).join('')}\n

\n `;\n } catch (e) {\n out.innerHTML = `

Error: ${e.message}

`;\n }\n}\nfunction escapeHtml(s) {\n return s.replace(/&/g, '&').replace(//g, '>').replace(/\"/g, '"');\n}\n// Debounced live-tokenize on input\nlet _tokDebounce = null;\ndocument.addEventListener('input', (e) => {\n if (e.target && e.target.id === 'liveTokInput') {\n if (_tokDebounce) clearTimeout(_tokDebounce);\n _tokDebounce = setTimeout(() => liveTokenize(), 250);\n }\n});\n\n// ── Cosine similarity playground (uses MiniLM, loaded lazily) ──\n// GPT-2's ONNX export doesn't expose hidden states, so we use a\n// proper sentence-embedding model just for the similarity demo.\nlet EMB_MODEL = null;\nlet EMB_TOKENIZER = null;\nlet EMB_LOADING = false;\nasync function ensureEmbedder(onProgress) {\n if (EMB_MODEL) return true;\n if (EMB_LOADING) {\n while (EMB_LOADING) await new Promise(r => setTimeout(r, 200));\n return !!EMB_MODEL;\n }\n EMB_LOADING = true;\n try {\n const { AutoTokenizer, AutoModel } = window.transformers;\n if (!AutoModel) throw new Error('AutoModel not exposed by transformers.js — reload page');\n EMB_TOKENIZER = await AutoTokenizer.from_pretrained('Xenova/all-MiniLM-L6-v2', {\n progress_callback: onProgress\n });\n EMB_MODEL = await AutoModel.from_pretrained('Xenova/all-MiniLM-L6-v2', {\n quantized: true,\n progress_callback: onProgress\n });\n return true;\n } catch (e) {\n console.error('[embedder] load failed', e);\n return false;\n } finally {\n EMB_LOADING = false;\n }\n}\n\n// Get the full per-token hidden state matrix (not mean-pooled) for any text\n// Returns: { tokens: string[], vectors: number[][] } where vectors[i] has length 384\nasync function getHiddenStates(text) {\n if (!text) return null;\n const ok = await ensureEmbedder();\n if (!ok) return null;\n const enc = await EMB_TOKENIZER(text, { return_tensor: false });\n const ids = enc.input_ids;\n const mask = enc.attention_mask || ids.map(() => 1);\n const T = REAL.Tensor;\n const inputIds = new T('int64', BigInt64Array.from(ids.map(i => BigInt(i))), [1, ids.length]);\n const attMask = new T('int64', BigInt64Array.from(mask.map(i => BigInt(i))), [1, ids.length]);\n const out = await EMB_MODEL({ input_ids: inputIds, attention_mask: attMask });\n const hs = out.last_hidden_state;\n if (!hs) return null;\n const [, S, D] = hs.dims;\n const tokens = ids.map(id => EMB_TOKENIZER.decode([id]));\n const vectors = [];\n for (let s = 0; s < S; s++) {\n const v = new Array(D);\n for (let d = 0; d < D; d++) v[d] = hs.data[s * D + d];\n vectors.push(v);\n }\n return { tokens, vectors, mask };\n}\nasync function getEmbeddingFor(text) {\n const result = await getHiddenStates(text);\n if (!result) return null;\n const D = result.vectors[0].length;\n // Mean-pool across tokens (sentence embedding)\n const avg = new Float32Array(D);\n for (const v of result.vectors) {\n for (let d = 0; d < D; d++) avg[d] += v[d];\n }\n for (let d = 0; d < D; d++) avg[d] /= result.vectors.length;\n return avg;\n}\nfunction cosineDot(a, b) {\n let dot = 0, na = 0, nb = 0;\n for (let i = 0; i < a.length; i++) {\n dot += a[i] * b[i];\n na += a[i] * a[i];\n nb += b[i] * b[i];\n }\n return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-9);\n}\nasync function liveCosineSim() {\n const a = document.getElementById('cosA')?.value;\n const b = document.getElementById('cosB')?.value;\n const out = document.getElementById('cosOutput');\n if (!out || !REAL.model) return;\n out.classList.add('rm-busy');\n if (!EMB_MODEL) {\n out.innerHTML = '

First time only · loading a small sentence-embedding model (~25 MB)…

';\n }\n try {\n const [va, vb] = await Promise.all([getEmbeddingFor(a), getEmbeddingFor(b)]);\n if (!va || !vb) {\n out.innerHTML = '

Please enter both words.

';\n return;\n }\n const sim = cosineDot(va, vb);\n const negative = sim < 0;\n const widthPct = Math.abs(sim) * 50;\n const posStyle = sim >= 0\n ? `left: 50%; width: ${widthPct}%;`\n : `right: 50%; width: ${widthPct}%;`;\n out.innerHTML = `\n

${sim.toFixed(3)}

cosine( ${escapeHtml(a)} , ${escapeHtml(b)} )

\n −1 opposite\n 0 unrelated\n +1 identical\n

\n `;\n } catch (e) {\n out.innerHTML = `

Error: ${e.message}

`;\n } finally {\n out.classList.remove('rm-busy');\n }\n}\n\n// ── Live Attention Playground ─────────────────────────────\n// Computes real self-attention in JS using MiniLM hidden states for any\n// user-typed text. The math is identical to what runs inside transformer\n// layers. We use raw embeddings as Q and K (instead of learned per-layer\n// projections) because no in-browser model exposes those weights yet.\nconst attnPlayState = { queryIdx: 0, hiddenStates: null, tokens: null };\n\nfunction buildAttnExplorer() {\n // First-time real-mode init: auto-run with the default sentence\n if (attnPlayState.hiddenStates === null) {\n recomputeAttnPlay();\n } else {\n renderAttnPlayTokens();\n renderAttnPlayDisplay();\n }\n}\n\nasync function recomputeAttnPlay() {\n const inp = document.getElementById('attnPlayInput');\n const display = document.getElementById('attnPlayDisplay');\n const tokensEl = document.getElementById('attnPlayTokens');\n if (!inp || !display) return;\n const text = inp.value;\n if (!text || !text.trim()) {\n display.innerHTML = '

Type something above and click Compute.

';\n return;\n }\n if (!EMB_MODEL) {\n display.innerHTML = '

First time only · loading MiniLM (~25 MB)…

';\n } else {\n display.innerHTML = '

computing real attention…

';\n }\n tokensEl.innerHTML = '';\n try {\n const res = await getHiddenStates(text);\n if (!res) {\n display.innerHTML = '

Couldn\\'t compute embeddings.

';\n return;\n }\n attnPlayState.hiddenStates = res.vectors;\n attnPlayState.tokens = res.tokens;\n if (attnPlayState.queryIdx >= res.tokens.length) {\n attnPlayState.queryIdx = Math.min(1, res.tokens.length - 1);\n }\n renderAttnPlayTokens();\n renderAttnPlayDisplay();\n } catch (e) {\n display.innerHTML = `

Error: ${escapeHtml(e.message)}

`;\n }\n}\n\nfunction renderAttnPlayTokens() {\n const tokensEl = document.getElementById('attnPlayTokens');\n if (!tokensEl || !attnPlayState.tokens) return;\n tokensEl.innerHTML = attnPlayState.tokens.map((tok, i) => {\n const lbl = tok.replace(/ /g, '·').replace(/\\n/g, '⏎').replace(/^\\[CLS\\]$/, '[CLS]');\n const active = i === attnPlayState.queryIdx ? ' active brick-active' : '';\n return ``;\n }).join('');\n}\n\nfunction setAttnPlayQuery(i) {\n attnPlayState.queryIdx = i;\n renderAttnPlayTokens();\n renderAttnPlayDisplay();\n}\n\nfunction renderAttnPlayDisplay() {\n const display = document.getElementById('attnPlayDisplay');\n if (!display || !attnPlayState.hiddenStates) return;\n\n const useScale = document.getElementById('attnPlayScale')?.checked ?? true;\n const useMask = document.getElementById('attnPlayMask')?.checked ?? false;\n const tempEl = document.getElementById('attnPlayTemp');\n const tempVal = tempEl ? (tempEl.value / 100) : 1.0;\n const tempLabel = document.getElementById('attnPlayTempVal');\n if (tempLabel) tempLabel.textContent = tempVal.toFixed(2);\n\n const Q = attnPlayState.queryIdx;\n const hs = attnPlayState.hiddenStates;\n const S = hs.length;\n const D = hs[0].length;\n const scale = useScale ? Math.sqrt(D) : 1;\n\n // Compute scores: Q_i · K_j for all j\n const scores = [];\n for (let k = 0; k < S; k++) {\n if (useMask && k > Q) { scores.push(-Infinity); continue; }\n let dot = 0;\n for (let d = 0; d < D; d++) dot += hs[Q][d] * hs[k][d];\n scores.push((dot / scale) / tempVal);\n }\n // softmax\n const finite = scores.filter(s => isFinite(s));\n const maxS = Math.max(...finite);\n const exps = scores.map(s => isFinite(s) ? Math.exp(s - maxS) : 0);\n const sumE = exps.reduce((a, b) => a + b, 0);\n const probs = exps.map(e => sumE > 0 ? e / sumE : 0);\n\n const maxProb = Math.max(...probs) || 1;\n const queryLabel = attnPlayState.tokens[Q].replace(/ /g, '·');\n const maskNote = useMask ? ` · masked positions show ▒` : '';\n display.innerHTML = `\n

query = \"${escapeHtml(queryLabel)}\" · ${useScale ? '√d scaled' : 'unscaled'} · T=${tempVal.toFixed(2)}${maskNote}

\n ${probs.map((p, i) => {\n const blocked = useMask && i > Q;\n const isHigh = p > 0.25;\n const keyLabel = attnPlayState.tokens[i].replace(/ /g, '·');\n const widthPct = blocked ? 0 : Math.max(1.5, (p / maxProb) * 100);\n const scoreText = blocked ? '▒ masked' : (p * 100).toFixed(1) + '%';\n return `

${escapeHtml(keyLabel)}

${scoreText}

`;\n }).join('')}\n `;\n}\n\n// Wire up live controls\ndocument.addEventListener('change', (e) => {\n const t = e.target;\n if (t && (t.id === 'attnPlayScale' || t.id === 'attnPlayMask')) renderAttnPlayDisplay();\n});\ndocument.addEventListener('input', (e) => {\n const t = e.target;\n if (t && t.id === 'attnPlayTemp') renderAttnPlayDisplay();\n});\n\nfunction ensureRealTag(titleId) {\n const t = document.getElementById(titleId);\n if (t && !t.querySelector('.real-tag')) {\n const tag = document.createElement('span'); tag.className = 'real-tag';\n t.appendChild(tag);\n }\n}\nfunction ensureRealTagOnTile(tile) {\n const title = tile.querySelector('.tile-title');\n if (!title || title.querySelector('.real-tag')) return;\n const tag = document.createElement('span'); tag.className = 'real-tag';\n title.appendChild(tag);\n}\nfunction clearRealTags() {\n document.querySelectorAll('.tile-title .real-tag').forEach(t => t.remove());\n}\n\nfunction revertIllustrative() {\n if (!REAL.illust) return;\n REAL.active = false;\n document.body.classList.remove('real-mode');\n\n // logits\n baseLogits.length = 0;\n REAL.illust.baseLogits.forEach(t => baseLogits.push(t));\n const tempEl = document.getElementById('tempSlider');\n const T = tempEl ? tempEl.value / 100 : 1.0;\n renderProbs(T);\n // Refresh top-N block with illustrative data\n const activeNBtn = document.querySelector('#topNChips .chip.active');\n const currentN = activeNBtn ? +activeNBtn.textContent.trim() : 7;\n setTopN(currentN);\n\n // attention\n for (let i = 0; i < attnTokens.length; i++) {\n attnTokens[i].score = REAL.illust.attnTokens[i].score;\n attnTokens[i].high = REAL.illust.attnTokens[i].high;\n }\n renderAttnRows(true);\n\n // embeddings\n Object.entries(REAL.illust.embVecs).forEach(([id, html]) => {\n const el = document.getElementById(id);\n if (el && html) el.innerHTML = html;\n });\n\n // generation\n continuation.length = 0;\n REAL.illust.continuation.forEach(t => continuation.push(t));\n resetGen();\n\n // note\n document.getElementById('noteIllust').style.display = 'inline';\n document.getElementById('noteReal').style.display = 'none';\n\n clearRealTags();\n try { localStorage.removeItem('rm-active'); } catch (e) {}\n}\n\n// ── HOOK UP THE HERO BUTTON ───────────────────────────────\nfunction bindRealButton() {\n const btn = document.getElementById('heroRealBtn');\n if (!btn) return;\n btn.addEventListener('click', async () => {\n if (REAL.loading) return;\n if (REAL.active) {\n setRMState('off');\n revertIllustrative();\n return;\n }\n if (REAL.loaded) {\n REAL.active = true;\n setRMState('on');\n applyReal();\n try { localStorage.setItem('rm-active','1'); } catch(_){}\n return;\n }\n await loadRealModel();\n });\n // Auto-restore\n try {\n if (localStorage.getItem('rm-active') === '1') {\n setTimeout(() => loadRealModel(), 700);\n }\n } catch (e) {}\n}\nbindRealButton();\n\n// =============== UTILITIES ===============\nfunction rand(seed) { return ((Math.sin(seed * 12.9898 + 78.233) * 43758.5453) % 1 + 1) % 1; }\nfunction clamp(v, a, b) { return Math.max(a, Math.min(b, v)); }\n\n// Aged-ink palette mapped to embedding values\nfunction colorForValue(v) {\n v = clamp(v, 0, 1);\n // Gradient from cream → brown → black with subtle warm tone\n if (v < 0.5) {\n const t = v * 2;\n // cream(#d1b984) to brown(#6b5a3f)\n const r = Math.round(209 - t * (209 - 107));\n const g = Math.round(185 - t * (185 - 90));\n const b = Math.round(132 - t * (132 - 63));\n return `rgb(${r},${g},${b})`;\n } else {\n const t = (v - 0.5) * 2;\n // brown(#6b5a3f) to near-black(#1a1612)\n const r = Math.round(107 - t * (107 - 26));\n const g = Math.round(90 - t * (90 - 22));\n const b = Math.round(63 - t * (63 - 18));\n return `rgb(${r},${g},${b})`;\n }\n}\n\n// =============== EMBEDDING BARS ===============\nfunction buildVec(id, seed, dim = 32) {\n const el = document.getElementById(id);\n if (!el) return;\n el.innerHTML = \"\";\n for (let i = 0; i < dim; i++) {\n const cell = document.createElement(\"div\");\n cell.className = \"vec-cell\";\n const v = rand(seed + i * 0.31);\n cell.style.background = colorForValue(v);\n cell.style.height = (8 + v * 22) + \"px\";\n el.appendChild(cell);\n }\n}\nbuildVec(\"emb-the\", 1.1);\nbuildVec(\"emb-cap\", 4.7);\nbuildVec(\"emb-of\", 7.3);\nbuildVec(\"emb-france\", 9.2);\nbuildVec(\"emb-is\", 12.5);\nbuildVec(\"france-tok\", 9.2);\nbuildVec(\"france-pos\", 17.3);\nbuildVec(\"france-sum\", 9.2 + 17.3);\n\n// ===== Multi-word Cosine Matrix (Stage 03) =====\nasync function computeCosineMatrix() {\n const inputs = document.querySelectorAll('#wordInputs input');\n const words = Array.from(inputs).map(i => i.value.trim()).filter(w => w);\n const out = document.getElementById('cosMatrix');\n if (words.length < 2) {\n out.innerHTML = '

Enter at least 2 words.

';\n return;\n }\n out.innerHTML = '

computing embeddings…

';\n try {\n const embeds = await Promise.all(words.map(w => getEmbeddingFor(w)));\n const n = embeds.length;\n if (embeds.some(e => !e)) {\n out.innerHTML = '

Couldn\\'t embed one or more words.

';\n return;\n }\n const matrix = [];\n for (let i = 0; i < n; i++) {\n const row = [];\n for (let j = 0; j < n; j++) row.push(cosineDot(embeds[i], embeds[j]));\n matrix.push(row);\n }\n renderCosineMatrix(words, matrix);\n } catch (e) {\n out.innerHTML = `

Error: ${escapeHtml(e.message)}

`;\n }\n}\n\nfunction renderCosineMatrix(words, matrix) {\n const n = words.length;\n const el = document.getElementById('cosMatrix');\n el.style.gridTemplateColumns = `90px repeat(${n}, 1fr)`;\n let html = '

';\n for (const w of words) html += `

${escapeHtml(w)}

`;\n for (let i = 0; i < n; i++) {\n html += `

${escapeHtml(words[i])}

`;\n for (let j = 0; j < n; j++) {\n const v = matrix[i][j];\n // Normalize 0..1 for color intensity (clamp negative to 0)\n const intensity = Math.max(0, Math.min(1, v));\n const r = 138 + Math.round((1 - intensity) * 100);\n const g = 47 + Math.round((1 - intensity) * 165);\n const b = 21 + Math.round((1 - intensity) * 180);\n const bg = `rgb(${r}, ${g}, ${b})`;\n const textColor = intensity > 0.6 ? 'var(--paper)' : 'var(--ink)';\n html += `

${v.toFixed(2)}

`;\n }\n }\n el.innerHTML = html;\n}\n\n// ===== Sample N Times (Stage 11) =====\nasync function sampleNTimes(n) {\n const T = +document.getElementById('tempSlider').value / 100;\n const probs = softmaxTemp(baseLogits.map(b => b.logit), T);\n const counts = new Array(baseLogits.length).fill(0);\n for (let i = 0; i < n; i++) {\n let r = Math.random(); let cum = 0;\n for (let j = 0; j < probs.length; j++) {\n cum += probs[j];\n if (r <= cum) { counts[j]++; break; }\n }\n }\n const out = document.getElementById('sampleNResults');\n if (!out) return;\n const maxCount = Math.max(...counts) || 1;\n const rowsHtml = baseLogits\n .map((b, i) => ({ tok: b.tok, count: counts[i], expected: (probs[i] * n) }))\n .sort((a, b) => b.count - a.count)\n .filter(r => r.count > 0 || r.expected > 0.5)\n .map((r, idx) => {\n const pct = (r.count / n) * 100;\n const expectedPct = (r.expected / n) * 100;\n const barColor = idx === 0 ? 'var(--brick)' : 'var(--ink)';\n return `

\"${r.tok}\"

${r.count}× (${pct.toFixed(0)}%)

`;\n }).join('');\n out.innerHTML = `

\n ${n} samples · T = ${T.toFixed(2)} · ${(counts.filter(c => c > 0).length)} distinct tokens picked\n

\n ${rowsHtml}\n

`;\n}\n\n// Top-N selector for Stage 10 logits block\nconst ILLUST_TOP15 = [\n { tok: \"·Paris\", logit: 10.5, note: \"← winning\" },\n { tok: \"·a\", logit: 7.8 },\n { tok: \"·home\", logit: 7.0 },\n { tok: \"·one\", logit: 6.3 },\n { tok: \"·the\", logit: 5.9 },\n { tok: \"·also\", logit: 5.5 },\n { tok: \"·France\", logit: 4.3, note: \"← the model 'knows' not to repeat\" },\n { tok: \"·now\", logit: 4.0 },\n { tok: \"·another\", logit: 3.6 },\n { tok: \"·its\", logit: 3.2 },\n { tok: \"·just\", logit: 2.9 },\n { tok: \"·known\", logit: 2.6 },\n { tok: \"·only\", logit: 2.3 },\n { tok: \"·in\", logit: 2.0 },\n { tok: \"·even\", logit: 1.7 }\n];\nfunction setTopN(n) {\n document.querySelectorAll('#topNChips .chip').forEach(c => {\n c.classList.remove('active', 'brick-active');\n });\n const targetBtn = Array.from(document.querySelectorAll('#topNChips .chip')).find(c => c.textContent.trim() == String(n));\n if (targetBtn) { targetBtn.classList.add('active', 'brick-active'); }\n document.getElementById('topNDisplay').textContent = n;\n\n // If we have real data, slice real top-N from REAL.data.topLogits etc.\n // Otherwise use ILLUST_TOP15.\n let src;\n if (REAL.active && REAL.data && REAL.data.topLogits) {\n src = REAL.data.topLogits.map((t, i) => ({\n tok: t.tok.replace(/^ /, '·'),\n logit: +t.logit.toFixed(2),\n note: i === 0 ? \"← winning (real GPT-2)\" : \"\"\n }));\n // Pad with placeholders if user wants more than we have\n while (src.length < n) src.push({ tok: \"...\", logit: 0, note: \"\" });\n } else {\n src = ILLUST_TOP15;\n }\n const shown = src.slice(0, n);\n const lines = shown.map((t, i) => {\n const padTok = (`\"${t.tok}\"`).padEnd(18);\n const cls = i === 0 ? 'b' : 'n';\n const noteSpan = t.note ? ` ${t.note}` : '';\n return `logits[${padTok}] = ${t.logit.toFixed(2)}${noteSpan}`;\n }).join('\\n');\n const remaining = 50257 - n;\n const pre = document.getElementById('logitsPre');\n if (pre) pre.innerHTML = lines + `\\n... (${remaining.toLocaleString()} more)`;\n}\n\n// Residual on/off gradient demo\nfunction renderResidualDemo(withResidual) {\n const layers = [12, 10, 8, 6, 4, 2, 1];\n const el = document.getElementById('resDemoBars');\n if (!el) return;\n el.innerHTML = layers.map(l => {\n // With residual: identity path keeps gradient ≈ 1 (slight wobble)\n // Without: gradient ≈ 0.85^(13-l) per layer multiplicatively\n const val = withResidual\n ? Math.max(0.7, 1 - (12 - l) * 0.025 + (Math.sin(l * 2.1) * 0.05))\n : Math.pow(0.85, 13 - l);\n const pct = Math.round(val * 100);\n const cls = withResidual ? '' : 'off';\n return `

layer ${l}

${val.toFixed(2)} ${withResidual ? '' : (val < 0.05 ? '· lost' : '')}

`;\n }).join('');\n}\nfunction setResidual(on) {\n document.getElementById('resOn').classList.toggle('active', on);\n document.getElementById('resOff').classList.toggle('active', !on);\n renderResidualDemo(on);\n}\n// initial render\nrenderResidualDemo(true);\n\n// Position playground — re-build the position + sum vectors when chip clicked\nfunction setPositionDemo(pos) {\n const chips = document.querySelectorAll('#posChips .chip');\n chips.forEach((c, i) => {\n c.classList.toggle('active', i === pos);\n c.classList.toggle('brick-active', i === pos);\n });\n const numEl = document.getElementById('posDemoNum');\n if (numEl) numEl.textContent = pos;\n // Use a position-dependent seed so the vector visibly changes\n const posSeed = 17.3 + pos * 5.7;\n buildVec(\"france-pos\", posSeed);\n buildVec(\"france-sum\", 9.2 + posSeed);\n}\n\n// =============== DOT PRODUCT ===============\nconst DOT_DIM = 8;\nlet qVecData = [];\nlet kVecData = [];\n\nfunction genVectors() {\n qVecData = []; kVecData = [];\n for (let i = 0; i < DOT_DIM; i++) {\n const base = (Math.random() * 1.6 - 0.6);\n qVecData.push(+base.toFixed(2));\n kVecData.push(+(base * 0.7 + (Math.random() * 0.6 - 0.3)).toFixed(2));\n }\n}\ngenVectors();\n\nfunction renderDotProduct() {\n const q = document.getElementById(\"qvec\");\n const k = document.getElementById(\"kvec\");\n const p = document.getElementById(\"pvec\");\n if (!q || !k || !p) return;\n q.innerHTML = \"\"; k.innerHTML = \"\"; p.innerHTML = \"\";\n\n for (let i = 0; i < DOT_DIM; i++) {\n const qc = document.createElement(\"div\");\n qc.className = \"numcell q\"; qc.id = `qc-${i}`;\n qc.innerHTML = `${i}${qVecData[i].toFixed(2)}`;\n q.appendChild(qc);\n\n const kc = document.createElement(\"div\");\n kc.className = \"numcell k\"; kc.id = `kc-${i}`;\n kc.innerHTML = `${i}${kVecData[i].toFixed(2)}`;\n k.appendChild(kc);\n\n const pc = document.createElement(\"div\");\n pc.className = \"numcell\"; pc.id = `pc-${i}`;\n pc.innerHTML = `${i}—`;\n p.appendChild(pc);\n }\n document.getElementById(\"dotprodRunning\").textContent = \"—\";\n document.getElementById(\"dotprodDisplay\").querySelector(\".calc\").textContent =\n \"Click below to walk through the dot product step by step.\";\n}\nrenderDotProduct();\n\nasync function animateDotProduct() {\n let running = 0;\n const calcEl = document.getElementById(\"dotprodDisplay\").querySelector(\".calc\");\n const runEl = document.getElementById(\"dotprodRunning\");\n const parts = [];\n\n for (let i = 0; i < DOT_DIM; i++) {\n const qc = document.getElementById(`qc-${i}`);\n const kc = document.getElementById(`kc-${i}`);\n const pc = document.getElementById(`pc-${i}`);\n qc.classList.add(\"lit\"); kc.classList.add(\"lit\");\n\n const product = +(qVecData[i] * kVecData[i]).toFixed(2);\n pc.innerHTML = `${i}${product.toFixed(2)}`;\n pc.classList.add(\"product\", \"lit\");\n running += product;\n parts.push(`(${qVecData[i].toFixed(2)}×${kVecData[i].toFixed(2)})`);\n calcEl.innerHTML = parts.join(\" + \");\n runEl.textContent = \"= \" + running.toFixed(2);\n\n await new Promise(r => setTimeout(r, 360));\n qc.classList.remove(\"lit\"); kc.classList.remove(\"lit\"); pc.classList.remove(\"lit\");\n }\n calcEl.innerHTML = parts.join(\" + \") + \" = \" + running.toFixed(2);\n runEl.innerHTML = `Q_is · K_France = ${running.toFixed(2)}`;\n}\nfunction randomizeVectors() { genVectors(); renderDotProduct(); }\n\n// =============== ATTENTION SCORE BARS ===============\nconst attnTokens = [\n { tok: '\"The\"', score: 0.08, high: false },\n { tok: '\"·capital\"', score: 0.34, high: true },\n { tok: '\"·of\"', score: 0.05, high: false },\n { tok: '\"·France\"', score: 0.41, high: true },\n { tok: '\"·is\" (self)', score: 0.12, high: false }\n];\nfunction renderAttnRows(reveal = false) {\n const c = document.getElementById(\"attnRows\");\n c.innerHTML = \"\";\n attnTokens.forEach((t, i) => {\n const row = document.createElement(\"div\");\n row.className = \"attn-reveal\" + (t.high ? \" high\" : \"\");\n row.id = `arow-${i}`;\n row.innerHTML = `\n

${t.tok}

${reveal ? (t.score * 100).toFixed(0) + \"%\" : \"\"}

\n `;\n c.appendChild(row);\n });\n}\nrenderAttnRows(true);\nasync function animateAttnScores() {\n renderAttnRows(false);\n await new Promise(r => setTimeout(r, 200));\n for (let i = 0; i < attnTokens.length; i++) {\n const row = document.getElementById(`arow-${i}`);\n const fill = row.querySelector(\".bar-fill\");\n const score = row.querySelector(\".score\");\n fill.style.width = (attnTokens[i].score * 100 / 0.45) + \"%\";\n score.textContent = (attnTokens[i].score * 100).toFixed(0) + \"%\";\n await new Promise(r => setTimeout(r, 280));\n }\n}\n\n// =============== HEADS ===============\nconst heads = [\n { name: \"HEAD 1\", focus: \"finds the proper noun → ·France\" },\n { name: \"HEAD 2\", focus: \"finds the role word → ·capital\" },\n { name: \"HEAD 3\", focus: \"tracks 'of' relations\" },\n { name: \"HEAD 4\", focus: \"syntactic structure\" },\n { name: \"HEAD 5\", focus: \"long-range references\" },\n { name: \"HEAD 6\", focus: \"named entities\" },\n { name: \"HEAD 7\", focus: \"fact-completion pattern\" },\n { name: \"HEAD 8\", focus: \"punctuation context\" }\n];\nconst headRotations = [\n [\"proper noun → France\", \"role word → capital\", \"'of' relations\", \"syntactic structure\", \"long-range refs\", \"named entities\", \"fact completion\", \"punctuation\"],\n [\"subject locator\", \"verb tense\", \"country detector\", \"discourse markers\", \"rhyme/sound\", \"magnitude of numbers\", \"code symbols\", \"speaker turn\"],\n [\"matches quotes\", \"scope of NOT\", \"list parallelism\", \"comparisons\", \"synonym links\", \"geography facts\", \"function calls\", \"sentence end\"]\n];\nfunction renderHeads(focuses) {\n const c = document.getElementById(\"headsContainer\");\n c.innerHTML = \"\";\n heads.forEach((h, i) => {\n const d = document.createElement(\"div\");\n d.className = \"head\";\n const f = focuses ? focuses[i] : h.focus;\n const w = 30 + Math.floor(rand(i * 7.3 + (focuses ? focuses.length : 0)) * 65);\n d.innerHTML = `

${h.name}

${f}

`;\n c.appendChild(d);\n });\n}\nrenderHeads();\nlet headIdx = 0;\nfunction cycleHeads() {\n headIdx = (headIdx + 1) % headRotations.length;\n renderHeads(headRotations[headIdx]);\n}\n\n// =============== FFN NEURONS ===============\nconst FFN_NEURONS = 100;\nfunction renderFFNNeurons(active = false) {\n const c = document.getElementById(\"ffnNeurons\");\n c.innerHTML = \"\";\n for (let i = 0; i < FFN_NEURONS; i++) {\n const n = document.createElement(\"div\");\n n.className = \"neuron\"; n.id = `nrn-${i}`;\n if (active) {\n const r = rand(i * 0.31);\n if (r > 0.85) n.classList.add(\"paris\");\n else if (r > 0.55) n.classList.add(\"active\");\n }\n c.appendChild(n);\n }\n}\nrenderFFNNeurons(false);\nfunction activateFFN() {\n renderFFNNeurons(false);\n const targets = [];\n for (let i = 0; i < FFN_NEURONS; i++) {\n const r = rand(i * 0.31);\n if (r > 0.85) targets.push({ i, cls: \"paris\" });\n else if (r > 0.55) targets.push({ i, cls: \"active\" });\n }\n targets.forEach((t, idx) => {\n setTimeout(() => {\n const n = document.getElementById(`nrn-${t.i}`);\n if (n) n.classList.add(t.cls);\n }, idx * 25);\n });\n}\nfunction resetFFN() { renderFFNNeurons(false); }\n\n// =============== STACK ===============\nconst stackBlocks = [\n { name: \"Block 1\", info: \"tokens, n-grams, surface\" },\n { name: \"Block 5\", info: \"local syntax, phrase structure\" },\n { name: \"Block 12\", info: \"recognizes fact-completion pattern\" },\n { name: \"Block 24\", info: \"France ↔ country concept linked\" },\n { name: \"Block 40\", info: \"retrieves 'Paris' from MLP memory\" },\n { name: \"Block 60\", info: \"answer commits, attention refines it\" },\n { name: \"Block 80\", info: \"vector approaches input-embed of 'Paris'\" },\n { name: \"Block 96\", info: \"ready to project to logits\" }\n];\nfunction renderStack() {\n const c = document.getElementById(\"stackViz\"); c.innerHTML = \"\";\n stackBlocks.forEach((b, i) => {\n const d = document.createElement(\"div\");\n d.className = \"stack-block\"; d.id = `stack-${i}`;\n d.innerHTML = `${b.name}${b.info}`;\n c.appendChild(d);\n });\n}\nrenderStack();\nfunction animateStack() {\n stackBlocks.forEach((_, i) => {\n setTimeout(() => {\n const el = document.getElementById(`stack-${i}`);\n el.style.background = \"var(--ink)\";\n el.style.color = \"var(--paper)\";\n const info = el.querySelector(\".info\");\n if (info) info.style.color = \"rgba(230,212,173,0.7)\";\n setTimeout(() => {\n el.style.background = \"\";\n el.style.color = \"\";\n if (info) info.style.color = \"\";\n }, 700);\n }, i * 320);\n });\n}\n\n// =============== PROB / SAMPLE ===============\nconst baseLogits = [\n { tok: \"·Paris\", logit: 10.5 },\n { tok: \"·a\", logit: 7.8 },\n { tok: \"·home\", logit: 7.0 },\n { tok: \"·one\", logit: 6.3 },\n { tok: \"·the\", logit: 5.9 },\n { tok: \"·also\", logit: 5.5 },\n { tok: \"·France\", logit: 4.3 }\n];\nfunction softmaxTemp(logits, T) {\n const scaled = logits.map(l => l / T);\n const m = Math.max(...scaled);\n const e = scaled.map(s => Math.exp(s - m));\n const sum = e.reduce((a, b) => a + b, 0);\n return e.map(x => x / sum);\n}\nfunction renderProbs(T = 1.0) {\n const probs = softmaxTemp(baseLogits.map(b => b.logit), T);\n const c = document.getElementById(\"probBars\"); c.innerHTML = \"\";\n baseLogits.forEach((b, i) => {\n const row = document.createElement(\"div\");\n row.className = \"prob-row\" + (i === 0 ? \" winner\" : \"\");\n row.innerHTML = `

\"${b.tok}\"

${(probs[i]*100).toFixed(1)}%

`;\n c.appendChild(row);\n });\n}\nrenderProbs(1.0);\ndocument.getElementById(\"tempSlider\").addEventListener(\"input\", e => {\n const T = e.target.value / 100;\n document.getElementById(\"tempVal\").textContent = T.toFixed(2);\n renderProbs(T);\n});\nfunction sampleToken() {\n const T = document.getElementById(\"tempSlider\").value / 100;\n const probs = softmaxTemp(baseLogits.map(b => b.logit), T);\n let r = Math.random(); let cum = 0; let chosen = 0;\n for (let i = 0; i < probs.length; i++) {\n cum += probs[i];\n if (r <= cum) { chosen = i; break; }\n }\n document.getElementById(\"sampleResult\").innerHTML =\n `Sampled (T=${T.toFixed(2)}): \"${baseLogits[chosen].tok}\" (p=${(probs[chosen]*100).toFixed(1)}%)`;\n}\n\n// =============== KV CACHE ===============\nconst promptTokens = [\"The\", \"·capital\", \"·of\", \"·France\", \"·is\"];\nconst decodeTokens = [\"·Paris\", \",\", \"·a\", \"·city\", \"·in\", \"·Europe\", \".\"];\nlet kvStep = 0;\nfunction renderKVCache() {\n const k = document.getElementById(\"kvCacheK\");\n const v = document.getElementById(\"kvCacheV\");\n k.innerHTML = \"\"; v.innerHTML = \"\";\n if (kvStep > 0) {\n promptTokens.forEach((t) => {\n [k, v].forEach(c => {\n const s = document.createElement(\"div\");\n s.className = \"kv-slot\";\n s.innerHTML = `

prefill

${t}`;\n c.appendChild(s);\n });\n });\n }\n for (let i = 0; i < kvStep - 1; i++) {\n [k, v].forEach(c => {\n const s = document.createElement(\"div\");\n s.className = \"kv-slot\";\n s.innerHTML = `

cached

${decodeTokens[i]}`;\n c.appendChild(s);\n });\n }\n}\nrenderKVCache();\nfunction kvGenerateOne() {\n const status = document.getElementById(\"kvStatus\");\n if (kvStep === 0) {\n kvStep = 1; renderKVCache();\n document.querySelectorAll(\"#kvCacheK .kv-slot, #kvCacheV .kv-slot\").forEach((el, i) => {\n el.style.opacity = \"0\"; el.style.transform = \"translateY(20px)\";\n setTimeout(() => { el.style.opacity = \"1\"; el.style.transform = \"translateY(0)\"; }, i * 70);\n });\n status.innerHTML = `Prefill phase complete. All 5 prompt tokens processed in parallel; K and V cached for every layer.`;\n return;\n }\n if (kvStep - 1 >= decodeTokens.length) {\n status.innerHTML = `Sequence complete. Reset to start again.`;\n return;\n }\n const newToken = decodeTokens[kvStep - 1];\n kvStep++; renderKVCache();\n const kSlots = document.querySelectorAll(\"#kvCacheK .kv-slot\");\n const vSlots = document.querySelectorAll(\"#kvCacheV .kv-slot\");\n const lastK = kSlots[kSlots.length - 1];\n const lastV = vSlots[vSlots.length - 1];\n if (lastK) {\n lastK.classList.add(\"new\");\n lastK.innerHTML = `

just computed

${newToken}`;\n setTimeout(() => {\n lastK.classList.remove(\"new\");\n lastK.innerHTML = `

cached

${newToken}`;\n }, 1500);\n }\n if (lastV) {\n lastV.classList.add(\"new\");\n lastV.innerHTML = `

just computed

${newToken}`;\n setTimeout(() => {\n lastV.classList.remove(\"new\");\n lastV.innerHTML = `

cached

${newToken}`;\n }, 1500);\n }\n const skipped = kSlots.length - 1;\n const total = kSlots.length;\n status.innerHTML = `Decode step ${kvStep - 1}: computed K and V for \"${newToken}\" only. The K/V of ${skipped} previous tokens were reused from cache — ${((skipped / total) * 100).toFixed(0)}% of attention work skipped.`;\n}\nfunction kvReset() {\n kvStep = 0; renderKVCache();\n document.getElementById(\"kvStatus\").innerHTML = \"\";\n}\n\n// =============== GENERATION LOOP (merged: canonical playback + real custom prompt) ===============\nconst CANONICAL_PROMPT = \"The capital of France is\";\nconst continuation = [\" Paris\", \",\", \" a\", \" city\", \" famous\", \" for\", \" art\", \" and\", \" food\", \".\"];\nconst genState = {\n maxTokens: 15,\n mode: \"greedy\",\n generatedCount: 0,\n promptText: CANONICAL_PROMPT,\n tokenIds: null,\n running: false,\n stop: false\n};\n\nfunction setGenMax(n) {\n genState.maxTokens = n;\n document.querySelectorAll(\"#genMaxChips .chip\").forEach(c => {\n const isActive = +c.textContent.trim() === n;\n c.classList.toggle(\"active\", isActive);\n c.classList.toggle(\"brick-active\", isActive);\n });\n}\nfunction setGenMode(mode) {\n genState.mode = mode;\n document.querySelectorAll(\"#genModeChips .chip\").forEach(c => {\n const txt = c.textContent.trim();\n const isActive = (mode === \"greedy\" && txt === \"greedy\") || (mode === \"sample\" && txt.startsWith(\"sample\"));\n c.classList.toggle(\"active\", isActive);\n c.classList.toggle(\"brick-active\", isActive);\n });\n}\n\nfunction onGenPromptEdit() {\n const inp = document.getElementById(\"genPromptInput\");\n if (!inp) return;\n genState.promptText = inp.value;\n genState.generatedCount = 0;\n genState.tokenIds = null;\n const display = document.getElementById(\"genDisplay\");\n if (display) display.innerHTML = `${escapeHtml(genState.promptText)}`;\n}\n\nfunction resetGen() {\n genState.stop = true;\n genState.running = false;\n genState.generatedCount = 0;\n genState.tokenIds = null;\n const inp = document.getElementById(\"genPromptInput\");\n const text = inp?.value || CANONICAL_PROMPT;\n genState.promptText = text;\n const display = document.getElementById(\"genDisplay\");\n if (display) display.innerHTML = `${escapeHtml(text)}`;\n}\n\nfunction appendGenToken(tokenStr) {\n const display = document.getElementById(\"genDisplay\");\n const cursor = display.querySelector(\".cursor\");\n if (cursor) cursor.remove();\n const span = document.createElement(\"span\");\n span.className = \"new\";\n span.textContent = tokenStr;\n span.style.opacity = \"0\";\n span.style.transform = \"translateY(6px)\";\n display.appendChild(span);\n requestAnimationFrame(() => {\n span.style.transition = \"all 0.32s cubic-bezier(0.34, 1.56, 0.64, 1)\";\n span.style.opacity = \"1\";\n span.style.transform = \"translateY(0)\";\n });\n setTimeout(() => span.classList.remove(\"new\"), 700);\n const newC = document.createElement(\"span\");\n newC.className = \"cursor\";\n display.appendChild(newC);\n}\n\nasync function generateOneReal() {\n if (!genState.tokenIds) {\n const enc = await REAL.tokenizer(genState.promptText, { return_tensor: false });\n genState.tokenIds = enc.input_ids.slice();\n }\n const T = REAL.Tensor;\n const inp = new T(\"int64\", BigInt64Array.from(genState.tokenIds.map(x => BigInt(x))), [1, genState.tokenIds.length]);\n const mask = new T(\"int64\", BigInt64Array.from(genState.tokenIds.map(() => 1n)), [1, genState.tokenIds.length]);\n const out = await REAL.model({ input_ids: inp, attention_mask: mask });\n const lT = out.logits;\n const [, S, V] = lT.dims;\n const lastStart = (S - 1) * V;\n const last = Array.from(lT.data.slice(lastStart, lastStart + V));\n\n let nextId;\n if (genState.mode === \"sample\") {\n const indexed = last.map((v, i) => ({ i, v }));\n indexed.sort((a, b) => b.v - a.v);\n const top = indexed.slice(0, 50);\n const maxL = top[0].v;\n const exps = top.map(t => Math.exp((t.v - maxL) / 0.8));\n const sum = exps.reduce((a, b) => a + b, 0);\n let r = Math.random(), cum = 0;\n nextId = top[0].i;\n for (let j = 0; j < top.length; j++) {\n cum += exps[j] / sum;\n if (r <= cum) { nextId = top[j].i; break; }\n }\n } else {\n let best = 0, bestVal = -Infinity;\n for (let j = 0; j < last.length; j++) {\n if (last[j] > bestVal) { bestVal = last[j]; best = j; }\n }\n nextId = best;\n }\n genState.tokenIds.push(nextId);\n return REAL.tokenizer.decode([nextId]);\n}\n\nasync function generateOne() {\n if (genState.running) return;\n if (genState.generatedCount >= genState.maxTokens) return;\n genState.running = true;\n try {\n let tokenStr;\n if (REAL.active && REAL.model && REAL.tokenizer) {\n tokenStr = await generateOneReal();\n } else {\n if (genState.promptText !== CANONICAL_PROMPT) {\n // Visual feedback: pulse the illustrative badge brick-red\n const badge = document.querySelector(\".mode-badge.mode-illust\");\n if (badge) {\n badge.style.transition = \"all 0.25s\";\n badge.style.background = \"var(--brick)\";\n badge.style.color = \"var(--paper)\";\n badge.style.borderColor = \"var(--brick)\";\n badge.style.transform = \"scale(1.08)\";\n setTimeout(() => {\n badge.style.background = \"\";\n badge.style.color = \"\";\n badge.style.borderColor = \"\";\n badge.style.transform = \"\";\n }, 1600);\n }\n const hint = document.getElementById(\"genHintIllust\");\n if (hint) {\n const orig = hint.innerHTML;\n hint.style.color = \"var(--brick)\";\n hint.style.fontWeight = \"700\";\n hint.innerHTML = \"↑ Flip on Run real GPT-2 at the top of the page to generate from a custom prompt.\";\n setTimeout(() => {\n if (hint) {\n hint.style.color = \"\";\n hint.style.fontWeight = \"\";\n hint.innerHTML = orig;\n }\n }, 2600);\n }\n return;\n }\n if (genState.generatedCount >= continuation.length) return;\n tokenStr = continuation[genState.generatedCount];\n }\n appendGenToken(tokenStr);\n genState.generatedCount++;\n } finally {\n genState.running = false;\n }\n}\n\nasync function generateAll() {\n if (genState.running) return;\n genState.stop = false;\n const limit = Math.min(\n genState.maxTokens,\n (REAL.active ? genState.maxTokens : continuation.length)\n );\n // Same-prompt early-exit handled by generateOne's guards\n for (let i = genState.generatedCount; i < limit; i++) {\n if (genState.stop) break;\n const beforeCount = genState.generatedCount;\n await generateOne();\n if (genState.generatedCount === beforeCount) break; // didn't generate (hint shown)\n await new Promise(r => setTimeout(r, 110));\n }\n}\n\n// =============== MASTER ARCHITECTURE SVG ===============\nconst ARCH_SVG = ``;\n\n// Inject into both containers\ndocument.getElementById('archHero').innerHTML = ARCH_SVG;\ndocument.getElementById('archMini').innerHTML = ARCH_SVG;\n\n// =============== STAGE → ARCH MAPPING + SCROLL TRACKING ===============\nconst SECTION_TO_STAGE = {\n start: 'start',\n tokenize: 'tokenize',\n embed: 'embed',\n position: 'position',\n attention: 'attention',\n multihead: 'attention',\n residual: 'residual',\n ffn: 'ffn',\n stack: 'stack',\n output: 'output',\n sample: 'sample',\n kvcache: 'kvcache',\n loop: 'loop',\n recap: ''\n};\n\nfunction setActiveStage(stage) {\n document.querySelectorAll('.arch-stage.arch-active').forEach(el => el.classList.remove('arch-active'));\n if (!stage) return;\n document.querySelectorAll(`.arch-stage[data-stage=\"${stage}\"]`).forEach(el => el.classList.add('arch-active'));\n}\n\n// IntersectionObserver to detect which section is most in view\nlet visibleSections = new Map();\nconst stageObserver = new IntersectionObserver((entries) => {\n entries.forEach(e => {\n if (e.isIntersecting) {\n visibleSections.set(e.target.id, e.intersectionRatio);\n } else {\n visibleSections.delete(e.target.id);\n }\n });\n // Find section with highest visibility\n let bestId = null; let bestRatio = 0;\n for (const [id, ratio] of visibleSections) {\n if (ratio > bestRatio) { bestRatio = ratio; bestId = id; }\n }\n if (bestId) {\n const stage = SECTION_TO_STAGE[bestId];\n setActiveStage(stage);\n }\n}, { threshold: [0, 0.15, 0.3, 0.5, 0.75, 1] });\ndocument.querySelectorAll('section.layer').forEach(s => stageObserver.observe(s));\n\n// Show/hide minimap based on scroll position.\n// Rule: only visible when the user has scrolled PAST the architecture overview.\n// IntersectionObserver alone can't distinguish \"above\" from \"below\" — both report\n// !isIntersecting — so we check the section's bounding rect directly on scroll.\nconst minimap = document.getElementById('minimap');\nconst archSection = document.querySelector('.arch-section');\nfunction updateMinimapVisibility() {\n if (!minimap || !archSection) return;\n const rect = archSection.getBoundingClientRect();\n // bottom < 0 means the arch-section has scrolled completely above the viewport\n // → we're past it → show minimap.\n // Otherwise (still above viewport, or intersecting) → hide.\n if (rect.bottom < 80) {\n minimap.classList.add('visible');\n } else {\n minimap.classList.remove('visible');\n }\n}\nwindow.addEventListener('scroll', updateMinimapVisibility, { passive: true });\nwindow.addEventListener('resize', updateMinimapVisibility, { passive: true });\nupdateMinimapVisibility(); // initial pass\n\n// =============== MOTION FADE-INS ===============\nwindow.addEventListener('motion-ready', () => {\n if (!window.M) return;\n const els = document.querySelectorAll('.tile, .story, .why, .insight, .tip, .warn, .cost, .state-bar, .compare');\n els.forEach((el) => {\n el.style.opacity = \"0\";\n el.style.transform = \"translateY(14px)\";\n });\n const obs = new IntersectionObserver((entries) => {\n entries.forEach(e => {\n if (e.isIntersecting) {\n window.M.animate(e.target,\n { opacity: 1, transform: \"translateY(0px)\" },\n { duration: 0.5, easing: [0.34, 1.56, 0.64, 1] }\n );\n obs.unobserve(e.target);\n }\n });\n }, { threshold: 0.06 });\n els.forEach(p => obs.observe(p));\n});\n",[133],"93d45ba6-a6d9-4902-aa0f-b4be309eaed8","main.ts",["D",1781527699489],"http","import { serveFile } from \"https://esm.town/v/std/utils/index.ts\";\n\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n const path = url.pathname;\n if (path === \"/styles.css\") return serveFile(\"./styles.css\", import.meta.url);\n if (path === \"/script.js\") return serveFile(\"./script.js\", import.meta.url);\n return serveFile(\"./index.html\", import.meta.url);\n}\n","transformer-viz-atiq",[140],"cc2a8629-0458-4285-a904-aa926d14ce5c","index.html","06822f5e-68a7-11f1-9fe5-1607ee4eb77e",11,["D",1781527696644],"\n\n\n\n\nHow GPT predicts \"Paris\" — A guided journey\n\n\n\n\n\n\n\n\n\n\n

Latest:

\n ATTENTION — Q·K dot productplanted\n KV CACHE — O(n²) → O(n)tended\n FFN — where facts liveplanted\n

\n \n Mode · Illustrative\n Loading GPT-2…\n Mode · Real · GPT-2 Live\n

\n\n\n\n\n\n

A guided journey from input → \"Paris\" · 13 stages · one prompt · every layer

est. 2026 / GPT-Viz Annual

\n\n\n

CHAPTER ZERO — INTRODUCTION

How GPT Decides Paris

We follow a single sentence — all five tokens of it — through every layer of a GPT model. By the end, you'll feel why each step exists, not just what it does.

\n \"The capital of France is\"\n →\n Paris\n

\n\n \n

\n \n

\n Optional. The blog is fully readable without this. Flip it on to see actual GPT-2 numbers replace the illustrative ones throughout.\n

\n\n\n

\n Index ::\n 01 · Input\n 02 · Tokenize\n 03 · Embed\n 04 · Position\n 05 · Attention\n 06 · Multi-Head\n 07 · Residual\n 08 · FFN\n 09 · ×96 Stack\n 10 · Output\n 11 · Sample\n 12 · KV Cache\n 13 · Loop\n ∎ Recap\n

\n\n\n

THE WHOLE PICTURE — BEFORE WE DIVE IN

One Forward Pass, Top to Bottom

This is the entire mechanism we're about to walk through. Every stage that follows highlights its component on the map.

\n\n\n\n\n\n

\n\n\n\n

01 Where we begin

The Question Arrives

\n\n

\n You type the sentence \"The capital of France is\" and hit enter. To you, this is a half-finished thought with an obvious completion. To the model, it's not even a sentence yet — it's a sequence of bytes. The model can't read English. It can't read characters. It can only do math on numbers. Everything that follows is the journey from those bytes to a single confident guess: \"Paris\".\n

\n\n

\n Current state:\n raw string · 24 bytes\n →\n about to become: tokens\n

\n\n

Our input str

\n \"The capital of France is\"\n

\n bytes: [84, 104, 101, 32, 99, 97, 112, 105, 116, 97, 108, 32, 111, 102, 32, 70, 114, 97, 110, 99, 101, 32, 105, 115]\n

\n\n\n\n

02 First transformation

The Tokenizer Chops It Up

\n\n

\n Before anything intelligent happens, the model needs to recognize chunks it knows. A BPE tokenizer scans the string and matches it against a fixed vocabulary of ~50,000 known pieces. Our sentence breaks neatly into 5 tokens. Each gets a permanent integer ID — its address in the vocabulary. From this point on, the model never sees letters again. It only sees these IDs.\n

\n\n

\n Current state:\n 5 token IDs\n →\n about to become: 5 meaning-vectors\n

\n\n

Our 5 tokens — meet the cast of this journey

\"The\"

id 464

\"·capital\"

id 3139

\"·of\"

id 286

\"·France\"

id 4881

\"·is\"

id 318

\n The last token, \"·is\", is highlighted because it's the one that matters most — its job is to predict what comes next. Everything else exists to help \"·is\" figure that out.\n

\n\n

\n Why sub-words and not whole words? A whole-word vocab would need millions of entries — every plural, tense, name, typo. A character vocab is too short; sequences explode. BPE finds the sweet spot: common words are one token, rare words decompose into pieces. \"France\" stays one token because it's common. A rare word like \"unhopefully\" gets split into several pieces (the actual split depends on the tokenizer's learned merges).\n

\n\n

\n The leading · on most of our tokens represents a literal space. \"France\" and \" France\" are different tokens. So is \"the\" vs \"The\". Capitalization and whitespace are part of identity.\n

\n\n \n

Live BPE Tokenizer

Type any text. GPT-2's tokenizer splits it in real-time below.

\n \n \n

\n Try: antidisestablishmentarianism (one word, many tokens) · π = 3.14159 (math symbols) · print(\"hello\") (code splits differently from prose) · 你好世界 (Chinese — each character ≈ 2 tokens in GPT-2's BPE)\n

\n\n

\n The 5 token IDs above are exact, from the real GPT-2 BPE tokenizer (tiktoken). The · prefix is our display convention for a literal space — GPT-2's internal byte-pair representation uses Ġ for the same role. From here on, vector bars, attention weights, FFN neuron patterns, and logit values are plausible illustrations shaped to teach the right intuition; they are not extracted from a running model. The architecture, math, dimensions, and complexity claims are exact. Want real values? Flip the Use real GPT-2 toggle at the top of the page.\n \n Real-model mode is active. Token IDs, top-7 logits, softmax probabilities, sampled token, generated continuation, and the live tokenizer playground are actual outputs from GPT-2 small (124M params, 2019) running on your device via transformers.js + ONNX Runtime Web. The cosine-similarity playground in Stage 03 uses all-MiniLM-L6-v2. Marked sections carry a tag.\n

\n One honest caveat: GPT-2 small is a small 2019 model with limited factual recall — it often doesn't predict \"Paris\" for our prompt (it tends to generate \"now the world's largest producer of food, and…\" instead). Bigger models (GPT-3, GPT-4, modern Claude / Gemini) do reliably answer \"Paris.\" The illustrative numbers throughout reflect what large models do; the real top-7 above shows you what a tiny model actually outputs.\n

\n What stays illustrative even in real mode: the Stage 5 attention bars and Stage 3 embedding vector bars — GPT-2's ONNX export doesn't expose attention probabilities or hidden states. FFN neurons, multi-head specializations, and per-block stack labels are conceptual abstractions that don't map to single layer outputs.\n \n

\n\n\n\n

03 Giving tokens meaning

From IDs to Vectors of Meaning

\n\n

\n A token ID like 4881 is meaningless on its own. The model holds a giant lookup table — its embedding matrix, with one row per token ID. Looking up row 4881 returns a fat vector: in GPT-3, 12,288 numbers. These numbers were tuned during training to place tokens with similar meanings near each other in vector space. \"France\" ended up near \"Germany\", \"Italy\", and \"Japan\" — not because anyone told it to, but because those words appeared in similar contexts. Our 5 tokens become 5 vectors. Same shape, different meanings.\n

\n\n

\n Current state:\n 5 vectors · no position yet\n →\n about to gain: position\n

\n\n

Each token lights up its dimensions\n ○ STAYS ILLUSTRATIVE\n

\"The\"

\"·capital\"

\"·of\"

\"·France\"

\"·is\"

\n 32 DIMS SHOWN. REAL MODELS: 768 (GPT-2) — 12,288 (GPT-3). EACH ROW = ONE TOKEN'S \"MEANING FINGERPRINT\".\n

\n\n

\n The key intuition: embeddings encode meaning as direction. Mathematical operations on these vectors map to semantic operations. The famous example: king − man + woman ≈ queen. By the time training finishes, \"France\"'s vector is geometrically close to other countries — near words like \"Paris\", \"European\", \"nation\" — and far from \"banana\" or \"Tuesday\". The model didn't memorize this. It emerged from billions of training sentences.\n

\n\n

\n The embedding table for GPT-3 is 50,257 × 12,288 ≈ 617M parameters just to map IDs to vectors. Almost a full GPT-2 model, used purely as a dictionary.\n

\n\n \n

Compare two words · cosine similarity

\n Compare actual learned embeddings of any two words or phrases. Cosine similarity is +1 if identical, 0 if unrelated, −1 if opposite. Watch how concepts cluster. (Powered by all-MiniLM-L6-v2, a 25 MB sentence-embedding model — loaded on first click.)\n

\n \n vs\n \n \n

\n Try: France / Italy (countries) · King / Queen · cat / kitten · cat / airplane (unrelated) · run / walked · happy / sad (antonyms — still positive!)\n

\n\n \n

Compare many words · pairwise heatmap

\n Type up to 6 words. See every pairwise similarity as a heatmap. Watch related concepts cluster together — the diagonal is always 1.00 (self-similarity), and groups of related words form darker patches.\n

\n \n \n \n \n \n \n

\n \n

\n Try mixing categories: dog / cat / lion / hammer / saw / drill — should form two clear clusters (animals vs tools).\n

\n\n\n\n

04 Adding order

\"France is\" ≠ \"is France\"

\n\n

\n There's a problem. The next stage — attention — computes sums of these vectors. Sums don't care about order. Without position information, \"France is\" and \"is France\" would produce identical outputs. To fix this, the model adds a position vector to each token's embedding. Position 0 has its own vector. Position 1 has another. Position 4 has another. These are added directly into the token vectors. Now \"·France\" sitting at position 3 is mathematically distinguishable from \"·France\" sitting at position 0.\n

\n\n

\n Current state:\n 5 vectors · meaning + position\n →\n about to enter: attention\n

\n\n

Position Playground · drag to move \"·France\"

\n Move the slider to put \"·France\" at different positions. Watch its position vector — and the resulting sum — change. The token's meaning stays the same; only its place updates.\n

\n Position:\n

\n \n \n \n \n \n

\n ← in the prompt \"The capital of France is\", France sits at position 3\n

\"·France\" tok

+ position 3

= sum

\n Same token (top row stays put). Position vector (middle) shifts every time. Sum (bottom) is what actually enters attention.\n

\n\n

\n Concat — rejected\n Half the vector for meaning, half for position. Wastes capacity, can't directly interact.\n

\n Add — used\n Same vector encodes both. The model learns to disentangle internally — for free.\n

\n\n\n\n

05 The heart of GPT

\"·is\" Sends Out a Query

\n\n

\n Now the most important moment. Our final token \"·is\" has one job — figure out what comes next. So it does what every token here does: it sends out a query vector, essentially asking \"who in this sentence has information that's relevant to me?\" Every other token offers a key vector — its \"tag\" advertising what kind of token it is. The dot product between query and key tells us how well they match. \"·is\" is going to find out, very quickly, that two tokens matter the most: \"·capital\" (the role) and \"·France\" (the country).\n

\n\n

\n Current state:\n 5 vectors with position\n →\n about to become: 5 context-mixed vectors\n

\n\n

Step 1 — Why three vectors (Q, K, V) instead of using the token vector directly?

\n You might ask: why bother making Q and K? Couldn't \"·is\" just dot its raw vector against the others? Here's why not:\n

\n No projections\n Dot products would be symmetric: \"is\" → \"France\" would equal \"France\" → \"is\". But language is directional. \"is\" needs to look at the noun. The noun shouldn't necessarily look at \"is\".\n

\n With Q, K, V\n Each token projects through 3 different learned matrices. Now \"is\" can have a Q that points exactly where \"France\"'s K points — without forcing the reverse. Asymmetric attention.\n

X · W_Q  →  Q   # what am I asking?\nX · W_K  →  K   # what tag do I broadcast?\nX · W_V  →  V   # what content do I send if chosen?

\n\n

Step 2 — How \"·is\" scores one other token (e.g. \"·France\")

\n We dot the Q vector from \"·is\" against the K vector from \"·France\". That means: multiply each pair of dimensions, then sum them up. The result is one number — how strongly \"·is\" wants to look at \"·France\".\n

Q vector from \"·is\"

K vector from \"·France\"

Element-wise products

Click below to watch the dot product build up dimension by dimension.

—

\n \n \n

\n Geometric intuition: a dot product is large when two vectors point in the same direction. So Q and K live in the same imagined space — high dot product means \"this query matches this tag.\"\n

\n\n

Step 3 — \"·is\" scores all 5 tokens\n ○ STAYS ILLUSTRATIVE\n

\n That dot-product calculation runs against every previous token. After scaling (÷√d) and softmax, we get a probability distribution — how much \"·is\" \"looks at\" each token. Notice where the weight lands.\n

\n \n

\n The biggest weights land on \"·capital\" and \"·France\" — exactly the tokens that define what the answer is supposed to be.\n

\n\n \n

Live Attention Playground · type any sentence

\n Type a sentence below. We tokenize it, look up real MiniLM-L6 embeddings for every token, then compute real softmax(Q·Kᵀ/√d) self-attention right here in your browser. Click any token to see what it attends to — and toggle the causal mask to see how GPT-style \"no peeking forward\" changes the pattern.\n

\n \n \n

\n\n

\n \n \n scale by 1/√d\n \n \n \n apply causal mask (GPT-style)\n \n \n temperature\n \n 1.00\n \n

\n\n

Click a token to make it the query:

\n\n

\n The math here is identical to what runs inside every transformer layer of GPT-2, GPT-4, Claude, etc.: dot-product attention with optional scaling and masking. The only difference is we use MiniLM's pre-trained 384-dim embeddings as both Q and K (instead of per-layer learned projections), since browsers can't yet expose intermediate attention weights from a real LM's ONNX export.\n

\n\n

Step 4 — \"·is\" becomes an enriched version of itself

\n With those weights, \"·is\" now computes a weighted sum of the V vectors from all 5 tokens. It mostly absorbs values from \"·capital\" and \"·France\", with smaller contributions from the rest. The result replaces \"·is\"'s own vector going forward.\n

new_is_vector = 0.08·V_The + 0.34·V_capital + 0.05·V_of + 0.41·V_France + 0.12·V_is

\n \"·is\" is no longer a pure copy of the word \"is\". It now contains the influence of \"capital\" and \"France\". The same operation happens for every other token in parallel — each one mixes in whatever earlier context matters most to it. This is attention. There's nothing more to it.\n

\n\n

Why /√d before softmax?

Dot products grow with vector dimension. Without scaling, the score for the best match becomes huge — softmax collapses to ~100% on one token. Gradients die. Scaling by √d keeps the distribution healthy.

Why mask future tokens?

During training the model sees full sentences like \"The capital of France is Paris\" and learns to predict every token from the ones before it. Without a mask, the position predicting \"·is\" could attend to \"·Paris\" and trivially copy the answer. The fix: set scores for positions to the right of each query to −∞ before softmax. e^−∞=0, so they contribute nothing. At inference there's nothing to mask in our 5-token prompt — the rule simply continues to apply.

\n\n

\n Attention is O(n²·d). Going from 4k to 32k context = 64× more attention compute, the central reason long contexts get expensive.\n

\n\n\n\n

06 Different questions, in parallel

The Model Does That, But Many Times

\n\n

\n What you just saw — \"·is\" querying all other tokens — was one attention head. But one head can only learn one kind of question. So GPT runs many heads in parallel, each with its own W_Q, W_K, W_V. Different heads specialize: one looks for the proper noun, another for the role, another for syntactic glue, another for distant references. Each head produces its own enriched \"·is\" vector. Then they're concatenated and projected back to a single vector. The \"is\" that comes out has been examined from many angles at once.\n

\n\n

What each head might be paying attention to illustrative

↓ concat(head_1, ..., head_n) · W_O

\n a single \"·is\" vector, enriched by 12 different perspectives\n

\n \n

\n\n

\n Mechanistic interpretability research has identified real GPT heads that match brackets, copy the previous token, find the subject of the sentence, and dozens more. Nobody designed these behaviors — they emerged from training.\n

\n\n\n\n

07 Don't forget who you were

Add the Old \"·is\" Back In, Then Normalize

\n\n

\n Attention just replaced our \"·is\" vector with a context-mixed version. But we don't want to throw away the original — that information might still be useful for the next layer. So we add the original back in: new_is = is_before + attention_output. This is the residual connection. Then we run LayerNorm to keep the numbers in a healthy range — without it, repeated additions across 96 layers would blow up.\n

\n\n

The bookkeeping (pre-norm, used by GPT-2/3 and modern models)

x_out = x + SubLayer( LayerNorm(x) )\n        └┬┘   └────────────┬─────────────┘\n       keep             new info

\n The original 2017 Transformer wrapped the norm around the residual (post-norm). GPT-2 onward moved the norm inside the residual branch (pre-norm) — it trains much more stably at depth. Most modern open models (LLaMA, Mistral, Gemma) further replace LayerNorm with RMSNorm — same idea, no mean-centering, cheaper.\n

\n\n \n

Try it · gradient flow through 12 layers

\n Flip the toggle to see what would happen during training. The bars show how much of the gradient survives back-propagating from layer 12 down to layer 1.\n

\n \n \n

\n Without residuals, gradient magnitude collapses exponentially with depth — early layers stop learning. With residuals, the identity path keeps the gradient near 1.0 even at the bottom of a deep stack.\n

\n\n

\n Why residuals exist at all? When training a 96-layer network, gradients have to flow backward through all 96 multiplications. Each one can shrink them. The residual x + f(x) always provides a clean identity path — gradients reach early layers without dying. Without residuals, deep networks simply don't learn. This single trick unlocked everything past ~20 layers.\n

\n\n\n\n

08 Where facts live

The Feed-Forward Net Thinks About \"·is\"

\n\n

\n Attention told us who to listen to. Now the model needs to do something with that. The Feed-Forward Network is applied to each token's vector independently. For our \"·is\" — which now carries information about \"capital\" and \"France\" — the FFN acts like a giant associative memory. The pattern \"capital + France + is\" activates a specific set of neurons in the hidden layer. Those neurons collectively encode \"the answer is Paris.\" They nudge the \"·is\" vector in a direction that, in vector space, points toward the word \"Paris\".\n

\n\n

\n \"·is\" Meaning:\n \"capital-of-France-is...\"\n →\n becoming: \"...basically Paris\"\n

\n\n

The FFN expands, activates, contracts

FFN(x) = W_2 · GELU( W_1 · x + b_1 ) + b_2\n\n# x:   (768,)            ← our \"is\" vector\n# W_1: (3072, 768)       → expand to 4× wide\n# W_2: (768, 3072)       → project back down

\n\n

Hidden layer neurons (mustard = active for general context · brick = \"Paris-knowing\" neurons):

\n \n \n

\n\n

\n Where does GPT \"remember\" that Paris is the capital of France? Probing research suggests this kind of factual knowledge lives in FFN weights, not attention. Attention routes context; the FFN turns that context into \"thinking\" — including looking up facts. They're a giant key-value memory whose keys are attention outputs and whose values are concept directions.\n

\n\n

\n FFN holds ~⅔ of all parameters in a transformer. Attention gets the headlines, but the MLPs hold most of the weights and most of the knowledge.\n

\n\n\n\n

09 Depth is where intelligence lives

That Whole Thing — 96 Times

\n\n

\n Everything you just saw — attention, residual, FFN, residual — is one transformer block. GPT-3 has 96 of them stacked. Each takes the previous block's output and refines it further. The intelligence isn't in any one block — it's in the refinement across depth.\n

\n (Illustrative narrative:) By block 5, our \"·is\" vector knows it's part of a fact-completion task. Around the middle layers, the model retrieves and commits to \"Paris\" as the answer — probing studies consistently localize factual recall to middle layers, not the final ones. By the late layers, the vector has been transformed into something close to the input embedding of \" Paris\", ready for the unembedding step.\n

\n\n

What changes across the stack illustrative

\n \n

\n\n

Real depths

GPT-2 small: 12 layers, 124M params
GPT-2 XL: 48 layers, 1.5B
GPT-3: 96 layers, 175B
LLaMA-3 70B: 80 layers, 70B
LLaMA-3.1 405B: 126 layers, 405B
GPT-4 (unconfirmed leaks): ~120 layers, MoE, ~1.7T total

Why so deep?

Each block can refine the representation a little. Stacking many lets the model build up reasoning, world knowledge, and answer synthesis in increments. Depth + scale + data = the capability we call \"intelligence.\"

\n\n\n\n

10 Turning the vector back into a word

What Word Lives in This Vector?

\n\n

\n After 96 blocks of refinement, the final vector for \"·is\" is dense with meaning that essentially says \"the next token should be Paris.\" But it's still a vector — 12,288 numbers. We need to turn it back into a token. The model takes this vector and asks every word in the vocabulary: \"how close are you to this vector?\" That's done with one matrix multiplication: last_vec · W_unembed. The result is one logit per vocabulary entry — 50,257 numbers, one per token. The bigger the number, the more the model wants that token.\n

\n\n

\n Current state:\n 1 vector for \"·is\"\n →\n becoming: 50,257 scores\n

\n\n

Top 7 logits (out of 50,257)

\n Show top:\n

\n \n \n \n \n

logits[\"·Paris\"]   = 10.5   ← winning\nlogits[\"·a\"]       = 7.8\nlogits[\"·home\"]    = 7.0\nlogits[\"·one\"]     = 6.3\nlogits[\"·the\"]     = 5.9\nlogits[\"·also\"]    = 5.5\nlogits[\"·France\"]  = 4.3   ← the model \"knows\" not to repeat\n...                       (50,250 more)

\n\n

\n Weight tying: in GPT-2 and GPT-3, W_unembed is literally the transpose of the input embedding matrix W_embed. The same map that turned IDs into vectors is reused (in reverse) to score vectors against IDs — saving ~600M params at GPT-3 scale and forcing a consistent meaning space. Most modern open models (LLaMA-2/3, Mistral, PaLM, Falcon) don't tie weights — they let the unembedding learn its own mapping.\n

\n\n\n\n

11 Making it a probability

Softmax: Logits Become Probabilities

\n\n

\n Logits aren't probabilities yet — they're raw scores. We apply softmax: exponentiate everything (kills negatives, amplifies big scores), then normalize so they sum to 1. \"·Paris\" now has 87% probability. \"·a\" has 4%. The rest have crumbs. Most of the time we just pick the highest, but with a non-zero temperature, we can sample probabilistically — giving the model the option to be more creative.\n

\n\n

probs = softmax(logits / T)

\n Temperature\n \n 1.00\n \n \n \n \n

\n\n

\n Why ever sample, instead of always picking the top? Greedy decoding gets repetitive (\"Paris. Paris. Paris.\") and stuck in safe phrasings. A calibrated bit of randomness produces text that's both coherent and varied. Temperature is the dial: low = confident and deterministic, high = creative and risky.\n

\n Try sampling 100× at temperature 0.20 vs 1.50. At low T, \"Paris\" wins almost every time. At high T, a long tail of less-likely tokens starts showing up. This is the diversity-vs-coherence trade-off, visible in the histogram.\n

\n\n\n\n

12 Don't recompute what you already know

Caching the Past So We Can Move Fast

\n\n

\n We just generated \"·Paris\". The conversation isn't done — maybe we want a longer sentence: \"The capital of France is Paris, a city famous for…\". To predict the next token, the model needs to do attention again, on 6 tokens now. But here's the trick: the K and V vectors for the original 5 tokens haven't changed. They depend only on each token's own context. So we cache them. Only the new \"·Paris\" token needs fresh K and V. That's the KV cache — and it's the reason ChatGPT can stream tokens in milliseconds instead of seconds.\n

\n\n

\n KV Cache:\n empty → 5 slots filled (prefill) → +1 per new token\n

\n\n

Watch the cache grow as we generate

K cache · each slot holds one token's K across all 96 layers

V cache

\n \n \n

\n\n

\n Without cache\n Recompute K and V for every prior token at every step. Each step costs O(n²) (full attention over n tokens). Generating a sequence of n tokens: O(n³) total.\n

\n With cache\n Only the new token's K and V are computed. Each step still attends over n cached K/V, so it's O(n) per step. Generating n tokens: O(n²) total. One full power lower in n.\n

\n\n

\n Cache memory ≈ 2 · n_layers · seq_len · (n_kv_heads · d_head) · bytes. LLaMA-3 70B uses Grouped-Query Attention (8 KV heads of 128 dim each, 80 layers) — at 32k context in fp16 that's ~10 GB per user. Without GQA the same model would need ~80 GB. This is why long contexts are expensive — and why \"cached input\" tokens in APIs cost 50–90% less than fresh prefills (the cache was already built).\n

\n\n

\n Real-world optimizations: PagedAttention (vLLM) treats the cache like virtual memory. GQA / MQA (LLaMA-3, Mistral) share K/V across attention heads to shrink cache 4–8×. Continuous batching packs multiple users' caches together. These are the engineering behind low API latency.\n

\n\n\n\n

13 One token at a time, forever

And Then We Loop

\n\n

\n We have \"·Paris\". We append it. Now the prompt is \"The capital of France is Paris\". The whole journey starts again — but thanks to the KV cache, almost all the work for the first 5 tokens is skipped. The model produces the next token. Then the next. Then the next. Generation is just this loop, run until the model decides it's done (by producing an end-of-sequence token).\n

\n\n

\n Generation · edit the prompt, watch GPT continue\n ○ ILLUSTRATIVE\n ⚡ REAL · GPT-2 LIVE\n

Edit the prompt below, then click Generate.

\n \n

\n The capital of France is\n

\n \n \n \n

\n Max new tokens:\n

\n \n \n \n

\n Sampling:\n \n \n \n \n \n \n

\n Try: The recipe calls for · Dear sister, · def fibonacci(n): · In the year 2099, · any sentence fragment. GPT-2 is from 2019 — fluent at style, loose with facts.\n

# The full generation loop, in essence\ntokens = tokenize(prompt)\nkv_cache, hidden = model.prefill(tokens)         # one parallel pass, O(n²·d) attention\n\nwhile len(tokens) < max_length:\n    logits, kv_cache = model.decode(tokens[-1], kv_cache)   # O(n·d) attention per step\n    next_id = sample(softmax(logits / T))\n    tokens.append(next_id)\n    if next_id == EOS: break\n\nprint(detokenize(tokens))

\n\n

\n The model itself has no memory between API calls. When you continue a chat, the entire conversation is re-sent as the prompt every time. The model is stateless. Modern APIs (Anthropic, OpenAI) now offer prompt caching that keeps KV state alive for minutes between requests — but that's an infrastructure optimization, not memory in the model. The weights don't change; the cache is just a way to avoid re-prefilling the same tokens.\n

\n\n

\n The \"typing speed\" you see when ChatGPT streams is real, not a UI effect. Each token = one full forward pass through 96 layers in the decode phase. 50 tokens/second = each layer running in roughly 200 microseconds on a GPU.\n

\n\n\n\n

∎ Recap · All 13 stages

The Whole Journey, On One Page

\n\n

\n Pull back from the details. Here's everything you just watched — the entire mechanism that turns \"The capital of France is\" into \"Paris\":\n

\n\n

  USER PROMPT: \"The capital of France is\"\n            │\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 01. TOKENIZE                         │ string → 5 IDs\n   └──────────────────────────────────────┘\n            │  [464, 3139, 286, 4881, 318]\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 02. EMBED                            │ IDs → dense meaning vectors\n   └──────────────────────────────────────┘\n            │  \"France\"-vec ≈ \"Italy\"-vec, far from \"banana\"\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 03. + POSITION                       │ add ordering info\n   └──────────────────────────────────────┘\n            │\n            ▼\n   ╔══════════════════════════════════════╗\n   ║   ┌─────────────────────────────┐    ║\n   ║   │ 04. ATTENTION                │    ║ \"·is\" looks at \"·capital\"\n   ║   │   Q,K,V projections         │    ║ and \"·France\" most strongly\n   ║   │   softmax(Q·Kᵀ/√d) · V      │    ║\n   ║   └────────────┬────────────────┘    ║\n   ║                ▼                     ║\n   ║   ┌─────────────────────────────┐    ║\n   ║   │ 05. MULTI-HEAD               │    ║ 12+ heads in parallel\n   ║   └────────────┬────────────────┘    ║\n   ║                ▼                     ║   × 96\n   ║   ┌─────────────────────────────┐    ║   layers\n   ║   │ 06. RESIDUAL + NORM          │    ║\n   ║   └────────────┬────────────────┘    ║\n   ║                ▼                     ║\n   ║   ┌─────────────────────────────┐    ║\n   ║   │ 07. FEED-FORWARD MLP         │    ║ activates Paris-neurons\n   ║   └────────────┬────────────────┘    ║\n   ║                ▼                     ║\n   ║   ┌─────────────────────────────┐    ║\n   ║   │ 08. RESIDUAL + NORM          │    ║\n   ║   └─────────────────────────────┘    ║\n   ╚══════════════════════════════════════╝\n            │  \"·is\" vector now points toward \"Paris\"\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 09. UNEMBED → LOGITS                 │ score against every vocab token\n   └──────────────────────────────────────┘\n            │\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 10. SOFTMAX → PROBS                  │ \"Paris\" = 87%\n   └──────────────────────────────────────┘\n            │\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 11. SAMPLE                            │ pick a token\n   └──────────────────────────────────────┘\n            │  → \"·Paris\"\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 12. STORE IN KV CACHE                │ K, V for \"·Paris\" cached\n   └──────────────────────────────────────┘\n            │\n            ▼\n   ┌──────────────────────────────────────┐\n   │ 13. LOOP — generate next             │ append, repeat\n   └──────────────────────────────────────┘

\n\n

If you remember 7 things

Embeddings turn IDs into geometric meaning.
Position is added so order survives.
Q/K/V let each token ask asymmetric questions.
Dot product + softmax = similarity → weights.
Multi-head + FFN = many views, then per-token thinking.
Residual + LayerNorm make deep stacking trainable.
KV cache drops generation one full power of n — O(n³)→O(n²).

What training actually adjusts

Architecture is fixed. Training tunes the numbers inside:

Embedding & unembedding matrices
W_Q, W_K, W_V, W_O for every head × every layer
W_1, W_2 in every FFN
LayerNorm scales

For GPT-3 that's 175B numbers, tuned by gradient descent on terabytes of text.

\n\n

\n What GPT really is: a very large, very carefully tuned next-token predictor. Everything else — answering, reasoning, coding, creativity — emerges from doing that one task well, at sufficient scale, on diverse enough data.\n

\n\n

\n One sentence to keep: \"GPT turns text into vectors, lets those vectors talk to each other and reshape themselves across many layers, then turns the final vector back into a probability over the next token — and repeats.\"\n

\n\n

\n\n\n\n\n\n\n\n\n\n\n\n\n",[147],"pulls","branches","forks","envVars",{"_160":125,"_162":125},"connections",{"_160":125,"_161":125},"count","unfilledCount","emptyCount",{"_18":146,"_20":147,"_117":148,"_119":-5,"_120":72,"_121":149,"_123":39,"_22":177,"_69":43,"_126":100,"_127":151,"_129":26,"_130":-5,"_168":178,"_89":179},{"_18":139,"_20":140,"_117":37,"_119":-5,"_120":72,"_121":70,"_123":39,"_22":174,"_69":43,"_126":142,"_127":143,"_129":26,"_130":144,"_168":175,"_89":176},{"_18":132,"_20":133,"_117":134,"_119":-5,"_120":72,"_121":135,"_123":39,"_22":171,"_69":125,"_126":100,"_127":137,"_129":26,"_130":-5,"_168":172,"_89":173},{"_18":115,"_20":116,"_117":118,"_119":-5,"_120":72,"_121":122,"_123":39,"_22":167,"_69":125,"_126":100,"_127":128,"_129":26,"_130":-5,"_168":169,"_89":170},["D",1781527697705],"children",[],[116],["D",1781527698948],[],[133],["D",1781527699489],[],[140],["D",1781527696644],[],[147],["D",1781519848496],["D",1789464074488],{"_16":17,"_87":83},{"_16":17,"_81":-5,"_82":83,"_34":35,"_84":85,"_86":26},{"_69":70,"_20":71,"_18":72,"_73":19,"_74":-5,"_75":-5,"_76":-5,"_77":-5,"_78":-5,"_79":21,"_80":17},"ctx",{"_62":-5,"_108":218,"_219":220,"_221":222,"_223":26,"_224":26,"_225":26,"_226":39,"_227":-5,"_228":-7,"_229":-7,"_230":125,"_231":26,"_232":26,"_233":-5,"_234":26,"_235":26,"_236":26,"_237":-5},"ENV",{"_189":190,"_191":192,"_193":71,"_194":195,"_196":197,"_198":199,"_200":201,"_202":203,"_204":205,"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

Search