/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
- Copyright (C) 2004-2020 The Stockfish developers (see AUTHORS file)
+ Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "evaluate_nnue.h"
-namespace Eval::NNUE {
-
- const uint32_t kpp_board_index[PIECE_NB][COLOR_NB] = {
- // convention: W - us, B - them
- // viewed from other side, W and B are reversed
- { PS_NONE, PS_NONE },
- { PS_W_PAWN, PS_B_PAWN },
- { PS_W_KNIGHT, PS_B_KNIGHT },
- { PS_W_BISHOP, PS_B_BISHOP },
- { PS_W_ROOK, PS_B_ROOK },
- { PS_W_QUEEN, PS_B_QUEEN },
- { PS_W_KING, PS_B_KING },
- { PS_NONE, PS_NONE },
- { PS_NONE, PS_NONE },
- { PS_B_PAWN, PS_W_PAWN },
- { PS_B_KNIGHT, PS_W_KNIGHT },
- { PS_B_BISHOP, PS_W_BISHOP },
- { PS_B_ROOK, PS_W_ROOK },
- { PS_B_QUEEN, PS_W_QUEEN },
- { PS_B_KING, PS_W_KING },
- { PS_NONE, PS_NONE }
- };
+namespace Stockfish::Eval::NNUE {
// Input feature converter
- LargePagePtr<FeatureTransformer> feature_transformer;
+ LargePagePtr<FeatureTransformer> featureTransformer;
// Evaluation function
- AlignedPtr<Network> network;
+ AlignedPtr<Network> network[LayerStacks];
// Evaluation function file name
std::string fileName;
+ std::string netDescription;
namespace Detail {
// Initialize the evaluation function parameters
template <typename T>
- void Initialize(AlignedPtr<T>& pointer) {
+ void initialize(AlignedPtr<T>& pointer) {
pointer.reset(reinterpret_cast<T*>(std_aligned_alloc(alignof(T), sizeof(T))));
std::memset(pointer.get(), 0, sizeof(T));
}
template <typename T>
- void Initialize(LargePagePtr<T>& pointer) {
+ void initialize(LargePagePtr<T>& pointer) {
static_assert(alignof(T) <= 4096, "aligned_large_pages_alloc() may fail for such a big alignment requirement of T");
pointer.reset(reinterpret_cast<T*>(aligned_large_pages_alloc(sizeof(T))));
// Read evaluation function parameters
template <typename T>
- bool ReadParameters(std::istream& stream, T& reference) {
+ bool read_parameters(std::istream& stream, T& reference) {
std::uint32_t header;
header = read_little_endian<std::uint32_t>(stream);
- if (!stream || header != T::GetHashValue()) return false;
- return reference.ReadParameters(stream);
+ if (!stream || header != T::get_hash_value()) return false;
+ return reference.read_parameters(stream);
+ }
+
+ // Write evaluation function parameters
+ template <typename T>
+ bool write_parameters(std::ostream& stream, const T& reference) {
+
+ write_little_endian<std::uint32_t>(stream, T::get_hash_value());
+ return reference.write_parameters(stream);
}
} // namespace Detail
// Initialize the evaluation function parameters
- void Initialize() {
+ void initialize() {
- Detail::Initialize(feature_transformer);
- Detail::Initialize(network);
+ Detail::initialize(featureTransformer);
+ for (std::size_t i = 0; i < LayerStacks; ++i)
+ Detail::initialize(network[i]);
}
// Read network header
- bool ReadHeader(std::istream& stream, std::uint32_t* hash_value, std::string* architecture)
+ bool read_header(std::istream& stream, std::uint32_t* hashValue, std::string* desc)
{
std::uint32_t version, size;
version = read_little_endian<std::uint32_t>(stream);
- *hash_value = read_little_endian<std::uint32_t>(stream);
+ *hashValue = read_little_endian<std::uint32_t>(stream);
size = read_little_endian<std::uint32_t>(stream);
- if (!stream || version != kVersion) return false;
- architecture->resize(size);
- stream.read(&(*architecture)[0], size);
+ if (!stream || version != Version) return false;
+ desc->resize(size);
+ stream.read(&(*desc)[0], size);
+ return !stream.fail();
+ }
+
+ // Write network header
+ bool write_header(std::ostream& stream, std::uint32_t hashValue, const std::string& desc)
+ {
+ write_little_endian<std::uint32_t>(stream, Version);
+ write_little_endian<std::uint32_t>(stream, hashValue);
+ write_little_endian<std::uint32_t>(stream, desc.size());
+ stream.write(&desc[0], desc.size());
return !stream.fail();
}
// Read network parameters
- bool ReadParameters(std::istream& stream) {
-
- std::uint32_t hash_value;
- std::string architecture;
- if (!ReadHeader(stream, &hash_value, &architecture)) return false;
- if (hash_value != kHashValue) return false;
- if (!Detail::ReadParameters(stream, *feature_transformer)) return false;
- if (!Detail::ReadParameters(stream, *network)) return false;
+ bool read_parameters(std::istream& stream) {
+
+ std::uint32_t hashValue;
+ if (!read_header(stream, &hashValue, &netDescription)) return false;
+ if (hashValue != HashValue) return false;
+ if (!Detail::read_parameters(stream, *featureTransformer)) return false;
+ for (std::size_t i = 0; i < LayerStacks; ++i)
+ if (!Detail::read_parameters(stream, *(network[i]))) return false;
return stream && stream.peek() == std::ios::traits_type::eof();
}
+ // Write network parameters
+ bool write_parameters(std::ostream& stream) {
+
+ if (!write_header(stream, HashValue, netDescription)) return false;
+ if (!Detail::write_parameters(stream, *featureTransformer)) return false;
+ for (std::size_t i = 0; i < LayerStacks; ++i)
+ if (!Detail::write_parameters(stream, *(network[i]))) return false;
+ return (bool)stream;
+ }
+
// Evaluation function. Perform differential calculation.
- Value evaluate(const Position& pos) {
+ Value evaluate(const Position& pos, bool adjusted) {
// We manually align the arrays on the stack because with gcc < 9.3
// overaligning stack variables with alignas() doesn't work correctly.
- constexpr uint64_t alignment = kCacheLineSize;
+ constexpr uint64_t alignment = CacheLineSize;
#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
- TransformedFeatureType transformed_features_unaligned[
- FeatureTransformer::kBufferSize + alignment / sizeof(TransformedFeatureType)];
- char buffer_unaligned[Network::kBufferSize + alignment];
+ TransformedFeatureType transformedFeaturesUnaligned[
+ FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
+ char bufferUnaligned[Network::BufferSize + alignment];
- auto* transformed_features = align_ptr_up<alignment>(&transformed_features_unaligned[0]);
- auto* buffer = align_ptr_up<alignment>(&buffer_unaligned[0]);
+ auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
+ auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
#else
alignas(alignment)
- TransformedFeatureType transformed_features[FeatureTransformer::kBufferSize];
- alignas(alignment) char buffer[Network::kBufferSize];
+ TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
+ alignas(alignment) char buffer[Network::BufferSize];
#endif
- ASSERT_ALIGNED(transformed_features, alignment);
+ ASSERT_ALIGNED(transformedFeatures, alignment);
ASSERT_ALIGNED(buffer, alignment);
- feature_transformer->Transform(pos, transformed_features);
- const auto output = network->Propagate(transformed_features, buffer);
+ const std::size_t bucket = (pos.count<ALL_PIECES>() - 1) / 4;
+ const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
+ const auto output = network[bucket]->propagate(transformedFeatures, buffer);
+
+ int materialist = psqt;
+ int positional = output[0];
+
+ int delta_npm = abs(pos.non_pawn_material(WHITE) - pos.non_pawn_material(BLACK));
+ int entertainment = (adjusted && delta_npm <= BishopValueMg - KnightValueMg ? 7 : 0);
+
+ int A = 128 - entertainment;
+ int B = 128 + entertainment;
+
+ int sum = (A * materialist + B * positional) / 128;
- return static_cast<Value>(output[0] / FV_SCALE);
+ return static_cast<Value>( sum / OutputScale );
}
// Load eval, from a file stream or a memory stream
bool load_eval(std::string name, std::istream& stream) {
- Initialize();
+ initialize();
fileName = name;
- return ReadParameters(stream);
+ return read_parameters(stream);
+ }
+
+ // Save eval, to a file stream or a memory stream
+ bool save_eval(std::ostream& stream) {
+
+ if (fileName.empty())
+ return false;
+
+ return write_parameters(stream);
}
-} // namespace Eval::NNUE
+} // namespace Stockfish::Eval::NNUE