github-starred/TinyTorch
2
0
Fork 0
mirror of https://github.com/MLSysBook/TinyTorch.git synced 2026-05-06 05:37:32 -05:00
Code Issues 7 Packages Projects Releases Wiki Activity

Fix nested ASCII box alignment in BPE and embedding diagrams

Browse Source
This commit is contained in:
Vijay Janapa Reddi
2025-11-30 09:57:01 -05:00
parent 5720b49a49
commit 30292bcc5a
1 changed files with 72 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/10_tokenization/10_tokenization.py
View File

@@ -569,78 +569,78 @@ Character tokenization provides a simple, robust foundation for text processing.
BPE is the secret sauce behind modern language models (GPT, BERT, etc.). It learns to merge frequent character pairs, creating subword units that balance vocabulary size with sequence length.
```
┌───────────────────────────────────────────────────────────────────────────┐
│ BPE TRAINING ALGORITHM: Learning Subword Units │
├───────────────────────────────────────────────────────────────────────────┤
│ │
│ STEP 1: Initialize with Character Vocabulary │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Training Data: ["hello", "hello", "help"] │ │
│ │ │ │
│ │ Initial Tokens (with end-of-word markers): │ │
│ │ ['h','e','l','l','o</w>'] (hello) │ │
│ │ ['h','e','l','l','o</w>'] (hello) │ │
│ │ ['h','e','l','p</w>'] (help) │ │
│ │ │ │
│ │ Starting Vocab: ['h', 'e', 'l', 'o', 'p', '</w>'] │ │
│ │ ↑ All unique characters │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 2: Count All Adjacent Pairs │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Pair Frequency Analysis: │ │
│ │ │ │
│ │ ('h', 'e'): ██████ 3 occurrences ← MOST FREQUENT! │ │
│ │ ('e', 'l'): ██████ 3 occurrences │ │
│ │ ('l', 'l'): ████ 2 occurrences │ │
│ │ ('l', 'o'): ████ 2 occurrences │ │
│ │ ('o', '<'): ████ 2 occurrences │ │
│ │ ('l', 'p'): ██ 1 occurrence │ │
│ │ ('p', '<'): ██ 1 occurrence │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 3: Merge Most Frequent Pair │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Merge Operation: ('h', 'e') → 'he' │ │
│ │ │ │
│ │ BEFORE: AFTER: │ │
│ │ ['h','e','l','l','o</w>'] → ['he','l','l','o</w>'] │ │
│ │ ['h','e','l','l','o</w>'] → ['he','l','l','o</w>'] │ │
│ │ ['h','e','l','p</w>'] → ['he','l','p</w>'] │ │
│ │ │ │
│ │ Updated Vocab: ['h','e','l','o','p','</w>', 'he'] │ │
│ │ ↑ NEW TOKEN! │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 4: Repeat Until Target Vocab Size Reached │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Iteration 2: Next most frequent is ('l', 'l') │ │
│ │ Merge ('l','l') → 'll' │ │
│ │ │ │
│ │ ['he','l','l','o</w>'] → ['he','ll','o</w>'] │ │
│ │ ['he','l','l','o</w>'] → ['he','ll','o</w>'] │ │
│ │ ['he','l','p</w>'] → ['he','l','p</w>'] │ │
│ │ │ │
│ │ Updated Vocab: ['h','e','l','o','p','</w>','he','ll'] │ │
│ │ ↑ NEW! │ │
│ │ │ │
│ │ Continue merging until vocab_size target... │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ FINAL RESULTS: │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Trained BPE can now encode efficiently: │ │
│ │ │ │
│ │ "hello" → ['he', 'll', 'o</w>'] = 3 tokens (vs 5 chars) │ │
│ │ "help" → ['he', 'l', 'p</w>'] = 3 tokens (vs 4 chars) │ │
│ │ │ │
│ │ Key Insights: BPE automatically discovers: │ │
│ │ - Common prefixes ('he') │ │
│ │ - Morphological patterns ('ll') │ │
│ │ - Natural word boundaries (</w>) │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘
┌───────────────────────────────────────────────────────────────────────┐
│ BPE TRAINING ALGORITHM: Learning Subword Units │
├───────────────────────────────────────────────────────────────────────┤
│ │
│ STEP 1: Initialize with Character Vocabulary │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ Training Data: ["hello", "hello", "help"] │ │
│ │ │ │
│ │ Initial Tokens (with end-of-word markers): │ │
│ │ ['h','e','l','l','o</w>'] (hello) │ │
│ │ ['h','e','l','l','o</w>'] (hello) │ │
│ │ ['h','e','l','p</w>'] (help) │ │
│ │ │ │
│ │ Starting Vocab: ['h', 'e', 'l', 'o', 'p', '</w>'] │ │
│ │ ↑ All unique characters │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 2: Count All Adjacent Pairs │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ Pair Frequency Analysis: │ │
│ │ │ │
│ │ ('h', 'e'): ██████ 3 occurrences ← MOST FREQUENT! │ │
│ │ ('e', 'l'): ██████ 3 occurrences │ │
│ │ ('l', 'l'): ████ 2 occurrences │ │
│ │ ('l', 'o'): ████ 2 occurrences │ │
│ │ ('o', '<'): ████ 2 occurrences │ │
│ │ ('l', 'p'): ██ 1 occurrence │ │
│ │ ('p', '<'): ██ 1 occurrence │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 3: Merge Most Frequent Pair │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ Merge Operation: ('h', 'e') → 'he' │ │
│ │ │ │
│ │ BEFORE: AFTER: │ │
│ │ ['h','e','l','l','o</w>'] → ['he','l','l','o</w>'] │ │
│ │ ['h','e','l','l','o</w>'] → ['he','l','l','o</w>'] │ │
│ │ ['h','e','l','p</w>'] → ['he','l','p</w>'] │ │
│ │ │ │
│ │ Updated Vocab: ['h','e','l','o','p','</w>', 'he'] │ │
│ │ ↑ NEW TOKEN! │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ STEP 4: Repeat Until Target Vocab Size Reached │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ Iteration 2: Next most frequent is ('l', 'l') │ │
│ │ Merge ('l','l') → 'll' │ │
│ │ │ │
│ │ ['he','l','l','o</w>'] → ['he','ll','o</w>'] │ │
│ │ ['he','l','l','o</w>'] → ['he','ll','o</w>'] │ │
│ │ ['he','l','p</w>'] → ['he','l','p</w>'] │ │
│ │ │ │
│ │ Updated Vocab: ['h','e','l','o','p','</w>','he','ll'] │ │
│ │ ↑ NEW! │ │
│ │ │ │
│ │ Continue merging until vocab_size target... │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
│ FINAL RESULTS: │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ Trained BPE can now encode efficiently: │ │
│ │ │ │
│ │ "hello" → ['he', 'll', 'o</w>'] = 3 tokens (vs 5 chars) │ │
│ │ "help" → ['he', 'l', 'p</w>'] = 3 tokens (vs 4 chars) │ │
│ │ │ │
│ │ Key Insights: BPE automatically discovers: │ │
│ │ - Common prefixes ('he') │ │
│ │ - Morphological patterns ('ll') │ │
│ │ - Natural word boundaries (</w>) │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
```
**Why BPE Works**: By starting with characters and iteratively merging frequent pairs, BPE discovers the natural statistical patterns in language. Common words become single tokens, rare words split into recognizable subword pieces!