updated cmake lists, improved move ordering

--------------------------------------------------
Results of bread_engine_1.2.0 vs bread_engine_1.1.4 (10+0.1, 1t, MB, UHO_2024_8mvs_big_+115_+134.pgn):
Elo: 9.01 +/- 7.14, nElo: 12.00 +/- 9.51
LOS: 99.33 %, DrawRatio: 38.01 %, PairsRatio: 1.11
Games: 5130, Wins: 1786, Losses: 1653, Draws: 1691, Points: 2631.5 (51.30 %)
Ptnml(0-2): [191, 564, 975, 591, 244]
LLR: 2.97 (-2.94, 2.94) [0.00, 10.00]
--------------------------------------------------
Bench: 9655652

Author: Nonlinear2

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(bread_engine VERSION 1.1.4)
+project(bread_engine VERSION 1.2.0)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -43,18 +43,26 @@ if ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR (CMAKE_CXX_COMPILER_ID STREQUAL
 endif()
 
 add_executable(generate_neural_net_header ${bread_UTILS}/generate_nn_header.cpp)
-target_compile_definitions(generate_neural_net_header PRIVATE bread_NN_HEADER_PATH="${bread_NN_HEADER_PATH}")
-target_compile_definitions(generate_neural_net_header PRIVATE bread_NNUE_MODEL_PATH="${bread_NNUE_MODEL_PATH}")
-
-# add custom target that generates the header when needed
-add_custom_command(
-    OUTPUT ${bread_NN_HEADER_PATH}
-    COMMENT "generating neural network header"
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${bread_NN_HEADER_DIR}
+add_executable(clear_neural_net_header ${bread_UTILS}/clear_nn_header.cpp)
+
+target_compile_definitions(
+    generate_neural_net_header PRIVATE bread_NN_HEADER_PATH="${bread_NN_HEADER_PATH}")
+target_compile_definitions(
+    generate_neural_net_header PRIVATE bread_NNUE_MODEL_PATH="${bread_NNUE_MODEL_PATH}")
+
+target_compile_definitions(
+    clear_neural_net_header PRIVATE bread_NN_HEADER_PATH="${bread_NN_HEADER_PATH}")
+target_compile_definitions(
+    clear_neural_net_header PRIVATE bread_NNUE_MODEL_PATH="${bread_NNUE_MODEL_PATH}")
+
+file(MAKE_DIRECTORY ${bread_NN_HEADER_DIR})
+
+add_custom_target(run_generate_nn_header
     COMMAND $<TARGET_FILE:generate_neural_net_header>
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS generate_neural_net_header
+    COMMENT "generating the neural network header"
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
 )
-add_custom_target(run_generate_neural_net_header DEPENDS ${bread_NN_HEADER_PATH})
 
 function(bread_configure bread_TARGET)
     cmake_parse_arguments(bread "" "" "SOURCES" ${ARGN})
@@ -65,7 +73,13 @@ function(bread_configure bread_TARGET)
 
     target_compile_definitions(${bread_TARGET} PRIVATE bread_VERSION="${CMAKE_PROJECT_VERSION}")
 
-    add_dependencies(${bread_TARGET} run_generate_neural_net_header)
+    add_dependencies(${bread_TARGET} run_generate_nn_header)
+
+    add_custom_command(
+        TARGET ${bread_TARGET} POST_BUILD
+        COMMAND $<TARGET_FILE:clear_neural_net_header>
+        COMMENT "clearing the neural network header"
+    )
 
     target_compile_definitions(${bread_TARGET} PRIVATE bread_TB_PATH="${bread_TB_PATH}")
 

dependencies/sorted_move_gen.hpp

@@ -32,7 +32,7 @@ class SortedMoveGen: public chess::Movelist {
 
     private:
     int initial_size;
-    int depth;
+    int depth = -1;
     int move_idx = -1;
     int num_remaining_moves;
     bool checked_tt_move = false;

src/benchmark_engine.cpp

@@ -44,12 +44,12 @@ void benchmark_nn(){
     NnueBoard board = NnueBoard();
 
     auto start = std::chrono::high_resolution_clock::now();
-    int num_iter = 10'000;
+    int num_iter = 10'000'000;
     for (int i = 0; i < num_iter; i++){
         board.evaluate();
     }
-    int mean = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - start).count()/num_iter;
-    std::cout << "time taken: " << mean << " microseconds per call";
+    int mean = 1000*std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - start).count()/num_iter;
+    std::cout << "time taken: " << mean << " nanoseconds per call\n";
     std::cout << "============================== \n";
 }
 
@@ -74,7 +74,7 @@ void benchmark_engine(int depth){
     engine.transposition_table.info();
 
     std::cout << "============================== \n";
-    std::cout << "average time: " << sum(times)/fens.size() << "\n";
+    std::cout << "average time: " << sum(times)/fens.size() << " ms\n";
     std::cout << "============================== \n";
 }
 

src/bread_engine_core.cpp

@@ -296,17 +296,17 @@ int Engine::negamax(int depth, int color, int alpha, int beta){
         if (transposition->best_move != NO_MOVE) sorted_move_gen.set_tt_move(transposition->best_move);
     }
 
-    bool is_in_check = inner_board.inCheck();
+    bool in_check = inner_board.inCheck();
 
     int static_eval = is_hit ? transposition->evaluation : inner_board.evaluate();
     // razoring
-    if (!pv && !is_in_check && (depth < 6) && static_eval + depth*800 + 1500 < alpha){ 
+    if (!pv && !in_check && (depth < 6) && static_eval + depth*800 + 1500 < alpha){ 
         static_eval = qsearch<false>(alpha, beta, color, QSEARCH_MAX_DEPTH); // we update static eval to the better qsearch eval. //? tweak depth?
         if (static_eval <= alpha) return static_eval;
     }
 
     // reverse futility pruning
-    if (!pv && !is_in_check && (depth < 6) && (static_eval - depth*800 - 1500 >= beta)){
+    if (!pv && !in_check && (depth < 6) && (static_eval - depth*800 - 1500 >= beta)){
         return static_eval;
     }
 
@@ -315,7 +315,7 @@ int Engine::negamax(int depth, int color, int alpha, int beta){
     int null_move_eval;
     if (!pv && 
         (depth > 4) &&
-        !is_in_check && 
+        !in_check && 
         !inner_board.last_move_null() && 
         beta != BEST_EVAL)
     {
@@ -351,7 +351,7 @@ int Engine::negamax(int depth, int color, int alpha, int beta){
         bool is_killer = SortedMoveGen<chess::movegen::MoveGenType::ALL>::killer_moves[depth].in_buffer(move);
 
         // lmp
-        if ((!pv) && (!is_in_check) && (!is_capture) && (sorted_move_gen.index() > 3 + depth) && (!is_hit) && (static_eval < alpha)) continue;
+        if ((!pv) && (!in_check) && (!is_capture) && (sorted_move_gen.index() > 3 + depth) && (!is_hit) && (static_eval < alpha)) continue;
 
         inner_board.update_state(move);
 
@@ -511,7 +511,6 @@ int Engine::qsearch(int alpha, int beta, int color, int depth){
         // SEE pruning
         if (!SEE::evaluate(inner_board, move, (alpha-stand_pat)/800 - 3)) continue;
 
-
         inner_board.update_state(move);
         pos_eval = -qsearch<pv>(-beta, -alpha, -color, depth-1);
         inner_board.restore_state(move);

src/sorted_move_gen.cpp

@@ -20,35 +20,51 @@ void SortedMoveGen<chess::movegen::MoveGenType::ALL>::set_score(chess::Move& mov
     const chess::Square to = move.to();
     const chess::Piece piece = board.at(from);
     const chess::Piece to_piece = board.at(to);
+    const int from_value = piece_value[static_cast<int>(piece.type())];
+
+    chess::Bitboard attacked_by_pawn = 0;
+
+    chess::Bitboard pawn_attackers = board.pieces(chess::PieceType::PAWN, ~board.sideToMove());
+
+    while (pawn_attackers)
+        attacked_by_pawn |= chess::attacks::pawn(~board.sideToMove(), pawn_attackers.pop());
+
     int score = 0;
 
     if ((piece != chess::Piece::WHITEKING) && (piece != chess::Piece::BLACKKING)){
-        score += psm.get_psm(piece, from, to);
+        score += 100*psm.get_psm(piece, from, to);
     } else {
         bool is_endgame = board.occ().count() <= ENDGAME_PIECE_COUNT;
-        score += psm.get_ksm(piece, is_endgame, to, from);
+        score += 100*psm.get_ksm(piece, is_endgame, to, from);
     }
 
+    if (piece.type() != chess::PieceType::PAWN){
+        score += bool(attacked_by_pawn & chess::Bitboard::fromSquare(from))
+                 * 40 * from_value * MATERIAL_CHANGE_MULTIPLIER;
+        
+        score -= bool(attacked_by_pawn & chess::Bitboard::fromSquare(to))
+            * 41 * from_value * MATERIAL_CHANGE_MULTIPLIER;
+    }
+
     // captures should be searched early, so
     // to_value = piece_value(to) - piece_value(from) doesn't seem to work.
     // however, find a way to make these captures even better ?
     if (to_piece != chess::Piece::NONE){
-        score += piece_value[static_cast<int>(to_piece.type())] * MATERIAL_CHANGE_MULTIPLIER;
+        score += 100 * piece_value[static_cast<int>(to_piece.type())] * MATERIAL_CHANGE_MULTIPLIER;
     }
 
     if (move.typeOf() == chess::Move::PROMOTION){
-        score += piece_value[static_cast<int>(move.promotionType())] * MATERIAL_CHANGE_MULTIPLIER;
+        score += 100 * piece_value[static_cast<int>(move.promotionType())] * MATERIAL_CHANGE_MULTIPLIER;
     }
 
-    if (killer_moves[depth].in_buffer(move)){
-        score += KILLER_SCORE;
+    if (depth != -1 && killer_moves[depth].in_buffer(move)){
+        score += 100 * KILLER_SCORE;
     }
 
-    score += history.get_history_bonus(from.index(), to.index(), board.sideToMove() == chess::Color::WHITE)/100; // cant be less than worst move score
-    
-    assert(score < BEST_MOVE_SCORE);
-    assert(score > WORST_MOVE_SCORE);
+    score += history.get_history_bonus(from.index(), to.index(), board.sideToMove() == chess::Color::WHITE); // cant be less than worst move score
 
+    score = std::clamp(score, WORST_MOVE_SCORE + 1, BEST_MOVE_SCORE - 1);
+
     move.setScore(score);
 }
 

utils/clear_nn_header.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <fstream>
+#include <cstdint>
+
+int main(){
+    std::ofstream output_file;
+    output_file.open(bread_NN_HEADER_PATH);
+    output_file << "#pragma once\n";
+    output_file << "#include <cstdint>\n";
+    output_file << "// this file has been auto generated. Please do not modify it by hand.\n\n";
+
+    output_file << "namespace nn_data {\n";
+
+    output_file << "inline int w1[] = {};\n";
+    output_file << "inline int w2[] = {};\n";
+    output_file << "inline int w3[] = {};\n";
+    output_file << "inline int w4[] = {};\n";
+
+    output_file << "inline int* weights[] = {w1, w2, w3, w4};\n";
+
+    output_file << "inline int b1[] = {};\n";
+    output_file << "inline int b2[] = {};\n";
+    output_file << "inline int b3[] = {};\n";
+    output_file << "inline int b4[] = {};\n";
+
+    output_file << "inline int* bias[] = {b1, b2, b3, b4};\n";
+    output_file << "}";
+    output_file.close();
+    return 0;
+}

utils/generate_nn_header.cpp

@@ -8,7 +8,7 @@
 
 // this functions writes the weights from input_path to output_path with comas separating the values
 template<typename weights_type>
-void parameters_to_header(std::string input_path, int weights_size, std::ofstream& output_path){
+void parameters_to_header(std::string input_path, int weights_size, std::ofstream& output_file){
     std::ifstream weights_stream;
     weights_type* weights = new weights_type[weights_size];
 
@@ -19,7 +19,7 @@ void parameters_to_header(std::string input_path, int weights_size, std::ofstrea
     } else {std::cout << "error loading weights \n";}
 
     for (int i = 0; i < weights_size; i++){
-        output_path << static_cast<int>(weights[i]) << ", ";
+        output_file << static_cast<int>(weights[i]) << ", ";
     }
 };