Hier die Build Datei:

https://github.com/LeelaChessZero/lc0/blob/master/build.cmd

Hier die GitHub Seite von Lc0 mit allen Informationen und Verweisen:

https://github.com/LeelaChessZero/lc0

Ceres eine unabhängige Weiterentwicklung von Lc0 „Ceres - an MCTS chess engine for research and recreation“:

https://github.com/dje-dev/Ceres

Hier sind zwei Derivate von Lc0:

https://github.com/Zeta36/leela-fish

Suche von SF, Eval von Lc0

https://github.com/QueensGambit/CrazyAra

Suche von Lc0, Eval Netz von menschlichen Partien

Nibbler, eine AnalyseGPU vor allem für Lc0:

https://github.com/rooklift/nibbler

Hier ein Diagramm über die Struktur von Lc0:

https://discord.com/channels/425419482568196106/425419999096733706/891096507661561857

Hier eine Veröffentlichung über Verbesserungen von AlphaZero:

Improvements to Increase the Efficiency of the AlphaZero Algorithm

https://www.scitepress.org/Papers/2021/102459/102459.pdf

Wie Lc0 die Züge im Suchbaum evaluiert (übersetzt aus https://lczero.org/dev/wiki/technical-explanation-of-leela-chess-zero/ ):

Leela durchsucht einen Baum von Zügen und Spielzuständen.  Jeder Spielzustand ist ein Knoten im Baum mit einem geschätzten Wert für diese Position und einer priorisierten Liste von zu berücksichtigenden Zügen (die so genannte Richtlinie für diese Position).  Traditionelle Schach-Engines haben ein sehr fein ausgearbeitetes Wert- und Richtliniengenerierungssystem;  Im Gegensatz zu herkömmlichen Engines verwendet Leela sein neuronales Netzwerk, das ohne menschliches Wissen trainiert wurde, sowohl für den Wert als auch für die Generierung von Richtlinien.  Dann erweitert Leela den Baum, um ein besseres Verständnis des Wurzelknotens, der aktuellen Position, zu erhalten.

Leela verwendet PUCT (Predictor + Upper Confidence Bound Tree Search). Es werden neue Knoten evaluiert, indem wir ein Playout durchführen: Beginnend mit dem Wurzelknoten (der aktuellen Position), wird ein zu erkundenden Zug gewählt und wiederholen Sie den Baum, bis eine Spielposition erreichet wird, die noch nicht untersucht wurde (oder eine Position, die die  Spiel, das als Endknoten bezeichnet wird). Der  den Baum mit dieser neuen Position erweitert  (unter der Annahme eines Nicht-Endknotens) und verwenden das neuronale Netz, um eine erste Schätzung des Wertes für die Position sowie die Richtlinie für weitere Bewegungen zu erstellen.  In Leela ist eine Richtlinie für einen Knoten eine Liste von Bewegungen und eine Wahrscheinlichkeit für jede Bewegung.  Die Wahrscheinlichkeit gibt die Wahrscheinlichkeit an, dass ein automatischer Spieler, der die Richtlinie ausführt, diesen Zug macht.  Nachdem dieser Knoten zum Baum hinzugefügt wurde, wird diesen neuen Wert auf allen Knoten gesichert, die während dieses Playouts besucht wurden.  Dies verbessert langsam den Wert verschiedener Pfade durch den Spielbaum.

Wenn tatsächlich ein Zug auf dem Brett gespielt wird, wird der gewählte Zug zur neuen Wurzel des Baumes.  Die alte Wurzel und die anderen Kinder dieses Wurzelknotens werden gelöscht.

Dies ist die gleiche Suche, die vom AGZ-Papier PUCT (Predictor + Upper Confidence Bound Tree Search) spezifiziert wird.  Viele Leute nennen dies MCTS (Monte-Carlo Tree Search), weil es dem Suchalgorithmus sehr ähnlich ist, den die Go-Programme im Jahr 2006 verwendet haben. Aber das in AGZ und Lc0 verwendete PUCT ersetzt Rollouts (Sampling von Playouts zu einem Terminal-Spielzustand) mit  ein neuronales Netz, das abschätzt, was ein Rollout bewirken würde.  Andere Suchalgorithmen werden auf Github von Leela Go in Erwägung gezogen, aber es besteht noch kein wirklicher Konsens darüber, dass etwas anderes nachweislich besser ist als PUCT.  Dies ist ein aktives Forschungsthema in der Überschneidung der Bereiche der KI sowie der Spieltheorie.

Hier eine gute Wikipedia Zusammenfassung von AlphaZero:

https://de.wikipedia.org/wiki/AlphaZero?wprov=sfti1

Hier eine mathematische Beschreibung der Lc0-Parameter:

https://lczero.org/blog/2020/04/a-laymans-guide-to-configuring-lc0/

Hier die Fortsetzung des Buches „Game Changer“ von Matthew Sadler:

„The Silicon Road to Chess Improvement
Chess Engine Training Methods, Opening Strategies & Middlegame Techniques“

https://www.newinchess.com/media/wysiwyg/product_pdf/9125.pdf

Mit vielen Stellungsbeispielen.

Hier von GitHub:

https://github.com/LeelaChessZero/lc0/wiki/Technical-Explanation-of-Leela-Chess-Zero

Hier die grundsätzliche Veröffentlichung über attention nets:

https://arxiv.org/pdf/1706.03762v5.pdf

Hier ein GitHub Projekt über „Attention Policy“:

https://github.com/LeelaChessZero/lc0/pull/1688

Hier ein GitHub Projekt über „Attention Net Training“:

https://github.com/Arcturai/lczero-training/tree/attention-net-body/tf

Hier die Veröffentlichung über „ Improving AlphaZero Using Monte-Carlo Graph Search“:

https://ml-research.github.io/papers/czech2021icaps_mcgs.pdf

Lc0 auf iGPU und DX12:

Lothar Jung schrieb:

Hallo Wolfgang,

meine Ryzen 5800h hat eine integrierte Vega 6 iGPU. Sie hat einen TDP von 15 Watt.
Hier ein umfassender Test: <a class='ura' href='https://www.notebookcheck.net/AMD-Radeon-RX-Vega-6-Ryzen-4000-GPU-Benchmarks-and-Specs.453149.0.html'>https://www.notebookcheck.net/AMD-Radeon-RX-Vega-6-Ryzen-4000-GPU-Benchmarks-and-Specs.453149.0.html</a>

Hallo Lothar,

die Vega11 ist in einer etwas älteren APU (Ryzen 5 2400g @ 3,9 GHZ) enthalten.
Aktuell habe ich zwei Ryzen 5 5600g im Einsatz. Diese enthalten eine Vega8, die deutlich höher getaktet ist, 1900 statt 1300 MHZ.
Das Verhältnis von CPU zu GPU bleibt aber in etwa gleich, da auch der CPU-Teil beim 5600g trotz gleicher Taktfrequenz deutlich schneller ist. Von daher habe ich an der Bezeichnung nichts geändert, obwohl sie korrekterweise "Vega8" lauten müsste...

Zitat:
Ich möchte sie gerne testen.
Könntest Du mir Deine backend Einstellungen für die iGPU übermitteln?

Ich habe von Discord folgende Informationen:

„To run on the igpu you can get the binaries and dll from <<a class='ura' href='https://ci.appveyor.com/project/LeelaChessZero/lc0/builds/43650133/job/9t8pjuo2472vgiem/artifacts'>https://ci.appveyor.com/project/LeelaChessZero/lc0/builds/43650133/job/9t8pjuo2472vgiem/artifacts</a>> and will also need the mimalloc dlls from the release. Then you need to add `--backend-opts=gpu=0` (or the equivalent uci option). However this may time out when initializing the backend with cutechess, so you need to add `--preload` to the command (cutechess allows this) and also specify the network file on the command or just have one network file in the directory. Finally a `cl_cache` subdirectory will reduce startup time on subsequent runs.“

Ich kann ehrlich gesagt mit Discord wenig anfangen, bin da nicht angemeldet und werde es auch nicht. Notfalls kenne ich wen, der wen kennt der dort angemeldet ist...

Meine Quelle ist immer https://lczero.org/play/download/
Von dort habe ich mir das DX12 Backend heruntergeladen: "Newer non-NVidia GPUs (only for latest versions of Windows 10)", https://github.com/LeelaChessZero/lc0/releases/download/v0.28.2/lc0-v0.28.2-windows10-gpu-dx12.zip
Das läuft out of the box, notwendige DLLs sind enthalten. Leider laufen aktuellere Netze ab T78... aktuell nicht auf AMD, das wird sich hoffentlich bald ändern.
Es empfiehlt sich auch, nicht die ganz "dicken Dinger" zu nutzen, sind einfach zu langsam. Optimal sind derzeit m.E. die 15x192 Netze, das stärkste ist 771721.

Ich nutze das Ganze ausschließlich unter Arena 3.5.1 und stelle da nichts spezielles ein, sondern nutze die Default-Einstellungen.
Einzige Ausnahme ist der NNCache den ich von 200000 auf 1000000 erhöht habe.
Backend DX12 ist vorbelegt, den Pfad zum Netz musst du nur setzen, wenn mehrere im Verzeichnis sind und das gewünschte nicht das neueste der vorhandenen Netze ist.

Ein Artikel über Directed-acyclic-graph

https://www.researchgate.net/figure/Directed-acyclic-graph-DAG-of-the-complete-data-under-the-missing-at-random-V-0_fig2_223990821

Veröffentlichung "Assessing Game Balance with AlphaZero:
Exploring Alternative Rule Sets in Chess"

https://arxiv.org/pdf/2009.04374.pdf

Hier eine bildhafte Übersicht über die Zusammenhänge zwischen Value und Policy Head:

https://cdn.discordapp.com/attachments/456135840012173313/996460537917476894/unknown.png

Hier eine grafische Übersicht:

https://medium.com/applied-data-science/alphago-zero-explained-in-one-diagram-365f5abf67e0

Hier ist der Anfang einer Serie von bisher 6 Veröffentlichungen zu „Lessons From Implementing AlphaZero“:

https://medium.com/oracledevs/lessons-from-implementing-alphazero-7e36e9054191

Hier zwei Grafik-Links zu MultiHeadAttention mit einer Erklärung:

https://cdn.discordapp.com/attachments/425419483016855563/1028299392635113502/unknown.png

https://cdn.discordapp.com/attachments/425419483016855563/1028299421101858826/unknown.png

Transformer is completely different arch, no convolutional NN tower there.
We use encoder only and 3 heads at the end (Attention policy, WDL value and Moves Left heads).
12 blocks, 8 heads, DFF (feed forward) 1536.
Kind of like GPT3 "small"

Sehr gute Lc0 Präsentation:

https://slides.com/crem/lc0#/logo

Eine umfassende technische Erläuterung von Lc0:

https://lczero.org/dev/wiki/technical-explanation-of-leela-chess-zero/

Compilierung von Lc0:

Give me the command to download and compile the lc0 repository from github on windows.
To download and compile the lc0 repository on Windows, you will need to have Git and a C++ compiler installed on your system. You can then follow these steps:

Open a command prompt or terminal and navigate to the directory where you want to download the lc0 repository.

Run the following command to clone the lc0 repository from GitHub:

```
git clone https://github.com/LeelaChessZero/lc0.git```
Navigate to the lc0 directory that was just created by the clone command:
```
cd lc0```
Run the following command to compile the lc0 source code:
```
cmake -G "Visual Studio 16 2019" -A x64 -DBLAS=OpenBLAS -DUSE_AVX2=ON -DUSE_AVX512=ON -DUSE_OPENMP=ON```
Once the compilation is complete, you can run lc0 by navigating to the build/release directory and running the lc0.exe executable.
```
cd build/release
lc0.exe
```
I want to run the cuda backend, what do I need to change above ?
To compile the lc0 repository with support for the CUDA backend, you will need to have the CUDA Toolkit installed on your system. You will also need a GPU that supports CUDA.

You can then follow the steps above, but when you run the cmake command, you will need to add the -DUSE_CUDA=ON flag to enable CUDA support:
```
cmake -G "Visual Studio 16 2019" -A x64 -DBLAS=OpenBLAS -DUSE_AVX2=ON -DUSE_AVX512=ON -DUSE_OPENMP=ON -DUSE_CUDA=ON
```
Once the compilation is complete, you can run lc0 with the CUDA backend by specifying the --backend=cudnn flag when running the lc0.exe executable:

```
cd build/release
lc0.exe --backend=cudnn
```
Note that you may need to set the CUDA_PATH environment variable to the path of your CUDA installation in order for the cmake command to find the CUDA libraries. For example, if CUDA is installed in C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0, you would set the CUDA_PATH environment variable like this:

```
set CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0
```
You can then run the cmake command as described above.

chatGPT can troubleshoot lc0 installation and compilation problems.

Hier die Veröffentlichung „Acquisition of Chess Knowledge in AlphaZero“:

https://arxiv.org/pdf/2111.09259.pdf

https://storage.googleapis.com/uncertainty-over-space/alphachess/index.html?factor=5

Hier eine neue Implementierung der Q-Funktion:

https://github.com/LeelaChessZero/lc0/pull/1802

Hier eine sehr anschauliche und lehrreiche Lc0 Präsentation:

https://slides.com/crem/lc0#/logo

Sehr empfehlenswert!

Hier eine umfassende technische Erläuterung von Lc0:

https://lczero.org/dev/wiki/technical-explanation-of-leela-chess-zero/

https://www.chess-journal.com/evaluatingSharpness1.html

Hier eine interaktive und sehr anschauliche Präsentation über Lc0, MCTS und Training:

https://slides.com/crem/lc0#/18/0/0

Weiter Entwicklung von Lc0:

https://github.com/Ergodice/lczero-training/blob/attention-net-body/README.md

MS-Veröffentlichung über „DeepNet: Scaling Transformers to 1,000 Layers“:

https://arxiv.org/pdf/2203.00555.pdf

Transformer-Netze sind eine Art von neuronalen Netzwerken, die besonders in der natürlichen Sprachverarbeitung und maschinellen Übersetzung eingesetzt werden. Sie wurden erstmals im Jahr 2017 von Vaswani et al. vorgestellt und haben seitdem zu großen Fortschritten in verschiedenen KI-Anwendungen geführt.

Traditionelle neuronale Netzwerke, wie zum Beispiel rekurrente neuronale Netze (RNNs) oder faltende neuronale Netze (CNNs), verwenden eine sequenzielle Verarbeitung, bei der die Reihenfolge der Eingabedaten berücksichtigt wird. RNNs haben jedoch Schwierigkeiten, lange Abhängigkeiten zwischen Wörtern oder Tokens zu modellieren, und CNNs können die Reihenfolge der Eingabe nicht explizit erfassen.

Transformer-Netze haben dieses Problem durch eine sogenannte "selbst-aufmerksame" Architektur gelöst. Statt einer sequenziellen Verarbeitung verwenden Transformer-Netze parallele Verarbeitungspfade, um Abhängigkeiten zwischen den Eingabedaten zu modellieren. Sie bestehen aus einer Stapelung von mehreren identischen Schichten, die als Encoder und Decoder bezeichnet werden.

Der Encoder nimmt eine Eingabesequenz von Wörtern oder Tokens entgegen und wandelt sie in eine abstraktere Darstellung um, die als "hidden representation" bezeichnet wird. Jedes Wort oder Token wird in einen Vektor, den sogenannten "Embedding-Vektor", umgewandelt. Anschließend durchlaufen die Embedding-Vektoren den Encoder, der mehrere Schichten von "Multi-Head Attention" und "Feedforward Neural Networks" enthält. Die Multi-Head Attention erlaubt es dem Netzwerk, Abhängigkeiten zwischen den Wörtern in der Eingabesequenz zu modellieren.

Die Decoder-Schichten nehmen die versteckte Repräsentation des Encoders und erzeugen schrittweise die Ausgabe. Auch der Decoder besteht aus mehreren Schichten von Multi-Head Attention und Feedforward Neural Networks, jedoch wird zusätzlich eine weitere Attention-Schicht eingeführt, die als "Masked Multi-Head Attention" bezeichnet wird. Diese Schicht stellt sicher, dass bei der Vorhersage jedes nächsten Worts nur die bereits generierten Teile der Ausgabe berücksichtigt werden.

Ein wichtiger Aspekt der Transformer-Architektur ist, dass sie Parallelisierung auf der Ebene der Berechnung ermöglicht. Da die Aufmerksamkeitsmechanismen unabhängig voneinander berechnet werden können, ist es möglich, größere Modelle zu trainieren und effizienter zu arbeiten. Dies hat zu einer Leistungssteigerung in der natürlichen Sprachverarbeitung geführt, insbesondere im Bereich der maschinellen Übersetzung.

Insgesamt haben Transformer-Netze durch ihre Fähigkeit, lange Abhängigkeiten zu modellieren und parallelisiert zu werden, zu großen Fortschritten in der KI geführt. Sie sind flexibel einsetzbar und haben sich als leistungsstarke Architektur für verschiedene Aufgaben erwiesen, einschließlich Übersetzung, Textgenerierung und Spracherkennung.

Lc0, auch bekannt als Leela Chess Zero, ist ein Open-Source-Schachprogramm, das auf künstlicher Intelligenz (KI) und maschinellem Lernen basiert. Es wurde entwickelt, um Schachpartien zu spielen, Strategien zu analysieren und neue Spielzüge zu erforschen. Die Entwicklung von Lc0 begann im Jahr 2017 als ein experimentelles Projekt von Gary Linscott und wurde zu einem gemeinschaftlichen Open-Source-Unterfangen, bei dem Schachenthusiasten und Programmierer aus der ganzen Welt beitrugen.

Lc0 basiert auf der Idee des DeepMind-Projekts AlphaZero und nutzt die Open-Source-Engine Stockfish. Es kombiniert Stockfish mit einer neuronalen Netzwerkarchitektur, die auf Convolutional Neural Networks (CNNs) basiert. Anstatt auf vorprogrammierte Eröffnungsvarianten oder Datenbanken zurückzugreifen, wurde Lc0 darauf trainiert, seine Spielstärke durch maschinelles Lernen zu entwickeln. Das Programm spielt Millionen von Partien gegen sich selbst und passt seine Strategien und Bewertungen basierend auf den gewonnenen Erfahrungen an.

Ein wichtiger technischer Fortschritt in Lc0 war die Einführung der Monte-Carlo-Tree-Search (MCTS)-Technik, die es der KI ermöglicht, einen Suchbaum mit möglichen Spielzügen aufzubauen und die vielversprechendsten Pfade zu erkunden. Durch die Kombination von MCTS mit den erlernten Bewertungsfunktionen des neuronalen Netzwerks konnte Lc0 seine Spielstärke kontinuierlich verbessern.

Weitere technische Fortschritte wurden im Bereich des maschinellen Lernens umgesetzt. Lc0 verwendet Convolutional Neural Networks (CNNs), um Schachpositionen zu bewerten und Spielzüge vorherzusagen. Das Programm trainiert sich selbst, indem es gegen sich selbst spielt und aus den gewonnenen Erfahrungen lernt. Durch die Optimierung von Hyperparametern und den Einsatz von verteiltem Computing konnte die Spielstärke von Lc0 weiter verbessert werden.

Die Attention Policy ist eine weitere wichtige technische Komponente, die in Lc0 implementiert wurde. Diese Aufmerksamkeitsrichtlinie ermöglicht es der KI, relevante Bereiche des Schachbretts zu fokussieren und wichtige Merkmale zu erkennen. Durch die Integration der Attention Policy kann Lc0 Informationen aus dem Schachbrett extrahieren, die für den Spielverlauf von Bedeutung sind, und diese Erkenntnisse in seine Entscheidungsfindung einbeziehen.

Die Entwicklung von Lc0 beinhaltet auch die Integration von Transformer-Netzwerken. Diese Netzwerkarchitektur ermöglicht eine verbesserte Modellierung und Verarbeitung von Schachpositionen. Transformer-Netzwerke erfassen komplexe Beziehungen zwischen Schachfiguren und ihren Positionen und nutzen Multi-Head-Attention-Mechanismen, um relevante Merkmale zu extrahieren und strategische Muster im Schachspiel zu erkennen.

Die Kombination aller dieser technischen Fortschritte hat dazu geführt, dass Lc0 beeindruckende Spielstärke erreicht hat. Es kann komplexe Positionen analysieren, innovative Spielzüge entdecken und sich an verschiedene Spielsituationen anpassen. Lc0 hat in verschiedenen Wettbewerben und gegen menschliche Spieler Erfolge erzielt und trägt zur Erweiterung des Wissens über das Schachspiel und die Möglichkeiten von KI im Schach bei.

Die Entwicklung von Lc0 ist ein kontinuierlicher Prozess, bei dem die Community ständig an der Verbesserung des Programms arbeitet. Durch die fortgesetzte Optimierung der Algorithmen, das Training der neuronalen Netze und den Einsatz modernster KI-Techniken wird Lc0 weiterhin seine Spielstärke steigern und neue Erkenntnisse im Schachspiel gewinnen. Lc0 bleibt ein dynamisches Projekt, das die Möglichkeiten von KI im Schach und anderen Bereichen kontinuierlich erforscht und erweitert.

Gute Beschreibung und graphische Darstellung von Lc0:

https://www.chessprogramming.org/Leela_Chess_Zero

Wichtige KI-Schachveröffentlichung:

https://arxiv.org/pdf/2308.09175.pdf

„Diversifying AI:
Towards Creative Chess with AlphaZero“
vom 16.03.2023, veröffentlicht am 17.08.2023.

Zusammenfassung:

„In den letzten Jahren haben Systeme der künstlichen Intelligenz (KI) die menschliche Intelligenz in einer Vielzahl von Rechenaufgaben übertroffen. Doch wie Menschen machen auch KI-Systeme Fehler, haben blinde Flecken, halluzinieren und haben Schwierigkeiten, sich auf neue Situationen einzustellen. In dieser Arbeit wird untersucht, ob KI von kreativen Entscheidungsmechanismen profitieren kann, wenn sie an die Grenzen ihrer rechnerischen Rationalität stößt. Insbesondere untersuchen wir, ob ein Team aus verschiedenen KI-Systemen eine einzelne KI bei anspruchsvollen Aufgaben übertreffen kann, indem es als Gruppe mehr Ideen entwickelt und dann die besten auswählt. Wir untersuchen diese Frage am Beispiel des Schachspiels, der sogenannten "Drosophila der KI". Wir bauen auf AlphaZero (AZ) auf und erweitern es, um eine Liga von Agenten über eine latent konditionierte Architektur, die wir AZdb nennen, zu repräsentieren. Wir trainieren AZdb, um mit Hilfe von Verhaltensvielfaltstechniken ein breiteres Spektrum an Ideen zu generieren und die vielversprechendsten mit subadditiver Planung auszuwählen. Unsere Experimente deuten darauf hin, dass AZdb auf vielfältige Weise Schach spielt, als Gruppe mehr Puzzles löst und ein homogeneres Team übertrifft. Insbesondere löst AZdb doppelt so viele anspruchsvolle Rätsel wie AZ, einschließlich der anspruchsvollen Penrose-Stellungen. Wenn wir Schach aus verschiedenen Eröffnungen spielen, stellen wir fest, dass sich die Spieler in AZdb auf verschiedene Eröffnungen spezialisieren, und dass die Auswahl eines Spielers für jede Eröffnung unter Verwendung subadditiver Planung zu einer Verbesserung von 50 Elo gegenüber AZ führt. Unsere Ergebnisse deuten darauf hin, dass Diversitätsboni in Teams von KI-Agenten ebenso wie in Teams von Menschen auftauchen und dass Diversität ein wertvoller Vorteil bei der Lösung von rechnerisch schwierigen Problemen ist.“

Ich empfehle den verständlicheren Anhang der Veröffentlichung zu Eröffnungen und Puzzles.

Hier die umfangreichen Parameteroptionen von Lc0:

https://lczero.org/dev/wiki/lc0-options/

Ein vereinfachtes Trainingsset für Lc0 in Python:

https://github.com/Rocketknight1/minimal_lczero

https://slides.com/crem/lc0