7f5925a7c683b207ce7eb30ab7a6d1379856e65d
[stockfish] / 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 <= RookValueMg - BishopValueMg ? 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
231   // format_cp_compact() converts a Value into (centi)pawns and writes it in a buffer.
232   // The buffer must have capacity for at least 5 chars.
233   static void format_cp_compact(Value v, char* buffer) {
234
235     buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
236
237     int cp = std::abs(100 * v / PawnValueEg);
238     if (cp >= 10000)
239     {
240         buffer[1] = '0' + cp / 10000; cp %= 10000;
241         buffer[2] = '0' + cp / 1000; cp %= 1000;
242         buffer[3] = '0' + cp / 100; cp %= 100;
243         buffer[4] = ' ';
244     }
245     else if (cp >= 1000)
246     {
247         buffer[1] = '0' + cp / 1000; cp %= 1000;
248         buffer[2] = '0' + cp / 100; cp %= 100;
249         buffer[3] = '.';
250         buffer[4] = '0' + cp / 10;
251     }
252     else
253     {
254         buffer[1] = '0' + cp / 100; cp %= 100;
255         buffer[2] = '.';
256         buffer[3] = '0' + cp / 10; cp %= 10;
257         buffer[4] = '0' + cp / 1;
258     }
259   }
260
261
262   // format_cp_aligned_dot() converts a Value into (centi)pawns and writes it in a buffer,
263   // always keeping two decimals. The buffer must have capacity for at least 7 chars.
264   static void format_cp_aligned_dot(Value v, char* buffer) {
265
266     buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
267
268     double cp = 1.0 * std::abs(int(v)) / PawnValueEg;
269     sprintf(&buffer[1], "%6.2f", cp);
270   }
271
272
273   // trace() returns a string with the value of each piece on a board,
274   // and a table for (PSQT, Layers) values bucket by bucket.
275
276   std::string trace(Position& pos) {
277
278     std::stringstream ss;
279
280     char board[3*8+1][8*8+2];
281     std::memset(board, ' ', sizeof(board));
282     for (int row = 0; row < 3*8+1; ++row)
283       board[row][8*8+1] = '\0';
284
285     // A lambda to output one box of the board
286     auto writeSquare = [&board](File file, Rank rank, Piece pc, Value value) {
287
288       const int x = ((int)file) * 8;
289       const int y = (7 - (int)rank) * 3;
290       for (int i = 1; i < 8; ++i)
291          board[y][x+i] = board[y+3][x+i] = '-';
292       for (int i = 1; i < 3; ++i)
293          board[y+i][x] = board[y+i][x+8] = '|';
294       board[y][x] = board[y][x+8] = board[y+3][x+8] = board[y+3][x] = '+';
295       if (pc != NO_PIECE)
296         board[y+1][x+4] = PieceToChar[pc];
297       if (value != VALUE_NONE)
298         format_cp_compact(value, &board[y+2][x+2]);
299     };
300
301     // We estimate the value of each piece by doing a differential evaluation from
302     // the current base eval, simulating the removal of the piece from its square.
303     Value base = evaluate(pos);
304     base = pos.side_to_move() == WHITE ? base : -base;
305
306     for (File f = FILE_A; f <= FILE_H; ++f)
307       for (Rank r = RANK_1; r <= RANK_8; ++r)
308       {
309         Square sq = make_square(f, r);
310         Piece pc = pos.piece_on(sq);
311         Value v = VALUE_NONE;
312
313         if (pc != NO_PIECE && type_of(pc) != KING)
314         {
315           auto st = pos.state();
316
317           pos.remove_piece(sq);
318           st->accumulator.computed[WHITE] = false;
319           st->accumulator.computed[BLACK] = false;
320
321           Value eval = evaluate(pos);
322           eval = pos.side_to_move() == WHITE ? eval : -eval;
323           v = base - eval;
324
325           pos.put_piece(pc, sq);
326           st->accumulator.computed[WHITE] = false;
327           st->accumulator.computed[BLACK] = false;
328         }
329
330         writeSquare(f, r, pc, v);
331       }
332
333     ss << " NNUE derived piece values:\n";
334     for (int row = 0; row < 3*8+1; ++row)
335         ss << board[row] << '\n';
336     ss << '\n';
337
338     auto t = trace_evaluate(pos);
339
340     ss << " NNUE network contributions "
341        << (pos.side_to_move() == WHITE ? "(White to move)" : "(Black to move)") << std::endl
342        << "+------------+------------+------------+------------+\n"
343        << "|   Bucket   |  Material  | Positional |   Total    |\n"
344        << "|            |   (PSQT)   |  (Layers)  |            |\n"
345        << "+------------+------------+------------+------------+\n";
346
347     for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket)
348     {
349       char buffer[3][8];
350       std::memset(buffer, '\0', sizeof(buffer));
351
352       format_cp_aligned_dot(t.psqt[bucket], buffer[0]);
353       format_cp_aligned_dot(t.positional[bucket], buffer[1]);
354       format_cp_aligned_dot(t.psqt[bucket] + t.positional[bucket], buffer[2]);
355
356       ss <<  "|  " << bucket    << "        "
357          << " |  " << buffer[0] << "  "
358          << " |  " << buffer[1] << "  "
359          << " |  " << buffer[2] << "  "
360          << " |";
361       if (bucket == t.correctBucket)
362           ss << " <-- this bucket is used";
363       ss << '\n';
364     }
365
366     ss << "+------------+------------+------------+------------+\n";
367
368     return ss.str();
369   }
370
371
372   // Load eval, from a file stream or a memory stream
373   bool load_eval(std::string name, std::istream& stream) {
374
375     initialize();
376     fileName = name;
377     return read_parameters(stream);
378   }
379
380   // Save eval, to a file stream or a memory stream
381   bool save_eval(std::ostream& stream) {
382
383     if (fileName.empty())
384       return false;
385
386     return write_parameters(stream);
387   }
388
389   /// Save eval, to a file given by its name
390   bool save_eval(const std::optional<std::string>& filename) {
391
392     std::string actualFilename;
393     std::string msg;
394
395     if (filename.has_value())
396         actualFilename = filename.value();
397     else
398     {
399         if (currentEvalFileName != EvalFileDefaultName)
400         {
401              msg = "Failed to export a net. A non-embedded net can only be saved if the filename is specified";
402
403              sync_cout << msg << sync_endl;
404              return false;
405         }
406         actualFilename = EvalFileDefaultName;
407     }
408
409     std::ofstream stream(actualFilename, std::ios_base::binary);
410     bool saved = save_eval(stream);
411
412     msg = saved ? "Network saved successfully to " + actualFilename
413                 : "Failed to export a net";
414
415     sync_cout << msg << sync_endl;
416     return saved;
417   }
418
419
420 } // namespace Stockfish::Eval::NNUE