feat: v0.4.0

Implemented capture history and better LMR. Ready for release.

Author: UndefinedCpp

README.md

@@ -4,12 +4,28 @@ This is a toy chess engine I developed over two weeks as part of my winter break
 
 This software **does not** come with a GUI, so if you want to play it you will need to download one from Internet. I recommend [en-croissant](https://github.com/franciscoBSalgueiro/en-croissant).
 
-This engine is still **WIP** and will be updated from time to time. Currently I am refactoring and optimizing and hope to hit 1600 Elo soon.
+This engine is still **WIP** and will be updated from time to time.
 
 ## Compiling
 
 Use the CMake to compile the engine.
 
+## Technical Details
+
+This engine is based on traditional *alpha-beta search* algorithm with simple optimizations and pruning methods. Features implemented:
+- Transposition table
+- Iterative deepening
+- Null move pruning
+- Quiescence search
+- Razoring
+- Late move reduction
+- History heuristics
+- A simple NNUE for evaluation
+
+Since v0.4.0 the engine uses **NNUE** for evaluation.
+- Uses naive `768->128->1` architecture. No accumulators, king buckets, subnetworks - so in theory this is not actually *efficiently updated*. However, with proper auto-vectorization this runs even *faster* than my previous handcrafted evaluation function.
+- Positions used to train this NNUE are collected from Lichess database. About 30% of the data is from chess960 variant. All positions are first evaluated with my own engine (v0.3.0) at depth 8, and then adjusted based on the actual outcome and the "imbalanceness" of the position. Thus, this network is purely original. So far, only 1.5M filtered positions are used to train this reasonably good network.
+
 ## License
 
 This project is licensed under the MIT License.

src/eval.h

@@ -3,6 +3,8 @@
 #include "types.h"
 #include <cstring>
 
+constexpr Value PIECE_VALUE[7] = {100, 300, 330, 550, 900, 10000, 0};
+
 /**
  * Checks if the game is over and returns the appropriate score.
  */

src/history.h

@@ -49,20 +49,53 @@ class SearchHistory {
             return data[(int) stm][move.from().index()][move.to().index()];
         }
         inline void update(const Color stm, const Move& move, int16_t bonus) {
-            int16_t& ref      = data[(int) stm][move.from().index()][move.to().index()];
-            int      newScore = bonus + ref;
+            int16_t& ref  = data[(int) stm][move.from().index()][move.to().index()];
+            int      diff = bonus - ref * std::abs(bonus) / MAX_HISTORY_SCORE;
 
-            ref = std::clamp(newScore, (int) MIN_HISTORY_SCORE, (int) MAX_HISTORY_SCORE);
+            ref = std::clamp(ref + diff, (int) MIN_HISTORY_SCORE, (int) MAX_HISTORY_SCORE);
         }
     };
 
-public:
-    KillerTable       killerTable[MAX_PLY];
-    QuietHistoryTable qHistoryTable;
+    struct CaptureHistoryTable {
+        int16_t data[2][6][64][6];
+
+        void clear() { std::memset(data, 0, sizeof(data)); }
+
+        inline int16_t get(const Color stm, const Move& move, const Position& pos) {
+            const Square to        = move.to();
+            const auto   aggressor = pos.at(move.from()).type();
+            const auto   victim    = pos.at(to).type();
+            assert(aggressor != PieceType::NONE);
+            if (victim == PieceType::NONE) { // en passant
+                return 0;
+            }
+            return data[(int) stm][(int) aggressor][to.index()][(int) victim];
+        }
+
+        inline void update(const Color stm, const Move& move, const Position& pos, int16_t bonus) {
+            const Square to        = move.to();
+            const auto   aggressor = pos.at(move.from()).type();
+            const auto   victim    = pos.at(to).type();
+            assert(aggressor != PieceType::NONE);
+            if (victim == PieceType::NONE) { // en passant
+                return;
+            }
+            int16_t& ref  = data[(int) stm][(int) aggressor][to.index()][(int) victim];
+            int      diff = bonus - ref * std::abs(bonus) / MAX_HISTORY_SCORE;
+
+            ref = std::clamp(ref + diff, (int) MIN_HISTORY_SCORE, (int) MAX_HISTORY_SCORE);
+        }
+    };
+
+    KillerTable         killerTable[MAX_PLY];
+    QuietHistoryTable   qHistoryTable;
+    CaptureHistoryTable capHistoryTable;
 
     void clear() {
         for (int i = 0; i < MAX_PLY; i++) {
             killerTable[i].clear();
         }
+        qHistoryTable.clear();
+        capHistoryTable.clear();
     }
 };

src/movepick.cpp

@@ -184,6 +184,11 @@ void MovePicker::generateNoisyMoves() {
         } else { // a losing capture
             score = mvvlva - 1000;
         }
+        // Use capture history heuristic
+        const int16_t hist = history.capHistoryTable.get(pos.sideToMove(), move, pos);
+        if (hist > 0) {
+            score = score / 2 + hist / 8;
+        }
 
         noisyBuffer.emplace_back(ScoredMove {move.move(), score});
     }
@@ -209,7 +214,7 @@ void MovePicker::generateQuietMoves() {
         if (pos.at(move.from()).type() != PieceType::PAWN &&
             (attacks::pawn(pos.sideToMove(), move.to()) &
              pos.pieces(PieceType::PAWN, ~pos.sideToMove()))) {
-            score -= 900;
+            score -= 1200;
         }
         // Assign score from quiet history
         int historyScore = history.qHistoryTable.get(pos.sideToMove(), move);

src/search.cpp

@@ -43,6 +43,17 @@ using SearchStack = std::array<SearchStackEntry, MAX_PLY>;
 
 std::thread searchThread;
 
+// LMR Table ============================================================================
+int8_t LMRTable[256][256];
+void   computeLMRTable() {
+    for (int depth = 1; depth < 256; ++depth) {
+        for (int moveIndex = 1; moveIndex < 256; ++moveIndex) {
+            LMRTable[depth][moveIndex] =
+                (int8_t) std::round(0.9f + std::sqrt(depth) * std::sqrt(moveIndex) / 3.0f);
+        }
+    }
+}
+
 // Global variables =====================================================================
 SearchStats   searchStats;
 SearchStack   searchStack;
@@ -104,7 +115,8 @@ Value qsearch(Position& pos, int depth, int ply, Value alpha, Value beta) {
         }
 
         // Delta Pruning
-        if (!pos.inCheck() && standPat + Value(1000) < alpha) {
+        Value delta = PIECE_VALUE[pos.at(m.to()).type()] + Value(200);
+        if (!pos.inCheck() && standPat + delta < alpha) {
             continue;
         }
 
@@ -207,9 +219,21 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
     currSS->staticEval = staticEval;
 
     // Pre-move-loop pruning
+
     // If static evaluation is a fail-high or fail-low, we can likely prune
     // without doing any further work.
     if (!isPV && !inCheck) {
+        // Reverse Futility Pruning
+        const Value futilityMargin = Value(200) + Value(100) * depth;
+        if (depth <= 9 && !alpha.isMate() && staticEval - futilityMargin > beta) {
+            return beta + (staticEval - beta) / 4;
+        }
+
+        // Razoring
+        if (staticEval < alpha - Value(500) - Value(100) * depth) {
+            return qsearch(pos, depth - 1, ply + 1, alpha, beta);
+        }
+
         // Null move pruning
         if (depth >= 6                                       // enough depth
             && currSS->canNullMove                           // prev move not null move
@@ -248,17 +272,32 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
         moveSearched++;
 
         // todo reductions and prunings
+        int reduction = 0;
+
+        const int lmrMinDepth = isPV ? 4 : 3;
+        if (moveSearched >= 3 && depth >= lmrMinDepth && !inCheck) {
+            reduction = LMRTable[depth][moveSearched];
+            if (!cutnode) {
+                reduction--;
+            }
+            if (isPV) {
+                reduction--;
+            }
+        }
 
         // Principal variation search
+        reduction       = std::clamp(reduction, 0, depth - 1);
+        int searchDepth = depth - reduction - 1;
+
         Value score;
         pos.makeMove(m);
         if (moveSearched == 1) {
-            score = -negamax<isPV>(pos, depth - 1, ply + 1, -beta, -alpha, false);
+            score = -negamax<isPV>(pos, searchDepth, ply + 1, -beta, -alpha, false);
         } else {
-            score = -negamax<false>(pos, depth - 1, ply + 1, -alpha - 1, -alpha, true);
+            score = -negamax<false>(pos, searchDepth, ply + 1, -alpha - 1, -alpha, true);
             // If it improves alpha, re-search with full window
             if (score > alpha && isPV) {
-                score = -negamax<true>(pos, depth - 1, ply + 1, -beta, -alpha, false);
+                score = -negamax<true>(pos, searchDepth, ply + 1, -beta, -alpha, false);
             }
         }
         pos.unmakeMove(m);
@@ -283,6 +322,9 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
                 if (!pos.isCapture(bestMove)) {
                     searchHistory.killerTable[ply].add(bestMove);
                     searchHistory.qHistoryTable.update(pos.sideToMove(), bestMove, depth * depth);
+                } else {
+                    searchHistory.capHistoryTable.update(
+                        pos.sideToMove(), bestMove, pos, depth * depth);
                 }
                 break;
             }
@@ -302,9 +344,9 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
 
 void searchWorker(SearchParams params, Position pos) {
     g_stopRequested.store(false);
-    searchStats = SearchStats();
     searchStack.fill(SearchStackEntry {});
     tt.incGeneration();
+    computeLMRTable();
 
     g_timeControl = TimeControl(pos.sideToMove(), params, TimeControl::now());
     int maxDepth  = params.depth > 0 ? (int) params.depth : 64;
@@ -316,6 +358,7 @@ void searchWorker(SearchParams params, Position pos) {
     Value windowLower = 20;
 
     for (int depth = 1; depth <= maxDepth; ++depth) {
+        searchStats = SearchStats();
         if (g_stopRequested.load())
             break;
         if (g_timeControl.hitSoftLimit(depth, (int) searchStats.nodes, 0))
@@ -343,7 +386,7 @@ void searchWorker(SearchParams params, Position pos) {
             }
         }
 
-        auto pv = extractPv(pos, depth);
+        auto pv = extractPv(pos, depth / 2 + 1);
         if (!pv.empty())
             rootBestMove = pv.front();
         rootBestScore = score;

src/uci.h

@@ -4,7 +4,7 @@
 #include <sstream>
 #include <string>
 
-#define ENGINE_VERSION "0.3.0"
+#define ENGINE_VERSION "0.4.0"
 
 namespace uci {
 

testengine.py

@@ -34,7 +34,8 @@ def elo_mode(args):
     # Output
     cmd += [
         "-pgnout", f'elo_{time.strftime("%Y%m%d-%H%M%S", time.localtime())}.pgn',
-        "-output", "format=fastchess"
+        "-output", "format=fastchess",
+        # "-log", "level=err"
     ]
 
     run_fastchess(cmd)