Cleanup

Bench: 2525875

src/core/bitboard.h

@@ -19,9 +19,9 @@
 
 #include "constants.h"
 
+#include <bit>
 #include <cassert>
 #include <immintrin.h>
-#include <bit>
 
 #ifdef _MSC_VER
 #include <intrin.h>

src/core/board.h

@@ -17,12 +17,12 @@
 
 #pragma once
 
+#include "../network/nnue.h"
 #include "../utils/utilities.h"
 #include "attacks.h"
 #include "bitboard.h"
 #include "board_state.h"
 #include "move.h"
-#include "../network/nnue.h"
 
 #include <algorithm>
 #include <sstream>

src/main.cpp

@@ -61,7 +61,7 @@ int main(int argc, char *argv[]) {
         test::run();
     } else if (mode == "bench") {
         run_bench();
-    }  else {
+    } else {
         uci::UCI protocol;
         protocol.start();
     }

src/network/adam.h

@@ -23,7 +23,6 @@ namespace nn {
 
     class Adam {
     public:
-
         Adam(float learning_rate) : LR(learning_rate), m_gradient(), v_gradient() {}
 
         void update(const std::vector<Gradient> &gradients, Network &network) {
@@ -67,4 +66,4 @@ namespace nn {
         }
     };
 
-}
+} // namespace nn

src/network/data_parser.h

@@ -38,7 +38,6 @@ namespace nn {
 
     class DataParser {
     public:
-
         DataParser(const std::string &path) {
             file.open(path, std::ios::in);
         }
@@ -58,7 +57,6 @@ namespace nn {
         }
 
     private:
-
         std::ifstream file;
 
         TrainingEntry parse_entry(const std::string &entry) {
@@ -85,7 +83,7 @@ namespace nn {
             for (; idx < fen.size() && fen[idx] != ' '; idx++) {
                 char c = fen[idx];
                 if ('1' <= c && c <= '8') {
-                    sq += c-'0';
+                    sq += c - '0';
                 } else if (c == '/') {
                     sq -= 16;
                 } else {
@@ -98,8 +96,10 @@ namespace nn {
 
             Color stm = COLOR_EMPTY;
             idx++;
-            if (fen[idx] == 'w') stm = WHITE;
-            else if (fen[idx] == 'b') stm = BLACK;
+            if (fen[idx] == 'w')
+                stm = WHITE;
+            else if (fen[idx] == 'b')
+                stm = BLACK;
             else {
                 throw 1;
             }
@@ -111,4 +111,4 @@ namespace nn {
             return res;
         }
     };
-}
+} // namespace nn

src/network/layers/accumulator.h

@@ -19,10 +19,11 @@
 
 #include "../activations/none.h"
 
+#include <array>
+#include <cstring>
+#include <fstream>
 #include <type_traits>
 #include <vector>
-#include <cstring>
-#include <array>
 
 namespace nn::layers {
 
@@ -32,7 +33,6 @@ namespace nn::layers {
         static_assert(std::is_invocable_r_v<T, decltype(ACTIVATION::forward), T>, "Invalid ACTIVATION::forward");
 
     public:
-
         void load_from_file(std::ifstream &file) {
             file.read(reinterpret_cast<char *>(biases.data()), sizeof(biases));
             file.read(reinterpret_cast<char *>(weights.data()), sizeof(weights));
@@ -73,7 +73,6 @@ namespace nn::layers {
         }
 
     private:
-
         std::array<T, OUT> accumulator;
         std::array<T, OUT> biases;
         std::array<T, IN * OUT> weights;
@@ -82,4 +81,4 @@ namespace nn::layers {
             std::copy(biases.begin(), biases.end(), accumulator.begin());
         }
     };
-}
+} // namespace nn::layers

src/network/layers/dense_layer.h

@@ -18,11 +18,11 @@
 #pragma once
 
 #include <array>
+#include <cstring>
 #include <functional>
+#include <random>
 #include <thread>
 #include <vector>
-#include <random>
-#include <cstring>
 
 #include "../activations/none.h"
 
@@ -51,7 +51,6 @@ namespace nn::layers {
     template<unsigned int IN, unsigned int OUT, typename T, typename T2, typename ACTIVATION = activations::none<T>>
     class DenseLayer {
     private:
-
         static_assert(std::is_invocable_r_v<T2, decltype(ACTIVATION::forward), T2>, "Invalid ACTIVATION::forward");
         static_assert(std::is_invocable_r_v<T2, decltype(ACTIVATION::backward), T2>, "Invalid ACTIVATION::backward");
 
@@ -62,7 +61,6 @@ namespace nn::layers {
         }
 
     public:
-
         std::array<T, OUT> biases;
         std::array<T, IN * OUT> weights;
 

src/network/network.h

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include "activations/relu.h"
 #include "activations/crelu.h"
+#include "activations/relu.h"
 #include "activations/sigmoid.h"
 #include "layers/dense_layer.h"
 
@@ -119,6 +119,5 @@ namespace nn {
 
             file.close();
         }
-
     };
 } // namespace nn

src/network/nnue.h

@@ -17,10 +17,14 @@
 
 #pragma once
 
+#include "../external/incbin/incbin.h"
+#include "../core/constants.h"
+#include "../utils/logger.h"
 #include "activations/crelu.h"
 #include "layers/accumulator.h"
 #include "layers/dense_layer.h"
-#include "../external/incbin/incbin.h"
+
+#include <cassert>
 
 namespace nn {
 
@@ -29,11 +33,10 @@ namespace nn {
     class NNUE {
 
     public:
-
         static constexpr int QSCALE = 64;
 
         NNUE() {
-            const unsigned char* data = gDefaultNetworkData;
+            const unsigned char *data = gDefaultNetworkData;
 
             int magic;
             std::memcpy(&magic, data, sizeof(int));
@@ -110,4 +113,4 @@ namespace nn {
         layers::DenseLayer<L1_SIZE, 1, int16_t, int32_t, activations::none<int16_t>> l1;
     };
 
-}
+} // namespace nn

src/network/train.h

@@ -18,8 +18,8 @@
 #pragma once
 
 #include "../utils/logger.h"
-#include "data_parser.h"
 #include "adam.h"
+#include "data_parser.h"
 
 #include <filesystem>
 #include <optional>
@@ -32,7 +32,6 @@ namespace nn {
 
     class Trainer {
     public:
-
         Trainer(const std::string &training_data, const std::string &validation_data, const std::optional<std::string> &network_path, float learning_rate, int epochs, int batch_size, int thread_count) :
         adam(learning_rate), training_parser(training_data), validation_parser(validation_data), batch_size(batch_size), thread_count(thread_count) {
 
@@ -71,7 +70,8 @@ namespace nn {
 
                 while (!is_new_epoch) {
                     iter++;
-                    epoch_iter++; checkpoint_iter++;
+                    epoch_iter++;
+                    checkpoint_iter++;
 
                     delete[] entries;
                     entries = entries_next;
@@ -203,8 +203,8 @@ namespace nn {
                 network.forward(entry.features, l0_output, l1_output, entry.phase);
                 float prediction = l1_output[0];
 
-                float error = (1.0f - EVAL_INFLUENCE) * (prediction - entry.wdl) * (prediction - entry.wdl)
-                              + EVAL_INFLUENCE * (prediction - entry.eval) * (prediction - entry.eval);
+                float error = (1.0f - EVAL_INFLUENCE) * (prediction - entry.wdl) * (prediction - entry.wdl) +
+                              EVAL_INFLUENCE * (prediction - entry.eval) * (prediction - entry.eval);
                 errors[id] += error;
                 accuracy[id] += ((entry.wdl - 0.5f) * (prediction - 0.5f) > 0.0f) || std::abs(entry.wdl - prediction) < 0.05f;
 
@@ -232,4 +232,4 @@ namespace nn {
             logger.print("Found", entry_count, "positions");
         }
     };
-}
+} // namespace nn

src/selfplay/selfplay.h

@@ -20,9 +20,9 @@
 #include "engine.h"
 
 #include <ctime>
-#include <random>
 #include <filesystem>
 #include <iomanip>
+#include <random>
 #include <sstream>
 
 namespace selfplay {
@@ -126,7 +126,7 @@ namespace selfplay {
         logger.print("Combining files...");
 
         std::ofstream file(output_file, std::ios::app | std::ios::out);
-        for (const auto& entry : std::filesystem::directory_iterator(path)) {
+        for (const auto &entry : std::filesystem::directory_iterator(path)) {
             std::ifstream in(entry.path());
             std::string tmp;
             while (std::getline(in, tmp)) {
@@ -165,7 +165,7 @@ namespace selfplay {
 
         std::random_device rd;
         std::mt19937 g(rd());
-        std::uniform_int_distribution<int> dist(0, dropout-1);
+        std::uniform_int_distribution<int> dist(0, dropout - 1);
 
         while (std::getline(book, tmp)) {
             if (dist(g) == 0)

src/uci/uci.h

@@ -18,12 +18,12 @@
 #pragma once
 
 #include "../core/board.h"
+#include "../network/train.h"
 #include "../search/search_manager.h"
 #include "../selfplay/selfplay.h"
-#include "../network/train.h"
 #include "../tests/perft.h"
-#include "../utils/split.h"
 #include "../utils/logger.h"
+#include "../utils/split.h"
 #include "../utils/utilities.h"
 #include "command.h"
 #include "option.h"
@@ -87,7 +87,7 @@ namespace uci {
         commands.emplace_back("display", [&](context tokens) {
             board.display();
         });
-        commands.emplace_back("eval", [&](context tokens){
+        commands.emplace_back("eval", [&](context tokens) {
             nn::NNUE network{};
             network.refresh(board.to_features());
             logger.print("Eval:", network.evaluate(board.get_stm()));
@@ -102,20 +102,20 @@ namespace uci {
             std::optional<int> dropout = find_element<int>(tokens, "dropout");
             selfplay::start_generation(limits, book.value_or("book.epd"), output.value_or("data.plain"), thread_count.value_or(1), dropout.value_or(1));
         });
-        commands.emplace_back("split", [&](context tokens){
+        commands.emplace_back("split", [&](context tokens) {
             std::optional<std::string> input_data = find_element<std::string>(tokens, "input");
             std::optional<std::string> output_data1 = find_element<std::string>(tokens, "output1");
             std::optional<std::string> output_data2 = find_element<std::string>(tokens, "output2");
             std::optional<int> rate = find_element<int>(tokens, "rate");
             split_data(input_data.value_or("data.plain"), output_data1.value_or("train.plain"), output_data2.value_or("validation.plain"), rate.value_or(10));
         });
-        commands.emplace_back("quantize", [&](context tokens){
+        commands.emplace_back("quantize", [&](context tokens) {
             std::optional<std::string> input = find_element<std::string>(tokens, "input");
             std::optional<std::string> output = find_element<std::string>(tokens, "output");
             nn::Network network_file(input.value_or("input.bin"));
             network_file.quantize<int16_t, nn::NNUE::QSCALE>(output.value_or("output.bin"));
         });
-        commands.emplace_back("train", [&](context tokens){
+        commands.emplace_back("train", [&](context tokens) {
             std::optional<std::string> network_path = find_element<std::string>(tokens, "network");
             std::optional<std::string> training_data = find_element<std::string>(tokens, "training_data");
             std::optional<std::string> validation_data = find_element<std::string>(tokens, "validation_data");

src/utils/split.h

@@ -30,8 +30,10 @@ inline void split_data(const std::string &input, const std::string &output1, con
 
     std::string line;
     while (std::getline(in, line)) {
-        if (dist(g) == 0) out2 << line << "\n";
-        else out1 << line << "\n";
+        if (dist(g) == 0)
+            out2 << line << "\n";
+        else
+            out1 << line << "\n";
     }
 
     in.close();