Architecture:
The diagram of the "SFNNv4" architecture:
https://user-images.githubusercontent.com/
8037982/
153455685-
cbe3a038-e158-4481-844d-
9d5fccf5c33a.png
The most important architectural changes are the following:
* 1024x2 [activated] neurons are pairwise, elementwise multiplied (not quite pairwise due to implementation details, see diagram), which introduces a non-linearity that exhibits similar benefits to previously tested sigmoid activation (quantmoid4), while being slightly faster.
* The following layer has therefore 2x less inputs, which we compensate by having 2 more outputs. It is possible that reducing the number of outputs might be beneficial (as we had it as low as 8 before). The layer is now 1024->16.
* The 16 outputs are split into 15 and 1. The 1-wide output is added to the network output (after some necessary scaling due to quantization differences). The 15-wide is activated and follows the usual path through a set of linear layers. The additional 1-wide output is at least neutral, but has shown a slightly positive trend in training compared to networks without it (all 16 outputs through the usual path), and allows possibly an additional stage of lazy evaluation to be introduced in the future.
Additionally, the inference code was rewritten and no longer uses a recursive implementation. This was necessitated by the splitting of the 16-wide intermediate result into two, which was impossible to do with the old implementation with ugly hacks. This is hopefully overall for the better.
First session:
The first session was training a network from scratch (random initialization). The exact trainer used was slightly different (older) from the one used in the second session, but it should not have a measurable effect. The purpose of this session is to establish a strong network base for the second session. Small deviations in strength do not harm the learnability in the second session.
The training was done using the following command:
python3 train.py \
/home/sopel/nnue/nnue-pytorch-training/data/nodes5000pv2_UHO.binpack \
/home/sopel/nnue/nnue-pytorch-training/data/nodes5000pv2_UHO.binpack \
--gpus "$3," \
--threads 4 \
--num-workers 4 \
--batch-size 16384 \
--progress_bar_refresh_rate 20 \
--random-fen-skipping 3 \
--features=HalfKAv2_hm^ \
--lambda=1.0 \
--gamma=0.992 \
--lr=8.75e-4 \
--max_epochs=400 \
--default_root_dir ../nnue-pytorch-training/experiment_$1/run_$2
Every 20th net was saved and its playing strength measured against some baseline at 25k nodes per move with pure NNUE evaluation (modified binary). The exact setup is not important as long as it's consistent. The purpose is to sift good candidates from bad ones.
The dataset can be found https://drive.google.com/file/d/1UQdZN_LWQ265spwTBwDKo0t1WjSJKvWY/view
Second session:
The second training session was done starting from the best network (as determined by strength testing) from the first session. It is important that it's resumed from a .pt model and NOT a .ckpt model. The conversion can be performed directly using serialize.py
The LR schedule was modified to use gamma=0.995 instead of gamma=0.992 and LR=4.375e-4 instead of LR=8.75e-4 to flatten the LR curve and allow for longer training. The training was then running for 800 epochs instead of 400 (though it's possibly mostly noise after around epoch 600).
The training was done using the following command:
The training was done using the following command:
python3 train.py \
/data/sopel/nnue/nnue-pytorch-training/data/T60T70wIsRightFarseerT60T74T75T76.binpack \
/data/sopel/nnue/nnue-pytorch-training/data/T60T70wIsRightFarseerT60T74T75T76.binpack \
--gpus "$3," \
--threads 4 \
--num-workers 4 \
--batch-size 16384 \
--progress_bar_refresh_rate 20 \
--random-fen-skipping 3 \
--features=HalfKAv2_hm^ \
--lambda=1.0 \
--gamma=0.995 \
--lr=4.375e-4 \
--max_epochs=800 \
--resume-from-model /data/sopel/nnue/nnue-pytorch-training/data/exp295/nn-epoch399.pt \
--default_root_dir ../nnue-pytorch-training/experiment_$1/run_$run_id
In particular note that we now use lambda=1.0 instead of lambda=0.8 (previous nets), because tests show that WDL-skipping introduced by vondele performs better with lambda=1.0. Nets were being saved every 20th epoch. In total 16 runs were made with these settings and the best nets chosen according to playing strength at 25k nodes per move with pure NNUE evaluation - these are the 4 nets that have been put on fishtest.
The dataset can be found either at ftp://ftp.chessdb.cn/pub/sopel/data_sf/T60T70wIsRightFarseerT60T74T75T76.binpack in its entirety (download might be painfully slow because hosted in China) or can be assembled in the following way:
Get the https://github.com/official-stockfish/Stockfish/blob/
5640ad48ae5881223b868362c1cbeb042947f7b4/script/interleave_binpacks.py script.
Download T60T70wIsRightFarseer.binpack https://drive.google.com/file/d/1_sQoWBl31WAxNXma2v45004CIVltytP8/view
Download farseerT74.binpack http://trainingdata.farseer.org/T74-May13-End.7z
Download farseerT75.binpack http://trainingdata.farseer.org/T75-June3rd-End.7z
Download farseerT76.binpack http://trainingdata.farseer.org/T76-Nov10th-End.7z
Run python3 interleave_binpacks.py T60T70wIsRightFarseer.binpack farseerT74.binpack farseerT75.binpack farseerT76.binpack T60T70wIsRightFarseerT60T74T75T76.binpack
Tests:
STC: https://tests.stockfishchess.org/tests/view/
6203fb85d71106ed12a407b7
LLR: 2.94 (-2.94,2.94) <0.00,2.50>
Total: 16952 W: 4775 L: 4521 D: 7656
Ptnml(0-2): 133, 1818, 4318, 2076, 131
LTC: https://tests.stockfishchess.org/tests/view/
62041e68d71106ed12a40e85
LLR: 2.94 (-2.94,2.94) <0.50,3.00>
Total: 14944 W: 4138 L: 3907 D: 6899
Ptnml(0-2): 21, 1499, 4202, 1728, 22
closes https://github.com/official-stockfish/Stockfish/pull/3927
Bench:
4919707
// The default net name MUST follow the format nn-[SHA256 first 12 digits].nnue
// for the build process (profile-build and fishtest) to work. Do not change the
// name of the macro, as it is used in the Makefile.
- #define EvalFileDefaultName "nn-ac07bd334b62.nnue"
+ #define EvalFileDefaultName "nn-6877cd24400e.nnue"
namespace NNUE {
#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
TransformedFeatureType transformedFeaturesUnaligned[
FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
- char bufferUnaligned[Network::BufferSize + alignment];
auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
- auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
#else
alignas(alignment)
TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
- alignas(alignment) char buffer[Network::BufferSize];
#endif
ASSERT_ALIGNED(transformedFeatures, alignment);
- ASSERT_ALIGNED(buffer, alignment);
const std::size_t bucket = (pos.count<ALL_PIECES>() - 1) / 4;
const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
- const auto positional = network[bucket]->propagate(transformedFeatures, buffer)[0];
+ const auto positional = network[bucket]->propagate(transformedFeatures);
// Give more value to positional evaluation when adjusted flag is set
if (adjusted)
#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
TransformedFeatureType transformedFeaturesUnaligned[
FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
- char bufferUnaligned[Network::BufferSize + alignment];
auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
- auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
#else
alignas(alignment)
TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
- alignas(alignment) char buffer[Network::BufferSize];
#endif
ASSERT_ALIGNED(transformedFeatures, alignment);
- ASSERT_ALIGNED(buffer, alignment);
NnueEvalTrace t{};
t.correctBucket = (pos.count<ALL_PIECES>() - 1) / 4;
for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket) {
- const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
- const auto output = network[bucket]->propagate(transformedFeatures, buffer);
-
- int materialist = psqt;
- int positional = output[0];
+ const auto materialist = featureTransformer->transform(pos, transformedFeatures, bucket);
+ const auto positional = network[bucket]->propagate(transformedFeatures);
t.psqt[bucket] = static_cast<Value>( materialist / OutputScale );
t.positional[bucket] = static_cast<Value>( positional / OutputScale );
{
# if defined(USE_SSE2)
// At least a multiple of 16, with SSE2.
- static_assert(PaddedInputDimensions % 16 == 0);
- constexpr IndexType NumChunks = PaddedInputDimensions / 16;
+ constexpr IndexType NumChunks = ceil_to_multiple<IndexType>(InputDimensions, 16) / 16;
const __m128i Zeros = _mm_setzero_si128();
const auto inputVector = reinterpret_cast<const __m128i*>(input);
# elif defined(USE_MMX)
- static_assert(InputDimensions % 8 == 0);
- constexpr IndexType NumChunks = InputDimensions / 8;
+ constexpr IndexType NumChunks = ceil_to_multiple<IndexType>(InputDimensions, 8) / 8;
const __m64 Zeros = _mm_setzero_si64();
const auto inputVector = reinterpret_cast<const __m64*>(input);
# elif defined(USE_NEON)
- constexpr IndexType NumChunks = (InputDimensions + 15) / 16;
+ constexpr IndexType NumChunks = ceil_to_multiple<IndexType>(InputDimensions, 16) / 16;
const auto inputVector = reinterpret_cast<const int8x8_t*>(input);
# endif
}
#endif
- template <typename PreviousLayer, IndexType OutDims, typename Enabled = void>
+ template <IndexType InDims, IndexType OutDims, typename Enabled = void>
class AffineTransform;
// A specialization for large inputs.
- template <typename PreviousLayer, IndexType OutDims>
- class AffineTransform<PreviousLayer, OutDims, std::enable_if_t<(PreviousLayer::OutputDimensions >= 2*64-1)>> {
+ template <IndexType InDims, IndexType OutDims>
+ class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) >= 2*64)>> {
public:
// Input/output type
- using InputType = typename PreviousLayer::OutputType;
+ using InputType = std::uint8_t;
using OutputType = std::int32_t;
- static_assert(std::is_same<InputType, std::uint8_t>::value, "");
// Number of input/output dimensions
- static constexpr IndexType InputDimensions = PreviousLayer::OutputDimensions;
+ static constexpr IndexType InputDimensions = InDims;
static constexpr IndexType OutputDimensions = OutDims;
static constexpr IndexType PaddedInputDimensions =
ceil_to_multiple<IndexType>(InputDimensions, MaxSimdWidth);
+ static constexpr IndexType PaddedOutputDimensions =
+ ceil_to_multiple<IndexType>(OutputDimensions, MaxSimdWidth);
+
+ using OutputBuffer = OutputType[PaddedOutputDimensions];
static_assert(PaddedInputDimensions >= 128, "Something went wrong. This specialization should not have been chosen.");
static_assert(OutputDimensions % NumOutputRegs == 0);
- // Size of forward propagation buffer used in this layer
- static constexpr std::size_t SelfBufferSize =
- ceil_to_multiple(OutputDimensions * sizeof(OutputType), CacheLineSize);
-
- // Size of the forward propagation buffer used from the input layer to this layer
- static constexpr std::size_t BufferSize =
- PreviousLayer::BufferSize + SelfBufferSize;
-
// Hash value embedded in the evaluation file
- static constexpr std::uint32_t get_hash_value() {
+ static constexpr std::uint32_t get_hash_value(std::uint32_t prevHash) {
std::uint32_t hashValue = 0xCC03DAE4u;
hashValue += OutputDimensions;
- hashValue ^= PreviousLayer::get_hash_value() >> 1;
- hashValue ^= PreviousLayer::get_hash_value() << 31;
+ hashValue ^= prevHash >> 1;
+ hashValue ^= prevHash << 31;
return hashValue;
}
// Read network parameters
bool read_parameters(std::istream& stream) {
- if (!previousLayer.read_parameters(stream)) return false;
for (std::size_t i = 0; i < OutputDimensions; ++i)
biases[i] = read_little_endian<BiasType>(stream);
// Write network parameters
bool write_parameters(std::ostream& stream) const {
- if (!previousLayer.write_parameters(stream)) return false;
for (std::size_t i = 0; i < OutputDimensions; ++i)
write_little_endian<BiasType>(stream, biases[i]);
// Forward propagation
const OutputType* propagate(
- const TransformedFeatureType* transformedFeatures, char* buffer) const {
- const auto input = previousLayer.propagate(
- transformedFeatures, buffer + SelfBufferSize);
- OutputType* output = reinterpret_cast<OutputType*>(buffer);
+ const InputType* input, OutputType* output) const {
#if defined (USE_AVX512)
using acc_vec_t = __m512i;
#if defined (USE_SSSE3) || defined (USE_NEON)
const in_vec_t* invec = reinterpret_cast<const in_vec_t*>(input);
-
// Perform accumulation to registers for each big block
for (IndexType bigBlock = 0; bigBlock < NumBigBlocks; ++bigBlock)
{
using BiasType = OutputType;
using WeightType = std::int8_t;
- PreviousLayer previousLayer;
-
alignas(CacheLineSize) BiasType biases[OutputDimensions];
alignas(CacheLineSize) WeightType weights[OutputDimensions * PaddedInputDimensions];
};
- template <typename PreviousLayer, IndexType OutDims>
- class AffineTransform<PreviousLayer, OutDims, std::enable_if_t<(PreviousLayer::OutputDimensions < 2*64-1)>> {
+ template <IndexType InDims, IndexType OutDims>
+ class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) < 2*64)>> {
public:
// Input/output type
- using InputType = typename PreviousLayer::OutputType;
+ // Input/output type
+ using InputType = std::uint8_t;
using OutputType = std::int32_t;
- static_assert(std::is_same<InputType, std::uint8_t>::value, "");
// Number of input/output dimensions
- static constexpr IndexType InputDimensions =
- PreviousLayer::OutputDimensions;
+ static constexpr IndexType InputDimensions = InDims;
static constexpr IndexType OutputDimensions = OutDims;
+
static constexpr IndexType PaddedInputDimensions =
- ceil_to_multiple<IndexType>(InputDimensions, MaxSimdWidth);
+ ceil_to_multiple<IndexType>(InputDimensions, MaxSimdWidth);
+ static constexpr IndexType PaddedOutputDimensions =
+ ceil_to_multiple<IndexType>(OutputDimensions, MaxSimdWidth);
+
+ using OutputBuffer = OutputType[PaddedOutputDimensions];
static_assert(PaddedInputDimensions < 128, "Something went wrong. This specialization should not have been chosen.");
static constexpr const IndexType InputSimdWidth = SimdWidth;
#endif
- // Size of forward propagation buffer used in this layer
- static constexpr std::size_t SelfBufferSize =
- ceil_to_multiple(OutputDimensions * sizeof(OutputType), CacheLineSize);
-
- // Size of the forward propagation buffer used from the input layer to this layer
- static constexpr std::size_t BufferSize =
- PreviousLayer::BufferSize + SelfBufferSize;
-
// Hash value embedded in the evaluation file
- static constexpr std::uint32_t get_hash_value() {
+ static constexpr std::uint32_t get_hash_value(std::uint32_t prevHash) {
std::uint32_t hashValue = 0xCC03DAE4u;
hashValue += OutputDimensions;
- hashValue ^= PreviousLayer::get_hash_value() >> 1;
- hashValue ^= PreviousLayer::get_hash_value() << 31;
+ hashValue ^= prevHash >> 1;
+ hashValue ^= prevHash << 31;
return hashValue;
}
// Read network parameters
bool read_parameters(std::istream& stream) {
- if (!previousLayer.read_parameters(stream)) return false;
for (std::size_t i = 0; i < OutputDimensions; ++i)
biases[i] = read_little_endian<BiasType>(stream);
for (std::size_t i = 0; i < OutputDimensions * PaddedInputDimensions; ++i)
// Write network parameters
bool write_parameters(std::ostream& stream) const {
- if (!previousLayer.write_parameters(stream)) return false;
for (std::size_t i = 0; i < OutputDimensions; ++i)
write_little_endian<BiasType>(stream, biases[i]);
}
// Forward propagation
const OutputType* propagate(
- const TransformedFeatureType* transformedFeatures, char* buffer) const {
- const auto input = previousLayer.propagate(
- transformedFeatures, buffer + SelfBufferSize);
- const auto output = reinterpret_cast<OutputType*>(buffer);
+ const InputType* input, OutputType* output) const {
#if defined (USE_AVX2)
using vec_t = __m256i;
#if defined (USE_SSSE3)
const auto inputVector = reinterpret_cast<const vec_t*>(input);
- static_assert(InputDimensions % 8 == 0);
static_assert(OutputDimensions % OutputSimdWidth == 0 || OutputDimensions == 1);
if constexpr (OutputDimensions % OutputSimdWidth == 0)
{
- constexpr IndexType NumChunks = InputDimensions / 4;
+ constexpr IndexType NumChunks = ceil_to_multiple<IndexType>(InputDimensions, 8) / 4;
constexpr IndexType NumRegs = OutputDimensions / OutputSimdWidth;
const auto input32 = reinterpret_cast<const std::int32_t*>(input);
using BiasType = OutputType;
using WeightType = std::int8_t;
- PreviousLayer previousLayer;
-
alignas(CacheLineSize) BiasType biases[OutputDimensions];
alignas(CacheLineSize) WeightType weights[OutputDimensions * PaddedInputDimensions];
};
namespace Stockfish::Eval::NNUE::Layers {
// Clipped ReLU
- template <typename PreviousLayer>
+ template <IndexType InDims>
class ClippedReLU {
public:
// Input/output type
- using InputType = typename PreviousLayer::OutputType;
+ using InputType = std::int32_t;
using OutputType = std::uint8_t;
- static_assert(std::is_same<InputType, std::int32_t>::value, "");
// Number of input/output dimensions
- static constexpr IndexType InputDimensions = PreviousLayer::OutputDimensions;
+ static constexpr IndexType InputDimensions = InDims;
static constexpr IndexType OutputDimensions = InputDimensions;
static constexpr IndexType PaddedOutputDimensions =
ceil_to_multiple<IndexType>(OutputDimensions, 32);
- // Size of forward propagation buffer used in this layer
- static constexpr std::size_t SelfBufferSize =
- ceil_to_multiple(OutputDimensions * sizeof(OutputType), CacheLineSize);
-
- // Size of the forward propagation buffer used from the input layer to this layer
- static constexpr std::size_t BufferSize =
- PreviousLayer::BufferSize + SelfBufferSize;
+ using OutputBuffer = OutputType[PaddedOutputDimensions];
// Hash value embedded in the evaluation file
- static constexpr std::uint32_t get_hash_value() {
+ static constexpr std::uint32_t get_hash_value(std::uint32_t prevHash) {
std::uint32_t hashValue = 0x538D24C7u;
- hashValue += PreviousLayer::get_hash_value();
+ hashValue += prevHash;
return hashValue;
}
// Read network parameters
- bool read_parameters(std::istream& stream) {
- return previousLayer.read_parameters(stream);
+ bool read_parameters(std::istream&) {
+ return true;
}
// Write network parameters
- bool write_parameters(std::ostream& stream) const {
- return previousLayer.write_parameters(stream);
+ bool write_parameters(std::ostream&) const {
+ return true;
}
// Forward propagation
const OutputType* propagate(
- const TransformedFeatureType* transformedFeatures, char* buffer) const {
- const auto input = previousLayer.propagate(
- transformedFeatures, buffer + SelfBufferSize);
- const auto output = reinterpret_cast<OutputType*>(buffer);
+ const InputType* input, OutputType* output) const {
#if defined(USE_AVX2)
if constexpr (InputDimensions % SimdWidth == 0) {
return output;
}
-
- private:
- PreviousLayer previousLayer;
};
} // namespace Stockfish::Eval::NNUE::Layers
+++ /dev/null
-/*
- Stockfish, a UCI chess playing engine derived from Glaurung 2.1
- Copyright (C) 2004-2022 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Stockfish is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-// NNUE evaluation function layer InputSlice definition
-
-#ifndef NNUE_LAYERS_INPUT_SLICE_H_INCLUDED
-#define NNUE_LAYERS_INPUT_SLICE_H_INCLUDED
-
-#include "../nnue_common.h"
-
-namespace Stockfish::Eval::NNUE::Layers {
-
-// Input layer
-template <IndexType OutDims, IndexType Offset = 0>
-class InputSlice {
- public:
- // Need to maintain alignment
- static_assert(Offset % MaxSimdWidth == 0, "");
-
- // Output type
- using OutputType = TransformedFeatureType;
-
- // Output dimensionality
- static constexpr IndexType OutputDimensions = OutDims;
-
- // Size of forward propagation buffer used from the input layer to this layer
- static constexpr std::size_t BufferSize = 0;
-
- // Hash value embedded in the evaluation file
- static constexpr std::uint32_t get_hash_value() {
- std::uint32_t hashValue = 0xEC42E90Du;
- hashValue ^= OutputDimensions ^ (Offset << 10);
- return hashValue;
- }
-
- // Read network parameters
- bool read_parameters(std::istream& /*stream*/) {
- return true;
- }
-
- // Write network parameters
- bool write_parameters(std::ostream& /*stream*/) const {
- return true;
- }
-
- // Forward propagation
- const OutputType* propagate(
- const TransformedFeatureType* transformedFeatures,
- char* /*buffer*/) const {
- return transformedFeatures + Offset;
- }
-
- private:
-};
-
-} // namespace Stockfish::Eval::NNUE::Layers
-
-#endif // #ifndef NNUE_LAYERS_INPUT_SLICE_H_INCLUDED
#include "features/half_ka_v2_hm.h"
-#include "layers/input_slice.h"
#include "layers/affine_transform.h"
#include "layers/clipped_relu.h"
-namespace Stockfish::Eval::NNUE {
-
- // Input features used in evaluation function
- using FeatureSet = Features::HalfKAv2_hm;
-
- // Number of input feature dimensions after conversion
- constexpr IndexType TransformedFeatureDimensions = 1024;
- constexpr IndexType PSQTBuckets = 8;
- constexpr IndexType LayerStacks = 8;
-
- namespace Layers {
+#include "../misc.h"
- // Define network structure
- using InputLayer = InputSlice<TransformedFeatureDimensions * 2>;
- using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 8>>;
- using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
- using OutputLayer = AffineTransform<HiddenLayer2, 1>;
-
- } // namespace Layers
-
- using Network = Layers::OutputLayer;
+namespace Stockfish::Eval::NNUE {
- static_assert(TransformedFeatureDimensions % MaxSimdWidth == 0, "");
- static_assert(Network::OutputDimensions == 1, "");
- static_assert(std::is_same<Network::OutputType, std::int32_t>::value, "");
+// Input features used in evaluation function
+using FeatureSet = Features::HalfKAv2_hm;
+
+// Number of input feature dimensions after conversion
+constexpr IndexType TransformedFeatureDimensions = 1024;
+constexpr IndexType PSQTBuckets = 8;
+constexpr IndexType LayerStacks = 8;
+
+struct Network
+{
+ static constexpr int FC_0_OUTPUTS = 15;
+ static constexpr int FC_1_OUTPUTS = 32;
+
+ Layers::AffineTransform<TransformedFeatureDimensions, FC_0_OUTPUTS + 1> fc_0;
+ Layers::ClippedReLU<FC_0_OUTPUTS> ac_0;
+ Layers::AffineTransform<FC_0_OUTPUTS, FC_1_OUTPUTS> fc_1;
+ Layers::ClippedReLU<FC_1_OUTPUTS> ac_1;
+ Layers::AffineTransform<FC_1_OUTPUTS, 1> fc_2;
+
+ // Hash value embedded in the evaluation file
+ static constexpr std::uint32_t get_hash_value() {
+ // input slice hash
+ std::uint32_t hashValue = 0xEC42E90Du;
+ hashValue ^= TransformedFeatureDimensions * 2;
+
+ hashValue = decltype(fc_0)::get_hash_value(hashValue);
+ hashValue = decltype(ac_0)::get_hash_value(hashValue);
+ hashValue = decltype(fc_1)::get_hash_value(hashValue);
+ hashValue = decltype(ac_1)::get_hash_value(hashValue);
+ hashValue = decltype(fc_2)::get_hash_value(hashValue);
+
+ return hashValue;
+ }
+
+ // Read network parameters
+ bool read_parameters(std::istream& stream) {
+ if (!fc_0.read_parameters(stream)) return false;
+ if (!ac_0.read_parameters(stream)) return false;
+ if (!fc_1.read_parameters(stream)) return false;
+ if (!ac_1.read_parameters(stream)) return false;
+ if (!fc_2.read_parameters(stream)) return false;
+ return true;
+ }
+
+ // Read network parameters
+ bool write_parameters(std::ostream& stream) const {
+ if (!fc_0.write_parameters(stream)) return false;
+ if (!ac_0.write_parameters(stream)) return false;
+ if (!fc_1.write_parameters(stream)) return false;
+ if (!ac_1.write_parameters(stream)) return false;
+ if (!fc_2.write_parameters(stream)) return false;
+ return true;
+ }
+
+ std::int32_t propagate(const TransformedFeatureType* transformedFeatures)
+ {
+ constexpr uint64_t alignment = CacheLineSize;
+
+ struct Buffer
+ {
+ alignas(CacheLineSize) decltype(fc_0)::OutputBuffer fc_0_out;
+ alignas(CacheLineSize) decltype(ac_0)::OutputBuffer ac_0_out;
+ alignas(CacheLineSize) decltype(fc_1)::OutputBuffer fc_1_out;
+ alignas(CacheLineSize) decltype(ac_1)::OutputBuffer ac_1_out;
+ alignas(CacheLineSize) decltype(fc_2)::OutputBuffer fc_2_out;
+ };
+
+#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
+ char bufferRaw[sizeof(Buffer) + alignment];
+ char* bufferRawAligned = align_ptr_up<alignment>(&bufferRaw[0]);
+ Buffer& buffer = *(new (bufferRawAligned) Buffer);
+#else
+ alignas(alignment) Buffer buffer;
+#endif
+
+ fc_0.propagate(transformedFeatures, buffer.fc_0_out);
+ ac_0.propagate(buffer.fc_0_out, buffer.ac_0_out);
+ fc_1.propagate(buffer.ac_0_out, buffer.fc_1_out);
+ ac_1.propagate(buffer.fc_1_out, buffer.ac_1_out);
+ fc_2.propagate(buffer.ac_1_out, buffer.fc_2_out);
+
+ // buffer.fc_0_out[FC_0_OUTPUTS] is such that 1.0 is equal to 127*(1<<WeightScaleBits) in quantized form
+ // but we want 1.0 to be equal to 600*OutputScale
+ std::int32_t fwdOut = int(buffer.fc_0_out[FC_0_OUTPUTS]) * (600*OutputScale) / (127*(1<<WeightScaleBits));
+ std::int32_t outputValue = buffer.fc_2_out[0] + fwdOut;
+
+#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
+ buffer.~Buffer();
+#endif
+
+ return outputValue;
+ }
+};
} // namespace Stockfish::Eval::NNUE
// Number of input/output dimensions
static constexpr IndexType InputDimensions = FeatureSet::Dimensions;
- static constexpr IndexType OutputDimensions = HalfDimensions * 2;
+ static constexpr IndexType OutputDimensions = HalfDimensions;
// Size of forward propagation buffer
static constexpr std::size_t BufferSize =
// Hash value embedded in the evaluation file
static constexpr std::uint32_t get_hash_value() {
- return FeatureSet::HashValue ^ OutputDimensions;
+ return FeatureSet::HashValue ^ (OutputDimensions * 2);
}
// Read network parameters
) / 2;
- #if defined(USE_AVX512)
-
- constexpr IndexType NumChunks = HalfDimensions / (SimdWidth * 2);
- static_assert(HalfDimensions % (SimdWidth * 2) == 0);
- const __m512i Control = _mm512_setr_epi64(0, 2, 4, 6, 1, 3, 5, 7);
- const __m512i Zero = _mm512_setzero_si512();
-
for (IndexType p = 0; p < 2; ++p)
{
- const IndexType offset = HalfDimensions * p;
- auto out = reinterpret_cast<__m512i*>(&output[offset]);
- for (IndexType j = 0; j < NumChunks; ++j)
- {
- __m512i sum0 = _mm512_load_si512(&reinterpret_cast<const __m512i*>
- (accumulation[perspectives[p]])[j * 2 + 0]);
- __m512i sum1 = _mm512_load_si512(&reinterpret_cast<const __m512i*>
- (accumulation[perspectives[p]])[j * 2 + 1]);
+ const IndexType offset = (HalfDimensions / 2) * p;
- _mm512_store_si512(&out[j], _mm512_permutexvar_epi64(Control,
- _mm512_max_epi8(_mm512_packs_epi16(sum0, sum1), Zero)));
- }
- }
- return psqt;
+#if defined(USE_AVX512)
- #elif defined(USE_AVX2)
+ constexpr IndexType OutputChunkSize = 512 / 8;
+ static_assert((HalfDimensions / 2) % OutputChunkSize == 0);
+ constexpr IndexType NumOutputChunks = HalfDimensions / 2 / OutputChunkSize;
- constexpr IndexType NumChunks = HalfDimensions / SimdWidth;
- constexpr int Control = 0b11011000;
- const __m256i Zero = _mm256_setzero_si256();
+ const __m512i Zero = _mm512_setzero_si512();
+ const __m512i One = _mm512_set1_epi16(127);
+ const __m512i Control = _mm512_setr_epi64(0, 2, 4, 6, 1, 3, 5, 7);
- for (IndexType p = 0; p < 2; ++p)
- {
- const IndexType offset = HalfDimensions * p;
- auto out = reinterpret_cast<__m256i*>(&output[offset]);
- for (IndexType j = 0; j < NumChunks; ++j)
+ const __m512i* in0 = reinterpret_cast<const __m512i*>(&(accumulation[perspectives[p]][0]));
+ const __m512i* in1 = reinterpret_cast<const __m512i*>(&(accumulation[perspectives[p]][HalfDimensions / 2]));
+ __m512i* out = reinterpret_cast< __m512i*>(output + offset);
+
+ for (IndexType j = 0; j < NumOutputChunks; j += 1)
{
- __m256i sum0 = _mm256_load_si256(&reinterpret_cast<const __m256i*>
- (accumulation[perspectives[p]])[j * 2 + 0]);
- __m256i sum1 = _mm256_load_si256(&reinterpret_cast<const __m256i*>
- (accumulation[perspectives[p]])[j * 2 + 1]);
+ const __m512i sum0a = _mm512_max_epi16(_mm512_min_epi16(in0[j * 2 + 0], One), Zero);
+ const __m512i sum0b = _mm512_max_epi16(_mm512_min_epi16(in0[j * 2 + 1], One), Zero);
+ const __m512i sum1a = _mm512_max_epi16(_mm512_min_epi16(in1[j * 2 + 0], One), Zero);
+ const __m512i sum1b = _mm512_max_epi16(_mm512_min_epi16(in1[j * 2 + 1], One), Zero);
- _mm256_store_si256(&out[j], _mm256_permute4x64_epi64(
- _mm256_max_epi8(_mm256_packs_epi16(sum0, sum1), Zero), Control));
+ const __m512i pa = _mm512_srli_epi16(_mm512_mullo_epi16(sum0a, sum1a), 7);
+ const __m512i pb = _mm512_srli_epi16(_mm512_mullo_epi16(sum0b, sum1b), 7);
+
+ out[j] = _mm512_permutexvar_epi64(Control, _mm512_packs_epi16(pa, pb));
}
- }
- return psqt;
- #elif defined(USE_SSE2)
+#elif defined(USE_AVX2)
- #ifdef USE_SSE41
- constexpr IndexType NumChunks = HalfDimensions / SimdWidth;
- const __m128i Zero = _mm_setzero_si128();
- #else
- constexpr IndexType NumChunks = HalfDimensions / SimdWidth;
- const __m128i k0x80s = _mm_set1_epi8(-128);
- #endif
+ constexpr IndexType OutputChunkSize = 256 / 8;
+ static_assert((HalfDimensions / 2) % OutputChunkSize == 0);
+ constexpr IndexType NumOutputChunks = HalfDimensions / 2 / OutputChunkSize;
- for (IndexType p = 0; p < 2; ++p)
- {
- const IndexType offset = HalfDimensions * p;
- auto out = reinterpret_cast<__m128i*>(&output[offset]);
- for (IndexType j = 0; j < NumChunks; ++j)
+ const __m256i Zero = _mm256_setzero_si256();
+ const __m256i One = _mm256_set1_epi16(127);
+ constexpr int Control = 0b11011000;
+
+ const __m256i* in0 = reinterpret_cast<const __m256i*>(&(accumulation[perspectives[p]][0]));
+ const __m256i* in1 = reinterpret_cast<const __m256i*>(&(accumulation[perspectives[p]][HalfDimensions / 2]));
+ __m256i* out = reinterpret_cast< __m256i*>(output + offset);
+
+ for (IndexType j = 0; j < NumOutputChunks; j += 1)
{
- __m128i sum0 = _mm_load_si128(&reinterpret_cast<const __m128i*>
- (accumulation[perspectives[p]])[j * 2 + 0]);
- __m128i sum1 = _mm_load_si128(&reinterpret_cast<const __m128i*>
- (accumulation[perspectives[p]])[j * 2 + 1]);
- const __m128i packedbytes = _mm_packs_epi16(sum0, sum1);
-
- #ifdef USE_SSE41
- _mm_store_si128(&out[j], _mm_max_epi8(packedbytes, Zero));
- #else
- _mm_store_si128(&out[j], _mm_subs_epi8(_mm_adds_epi8(packedbytes, k0x80s), k0x80s));
- #endif
+ const __m256i sum0a = _mm256_max_epi16(_mm256_min_epi16(in0[j * 2 + 0], One), Zero);
+ const __m256i sum0b = _mm256_max_epi16(_mm256_min_epi16(in0[j * 2 + 1], One), Zero);
+ const __m256i sum1a = _mm256_max_epi16(_mm256_min_epi16(in1[j * 2 + 0], One), Zero);
+ const __m256i sum1b = _mm256_max_epi16(_mm256_min_epi16(in1[j * 2 + 1], One), Zero);
+
+ const __m256i pa = _mm256_srli_epi16(_mm256_mullo_epi16(sum0a, sum1a), 7);
+ const __m256i pb = _mm256_srli_epi16(_mm256_mullo_epi16(sum0b, sum1b), 7);
+
+ out[j] = _mm256_permute4x64_epi64(_mm256_packs_epi16(pa, pb), Control);
}
- }
- return psqt;
- #elif defined(USE_MMX)
+#elif defined(USE_SSE2)
- constexpr IndexType NumChunks = HalfDimensions / SimdWidth;
- const __m64 k0x80s = _mm_set1_pi8(-128);
+ constexpr IndexType OutputChunkSize = 128 / 8;
+ static_assert((HalfDimensions / 2) % OutputChunkSize == 0);
+ constexpr IndexType NumOutputChunks = HalfDimensions / 2 / OutputChunkSize;
- for (IndexType p = 0; p < 2; ++p)
- {
- const IndexType offset = HalfDimensions * p;
- auto out = reinterpret_cast<__m64*>(&output[offset]);
- for (IndexType j = 0; j < NumChunks; ++j)
+ const __m128i Zero = _mm_setzero_si128();
+ const __m128i One = _mm_set1_epi16(127);
+
+ const __m128i* in0 = reinterpret_cast<const __m128i*>(&(accumulation[perspectives[p]][0]));
+ const __m128i* in1 = reinterpret_cast<const __m128i*>(&(accumulation[perspectives[p]][HalfDimensions / 2]));
+ __m128i* out = reinterpret_cast< __m128i*>(output + offset);
+
+ for (IndexType j = 0; j < NumOutputChunks; j += 1)
{
- __m64 sum0 = *(&reinterpret_cast<const __m64*>(accumulation[perspectives[p]])[j * 2 + 0]);
- __m64 sum1 = *(&reinterpret_cast<const __m64*>(accumulation[perspectives[p]])[j * 2 + 1]);
- const __m64 packedbytes = _mm_packs_pi16(sum0, sum1);
- out[j] = _mm_subs_pi8(_mm_adds_pi8(packedbytes, k0x80s), k0x80s);
+ const __m128i sum0a = _mm_max_epi16(_mm_min_epi16(in0[j * 2 + 0], One), Zero);
+ const __m128i sum0b = _mm_max_epi16(_mm_min_epi16(in0[j * 2 + 1], One), Zero);
+ const __m128i sum1a = _mm_max_epi16(_mm_min_epi16(in1[j * 2 + 0], One), Zero);
+ const __m128i sum1b = _mm_max_epi16(_mm_min_epi16(in1[j * 2 + 1], One), Zero);
+
+ const __m128i pa = _mm_srli_epi16(_mm_mullo_epi16(sum0a, sum1a), 7);
+ const __m128i pb = _mm_srli_epi16(_mm_mullo_epi16(sum0b, sum1b), 7);
+
+ out[j] = _mm_packs_epi16(pa, pb);
}
- }
- _mm_empty();
- return psqt;
- #elif defined(USE_NEON)
+#elif defined(USE_NEON)
- constexpr IndexType NumChunks = HalfDimensions / (SimdWidth / 2);
- const int8x8_t Zero = {0};
+ constexpr IndexType OutputChunkSize = 128 / 8;
+ static_assert((HalfDimensions / 2) % OutputChunkSize == 0);
+ constexpr IndexType NumOutputChunks = HalfDimensions / 2 / OutputChunkSize;
- for (IndexType p = 0; p < 2; ++p)
- {
- const IndexType offset = HalfDimensions * p;
- const auto out = reinterpret_cast<int8x8_t*>(&output[offset]);
+ const int16x8_t Zero = vdupq_n_s16(0);
+ const int16x8_t One = vdupq_n_s16(127);
- constexpr IndexType UnrollFactor = 16;
- static_assert(UnrollFactor % UnrollFactor == 0);
- for (IndexType j = 0; j < NumChunks; j += UnrollFactor)
+ const int16x8_t* in0 = reinterpret_cast<const int16x8_t*>(&(accumulation[perspectives[p]][0]));
+ const int16x8_t* in1 = reinterpret_cast<const int16x8_t*>(&(accumulation[perspectives[p]][HalfDimensions / 2]));
+ int8x16_t* out = reinterpret_cast< int8x16_t*>(output + offset);
+
+ for (IndexType j = 0; j < NumOutputChunks; j += 1)
{
- int16x8_t sums[UnrollFactor];
- for (IndexType i = 0; i < UnrollFactor; ++i)
- sums[i] = reinterpret_cast<const int16x8_t*>(accumulation[perspectives[p]])[j+i];
+ const int16x8_t sum0a = vmaxq_s16(vminq_s16(in0[j * 2 + 0], One), Zero);
+ const int16x8_t sum0b = vmaxq_s16(vminq_s16(in0[j * 2 + 1], One), Zero);
+ const int16x8_t sum1a = vmaxq_s16(vminq_s16(in1[j * 2 + 0], One), Zero);
+ const int16x8_t sum1b = vmaxq_s16(vminq_s16(in1[j * 2 + 1], One), Zero);
+
+ const int8x8_t pa = vshrn_n_s16(vmulq_s16(sum0a, sum1a), 7);
+ const int8x8_t pb = vshrn_n_s16(vmulq_s16(sum0b, sum1b), 7);
- for (IndexType i = 0; i < UnrollFactor; ++i)
- out[j+i] = vmax_s8(vqmovn_s16(sums[i]), Zero);
+ out[j] = vcombine_s8(pa, pb);
}
- }
- return psqt;
- #else
+#else
- for (IndexType p = 0; p < 2; ++p)
- {
- const IndexType offset = HalfDimensions * p;
- for (IndexType j = 0; j < HalfDimensions; ++j)
- {
- BiasType sum = accumulation[perspectives[p]][j];
- output[offset + j] = static_cast<OutputType>(std::max<int>(0, std::min<int>(127, sum)));
+ for (IndexType j = 0; j < HalfDimensions / 2; ++j) {
+ BiasType sum0 = accumulation[static_cast<int>(perspectives[p])][j + 0];
+ BiasType sum1 = accumulation[static_cast<int>(perspectives[p])][j + HalfDimensions / 2];
+ sum0 = std::max<int>(0, std::min<int>(127, sum0));
+ sum1 = std::max<int>(0, std::min<int>(127, sum1));
+ output[offset + j] = static_cast<OutputType>(sum0 * sum1 / 128);
}
+
+#endif
}
- return psqt;
- #endif
+ return psqt;
} // end of function transform()
projects / stockfish / commitdiff