2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
Add NNUE evaluation
This patch ports the efficiently updatable neural network (NNUE) evaluation to Stockfish.
Both the NNUE and the classical evaluations are available, and can be used to
assign a value to a position that is later used in alpha-beta (PVS) search to find the
best move. The classical evaluation computes this value as a function of various chess
concepts, handcrafted by experts, tested and tuned using fishtest. The NNUE evaluation
computes this value with a neural network based on basic inputs. The network is optimized
and trained on the evalutions of millions of positions at moderate search depth.
The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
It can be evaluated efficiently on CPUs, and exploits the fact that only parts
of the neural network need to be updated after a typical chess move.
[The nodchip repository](https://github.com/nodchip/Stockfish) provides additional
tools to train and develop the NNUE networks.
This patch is the result of contributions of various authors, from various communities,
including: nodchip, ynasu87, yaneurao (initial port and NNUE authors), domschl, FireFather,
rqs, xXH4CKST3RXx, tttak, zz4032, joergoster, mstembera, nguyenpham, erbsenzaehler,
dorzechowski, and vondele.
This new evaluation needed various changes to fishtest and the corresponding infrastructure,
for which tomtor, ppigazzini, noobpwnftw, daylen, and vondele are gratefully acknowledged.
The first networks have been provided by gekkehenker and sergiovieri, with the latter
net (nn-97f742aaefcd.nnue) being the current default.
The evaluation function can be selected at run time with the `Use NNUE` (true/false) UCI option,
provided the `EvalFile` option points the the network file (depending on the GUI, with full path).
The performance of the NNUE evaluation relative to the classical evaluation depends somewhat on
the hardware, and is expected to improve quickly, but is currently on > 80 Elo on fishtest:
60000 @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f28fe6ea5abc164f05e4c4c
ELO: 92.77 +-2.1 (95%) LOS: 100.0%
Total: 60000 W: 24193 L: 8543 D: 27264
Ptnml(0-2): 609, 3850, 9708, 10948, 4885
40000 @ 20+0.2 th 8
https://tests.stockfishchess.org/tests/view/5f290229a5abc164f05e4c58
ELO: 89.47 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 12756 L: 2677 D: 24567
Ptnml(0-2): 74, 1583, 8550, 7776, 2017
At the same time, the impact on the classical evaluation remains minimal, causing no significant
regression:
sprt @ 10+0.1 th 1
https://tests.stockfishchess.org/tests/view/5f2906a2a5abc164f05e4c5b
LLR: 2.94 (-2.94,2.94) {-6.00,-4.00}
Total: 34936 W: 6502 L: 6825 D: 21609
Ptnml(0-2): 571, 4082, 8434, 3861, 520
sprt @ 60+0.6 th 1
https://tests.stockfishchess.org/tests/view/5f2906cfa5abc164f05e4c5d
LLR: 2.93 (-2.94,2.94) {-6.00,-4.00}
Total: 10088 W: 1232 L: 1265 D: 7591
Ptnml(0-2): 49, 914, 3170, 843, 68
The needed networks can be found at https://tests.stockfishchess.org/nns
It is recommended to use the default one as indicated by the `EvalFile` UCI option.
Guidelines for testing new nets can be found at
https://github.com/glinscott/fishtest/wiki/Creating-my-first-test#nnue-net-tests
Integration has been discussed in various issues:
https://github.com/official-stockfish/Stockfish/issues/2823
https://github.com/official-stockfish/Stockfish/issues/2728
The integration branch will be closed after the merge:
https://github.com/official-stockfish/Stockfish/pull/2825
https://github.com/official-stockfish/Stockfish/tree/nnue-player-wip
closes https://github.com/official-stockfish/Stockfish/pull/2912
This will be an exciting time for computer chess, looking forward to seeing the evolution of
this approach.
Bench: 4746616
2020-08-05 09:11:15 -06:00
|
|
|
Copyright (C) 2004-2020 The Stockfish developers (see AUTHORS file)
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-09-23 16:32:53 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-09-23 16:32:53 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <cassert>
|
2014-12-30 02:31:50 -07:00
|
|
|
#include <cstring> // For std::memset
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
#include "material.h"
|
2014-12-30 02:31:50 -07:00
|
|
|
#include "thread.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-07-26 10:42:48 -06:00
|
|
|
using namespace std;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2014-12-27 02:47:21 -07:00
|
|
|
// Polynomial material imbalance parameters
|
2009-11-15 01:35:22 -07:00
|
|
|
|
2018-03-18 16:38:58 -06:00
|
|
|
constexpr int QuadraticOurs[][PIECE_TYPE_NB] = {
|
2014-05-10 00:18:09 -06:00
|
|
|
// OUR PIECES
|
2013-03-13 17:23:29 -06:00
|
|
|
// pair pawn knight bishop rook queen
|
2018-08-14 00:31:56 -06:00
|
|
|
{1438 }, // Bishop pair
|
|
|
|
{ 40, 38 }, // Pawn
|
|
|
|
{ 32, 255, -62 }, // Knight OUR PIECES
|
2015-10-20 20:46:06 -06:00
|
|
|
{ 0, 104, 4, 0 }, // Bishop
|
2018-08-14 00:31:56 -06:00
|
|
|
{ -26, -2, 47, 105, -208 }, // Rook
|
|
|
|
{-189, 24, 117, 133, -134, -6 } // Queen
|
2013-03-13 17:23:29 -06:00
|
|
|
};
|
2009-07-20 02:56:21 -06:00
|
|
|
|
2018-03-18 16:38:58 -06:00
|
|
|
constexpr int QuadraticTheirs[][PIECE_TYPE_NB] = {
|
2013-03-13 17:23:29 -06:00
|
|
|
// THEIR PIECES
|
|
|
|
// pair pawn knight bishop rook queen
|
2020-06-24 14:19:58 -06:00
|
|
|
{ }, // Bishop pair
|
|
|
|
{ 36, }, // Pawn
|
|
|
|
{ 9, 63, }, // Knight OUR PIECES
|
|
|
|
{ 59, 65, 42, }, // Bishop
|
|
|
|
{ 46, 39, 24, -24, }, // Rook
|
|
|
|
{ 97, 100, -42, 137, 268, } // Queen
|
2017-07-08 15:07:25 -06:00
|
|
|
};
|
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
// Endgame evaluation and scaling functions are accessed directly and not through
|
2014-01-05 17:21:44 -07:00
|
|
|
// the function maps because they correspond to more than one material hash key.
|
2014-12-30 02:31:50 -07:00
|
|
|
Endgame<KXK> EvaluateKXK[] = { Endgame<KXK>(WHITE), Endgame<KXK>(BLACK) };
|
2011-04-11 10:12:41 -06:00
|
|
|
|
2011-08-21 13:11:37 -06:00
|
|
|
Endgame<KBPsK> ScaleKBPsK[] = { Endgame<KBPsK>(WHITE), Endgame<KBPsK>(BLACK) };
|
|
|
|
Endgame<KQKRPs> ScaleKQKRPs[] = { Endgame<KQKRPs>(WHITE), Endgame<KQKRPs>(BLACK) };
|
|
|
|
Endgame<KPsK> ScaleKPsK[] = { Endgame<KPsK>(WHITE), Endgame<KPsK>(BLACK) };
|
|
|
|
Endgame<KPKP> ScaleKPKP[] = { Endgame<KPKP>(WHITE), Endgame<KPKP>(BLACK) };
|
2010-04-26 06:43:03 -06:00
|
|
|
|
2015-02-07 02:09:56 -07:00
|
|
|
// Helper used to detect a given material distribution
|
|
|
|
bool is_KXK(const Position& pos, Color us) {
|
|
|
|
return !more_than_one(pos.pieces(~us))
|
|
|
|
&& pos.non_pawn_material(us) >= RookValueMg;
|
2010-04-26 03:42:46 -06:00
|
|
|
}
|
|
|
|
|
Renaming some variables in code
Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.
Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426
No functional change.
2018-03-15 03:44:26 -06:00
|
|
|
bool is_KBPsK(const Position& pos, Color us) {
|
2015-02-07 02:09:56 -07:00
|
|
|
return pos.non_pawn_material(us) == BishopValueMg
|
|
|
|
&& pos.count<PAWN >(us) >= 1;
|
2010-04-26 03:42:46 -06:00
|
|
|
}
|
|
|
|
|
2015-02-07 02:09:56 -07:00
|
|
|
bool is_KQKRPs(const Position& pos, Color us) {
|
|
|
|
return !pos.count<PAWN>(us)
|
|
|
|
&& pos.non_pawn_material(us) == QueenValueMg
|
|
|
|
&& pos.count<ROOK>(~us) == 1
|
|
|
|
&& pos.count<PAWN>(~us) >= 1;
|
2010-04-26 03:42:46 -06:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
/// imbalance() calculates the imbalance by comparing the piece count of each
|
2012-12-16 04:00:54 -07:00
|
|
|
/// piece type for both colors.
|
2020-06-24 14:19:58 -06:00
|
|
|
|
2012-12-16 04:00:54 -07:00
|
|
|
template<Color Us>
|
|
|
|
int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
|
|
|
|
|
2020-03-30 14:45:35 -06:00
|
|
|
constexpr Color Them = ~Us;
|
2012-12-16 04:00:54 -07:00
|
|
|
|
2018-08-14 00:31:56 -06:00
|
|
|
int bonus = 0;
|
2012-12-16 04:00:54 -07:00
|
|
|
|
2017-11-18 03:24:23 -07:00
|
|
|
// Second-degree polynomial material imbalance, by Tord Romstad
|
2014-06-20 15:15:31 -06:00
|
|
|
for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
|
2012-12-16 04:00:54 -07:00
|
|
|
{
|
2014-06-20 15:15:31 -06:00
|
|
|
if (!pieceCount[Us][pt1])
|
2012-12-16 04:00:54 -07:00
|
|
|
continue;
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
int v = QuadraticOurs[pt1][pt1] * pieceCount[Us][pt1];
|
2012-12-16 04:00:54 -07:00
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
for (int pt2 = NO_PIECE_TYPE; pt2 < pt1; ++pt2)
|
2014-12-30 02:31:50 -07:00
|
|
|
v += QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2]
|
|
|
|
+ QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2];
|
2012-12-16 04:00:54 -07:00
|
|
|
|
2014-06-20 15:15:31 -06:00
|
|
|
bonus += pieceCount[Us][pt1] * v;
|
2012-12-16 04:00:54 -07:00
|
|
|
}
|
2014-04-03 02:38:11 -06:00
|
|
|
|
2014-06-20 15:15:31 -06:00
|
|
|
return bonus;
|
2012-12-16 04:00:54 -07:00
|
|
|
}
|
|
|
|
|
2011-04-11 10:12:41 -06:00
|
|
|
} // namespace
|
2009-07-17 11:16:20 -06:00
|
|
|
|
2012-12-16 04:00:54 -07:00
|
|
|
namespace Material {
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
/// Material::probe() looks up the current position's material configuration in
|
|
|
|
/// the material hash table. It returns a pointer to the Entry if the position
|
|
|
|
/// is found. Otherwise a new Entry is computed and stored there, so we don't
|
|
|
|
/// have to recompute all when the same material configuration occurs again.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
Entry* probe(const Position& pos) {
|
2008-10-27 12:07:48 -06:00
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
Key key = pos.material_key();
|
2014-12-30 02:31:50 -07:00
|
|
|
Entry* e = pos.this_thread()->materialTable[key];
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-03-31 05:15:57 -06:00
|
|
|
if (e->key == key)
|
|
|
|
return e;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2013-07-13 09:21:24 -06:00
|
|
|
std::memset(e, 0, sizeof(Entry));
|
2012-03-31 05:15:57 -06:00
|
|
|
e->key = key;
|
|
|
|
e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
|
2017-07-09 03:45:31 -06:00
|
|
|
|
|
|
|
Value npm_w = pos.non_pawn_material(WHITE);
|
|
|
|
Value npm_b = pos.non_pawn_material(BLACK);
|
2020-03-05 10:37:08 -07:00
|
|
|
Value npm = Utility::clamp(npm_w + npm_b, EndgameLimit, MidgameLimit);
|
2017-07-09 03:45:31 -06:00
|
|
|
|
|
|
|
// Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME]
|
|
|
|
e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
|
2009-11-13 05:29:04 -07:00
|
|
|
|
2013-12-02 11:04:09 -07:00
|
|
|
// Let's look if we have a specialized evaluation function for this particular
|
|
|
|
// material configuration. Firstly we look for a fixed configuration one, then
|
|
|
|
// for a generic one if the previous search failed.
|
2019-05-15 02:41:58 -06:00
|
|
|
if ((e->evaluationFunction = Endgames::probe<Value>(key)) != nullptr)
|
2012-03-31 05:15:57 -06:00
|
|
|
return e;
|
2008-10-28 12:30:57 -06:00
|
|
|
|
2019-07-16 06:08:58 -06:00
|
|
|
for (Color c : { WHITE, BLACK })
|
2015-02-07 02:09:56 -07:00
|
|
|
if (is_KXK(pos, c))
|
|
|
|
{
|
|
|
|
e->evaluationFunction = &EvaluateKXK[c];
|
|
|
|
return e;
|
|
|
|
}
|
2011-04-11 03:32:55 -06:00
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
// OK, we didn't find any special evaluation function for the current material
|
|
|
|
// configuration. Is there a suitable specialized scaling function?
|
2019-05-15 02:41:58 -06:00
|
|
|
const auto* sf = Endgames::probe<ScaleFactor>(key);
|
2008-11-01 04:38:30 -06:00
|
|
|
|
2019-03-31 03:47:36 -06:00
|
|
|
if (sf)
|
2008-10-27 14:54:39 -06:00
|
|
|
{
|
2017-06-04 03:03:23 -06:00
|
|
|
e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned
|
2012-03-31 05:15:57 -06:00
|
|
|
return e;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
// We didn't find any specialized scaling function, so fall back on generic
|
|
|
|
// ones that refer to more than one material distribution. Note that in this
|
|
|
|
// case we don't return after setting the function.
|
2019-07-16 06:08:58 -06:00
|
|
|
for (Color c : { WHITE, BLACK })
|
2015-02-07 02:09:56 -07:00
|
|
|
{
|
Renaming some variables in code
Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.
Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426
No functional change.
2018-03-15 03:44:26 -06:00
|
|
|
if (is_KBPsK(pos, c))
|
2015-02-07 02:09:56 -07:00
|
|
|
e->scalingFunction[c] = &ScaleKBPsK[c];
|
2008-10-27 14:54:39 -06:00
|
|
|
|
2015-02-07 02:09:56 -07:00
|
|
|
else if (is_KQKRPs(pos, c))
|
|
|
|
e->scalingFunction[c] = &ScaleKQKRPs[c];
|
|
|
|
}
|
2008-10-27 14:54:39 -06:00
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board
|
2008-10-27 14:54:39 -06:00
|
|
|
{
|
2013-06-16 03:59:40 -06:00
|
|
|
if (!pos.count<PAWN>(BLACK))
|
2008-10-27 14:54:39 -06:00
|
|
|
{
|
2013-06-16 03:59:40 -06:00
|
|
|
assert(pos.count<PAWN>(WHITE) >= 2);
|
2014-12-30 02:31:50 -07:00
|
|
|
|
2012-03-31 05:15:57 -06:00
|
|
|
e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
|
2008-10-27 14:54:39 -06:00
|
|
|
}
|
2013-06-16 03:59:40 -06:00
|
|
|
else if (!pos.count<PAWN>(WHITE))
|
2008-10-27 14:54:39 -06:00
|
|
|
{
|
2013-06-16 03:59:40 -06:00
|
|
|
assert(pos.count<PAWN>(BLACK) >= 2);
|
2014-12-30 02:31:50 -07:00
|
|
|
|
2012-03-31 05:15:57 -06:00
|
|
|
e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
|
2008-10-27 14:54:39 -06:00
|
|
|
}
|
2013-06-16 03:59:40 -06:00
|
|
|
else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
|
2008-10-27 14:54:39 -06:00
|
|
|
{
|
2009-08-13 04:45:35 -06:00
|
|
|
// This is a special case because we set scaling functions
|
|
|
|
// for both colors instead of only one.
|
2012-03-31 05:15:57 -06:00
|
|
|
e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
|
|
|
|
e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
|
2008-10-27 14:54:39 -06:00
|
|
|
}
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2014-12-30 02:31:50 -07:00
|
|
|
// Zero or just one pawn makes it difficult to win, even with a small material
|
|
|
|
// advantage. This catches some trivial draws like KK, KBK and KNK and gives a
|
|
|
|
// drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN).
|
2013-06-16 03:59:40 -06:00
|
|
|
if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
|
2014-12-30 02:31:50 -07:00
|
|
|
e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW :
|
2015-10-05 20:48:47 -06:00
|
|
|
npm_b <= BishopValueMg ? 4 : 14);
|
2011-04-11 06:50:56 -06:00
|
|
|
|
2013-06-16 03:59:40 -06:00
|
|
|
if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
|
2014-12-30 02:31:50 -07:00
|
|
|
e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW :
|
2015-10-05 20:48:47 -06:00
|
|
|
npm_w <= BishopValueMg ? 4 : 14);
|
2011-04-11 03:32:55 -06:00
|
|
|
|
2013-09-04 22:34:13 -06:00
|
|
|
// Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
|
2013-12-02 11:04:09 -07:00
|
|
|
// for the bishop pair "extended piece", which allows us to be more flexible
|
2011-04-11 03:32:55 -06:00
|
|
|
// in defining bishop pair bonuses.
|
2018-03-18 16:38:58 -06:00
|
|
|
const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
|
2013-09-04 22:34:13 -06:00
|
|
|
{ pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
|
|
|
|
pos.count<BISHOP>(WHITE) , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
|
|
|
|
{ pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
|
|
|
|
pos.count<BISHOP>(BLACK) , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
|
2010-11-23 01:09:15 -07:00
|
|
|
|
2018-03-18 16:38:58 -06:00
|
|
|
e->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
|
2012-03-31 05:15:57 -06:00
|
|
|
return e;
|
2011-04-11 03:32:55 -06:00
|
|
|
}
|
|
|
|
|
2012-12-16 04:00:54 -07:00
|
|
|
} // namespace Material
|