Schaakengine · C# / .NET 10 · UCI

DeepChess

Een klassieke schaakengine, gebouwd met bitboards, alfa-bèta-zoeken en een evaluatie die met Texel-tuning op ruim een miljoen stellingen is afgesteld. Elke wijziging is in honderden partijen gemeten: alleen wat Elo opleverde, bleef erin. Hieronder draait dezelfde C#-code als WebAssembly in je browser.

~2710
Elo op de schaal van Stockfish UCI_Elo (10+0.1, 1 thread)
+610
Elo-winst van v0.1.0 (~2100) naar v0.9.16
31
getagde versies in 17 dagen, elk tegen de vorige of tegen Stockfish gemeten
700+
evaluatiegewichten, automatisch getuned op 1,25 M stellingen
Live demo

Speel tegen DeepChess

De engine draait volledig in je browser, in een Web Worker. Er gaat niets naar een server. In de browser rekent hij met één thread en een geïnterpreteerde .NET-runtime, ongeveer 20× trager dan native: reken op een sterke clubspeler, niet op 2700.

0,00
Engine laden…

Architectuur

Hoe DeepChess een zet zoekt

Het hart is een alfa-bèta-zoekfunctie met iterative deepening: eerst diepte 1, dan 2, enzovoort, tot de tijd op is. Elke diepte maakt de zetvolgorde voor de volgende beter, en een goede volgorde maakt alfa-bèta exponentieel efficiënter. Rond die kern zitten de technieken van moderne engines, elk apart in te schakelen als UCI-optie, zodat hun bijdrage meetbaar is.

1Stelling12 bitborden van 64 bits, Zobrist-sleutel
2Zetgeneratiemagic bitboards voor loper, toren en dame
3Zoekenalfa-bèta, iterative deepening, aspiration windows
4Snoeiennull move, LMR, futility, SEE, late move pruning
5Quiescenceslagzetten uitrekenen tot de stelling rustig is
6Evaluatie700+ getunede gewichten, middenspel ↔ eindspel

Bitboards en magic bitboards

Elk stuktype is een getal van 64 bits, één bit per veld. Aanvallen van lopers, torens en dames komen uit één tabelopzoeking: de blokkerende stukken worden met een "magic" getal vermenigvuldigd tot een index. De magic-getallen zoekt de engine bij het opstarten (0,4 s). +22% snelheid

Transpositietabel

Dezelfde stelling ontstaat via verschillende zetvolgordes. Een hashtabel met buckets van 4 entries en een generatie per zoekopdracht onthoudt score, diepte en beste zet. Diepte 14 met 2 threads ging van 33,7 naar 14,5 s, en 64 MB werkt even goed als 512 MB.

Zetvolgorde

Eerst de zet uit de hashtabel, dan slagzetten en promoties, dan twee killer moves en tot slot rustige zetten op hun history-score: hoe vaak gaven ze eerder een afkapping. history +47 stabiele sortering +42

Snoeien en reduceren

Null move pruning (adaptief: 2 + diepte/4), logaritmische late move reductions, reverse futility en futility pruning, late move pruning, SEE-pruning en internal iterative reduction. Tijd tot diepte 13 ging daardoor van 17,9 naar onder de 5 seconden.

Extensies

Een schaakzet wordt een halve zet dieper gezocht, zodat aanvallen op de koning binnen de horizon vallen. Singular extensions zijn ingebouwd, maar leverden bij 10+0.1 niets aantoonbaars op (+4 ± 26) en staan uit.

Lazy SMP

Meerdere threads zoeken dezelfde boom en delen de hashtabel. Hulpthreads doorlopen de wortelzetten in een andere volgorde en slaan drukke dieptes over. 4 threads tegen 1: +104 Elo; 10 tegen 4 nog eens +96.

Tijdbeheer

Na elke diepte beslist de engine of hij doorgaat: bij een stabiele beste zet stopt hij na 0,7× de normale tijd, bij een wisselende zet of een zakkende score rekent hij tot 2× langer. Met één legale zet speelt hij meteen.

Syzygy en openingsboek

Een eigen lezer voor Syzygy-eindspeltabellen (op basis van python-chess, geverifieerd op 89.426 stellingen zonder één verschil) en voor Polyglot-openingsboeken. Ponderen, Skill Level en UCI_Elo zijn er ook.

Evaluatie

Gewichten uit data in plaats van gevoel

Tot v0.6 waren de gewichten met de hand gekozen: "een paard op e4 is 20 centipawns waard". Een blunderanalyse tegen Stockfish liet zien dat DeepChess daardoor structureel te optimistisch was. In stellingen die volgens Stockfish gelijk stonden, gaf DeepChess zichzelf bijna een pion voordeel.

Bij Texel-tuning worden alle gewichten tegelijk zo gekozen dat de evaluatie de uitslag van echte partijen zo goed mogelijk voorspelt. De score wordt omgezet naar een verwachte uitslag, en de tuner (Adam-optimalisatie, in C#) minimaliseert de kwadratische fout:

verwachte uitslag = 1 / (1 + 10−K · score / 400)
fout = gemiddelde van (uitslag − verwachting)²

De data: 725.000 rustige stellingen uit de Zurichess-set, aangevuld met eigen partijen. Later 8.000 partijen van de engine tegen zichzelf, gelabeld door Stockfish op diepte 10.

+125 ± 46 Elo voor de eerste tuning, tegen dezelfde build met de handgekozen gewichten.

Wat de evaluatie meeweegt

  • Materiaal en stuk-veldtabellenapart voor middenspel en eindspel, geleidelijk overgevloeid op basis van het materiaal
  • Pionstructuurvrijpionnen per rij, verbonden, geïsoleerde, dubbele en geblokkeerde pionnen; met een eigen pionhashtabel
  • Mobiliteiteen waarde per aantal bereikbare velden van paard, loper, toren en dame (132 gewichten)
  • Koningsveiligheidpionschild, aanvallers in de koningszone, veilige schaakvelden, open lijnen; als één formule
  • Stukkenloperpaar, toren op (half)open lijn, buitenposten, hangende en aangevallen stukken
  • Eindspelafstand van de koningen tot vrijpionnen, schaalfactor voor remise-eindspelen

Optimisme vóór de tuning (v0.6.2)

Volgens StockfishStockfishDeepChess
DeepChess staat 1–3 achter−1,85+0,53
ongeveer gelijk0,00+0,86
DeepChess staat 1–3 voor+1,74+2,55

Mediaan van de evaluatie in pionnen, in dezelfde stellingen uit 200 partijen tegen SF2300.

Resultaten

Van ~2100 naar ~2710 Elo

Elke versie is in 200 partijen tegen een afgezwakte Stockfish 16 gemeten (10 seconden + 0,1 per zet, 1 thread, gebalanceerde openingen met wisselende kleuren). De schatting is de ingestelde UCI_Elo plus het gemeten verschil, met een marge van ongeveer ±50.

Geschatte Elo per versieStockfish UCI_Elo-schaal, 10+0.1
Gemeten winst per techniektegen dezelfde build zonder de wijziging, met 95%-marge · grijs: teruggedraaid of standaard uit

Winst tegen jezelf telt half

Van v0.8.0 tot v0.9.4 telden de winsten tegen de vorige versie op tot ongeveer +190 Elo. Tegen dezelfde Stockfish bleef daar ongeveer +90 van over. Een engine wint van zijn eigen vorige versie makkelijker dan van een vreemde engine.

De "correcte" regel speelde zwakker

In v0.2.0 werd een herhaling pas remise bij de officiële drievoudige herhaling: −41 Elo. De strengere regel dwingt de winnende kant nieuwe stellingen op te zoeken; de correcte liet hem heen en weer schuiven tot de tegenstander kon herhalen.

De meetlat is uitgerekt

v0.8.0 scoorde 50% tegen SF2500 maar 28,5% tegen SF2600: bij 10+0.1 liggen die niveaus ~160 Elo uit elkaar, niet 100. Daarom wordt elke nieuwe versie tegen hetzelfde niveau gemeten. Op 40 zetten in 5 minuten scoorde v0.9.16 zelfs 84% tegen SF2600.

Werkwijze

Meten, niet gokken

Matches met cutechess-cli

Elke wijziging is een UCI-optie. Een match speelt de build mét tegen dezelfde build zónder, met elke opening twee keer en wisselende kleuren. 200 partijen geven een marge van ±40 Elo; wat daarbinnen valt, telt niet als bewezen.

SPRT voor kleine winsten

Een Sequential Probability Ratio Test speelt door tot H0 (geen winst) of H1 (minstens +10) aannemelijk genoeg is. Tijdbeheer leek eerst +35 waard, maar kwam na 1.656 partijen uit op +6,5 ± 13: de eerste meting was vooral geluk.

Blunderanalyse met Stockfish

Een Python-script laat Stockfish elke zet van DeepChess beoordelen, per fase. Zo bleek het eindspel eerst het zwakst (224 van 272 blunders), en na de koningstabel het middenspel. De blunderstellingen worden daarna een regressietest.

Zelfde boom, sneller

Snelheidswinst telt pas als de zoekboom exact gelijk blijft: hetzelfde aantal knopen op vaste diepte. Gemeten met perf stat in beide volgordes. Zo bleef bijvoorbeeld PEXT eruit: winst binnen de meetruis.

Wat niet werkte

PVS, continuation history, "improving", PV-knopen apart, stemmen tussen threads en schaakzetten in de quiescence: allemaal ingebouwd, gemeten en teruggedraaid of uitgezet. Zie de grijze balken hierboven.

163 unittests

Zetgeneratie (perft), Zobrist-hashing, transpositietabel, SEE, Polyglot, Syzygy, tactische stellingen uit Win at Chess, en het UCI-protocol zelf. Snelheidsoptimalisaties moeten dezelfde tests en dezelfde knopen halen.

Zelf gebruiken

DeepChess in je eigen schaak-GUI

DeepChess heeft geen eigen interface: het is een UCI-engine die je koppelt aan een GUI zoals Cute Chess, PyChess, Arena of BanksiaGUI. Bouwen vraagt de .NET 10 SDK:

# bouwen
dotnet publish DeepChess.Uci -c Release -o publish

# snelle controle
printf 'uci\nisready\nposition startpos\ngo depth 12\nquit\n' \
  | ./publish/DeepChess.Uci

Een Elo-meting tegen Stockfish:

cutechess-cli \
  -engine cmd=./publish/DeepChess.Uci option.Threads=1 \
  -engine cmd=stockfish option.UCI_LimitStrength=true \
          option.UCI_Elo=2600 option.Threads=1 \
  -each proto=uci tc=10+0.1 \
  -openings file=noob_3moves.epd format=epd order=random \
  -repeat -games 2 -rounds 100 -concurrency 4

Belangrijkste opties

OptieStandaardBetekenis
Hash64transpositietabel in MB
Threads½ coresLazy SMP-zoekthreads
BookFileleegPolyglot-openingsboek (.bin)
SyzygyPathleegmap(pen) met eindspeltabellen
Skill Level200–20, zwakker spelen zoals Stockfish
UCI_Elo27101320–2710, met UCI_LimitStrength
Ponderuitdenken in de tijd van de tegenstander
EvalFileleeggewichten uit de tuner

Daarnaast is elke zoektechniek (NullMovePruning, LateMoveReductions, AspirationWindows, …) en elk getal ervan (LmrBase, FutilityPerPly, …) als optie in te stellen, voor eigen experimenten.