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
|
2021-01-08 09:04:23 -07:00
|
|
|
Copyright (C) 2004-2021 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-10-26 14:44:58 -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-10-26 14:44:58 -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/>.
|
|
|
|
*/
|
|
|
|
|
2013-07-23 07:31:57 -06:00
|
|
|
#ifndef POSITION_H_INCLUDED
|
2008-08-31 23:59:13 -06:00
|
|
|
#define POSITION_H_INCLUDED
|
|
|
|
|
2011-05-17 03:47:52 -06:00
|
|
|
#include <cassert>
|
2016-04-17 13:31:19 -06:00
|
|
|
#include <deque>
|
2016-09-17 00:19:06 -06:00
|
|
|
#include <memory> // For std::unique_ptr
|
2015-01-09 04:35:44 -07:00
|
|
|
#include <string>
|
2011-05-17 03:47:52 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "bitboard.h"
|
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
|
|
|
#include "evaluate.h"
|
2021-01-12 06:59:51 -07:00
|
|
|
#include "psqt.h"
|
2011-02-23 13:27:22 -07:00
|
|
|
#include "types.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
|
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
|
|
|
#include "nnue/nnue_accumulator.h"
|
|
|
|
|
2021-02-26 02:02:13 -07:00
|
|
|
namespace Stockfish {
|
2015-01-07 01:09:41 -07:00
|
|
|
|
|
|
|
/// StateInfo struct stores information needed to restore a Position object to
|
|
|
|
/// its previous state when we retract a move. Whenever a move is made on the
|
|
|
|
/// board (by calling Position::do_move), a StateInfo object must be passed.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-22 12:16:21 -07:00
|
|
|
struct StateInfo {
|
2015-01-07 01:09:41 -07:00
|
|
|
|
|
|
|
// Copied when making a move
|
|
|
|
Key pawnKey;
|
|
|
|
Key materialKey;
|
|
|
|
Value nonPawnMaterial[COLOR_NB];
|
|
|
|
int castlingRights;
|
|
|
|
int rule50;
|
|
|
|
int pliesFromNull;
|
2011-07-20 02:45:40 -06:00
|
|
|
Square epSquare;
|
2009-03-02 09:32:30 -07:00
|
|
|
|
2016-09-17 00:19:06 -06:00
|
|
|
// Not copied when making a move (will be recomputed anyhow)
|
2015-01-07 01:09:41 -07:00
|
|
|
Key key;
|
|
|
|
Bitboard checkersBB;
|
2009-03-02 09:32:30 -07:00
|
|
|
StateInfo* previous;
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard blockersForKing[COLOR_NB];
|
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
|
|
|
Bitboard pinners[COLOR_NB];
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard checkSquares[PIECE_TYPE_NB];
|
2021-05-21 12:22:29 -06:00
|
|
|
Piece capturedPiece;
|
2020-01-09 12:49:13 -07:00
|
|
|
int repetition;
|
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
|
|
|
|
|
|
|
// Used by NNUE
|
|
|
|
Eval::NNUE::Accumulator accumulator;
|
|
|
|
DirtyPiece dirtyPiece;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2020-06-24 14:19:58 -06:00
|
|
|
|
2017-08-13 00:38:39 -06:00
|
|
|
/// A list to keep track of the position states along the setup moves (from the
|
|
|
|
/// start position to the position just before the search starts). Needed by
|
|
|
|
/// 'draw by repetition' detection. Use a std::deque because pointers to
|
|
|
|
/// elements are not invalidated upon list resizing.
|
2016-04-17 13:31:19 -06:00
|
|
|
typedef std::unique_ptr<std::deque<StateInfo>> StateListPtr;
|
2016-04-11 08:45:36 -06:00
|
|
|
|
2012-10-28 10:12:40 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
/// Position class stores information regarding the board representation as
|
|
|
|
/// pieces, side to move, hash keys, castling info, etc. Important methods are
|
|
|
|
/// do_move() and undo_move(), used by the search to update node info when
|
|
|
|
/// traversing the search tree.
|
2016-09-17 00:19:06 -06:00
|
|
|
class Thread;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
class Position {
|
|
|
|
public:
|
2015-01-07 01:09:41 -07:00
|
|
|
static void init();
|
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
Position() = default;
|
2015-01-21 05:18:19 -07:00
|
|
|
Position(const Position&) = delete;
|
2016-04-11 08:45:36 -06:00
|
|
|
Position& operator=(const Position&) = delete;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2014-11-01 11:50:27 -06:00
|
|
|
// FEN string input/output
|
2016-04-11 08:45:36 -06:00
|
|
|
Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th);
|
2016-07-16 00:10:45 -06:00
|
|
|
Position& set(const std::string& code, Color c, StateInfo* si);
|
2021-01-30 01:50:04 -07:00
|
|
|
std::string fen() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Position representation
|
2009-09-02 03:57:38 -06:00
|
|
|
Bitboard pieces(PieceType pt) const;
|
|
|
|
Bitboard pieces(PieceType pt1, PieceType pt2) const;
|
2012-05-01 05:01:38 -06:00
|
|
|
Bitboard pieces(Color c) const;
|
|
|
|
Bitboard pieces(Color c, PieceType pt) const;
|
|
|
|
Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
|
2012-04-02 11:21:17 -06:00
|
|
|
Piece piece_on(Square s) const;
|
|
|
|
Square ep_square() const;
|
2013-09-28 06:43:50 -06:00
|
|
|
bool empty(Square s) const;
|
2013-06-16 03:59:40 -06:00
|
|
|
template<PieceType Pt> int count(Color c) const;
|
2017-03-08 19:45:09 -07:00
|
|
|
template<PieceType Pt> int count() const;
|
2015-08-04 01:00:52 -06:00
|
|
|
template<PieceType Pt> Square square(Color c) const;
|
2019-05-29 02:00:32 -06:00
|
|
|
bool is_on_semiopen_file(Color c, Square s) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Castling
|
2020-05-23 05:26:13 -06:00
|
|
|
CastlingRights castling_rights(Color c) const;
|
2019-08-12 08:42:28 -06:00
|
|
|
bool can_castle(CastlingRights cr) const;
|
|
|
|
bool castling_impeded(CastlingRights cr) const;
|
|
|
|
Square castling_rook_square(CastlingRights cr) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Checking
|
|
|
|
Bitboard checkers() const;
|
2018-02-26 17:18:33 -07:00
|
|
|
Bitboard blockers_for_king(Color c) const;
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard check_squares(PieceType pt) const;
|
2020-07-11 08:59:33 -06:00
|
|
|
Bitboard pinners(Color c) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Attacks to/from a given square
|
2009-09-20 02:31:48 -06:00
|
|
|
Bitboard attackers_to(Square s) const;
|
2014-12-07 16:53:33 -07:00
|
|
|
Bitboard attackers_to(Square s, Bitboard occupied) const;
|
2016-09-12 00:47:19 -06:00
|
|
|
Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Properties of moves
|
2016-07-03 02:35:44 -06:00
|
|
|
bool legal(Move m) const;
|
2013-09-28 06:43:50 -06:00
|
|
|
bool pseudo_legal(const Move m) const;
|
|
|
|
bool capture(Move m) const;
|
|
|
|
bool capture_or_promotion(Move m) const;
|
2016-07-03 02:35:44 -06:00
|
|
|
bool gives_check(Move m) const;
|
2013-09-28 06:43:50 -06:00
|
|
|
Piece moved_piece(Move m) const;
|
2016-09-03 10:14:01 -06:00
|
|
|
Piece captured_piece() const;
|
2010-03-08 06:57:01 -07:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Piece specific
|
2013-09-28 06:43:50 -06:00
|
|
|
bool pawn_passed(Color c, Square s) const;
|
|
|
|
bool opposite_bishops() const;
|
2019-04-16 15:10:53 -06:00
|
|
|
int pawns_on_same_color_squares(Color c, Square s) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Doing and undoing moves
|
2016-11-11 06:02:28 -07:00
|
|
|
void do_move(Move m, StateInfo& newSt);
|
2016-11-03 04:45:39 -06:00
|
|
|
void do_move(Move m, StateInfo& newSt, bool givesCheck);
|
2009-02-22 09:49:52 -07:00
|
|
|
void undo_move(Move m);
|
2016-11-03 04:45:39 -06:00
|
|
|
void do_null_move(StateInfo& newSt);
|
2013-01-27 03:45:01 -07:00
|
|
|
void undo_null_move();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2016-09-17 00:19:06 -06:00
|
|
|
// Static Exchange Evaluation
|
2017-06-24 04:36:07 -06:00
|
|
|
bool see_ge(Move m, Value threshold = VALUE_ZERO) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Accessing hash keys
|
2011-12-25 03:50:59 -07:00
|
|
|
Key key() const;
|
2014-10-03 22:07:55 -06:00
|
|
|
Key key_after(Move m) const;
|
2011-12-25 03:50:59 -07:00
|
|
|
Key material_key() const;
|
2015-01-07 01:09:41 -07:00
|
|
|
Key pawn_key() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-01-10 03:57:06 -07:00
|
|
|
// Other properties of the position
|
2012-04-02 11:21:17 -06:00
|
|
|
Color side_to_move() const;
|
2013-02-16 04:42:22 -07:00
|
|
|
int game_ply() const;
|
2011-01-03 14:31:17 -07:00
|
|
|
bool is_chess960() const;
|
2012-04-06 11:36:46 -06:00
|
|
|
Thread* this_thread() const;
|
Threefold repetition detection
Implement a threefold repetition detection. Below are the examples of
problems fixed by this change.
Loosing move in a drawn position.
position fen 8/k7/3p4/p2P1p2/P2P1P2/8/8/K7 w - - 0 1 moves a1a2 a7a8 a2a1
The old code suggested a loosing move "bestmove a8a7", the new code suggests "bestmove a8b7" leading to a draw.
Incorrect evaluation (happened in a real game in TCEC Season 9).
position fen 4rbkr/1q3pp1/b3pn2/7p/1pN5/1P1BBP1P/P1R2QP1/3R2K1 w - - 5 31 moves e3d4 h8h6 d4e3
The old code evaluated it as "cp 0", the new code evaluation is around "cp -50" which is adequate.
Brings 0.5-1 ELO gain. Passes [-3.00,1.00].
STC: http://tests.stockfishchess.org/tests/view/584ece040ebc5903140c5aea
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 47744 W: 8537 L: 8461 D: 30746
LTC: http://tests.stockfishchess.org/tests/view/584f134d0ebc5903140c5b37
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 36775 W: 4739 L: 4639 D: 27397
Patch has been rewritten into current form for simplification and
logic slightly changed so that return a draw score if the position
repeats once earlier but after or at the root, or repeats twice
strictly before the root. In its original form, repetition at root
was not returned as an immediate draw.
After retestimng testing both version with SPRT[-3, 1], both passed
succesfully, but this version was chosen becuase more natural. There is
an argument about MultiPV in which an extended draw at root may be sensible.
See discussion here:
https://github.com/official-stockfish/Stockfish/pull/925
For documentation, current version passed both at STC and LTC:
STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 51562 W: 9314 L: 9245 D: 33003
LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 115663 W: 14904 L: 14906 D: 85853
bench: 5468995
2016-12-12 08:04:16 -07:00
|
|
|
bool is_draw(int ply) const;
|
Use cycle detection to bound search value
A position which has a move which draws by repetition, or which could have
been reached from an earlier position in the game tree, is considered to be
at least a draw for the side to move.
Cycle detection algorithm by Marcel van Kervink:
https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf
----------------------------
How does the algorithm work in practice? The algorithm is an efficient
method to detect if the side to move has a drawing move, without doing any
move generation, thus possibly giving a cheap cutoffThe most interesting
conditions are both on line 1195:
```
if ( originalKey == (progressKey ^ stp->key)
|| progressKey == Zobrist::side)
```
This uses the position keys as a sort-of Bloom filter, to avoid the expensive
checks which follow. For "upcoming repetition" consider the opening Nf3 Nf6 Ng1.
The XOR of this position's key with the starting position gives their difference,
which can be used to look up black's repeating move (Ng8). But that look-up is
expensive, so line 1195 checks that the white pieces are on their original squares.
This is the subtlest part of the algorithm, but the basic idea in the above game
is there are 4 positions (starting position and the one after each move). An XOR
of the first pair (startpos and after Nf3) gives a key matching Nf3. An XOR of
the second pair (after Nf6 and after Ng1) gives a key matching the move Ng1. But
since the difference in each pair is the location of the white knight those keys
are "identical" (not quite because while there are 4 keys the the side to move
changed 3 times, so the keys differ by Zobrist::side). The loop containing line
1195 does this pair-wise XOR-ing.
Continuing the example, after line 1195 determines that the white pieces are
back where they started we still need to make sure the changes in the black
pieces represents a legal move. This is done by looking up the "moveKey" to
see if it corresponds to possible move, and that there are no pieces blocking
its way. There is the additional complication that, to match the behavior of
is_draw(), if the repetition is not inside the search tree then there must be
an additional repetition in the game history. Since a position can have more
than one upcoming repetition a simple count does not suffice. So there is a
search loop ending on line 1215.
On the other hand, the "no-progress' is the same thing but offset by 1 ply.
I like the concept but think it currently has minimal or negative benefit,
and I'd be happy to remove it if that would get the patch accepted. This
will not, however, save many lines of code.
-----------------------------
STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 36430 W: 7446 L: 7150 D: 21834
http://tests.stockfishchess.org/tests/view/5afc123f0ebc591fdf408dfc
LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 12998 W: 2045 L: 1876 D: 9077
http://tests.stockfishchess.org/tests/view/5afc2c630ebc591fdf408e0c
How could we continue after the patch:
• The code in search() that checks for cycles has numerous possible variants.
Perhaps the check need could be done in qsearch() too.
• The biggest improvement would be to get "no progress" to be of actual benefit,
and it would be helpful understand why it (probably) isn't. Perhaps there is an
interaction with the transposition table or the (fantastically complex) tree
search. Perhaps this would be hard to fix, but there may be a simple oversight.
Closes https://github.com/official-stockfish/Stockfish/pull/1575
Bench: 4550412
2018-05-16 14:47:41 -06:00
|
|
|
bool has_game_cycle(int ply) const;
|
2018-04-18 10:38:38 -06:00
|
|
|
bool has_repeated() const;
|
2015-01-18 00:05:05 -07:00
|
|
|
int rule50_count() const;
|
2015-01-07 01:09:41 -07:00
|
|
|
Score psq_score() const;
|
|
|
|
Value non_pawn_material(Color c) const;
|
2017-03-08 19:45:09 -07:00
|
|
|
Value non_pawn_material() const;
|
2010-07-11 10:23:50 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Position consistency check, for debugging
|
2017-06-24 04:36:07 -06:00
|
|
|
bool pos_is_ok() const;
|
2012-04-02 11:21:17 -06:00
|
|
|
void flip();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
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
|
|
|
// Used by NNUE
|
|
|
|
StateInfo* state() const;
|
|
|
|
|
2021-06-17 04:36:06 -06:00
|
|
|
void put_piece(Piece pc, Square s);
|
|
|
|
void remove_piece(Square s);
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
private:
|
2012-04-02 11:21:17 -06:00
|
|
|
// Initialization helpers (used while setting up a position)
|
2014-03-08 07:08:55 -07:00
|
|
|
void set_castling_right(Color c, Square rfrom);
|
2014-03-12 15:46:17 -06:00
|
|
|
void set_state(StateInfo* si) const;
|
2016-08-27 02:05:42 -06:00
|
|
|
void set_check_info(StateInfo* si) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Other helpers
|
2019-12-21 15:36:29 -07:00
|
|
|
void move_piece(Square from, Square to);
|
2014-03-13 05:53:03 -06:00
|
|
|
template<bool Do>
|
2015-02-08 05:21:50 -07:00
|
|
|
void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
|
2008-10-23 13:43:48 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Data members
|
2012-10-21 02:41:23 -06:00
|
|
|
Piece board[SQUARE_NB];
|
|
|
|
Bitboard byTypeBB[PIECE_TYPE_NB];
|
|
|
|
Bitboard byColorBB[COLOR_NB];
|
2016-09-03 10:14:01 -06:00
|
|
|
int pieceCount[PIECE_NB];
|
2014-03-08 07:08:55 -07:00
|
|
|
int castlingRightsMask[SQUARE_NB];
|
|
|
|
Square castlingRookSquare[CASTLING_RIGHT_NB];
|
|
|
|
Bitboard castlingPath[CASTLING_RIGHT_NB];
|
2021-05-21 12:22:29 -06:00
|
|
|
Thread* thisThread;
|
|
|
|
StateInfo* st;
|
2013-02-16 04:42:22 -07:00
|
|
|
int gamePly;
|
2011-07-02 04:01:12 -06:00
|
|
|
Color sideToMove;
|
2018-06-09 05:45:49 -06:00
|
|
|
Score psq;
|
2014-02-18 00:30:13 -07:00
|
|
|
bool chess960;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2016-11-27 01:11:56 -07:00
|
|
|
extern std::ostream& operator<<(std::ostream& os, const Position& pos);
|
2015-11-07 23:26:39 -07:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline Color Position::side_to_move() const {
|
|
|
|
return sideToMove;
|
2010-10-31 03:55:28 -06:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Piece Position::piece_on(Square s) const {
|
2020-03-25 19:57:36 -06:00
|
|
|
assert(is_ok(s));
|
2008-08-31 23:59:13 -06:00
|
|
|
return board[s];
|
|
|
|
}
|
|
|
|
|
2020-03-25 19:57:36 -06:00
|
|
|
inline bool Position::empty(Square s) const {
|
|
|
|
return piece_on(s) == NO_PIECE;
|
2012-01-09 14:34:00 -07:00
|
|
|
}
|
|
|
|
|
2020-03-25 19:57:36 -06:00
|
|
|
inline Piece Position::moved_piece(Move m) const {
|
|
|
|
return piece_on(from_sq(m));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2020-03-25 19:57:36 -06:00
|
|
|
inline Bitboard Position::pieces(PieceType pt = ALL_PIECES) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
return byTypeBB[pt];
|
|
|
|
}
|
|
|
|
|
2009-09-02 03:57:38 -06:00
|
|
|
inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return pieces(pt1) | pieces(pt2);
|
2009-09-02 03:57:38 -06:00
|
|
|
}
|
|
|
|
|
2012-05-01 05:01:38 -06:00
|
|
|
inline Bitboard Position::pieces(Color c) const {
|
|
|
|
return byColorBB[c];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(Color c, PieceType pt) const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return pieces(c) & pieces(pt);
|
2012-05-01 05:01:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return pieces(c) & (pieces(pt1) | pieces(pt2));
|
2009-09-02 03:57:38 -06:00
|
|
|
}
|
|
|
|
|
2013-06-16 03:59:40 -06:00
|
|
|
template<PieceType Pt> inline int Position::count(Color c) const {
|
2016-09-03 10:14:01 -06:00
|
|
|
return pieceCount[make_piece(c, Pt)];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2017-03-08 19:45:09 -07:00
|
|
|
template<PieceType Pt> inline int Position::count() const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return count<Pt>(WHITE) + count<Pt>(BLACK);
|
2017-03-08 19:45:09 -07:00
|
|
|
}
|
|
|
|
|
2015-08-04 01:00:52 -06:00
|
|
|
template<PieceType Pt> inline Square Position::square(Color c) const {
|
Remove piece lists
This patch removes the incrementally updated piece lists from the Position object.
This has been tried before but always failed. My reasons for trying again are:
* 32-bit systems (including phones) are now much less important than they were some years ago (and are absent from fishtest);
* NNUE may have made SF less finely tuned to the order in which moves were generated.
STC:
LLR: 2.94 (-2.94,2.94) {-1.25,0.25}
Total: 55272 W: 5260 L: 5216 D: 44796
Ptnml(0-2): 208, 4147, 18898, 4159, 224
https://tests.stockfishchess.org/tests/view/5fc2986a42a050a89f02c926
LTC:
LLR: 2.96 (-2.94,2.94) {-0.75,0.25}
Total: 16600 W: 673 L: 608 D: 15319
Ptnml(0-2): 14, 533, 7138, 604, 11
https://tests.stockfishchess.org/tests/view/5fc2f98342a050a89f02c95c
closes https://github.com/official-stockfish/Stockfish/pull/3247
Bench: 3940967
2020-11-29 04:05:26 -07:00
|
|
|
assert(count<Pt>(c) == 1);
|
|
|
|
return lsb(pieces(c, Pt));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline Square Position::ep_square() const {
|
|
|
|
return st->epSquare;
|
|
|
|
}
|
|
|
|
|
2019-05-29 02:00:32 -06:00
|
|
|
inline bool Position::is_on_semiopen_file(Color c, Square s) const {
|
|
|
|
return !(pieces(c, PAWN) & file_bb(s));
|
2019-04-16 08:09:36 -06:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline bool Position::can_castle(CastlingRights cr) const {
|
2014-03-08 07:08:55 -07:00
|
|
|
return st->castlingRights & cr;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2020-05-23 05:26:13 -06:00
|
|
|
inline CastlingRights Position::castling_rights(Color c) const {
|
2020-04-29 09:39:25 -06:00
|
|
|
return c & CastlingRights(st->castlingRights);
|
2011-06-11 05:41:20 -06:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline bool Position::castling_impeded(CastlingRights cr) const {
|
2020-01-09 12:49:13 -07:00
|
|
|
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
|
|
|
|
|
2020-03-25 19:57:36 -06:00
|
|
|
return pieces() & castlingPath[cr];
|
2012-02-27 04:11:18 -07:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline Square Position::castling_rook_square(CastlingRights cr) const {
|
2020-01-09 12:49:13 -07:00
|
|
|
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
return castlingRookSquare[cr];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-10-22 07:21:57 -06:00
|
|
|
inline Bitboard Position::attackers_to(Square s) const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return attackers_to(s, pieces());
|
2011-10-22 07:21:57 -06:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Bitboard Position::checkers() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->checkersBB;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2018-02-26 17:18:33 -07:00
|
|
|
inline Bitboard Position::blockers_for_king(Color c) const {
|
|
|
|
return st->blockersForKing[c];
|
2020-07-11 08:59:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pinners(Color c) const {
|
|
|
|
return st->pinners[c];
|
2016-07-03 02:35:44 -06:00
|
|
|
}
|
|
|
|
|
2016-08-27 02:05:42 -06:00
|
|
|
inline Bitboard Position::check_squares(PieceType pt) const {
|
|
|
|
return st->checkSquares[pt];
|
2011-10-30 11:16:28 -06:00
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::pawn_passed(Color c, Square s) const {
|
2019-02-08 02:36:03 -07:00
|
|
|
return !(pieces(~c, PAWN) & passed_pawn_span(c, s));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2019-04-16 15:10:53 -06:00
|
|
|
inline int Position::pawns_on_same_color_squares(Color c, Square s) const {
|
|
|
|
return popcount(pieces(c, PAWN) & ((DarkSquares & s) ? DarkSquares : ~DarkSquares));
|
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::key() const {
|
Improve play for closed positions
This patch give a small bonus to incite the attacking side to keep more
pawns on the board.
A consequence of this bonus is that Stockfish will tend to play positions
slightly more closed on average than master, especially when it believes
that it has an advantage.
To lower the risk of blockades where Stockfish start shuffling without
progress, we also implement a progressive decrease of the evaluation
value with the 50 moves counter (along with the necessary aging of the
transposition table to reduce the impact of the Graph History Interaction
problem): since the evaluation decreases during shuffling phases, the
engine will tend to examine the consequences of pawn breaks faster during
the search.
Passed STC:
LLR: 2.96 (-2.94,2.94) {-0.25,1.25}
Total: 26184 W: 2406 L: 2252 D: 21526
Ptnml(0-2): 85, 1784, 9223, 1892, 108
https://tests.stockfishchess.org/tests/view/600cc08b735dd7f0f0352c06
Passed LCT:
LLR: 2.95 (-2.94,2.94) {0.25,1.25}
Total: 199768 W: 7695 L: 7191 D: 184882
Ptnml(0-2): 85, 6478, 86269, 6952, 100
https://tests.stockfishchess.org/tests/view/600ccd28735dd7f0f0352c10
Closes https://github.com/official-stockfish/Stockfish/pull/3321
Bench: 3988915
2021-01-21 10:53:29 -07:00
|
|
|
return st->rule50 < 14 ? st->key
|
|
|
|
: st->key ^ make_key((st->rule50 - 14) / 8);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::pawn_key() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->pawnKey;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::material_key() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->materialKey;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
inline Score Position::psq_score() const {
|
2018-06-09 05:45:49 -06:00
|
|
|
return psq;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Value Position::non_pawn_material(Color c) const {
|
2014-12-07 16:53:33 -07:00
|
|
|
return st->nonPawnMaterial[c];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2017-03-08 19:45:09 -07:00
|
|
|
inline Value Position::non_pawn_material() const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return non_pawn_material(WHITE) + non_pawn_material(BLACK);
|
2017-03-08 19:45:09 -07:00
|
|
|
}
|
|
|
|
|
2013-02-16 04:42:22 -07:00
|
|
|
inline int Position::game_ply() const {
|
|
|
|
return gamePly;
|
2010-07-11 10:23:50 -06:00
|
|
|
}
|
|
|
|
|
2015-01-18 00:05:05 -07:00
|
|
|
inline int Position::rule50_count() const {
|
|
|
|
return st->rule50;
|
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline bool Position::opposite_bishops() const {
|
2020-03-25 19:57:36 -06:00
|
|
|
return count<BISHOP>(WHITE) == 1
|
|
|
|
&& count<BISHOP>(BLACK) == 1
|
2015-08-04 01:00:52 -06:00
|
|
|
&& opposite_colors(square<BISHOP>(WHITE), square<BISHOP>(BLACK));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-01-03 14:31:17 -07:00
|
|
|
inline bool Position::is_chess960() const {
|
2011-04-04 01:53:44 -06:00
|
|
|
return chess960;
|
2011-01-03 14:31:17 -07:00
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::capture_or_promotion(Move m) const {
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2013-12-06 02:43:17 -07:00
|
|
|
return type_of(m) != NORMAL ? type_of(m) != CASTLING : !empty(to_sq(m));
|
2011-06-22 16:04:57 -06:00
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::capture(Move m) const {
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2016-09-17 00:19:06 -06:00
|
|
|
// Castling is encoded as "king captures rook"
|
2021-01-09 08:46:06 -07:00
|
|
|
return (!empty(to_sq(m)) && type_of(m) != CASTLING) || type_of(m) == EN_PASSANT;
|
2009-10-21 04:41:24 -06:00
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline Piece Position::captured_piece() const {
|
|
|
|
return st->capturedPiece;
|
2010-03-08 06:57:01 -07:00
|
|
|
}
|
|
|
|
|
2012-04-06 11:36:46 -06:00
|
|
|
inline Thread* Position::this_thread() const {
|
|
|
|
return thisThread;
|
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline void Position::put_piece(Piece pc, Square s) {
|
2013-08-01 07:58:38 -06:00
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
board[s] = pc;
|
2020-05-23 05:26:13 -06:00
|
|
|
byTypeBB[ALL_PIECES] |= byTypeBB[type_of(pc)] |= s;
|
2016-09-03 10:14:01 -06:00
|
|
|
byColorBB[color_of(pc)] |= s;
|
Remove piece lists
This patch removes the incrementally updated piece lists from the Position object.
This has been tried before but always failed. My reasons for trying again are:
* 32-bit systems (including phones) are now much less important than they were some years ago (and are absent from fishtest);
* NNUE may have made SF less finely tuned to the order in which moves were generated.
STC:
LLR: 2.94 (-2.94,2.94) {-1.25,0.25}
Total: 55272 W: 5260 L: 5216 D: 44796
Ptnml(0-2): 208, 4147, 18898, 4159, 224
https://tests.stockfishchess.org/tests/view/5fc2986a42a050a89f02c926
LTC:
LLR: 2.96 (-2.94,2.94) {-0.75,0.25}
Total: 16600 W: 673 L: 608 D: 15319
Ptnml(0-2): 14, 533, 7138, 604, 11
https://tests.stockfishchess.org/tests/view/5fc2f98342a050a89f02c95c
closes https://github.com/official-stockfish/Stockfish/pull/3247
Bench: 3940967
2020-11-29 04:05:26 -07:00
|
|
|
pieceCount[pc]++;
|
2016-09-03 10:14:01 -06:00
|
|
|
pieceCount[make_piece(color_of(pc), ALL_PIECES)]++;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq += PSQT::psq[pc][s];
|
2013-07-29 09:44:58 -06:00
|
|
|
}
|
|
|
|
|
2019-12-21 15:36:29 -07:00
|
|
|
inline void Position::remove_piece(Square s) {
|
2013-08-01 07:58:38 -06:00
|
|
|
|
2019-12-21 15:36:29 -07:00
|
|
|
Piece pc = board[s];
|
2013-08-01 07:58:38 -06:00
|
|
|
byTypeBB[ALL_PIECES] ^= s;
|
2016-09-03 10:14:01 -06:00
|
|
|
byTypeBB[type_of(pc)] ^= s;
|
|
|
|
byColorBB[color_of(pc)] ^= s;
|
2021-06-17 04:36:06 -06:00
|
|
|
board[s] = NO_PIECE;
|
Remove piece lists
This patch removes the incrementally updated piece lists from the Position object.
This has been tried before but always failed. My reasons for trying again are:
* 32-bit systems (including phones) are now much less important than they were some years ago (and are absent from fishtest);
* NNUE may have made SF less finely tuned to the order in which moves were generated.
STC:
LLR: 2.94 (-2.94,2.94) {-1.25,0.25}
Total: 55272 W: 5260 L: 5216 D: 44796
Ptnml(0-2): 208, 4147, 18898, 4159, 224
https://tests.stockfishchess.org/tests/view/5fc2986a42a050a89f02c926
LTC:
LLR: 2.96 (-2.94,2.94) {-0.75,0.25}
Total: 16600 W: 673 L: 608 D: 15319
Ptnml(0-2): 14, 533, 7138, 604, 11
https://tests.stockfishchess.org/tests/view/5fc2f98342a050a89f02c95c
closes https://github.com/official-stockfish/Stockfish/pull/3247
Bench: 3940967
2020-11-29 04:05:26 -07:00
|
|
|
pieceCount[pc]--;
|
2016-09-03 10:14:01 -06:00
|
|
|
pieceCount[make_piece(color_of(pc), ALL_PIECES)]--;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq -= PSQT::psq[pc][s];
|
2013-07-29 09:44:58 -06:00
|
|
|
}
|
|
|
|
|
2019-12-21 15:36:29 -07:00
|
|
|
inline void Position::move_piece(Square from, Square to) {
|
2015-02-08 05:21:50 -07:00
|
|
|
|
2019-12-21 15:36:29 -07:00
|
|
|
Piece pc = board[from];
|
Make Square and Bitboard operators commutative
As Stockfish developers, we aim to make our code as legible and as close
to simple English as possible. However, one of the more notable exceptions
to this rule concerns operations between Squares and Bitboards.
Prior to this pull request, AND, OR, and XOR were only defined when the
Bitboard was the first operand, and the Square the second. For example,
for a Bitboard b and Square s, "b & s" would be valid but "s & b" would not.
This conflicts with natural reasoning about logical operators, both
mathematically and intuitively, which says that logical operators should
commute.
More dangerously, however, both Square and Bitboard are defined as integers
"under the hood." As a result, code like "s & b" would still compile and give
reasonable bench values. This trap occasionally ensnares even experienced
Stockfish developers, but it is especially dangerous for new developers not
aware of this peculiarity. Because there is no compilation or runtime error,
and a reasonable bench, only a close review by approvers can spot this error
when a test has been submitted--and many times, these bugs have slipped past
review. This is by far the most common logical error on Fishtest, and has
wasted uncountable STC games over the years.
However, it can be fixed by adding three non-functional lines of code. In this
patch, we define the operators when the operands are provided in the opposite
order, i.e., we make AND, OR, and XOR commutative for Bitboards and Squares.
Because these are inline methods and implemented identically, the executable
does not change at all.
This patch has the small side-effect of requiring Squares to be explicitly
cast to integers before AND, OR, or XOR with integers. This is only performed
twice in Stockfish's source code, and again does not change the executable at
all (since Square is an enum defined as an integer anyway).
For demonstration purposes, this pull request also inverts the order of one AND
and one OR, to show that neither the bench nor the executable change. (This
change can be removed before merging, if preferred.)
I hope that this pull request significantly lowers the barrier-of-entry for new
developer to join the Stockfish project. I also hope that this change will improve
our efficiency in using our generous CPU donors' machines, since it will remove
one of the most common causes of buggy tests.
Following helpful review and comments by Michael Stembera (@mstembera), we add
a further clean-up by implementing OR for two Squares, to anticipate additional
traps developers may encounter and handle them cleanly.
Closes https://github.com/official-stockfish/Stockfish/pull/2387
No functional change.
2019-10-31 22:27:19 -06:00
|
|
|
Bitboard fromTo = from | to;
|
2018-06-02 09:41:37 -06:00
|
|
|
byTypeBB[ALL_PIECES] ^= fromTo;
|
|
|
|
byTypeBB[type_of(pc)] ^= fromTo;
|
|
|
|
byColorBB[color_of(pc)] ^= fromTo;
|
2015-02-08 05:21:50 -07:00
|
|
|
board[from] = NO_PIECE;
|
2016-09-03 10:14:01 -06:00
|
|
|
board[to] = pc;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
|
2015-02-08 05:21:50 -07:00
|
|
|
}
|
|
|
|
|
2016-11-11 06:02:28 -07:00
|
|
|
inline void Position::do_move(Move m, StateInfo& newSt) {
|
|
|
|
do_move(m, newSt, gives_check(m));
|
|
|
|
}
|
|
|
|
|
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
|
|
|
inline StateInfo* Position::state() const {
|
|
|
|
|
|
|
|
return st;
|
|
|
|
}
|
|
|
|
|
2021-02-26 02:02:13 -07:00
|
|
|
} // namespace Stockfish
|
|
|
|
|
2013-07-23 07:31:57 -06:00
|
|
|
#endif // #ifndef POSITION_H_INCLUDED
|