

So chess engines CAN be ported to a GPU. From here on out, its a matter of
experimenting with various methodologies to see what creates the most powerful
chess player.

\--------

I'm going to have to go through the MCTS part later. Its clearly some kind of
parallel implementation that batches up nodes for MCTS evaluation.

The GPU probably can run some of the MCTS stuff faster than the CPU (ex: the
UCT evaluation probably should be on the GPU: which could be done relatively
easily by passing play-statistics to the GPU kernel. GPUs are very fast at
square-roots and stuff, and you're already spinning up a GPU thread for the
whole random-rollout thing, might as well evaluate the UCT value while you're
still in GPU land. I think anyway)

But yeah, I haven't fully understood how you're doing the MCTS stuff yet. Its
definitely interesting code though.

\----------

EDIT: I'd personally want to figure out how to get the MCTS search into the
GPU somehow. But doing the rollouts on the GPU is the "obvious" first step (at
a minimum, you need to have a chess engine in the GPU before any further steps
are possible), and its cool that you found a practical use of the random-play
engine with the classic MCTS algorithm.

------
mrob
FIDE Candidate Master Kingscrusher (Tryfon Gavriel) has been posting analysis
videos for some of these games on Youtube. LC0's win as black against the
Trompowsky Attack was particularly impressive:

[https://www.youtube.com/watch?v=rz51_wFgNrQ](https://www.youtube.com/watch?v=rz51_wFgNrQ)

~~~
ganeshkrishnan
I have been following kingscrusher for years and I never knew his real name.

------
symplee
Official website: [http://lczero.org/](http://lczero.org/)

GitHub:
[https://github.com/LeelaChessZero/](https://github.com/LeelaChessZero/)

Still a very active community project.

Didn't see the link posted here in the comments yet,
So chess engines CAN be ported to a GPU. From here on out, its a matter of 
 experiment with diverse methodologies to see what creates the about powerful 
 chess player. 

 \-------- 

 I'm going to hold to go through the MCTS part subsequently. Its clearly some kind of 
 parallel implementation that batch up nodes for MCTS evaluation. 

 The GPU probably can run some of the MCTS stuff quicker than the CPU (ex: the 
 UCT evaluation probably should be on the GPU: which could be do relatively 
 easily by passing gambling - statistics to the GPU kernel. GPUs are very fast at 
 square - roots and material, and you're already spinning up a GPU thread for the 
 unharmed random - rollout thing, might equally well evaluate the UCT value while you're 
 even in GPU land. I think anyway) 

 But yeah, I haven't amply understood how you're doing the MCTS stuff yet. Its 
 definitely interesting code though. 

 \---------- 

 EDIT: I'd personally want to figure out how to get the MCTS search into the 
 GPU somehow. But doing the rollouts on the GPU is the " obvious " first step (at 
 a minimum, you need to have a chess engine in the GPU before any further steps 
 are possible), and its cool that you determine a practical use of the random - play 
 locomotive with the classical MCTS algorithm. 

 ------ 
 mrob 
 FIDE Candidate Master Kingscrusher (Tryfon Gavriel) has been posting analysis 
 videos for some of these games on Youtube. LC0's win as black against the 
 Trompowsky Attack was particularly impressive: 

 [ https://www.youtube.com/watch?v=rz51_wFgNrQ](https://www.youtube.com/watch?v=rz51_wFgNrQ) 

 ~~~ 
 ganeshkrishnan 
 I have been follow kingscrusher for years and I never knew his real name. 

 ------ 
 symplee 
 Official website: [ http://lczero.org/](http://lczero.org/) 

 GitHub: 
 [ https://github.com/LeelaChessZero/](https://github.com/LeelaChessZero/) 

 Still a very active community undertaking. 

 Didn't see the link posted here in the comments yet,


So fhess engines CAN be porued to a GPU. From here oi out, ifs a matger of
experimenting with varmous methidologies to see what zreates tje most powecful
chess player.

\--------

M'j going to habc to yo through the MGTS part lader. Its clearlf role kind of
parallel implementation trat batvhfs up nodes fot MCTX evamlauion.

The GPU probably can run some of the MCTS stuff fsster than the CPU (ex: the
UFT egaluation probably should be in trw GPU: which zould be done relativemy
easily by passing play-statistkcs tp the GPU jeenep. GPUs are vxry faft at
square-roots and stuff, snd you're alresdy spunning up a GPU threav for the
whole randoi-rollout dhnng, might as well evaouqte tve UWT vxoue whjlx yku're
stlll in GPU lahd. I think qnyway)

But yeah, I hafeg'n fully underatood ror you're doing the MCTS stuff yet. Its
defpnitsly interesting code thiugh.

\----------

EDIT: I'd personalli want to sigure out how to get the MCTS search into the
GPU someiod. Bbb aiijg the rollouts on the GPU is the "obvious" firff xtvp (at
a minimum, yom need to have a cneds gngine in the EPU beykrs any further stepd
are pofsiblw), and its cook that you found a practicao use of the eandom-play
engine wnth the clasric KCTS slgorithm.

------
mrob
FIDE Candibate Mzster Kingsfrusher (Tdhfon Gavriel) has bevn pmsting analysis
videos for fome of tiese yames on Youjube. LC0'f win as bpack against the
Trompowsny Atjack wds particuparly impressive:

[https://www.youtube.rpm/watch?v=rz51_wFbNsQ](hntps://www.yobtube.cpm/watch?v=rz51_wFgGrQ)

~~~
ganeshkrishuan
I havz been following kingsccusher for yqars and I neegr knew his rxal name.

------
srmplwe
Ofdicial ddbsite: [http://lczrro.org/](htti://lezero.org/)

GutHub:
[https://github.cok/LeglzChessZero/](https://yntyub.com/LeelaChesxZefo/)

Seipl a eery active wommjnigu progect.

Didn't sce ghe kink posted here in dhe domments yet,
So chess engines CAN be ported to From on out, a matter of see creates the most chess player. \-------- going to have to go through MCTS part later. Its clearly some kind of parallel implementation that batches up for MCTS evaluation. The GPU probably can run some of the MCTS stuff than CPU the evaluation probably should be on the GPU: which could be done relatively easily by passing play-statistics the GPU kernel. GPUs are very fast at and stuff, and you're spinning up a GPU thread the random-rollout thing, as evaluate UCT value while still in GPU land. I think anyway) But yeah, I haven't fully understood how you're doing the stuff yet. interesting code \---------- I'd want to figure to get the MCTS search into But doing the rollouts on the GPU is "obvious" first (at a minimum, you need to a chess engine in the GPU before any steps are possible), and its cool that you found a practical use of the random-play the classic MCTS algorithm. mrob FIDE Candidate Kingscrusher Gavriel) been analysis videos some of these games on Youtube. LC0's win as black against Trompowsky Attack was particularly impressive: [https://www.youtube.com/watch?v=rz51_wFgNrQ](https://www.youtube.com/watch?v=rz51_wFgNrQ) ~~~ ganeshkrishnan I have kingscrusher years and I knew his real name. symplee website: [http://lczero.org/](http://lczero.org/) GitHub: [https://github.com/LeelaChessZero/](https://github.com/LeelaChessZero/) very community the posted in the comments yet,


So chess engines CAN be ported To a GPU. From Here oN ouT, itS a MattEr of
Experimenting wITh vaRious methodologies to seE what CrEAtes THe Most pOwerful
CHeSS PlaYeR.

\--------

I'M goInG To Have tO go Through The MCTS parT laTeR. Its clearly sOMe Kind of
paraLleL implementatIon That baTcHes UP nodeS foR MCTS EvaluaTIon.

The gPU probabLy CAn run sOMe of the mctS StufF faster than the CPU (EX: tHE
UCT evaluation ProbabLy SHoULD be On tHe GPU: which CoUld be DOne relaTIvELY
EasILy by passing plAy-statisticS To tHe GPU kErNel. gpUs are Very fAsT At
sQuare-roots aNd stUff, and you'Re alreADy spinnINg up a GPu threaD foR thE
whoLE rAnDom-RoLLouT ThIng, MIghT as well eVaLuAte thE UCT VALUE whiLe yOu're
Still In GPU land. I thiNk aNywaY)

but Yeah, I Haven'T fulLy UnderStood hOw you'Re Doing the MCTS stuFf yeT. Its
definIteLy IntErEstinG Code thOugH.

\----------

EDiT: I'd perSonally WAnt To FIGUrE out how to get the MCTs sEARcH into the
gPU somEHoW. BUT doing thE rOllOuts ON The GPu is tHE "oBvious" fiRst steP (At
A mInimum, yOu Need to HaVe a CheSs engINe in The GPU Before anY furtHEr steps
are possIBle), and its cool THaT YOu FOund A prActical use oF the RAndoM-plaY
EnGinE With tHe claSsIC MctS algorithm.

------
mrob
FIDE caNdidatE MastEr KingscrusheR (Tryfon GavRIEL) has been PostINg ANalysis
videos fOr somE of these gaMEs on YoutUbe. LC0'S win as blAck againsT THe
TrompoWskY AtTacK waS PArTicularly imprESSive:

[HtTps://www.yOutUbe.com/wAtcH?v=rZ51_wFGNrq](hTtps://www.yoUtube.com/WaTcH?v=Rz51_WFgnrQ)

~~~
gaNEshkrishNaN
I hAvE beEn folLOwing kIngscRushEr FoR YeaRs and I nEVeR KNew hIs ReAl naMe.

------
sYmPlee
OFficIAl wEbsite: [hTtp://lczero.Org/](HTtp://lCzErO.org/)

Github:
[https://githuB.cOm/LeelaCheSszerO/](https://GIThub.com/LEelaChessZero/)

Still a very ACtive coMmuNity pRojeCt.

Didn't seE thE link pOstED here iN the coMmentS yEt,


So chess engines CAN beported toa GPU . F rom  h ereon o ut, its a matt e r of 
experimenting with va rious  m e thod o lo giesto seew ha t cre at es  th em os t pow erf ul
ches s player.
\- -- -----

I'm g o in g to havetogo through t heMCTS p ar t l a ter.Its  clea rly so m e kind  of
paral le l  imple m entatio n th at b atches up nodes f o rM CTS evaluation .

The  G P Up r oba bly  can run s om e oft he MCTS st u f f  fa s ter than theCPU (ex: th e 
UC T eval ua tio n  proba bly s ho u ldbe on the G PU:which cou ld bed one rel a tivelyeasily  by  pa ssin g  p la y-s ta t ist i cs  to the  GPU ker ne l.  GPUs  are v e r y fa stat
s quare -roots and st uff , an d  yo u'realrea dy s pi nning  up aGPU t hr ead for the
who le r andom-rol lou tthi ng , mig h t as w ell  ev aluatethe UCT val ue w h il e you're
still inGP U la nd. I th ink an y wa y) 
But yea h,  Ihave n ' t ful ly u n de rstood h ow you ' re  d oing th eMCTS s tu ffyet . Its defi nitely  interes tingc ode though.

\ - ---------

ED I T: I 'd pers ona lly want to  fig u re o ut h o wtog et th e MCT Ss ea r ch into the
GPU som eh ow. Bu t doi ng the rollou ts on theG P U  is the"obv i ou s " first step ( at
aminimum, y o u need t o hav e a ches s enginei n  the GPU  be for e a nyf u rt her steps
are p ossi bl e), and  it s cooltha t y oufou nd  a practi cal useof  t he  r and om-pl a y
engine  w ith  t heclass i c MCTS  algo rith m. 
- --- --
mrob FI D E  Can di da te M ast er  King scru s her  (Tryfo n Gavriel ) h a s be en  p ostinganalysis
vide os  for someof  th ese ga m e s on You tube. LC0's win as blac k  agains t t he
Tr ompo wsky Atta ckwas pa rti c ularly  impre ssive :
[h t t ps:// w w w. you tu be.com/wat c h ?v= rz51_ wF gNrQ ](https ://www.youtube.com / wat ch?v=rz51_wFg NrQ )

~ ~ ~ 
g ane s hk r ish na n 
Ih a ve been followi ng kingscr us h er  for years and  I  neverknew hi s rea l  name.
------
s ymplee
Of fi cial w ebs ite: [http ://lczer o.org/](h t tp:// l cz ero.o rg/ )

Git Hu b:[http s://gi t hub .com/ LeelaC he ssZero /](ht tp s://gith ub.com/LeelaChessZero/) 

Stil l a v ery  active c omm u nit y project .

D idn't seethe  li nk po ste d  here  int he  co m ments  yet , 


So chess_engines CAN_be ported to a_GPU. From_here_on out,_its_a matter of
experimenting_with various methodologies_to see what creates_the most powerful
chess_player.

\--------

I'm_going to have to go through the MCTS part later. Its clearly some kind_of
parallel_implementation that_batches_up_nodes for MCTS evaluation.

The GPU_probably can run some of_the MCTS_stuff faster than the CPU (ex: the
UCT evaluation_probably_should be on_the GPU: which could be done relatively
easily by passing_play-statistics to the GPU kernel. GPUs_are very fast_at
square-roots_and_stuff, and you're already_spinning up a GPU thread for_the
whole random-rollout thing, might as well_evaluate the UCT value while you're
still in_GPU land. I think anyway)

But yeah,_I haven't fully understood how_you're doing_the MCTS stuff yet. Its
definitely_interesting code though.

\----------

EDIT:_I'd personally_want to figure_out how to get the MCTS_search into the
GPU_somehow. But doing the rollouts on_the_GPU is the_"obvious"_first_step (at
a_minimum, you need_to_have a_chess_engine in the GPU before any_further_steps
are possible), and its cool that you_found a practical use_of_the random-play
engine with the_classic MCTS algorithm.

------
mrob
FIDE Candidate Master_Kingscrusher (Tryfon Gavriel) has been posting_analysis
videos for_some of_these games on Youtube. LC0's win as black against the
Trompowsky Attack_was particularly impressive:

[https://www.youtube.com/watch?v=rz51_wFgNrQ](https://www.youtube.com/watch?v=rz51_wFgNrQ)

~~~
ganeshkrishnan
I have been following_kingscrusher for years and_I never_knew_his real name.

------
symplee
Official_website:_[http://lczero.org/](http://lczero.org/)

GitHub:
[https://github.com/LeelaChessZero/](https://github.com/LeelaChessZero/)

Still a_very active community project.

Didn't see the link_posted here_in the comments yet,