csslab / maia-chess

Maia is a human-like neural network chess engine trained on millions of human games.

Aligning Superhuman AI with Human Behavior: Chess as a Model System

website/paper/code/lichess

A collection of chess engines that play like humans, from ELO 1100 to 1900.

In this repo is our 9 final maia models saved as Leela Chess neural networks, and the code to create more and reproduce our results.

Our website has information about the project and team.

You can also play against three of of our models on Lichess:

• maia1 is targeting ELO 1100
• maia5 is targeting ELO 1500
• maia9 is targeting ELO 1900
• MaiaMystery is for testing new versions of Maia

We also have a Lichess team, maia-bots, that we will add more bots to.

How to Run Maia

The Maias are not a full chess framework chess engines, they are just brains (weights) and require a body to work. So you need to load them with lc0 and follow the instructions here. Then unlike most other engines you want to disable searching, a nodes limit of 1 is what we use. This looks like go nodes 1 in UCI. Note also, the models are also stronger than the rating they are trained on since they make the average move of a player at that rating.

The links to download the models directly are:

Models with Lichess Bots

Targeted Rating	lichess name	link
1100	maia1	maia-1100.pb.gz
1500	maia5	maia-1500.pb.gz
1900	maia9	maia-1900.pb.gz

The bots on Lichess use opening books that are still in development, since the models play the same move every time.

Other Models

Targeted Rating	link
1200	maia-1200.pb.gz
1300	maia-1300.pb.gz
1400	maia-1400.pb.gz
1600	maia-1600.pb.gz
1700	maia-1700.pb.gz
1800	maia-1800.pb.gz

We also have all the models in the maia_weights folder of the repo.

Example

When running the models on the command line it should look like this:

:~/maia-chess$ lc0 --weights=model_files/maia-1100.pb.gz
       _
|   _ | |
|_ |_ |_| v0.26.3 built Dec 18 2020
go nodes 1
Loading weights file from: model_files/maia-1100.pb.gz
Creating backend [cudnn-auto]...
Switching to [cudnn]...
...
info depth 1 seldepth 1 time 831 nodes 1 score cp 6 tbhits 0 pv e2e4
bestmove e2e4

move_prediction/maia_chess_backend also has the LeelaEngine class that uses the config files move_prediction/model_files/*/config.yaml to wrap python-chess and allow the models to be used in Python.

Datasets

As part of our analysis all the game on Lichess with stockfish analysis were processed into csv files. These can be found here

Code

Move Prediction

To create your own maia from a set of chess games in the PGN format:

1. Setup your environment
   1. (optional) Install the conda environment, maia_env.yml
   2. Make sure all the required packages are installed from requirements.txt
2. Convert the PGN into the training format
   1. Add the pgn-extract tool to your path
   2. Add the trainingdata-tool to your path
   3. Run move_prediction/pgn_to_trainingdata.sh PGN_FILE_PATH OUTPUT_PATH
   4. Wait a bit as the processing is both IO and CPU intense
   5. The script will create a training and validation set, if you wish to train on the whole set copy the files from OUTPUT_PATH/validation to OUTPUT_PATH/training
3. Edit move_prediction/maia_config.yml
   1. Add OUTPUT_PATH/training/*/* to input_train
   2. Add OUTPUT_PATH/validation/*/* to input_test
   3. (optional) If you have multiple GPUS change the gpu filed to the one you are using
   4. (optional) You can also change all the other training parameters here, like the number of layers
4. Run the training script move_prediction/train_maia.py PATH_TO_CONFIG
5. (optional) You can use tensorboard to watch the training progress, the logs are in runs/CONFIG_BASENAME/
6. Once complete the final model will be in models/CONFIG_BASENAME/ directory. It will be the one with the largest number

Replication

To train the models we present in the paper you need to download the raw files from Lichess then cut them into the training sets and process them into the training data format. This is a similar format to the general training instructions just with our specified data, so you will need to have trainingdata-tool and pgn-extract on your PATH.

Also note that running the scripts manually line by line might be necessary as they do not have any flow control logic. And that move_prediction/replication-move_training_set.py is where the main shuffling and games selection logic is.

1. Download the games from Lichess between January 2017 and November 2019 to data/lichess_raw
2. Run move_prediction/replication-generate_pgns.sh
3. Run move_prediction/replication-make_leela_files.sh
4. Edit move_prediction/maia_config.yml and add the elo you want to train:
   1. input_test : ../data/elo_ranges/${elo}/test
   2. output_train : ../data/elo_ranges/${elo}/train
5. Run the training script move_prediction/train_maia.py PATH_TO_CONFIG

We also include some other (but not all) config files that we tested. Although, we still recommend using the final config move_prediction/maia_config.yml.

If you wish to generate the testing set we used you can download the December 2019 data and run move_prediction/replication-make_testing_pgns.sh. The data is also avaible for download as a CSV here. The script for running models on the dataset is replication-run_model_on_csv.py and requires the lc0 binary on the path.

Blunder Prediction

To train the blunder prediction models follow these instructions:

1. Setup your environment
   1. (optional) Install the conda environment, maia_env.yml
2. Make sure all the required packages are installed from requirements.txt
3. Run blunder_prediction/make_csvs.sh
   1. You will probably need to update the paths, and may want to change the targets or use a for loop
4. Run blunder_prediction/mmap_csv.py on all the csv files
5. Select a config from blunder_prediction/configs and update the paths
6. Run `blunder_prediction/train_model.py CONFIG_PATH

Citation

@inproceedings{mcilroyyoung2020maia,
  title={Aligning Superhuman AI with Human Behavior: Chess as a Model System},
  author={McIlroy-Young, Reid and  Sen, Siddhartha and Kleinberg, Jon and Anderson, Ashton},
  year={2020},
  booktitle={Proceedings of the 25th ACM SIGKDD international conference on Knowledge discovery and data mining}
}

License

The software is available under the GPL License.

Contact

Please open an issue or email Reid McIlroy-Young to get in touch

maia-chess's Issues

Could this be used for cheat detection?

With all that cheating debate going on....

I am wondering if Maia or a Maia-like approach could be used to provide additional input to a cheat detection system?

After all, you reported in your papers that with Maia you get much higher human move predictions (depending on rating class) than with say stockfish.

Suppose we take not only the position & rating, but also extra-information such the remaining time of the player into account. Could a network be trained in such a way that the, say top3 move predictions amount to an (80%/90%/almost 100%) move prediction for a given position?

Given a game, this would then provide at least guidance to those positions where a human player (a potential cheater) played moves that the network classifies as "non-human".

Instead of a predictor one could of course also try to create a distiguisher network that given a position and a move tries to predict with a certain amount of probability if that was an engine or computer move...

There might be other creative ways... This might be complete nonsense and not work in practice, but given that you trained Maia and have a much better intuition on what a trained network is capable of, I would like to hear your opinion...

Attempt in recreating the accuracy test results of Maia's paper

I am working on a project which uses Maia's research and I need to recreate the results shown in the paper, thankfully you have provided the scripts necessary to do that, however I am encountering issues.

I looked at this post: #44

Which is where I am at and having trouble getting lc0 to cooperate with the execution of replication-run_model_on_csv.py, which leads to model_loader and looks for the lc0, I have changed the line to the following:
model = LC0Engine(lc0Path="D:\University\Project - Playing Chess with AI\Maia\lc0", noise=noise, temperature=temperature, temp_decay=temp_decay, **kwargs)
In order to get direct access to the lc0 file, but it either gives an access error or chess.engine.EngineTerminatedError: engine process died unexpectedly (exit code: 3221226505)

Currently using: lc0 v0.29.0 and python-chess 0.31.4

What are the requirements exactly in order to run this ? (Version of lc0 and python-chess ?)
I am running it using the anaconda environment I have set up with the requirements.txt and using administrator privileges etc.

Thank you in advance.

Missing dependencies: maia_chess_backend and haibrid_chess_utils

Hi There!

I wanted to replicate some of your work; but I noticed that many of the data generators require a library called haibrid_chess_utils or maia_chess_backend in past commits. I was wondering if you were open to share this as well to the community?

Questions about centipawn score/win probability estimation

Thanks for the great work and for the processed Lichess CSVs! I have a few questions about centipawn scores/win probabilities:

• Some of the centipawn values in the CSVs have the value None. What does this indicate?
• Why did you decide to predict empirical win probability, vs simply predicting the raw cp score?
• Is there a place I can retrieve the mapping from cp -> empirical win probability as reported in Fig 11 of the paper?
• Also curious if the task of predicting win probability as an auxiliary task improved move prediction performance versus just training on the move prediction task alone. Did you explore this?

Can you build a Korean chess engine?

rematch button for maia bots on lichess.org not working

The maia bots on lichess no longer accept rematches. A few months ago they would always accept a rematch after a game, but now they don't. I'm not sure the exact day this stopped working, but I think it was sometime in the past few months.

Maia 1100 fails to mate 1 king with 6 queens

Hi. Sorry for bringing up the quality of the moves again; this one seems like not a single fluke, but as as systematic deficiency: Maia 1100 fails to win a game with 6 queens vs. a king. The game is here (also attached). On move 66 Maia creates its sixth queen by promotion, and then for the next 47 moves it only shuffles its pieces around on the 1st rank, without even trying to attack the king. The game finally ends on move 113 by the 5-fold repetition as a draw.

It seems that in this case the net optimizes for moving the pieces to the 1st rank, rather than winning the game. Maybe aggressive king movement is the way to beat Maya? :)

(Note that in this game the first few moves Maia makes are actually from an opening book; I've extracted it from your fairly useful dataset).

Anyway, I understand that fixing behavior in such cases would require re-training the net (or at least training it some more), which I don't know if you want to do. Still, in a 6-queen end game, at least moving the queens to attack is something that players of any rating would do.

So I guess I'm looking for an advice here. I'm trying to use Maia as a beginner-friendly AI; is there anything that I can do to make it actually win in this example? Maybe use end-game tables of some sort? Do you do that for the lichess bots? Or supplement it with a different AI that would recognize obvious moves, and take over under some conditions? Any ideas? (I would of course prefer Maia to just work by itself).

Move time simulation

This is about the implementation of Maia in Lichess: Could Maia learn to take time before it moves? Ideally based on the complexity of the situation and the difficulty of finding the correct move.

Right now its moves are very human-like, but its move time is very frustrating to play against, and obviously unrealistic.

Human accuracy comparison to Good/Bad/Mean/Evil Gyal?

@dkappe has trained a number of nets on Lichess data, with some Stockfish mixed in to fill in gaps where the Lichess data tends to be sparse (e.g. endgames after a material imbalance, where human players in most games resign). Any chance you'd be able to do a "how human does it play?" comparison against his nets to see how they stack up against the Maia nets? I've been playing the Maia 1100 net, and it misses some very obvious moves that an 1100 human would make (e.g. Maia 1100 sometimes fails to take back during an exchange, leaving the game lost). I'm wondering if his mix of human and Stockfish data might create a "more human" player than human data alone. And since you've already got the code to make those comparisons between human play and engine play... ;-)

https://github.com/dkappe/leela-chess-weights/wiki/Mean-Girl:--the-most-fun-leela-style-net
https://github.com/dkappe/leela-chess-weights/wiki/Bad-Gyal

Background papers

I may have dreamed, but it seems that there have been many versions of papers about this project.
I am particularly interested in the version or papers (one I seem to recall looking at, or was it on a website), about figure 11 type of plots from the only paper now mentioned on the readme of this site.

I was impressed by all the preliminary work characterizing lichess data, and using non-deep machine learning or other statistical approach to get a complete set of angles about the data. I thought it looked solid, and was equally valuable to me as the properties of the maïa engines.

I hope new paper versions have not trimmed such reporting of background work. It is also giving confidence about the quality of the lichess data.

In particular, I thought there were additional figures of the type that figure 11 shows. but with more detail about the spread of the data points. Also i am looking for online versions of such figures I could refer to and embed, say here for example or on lichess.

Make the bots resign

Add some way for models to resign, maybe train a head?

Maia not going instantly anymore on lichess

Maia not going instantly anymore on lichess after typing ‚go‘ or ‚fast‘

How much disk-space for training

Assuming I download the 12 data files and unzip them and then run the code that turns them into training files, how much disk space will I need?
I wonder if it would be possible for you to publish some sort of directory structure on your site so that I can know how much I will need depending on what kind of training I do?
What if I only used one month of data, for example. Or only trained a 1100 model.

use history of game to make more human move

Hi,

If i understand all is calculated on one position. Maybe the human behaviour can be better if history of moves can be take into account. At least the move number can help.

Repeated "how humanly did I play" question during game on Lichess

In the middle of a recent game against maia1 on lichess the bot began to repeatedly say

gg! On a scale from 1 to 5 how humanly did I play? 1 = not human, 5 = very human

Replication on Windows

Hello everyone.

Firstly, congratulations on the Maia Chess project. I've been watching Maia Chess run on Lichess and it's very impressive.

From what it looks like, you've only run the code on Linux, but I'm on a Windows machine. Anyone successfully trained Maia Chess on a Windows machine?

I do have some experience in training Leela Chess Zero on Windows, as I trained my own version of Leela Chess Zero a while ago, so there's a part of me that the process between the two might be similar.

Kind regards,

CallOn84

How to use it in UCI mode

Hi,

What do you mean with:

When using the model in UCI mode add nodes 1 when querying as that disables the search.

I only see these parameters for UCI LC0:

       _
|   _ | |
|_ |_ |_| v0.26.3 built Oct 10 2020
Detected 6 core(s) and 6 thread(s) in 1 group(s).
Group 0 has 6 core(s) and 6 thread(s).
uci
id name Lc0 v0.26.3
id author The LCZero Authors.
option name WeightsFile type string default <autodiscover>
option name Backend type combo default cuda-auto var cuda-auto var cuda var cuda-fp16 var random var check var recordreplay var roundrobin var multiplexing var demux
option name BackendOptions type string default
option name Threads type spin default 2 min 1 max 128
option name NNCacheSize type spin default 200000 min 0 max 999999999
option name MinibatchSize type spin default 256 min 1 max 1024
option name MaxPrefetch type spin default 32 min 0 max 1024
option name CPuct type string default 2.147000
option name CPuctAtRoot type string default 2.147000
option name CPuctBase type string default 18368.000000
option name CPuctBaseAtRoot type string default 18368.000000
option name CPuctFactor type string default 2.815000
option name CPuctFactorAtRoot type string default 2.815000
option name TwoFoldDraws type check default true
option name VerboseMoveStats type check default false
option name FpuStrategy type combo default reduction var reduction var absolute
option name FpuValue type string default 0.443000
option name FpuStrategyAtRoot type combo default same var reduction var absolute var same
option name FpuValueAtRoot type string default 1.000000
option name CacheHistoryLength type spin default 0 min 0 max 7
option name PolicyTemperature type string default 1.607000
option name MaxCollisionEvents type spin default 32 min 1 max 65536
option name MaxCollisionVisits type spin default 9999 min 1 max 1000000
option name OutOfOrderEval type check default true
option name MaxOutOfOrderEvalsFactor type string default 1.000000
option name StickyEndgames type check default true
option name SyzygyFastPlay type check default true
option name MultiPV type spin default 1 min 1 max 500
option name PerPVCounters type check default false
option name ScoreType type combo default centipawn var centipawn var centipawn_with_drawscore var centipawn_2019 var centipawn_2018 var win_percentage var Q var W-L
option name HistoryFill type combo default fen_only var no var fen_only var always
option name MovesLeftMaxEffect type string default 0.100000
option name MovesLeftThreshold type string default 1.000000
option name MovesLeftSlope type string default 0.005000
option name MovesLeftConstantFactor type string default 0.000000
option name MovesLeftScaledFactor type string default 0.000000
option name MovesLeftQuadraticFactor type string default 1.000000
option name MaxConcurrentSearchers type spin default 1 min 0 max 128
option name DrawScoreSideToMove type spin default 0 min -100 max 100
option name DrawScoreOpponent type spin default 0 min -100 max 100
option name DrawScoreWhite type spin default 0 min -100 max 100
option name DrawScoreBlack type spin default 0 min -100 max 100
option name NodesPerSecondLimit type string default 0.000000
option name SolidTreeThreshold type spin default 100 min 1 max 2000000000
option name SyzygyPath type string default
option name Ponder type check default true
option name UCI_Chess960 type check default false
option name UCI_ShowWDL type check default false
option name UCI_ShowMovesLeft type check default false
option name ConfigFile type string default lc0.config
option name SmartPruningFactor type string default 1.330000
option name SmartPruningMinimumBatches type spin default 0 min 0 max 10000
option name RamLimitMb type spin default 0 min 0 max 100000000
option name MoveOverheadMs type spin default 200 min 0 max 100000000
option name TimeManager type string default legacy
option name LogFile type string default
uciok

The nearest one is NodesPerSecondLimit

Thank you
C.

Parsing Issues

Hi,

I have a huge interest in completing this project: https://usra.cs.toronto.edu/public/project/320?sort_by=0&opportunity_id=1 for my CSC494 term. However I was dismayed to find out that the project is in an "archived state" (as per #32 (comment)). Is this project really not being worked on anymore?

Thank you,
Ibrahim

Unclear instructions/ no instructions for Android

I just can't figure out how to install the bot on Android.
I think i need to change network of lc0 to maia-1900, i just don't know how

Decline challenge API

https://lichess.org/api#operation/challengeDecline

There's a new field in the API, to give a reason why it was declined. Would be lovely if Maia would take advantage of it, since, in particular, there are a few who tries to challenge the bot's to unlimited time control challenges.

maia disconnects sometimes

Variability in prediction in the same position

Do the Maia predictions have some randomness involved? For some positions, it appears the predicted move is not always the same. For example, in the position 5k2/5pp1/7p/2p5/5PPP/1p5R/2P1K3/1r6 w - - 0 33, either isolated or using the move history (1. e4 e5 2. Nf3 Nc6 3. Nc3 Nf6 4. d4 d6 5. Be3 Be7 6. dxe5 dxe5 7. Nxe5 Nxe5 8. f4 Nc6 9. Qe2 O-O 10. Qc4 Be6 11. Qe2 Nd4 12. Qd2 c5 13. e5 Ng4 14. O-O-O Nxe3 15. Qxe3 Qc7 16. Ne4 h6 17. b3 Rfd8 18. h4 a5 19. g3 b5 20. Bh3 Bxh3 21. Rxh3 Nxb3+ 22. Kb2 Rxd1 23. Kxb3 Rb1+ 24. Kc3 b4+ 25. Kd2 a4 26. Nd6 Bxd6 27. exd6 Qxd6+ 28. Ke2 Re8 29. Qxe8+ Qf8 30. Qxf8+ Kxf8 31. g4 b3 32. axb3 axb3), most times the predicted move would be h3b3 but also often it would be c2b3 and rarely h3c3. I am noticing this variability with all ELO networks, using lc0 27.0, in python-chess 1.6.1, macOS 11.4, in a Jupyter notebook. The variability appears larger when I re-start the kernel and run all again, but also happens if I re-run the same cell many times.

make go fast persistent?

I'm enjoying playing Maia1. Nice work! would it be possible to make the option to go fast stay persistent? Meaning against any particular user the state remains the same for every game until changed. I change it at the start of every game. I have chat disabled and play in zen mode. So it takes a number of steps to go fast. Thanks!

is possible to tell maia to play a specific gambit to train?

hi,
i really want to use maia to train me to know a specific gambit, is possible to do so? In this case how to do that?

Are the replication-scripts.sh temporarily out of order?

I have managed to get replication-generate_pgns.sh working but replication-make_leela_files.sh is referencing all sorts of paths that don’t seem to exist (eg /datadrive/pgns_ranged). And when I run it, it has been re-arranging the code files in maia-chess s directory.

I notice in some of the issue posts that there is an update coming, but for the time being should I be expecting these scripts not to work?

Slow play even with "fast" and one legal move

I'm having an issue with Maia1 playing slow even in situations that should be fast. It took Maia several minutes to make the only legal move in this position even after typing "fast" in chat and getting the "I'll play instantly" reply. I'm not sure what to do with this and if there is anything I can do to make Maia1 play any faster. Thank you for your help.

How to use with python-chess

So there are practically no instructions except one line telling you can use it with python-chess but I am not entirely sure how to do so. furthermore, it says AttributeError: module 'chess' has no attribute 'uci' when importing chess.uci.

Can you please explain how I can use maia in python-chess library and make it give the moves it wants to play from a python-chess board?

Thanks

Move time simulation in python chess

How do I use move time simulation in python chess? When I use the play method, the engine almost instantly returns a move.

is it possible to train on self-play?

Is it possible? It plays with itself and learn on it, if yes, please help, maybe you have code snipped/repository?

What opening books and tablebases would you suggest?

I have a GUI that supports tablebases and opening books and I am searching all around internet where to get them. But I am rather new in this and I don't know what I should look for.

What opening books and rablebases would suite maia best if I want as many wins as possible for maia?

Maia taking exceedingly long time on a move

I've played a few games recently against maia5

https://lichess.org/B4v64i5A -- it took 11 minutes to think on move 18 in a 10 minute (with increment) game. It almost timed out, but it did come back
https://lichess.org/zs9em2eO -- took 10 minutes on last move and timed out; again, 10 minute + increment game.

While first I guess could be vaguely attributed to time management (but still suspicious), there is certainly something outright wrong with second one. In both cases while waiting, I did check currently played other games by maia5, and it was making moves in timely manner, so it wasn't something to do with server going down or such. The issue doesn't seem to be necessarily related to position; challenging the bot from same position again worked fine

Hello, I am trying to implement maia-chess to my game:

I am developing an educative game about chess and my idea was to present characters that play more human-like. I am using Ren'py on MAC but I am unsure how to go about implementing maia-chess to the game, any suggestions on how to go about this in a smart way?

Thank you!

make stand alone distribution

it is not clear how to make this work offline...(you need to add more details or instructions on (How to Run Maia) section)
I think it is better to make standalone installation or distribution so we just download and start using...

How can I train a model personalized to a particular player?

Is there a script that would do pretty much the same as train_maia.py, but starting with a given set of weights?

This achieves the highest move-matching accuracy in the paper but I didn't find it mentioned in the readme.

Broken data link in README

Hi,

Thanks for your nice paper on MAIA. I was looking for the data you use but the link in your README is broken. Is the data available?

Thanks,
John.

Train for maia:2000 maia:2100 maia:2200

It would be interesting to have other more powerful versions having the same human-like style.

Lichess bots abandoning games

Hey! Not sure if this is the best place to report issues with your lichess bots. I've found that they have a tendency to abandon games. My guess is that you're hitting lichess API rate limits, as your bots seem to be getting quite popular -- so just wanted to flag that in case you weren't aware.

Unless of course that's expected behavior, the 1500 bot did tend to abandon once advantage went 0.5 to me -- which accurately reflects my experience with human 1500s on lichess. In that case, disregard this issue and congrats on passing the chess turing test :P

how to use the model

hello! I would like to know how to use the model(the.pb file) in your project. The step i should do is load the model in the program, pass parameters to the model about the current board and get the best move. Do i need to clone all the project to local, or I only need to use a piece of code? Looking forward to your early reply!(only used in education project)

Feature: ask maia to play a certain opening

before the game starts, perhaps maia could accept a parameter with the desired opening it should attempt. things to consider:

• what if maia is black and white goes off script (i ask maia to play italian game (both start with e4-e5) but then white switches it to king's gambit
• perhaps game should start with a predefined position (for king's gambit, e4, e5, f5), and game starts with black to move

this would do wonders for those of us learning openings and trying to navigate the lines

Can I use maia

Can I use maia to create my own bot? Do I have the permission?

Maia for Slow chess games

Hi folks, I recently found out about this project and it is amazing.

However, one thing stops me from playing against Maia on Lichess - I play slow games, 45|45 or 90|30. Maia currently doesn't play like a slow chess player, it "thinks" for 30 seconds to a minute per move which is not something that slow chess player would do. Often times it ends up with more time on the clock than it started with.

The problem with this is that it changes the game, it changes the thinking from my part - I've also consulted with people from my chess club and they all agree. You spend couple of minutes, perhaps 10 minute for the most important moves, and it is not normal behavior that you have to stress your brain on that level once again in 30 seconds.

Do you have plans to focus on time management in future releases?

How to use blunder prediction for given position/fen + next move

Hello there,

I am trying to use blunder prediction for my hobby project I plan to work on - what I need is to predict blunder probability for given move at given position - how do I do it ?

P.S. I would rather avoid training my own blunder prediction model

Does the version of Lc0 matter?

From the code it appears you used Leela version 0.23 when doing the experiments reported on the paper. If a newer version of Leela is used, could this change the moves predicted by the Maia networks?

A blunder with Maia 1500 and 1700

Hi. So I have encountered a position where Maia 1500 and 1700 both give up a queen, while the rest (including 1100) do not. Is this sort of a thing considered a bug?

The position is this:

1r4k1/3b2pp/4p3/Qpq1Pp2/2p2P2/2P1PB2/6PP/4R1K1 b - - 2 26

(I also have the full game, if you need that).

You can see the position on lichess. Maia 1500 and 1700 both go b5b4, the rest go d7c6. To be honest, I would be surprised to see any player at all -- much less someone of rating 1700 -- to play b4 here.

https://github.com/CSSLab/maia-chess.git

https://github.com/CSSLab/maia-chess.git

Is it possible?

I am not being able to understand readme. Too complex
Can it be explained in a simpler way

Inspired!

Hello good day. I'm a beginner in programming in Brazil, and I got access to the code and I was amazed. I would like to know what your next steps are? Create the Mayan 2000 rating? And is it possible to get an exe from the engine? I await response, I'll be watching!

Why is it necessary to limit the nodes to 1?

Accuracy Elaboration

Hi guys,

Can you elaborate on how you received Maia's accuracy numbers? or show me where is the script that calculates that?
What are the steps for reproducing the same results on my computer?

Thanks!

Maia1 doesn't accept challenges

Hi,

Noticing that maia1 does not accept Lichess challenges. Is there an issue with the Bot or only a specific game configuration that it accepts games for?

Thanks,
Marius