Hoe bouw en train je je eigen GPT op een gewone laptop

De meeste neurale netwerk-tutorials van tegenwoordig komen neer op twee scenario's. Je wordt gevraagd om de OpenAI API aan te roepen met een paar regels Python, of om een kant-en-klaar model van Hugging Face te downloaden en de .generate() methode aan te roepen. In beide gevallen blijven alle innerlijke werkingen achter de schermen. Je krijgt een resultaat, maar je begrijpt nauwelijks hoe matrix vermenigvuldigingen ruwe tekst omzetten in betekenisvolle zinnen.

Onlangs kwam ik de llm-from-scratch repository tegen van ontwikkelaar angelos-p. Het is een interactieve workshop waar je elk onderdeel van een taalmodel vanaf nul schrijft. Geen zware abstracties: gewoon pure PyTorch, heldere wiskunde, en een model met 10 miljoen parameters trainen op je laptop in minder dan een uur.

Входной текст
    │
    ▼
┌─────────────────┐
│   Tokenizer     │  "hello" → [20, 43, 50, 50, 53]
└────────┬────────┘
         ▼
┌─────────────────┐
│  Token Embed +  │  Векторы токенов + позиция
│  Position Embed │  (размерность n_embd)
└────────┬────────┘
         ▼
┌─────────────────┐
│  Transformer    │  × n_layer слоев
│  Block:         │
│  ┌────────────┐ │
│  │ LayerNorm  │ │
│  │ Self-Attn  │ │  n_head параллельных голов внимания
│  │ + Residual │ │
│  ├────────────┤ │
│  │ LayerNorm  │ │
│  │ MLP (FFN)  │ │  расширение 4x, GELU, проекция назад
│  │ + Residual │ │
│  └────────────┘ │
└────────┬────────┘
         ▼
┌─────────────────┐
│   LayerNorm     │
│   Linear → logits│  вероятности следующего символа
└─────────────────┘

Waar het allemaal begon

Veel mensen hebben gehoord van Andrej Karpathy's nanoGPT project. Karpathy liet zien dat een volledige GPT-2 architectuur met 124 miljoen parameters in slechts een paar honderd regels code past. Het reproduceren van de originele GPT-2 vereist echter nog steeds een flinke hoeveelheid rekenkracht en tijd.

De auteur van llm-from-scratch ging nog een stap verder. Ze verwijderden alle onnodige cluster-optimalisaties en pasten de code aan zodat je het in één avond met de hand kunt schrijven. Het uiteindelijke model train op Apple Silicon (MPS), Nvidia GPU's via CUDA, of zelfs een gewone CPU. Als je geen lokale hardware hebt, draait alles in gratis Google Colab.

Wat de workshop bevat

Het materiaal is opgedeeld in stapsgewijze modules in de docs/ map. Je maakt opeenvolgend drie werkende bestanden: model.py, train.py en generate.py.

1. Karakterniveau-tokenisatie

Bij het werken met enorme tekstcorpora is de standaardoplossing het BPE (Byte Pair Encoding) algoritme met een vocabulaire van 50.000 tokens. Maar als je een klein netwerk traint op een dataset van 1 megabyte, breekt BPE je training. De meeste token-paren verschijnen slechts een paar keer in de hele tekst, en de gewichten convergeren simpelweg niet voor ze.

Daarom gebruikt de auteur een karakter-niveau tokenizer voor het trainen op Shakespeares toneelstukken. Het alfabet bestaat uit slechts 65 unieke tekens. Dit vocabulaire is compact, codeert snel, en geeft een klein model de kans om grammatica en dialoogstructuur te vatten.

2. De Transformer bouwen

Hier assembleer je met de hand de GPT decoder-architectuur:

• Embedding-tabellen voor karakters en posities in de tekst.
• Multi-Head Self-Attention blok, waar elke karakter-vector interageert met context via queries, keys en values (Q, K, V).
• Causale masker-mechanisme dat voorkomt dat het model naar toekomstige tokens gluurt tijdens generatie.
• Volledig verbonden lagen (MLP) met GELU-activatie en LayerNorm-normalisatie.

De architectuur wordt gemonteerd zonder magie van derden-frameworks. Je kunt duidelijk zien waar elke tensor stroomt en in welke fase residuele verbindingen worden toegevoegd.

3. Trainingslus

In de derde fase schrijf je de trainingspijplijn. Deze omvat:

• Berekening van Cross-Entropy verlies tussen voorspelde logits en werkelijke volgende karakters.
• AdamW optimizer met weight decay-afstemming.
• Gradient clipping om gewichtsexplosie tijdens training te voorkomen.
• Learning rate scheduler met warmup en cosine decay.

4. Tekstgeneratie en sampling

Het voltooide model moet aan het woord komen. Je implementeert een autoregressieve lus: neem een tekstzaadje, voer het door de transformer, extraheer de kansverdeling voor de volgende token, en selecteer deze met temperature via greedy search of top-k sampling.

Configuraties voor experimenten

De repository biedt drie modelprofielen. Je kunt kiezen op basis van hoeveel vrije tijd je hebt.

| Profiel | Parameters | Lagen (n_layer) | Heads (n_head) | Dimensie (n_embd) | Trainingsduur (M3 Pro) | |---|---|---|---|---|---| | Tiny | ~0,5M | 2 | 2 | 128 | ~5 minuten |

| Small | ~4M | 4 | 4 | 256 | ~20 minuten | | Medium | ~10M | 6 | 6 | 384 | ~45 minuten |

Alle profielen werken met een contextlengte van 256 tekens. Het Tiny-profiel is geweldig voor snel debuggen wanneer je wilt controleren of de code zonder fouten draait shape mismatch. Het Medium-profiel produceert al vrij leesbaar Shakespeareaans proza met karakterdialoog-onderverdelingen.

Hoe het project te draaien

Voor omgevingsbeheer raadt de auteur de snelle package manager uv aan.

Afhankelijkheden installeren en een werkmap maken:

# Установка uv (если еще не установлен)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Клонируем репозиторий и синхронизируем окружение
git clone https://github.com/angelos-p/llm-from-scratch
cd llm-from-scratch
uv sync
mkdir scratchpad && cd scratchpad

Als je de voorkeur geeft aan Google Colab, is het installeren van een minimale set bibliotheken voldoende:

!pip install torch numpy tqdm tiktoken

Neem dan het data/shakespeare.txt bestand, open de eerste handleiding docs/01-tokenization.md, en begin stap voor stap code te schrijven.

Voor wie is deze workshop

Het project spreekt aan wie抽象e artikelen met attention-plots beu is en echte code wil zien. Er is geen diepgaande kennis van machine learning nodig om het te voltooien. Het is voldoende om je prettig te voelen bij het lezen van Python-syntaxis en het begrijpen van basis array-bewerkingen.

Na het voltooien van alle zes handleidingen verdwijnt het gevoel van magie rond LLMs. Je begrijpt in de praktijk waarom modellen learning rate warmup nodig hebben, hoe temperature de willekeurigheid van antwoorden beïnvloedt, en waarom kleine modellen zo gevoelig zijn voor vocabulaire-grootte. Het is een geweldige manier om een weekend productief te besteden voor je technische kennis.