Progress On Bricabrac

[lithander]

It appears but might not be true that MCE Chile may been heavily influenced by PeSTO. Maybe Thomas will clarify that.

I used the same dataset of quiet positions (from Zurichess) that was used for training Pesto. But the resulting PSTs look quite different and the engines seem to play different. However as I was previously using PeSTO and my goal was to find tables that could beat the previous version the results are probably especially good against PeSTO. Selection bias, so to speak.

I tried compiling and playing Bric. But I can't reproduce your very good results of the Zygote version beating MinimalChess 0.4.1 (which is the last publicly released version). Both the PeSTO and the PeSTOZygote version do rather poorly in my tests, lose on time, play illegal moves and in short: experience problems.

Code: Select all

Score of MinimalChess 0.4.1 vs BricPESTO: 507 - 13 - 16  [0.961] 536
Score of MinimalChess 0.4.1 vs BricPESTOzygote: 172 - 11 - 8  [0.921] 191

I downloaded the zip from mediafire, compiled the CPP in Visual Studio as you said, one with the zygote define and one without. x64 and Release.

The tournament settings are as follows:

Code: Select all

./cutechess-cli.exe -engine conf="MinimalChess 0.4.1" -engine conf="BricPESTO" -each tc=5+0.5 book=varied.bin -pgnout mmc041_vs_bricPesto.pgn -rounds 1000 -games 2 -repeat -concurrency 5

Here are the PGNs and my compiled binaries: https://www.dropbox.com/s/8fxrjdac9b7bh ... C.zip?dl=0

Let me know what I did wrong!

Edit: I'm now using the Exe from the media-fire link. It does play properly except that it sometimes loses on time. So that must mean my compile didn't work. Can you provide a compiled version of the "zygote" version, too? The zip included only the normal Pesto version, I think.

Edit2: Okay, it's even stranger than that. The illegal moves started to happen again after playing ~50 games. But it wasn't limited to my own compile. Also the Exe you provided shows the same behavior. I'm pretty sure Cute Chess isn't restarting the engines and just uses one instance per thread for all 2000 games. It seems that Bric has some kind of issue that only surfaces after using it to play more than 50 games. Weird.

[Mike Sherwin]

It appears but might not be true that MCE Chile may been heavily influenced by PeSTO. Maybe Thomas will clarify that.

I used the same dataset of quiet positions (from Zurichess) that was used for training Pesto. But the resulting PSTs look quite different and the engines seem to play different. However as I was previously using PeSTO and my goal was to find tables that could beat the previous version the results are probably especially good against PeSTO. Selection bias, so to speak.

I tried compiling and playing Bric. But I can't reproduce your very good results of the Zygote version beating MinimalChess 0.4.1 (which is the last publicly released version). Both the PeSTO and the PeSTOZygote version do rather poorly in my tests, lose on time, play illegal moves and in short: experience problems.

Code: Select all

Score of MinimalChess 0.4.1 vs BricPESTO: 507 - 13 - 16  [0.961] 536
Score of MinimalChess 0.4.1 vs BricPESTOzygote: 172 - 11 - 8  [0.921] 191

I downloaded the zip from mediafire, compiled the CPP in Visual Studio as you said, one with the zygote define and one without. x64 and Release.

The tournament settings are as follows:

Code: Select all

./cutechess-cli.exe -engine conf="MinimalChess 0.4.1" -engine conf="BricPESTO" -each tc=5+0.5 book=varied.bin -pgnout mmc041_vs_bricPesto.pgn -rounds 1000 -games 2 -repeat -concurrency 5

Here are the PGNs and my compiled binaries: https://www.dropbox.com/s/8fxrjdac9b7bh ... C.zip?dl=0

Let me know what I did wrong!

Edit: I'm now using the Exe from the media-fire link. It does play properly except that it sometimes loses on time. So that must mean my compile didn't work. Can you provide a compiled version of the "zygote" version, too? The zip included only the normal Pesto version, I think.

Ah, sorry I forgot to mention that in MSVS 2019 I had to turn off Whole Program Optimization to get a stable exe. Try that and in the meantime I'll prepare a new upload. I only use Arena 3.51 and in over 4000 games now at 5 sec and 0.5 sec inc it has not lost on time. I'll have to download cutechess.

[Guenther]

...
I only use Arena 3.51 and in over 4000 games now at 5 sec and 0.5 sec inc it has not lost on time. I'll have to download cutechess.

That's a grave error when developing a new chess program for several reasons.

[lithander]

Ah, sorry I forgot to mention that in MSVS 2019 I had to turn off Whole Program Optimization to get a stable exe. Try that and in the meantime I'll prepare a new upload.

As I added it my 2nd edit of the above post the weird behaviour also happened with the compiled executable that you supplied. I guess the best course of action would be for you to try and reproduce my test settings (I hope I included all relevant information?) and experience the errors for yourself, hopefully providing you with a chance to find a fix.

But when you have new builds I'll test them of course.

[Mike Sherwin]

Ah, sorry I forgot to mention that in MSVS 2019 I had to turn off Whole Program Optimization to get a stable exe. Try that and in the meantime I'll prepare a new upload.

As I added it my 2nd edit of the above post the weird behaviour also happened with the compiled executable that you supplied. I guess the best course of action would be for you to try and reproduce my test settings (I hope I included all relevant information?) and experience the errors for yourself, hopefully providing you with a chance to find a fix.

But when you have new builds I'll test them of course.

Last Friday I got the first Moderna vaccine injection. By Saturday and especially Sunday I was fighting off extreme tiredness with lots of caffeine. No flu like symptoms though. I've been sleeping most of the last 15 hours. This morning the last couple of days are mostly gone and I do not remember much. It will take me some time to get back on track.

[Mike Sherwin]

I downloaded the source to make sure that I was working from the same source. Now it does not go lower than 2 seconds. Also I made sure Whole Program Optimization was turned off. Started the gauntlets. Let's see what happens.

[Mike Sherwin]

I am now of the opinion that Zygote's learning at extremely fast time controls like 5s + 500ms is nothing but noise. So a 30sec per move gauntlet is now underway to test that notion.

BricPESTO1 - MinimalChessEngine : 36.0/100 23-51-26 (101000=10=0=00011110000000=110001110=000100000=1000=0000==1=0111101====0=0=====001000=0001==001===00) 36% -100
BricPESTO1 - Rustic-alpha-2_64-bit-popcnt : 45.0/100 36-46-18 (100010==0111000000==001101111110=1110=0=110011=100=000=001=0011011=0001010=000==010=1010100001011==1) 45% -35
BricPESTO1 - Tscp181 : 59.0/100 49-31-20 (101=011=10011000=011=0001=01=110=111=1111100011101011==110=1==111001100100==0==111100011=01=110111=1) 59% +63

1939 - 100 = 1839
1815 - 35 = 1780
1724 + 63 = 1885
performance = 1834

BricPESTOz1 - MinimalChessEngine : 26.5/100 19-66-15 (001001=00=10=00000100000000110010=0000010000=0101=0001=0000===10=01000000=000001=01000110000=1000=01) 27% -173
BricPESTOz1 - Rustic-alpha-2_64-bit-popcnt : 48.5/100 41-44-15 (101001=001=110=000=11110111=001000011=0100001011111010=010100010100100001==0=0110==111=010=11010101=) 49% -7
BricPESTOz1 - Tscp181 : 64.0/100 57-29-14 (1111010=11101==1=100100000110011=011=1110==111110111011101111=000100=11011=0=1100111=11110110111110=) 64% +100

1939 - 173 = 1766
1815 - 7 = 1808
1724 + 100 = 1824
performance = 1799

https://www.mediafire.com/file/kn5wug3d ... 1.zip/file

Whether I did everything right this time or not I have to be done with PeSTO. Thanks!

[Mike Sherwin]

I have been undecided upon how to fashion the evaluation. I did not want to merely repeat what was done in RomiChess. I wanted to underpin it with a concept that did not rely on arbitrary rules of thumb like bonusing a knight just because it is in the center. I wanted something that the rest of the eval could be crafted around to support and strengthen the foundational concept. For example I don't want to write pawn push code just for the sake of pushing pawns. I really do not have the words to convey my thinking but I think that the following code and sample game might make it more clear.

I remembered something that David Bronstein once wrote in one of his books. Paraphrased, 'The key to making strong moves is to not put pieces on squares in which they can be advantageously attacked in one turn'. In the following code only second move mobility is counted for non attacked squares. If the first move's to-square is attacked the second move mobility from that square is not counted. Once there is a SEE function I will modify that to use the SEE function. The code is just the basic idea and nothing more. It is the foundation that I want to build upon.

Code: Select all

void InitSearch(Thread* t) {
  u64 bb, cc, b, a, pieces, allPieces;
  u32 sq;
  s32 i, col, cenCol, row, cenRow;
  SplitBB blocks;

  allPieces = piece[WHITE] | piece[BLACK];

  for (i = A1; i <= H8; i++) {
    col = i & 7;
    row = i >> 3;
    cenCol = col < 4 ? col : 7 - col;
    cenRow = row < 4 ? row : 7 - row;

    // white pawns
    wpPST[i] = 0;
    
    // black pawns
    bpPST[i] = 0;

    // white knights
    wnPST[i] = 0;
    bb = knightMoves[i] & ~piece[WHITE];
    while (bb) {
      _BitScanForward64(&sq, bb);
      bb ^= one << sq;
      if (!AtkByBlack(t, one << sq)) {
        cc = knightMoves[sq] & ~piece[WHITE];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          wnPST[i] += (1 - AtkByBlack(t, one << sq));
        }
      }
    }

    // black knights
    bnPST[i] = 0;
    bb = knightMoves[i] & ~piece[BLACK];
    while (bb) {
      _BitScanForward64(&sq, bb);
      bb ^= one << sq;
      if (!AtkByWhite(t, one << sq)) {
        cc = knightMoves[sq] & ~piece[BLACK];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          bnPST[i] += (1 - AtkByWhite(t, one << sq));
        }
      }
    }

    // bishops
    blocks.bb = allPieces & b7e[i];
    blocks.bb = ((blocks.l32 >> 8) | blocks.h32);
    bb = bss[i][blocks.r1][0]
       & bss[i][blocks.r2][1]
       & bss[i][blocks.r3][2];

    // white bishops
    wbPST[i] = 0;
    b = bb & ~piece[WHITE];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByBlack(t, one << sq)) {
        blocks.bb = allPieces & b7e[sq];
        blocks.bb = ((blocks.l32 >> 8) | blocks.h32);
        cc = bss[sq][blocks.r1][0]
           & bss[sq][blocks.r2][1]
           & bss[sq][blocks.r3][2]
           & ~piece[WHITE];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          wbPST[i] += (1 - AtkByBlack(t, one << sq));
        }
      }
    }

    // black bishops
    bbPST[i] = 0;
    b = bb & ~piece[BLACK];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByWhite(t, one << sq)) {
        blocks.bb = allPieces & b7e[sq];
        blocks.bb = ((blocks.l32 >> 8) | blocks.h32);
        cc = bss[sq][blocks.r1][0]
           & bss[sq][blocks.r2][1]
           & bss[sq][blocks.r3][2]
           & ~piece[BLACK];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          bbPST[i] += (1 - AtkByWhite(t, one << sq));
        }
      }
    }

    // rooks
    blocks.bb = allPieces & rob[i];
    bb = qss[i][(blocks.bb >> (i & 56)) & 127][0]
       & qss[i][blocks.r2][1]
       & qss[i][blocks.r3][2]
       & qss[i][blocks.r4][3]
       & qss[i][blocks.r5][4]
       & qss[i][blocks.r6][5]
       & qss[i][blocks.r7][6]
       & rob[i];

    // white rooks
    wrPST[i] = 0;
    b = bb & ~piece[WHITE];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByBlack(t, one << sq)) {
        blocks.bb = allPieces & rob[sq];
        cc = qss[sq][(blocks.bb >> (i & 56)) & 127][0]
          & qss[sq][blocks.r2][1]
          & qss[sq][blocks.r3][2]
          & qss[sq][blocks.r4][3]
          & qss[sq][blocks.r5][4]
          & qss[sq][blocks.r6][5]
          & qss[sq][blocks.r7][6]
          & rob[sq]
          & ~piece[WHITE];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          wrPST[i] += (1 - AtkByBlack(t, one << sq));
        }
      }
    }

    // black rooks
    brPST[i] = 0;
    b = bb & ~piece[BLACK];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByWhite(t, one << sq)) {
        blocks.bb = allPieces & rob[sq];
        cc = qss[sq][(blocks.bb >> (i & 56)) & 127][0]
          & qss[sq][blocks.r2][1]
          & qss[sq][blocks.r3][2]
          & qss[sq][blocks.r4][3]
          & qss[sq][blocks.r5][4]
          & qss[sq][blocks.r6][5]
          & qss[sq][blocks.r7][6]
          & rob[sq]
          & ~piece[BLACK];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          brPST[i] += (1 - AtkByWhite(t, one << sq));
        }
      }
    }

    // queens
    blocks.bb = allPieces & rob[i];
    bb = qss[i][(blocks.bb >> (i & 56)) & 127][0]
      & qss[i][blocks.r2][1]
      & qss[i][blocks.r3][2]
      & qss[i][blocks.r4][3]
      & qss[i][blocks.r5][4]
      & qss[i][blocks.r6][5]
      & qss[i][blocks.r7][6];

    // white queens
    wqPST[i] = 0;
    b = bb & ~piece[WHITE];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByBlack(t, one << sq)) {
        blocks.bb = allPieces & (rob[sq] | bob[sq]);
        cc = qss[sq][(blocks.bb >> (i & 56)) & 127][0]
          & qss[sq][blocks.r2][1]
          & qss[sq][blocks.r3][2]
          & qss[sq][blocks.r4][3]
          & qss[sq][blocks.r5][4]
          & qss[sq][blocks.r6][5]
          & qss[sq][blocks.r7][6]
          & ~piece[WHITE];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          wqPST[i] += (1 - AtkByBlack(t, one << sq));
        }
      }
    }

    // black queens
    bqPST[i] = 0;
    b = bb & ~piece[BLACK];
    while (b) {
      _BitScanForward64(&sq, b);
      b ^= one << sq;
      if (!AtkByWhite(t, one << sq)) {
        blocks.bb = allPieces & (rob[sq] | bob[sq]);
        cc = qss[sq][(blocks.bb >> (i & 56)) & 127][0]
          & qss[sq][blocks.r2][1]
          & qss[sq][blocks.r3][2]
          & qss[sq][blocks.r4][3]
          & qss[sq][blocks.r5][4]
          & qss[sq][blocks.r6][5]
          & qss[sq][blocks.r7][6]
          & ~piece[BLACK];
        while (cc) {
          _BitScanForward64(&sq, cc);
          cc ^= one << sq;
          bqPST[i] += (1 - AtkByWhite(t, one << sq));
        }
      }
    }

    // white king
    wkPST[i] = ((2000 - mat[BLACK]) / 200) * cenCol * cenRow;

    // black king
    bkPST[i] = ((2000 - mat[WHITE]) / 200) * cenCol * cenRow;
  }

  pos[WHITE] = 0;
  pos[BLACK] = 0;
  mat[WHITE] = 0;
  mat[BLACK] = 0;

  pieces = piece[WHITE];
  while (pieces) {
    _BitScanForward64(&sq, pieces);
    pieces ^= one << sq;
    mat[WHITE] += value[board[sq]];
    pos[WHITE] += pcePST[board[sq]][sq];
  }

  pieces = piece[BLACK];
  while (pieces) {
    _BitScanForward64(&sq, pieces);
    pieces ^= one << sq;
    mat[BLACK] += value[board[sq]];
    pos[BLACK] += pcePST[board[sq]][sq];
  }
}

[pgn][Event "Computer chess game"]
[Site "DESKTOP-HFVHK2B"]
[Date "2021.05.13"]
[Round "?"]
[White "Bricabrac"]
[Black "Bricabrac"]
[Result "1/2-1/2"]
[BlackElo "2000"]
[ECO "A00"]
[Opening "Van Kruij's Opening"]
[Time "13:02:35"]
[WhiteElo "2000"]
[TimeControl "0+30"]
[Termination "normal"]
[PlyCount "153"]
[WhiteType "program"]
[BlackType "program"]

1. e3 {(e2e3 d7d5 d1f3 d8d6 f1e2 c8d7 b1c3 g8f6) 0.00/8 29} d5 {(d7d5 d1h5
d8d6 b1c3 g8f6 h5g5 h7h6 f1b5) -0.74/8 29} 2. c4 {(c2c4 d8d6 c4d5 d6d5 d1a4
b8d7 a4c4 d5c6) -0.03/8 29} e6 {(e7e6 d1a4 c7c6 c4d5 e6d5 e3e4 d8d6 e4d5)
+0.29/8 29} 3. b3 {(b2b3 g8e7 c1b2 a7a5 b1c3 d5c4 f1c4 a8a7) -0.25/8 29} a6
{(a7a6 c1b2 a8a7 f1e2 g8e7 b1c3 d5c4 b3c4) +0.27/8 29} 4. Bb2 {(c1b2 g8e7
f1e2 d5c4 b3c4 h7h6 b1c3 h8h7) -0.29/8 29} dxc4 {(d5c4 f1c4 g8e7 b1c3 h7h6
c3e2 h8h7) +0.07/7 29} 5. bxc4 {(b3c4 d8g5 f2f4 g5f5 b2e5 e8d8 f1e2)
-0.30/7 29} a5 {(a6a5 b1c3 c8d7 a1c1 a8a6 c4c5 a6c6 c3e2) +0.09/8 29} 6. d4
{(d2d4 g8e7 c4c5 c8d7 b1c3 d7c6 g1e2) -0.09/7 29} b6 {(b7b6 g1e2 a8a6 b1c3
f8e7 a1c1 c8b7 c1c2) -0.15/8 29} 7. Nc3 {(b1c3 c8b7 a1c1 h7h5 g1e2 h8h6
c1c2 f8e7) +0.23/8 29} Bb7 {(c8b7 h2h3 f8d6 a1c1 e8f8 g1e2 d6e7) -0.24/7
29} 8. h3 {(h2h3 g8e7 h1h2 b8c6 g1e2 f7f5 a1c1) +0.04/7 29} Ne7 {(g8e7 g1e2
h7h5 e2f4 h5h4 c3e2 h8h6) +0.05/7 29} 9. Rb1 {(a1b1 c7c5 b2c1 c5d4 e3d4
b8c6 c1e3) +0.30/7 29} Nf5 {(e7f5 g1e2 f8e7 b1c1 f5d6 c4c5 d6f5) -0.15/7
29} 10. Nf3 {(g1f3 f8e7 b1c1 b8c6 c3e2 e8g8 c1c2) -0.10/7 29} Nc6 {(b8c6
c3e2 f5e7 b1c1 h7h5 c1c3 h8h6) +0.01/7 29} 11. Bc1 {(b2c1 h7h5 b1b2 h8h7
c3e2 f5e7 a2a3) +0.07/7 29} h5 {(h7h5 d1b3 h8h6 b1b2 h5h4 b3c2 f5e7)
-0.15/7 29} 12. a3 {(a2a3 f7f6 d1c2 f5e7 b1b2 e6e5 d4e5) +0.14/7 29} f6
{(f7f6 d1c2 g7g6 f1d3 h8h6 d4d5 e6d5) -0.25/7 29} 13. Qa4 {(d1a4 f8b4 a4c2
b4c3 c2c3 e8f8 c3c2) +0.35/7 29} Bb4 {(f8b4 a3b4 a5b4 a4c2 b4c3 d4d5 c6e7)
-0.43/7 29} 14. axb4 {(a3b4 a5b4 a4c2 b4c3 d4d5 c6e7 d5e6) +0.31/7 29} axb4
{(a5b4 a4c2 b4c3 d4d5 c6e7 d5e6 d8d6) -0.35/7 29} 15. Qc2 {(a4c2 b4c3 c2c3
a8a2 c1b2 d8e7 c3c2) +0.34/7 29} bxc3 {(b4c3 d4d5 c6e7 d5e6 d8d6 b1b3 d6e6)
+0.09/7 29} 16. Ng1 {(f3g1 d8e7 c2c3 a8a2 c4c5 e7d8 g1e2) -0.10/7 29} Na5
{(c6a5 c2c3 f5d6 c4c5 b6c5 d4c5 d6f5) +0.16/7 30} 17. Qxc3 {(c2c3 g7g5 g1e2
d8e7 c4c5 b6c5 d4c5) -0.03/7 29} Qe7 {(d8e7 b1b2 g7g6 c3c2 e7g7 c4c5 b6c5)
-0.21/7 29} 18. Qc2 {(c3c2 f5d6 f2f3 b7a6 c4c5 a6f1 e1f1) +0.10/7 29} Kd8
{(e8d8 g1e2 e7e8 c4c5 b6c5 c1d2 f5d6) -0.02/7 29} 19. Ne2 {(g1e2 g7g5 c4c5
b6c5 d4c5 b7c6 c1b2) +0.05/7 29} Nh4 {(f5h4 h1g1 b7c6 c1d2 h4f5 d2b4 f5d6)
+0.07/7 29} 20. Rg1 {(h1g1 b7c6 e3e4 f6f5 f2f3 f5e4 f3e4) +0.06/7 29} Bc6
{(b7c6 e3e4 a5b7 e2c3 b7d6 c1b2 h4g6) -0.04/7 30} 21. c5 {(c4c5 b6c5 d4c5
h4f5 b1a1 d8c8 a1a3) 0.00/7 29} bxc5 {(b6c5 d4c5 d8e8 c2c3 e7d8 b1a1 a5b7)
-0.19/7 29} 22. dxc5 {(d4c5 a5b7 b1b4 h4f5 e3e4 f5h6 b4d4) +0.13/7 29} Nb7
{(a5b7 c2c4 a8a4 c4c3 d8c8 g2g3 h4f3) -0.43/7 29} 23. Qc4 {(c2c4 h4f5 e3e4
f5h6 e2d4 d8d7 d4c6 d7c6) +0.71/8 29} f5 {(f6f5 b1b4 h4g6 e2d4 d8d7 d4c6
d7c6) -0.56/7 29} 24. Nd4 {(e2d4 c6e4 d4e6 d8d7 c5c6 e4c6 e6g7 e7g7)
+0.99/8 29} Be4 {(c6e4 d4e6 d8c8 b1b2 c7c6 b2b4 h8h6 c4b3) -0.31/8 29} 25.
Nxe6+ {(d4e6 d8c8 b1b5 c7c6 b5b4 h8h6 c4b3) +0.22/7 29} Kc8 {(d8c8 b1b2
h8h6 f2f3 e7e6 f3e4 e6c4 f1c4 b7c5) -0.30/9 29} 26. Rb4 {(b1b4 h8h6 e6d4
e7c5 c4c5 b7c5 c1b2) +0.32/7 29} Rh6 {(h8h6 e6f4 e7c5 c1b2 c5c4 f1c4 g7g5)
-0.17/7 29} 27. Nf4 {(e6f4 e7c5 c1b2 c5c4 f1c4 g7g5 b2g7) +0.17/7 29} Qxc5
{(e7c5 c4c5 b7c5 c1b2 h6h7 f4e2 c5d7) -0.06/7 29} 28. Qxc5 {(c4c5 b7c5 c1b2
g7g5 b2g7 h6h7 g7d4) +0.02/7 29} Nxc5 {(b7c5 c1b2 g7g5 b4c4 g5f4 c4c5 f4e3
f2e3) -0.35/8 29} 29. Bb2 {(c1b2 g7g5 b2g7 h6h7 g7f6 g5f4 f6h4 f4e3)
+0.12/8 29} g5 {(g7g5 b4c4 g5f4 c4c5 h6g6 e3f4 h4g2 f1g2) -0.23/8 29} 30.
Rc4 {(b4c4 h6b6 b2c1 g5f4 c4c5 b6g6 e3f4 h4g2) +0.20/8 29} Rb6 {(h6b6 c4c5
b6b2 f4e2 b2b6 f2f4 g5f4 e3f4) +0.62/8 29} 31. Rxc5 {(c4c5 b6b2 f4e2 a8a1
e2c1 b2b6 f2f4 g5f4) -0.43/8 30} Rxb2 {(b6b2 f4e2 a8a1 e2c1 e4c2 e1d2 c2b3
d2e1) +0.16/8 30} 32. Ne2 {(f4e2 a8a1 e2c1 c8b7 f2f3 b7b6 c5c4 e4d5)
-0.65/8 29} Ra1+ {(a8a1 e2c1 c7c6 c5c3 e4d5 f2f3 b2b6 f1c4) +1.26/8 29} 33.
Nc1 {(e2c1 c8d7 c5c4 e4d5 c4c3 b2b6 e1d1 g5g4 c3c5) -1.51/9 29} Kd7 {(c8d7
c5c4 e4d5 c4c3 b2b6 e1d2 d7d6 c1d3) +0.77/8 29} 34. Rc4 {(c5c4 b2b8 e1d1
a1a8 f1e2 e4b7 c4d4 d7e6) -1.33/8 29} Bd5 {(e4d5 c4c3 b2b8 f2f3 a1a8 f1c4
c7c6 c4d5) +1.71/8 29} 35. Rc3 {(c4c3 d7d6 f1c4 d5g2 c4e2 b2b8 e2h5 a1a8)
-1.59/8 29} Rb8 {(b2b8 c3c2 a1a8 c2d2 d7c6 f2f4 g5f4 e3f4) +1.49/8 29} 36.
Kd1 {(e1d1 d7c8 f1d3 c8b7 d3f1 d5f7 f1c4 f7g6) -0.93/8 29} c6 {(c7c6 c3d3
d7e6 f2f4 g5f4 e3f4 h4g6 g2g3) +0.98/8 29} 37. Bd3 {(f1d3 d7e6 d3c4 h4g6
c4d5 c6d5 g2g4 f5g4) -0.97/8 29} Ke7 {(d7e7 g2g3 h4f3 g1f1 e7e6 d3e2 g5g4
h3g4) +0.83/8 29} 38. f3 {(f2f3 e7d6 d3c4 d5c4 c3c4 a1a7 f3f4 g5f4) -0.87/8
29} Kd6 {(e7d6 d3c4 h4g6 c4d5 c6d5 c3c2 a1a7 c2a2) +0.75/8 29} 39. e4
{(e3e4 d5e6 d3c2 f5e4 c2e4 a1a6 g2g4 h5g4) -1.02/8 29} fxe4 {(f5e4 f3e4
d5f7 d3e2 a1a4 c3d3 d6e5 d3d7) +0.97/8 29} 40. fxe4 {(f3e4 d5e6 d3e2 g5g4
c3d3 d6c5 h3g4 h5g4) -1.12/8 29} Bb3+ {(d5b3 d1e1 b3f7 d3e2 b8b1 e1d1 a1a7
c3c2) +0.98/8 29} 41. Kd2 {(d1d2 b3e6 d3e2 g5g4 e4e5 d6d5 e2c4 d5e5 c4e6)
-0.91/9 29} Ng6 {(h4g6 g1f1 b3e6 f1f6 g6f8 c3b3 b8e8 b3b7) +0.96/8 29} 42.
g4 {(g2g4 h5h4 g1f1 b3e6 f1f6 g6f8 c3b3 b8e8) -0.75/8 29} h4 {(h5h4 g1f1
b3e6 f1f6 g6e5 c3b3 e5f3 d2c2) +0.81/8 30} 43. Rf1 {(g1f1 b3e6 d3c4 e6c4
f1f6 d6e5 f6g6 c4b5) -0.90/8 29} Be6 {(b3e6 d3c4 e6c4 f1f6 c4e6 f6g6 a1a4
c3e3) +0.66/8 29} 44. Bc4 {(d3c4 e6c4 f1f6 c4e6 f6g6 a1a4 c3e3 a4a5)
-0.62/8 29} Nf4 {(g6f4 e4e5 d6e7 c4e6 e7e6 c3c6 e6e5 c6c3) +0.51/8 29} 45.
e5+ {(e4e5 d6e7 c4e6 e7e6 c3c6 e6d5 c6c3 d5e5) -0.93/8 29} Kd7 {(d6d7 c1d3
a1a5 d3f4 g5f4 c3d3 d7e7 f1f4 a5e5 d3e3) +0.69/10 29} 46. Bxe6+ {(c4e6 f4e6
c3b3 b8e8 b3b7 d7c8 b7f7 e8g8) -0.59/8 29} Kxe6 {(d7e6 c3c6 e6d5 c6c3 b8b2
c3c2 b2b8 c2a2 a1a2) +0.61/9 29} 47. Rxc6+ {(c3c6 e6d5 c6c3 b8b2 d2d1 d5e5
f1e1 e5d4 e1e3) -0.92/9 29} Kd5 {(e6d5 c6c3 b8b2 c3c2 b2b7 c2c3 b7b2 d2d1
d5e5 c3e3) +0.73/10 30} 48. Rc3 {(c6c3 b8b2 c3c2 b2b7 c2c3 b7b2 d2d1 d5e5
c3e3) -0.68/9 29} Rb2+ {(b8b2 d2e3 f4g2 e3f3 a1a7 c1e2 d5e5 f3g2) +0.92/8
29} 49. Rc2 {(c3c2 b2c2 d2c2 a1a3 f1e1 f4h3 e5e6 a3a8 e6e7 a8e8) -0.81/10
29} Rxc2+ {(b2c2 d2c2 f4h3 f1d1 d5e6 c1d3 a1a2 c2c3 a2a7) +0.88/9 29} 50.
Kxc2 {(d2c2 a1a3 f1e1 f4h3 e5e6 a3a8 e6e7 a8e8 e1e3 e8c8) -1.19/10 29} Nxh3
{(f4h3 f1f5 a1a4 c1e2 a4g4 e2c3 d5c4 f5f3 g4g2 c2c1) +1.11/10 29} 51. Rd1+
{(f1d1 d5e6 c1d3 a1d1 c2d1 h3f4 d1d2 f4d3 d2d3 e6e5) -1.15/10 29} Ke4
{(d5e4 e5e6 a1a8 d1f1 h3f4 e6e7 a8e8 c1b3 e4e5 f1e1 e5d5) +1.16/11 30} 52.
e6 {(e5e6 a1a8 e6e7 a8e8 c1b3 e4f3 d1d7 e8c8 c2d3 f3g4) -0.98/10 29} Ra8
{(a1a8 e6e7 a8e8 c1a2 e4f3 d1d7 e8c8 c2d2 f3g4 d7b7) +0.94/10 29} 53. e7
{(e6e7 a8e8 d1f1 h3f4 c1b3 e4e5 f1e1 e5d6 c2c3 e8e7) -0.98/10 29} Rc8+
{(a8c8 c2b3 c8e8 b3c4 e4f3 d1d7 h3f2 c4d4 f3f4 d7b7) +0.80/10 29} 54. Kb3
{(c2b3 c8b8 b3c4 b8e8 c1d3 h3f4 d1e1 e4f3 d3f4 f3f4 e1e6) -0.42/11 29} Rb8+
{(c8b8 b3c4 b8e8 c1d3 h3f4 d1e1 e4f3 d3f4 f3f4 e1e6) +0.45/10 30} 55. Kc4
{(b3c4 b8e8 d1f1 h3f4 c4c5 f4g6 c5d6 e4e3 f1f7 e3d4 c1b3) -0.21/11 29} Re8
{(b8e8 c1d3 h3f4 d1e1 e4f3 d3f4 f3f4 c4d4 f4g4 e1e6) +0.41/10 29} 56. Re1+
{(d1e1 e4f3 c4d5 f3f2 c1d3 f2f3 d3e5 f3f2 e1h1 h3f4) +0.22/10 29} Kf3
{(e4f3 c4c5 f3f2 e1e5 h3f4 c5d6 f4g6 c1d3 f2f3 e5e6 g6f4) -0.53/11 29} 57.
Kd5 {(c4d5 f3f2 e1e5 h3f4 d5d6 f4g6 c1d3 f2f3 e5e6 g6h8) +0.83/10 29} Nf2
{(h3f2 d5d6 h4h3 d6d7 e8e7 d7e7 h3h2 c1d3 h2h1q e1h1) -0.17/10 29} 58. Kd6
{(d5d6 h4h3 d6d7 e8e7 d7e7 h3h2 c1d3 h2h1q e1h1 f2h1) +0.13/10 29} h3
{(h4h3 d6d7 e8e7 d7e7 h3h2 c1d3 h2h1q e1h1 f2h1 d3e5) -0.20/10 29} 59. Kd7
{(d6d7 e8a8 c1d3 h3h2 d3f2 f3f2 e1b1 a8a7 d7d6 a7a6) +0.18/10 30} Ra8
{(e8a8 e7e8q a8e8 d7e8 h3h2 c1d3 h2h1q e1h1 f2h1 d3e5) -0.03/10 29} 60.
e8=R {(e7e8r a8e8 d7e8 h3h2 c1d3 h2h1q e1h1 f2h1 d3e5) -0.01/9 29} Rxe8
{(a8e8 e1e8 h3h2 e8f8 f3g4 c1d3 f2d3 f8h8 d3e5) -0.22/9 29} 61. Rxe8 {(e1e8
h3h2 e8h8 h2h1q h8h1 f2h1 d7e6 f3g4 e6e5 g4f3) -0.68/10 29} h2 {(h3h2 e8h8
h2h1q h8h1 f2h1 d7e6 f3g4 e6e5 g4f3 c1b3) +0.36/10 29} 62. Re1 {(e8e1 h2h1q
e1h1 f2h1 d7d6 f3g4 d6e5 g4f3 c1b3 f3e3) -0.46/10 29} h1=R {(h2h1r e1h1
f2h1 d7e6 f3e4 e6f6 e4f4 c1d3 f4g4 f6e5) +0.35/10 29} 63. Rxh1 {(e1h1 f2h1
d7e6 h1g3 c1b3 f3g4 e6e5 g3e2 b3a5 e2c3) -0.62/10 29} Nxh1 {(f2h1 d7e6 f3g4
e6e5 g4f3 c1b3 h1f2 b3d4 f3e3 e5d5 f2e4) +0.35/11 29} 64. Ke6 {(d7e6 f3g4
c1d3 h1g3 e6e5 g4f3 d3e1 f3e3 e1c2 e3d3 c2b4 d3e3) -0.56/12 29} Kxg4 {(f3g4
c1d3 h1g3 e6e5 g4f3 d3b2 g3f1 b2c4 g5g4 e5f5 g4g3 f5e5 f1e3) +0.51/13 29}
65. Nd3 {(c1d3 h1g3 e6e5 g4f3 d3b2 f3e3 b2c4 e3d3 c4d6 d3c3 d6f7 g5g4)
-0.50/12 29} Ng3 {(h1g3 e6f6 g3f1 f6e5 f1d2 d3b4 g4f3 b4d5 g5g4 e5d4 f3e2
d5c3 e2f3) +0.49/13 29} 66. Kf6 {(e6f6 g3e2 f6e5 g4f3 e5f5 e2d4 f5g5 f3e4
d3c5 e4d5 c5d7 d5e4) -0.50/12 29} Nh5+ {(g3h5 f6e5 h5g3 d3e1 g3f1 e1d3 f1d2
d3c5 g4f3 c5e6 g5g4 e5d4 d2e4) +0.60/13 29} 67. Ke5 {(f6e5 h5f4 d3f2 g4f3
f2e4 f4g6 e5f5 g6e7 f5e5 g5g4 e4d6 f3e3 d6c4 e3d3) -0.49/14 29} Ng3 {(h5g3
d3e1 g3f1 e1d3 f1d2 d3b4 g4f3 b4d5 d2c4 e5d4 c4d2 d4e5 d2c4) +0.46/13 29}
68. Nb2 {(d3b2 g4f3 b2c4 g5g4 c4d2 f3e3 d2c4 e3f3 c4b6 f3e3 b6c4 e3d3 e5d5)
-0.50/13 29} Kf3 {(g4f3 b2d3 f3e3 d3b4 e3f3 b4c2 g3e2 c2e1 f3e3 e1c2 e3d3
c2b4 d3e3) +0.54/13 29} 69. Nd3 {(b2d3 f3e3 d3e1 e3e2 e1c2 e2d3 c2e1 d3e3
e1c2 e3d3 c2d4 g3e4) -0.53/12 29} g4 {(g5g4 d3e1 f3f2 e1d3 f2e3 d3b4 g3f1
b4d5 e3d3 d5b4 d3e3 b4d5) +0.55/12 29} 70. Ne1+ {(d3e1 f3e2 e1g2 g3f1 g2f4
e2e3 f4d5 e3d3 d5b4 d3c4 b4d5 f1d2) -0.57/12 29} Ke2 {(f3e2 e1g2 g3h1 e5f4
g4g3 g2e3 e2f2 e3d1 f2e2 d1c3 e2d3 c3e4 g3g2 e4c5) +0.69/14 29} 71. Ng2
{(e1g2 g3h1 e5e4 g4g3 g2e3 h1f2 e4d4 e2f3 e3f5 f2g4 f5h4 f3f4 h4g6)
-0.73/13 29} Kf2 {(e2f2 g2f4 f2f3 f4g6 f3e3 g6f4 g3e4 f4d5 e3d3 d5b4 d3e3
b4d5 e3d3) +0.64/13 29} 72. Nf4 {(g2f4 g3h1 f4d3 f2f1 d3f4 g4g3 f4d5 g3g2
d5e3 f1f2 e3g2 f2g2 e5e4) -2.36/13 29} Nh1 {(g3h1 e5d4 g4g3 f4d3 f2f1 d3e5
g3g2 e5f3 h1f2 d4d5 g2g1q f3g1) +2.31/12 29} 73. Nd3+ {(f4d3 f2f1 d3f4 g4g3
f4d5 g3g2 d5e3 f1f2 e3g2 f2g2 e5e4 g2f2) -2.45/12 29} Kf1 {(f2f1 d3f4 g4g3
f4d5 g3g2 d5e3 f1f2 e3g2 f2g2 e5e4 g2f2 e4d4) +2.47/12 29} 74. Kd5 {(e5d5
g4g3 d3e5 g3g2 e5f3 f1f2 d5e4 h1g3 e4f4 g3e2 f4e4 g2g1q) -2.54/12 29} g3
{(g4g3 d3f4 h1f2 d5d4 g3g2 f4g2 f1g2 d4e3 g2g3 e3d4 g3f4 d4d5) +2.80/12 29}
75. Nf4 {(d3f4 h1f2 d5d4 g3g2 f4g2 f1g2 d4d5 g2f3 d5d4 f3f4 d4d5 f2e4)
-2.97/12 29} Nf2 {(h1f2 d5d4 g3g2 f4g2 f1g2 d4c4 g2f3 c4d5 f3f4 d5d4 f2g4
d4d5 g4e3) +2.95/13 29} 76. Kd4 {(d5d4 g3g2 f4g2 f1g2 d4c4 g2f3 c4d5 f3f4
d5d4 f2g4 d4d5 g4e5) -2.94/12 30} g2 {(g3g2 f4g2 f1g2 d4c4 g2f3 c4d5 f3e3
d5e5 e3d3 e5d5 f2g4 d5d6 d3d4) +3.35/13 29} 77. Nxg2 {(f4g2 f1g2 d4c4 g2f3
c4d5 f3e3 d5e5 e3d3 e5d5 f2g4 d5d6) -3.11/11 30 Insufficient material}
1/2-1/2
[/pgn]

[Mike Sherwin]

I wanted to jump right in and start adding to the eval but resisted long enough to get a baseline result for the above code. Besides I had to leave the house for a few hours.

Bricabrac1 - Tscp181 : 9.0/100 6-88-6 (0100000000000000001000000000000000010000000000000=000000000=000000=000000000=000=000010100000=100000) 9% -402

Even though at first glance it is a horrific looking result it really is not that bad. And about what I had expected for 1 sec per move. At 30 seconds per move it can see the value in pushing pawns. At 1 second per move it will push a pawn to help a piece develop but refuses to try and promote or to stop an opponents pawn from advancing until it is too late. I have started a 30 second per move match. I'll report on that in about 3 days.

Next on the list.
1. While counting safe squares for move two of a piece is pretty good it does matter the location of those squares.
2. Bonusing winning attacks.
3. Bonusing if has a safe retreat square.
4. Normalizing the values to some maximum for each piece type.
5. Pawn structure.
6. Pawn evaluation hash.

[lithander]

Your work and comments have inspired me to try and add a dynamic component to MinimalChess' evaluation wich is atm using PSTs only.

I don't want to replace the PSTs but augment them. The dynamic component will make use of a tunable table also. That way I don't have to hardcode chess knowledge into the engine but enable the tuner to derive it statistically from a dataset of games just like with the PSTs.

What I'm currently testing is an implementation where for each piece on the board it will look at all the squares it could potentially move to. If the square is empty it doesn't affect the score but for each friendly and opponent piece encountered a bonus or malus is added to the score. These bonuses come from a tunable table of size 6x6x2.

The results are promising and seem to make a lot of sense intuitively. For example there's a bonus of 9 if a pawn can attack a friendly other pawn's square. This leads to a better looking pawn structure than what PSTs can do on their own.

Code: Select all

          // Friends                                      Foes
          // P      N      B      R      Q      K         P      N      B      R      Q      K
             9,     7,    13,     3,    -2,    -6,        0,    27,    36,    15,    32,    84, //P
            -1,     0,    -2,     0,     3,    -1,       -5,     0,    18,    15,    14,    30, //N
           -11,    -3,    34,     3,    -6,    -5,       -4,    11,     0,     8,    19,    20, //B
           -10,    -2,     2,    -2,    -1,    -3,       -4,    -2,     1,     0,    10,     5, //R
            -3,     1,     4,    -4,   -34,    -3,       -2,    -3,     0,     3,     0,     6, //Q
             6,     0,     7,    -8,    -3,     0,       30,     5,     9,     3,   -34,     0, //K

This is what the tuner found to be good values for my current implementation. For example it seems to make sense for a pawn to guard other pawns (9), knights (7) and bishops (13) but not queens and certainly not kings. And if your pawn can attack an enemy piece that always warrants a huge bonus for each type except other pawns. (Because they can then also attack you so there's no bonus for one side)

There are different implementation details I want to try... For example, when do you stop giving a bonus for sliders? after the first piece on the axis? after the 2nd? Or not at all? (what I do currently) Or... should there be a distinct table for midgame and endgame? But this is the general direction I'm going to try to improve MinimalChess' evaluation with. And preliminary results are promising.