git.sesse.net Git - stockfish/blob - src/nnue/evaluate_nnue.cpp

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
   4
   5   Stockfish is free software: you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation, either version 3 of the License, or
   8   (at your option) any later version.
   9
  10   Stockfish is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 // Code for calculating NNUE evaluation function
  20
  21 #include <iostream>
  22 #include <set>
  23 #include <sstream>
  24 #include <iomanip>
  25 #include <fstream>
  26
  27 #include "../evaluate.h"
  28 #include "../position.h"
  29 #include "../misc.h"
  30 #include "../uci.h"
  31 #include "../types.h"
  32
  33 #include "evaluate_nnue.h"
  34
  35 namespace Stockfish::Eval::NNUE {
  36
  37   // Input feature converter
  38   LargePagePtr<FeatureTransformer> featureTransformer;
  39
  40   // Evaluation function
  41   AlignedPtr<Network> network[LayerStacks];
  42
  43   // Evaluation function file name
  44   std::string fileName;
  45   std::string netDescription;
  46
  47   namespace Detail {
  48
  49   // Initialize the evaluation function parameters
  50   template <typename T>
  51   void initialize(AlignedPtr<T>& pointer) {
  52
  53     pointer.reset(reinterpret_cast<T*>(std_aligned_alloc(alignof(T), sizeof(T))));
  54     std::memset(pointer.get(), 0, sizeof(T));
  55   }
  56
  57   template <typename T>
  58   void initialize(LargePagePtr<T>& pointer) {
  59
  60     static_assert(alignof(T) <= 4096, "aligned_large_pages_alloc() may fail for such a big alignment requirement of T");
  61     pointer.reset(reinterpret_cast<T*>(aligned_large_pages_alloc(sizeof(T))));
  62     std::memset(pointer.get(), 0, sizeof(T));
  63   }
  64
  65   // Read evaluation function parameters
  66   template <typename T>
  67   bool read_parameters(std::istream& stream, T& reference) {
  68
  69     std::uint32_t header;
  70     header = read_little_endian<std::uint32_t>(stream);
  71     if (!stream || header != T::get_hash_value()) return false;
  72     return reference.read_parameters(stream);
  73   }
  74
  75   // Write evaluation function parameters
  76   template <typename T>
  77   bool write_parameters(std::ostream& stream, const T& reference) {
  78
  79     write_little_endian<std::uint32_t>(stream, T::get_hash_value());
  80     return reference.write_parameters(stream);
  81   }
  82
  83   }  // namespace Detail
  84
  85   // Initialize the evaluation function parameters
  86   void initialize() {
  87
  88     Detail::initialize(featureTransformer);
  89     for (std::size_t i = 0; i < LayerStacks; ++i)
  90       Detail::initialize(network[i]);
  91   }
  92
  93   // Read network header
  94   bool read_header(std::istream& stream, std::uint32_t* hashValue, std::string* desc)
  95   {
  96     std::uint32_t version, size;
  97
  98     version     = read_little_endian<std::uint32_t>(stream);
  99     *hashValue  = read_little_endian<std::uint32_t>(stream);
 100     size        = read_little_endian<std::uint32_t>(stream);
 101     if (!stream || version != Version) return false;
 102     desc->resize(size);
 103     stream.read(&(*desc)[0], size);
 104     return !stream.fail();
 105   }
 106
 107   // Write network header
 108   bool write_header(std::ostream& stream, std::uint32_t hashValue, const std::string& desc)
 109   {
 110     write_little_endian<std::uint32_t>(stream, Version);
 111     write_little_endian<std::uint32_t>(stream, hashValue);
 112     write_little_endian<std::uint32_t>(stream, desc.size());
 113     stream.write(&desc[0], desc.size());
 114     return !stream.fail();
 115   }
 116
 117   // Read network parameters
 118   bool read_parameters(std::istream& stream) {
 119
 120     std::uint32_t hashValue;
 121     if (!read_header(stream, &hashValue, &netDescription)) return false;
 122     if (hashValue != HashValue) return false;
 123     if (!Detail::read_parameters(stream, *featureTransformer)) return false;
 124     for (std::size_t i = 0; i < LayerStacks; ++i)
 125       if (!Detail::read_parameters(stream, *(network[i]))) return false;
 126     return stream && stream.peek() == std::ios::traits_type::eof();
 127   }
 128
 129   // Write network parameters
 130   bool write_parameters(std::ostream& stream) {
 131
 132     if (!write_header(stream, HashValue, netDescription)) return false;
 133     if (!Detail::write_parameters(stream, *featureTransformer)) return false;
 134     for (std::size_t i = 0; i < LayerStacks; ++i)
 135       if (!Detail::write_parameters(stream, *(network[i]))) return false;
 136     return (bool)stream;
 137   }
 138
 139   // Evaluation function. Perform differential calculation.
 140   Value evaluate(const Position& pos, bool adjusted) {
 141
 142     // We manually align the arrays on the stack because with gcc < 9.3
 143     // overaligning stack variables with alignas() doesn't work correctly.
 144
 145     constexpr uint64_t alignment = CacheLineSize;
 146
 147 #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
 148     TransformedFeatureType transformedFeaturesUnaligned[
 149       FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
 150     char bufferUnaligned[Network::BufferSize + alignment];
 151
 152     auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
 153     auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
 154 #else
 155     alignas(alignment)
 156       TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
 157     alignas(alignment) char buffer[Network::BufferSize];
 158 #endif
 159
 160     ASSERT_ALIGNED(transformedFeatures, alignment);
 161     ASSERT_ALIGNED(buffer, alignment);
 162
 163     const std::size_t bucket = (pos.count<ALL_PIECES>() - 1) / 4;
 164     const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
 165     const auto output = network[bucket]->propagate(transformedFeatures, buffer);
 166
 167     int materialist = psqt;
 168     int positional  = output[0];
 169
 170     int delta_npm = abs(pos.non_pawn_material(WHITE) - pos.non_pawn_material(BLACK));
 171     int entertainment = (adjusted && delta_npm <= BishopValueMg - KnightValueMg ? 7 : 0);
 172
 173     int A = 128 - entertainment;
 174     int B = 128 + entertainment;
 175
 176     int sum = (A * materialist + B * positional) / 128;
 177
 178     return static_cast<Value>( sum / OutputScale );
 179   }
 180
 181   struct NnueEvalTrace {
 182     static_assert(LayerStacks == PSQTBuckets);
 183
 184     Value psqt[LayerStacks];
 185     Value positional[LayerStacks];
 186     std::size_t correctBucket;
 187   };
 188
 189   static NnueEvalTrace trace_evaluate(const Position& pos) {
 190
 191     // We manually align the arrays on the stack because with gcc < 9.3
 192     // overaligning stack variables with alignas() doesn't work correctly.
 193
 194     constexpr uint64_t alignment = CacheLineSize;
 195
 196 #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
 197     TransformedFeatureType transformedFeaturesUnaligned[
 198       FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
 199     char bufferUnaligned[Network::BufferSize + alignment];
 200
 201     auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
 202     auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
 203 #else
 204     alignas(alignment)
 205       TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
 206     alignas(alignment) char buffer[Network::BufferSize];
 207 #endif
 208
 209     ASSERT_ALIGNED(transformedFeatures, alignment);
 210     ASSERT_ALIGNED(buffer, alignment);
 211
 212     NnueEvalTrace t{};
 213     t.correctBucket = (pos.count<ALL_PIECES>() - 1) / 4;
 214     for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket) {
 215       const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
 216       const auto output = network[bucket]->propagate(transformedFeatures, buffer);
 217
 218       int materialist = psqt;
 219       int positional  = output[0];
 220
 221       t.psqt[bucket] = static_cast<Value>( materialist / OutputScale );
 222       t.positional[bucket] = static_cast<Value>( positional / OutputScale );
 223     }
 224
 225     return t;
 226   }
 227
 228   static const std::string PieceToChar(" PNBRQK  pnbrqk");
 229
 230   // Requires the buffer to have capacity for at least 5 values
 231   static void format_cp_compact(Value v, char* buffer) {
 232
 233     buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
 234
 235     int cp = std::abs(100 * v / PawnValueEg);
 236
 237     if (cp >= 10000)
 238     {
 239       buffer[1] = '0' + cp / 10000; cp %= 10000;
 240       buffer[2] = '0' + cp / 1000; cp %= 1000;
 241       buffer[3] = '0' + cp / 100; cp %= 100;
 242       buffer[4] = ' ';
 243     }
 244     else if (cp >= 1000)
 245     {
 246       buffer[1] = '0' + cp / 1000; cp %= 1000;
 247       buffer[2] = '0' + cp / 100; cp %= 100;
 248       buffer[3] = '.';
 249       buffer[4] = '0' + cp / 10;
 250     }
 251     else
 252     {
 253       buffer[1] = '0' + cp / 100; cp %= 100;
 254       buffer[2] = '.';
 255       buffer[3] = '0' + cp / 10; cp %= 10;
 256       buffer[4] = '0' + cp / 1;
 257     }
 258   }
 259
 260   // Requires the buffer to have capacity for at least 7 values
 261   static void format_cp_aligned_dot(Value v, char* buffer) {
 262     buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
 263
 264     int cp = std::abs(100 * v / PawnValueEg);
 265
 266     if (cp >= 10000)
 267     {
 268       buffer[1] = '0' + cp / 10000; cp %= 10000;
 269       buffer[2] = '0' + cp / 1000; cp %= 1000;
 270       buffer[3] = '0' + cp / 100; cp %= 100;
 271       buffer[4] = '.';
 272       buffer[5] = '0' + cp / 10; cp %= 10;
 273       buffer[6] = '0' + cp;
 274     }
 275     else if (cp >= 1000)
 276     {
 277       buffer[1] = ' ';
 278       buffer[2] = '0' + cp / 1000; cp %= 1000;
 279       buffer[3] = '0' + cp / 100; cp %= 100;
 280       buffer[4] = '.';
 281       buffer[5] = '0' + cp / 10; cp %= 10;
 282       buffer[6] = '0' + cp;
 283     }
 284     else
 285     {
 286       buffer[1] = ' ';
 287       buffer[2] = ' ';
 288       buffer[3] = '0' + cp / 100; cp %= 100;
 289       buffer[4] = '.';
 290       buffer[5] = '0' + cp / 10; cp %= 10;
 291       buffer[6] = '0' + cp / 1;
 292     }
 293   }
 294
 295
 296   // trace() returns a string with the value of each piece on a board,
 297   // and a table for (PSQT, Layers) values bucket by bucket.
 298
 299   std::string trace(Position& pos) {
 300
 301     std::stringstream ss;
 302
 303     char board[3*8+1][8*8+2];
 304     std::memset(board, ' ', sizeof(board));
 305     for (int row = 0; row < 3*8+1; ++row)
 306       board[row][8*8+1] = '\0';
 307
 308     // A lambda to output one box of the board
 309     auto writeSquare = [&board](File file, Rank rank, Piece pc, Value value) {
 310
 311       const int x = ((int)file) * 8;
 312       const int y = (7 - (int)rank) * 3;
 313       for (int i = 1; i < 8; ++i)
 314          board[y][x+i] = board[y+3][x+i] = '-';
 315       for (int i = 1; i < 3; ++i)
 316          board[y+i][x] = board[y+i][x+8] = '|';
 317       board[y][x] = board[y][x+8] = board[y+3][x+8] = board[y+3][x] = '+';
 318       if (pc != NO_PIECE)
 319         board[y+1][x+4] = PieceToChar[pc];
 320       if (value != VALUE_NONE)
 321         format_cp_compact(value, &board[y+2][x+2]);
 322     };
 323
 324     // We estimate the value of each piece by doing a differential evaluation from
 325     // the current base eval, simulating the removal of the piece from its square.
 326     Value base = evaluate(pos);
 327     base = pos.side_to_move() == WHITE ? base : -base;
 328
 329     for (File f = FILE_A; f <= FILE_H; ++f)
 330       for (Rank r = RANK_1; r <= RANK_8; ++r)
 331       {
 332         Square sq = make_square(f, r);
 333         Piece pc = pos.piece_on(sq);
 334         Value v = VALUE_NONE;
 335
 336         if (pc != NO_PIECE && type_of(pc) != KING)
 337         {
 338           auto st = pos.state();
 339
 340           pos.remove_piece(sq);
 341           st->accumulator.computed[WHITE] = false;
 342           st->accumulator.computed[BLACK] = false;
 343
 344           Value eval = evaluate(pos);
 345           eval = pos.side_to_move() == WHITE ? eval : -eval;
 346           v = base - eval;
 347
 348           pos.put_piece(pc, sq);
 349           st->accumulator.computed[WHITE] = false;
 350           st->accumulator.computed[BLACK] = false;
 351         }
 352
 353         writeSquare(f, r, pc, v);
 354       }
 355
 356     ss << " NNUE derived piece values:\n";
 357     for (int row = 0; row < 3*8+1; ++row)
 358         ss << board[row] << '\n';
 359     ss << '\n';
 360
 361     auto t = trace_evaluate(pos);
 362
 363     ss << " NNUE network contributions "
 364        << (pos.side_to_move() == WHITE ? "(White to move)" : "(Black to move)") << std::endl
 365        << "+------------+------------+------------+------------+\n"
 366        << "|   Bucket   |  Material  | Positional |   Total    |\n"
 367        << "|            |   (PSQT)   |  (Layers)  |            |\n"
 368        << "+------------+------------+------------+------------+\n";
 369
 370     for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket)
 371     {
 372       char buffer[3][8];
 373       std::memset(buffer, '\0', sizeof(buffer));
 374
 375       format_cp_aligned_dot(t.psqt[bucket], buffer[0]);
 376       format_cp_aligned_dot(t.positional[bucket], buffer[1]);
 377       format_cp_aligned_dot(t.psqt[bucket] + t.positional[bucket], buffer[2]);
 378
 379       ss <<  "|  " << bucket    << "        "
 380          << " |  " << buffer[0] << "  "
 381          << " |  " << buffer[1] << "  "
 382          << " |  " << buffer[2] << "  "
 383          << " |";
 384       if (bucket == t.correctBucket)
 385           ss << " <-- this bucket is used";
 386       ss << '\n';
 387     }
 388
 389     ss << "+------------+------------+------------+------------+\n";
 390
 391     return ss.str();
 392   }
 393
 394
 395   // Load eval, from a file stream or a memory stream
 396   bool load_eval(std::string name, std::istream& stream) {
 397
 398     initialize();
 399     fileName = name;
 400     return read_parameters(stream);
 401   }
 402
 403   // Save eval, to a file stream or a memory stream
 404   bool save_eval(std::ostream& stream) {
 405
 406     if (fileName.empty())
 407       return false;
 408
 409     return write_parameters(stream);
 410   }
 411
 412   /// Save eval, to a file given by its name
 413   bool save_eval(const std::optional<std::string>& filename) {
 414
 415     std::string actualFilename;
 416     std::string msg;
 417
 418     if (filename.has_value())
 419         actualFilename = filename.value();
 420     else
 421     {
 422         if (eval_file_loaded != EvalFileDefaultName)
 423         {
 424              msg = "Failed to export a net. A non-embedded net can only be saved if the filename is specified";
 425
 426              sync_cout << msg << sync_endl;
 427              return false;
 428         }
 429         actualFilename = EvalFileDefaultName;
 430     }
 431
 432     std::ofstream stream(actualFilename, std::ios_base::binary);
 433     bool saved = save_eval(stream);
 434
 435     msg = saved ? "Network saved successfully to " + actualFilename
 436                 : "Failed to export a net";
 437
 438     sync_cout << msg << sync_endl;
 439     return saved;
 440   }
 441
 442
 443 } // namespace Stockfish::Eval::NNUE