Reinforcement learning · PyTorch

Vier op een Rij met AlphaZero

Een neuraal netwerk dat Vier op een Rij leert door miljoenen zetten tegen zichzelf te spelen. Er zijn geen menselijke partijen of openingsboeken gebruikt, alleen de spelregels, zoekwerk en een GPU. Het getrainde model draait hieronder in je browser.

99%
theoretisch juiste uitkomst gehaald in 98 partijen tegen een sterke solver
96,5%
beste zet gevonden (MCTS) in kritieke stellingen
3,65 M
parameters: ResNet met 12 blokken × 128 filters
~150k
self-play partijen in ~56 uur op één laptop-GPU
Live demo

Speel tegen het model

Het beste checkpoint (iteratie 1161) is geëxporteerd naar ONNX en draait met onnxruntime-web in WebAssembly. De boomzoektocht is een JavaScript-port van de Python-MCTS, met dezelfde PUCT-formule en virtual-loss-batching. Er komt geen server aan te pas: alles draait op je eigen apparaat.

Model laden

Netwerk (14,6 MB) en WebAssembly-runtime (14 MB) worden opgehaald…

1000 is het aantal simulaties uit de evaluatie. „Alleen policy” speelt direct de zet met de hoogste kans uit het netwerk, zonder te zoeken.

Wat denkt AlphaZero?

1234567

Bezoeken per kolom in de zoekboom. De gekozen zet is geel gemarkeerd.

jijevaluatie (value-head + MCTS)AlphaZero
Het netwerk

Eén ResNet, twee koppen

Net als in AlphaZero leert één netwerk twee dingen tegelijk: welke zetten kansrijk zijn (policy) en wie er gaat winnen (value). De gedeelde residual-toren leert patronen die voor beide nuttig zijn, zoals dreigingen, open rijen en zugzwang in de onderste rijen.

Input 2 × 6 × 7 kanaal 0: mijn stenen · kanaal 1: tegenstander Conv 3×3, 128 filters BatchNorm · ReLU Residual-toren × 12 conv 3×3 → BN → ReLU conv 3×3 → BN + skip-verbinding → ReLU Policy-head conv 1×1, 32 · BN · ReLU FC 1344 → 7 softmax P(kolom) voor 7 zetten Value-head conv 1×1, 32 · BN · ReLU FC 1344 → 64 · ReLU FC 64 → 1 · tanh v ∈ [−1, 1] voor speler aan zet ≈ 3,65 M parameters · ±0,15 GFLOP per stelling

Input vanuit de speler aan zet

Het bord wordt altijd gecodeerd vanuit de speler die aan zet is: kanaal 0 bevat zijn eigen stenen, kanaal 1 die van de tegenstander. Daardoor hoeft het netwerk geen aparte kleuren te leren en is de value altijd „hoe goed sta ík”. In de boom wordt dat bij elk niveau omgedraaid (q = −child.value).

Initialisatie met een doel

De convoluties gebruiken Kaiming-initialisatie, de lineaire lagen orthogonale. De laatste laag van beide heads krijgt gain = 0.01, zodat een vers netwerk start met een bijna uniforme policy en een value rond 0. MCTS vertrouwt het netwerk dus pas als het iets geleerd heeft.

Blokken × filters
12 × 128
Policy-output
logits → softmax (7)
Value-output
tanh (1)
Augmentatie
horizontaal spiegelen
Export
ONNX opset 17, fp32
Zoeken

MCTS met PUCT

Het netwerk alleen is een snelle intuïtie. De echte speelsterkte komt van Monte Carlo Tree Search, die het netwerk honderden keren per zet bevraagt en zijn eigen schattingen corrigeert met wat de zoekboom vindt.

1 · Selectie

Vanaf de wortel daalt de zoektocht af naar het kind met de hoogste PUCT-score: de gemiddelde waarde Q plus een exploratieterm die groot is voor zetten met een hoge prior P en weinig bezoeken N.

a* = argmax Q(s,a) + c·P(s,a)·√N(s) / (1+N(s,a))

c_puct = 1.2

2 · Expansie en evaluatie

Een nieuw blad wordt door het netwerk geëvalueerd. De policy wordt gemaskeerd op legale zetten en hergenormaliseerd, en wordt de prior voor de kinderen. De value vervangt de willekeurige rollout uit klassieke MCTS.

Eindstellingen krijgen de exacte uitkomst (−1, 0) zonder netwerk.

3 · Backpropagatie

De waarde gaat het pad omhoog en wisselt bij elk niveau van teken, omdat winst voor de één verlies is voor de ander. Na alle simulaties is het aantal bezoeken per zet de verbeterde policy π, en die wordt het leerdoel voor het netwerk.

Batching met virtual loss

Een GPU is traag als je hem stellingen één voor één geeft. Daarom verzamelt de zoektocht 32 bladeren voordat het netwerk één keer met een batch draait. Om te voorkomen dat alle 32 hetzelfde pad kiezen, krijgt elk pad tijdelijk een virtual loss: N += 1, W += 1. Het pad lijkt dan even slechter voor de ouder. Bij de backpropagatie wordt dat weer teruggedraaid.

In de browserdemo is de batch 16.

Exploratie tijdens self-play

Dirichlet-ruis
α = 0.3, ε = 0.25 op de wortel
Temperatuur
τ = 1 voor de eerste 10 zetten, daarna greedy
Simulaties
800 (training), 1000 (evaluatie)
Tie-break
willekeurig bij gelijke score

Zonder ruis en temperatuur speelt self-play steeds dezelfde partij, en dan leert het netwerk alleen die ene opening.

Leren

Self-play en training

Elke iteratie spelen parallelle workers 128 partijen tegen zichzelf. Hun stellingen gaan in een replay-buffer en de trainer doet daarna 40 gradient-stappen. De nieuwe gewichten gaan via gedeeld geheugen terug naar de workers.

Self-play workers × 6–8 elk een eigen CUDA-context MCTS, 800 simulaties per zet 128 partijen per iteratie (stelling, π, z) Replay-buffer, 250k posities + horizontaal gespiegeld (×2) value-doel z: exacte uitkomst van de solver vanaf 6 stenen, anders de partijuitslag ≈ laatste 40 iteraties Trainer 40 stappen × batch 512 AdamW · cosine-LR · AMP + GradScaler grad-clip 5 · entropy-bonus met decay evaluatie elke 40 iteraties nieuwe gewichten via /dev/shm ≈ 6.000 nieuwe posities per iteratie

Verliesfunctie

L = −π·log p + Huber(v, z) − cent(t)·H(p)

Cross-entropy naar de MCTS-bezoekverdeling π, en een Huber-loss (δ = 1) op de value. Een kleine entropy-bonus houdt de policy in het begin breed. Daarna daalt c_ent exponentieel van 0.005 naar 0.001, zodat het model zekerder mag worden naarmate het beter speelt.

Mixed precision

Forward en loss draaien onder torch.amp.autocast. Een GradScaler schaalt de loss op, zodat kleine gradiënten in fp16 niet naar nul vallen. Vóór het clippen wordt teruggeschaald (unscale_), anders klopt de clip-norm niet. De scale bleef de hele run tussen 216 en 219, meestal op 218, en zakte nooit in.

Exacte value-doelen

Een partijuitslag is een ruizig doel: één blunder in zet 30 maakt een gewonnen opening „verloren”. Daarom krijgen stellingen vanaf 6 stenen als doel de theoretische uitkomst, berekend door een perfecte solver in C (het algoritme van Pascal Pons, aangeroepen via ctypes en per worker gecachet).

Trainingsverloop

Van nul tot bijna perfect

De run die hier staat begon vanaf willekeurige gewichten: 1.250 iteraties, ruim 160.000 partijen en ~56 uur op een RTX 3070 Ti (laptop). Elke 40 iteraties speelde het model tegen een vaste set van 98 openingen, met een sterke solver als tegenstander, en werd het getest op 1.000 kritieke stellingen. Rond iteratie 1050 stond de learning rate bijna op het minimum en zat de score op een plateau. Een warme herstart naar 2·10⁻⁴ leverde daarna het beste checkpoint op: iteratie 1161, met 99% theorie gehaald. Beweeg over een grafiek voor de waarden.

Speelsterkte

Aandeel partijen of stellingen goed (%), per evaluatie

Loss

Per iteratie, voortschrijdend gemiddelde over 15 iteraties

Policy-entropie

Hoe breed de policy is (nats)

Entropy-coëfficiënt

Exponentieel verval, 0.005 → 0.001

Learning rate

Cosine van 2·10⁻⁴ naar 10⁻⁵, warme herstart bij 1053

Explained variance, value-head

1 = value voorspelt de doelen perfect