Beyond Perfection: The Ultimate Guide to Lc0's Human-Like Personality Nets!

[Dirk]

Ok I have gathered all the information about net models I use for lc0 in order to play against a human-like opponent.

With the help of Gemini I can now present the ultimate guide for human-like lc0 nets : 

 

Hey Picochess crew,

get ready to completely transform your chess experience! While our recent discussions about complex PyTorch models were fascinating, I’m thrilled to introduce a far simpler, more performant, and, frankly, more fun path to creating incredible chess opponents for PicoChess.

We're talking about a new generation of Lc0 neural networks specifically designed to play with human-like style, character, and even fallibility.

The best part? The setup is a dream:

1. Download a network file.
2. Import Lc0 as an engine in Picochess (should be already there).
3. Point the engine to the net and, crucially, set a specific node limit. That’s it!

This guide will be your deep dive into this amazing world. Let's get started!

1. The Philosophy: Why Weaker, Human-Like Nets are a Game-Changer

The goal here isn't to build the strongest engine possible—it's to build the most interesting one. Instead of getting steamrolled by a flawless 3500 Elo demigod, you get a sparring partner that feels human, is beatable (but still a challenge!), and is perfect for our Picochess setups.

2. The Tech Evolution: Lc0's Shift from ResNet to Transformers

It's helpful to know the two main types of Lc0 architecture:

• Vision/ResNet (The Classics): The original architecture, robust and the foundation for the first wave of "personality" nets.
• Transformers (The New Wave): The cutting-edge architecture (like ChatGPT etc.) with a deeper understanding of the board and game course, used to create the next generation of nuanced, human-like opponents.

Part I: The Pioneers – The Maia Project (ResNet-Based)

Maia was a revolutionary project that trained an AI only on human games from specific rating levels. The key to authentic Maia play is to use a small, fixed node search (e.g., 2-12 nodes). This preserves its human-trained character while allowing it to avoid simple one-move blunders.

Maia Net Target Elo Recommended Nodes
maia-1100 ~1100 1–2
maia-1300 ~1300 1–2
maia-1500 ~1500 1–4
maia-1700 ~1700 1–6
maia-1900 ~1900 2–8
maia-2200 ~2200 4-10
maia-2500 ~2500 6-12

I have added the 2200 and 2500 nets to my maia configuration:

maia.uci

[DEFAULT]

Hash = 192

Threads = 1

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1100.pb.gz

;SyzygyPath = /opt/picochess/tablebases/syzygy

[Elo@1100]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1100.pb.gz

[Elo@1200]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1200.pb.gz

[Elo@1300]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1300.pb.gz

[Elo@1400]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1400.pb.gz

[Elo@1500]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1500.pb.gz

[Elo@1600]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1600.pb.gz

[Elo@1700]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1700.pb.gz

[Elo@1800]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1800.pb.gz

Threads = 2

[Elo@1900]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1900.pb.gz

Threads = 2

[Elo@2200]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-2200.pb.gz

Threads = 2

[BigMaia@2500]

WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-2500.pb.gz

Threads = 2

Part II: The Personalities – Detlef Kappe's "Gyal" Family (ResNet-Based)

This is where the magic truly happens. Detlef Kappe created a legendary series of nets, each with a distinct and vibrant personality, often by blending human Lichess data with Stockfish analysis.

Master Download Link for Kappe's Nets: https://github.com/dkappe/leela-chess-weights/wiki/Bad-Gyal

Meet the "Gyal" Family:

• Mean Girl (The Unorthodox Attacker): The most famous of the set. Expect aggressive, tricky, and unorthodox play. On a Raspberry Pi 3, she hits ~2400 Lichess Elo with just 8 nodes per move!  https://github.com/dkappe/leela-chess-weights/wiki/Mean-Girl:--the-most-fun-leela-style-net
• GOODGYAL (The Solid "Good Girl"): Plays a more solid, positional, and strategic game. Excellent for honing your positional understanding.
• BADGYAL (The "Bad Girl" Brawler): A wild, tactical, and aggressive style, perfect for sharp, "coffee house" style games.
• EVILGYAL (The "Evil" Maniac): Plays an extremely aggressive, sacrificial style. Perfect for chaotic and entertaining games.
• TINYGYAL (The Tiny Sparring Partner): Explicitly designed as a weaker sparring partner. An incredibly small 2x16 net that is perfect for beginners. Try it with just 10-50 nodes.

Part III: The Future is Now – Fine-Tuned Transformer Nets

These nets are created by taking a god-tier Lc0 Transformer and fine-tuning it on hundreds of thousands of high-level human games. This shapes its style to be more human while retaining immense power.

Origins:

• "classic1" T1-512x15x8h-swa-3395000 fine-tuned with classical games where both players were rated 2500+
• "maia3" 768x15x24h-t82-swa-7464000 fine-tuned with 2020–2023 Lichess blitz games where both players were rated 2600+, and at least one was 2800+, with all bot games excluded. (~200k games, 10k steps, 1024 batch size)
• "classic2" Maia3 fine-tuned with (all?) registered classical games from ~1993–2023 where both players were rated 2550+. (~200k games, 10k steps, 1024 batch size) 

The Ultimate Strength Guide: Nodes vs. FIDE Elo

This amazing table, based on data from Kronos, is your cheat sheet. Crucial Rule: maia3 needs roughly double the nodes of classic2 for the same strength.

Target-Elo Elite v2 Nodes/Move classic2 Nodes/Move maia3 (Est. Nodes)
~400 Policy/1 - -
~1500 8 - -
~1600 13 - -
~1700 20 - -
~1800 31 - -
~1900 48 - -
~2000 - 1 2
~2100 - 5 10
~2200 - 10 20
~2300 - 15  30
~2400 - 21 42
~2500 - 28 56
~2600 - 41 82
~2700 - 63 126
~2800 - 103 206
~2900 - 180 360
~3000 - 336 672
~3100 - 685 1370
~3200 - 1600 3200

Downloads for the Transformer Gods:

• classical1: Download Link
• maia3: Download Link
• classic2: Download Link
• Elite & maia2200: https://github.com/CallOn84/LeelaNets

Bei aware of the fact that not all nodes numbers can be achieved by all Raspberry Pis  (but no worries - thats might be even better for a more human like playing style ;-)

About setting the node limit

You have two options:

1. Set the number of nodes manually by choosing Time -> Nodes -> …
2. Set the number of nodes automatically by defining an „elo“ level in the uci file for lc0 consisting of the uci parameter WeightsFile, Threads and PicoNode (for this you need my updated picochess.py source file from my GitHub repository https://github.com/tosca07/picochess) 

Elo-Level samples for explicit nodes settings in the uci file for lc0:

[Elite@400]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz

Threads = 2

PicoNode = 1

[Elite@1500]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz

Threads = 2

PicoNode = 8

This is how my current lc0 uci file looks like (I have not done this yet for my lc0 entries as I use the manual method)

[DEFAULT]

Hash = 192

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/792013-192x15.txt

##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/t1-256x10-distilled-swa-2432500.pb.gz

##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/128x10-t60-2-2990.txt

SyzygyPath = /opt/picochess/tablebases/syzygy

Backend = blas

MinibatchSize = 16

CPuct = 1.745000

MaxPrefetch = 0

SmartPruningFactor = 5 

MaxCollisionVisits = 1

[01-Mean Girl]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/meangirl-8.pb.gz

Threads = 1

[02-Bad Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/badgyal-8.pb.gz

Threads = 1

[03-Good Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/goodgyal-7.pb.gz

Threads = 1

[04-Evil Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/evilgyal-6.pb.gz

Threads = 1

[05-Tiny Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/tinygyal-8.pb.gz

Threads = 1

[06-classic1]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic1.pb.gz

Threads = 1

[07-classic2]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz

Threads = 1

[08-maia3]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz

Threads = 2

[09-elitev2]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz

Threads = 2

[10-Std1Core]

Threads = 1

[11-Std2Cores]

Threads = 2

[12-Std3Cores]

Threads = 3

[13-Std4Cores]

Threads = 4

So, fire up your Pi, download a few nets, and start experimenting. Begin with a low node count, see how long your Pi takes to make a move, and adjust to find the perfect balance of strength and speed for your enjoyment.

Happy playing!

Dirk

[Randy Reade]

This is very interesting, Dirk. I'll try to find some time to set it up. Thanks for sharing.

Randy

--
You received this message because you are subscribed to the Google Groups "PicoChess" group.
To unsubscribe from this group and stop receiving emails from it, send an email to picochess+...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/picochess/84cba7fd-0ec6-4701-8cb3-d8fb3bb201ccn%40googlegroups.com.

[Andrea Gatti]

Dirk, this is absolutely awesome. It is a great addition to PicoChess, I'd say a new Chapter altogether.

I'd love to test it out and I plan to do so, as son as I'm back from a short vacation.

Thank you!

Andrea

[Dirk]

I have added the suggested nodes restriction for the different models  in my uci files (remember you will need my updated picochess.py source file rom my GitHub repository if you want to use this automation otherwise just set the number of nodes via the Time -> Node ... menu option)

lc0.uci:

[DEFAULT]
Hash = 192
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/792013-192x15.txt
##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/t1-256x10-distilled-swa-2432500.pb.gz
##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/128x10-t60-2-2990.txt
SyzygyPath = /opt/picochess/tablebases/syzygy
Backend = blas
MinibatchSize = 16
CPuct = 1.745000
MaxPrefetch = 0
SmartPruningFactor = 5
MaxCollisionVisits = 1

[01-Mean Girl]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/meangirl-8.pb.gz
Threads = 1

PicoNode = 2

[02-Bad Gyal]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/badgyal-8.pb.gz
Threads = 1

PicoNode = 2

[03-Good Gyal]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/goodgyal-7.pb.gz
Threads = 1

PicoNode = 2

[04-Evil Gyal]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/evilgyal-6.pb.gz
Threads = 1

PicoNode = 2

[05-Tiny Gyal]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/tinygyal-8.pb.gz
Threads = 1

PicoNode = 2

[06-classic1]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic1.pb.gz
Threads = 1

PicoNode = 1

[07-classic2-1]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz
Threads = 2
PicoNode = 1

[07-classic2-2]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz
Threads = 1

PicoNode = 2

[08-maia3]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 1
PicoNode = 1

[09-elitev2@400]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2
PicoNode = 1

[09-elitev2@1000]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2

PicoNode = 4

[09-elitev2@1500]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2
PicoNode = 8

[09-elitev2@1700]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2

PicoNode = 20

[10-Std1Core]
Threads = 1

[11-Std2Cores]
Threads = 2

[12-Std3Cores]
Threads = 3

[13-Std4Cores]
Threads = 4

maia.uci:

[DEFAULT]
Hash = 192
Threads = 1
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1100.pb.gz
;SyzygyPath = /opt/picochess/tablebases/syzygy

[Elo@1100]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1100.pb.gz

PicoNode = 1

[Elo@1200]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1200.pb.gz
PicoNode = 1

[Elo@1300]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1300.pb.gz
PicoNode = 1

[Elo@1400]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1400.pb.gz
PicoNode = 2

[Elo@1500]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1500.pb.gz
PicoNode = 2

[Elo@1600]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1600.pb.gz
PicoNode = 3

[Elo@1700]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1700.pb.gz
Threads = 2
PicoNode = 3

[Elo@1800]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1800.pb.gz
Threads = 3
PicoNode = 3

[Elo@1900]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-1900.pb.gz
Threads = 2

PicoNode = 3

[Elo@2200]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-2200.pb.gz
Threads = 2

PicoNode = 4

[BigMaia@2500]
WeightsFile = /opt/picochess/engines/aarch64/maia_weights/maia-2500.pb.gz
Threads = 2

PicoNode = 6

[Randy Reade]

Hi Dirk,

Hash is no longer a valid option for lc0/maia so can be removed from the respective .uci file. Also, since maia in my images is just lc0 compiled with 1 node as default, I don't know if it's useful to keep it with your new picochess.py. We could probably just rename lc0 to maia. Or do we even need a maia any more?

Randy

--
You received this message because you are subscribed to the Google Groups "PicoChess" group.
To unsubscribe from this group and stop receiving emails from it, send an email to picochess+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/picochess/58dafdf1-6196-4ef1-bda2-3c198e44969fn%40googlegroups.com.

[Luigi Vogliobene]

Hi Dirk, where to find the BigMaia 2500 weight file ? Thank you. Luigi 

[Dirk]

https://drive.google.com/file/d/1eT76c17prwirTDtPSGTNlUgwqIW8d_Cv/view?usp=sharing

This link was missing - thanks Luigi!

Dirk

[Dirk]

Hi Randy,

yes we even could make a copy of lc0 and rename it according the model name for each main model net and then define the uci file of the different elo/nodes level eg: (for elite, classical2, maia3).

Regarding maia1 I am not sure if someone wants to keep the old architecture (meaning no necessarily to set the nodes manually or if someone does not like the clock display when the nodes level are active.

I think your hard codes nodes = 1 command is correctly overwritten when sending a new go  command with the nodes restriction so we could keep your Maia compilation and the user could deicide if he wants too keep the old uci levels or the updated ones...

Hmmm... I leave the decision up to you and your images ;-)

Dirk 

[Thomas]

I am looking forward to receiving the new possibilities in the next images as I am not firm understanding all of the above written ;)

[Dirk]

Hi Thomas,

no wories: you don’t need to understand all the deep leaning neural network nitty-gritty to enjoy the cake. Hopefully some of these „human“ neural network opponents will find their way into the images provided by Randy.

I have created an overview (for me) because of the whole complex deep learning fuss, maybe some of you find it helpful.

Dirk  

A Grandmaster's Guide to AI Brains: Understanding the New Wave of Chess Engines

You've probably noticed a zoo of new, weirdly-named chess engines popping up lately: Maia, Maia2, Meangirl, Elite, Chess-Transformers... What's the deal? Aren't they all just „engines“?

Well, not quite. We're moving beyond the age of engines that just calculate billions of moves. The new kids on the block use "deep learning," and they learn and "think" about chess in fundamentally different ways. Some try to be gods, others try to be... well, us!

Let's break down the key differences. Think of this as getting to know the personalities of your new digital opponents.

1. The Brain's Blueprint: Engine Architectures

The "architecture" is the fundamental design of the neural network. Just like a car can have a V8 engine or an electric motor, AIs have different brain structures for different tasks.

a) The Classic: ResNet (The Image Recognizer)

Think of a Residual Network (ResNet) as an AI that sees the chessboard as a picture. It’s incredibly good at recognizing static patterns in that picture: "Aha, this pawn structure looks good," or "That knight on f5 is a monster."

• Who uses it? Early Leela Chess Zero (Lc0) networks, the Maia 1 models, and Detlef Kappe's fantastic "personality" engines (like Meangirl, Boring, etc.).
• Strengths: Very efficient and powerful for evaluating a single, given position. It's a master of tactics and positional patterns.
• Weaknesses (The "Goldfish Brain" Problem): A pure ResNet has no memory of how the game got to this position. It just sees the "now." It doesn't understand the story of the game or the long-term plans that led to the current board state.

b) The New Challenger: Transformers (The Language Master)

This is the same architecture that powers models like ChatGPT. A Transformer doesn't see the board as a static image; it reads the entire game as a language. The input isn't just the board position, but the sequence of moves that got there (e.g., "1. e4 e5 2. Nf3 Nc6...").

• Who uses it? Maia 2, the chess-transformers project, the very latest Lc0 networks, bigmaia2500, and the "elite" series.
• Strengths (The "Storyteller"): Because it understands the sequence, it grasps the context of the game. It can recognize long-term strategic plans, understand opening theory on a deeper level, and make moves that are logically consistent with the flow of the game. This is a huge leap forward!
• Weaknesses: They are generally more complex and computationally "heavy" to train and run than ResNets.

2. The School of Chess: How These Engines Learn

An AI is only as good as its teachers and its textbooks. This is where the philosophies diverge dramatically.

a) The "Zero" Method: Learning From the Void (Leela Chess Zero)

This is the famous AlphaZero approach. You give the AI a completely blank slate—it only knows the rules of chess. Then, you make it play millions of games against itself.

• Method: It starts by making random moves. When a game ends, it looks back and learns what moves led to a win. The AI is its own teacher and student. This is called Reinforcement Learning.
• Result: The engine develops a completely alien, superhuman understanding of chess, untainted by centuries of human bias. It discovers strategies we never dreamed of. The goal is to find the objectively best move, period.

b) The Human-Trained Method: Learning From Us! (Maia, Kappe's Nets, Transformers)

These engines are designed to play more like humans. To do that, they study... well, humans!

• Method: Developers feed the AI a massive database of millions of games played by humans (often from Lichess). The AI's goal is to predict the next move a human would make in a given position. This is called Supervised Learning.
• Sub-Flavors:
  • Pure Human (Maia, chess-transformers): These models purely try to imitate human moves from specific Elo brackets. This is why a "Maia-1500" will sometimes make a blunder a 1500-rated player would make! Its goal is imitation, not perfection.
  • The Hybrid (Detlef Kappe's Nets): This is a clever twist. Detlef's engines are also trained on human games, but with a grandmaster "coach" looking over their shoulder: Stockfish! The AI learns from human moves, but Stockfish's analysis is blended in to prevent it from becoming too bad or random from learning all the terrible moves we mortals play.

3. How They "Think": Search Methods

A neural net provides the "intuition," but an engine still needs a way to "think" ahead and calculate variations.

a) Traditional Search & NNUE (The Deep Calculator)

Traditional engines like Stockfish use a brute-force (but very clever) search method called Alpha-Beta Pruning to explore millions of possible future positions. For decades, they evaluated these positions using hand-crafted rules (e.g., "a queen is worth 9 points," "rooks on open files are good").

The modern twist is NNUE (Efficiently Updatable Neural Network). This replaces the old hand-crafted rules with a small, super-fast neural network that runs on the CPU. So, Stockfish still uses its powerful Alpha-Beta search, but the final "is this position good or bad?" question is answered by a mini-AI.

b) Monte Carlo Tree Search - MCTS (The Smart Scout)

This is what Lc0 uses. MCTS doesn't try to look at every branch of the game tree. Instead, it acts like a team of scouts.

1. The main neural network (Policy Head) suggests a few "interesting" moves to explore.
2. The engine "plays out" thousands of quick, semi-random games (simulations) starting from those moves.
3. It checks which starting moves led to the best outcomes most often.
4. The move that consistently led to good results is the one it plays.

Why use MCTS for these big networks? Because it pairs perfectly with the network's "intuition." The network intelligently guides the search, focusing the engine's power only on the most promising variations instead of wasting time on obviously bad moves.

4. Taming the Beast: Controlling Strength and Personality

A full-power Lc0 is a god. But what if you want a fun, beatable, or "stylish" opponent? You need to put a leash on it.

• Use of smaller networks 
• Direct Output Transformers Nets based on Torch etc): Similarly, a pure Transformer-based engine can just output the most likely next "word" (move) in the game's "sentence." No deep search happens. (Maia2, chess-transformers)
• Limited Search (Lc0 Personalities): This is the most common and flexible technique. You take the god-like Lc0 engine but deliberately restrict its thinking time. Instead of letting it check millions of positions (nodes), you might limit it to just a few hundred.
  • Policy Only (Maia 1): This is the simplest method. The engine doesn't "think" ahead at all. It just plays the first move that comes to its mind—the one its policy network says is most probable. This is often called using "1 node." It’s pure instinct.
  • Small node numbers up to max. Some hundred

The result? An engine that has the superhuman intuition of Lc0 but lacks the deep tactical calculation to be perfect. It might play a beautiful, strategic game but can sometimes miss a deep tactic. This is exactly how Kappe's nets, Maia 3, Elite, etc., are configured to create distinct and human-like playing styles!

Summary Table: The AI Chess World at a Glance

🧠 1. Traditional Engines (e.g., Stockfish 17)

• Core Philosophy:
  Their main goal is to find the best move through massive, efficient brute-force calculation. These engines analyze millions of positions very quickly to determine the strongest continuation.
• "Brain" Type:
  A combination of classic alpha-beta search algorithms and a neural network evaluator (NNUE) to refine decision-making. The search is still rule-driven and highly optimized.
• Learning Method:
  The NNUE component is trained on vast amounts of chess data, but the search process itself is purely algorithmic and not learned — it’s engineered.
• Goal of a Move:
  To identify the objectively strongest move based on deep, exhaustive evaluation of possible continuations.
• Personality:
  Cold, precise, tactical, and relentless. These engines are like calculators — they won’t miss a tactic and often spot deep combinations humans wouldn’t consider.

🤖 2. "Zero" Method Engines (e.g., Lc0)

• Core Philosophy:
  These AIs start from nothing and learn everything by playing against themselves. The goal is to discover strong strategy through reinforcement learning rather than being told what’s good.
• "Brain" Type:
  Typically uses a ResNet or Transformer neural network as an evaluator, paired with Monte Carlo Tree Search (MCTS) for decision-making. It’s inspired by AlphaZero.
• Learning Method:
  Reinforcement learning via millions of self-play games. No human data is used — only the rules of chess and self-improvement through experience.
• Goal of a Move:
  To play the move that its own training has proven best, based on what it’s learned from self-play and MCTS exploration.
• Personality:
  Often creative, alien, and profoundly strategic. These engines sometimes make moves that seem strange to humans but are incredibly effective. Their style feels more “philosophical” or intuitive.

🧍‍♂️ 3. "Human-Trained" Models (e.g., Maia, Kappe, Transformer-based bots)

• Core Philosophy:
  The goal is to imitate human players — including their strengths, typical ideas, and even their mistakes. These models aim to be relatable rather than perfect.
• "Brain" Type:
  Built on ResNet or Transformer architectures. Often these systems operate with minimal or no search, relying on pattern recognition alone.
• Learning Method:
  Supervised learning using massive databases of real human games. The model learns what a player of a given rating is statistically likely to play in a position.
• Goal of a Move:
  To play the move a human (of a specific skill level) would most likely choose — not necessarily the objectively best move, but the most realistic one.
• Personality:
  Flexible and customizable. It can be tuned to play like a solid club player, an aggressive attacker, or even someone who blunders a bit! Great for training or fun matches with human-like behavior.

Hope this helps demystify these amazing new engines! It's an exciting time to be a chess fan.

Happy chess playing!

--------------------------------------------------------------------------------------------------------------------------------

[Thomas]

Absolutely! I understand the different approaches in learning etc.. Looking forward to (hopefully) seeing all this gems integrated in the next versions of PicoChess.

I built an AI-automation that analyses my games after a PicoChess match. Logfile sent to me via Email > PGN gets extracted by my AI > Email with suggestions to improve and focusing on in my studies is sent to me in the tonality of a friendly Grand Master who teaches me his secrets. ♟️ 😀

[Dirk]

I have reworked the lc0 settings so that they would better fit to my chess playing strength level and hardware (I use my pi5 for these most of the time) and modified the level texts so that they better fit for web and DGTPI display....

[DEFAULT]

[06-maia3 1n]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 2
PicoNode = 1

[06-maia3 2n]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 2
PicoNode = 2

[06-maia3 3n]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 2
PicoNode = 3

[classic1]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic1.pb.gz
Threads = 1
PicoNode = 1

[classic2-1n]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz
Threads = 2
PicoNode = 1

[classic2-2n]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz
Threads = 2

PicoNode = 2

[classic2-3n]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/classic2.pb.gz
Threads = 2

PicoNode = 3

[elite 0400]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 1
PicoNode = 1

[elite 1000]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2

PicoNode = 2

[elite 1300]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2

PicoNode = 3

[elite 1500]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2
PicoNode = 4

[elitev 1700]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2
PicoNode = 8

[elitev 1900]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/elite_v2.pb.gz
Threads = 2

PicoNode = 16

[Dirk]

fixed some copy/paste glitches ...

[DEFAULT]
WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/792013-192x15.txt
##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/t1-256x10-distilled-swa-2432500.pb.gz
##WeightsFile = /opt/picochess/engines/armv7l/lc0_weights/128x10-t60-2-2990.txt
SyzygyPath = /opt/picochess/tablebases/syzygy
Backend = blas
MinibatchSize = 16
CPuct = 1.745000
MaxPrefetch = 0
SmartPruningFactor = 5
MaxCollisionVisits = 1

[1-Mean Girl]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/meangirl-8.pb.gz
Threads = 1
PicoNode = 2

[2-Bad Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/badgyal-8.pb.gz
Threads = 1
PicoNode = 2

[3-Good Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/goodgyal-7.pb.gz
Threads = 1
PicoNode = 2

[4-Evil Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/evilgyal-6.pb.gz
Threads = 1
PicoNode = 2

[5-Tiny Gyal]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/tinygyal-8.pb.gz
Threads = 1
PicoNode = 2

[6-maia3 1n]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 2
PicoNode = 1

[7-maia3 2n]

WeightsFile = /opt/picochess/engines/aarch64/lc0_weights/maia3.pb.gz
Threads = 2
PicoNode = 2

[8-maia3 3n]

[01-Std1Core]
Threads = 1

[02-Std2Cores]
Threads = 2

[03-Std3Cores]
Threads = 3

[04-Std4Cores]
Threads = 4

[Andrea Gatti]

Hello Dirk, thank-you. Your work continues to be extremely interesting in the realm of new Chess Engines' algos and nets.

Would you be able to elaborate a bit more on what/how you tuned the Lc0 params?

I'm currently using a Rpi 4B 4Gb and my ELO rating is approx 1500 (FIDE).

Is there a formula that links how you would set Lc0 up, depending on your rating?

Thanks!

Regards

AG

PS: Now that the vacation period has started here in Italy, I'd like to experiment a bit with my PicoChess and set it up with these latest additions!

[Dirk Mollmann]

Hi Andrea,

there is no specific general formula for the node settings regarding elo strength as it depends on the specific network (size, architecture etc).

The values in my first postings are the suggested values I found in the corresponding discord threads etc.

I just figured out that for me the original settings are too high so I reduced them a little bit.

It is a try and error with the node settings but as small numbers are already sufficient for a decent play it won’t last too long until you will figure out sine settings that fit your strength I guess.

Enjoy!

Dirk

[Andrea Gatti]

Hi Dirk, interesting.

What you mention, in general regarding engine's ELO strenght on PicoChess, reminds me that I need to move forward with an idea I started working on, recently. To be honest, I started working on it only since ChatGPT has become so powerful and available to everyone. This is because I use it to help me with programming, since I'm not a programmer.

Here's the idea:

I started working on accessing PicoChess' engines from within the ChessBase GUI. The idea is that an engine, running on PicoChess, is seen as a remote engine from the GUI installed on the PC.

Why doing so?

Because I own a paid version of their program :-) and because that GUI is a good stage where I can play tournaments between engines.

As I mentioned in some other threads, for me PicoChess represents a training tool, and under that light, it is somehow important for me to understand pretty reliably what an engine's ELO strenght is. By running engines tourneys on the PC GUI, I will be able to assign specific ELO rating to the engines on my specific install of PicoChess.

For the same very reasons, your work with engines playing "human" style, is extremely important to me.

I hope I have been clear with my explanation.

If you happen to have ideas that can help me with my project, please feel free to share them. Or maybe there is an easier way to run engine tournaments between set of engines (around 6  or 8 or 10 at a time) in a different GUI? I don't know.

Thanks!

Ciao Andrea.

[DJ Dekker]

Hi Andrea,

As far as the engine tournament is concerned, my suggestion would be that you compile “Scid vs. PC” from source on your Raspberry Pi. This app is not only a games database,  but can also be used to run engine tournaments. This would eliminate the need for setting up remote engines.

Greetings,

DJ

Op zaterdag 9 augustus 2025 om 09:16:53 UTC+2 schreef andreag...@gmail.com:

[Andrea Gatti]

Hello DJ, nice to read from you.

Thank-you, I did not think about Scid vs PC. I'm not familiar with it, and I didn't know it could be compiled for an Rpi.

While browsing for it, I incidentally came across an old thread by yourself, where you mentioned you had been able to compile and run it on an Rpi, where you organised some engine_vs_engine tournaments, to assign ELO rating to them.

As far as compilation on the RPi goes, my skills stop at compiling Stockfish and a handful of other engines. I've understood that Scid vs PC is written in another language (Tcl/tkl if I'm no mistaken), so I'll need to understand how to compile it.

If you happen to be able to give me a hand or some tips on how to do it, that would be much appreciated, helping me saving quite some time.

Thanks!!

Andrea.

PS: I'm still anyway also interested in accessing from the Fritz GUI some other UCI engines running on the RPi, as it would be a nice exercise to be done, and could be helpful to others. ChatGPT tells me it's not very hard to do, but I don't believe her! (I use ChatGPT with a female voice...).

[DJ Dekker]

Hi Andrea,

The Scid vs PC website provides instructions for compiling, see https://scidvspc.sourceforge.net/#toc4. It is not a complicated process.

The script will check for any dependencies like Tcl/Tk and install them as well.

Greetings,

DJ

Op zondag 10 augustus 2025 om 10:27:45 UTC+2 schreef andreag...@gmail.com:

[Andrea Gatti]

Hi DJ,

excellent news, thank you.

Kind regards,

Andrea