nnue/evaluate_nnue.cpp nnue/features/half_ka_v2_hm.cpp

nnue/evaluate_nnue.h nnue/features/half_ka_v2_hm.h nnue/layers/affine_transform.h \

tt.h tune.h types.h uci.h ucioption.h perft.h

CXXFLAGS += -stdlib=libc++ -fPIE

#include <fstream>

#include <optional>

#include <unordered_map>

#include <vector>

#include "incbin/incbin.h"

#include "misc.h"

#include "nnue/evaluate_nnue.h"

#include "nnue/nnue_architecture.h"

#include "ucioption.h"

// Macro to embed the default efficiently updatable neural network (NNUE) file

// data in the engine binary (using incbin.h, by Dale Weiler).

// This macro invocation will declare the following three variables

// const unsigned char gEmbeddedNNUEData[]; // a pointer to the embedded data

// const unsigned char *const gEmbeddedNNUEEnd; // a marker to the end

// const unsigned int gEmbeddedNNUESize; // the size of the embedded file

// Note that this does not work in Microsoft Visual Studio.

#if !defined(_MSC_VER) && !defined(NNUE_EMBEDDING_OFF)

INCBIN(EmbeddedNNUEBig, EvalFileDefaultNameBig);

INCBIN(EmbeddedNNUESmall, EvalFileDefaultNameSmall);

#else

const unsigned char gEmbeddedNNUEBigData[1] = {0x0};

const unsigned char* const gEmbeddedNNUEBigEnd = &gEmbeddedNNUEBigData[1];

const unsigned int gEmbeddedNNUEBigSize = 1;

const unsigned char gEmbeddedNNUESmallData[1] = {0x0};

const unsigned char* const gEmbeddedNNUESmallEnd = &gEmbeddedNNUESmallData[1];

const unsigned int gEmbeddedNNUESmallSize = 1;

#endif

namespace Eval {

// Tries to load a NNUE network at startup time, or when the engine

// receives a UCI command "setoption name EvalFile value nn-[a-z0-9]{12}.nnue"

// The name of the NNUE network is always retrieved from the EvalFile option.

// We search the given network in three locations: internally (the default

// network may be embedded in the binary), in the active working directory and

// in the engine directory. Distro packagers may define the DEFAULT_NNUE_DIRECTORY

// variable to have the engine search in a special directory in their distro.

NNUE::EvalFiles NNUE::load_networks(const std::string& rootDirectory,

const OptionsMap& options,

NNUE::EvalFiles evalFiles) {

for (auto& [netSize, evalFile] : evalFiles)

{

std::string user_eval_file = options[evalFile.optionName];

if (user_eval_file.empty())

user_eval_file = evalFile.defaultName;

#if defined(DEFAULT_NNUE_DIRECTORY)

std::vector<std::string> dirs = {"<internal>", "", rootDirectory,

stringify(DEFAULT_NNUE_DIRECTORY)};

#else

std::vector<std::string> dirs = {"<internal>", "", rootDirectory};

#endif

for (const std::string& directory : dirs)

{

if (evalFile.current != user_eval_file)

{

if (directory != "<internal>")

{

std::ifstream stream(directory + user_eval_file, std::ios::binary);

auto description = NNUE::load_eval(stream, netSize);

if (description.has_value())

{

evalFile.current = user_eval_file;

evalFile.netDescription = description.value();

}

}

if (directory == "<internal>" && user_eval_file == evalFile.defaultName)

{

// C++ way to prepare a buffer for a memory stream

class MemoryBuffer: public std::basic_streambuf<char> {

public:

MemoryBuffer(char* p, size_t n) {

setg(p, p, p + n);

setp(p, p + n);

}

};

MemoryBuffer buffer(

const_cast<char*>(reinterpret_cast<const char*>(

netSize == Small ? gEmbeddedNNUESmallData : gEmbeddedNNUEBigData)),

size_t(netSize == Small ? gEmbeddedNNUESmallSize : gEmbeddedNNUEBigSize));

(void) gEmbeddedNNUEBigEnd; // Silence warning on unused variable

(void) gEmbeddedNNUESmallEnd;

std::istream stream(&buffer);

auto description = NNUE::load_eval(stream, netSize);

if (description.has_value())

{

evalFile.current = user_eval_file;

evalFile.netDescription = description.value();

}

}

}

}

}

return evalFiles;

}

// Verifies that the last net used was loaded successfully

void NNUE::verify(const OptionsMap& options,

const std::unordered_map<Eval::NNUE::NetSize, EvalFile>& evalFiles) {

for (const auto& [netSize, evalFile] : evalFiles)

{

std::string user_eval_file = options[evalFile.optionName];

if (user_eval_file.empty())

user_eval_file = evalFile.defaultName;

if (evalFile.current != user_eval_file)

{

std::string msg1 =

"Network evaluation parameters compatible with the engine must be available.";

std::string msg2 =

"The network file " + user_eval_file + " was not loaded successfully.";

std::string msg3 = "The UCI option EvalFile might need to specify the full path, "

"including the directory name, to the network file.";

std::string msg4 = "The default net can be downloaded from: "

"https://tests.stockfishchess.org/api/nn/"

+ evalFile.defaultName;

std::string msg5 = "The engine will be terminated now.";

sync_cout << "info string ERROR: " << msg1 << sync_endl;

sync_cout << "info string ERROR: " << msg2 << sync_endl;

sync_cout << "info string ERROR: " << msg3 << sync_endl;

sync_cout << "info string ERROR: " << msg4 << sync_endl;

sync_cout << "info string ERROR: " << msg5 << sync_endl;

exit(EXIT_FAILURE);

}

sync_cout << "info string NNUE evaluation using " << user_eval_file << sync_endl;

}

}

}

Value Eval::evaluate(const Position& pos, int optimism) {

Value nnue = smallNet ? NNUE::evaluate<NNUE::Small>(pos, true, &nnueComplexity, psqtOnly)

: NNUE::evaluate<NNUE::Big>(pos, true, &nnueComplexity, false);

std::string Eval::trace(Position& pos) {

ss << '\n' << NNUE::trace(pos) << '\n';

Value v;

v = NNUE::evaluate<NNUE::Big>(pos, false);

v = pos.side_to_move() == WHITE ? v : -v;

v = evaluate(pos, VALUE_ZERO);

#include <unordered_map>

class OptionsMap;

std::string trace(Position& pos);

int simple_eval(const Position& pos, Color c);

Value evaluate(const Position& pos, int optimism);

// name of the macro, as it is used in the Makefile.

struct EvalFile {

// UCI option name

std::string optionName;

// Default net name, will use one of the macros above

std::string defaultName;

// Selected net name, either via uci option or default

std::string current;

// Net description extracted from the net file

std::string netDescription;

};

enum NetSize : int;

using EvalFiles = std::unordered_map<Eval::NNUE::NetSize, EvalFile>;

EvalFiles load_networks(const std::string&, const OptionsMap&, EvalFiles);

void verify(const OptionsMap&, const EvalFiles&);

} // namespace NNUE

#include "evaluate.h"

uci.evalFiles = Eval::NNUE::load_networks(uci.working_directory(), uci.options, uci.evalFiles);