2 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3 Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
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.
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.
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/>.
19 // Code for calculating NNUE evaluation function
27 #include "../evaluate.h"
28 #include "../position.h"
33 #include "evaluate_nnue.h"
35 namespace Stockfish::Eval::NNUE {
37 // Input feature converter
38 LargePagePtr<FeatureTransformer> featureTransformer;
40 // Evaluation function
41 AlignedPtr<Network> network[LayerStacks];
43 // Evaluation function file name
45 std::string netDescription;
49 // Initialize the evaluation function parameters
51 void initialize(AlignedPtr<T>& pointer) {
53 pointer.reset(reinterpret_cast<T*>(std_aligned_alloc(alignof(T), sizeof(T))));
54 std::memset(pointer.get(), 0, sizeof(T));
58 void initialize(LargePagePtr<T>& pointer) {
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));
65 // Read evaluation function parameters
67 bool read_parameters(std::istream& stream, T& reference) {
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);
75 // Write evaluation function parameters
77 bool write_parameters(std::ostream& stream, const T& reference) {
79 write_little_endian<std::uint32_t>(stream, T::get_hash_value());
80 return reference.write_parameters(stream);
85 // Initialize the evaluation function parameters
88 Detail::initialize(featureTransformer);
89 for (std::size_t i = 0; i < LayerStacks; ++i)
90 Detail::initialize(network[i]);
93 // Read network header
94 bool read_header(std::istream& stream, std::uint32_t* hashValue, std::string* desc)
96 std::uint32_t version, size;
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;
103 stream.read(&(*desc)[0], size);
104 return !stream.fail();
107 // Write network header
108 bool write_header(std::ostream& stream, std::uint32_t hashValue, const std::string& desc)
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();
117 // Read network parameters
118 bool read_parameters(std::istream& stream) {
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();
129 // Write network parameters
130 bool write_parameters(std::ostream& stream) {
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;
139 // Evaluation function. Perform differential calculation.
140 Value evaluate(const Position& pos, bool adjusted) {
142 // We manually align the arrays on the stack because with gcc < 9.3
143 // overaligning stack variables with alignas() doesn't work correctly.
145 constexpr uint64_t alignment = CacheLineSize;
147 #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
148 TransformedFeatureType transformedFeaturesUnaligned[
149 FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
150 char bufferUnaligned[Network::BufferSize + alignment];
152 auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
153 auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
156 TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
157 alignas(alignment) char buffer[Network::BufferSize];
160 ASSERT_ALIGNED(transformedFeatures, alignment);
161 ASSERT_ALIGNED(buffer, alignment);
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);
167 int materialist = psqt;
168 int positional = output[0];
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);
173 int A = 128 - entertainment;
174 int B = 128 + entertainment;
176 int sum = (A * materialist + B * positional) / 128;
178 return static_cast<Value>( sum / OutputScale );
181 struct NnueEvalTrace {
182 static_assert(LayerStacks == PSQTBuckets);
184 Value psqt[LayerStacks];
185 Value positional[LayerStacks];
186 std::size_t correctBucket;
189 static NnueEvalTrace trace_evaluate(const Position& pos) {
191 // We manually align the arrays on the stack because with gcc < 9.3
192 // overaligning stack variables with alignas() doesn't work correctly.
194 constexpr uint64_t alignment = CacheLineSize;
196 #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
197 TransformedFeatureType transformedFeaturesUnaligned[
198 FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
199 char bufferUnaligned[Network::BufferSize + alignment];
201 auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
202 auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
205 TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
206 alignas(alignment) char buffer[Network::BufferSize];
209 ASSERT_ALIGNED(transformedFeatures, alignment);
210 ASSERT_ALIGNED(buffer, alignment);
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);
218 int materialist = psqt;
219 int positional = output[0];
221 t.psqt[bucket] = static_cast<Value>( materialist / OutputScale );
222 t.positional[bucket] = static_cast<Value>( positional / OutputScale );
228 static const std::string PieceToChar(" PNBRQK pnbrqk");
230 // Requires the buffer to have capacity for at least 5 values
231 static void format_cp_compact(Value v, char* buffer) {
233 buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
235 int cp = std::abs(100 * v / PawnValueEg);
239 buffer[1] = '0' + cp / 10000; cp %= 10000;
240 buffer[2] = '0' + cp / 1000; cp %= 1000;
241 buffer[3] = '0' + cp / 100; cp %= 100;
246 buffer[1] = '0' + cp / 1000; cp %= 1000;
247 buffer[2] = '0' + cp / 100; cp %= 100;
249 buffer[4] = '0' + cp / 10;
253 buffer[1] = '0' + cp / 100; cp %= 100;
255 buffer[3] = '0' + cp / 10; cp %= 10;
256 buffer[4] = '0' + cp / 1;
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 ? '+' : ' ');
264 int cp = std::abs(100 * v / PawnValueEg);
268 buffer[1] = '0' + cp / 10000; cp %= 10000;
269 buffer[2] = '0' + cp / 1000; cp %= 1000;
270 buffer[3] = '0' + cp / 100; cp %= 100;
272 buffer[5] = '0' + cp / 10; cp %= 10;
273 buffer[6] = '0' + cp;
278 buffer[2] = '0' + cp / 1000; cp %= 1000;
279 buffer[3] = '0' + cp / 100; cp %= 100;
281 buffer[5] = '0' + cp / 10; cp %= 10;
282 buffer[6] = '0' + cp;
288 buffer[3] = '0' + cp / 100; cp %= 100;
290 buffer[5] = '0' + cp / 10; cp %= 10;
291 buffer[6] = '0' + cp / 1;
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.
299 std::string trace(Position& pos) {
301 std::stringstream ss;
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';
308 // A lambda to output one box of the board
309 auto writeSquare = [&board](File file, Rank rank, Piece pc, Value value) {
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] = '+';
319 board[y+1][x+4] = PieceToChar[pc];
320 if (value != VALUE_NONE)
321 format_cp_compact(value, &board[y+2][x+2]);
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;
329 for (File f = FILE_A; f <= FILE_H; ++f)
330 for (Rank r = RANK_1; r <= RANK_8; ++r)
332 Square sq = make_square(f, r);
333 Piece pc = pos.piece_on(sq);
334 Value v = VALUE_NONE;
336 if (pc != NO_PIECE && type_of(pc) != KING)
338 auto st = pos.state();
340 pos.remove_piece(sq);
341 st->accumulator.computed[WHITE] = false;
342 st->accumulator.computed[BLACK] = false;
344 Value eval = evaluate(pos);
345 eval = pos.side_to_move() == WHITE ? eval : -eval;
348 pos.put_piece(pc, sq);
349 st->accumulator.computed[WHITE] = false;
350 st->accumulator.computed[BLACK] = false;
353 writeSquare(f, r, pc, v);
356 ss << " NNUE derived piece values:\n";
357 for (int row = 0; row < 3*8+1; ++row)
358 ss << board[row] << '\n';
361 auto t = trace_evaluate(pos);
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";
370 for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket)
373 std::memset(buffer, '\0', sizeof(buffer));
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]);
379 ss << "| " << bucket << " "
380 << " | " << buffer[0] << " "
381 << " | " << buffer[1] << " "
382 << " | " << buffer[2] << " "
384 if (bucket == t.correctBucket)
385 ss << " <-- this bucket is used";
389 ss << "+------------+------------+------------+------------+\n";
395 // Load eval, from a file stream or a memory stream
396 bool load_eval(std::string name, std::istream& stream) {
400 return read_parameters(stream);
403 // Save eval, to a file stream or a memory stream
404 bool save_eval(std::ostream& stream) {
406 if (fileName.empty())
409 return write_parameters(stream);
412 /// Save eval, to a file given by its name
413 bool save_eval(const std::optional<std::string>& filename) {
415 std::string actualFilename;
418 if (filename.has_value())
419 actualFilename = filename.value();
422 if (eval_file_loaded != EvalFileDefaultName)
424 msg = "Failed to export a net. A non-embedded net can only be saved if the filename is specified";
426 sync_cout << msg << sync_endl;
429 actualFilename = EvalFileDefaultName;
432 std::ofstream stream(actualFilename, std::ios_base::binary);
433 bool saved = save_eval(stream);
435 msg = saved ? "Network saved successfully to " + actualFilename
436 : "Failed to export a net";
438 sync_cout << msg << sync_endl;
443 } // namespace Stockfish::Eval::NNUE