{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 🧠 Tokenization & Embeddings\n", "\n", "How does a sentence become a list of vectors β€” and what does that space actually look like?\n", "\n", "We'll use **Qwen 3.6-35B-A3B**'s tokenizer (our actual model).\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using device: cuda\n" ] } ], "source": [ "import torch\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import safetensors\n", "from huggingface_hub import hf_hub_download\n", "from collections import Counter\n", "from sklearn.decomposition import PCA\n", "from transformers import AutoTokenizer\n", "import requests\n", "import json\n", "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Using device: {device}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## Section 0 β€” The Full Pipeline\n", "\n", "Before we dive into *how* tokenization works, let's see the whole thing in action.\n", "\n", "**Text β†’ Tokenize β†’ Prefill β†’ Decode β†’ de-Tokenize β†’ Text**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 0.1 β€” Load Qwen's Tokenizer\n", "\n", "This is the actual tokenizer used by our 35B model running on atom (the DGX Spark)." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vocabulary size: 248,044\n", "Special tokens: ['<|im_end|>', '<|endoftext|>', '<|audio_start|>', '<|audio_end|>', '<|audio_pad|>', '<|image_pad|>', '<|video_pad|>', '<|vision_start|>', '<|vision_end|>']\n" ] } ], "source": [ "qwen_tok = AutoTokenizer.from_pretrained(\"Qwen/Qwen3.6-35B-A3B\", trust_remote_code=True)\n", "print(f\"Vocabulary size: {qwen_tok.vocab_size:,}\")\n", "print(f\"Special tokens: {qwen_tok.all_special_tokens}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**248,044 tokens.** That's Qwen's vocabulary β€” everything it can say, encoded as integers." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 0.2 β€” Text β†’ Token IDs\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Prompt: Gentrification is a complex and multifaceted process \n", "β†’ 12 tokens\n", "\n", " 0 | G ( 38)\n", " 1 | entr ( 23003)\n", " 2 | ification ( 2325)\n", " 3 | ␣is ( 369)\n", " 4 | ␣a ( 264)\n", " 5 | ␣complex ( 6150)\n", " 6 | ␣and ( 321)\n", " 7 | ␣multif ( 59217)\n", " 8 | ac ( 565)\n", " 9 | eted ( 23706)\n", " 10 | ␣process ( 1817)\n", " 11 | ␣ ( 220)\n" ] } ], "source": [ "prompt = \"Gentrification is a complex and multifaceted process \"\n", "input_ids = qwen_tok.encode(prompt)\n", "tokens = qwen_tok.convert_ids_to_tokens(input_ids)\n", "\n", "print(f\"Prompt: {prompt}\")\n", "print(f\"β†’ {len(input_ids)} tokens\")\n", "print()\n", "for i, (tok, tid) in enumerate(zip(tokens, input_ids)):\n", " print(f\" {i:2d} | {str(tok).replace('Δ ', '␣'):>20} ({tid:>6})\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These integers are what is sent to the LLM.\n", "\n", "**Inside the model, each integer becomes a 2048-dimensional vector via a lookup table called the embedding matrix.**\n", "\n", "We'll explore exactly how that works in Part 2. For now, let's send these token IDs through the full model on atom.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 0.3 β€” Tokens β†’ LLM (atom)\n", "\n", "We send the token IDs to the vLLM server running on the DGX Spark. The model processes them\n", "and returns new token IDs." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "βœ… atom responded!\n", "\n", "Output: Gentrification is a complex and multifaceted process 1. It involves the transformation of a\n" ] } ], "source": [ "API_BASE = \"http://aitopatom-0a62.local:8000/v1\"\n", "MODEL_NAME = \"Qwen/Qwen3.6-35B-A3B\"\n", "\n", "def query_model(prompt, max_tokens=8):\n", " try:\n", " response = requests.post(\n", " f\"{API_BASE}/completions\",\n", " json={\n", " \"model\": MODEL_NAME,\n", " \"prompt\": prompt,\n", " \"max_tokens\": max_tokens,\n", " \"temperature\": 0.0,\n", " \"echo\": True, # include prompt in response\n", " },\n", " headers={\"Authorization\": \"Bearer EMPTY\"},\n", " timeout=30,\n", " )\n", " return response.json()\n", " except Exception as e:\n", " return {\"error\": str(e)}\n", "\n", "result = query_model(prompt)\n", "print(\"βœ… atom responded!\")\n", "print()\n", "# Parse the response\n", "text = result[\"choices\"][0][\"text\"]\n", "all_tokens = result.get(\"usage\", {}).get(\"completion_tokens\", []) # not always available\n", "print(f\"Output: {text}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Key takeaway from the pipeline:** The model on atom takes our token IDs, processes them through 40 transformer layers,\n", "and returns new token IDs. How exactly those token IDs become vectors β€” and what the vector space looks like β€”\n", "is what we'll uncover next.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## Section 1 β€” From Text to Tokens" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1 β€” The goal of tokenization is **Vocabulary Compression**\n", "\n", "Qwen uses a **BPE (Byte-Pair Encoding)** tokenizer (like GPT-4, Claude, and most modern models).\n", "Common words stay as single tokens; rare words decompose into known pieces." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Word Qwen Tokens \n", "──────────────────────────────────────────────────────────────────────\n", "transformer ['transform', 'er'] \n", "revolutionized ['revolution', 'ized'] \n", "NLP ['N', 'LP'] \n", "embedding ['embedding'] \n", "attention ['attention'] \n" ] } ], "source": [ "# Compare: a word that might split differently\n", "words = [\"transformer\", \"revolutionized\", \"NLP\", \"embedding\", \"attention\"]\n", "\n", "print(f\"{'Word':<20} {'Qwen Tokens':<50}\")\n", "print(f\"{'─'*70}\")\n", "for word in words:\n", " qwen_toks = qwen_tok.tokenize(word)\n", " print(f\"{word:<20} {str(qwen_toks):<50}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 β€” How BPE Actually Works\n", "\n", "Let's build a tiny BPE from scratch. This is the same algorithm that trained Qwen's 248k-token vocabulary." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running BPE merges...\n", " Step 0: merged ('e', 'r') (count=65) β†’ 'er'\n", " Step 1: merged ('er', '') (count=50) β†’ 'er'\n", " Step 2: merged ('t', '') (count=50) β†’ 't'\n", " Step 3: merged ('e', 's') (count=35) β†’ 'es'\n", " Step 4: merged ('es', 't') (count=35) β†’ 'est'\n", " Step 5: merged ('o', 'r') (count=30) β†’ 'or'\n", " Step 6: merged ('e', 'a') (count=30) β†’ 'ea'\n", " Step 7: merged ('a', 'l') (count=30) β†’ 'al'\n", " Step 8: merged ('al', 'l') (count=30) β†’ 'all'\n", " Step 9: merged ('i', 'g') (count=30) β†’ 'ig'\n", " Step 10: merged ('ig', 'h') (count=30) β†’ 'igh'\n", " Step 11: merged ('p', 'l') (count=15) β†’ 'pl'\n", " Step 12: merged ('pl', 'a') (count=15) β†’ 'pla'\n", " Step 13: merged ('pla', 'y') (count=15) β†’ 'play'\n", " Step 14: merged ('er', 's') (count=15) β†’ 'ers'\n", " Step 15: merged ('ers', '') (count=15) β†’ 'ers'\n", " Step 16: merged ('w', 'or') (count=15) β†’ 'wor'\n", " Step 17: merged ('wor', 'k') (count=15) β†’ 'work'\n", " Step 18: merged ('t', 'ea') (count=15) β†’ 'tea'\n", " Step 19: merged ('tea', 'c') (count=15) β†’ 'teac'\n", " Step 20: merged ('teac', 'h') (count=15) β†’ 'teach'\n", " Step 21: merged ('t', 'all') (count=15) β†’ 'tall'\n", " Step 22: merged ('g', 'r') (count=15) β†’ 'gr'\n", " Step 23: merged ('gr', 'ea') (count=15) β†’ 'grea'\n", " Step 24: merged ('t', 'er') (count=15) β†’ 'ter'\n", " Step 25: merged ('t', 'est') (count=15) β†’ 'test'\n", " Step 26: merged ('s', 'm') (count=15) β†’ 'sm'\n", " Step 27: merged ('sm', 'all') (count=15) β†’ 'small'\n", " Step 28: merged ('h', 'igh') (count=15) β†’ 'high'\n", " Step 29: merged ('l', 'o') (count=15) β†’ 'lo'\n", " Step 30: merged ('lo', 'n') (count=15) β†’ 'lon'\n", " Step 31: merged ('lon', 'g') (count=15) β†’ 'long'\n", " Step 32: merged ('s', 'h') (count=15) β†’ 'sh'\n", " Step 33: merged ('sh', 'or') (count=15) β†’ 'shor'\n", " Step 34: merged ('l', 'igh') (count=15) β†’ 'ligh'\n", " Step 35: merged ('play', '') (count= 5) β†’ 'play'\n", " Step 36: merged ('play', 'er') (count= 5) β†’ 'player'\n", " Step 37: merged ('play', 'ers') (count= 5) β†’ 'players'\n", " Step 38: merged ('work', '') (count= 5) β†’ 'work'\n", " Step 39: merged ('work', 'er') (count= 5) β†’ 'worker'\n" ] } ], "source": [ "# ── Our miniature training corpus ──\n", "# Each word type appears once, so we can track frequency precisely.\n", "# Notice the patterns: -er and -est suffixes appear across multiple words.\n", "corpus = [\n", " # 10 word types Γ— 5 repetitions each\n", " # Dissimilar base words ensure clean suffix discovery\n", " \"play player players \" * 5,\n", " \"work worker workers \" * 5,\n", " \"teach teacher teachers \" * 5,\n", " \"tall taller tallest \" * 5,\n", " \"great greater greatest \" * 5,\n", " \"small smaller smallest \" * 5,\n", " \"high higher highest \" * 5,\n", " \"long longer longest \" * 5,\n", " \"short shorter shortest \" * 5,\n", " \"light lighter lightest \" * 5,\n", "]\n", "\n", "# ── Step 1: Start with individual characters ──\n", "# Split every word into letters. marks a word boundary\n", "# so BPE knows not to merge characters across different words.\n", "def get_vocab(corpus):\n", " vocab = Counter()\n", " for sentence in corpus:\n", " for word in sentence.split():\n", " tokens = \" \".join(list(word)) + \" \"\n", " vocab[tokens] += 1\n", " return vocab\n", "\n", "# ── Step 2: Count every adjacent pair ──\n", "# The pair that appears most frequently gets merged next.\n", "def get_stats(vocab):\n", " pairs = Counter()\n", " for tokens, count in vocab.items():\n", " symbols = tokens.split()\n", " for i in range(len(symbols) - 1):\n", " pairs[(symbols[i], symbols[i+1])] += count\n", " return pairs\n", "\n", "# ── Step 3: Merge the winning pair ──\n", "# Replace every occurrence of (e, r) with er across all words.\n", "# This is the only rule: frequency determines the merge order.\n", "def merge_vocab(pair, vocab):\n", " merged = \"\".join(pair)\n", " new_vocab = Counter()\n", " for tokens, count in vocab.items():\n", " symbols = tokens.split()\n", " i = 0\n", " new_symbols = []\n", " while i < len(symbols):\n", " if i < len(symbols) - 1 and symbols[i] == pair[0] and symbols[i+1] == pair[1]:\n", " new_symbols.append(merged)\n", " i += 2\n", " else:\n", " new_symbols.append(symbols[i])\n", " i += 1\n", " new_vocab[\" \".join(new_symbols)] = count\n", " return new_vocab\n", "\n", "# ── Run merge steps ──\n", "# Each iteration: count pairs β†’ pick most frequent β†’ merge β†’ repeat\n", "print(\"Running BPE merges...\")\n", "vocab = get_vocab(corpus)\n", "for step in range(40):\n", " pairs = get_stats(vocab)\n", " if not pairs:\n", " break\n", " best_pair = pairs.most_common(1)[0]\n", " vocab = merge_vocab(best_pair[0], vocab)\n", " merged_str = \"\".join(best_pair[0])\n", " print(f\" Step {step:2d}: merged {str(best_pair[0]):12s} (count={best_pair[1]:2d}) β†’ '{merged_str}'\")\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compression: 30 unique words β†’ 20 shared subword pieces = 1.5Γ—\n", "\n", "Final vocabulary:\n", " great β†’ ['grea', 't']\n", " greater β†’ ['grea', 'ter']\n", " greatest β†’ ['grea', 'test']\n", " high β†’ ['high']\n", " higher β†’ ['high', 'er']\n", " highest β†’ ['high', 'est']\n", " light β†’ ['ligh', 't']\n", " lighter β†’ ['ligh', 'ter']\n", " lightest β†’ ['ligh', 'test']\n", " long β†’ ['long']\n", " longer β†’ ['long', 'er']\n", " longest β†’ ['long', 'est']\n", " play β†’ ['play']\n", " player β†’ ['player']\n", " players β†’ ['players']\n", " short β†’ ['shor', 't']\n", " shorter β†’ ['shor', 'ter']\n", " shortest β†’ ['shor', 'test']\n", " small β†’ ['small']\n", " smaller β†’ ['small', 'er']\n", " smallest β†’ ['small', 'est']\n", " tall β†’ ['tall']\n", " taller β†’ ['tall', 'er']\n", " tallest β†’ ['tall', 'est']\n", " teach β†’ ['teach']\n", " teacher β†’ ['teach', 'er']\n", " teachers β†’ ['teach', 'ers']\n", " workers β†’ ['work', 'ers']\n", " work β†’ ['work']\n", " worker β†’ ['worker']\n" ] } ], "source": [ "# Count unique words vs unique subword tokens in the final vocabulary\n", "unique_words = set()\n", "for sentence in corpus:\n", " for word in sentence.split():\n", " unique_words.add(word)\n", "\n", "unique_subwords = set()\n", "for tokens, count in vocab.items():\n", " symbols = tokens.replace(\" \", \"\").split()\n", " for s in symbols:\n", " unique_subwords.add(s)\n", "\n", "ratio = len(unique_words) / len(unique_subwords)\n", "print(f\"Compression: {len(unique_words)} unique words β†’ {len(unique_subwords)} shared subword pieces = {ratio:.1f}Γ—\")\n", "print()\n", "print(\"Final vocabulary:\")\n", "for tokens, count in sorted(vocab.items()):\n", " symbols = tokens.replace(\" \", \"\").split()\n", " word = \"\".join(symbols)\n", " print(f\" {word:12s} β†’ {symbols}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**This is purely statistical.** The algorithm doesn't know that `-er` means \"comparative\" or `-est` means \"superlative.\" It just notices that certain character pairs appear together very frequently in the training data.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## Section 2 β€” Tokens Are Vectors\n", "\n", "So far: we've seen how text gets chopped into subword pieces.\n", "Now: what are those pieces as numbers β€” and what does the model actually see?\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.0 β€” From Tokens to IDs\n", "\n", "Each subword piece maps to an integer β€” the **token ID**. This is what actually gets sent to the model.\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Word Subword tokens Token IDs\n", "───────────────────────────────────────────────────────────────────────────\n", "embedding ['embedding'] [91342]\n", "attention ['attention'] [51319]\n", "transformer ['transform', 'er'] [4549, 261]\n", "revolutionized ['revolution', 'ized'] [92410, 1452]\n", "NLP ['N', 'LP'] [45, 12207]\n", "tokenization ['token', 'ization'] [5658, 1954]\n" ] } ], "source": [ "# Show the token IDs for a few words\n", "words = [\n", " \"embedding\",\n", " \"attention\",\n", " \"transformer\",\n", " \"revolutionized\",\n", " \"NLP\",\n", " \"tokenization\",\n", "]\n", "\n", "print(f\"{'Word':<20} {'Subword tokens':<35} {'Token IDs'}\")\n", "print(f\"{'─'*75}\")\n", "for w in words:\n", " toks = qwen_tok.tokenize(w)\n", " ids = qwen_tok.convert_tokens_to_ids(toks)\n", " # Show decoded tokens with ␣ instead of Δ \n", " display_toks = [str(t).replace(chr(288), chr(9251)) for t in toks]\n", " print(f\"{w:<20} {str(display_toks):<35} {str(ids)}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A single word can be **1 token** (`embedding`), **2 tokens** (`transform`+`er`), or any number.\n", "\n", "These integers β€” e.g., `[91342]` for `\"embedding\"` β€” are the only thing the model receives.\n", "The next step is turning them into vectors.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 β€” The Embedding Matrix\n", "\n", "Every token ID maps to a vector via a lookup table. Shape: `(vocab_size Γ— d_model)`." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Qwen embedding matrix: torch.Size([248320, 2048])\n", " = 248,320 tokens Γ— 2048 dimensions\n", " dtype: torch.float16\n" ] } ], "source": [ "# Load Qwen's embedding matrix from the model weights\n", "shard_path = hf_hub_download(\n", " \"Qwen/Qwen3.6-35B-A3B\",\n", " \"model-00001-of-00026.safetensors\"\n", ")\n", "\n", "with safetensors.safe_open(shard_path, framework=\"pt\", device=\"cpu\") as f:\n", " embed_weight = f.get_tensor(\"model.language_model.embed_tokens.weight\")\n", "\n", "embedding = embed_weight.to(dtype=torch.float16, device=device)\n", "print(f\"Qwen embedding matrix: {embedding.shape}\")\n", "print(f\" = {embedding.shape[0]:,} tokens Γ— {embedding.shape[1]} dimensions\")\n", "print(f\" dtype: {embedding.dtype}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**This is it.** The actual embedding layer from the Qwen 35B model β€” 248,320 rows, 2,048 columns.\n", "\n", "It is actually 276 tokens more than the 248,044 we saw earlier because it includes special tokens - image, video, space, start, stop etc.\n", "\n", "Every token ID is just an index into this table. The model never sees the string `\"the\"` or the integer `1719` β€” it sees the vector at row 1719.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 β€” A Closer Look\n", "\n", "Let's pick a few tokens and see their actual vectors." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Token | ID | First 8 dimensions of vector\n", "-----------------------------------------------------------------\n", " the | 1719 | -0.003 -0.009 +0.002 -0.002 -0.008 +0.003 +0.002 +0.000\n", " complex | 22523 | -0.003 -0.001 -0.013 +0.012 -0.021 -0.007 -0.019 -0.007\n", " process | 4480 | +0.006 +0.002 -0.011 -0.003 +0.007 +0.005 -0.009 +0.000\n", " city | 8656 | +0.007 -0.004 -0.025 +0.004 -0.008 +0.018 -0.002 -0.008\n", " ␣and | 321 | -0.000 +0.000 +0.012 -0.004 -0.001 -0.001 -0.001 -0.002\n", " . | 13 | -0.000 +0.001 +0.010 -0.001 +0.000 -0.000 -0.001 +0.000\n" ] } ], "source": [ "sample_tokens = [\"the\", \"complex\", \"process\", \"city\", \"Δ and\", \".\"]\n", "sample_ids = qwen_tok.convert_tokens_to_ids(sample_tokens)\n", "sample_vectors = embedding[torch.tensor(sample_ids)].detach().cpu().float()\n", "\n", "print(f\"{'Token':>15} | {'ID':>6} | First 8 dimensions of vector\")\n", "print(\"-\" * 65)\n", "for tok, tid, vec in zip(sample_tokens, sample_ids, sample_vectors):\n", " dims = \" \".join(f\"{v:+.3f}\" for v in vec[:8])\n", " print(f\"{str(tok).replace(chr(288), chr(9251)):>15} | {tid:>6} | {dims}\")\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Visualize as a heatmap\n", "# Qwen embeddings have std ~0.012, so we zoom the color scale to Β±0.05\n", "fig, axes = plt.subplots(len(sample_tokens), 1, figsize=(12, 5))\n", "for i, (tok, vec) in enumerate(zip(sample_tokens, sample_vectors)):\n", " ax = axes[i]\n", " im = ax.imshow(vec[:128].unsqueeze(0), aspect=\"auto\", cmap=\"RdBu_r\", vmin=-0.05, vmax=0.05)\n", " ax.set_ylabel(f\"'{str(tok).replace(chr(288), chr(9251))}'\", fontsize=10)\n", " ax.set_yticks([])\n", " if i < len(sample_tokens) - 1:\n", " ax.set_xticks([])\n", " else:\n", " ax.set_xlabel(\"Dimension (first 128 of 2048)\")\n", "\n", "# Add a shared colorbar\n", "fig.subplots_adjust(right=0.92)\n", "cbar_ax = fig.add_axes([0.93, 0.15, 0.015, 0.7])\n", "cbar = fig.colorbar(im, cax=cbar_ax)\n", "cbar.set_label(\"Embedding value\", fontsize=10)\n", "\n", "plt.suptitle(\"Qwen Embedding Vectors β€” First 128 of 2048 Dimensions\", fontsize=14)\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each token is a point in a **2048-dimensional** space. The model doesn't see \"the\" as a word β€” it sees this specific vector.\n", "\n", "These vectors are **learned** during training. \n", "\n", "Which raises a question - do tokens that appear in similar contexts develop similar vectors?\n", "\n", "What does \"similar\" actually mean here? Let's find out.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## Section 3 β€” Exploring the Embedding Space\n", "\n", "Let's take the full embedding matrix and see what structure emerges." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1 β€” t-SNE: Seeing the Clusters\n", "\n", "Unlike PCA (which maximizes global variance), t-SNE preserves **local neighborhoods** β€” similar tokens stay close together.\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running t-SNE on 3000 vectors...\n", "t-SNE complete β€” local neighborhoods preserved\n", "(Perplexity=30 means each point considers ~30 neighbors)\n" ] } ], "source": [ "from sklearn.manifold import TSNE\n", "\n", "rng = np.random.RandomState(42)\n", "n_sample = 3000\n", "# Sample from Qwen's 248k vocabulary\n", "n_vocab = embedding.shape[0]\n", "indices = rng.choice(n_vocab, n_sample, replace=False)\n", "sampled_vectors = embedding[torch.tensor(indices)].detach().cpu().float().numpy()\n", "\n", "print(f\"Running t-SNE on {n_sample} vectors...\")\n", "tsne = TSNE(n_components=2, random_state=42, perplexity=30, learning_rate=\"auto\", init=\"random\")\n", "coords = tsne.fit_transform(sampled_vectors)\n", "print(\"t-SNE complete β€” local neighborhoods preserved\")\n", "print(\"(Perplexity=30 means each point considers ~30 neighbors)\")\n" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Classify sampled tokens for coloring\n", "sampled_texts = [qwen_tok.decode([int(idx)]) for idx in indices]\n", "\n", "def classify(tok):\n", " if not tok:\n", " return \"empty\"\n", " if all(c.isdigit() or c.isspace() for c in tok):\n", " return \"digit\"\n", " if any(c in \".,!?;:'\\\"()[]{}-_+=/\\\\@#$%^&*~`\" for c in tok):\n", " return \"punctuation\"\n", " if tok.startswith(\"Δ \"):\n", " return \"word (with space)\"\n", " if len(tok) <= 2:\n", " return \"short piece\"\n", " return \"subword piece\"\n", "\n", "categories = [classify(t) for t in sampled_texts]\n", "\n", "colors = {\n", " \"word (with space)\": \"#4C72B0\",\n", " \"subword piece\": \"#DD8452\",\n", " \"short piece\": \"#55A868\",\n", " \"punctuation\": \"#C44E52\",\n", " \"digit\": \"#937860\",\n", " \"empty\": \"#8172B3\",\n", "}\n", "\n", "fig, ax = plt.subplots(figsize=(12, 10))\n", "for cat in colors:\n", " mask = np.array([c == cat for c in categories])\n", " if mask.sum() == 0:\n", " continue\n", " ax.scatter(coords[mask, 0], coords[mask, 1],\n", " c=colors[cat], label=f\"{cat} ({mask.sum()})\",\n", " s=5, alpha=0.6)\n", "\n", "ax.set_title(\"Qwen Token Embeddings β€” t-SNE Projection\", fontsize=15)\n", "ax.set_xlabel(\"t-SNE dim 1\")\n", "ax.set_ylabel(\"t-SNE dim 2\")\n", "ax.legend(markerscale=3, fontsize=10)\n", "plt.tight_layout()\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Clear clusters:**\n", "- Words with a space prefix (blue) form tight groups.\n", "- Subword pieces (orange) and short pieces (green) occupy distinct neighborhoods.\n", "- Punctuation (red) and digits (brown) sit in isolated regions.\n", "\n", "t-SNE reveals structure that PCA missed β€” the local grouping of similar tokens is strong,\n", "even though the global variance is spread across 2048 dimensions.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2 β€” Nearest Neighbors\n", "\n", "Let's pick some tokens and find who lives next door." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**How \"nearest\" is measured:** We use **cosine similarity** β€” the cosine of the angle between two vectors.\n", "\n", "Two vectors pointing in the same direction β†’ cosine = 1.0 (identical).\n", "Opposite directions β†’ cosine = -1.0. Perpendicular β†’ cosine = 0.0 (unrelated).\n", "\n", "Since we normalize vectors to unit length, cosine similarity is just the **dot product**:\n", "`sim = v Β· w / (|v| Γ— |w|)` = `(v / |v|) Β· (w / |w|)` = dot product of unit vectors.\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "def nearest_neighbors(token_str, k=8):\n", " tid = qwen_tok.convert_tokens_to_ids(token_str)\n", " if tid == qwen_tok.unk_token_id:\n", " print(f\"'{token_str}' not in vocabulary\")\n", " return\n", "\n", " query = embedding[tid].detach().cpu().float()\n", " all_embeds = embedding.detach().cpu().float()\n", "\n", " query_norm = query / query.norm()\n", " # Cosine similarity = dot product of unit vectors\n", " all_norms = all_embeds / all_embeds.norm(dim=1, keepdim=True)\n", " sims = (all_norms @ query_norm).numpy() # dot product = cosine sim for unit vectors\n", "\n", " # Filter out trivial variants: same word with different spacing/casing/punctuation\n", " query_text = qwen_tok.decode([tid]).strip().lower()\n", " top_k = np.argsort(-sims)\n", " filtered = []\n", " for idx in top_k:\n", " nt = qwen_tok.convert_ids_to_tokens(int(idx))\n", " nd = qwen_tok.decode([int(idx)]).strip().lower()\n", " # Skip self and trivial variants (same base word)\n", " if idx == tid:\n", " continue\n", " if nd == query_text or nd.strip(\".,!?;:\\'\\\"()[]{}-_+=/\\\\@#$%^&*~`\\t \") == query_text:\n", " continue\n", " filtered.append((sims[idx], nt, nd, idx))\n", " if len(filtered) >= k:\n", " break\n", "\n", " print(f\"Neighbors of '{token_str}' (ID {tid}):\")\n", " print(f\" {'Rank':<5} {'Token':<20} {'Similarity':<12} {'Decoded'}\")\n", " print(f\" {'─'*55}\")\n", " for i, (sim, nt, nd, idx) in enumerate(filtered):\n", " print(f\" {i+1:<5} {str(nt).replace(chr(288), chr(9251)):<20} {sim:.4f} {repr(nd)}\")\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Neighbors of 'The' (ID 760):\n", " Rank Token Similarity Decoded\n", " ───────────────────────────────────────────────────────\n", " 1 >The 0.5049 '>the'\n", " 2 Γ’Δ’ΔΎThe 0.4470 'β€œthe'\n", " 3 nThe 0.4230 'nthe'\n", " 4 Die 0.3843 'die'\n", " 5 Γ’Δ’ΔΆthe 0.3828 'β€”the'\n", " 6 This 0.3735 'this'\n", " 7 La 0.3700 'la'\n", " 8 ␣La 0.3584 'la'\n" ] } ], "source": [ "nearest_neighbors(\"The\")" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Neighbors of 'ing' (ID 286):\n", " Rank Token Similarity Decoded\n", " ───────────────────────────────────────────────────────\n", " 1 ed 0.5651 'ed'\n", " 2 ings 0.5039 'ings'\n", " 3 ting 0.5023 'ting'\n", " 4 ating 0.4862 'ating'\n", " 5 er 0.4620 'er'\n", " 6 ers 0.4397 'ers'\n", " 7 es 0.4388 'es'\n", " 8 ation 0.4369 'ation'\n" ] } ], "source": [ "nearest_neighbors(\"ing\")" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Neighbors of 'run' (ID 5917):\n", " Rank Token Similarity Decoded\n", " ───────────────────────────────────────────────────────\n", " 1 ␣runs 0.5054 'runs'\n", " 2 ␣running 0.4038 'running'\n", " 3 runs 0.3918 'runs'\n", " 4 running 0.3711 'running'\n", " 5 ␣ran 0.3687 'ran'\n", " 6 ␣Runs 0.3632 'runs'\n", " 7 ␣Running 0.3614 'running'\n", " 8 Running 0.3285 'running'\n" ] } ], "source": [ "nearest_neighbors(\"run\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.3 β€” Cosine Similarity Between Related Pairs\n", "\n", "Let's test whether intuitively \"similar\" tokens are actually close in this space." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Token 1 Token 2 Cosine Similarity \n", "────────────────────────────────────────\n", "The the 0.6071\n", "run walk 0.1583\n", "ing ed 0.5651\n", ". ! 0.4394\n", "The ␣fox 0.0429\n", "low high 0.4239\n", "new old 0.2707\n" ] } ], "source": [ "def cos_sim(t1, t2):\n", " id1, id2 = qwen_tok.convert_tokens_to_ids(t1), qwen_tok.convert_tokens_to_ids(t2)\n", " if id1 == qwen_tok.unk_token_id or id2 == qwen_tok.unk_token_id:\n", " return None\n", " v1 = embedding[id1].detach().cpu().float()\n", " v2 = embedding[id2].detach().cpu().float()\n", " return torch.cosine_similarity(v1.unsqueeze(0), v2.unsqueeze(0)).item()\n", "\n", "pairs = [\n", " (\"The\", \"the\"), # same word, different case\n", " (\"run\", \"walk\"), # similar verb\n", " (\"ing\", \"ed\"), # both verb suffixes\n", " (\".\", \"!\"), # sentence-ending punctuation\n", " (\"The\", \"Δ fox\"), # article vs content word\n", " (\"low\", \"high\"), # opposites\n", " (\"new\", \"old\"), # opposites\n", "]\n", "\n", "print(f\"{'Token 1':<12} {'Token 2':<12} {'Cosine Similarity':<18}\")\n", "print(f\"{'─'*40}\")\n", "for t1, t2 in pairs:\n", " s = cos_sim(t1, t2)\n", " t1d = str(t1).replace(chr(288), chr(9251))\n", " t2d = str(t2).replace(chr(288), chr(9251))\n", " print(f\"{t1d:<12} {t2d:<12} {s:.4f}\" if s else f\"{t1d:<12} {t2d:<12} {chr(40)+chr(39)+chr(79)+chr(79)+chr(86)+chr(39)+chr(41):<18}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Observations:**\n", "\n", "**Key insight:** The embedding space captures **distributional similarity** β€” tokens that appear in similar contexts β€” not semantic similarity as humans define it. Antonyms can be neighbors because they fill the same syntactic slot." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4 β€” Annotated t-SNE Plot\n", "\n", "Let's place specific tokens on the map to see where they land.\n" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "tokens_to_label = [\n", " \"the\", \"a\", \"an\",\n", " \"run\", \"jump\", \"walk\",\n", " \"0\", \"1\", \"2\", \"3\",\n", " \".\", \",\", \"!\", \"?\",\n", "]\n", "\n", "label_ids = [qwen_tok.convert_tokens_to_ids(t) for t in tokens_to_label]\n", "label_vecs = embedding[torch.tensor(label_ids)].detach().cpu().float().numpy()\n", "\n", "# Run t-SNE on sampled + label vectors together for consistent coordinates\n", "all_vectors = np.vstack([sampled_vectors, label_vecs])\n", "tsne_all = TSNE(n_components=2, random_state=42, perplexity=30, learning_rate=\"auto\", init=\"random\")\n", "all_coords = tsne_all.fit_transform(all_vectors)\n", "\n", "coords = all_coords[:n_sample]\n", "label_coords = all_coords[n_sample:]\n", "\n", "fig, ax = plt.subplots(figsize=(14, 10))\n", "\n", "for cat in colors:\n", " mask = np.array([c == cat for c in categories])\n", " if mask.sum() == 0:\n", " continue\n", " ax.scatter(coords[mask, 0], coords[mask, 1],\n", " c=colors[cat], label=cat, s=3, alpha=0.4)\n", "\n", "ax.scatter(label_coords[:, 0], label_coords[:, 1], c=\"black\", s=40, zorder=5)\n", "\n", "label_colors = {\n", " \"the\": \"#4C72B0\", \"a\": \"#4C72B0\", \"an\": \"#4C72B0\",\n", " \"run\": \"#4C72B0\", \"jump\": \"#4C72B0\", \"walk\": \"#4C72B0\",\n", " \"0\": \"#937860\", \"1\": \"#937860\", \"2\": \"#937860\", \"3\": \"#937860\",\n", " \".\": \"#C44E52\", \",\": \"#C44E52\", \"!\": \"#C44E52\", \"?\": \"#C44E52\",\n", " \"ing\": \"#DD8452\", \"ed\": \"#DD8452\", \"ly\": \"#DD8452\",\n", "}\n", "\n", "for tok, coord in zip(tokens_to_label, label_coords):\n", " ax.annotate(tok, coord, fontsize=12, fontweight=\"bold\",\n", " textcoords=\"offset points\", xytext=(5, 5),\n", " color=label_colors.get(tok, \"black\"))\n", "\n", "ax.set_title(\"Qwen Token Embeddings β€” t-SNE (Annotated)\", fontsize=15)\n", "ax.set_xlabel(\"t-SNE dim 1\")\n", "ax.set_ylabel(\"t-SNE dim 2\")\n", "ax.legend(markerscale=3, fontsize=9, loc=\"upper left\")\n", "plt.tight_layout()\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**What the t-SNE plot shows:**\n", "\n", "1. **Digits cluster tightly** β€” `0, 1, 2, 3` all in one spot.\n", "2. **Punctuation clusters** β€” `.`, `,`, `!`, `?` in their own region.\n", "3. **Suffixes near each other** β€” `ing`, `ed`, `ly` share a neighborhood.\n", "4. **Functional words spread out** β€” `the`, `a`, `an` aren't particularly close.\n", "5. **Verbs cluster together** β€” `run`, `jump`, `walk` in the same region.\n", "\n", "t-SNE makes these groupings much more visible than PCA because it preserves local relationships.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "## Wrapping Up\n", "\n", "**What we learned:**\n", "\n", "1. **The full pipeline** β€” Text β†’ Token IDs β†’ Embedding vectors β†’ Transformer β†’ Logits β†’ Token IDs β†’ Text. The LLM never sees language β€” it sees integers and vectors.\n", "\n", "2. **Tokenization (BPE)** β€” Purely statistical. Common subwords survive, rare ones decompose. Qwen's 248k vocabulary works the same way as every other BPE tokenizer.\n", "\n", "3. **The embedding space has structure** β€” Digits cluster, suffixes cluster, punctuation clusters. But it's **distributional**, not human-semantic. `\"ing\"` and `\"ed\"` are close because they play similar roles, not because the model understands verb tenses.\n", "\n", "4. **Real understanding happens in the attention layers** above the embeddings. The embedding space is the *foundation* β€” arranged so the Transformer can build context-aware representations on top.\n", "\n", "**Next time:** How do these token vectors interact? We'll look at self-attention and see how the model combines token information to build context-aware representations.\n" ] } ], "metadata": { "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.7" } }, "nbformat": 4, "nbformat_minor": 4 }