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.
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.
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.
Bezoeken per kolom in de zoekboom. De gekozen zet is geel gemarkeerd.
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.
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).
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.
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.
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.
c_puct = 1.2
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.
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.
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.
Zonder ruis en temperatuur speelt self-play steeds dezelfde partij, en dan leert het netwerk alleen die ene opening.
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.
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.
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.
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).
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.
Aandeel partijen of stellingen goed (%), per evaluatie
Per iteratie, voortschrijdend gemiddelde over 15 iteraties
Hoe breed de policy is (nats)
Exponentieel verval, 0.005 → 0.001
Cosine van 2·10⁻⁴ naar 10⁻⁵, warme herstart bij 1053
1 = value voorspelt de doelen perfect