def _run_single_playout(self,
state: GameState,
parent_node: Node,
depth=1,
mv_list=[]): #, pipe_id):
"""
This function works recursively until a terminal node is reached
:param state: Current game-state for the evaluation. This state differs between the treads
:param parent_node: Current parent-node of the selected node. In the first expansion this is the root node.
:param depth: Current depth for the evaluation. Depth is increased by 1 for every recusive call
:param mv_list: List of moves which have been taken in the current path. For each selected child node this list
is expanded by one move recursively.
:return: -value: The inverse value prediction of the current board state. The flipping by -1 each turn is needed
because the point of view changes each half-move
depth: Current depth reach by this evaluation
mv_list: List of moves which have been selected
"""
# select a legal move on the chess board
node, move, child_idx = self._select_node(parent_node)
if move is None:
raise Exception(
"Illegal tree setup. A 'None' move was selected which souldn't be possible"
)
# update the visit counts to this node
# temporarily reduce the attraction of this node by applying a virtual loss /
# the effect of virtual loss will be undone if the playout is over
parent_node.apply_virtual_loss_to_child(child_idx, self.virtual_loss)
# apply the selected move on the board
state.apply_move(move)
# append the selected move to the move list
mv_list.append(move)
if node is None:
# get the board-fen which is used as an identifier for the board positions in the look-up table
board_fen = state.get_board_fen()
# check if the addressed fen exist in the look-up table
if board_fen in self.node_lookup:
# get the node from the look-up list
node = self.node_lookup[board_fen]
with parent_node.lock:
# setup a new connection from the parent to the child
parent_node.child_nodes[child_idx] = node
# get the prior value from the leaf node which has already been expanded
#value = node.v
# get the value from the leaf node (the current function is called recursively)
value, depth, mv_list = self._run_single_playout(
state, node, depth + 1, mv_list)
else:
# expand and evaluate the new board state (the node wasn't found in the look-up table)
# its value will be backpropagated through the tree and flipped after every layer
# receive a free available pipe
my_pipe = self.my_pipe_endings.pop()
my_pipe.send(state.get_state_planes())
# this pipe waits for the predictions of the network inference service
[value, policy_vec] = my_pipe.recv()
# put the used pipe back into the list
self.my_pipe_endings.append(my_pipe)
# initialize is_leaf by default to false
is_leaf = False
# check if the current player has won the game
# (we don't need to check for is_lost() because the game is already over
# if the current player checkmated his opponent)
if state.is_won() is True:
value = -1
is_leaf = True
legal_moves = []
p_vec_small = None
# check if you can claim a draw - its assumed that the draw is always claimed
elif state.is_draw() is True:
value = 0
is_leaf = True
legal_moves = []
p_vec_small = None
else:
# get the current legal move of its board state
legal_moves = list(state.get_legal_moves())
if len(legal_moves) < 1:
raise Exception(
'No legal move is available for state: %s' % state)
# extract a sparse policy vector with normalized probabilities
try:
p_vec_small = get_probs_of_move_list(
policy_vec,
legal_moves,
is_white_to_move=state.is_white_to_move(),
normalize=True)
except KeyError:
raise Exception('Key Error for state: %s' % state)
# convert all legal moves to a string if the option check_mate_in_one was enabled
if self.check_mate_in_one is True:
str_legal_moves = str(state.get_legal_moves())
else:
str_legal_moves = ''
# create a new node
new_node = Node(value, p_vec_small, legal_moves,
str_legal_moves, is_leaf)
#if is_leaf is False:
# test of adding dirichlet noise to a new node
# new_node.apply_dirichlet_noise_to_prior_policy(epsilon=self.dirichlet_epsilon/4, alpha=self.dirichlet_alpha)
# include a reference to the new node in the look-up table
self.node_lookup[board_fen] = new_node
with parent_node.lock:
# add the new node to its parent
parent_node.child_nodes[child_idx] = new_node
# check if the new node has a mate_in_one connection (if yes overwrite the network prediction)
if new_node.mate_child_idx is not None:
value = 1
# check if we have reached a leaf node
elif node.is_leaf is True:
value = node.v
# receive a free available pipe
my_pipe = self.my_pipe_endings.pop()
my_pipe.send(state.get_state_planes())
# this pipe waits for the predictions of the network inference service
[_, _] = my_pipe.recv()
# put the used pipe back into the list
self.my_pipe_endings.append(my_pipe)
else:
# get the value from the leaf node (the current function is called recursively)
value, depth, mv_list = self._run_single_playout(
state, node, depth + 1, mv_list)
# revert the virtual loss and apply the predicted value by the network to the node
parent_node.revert_virtual_loss_and_update(child_idx,
self.virtual_loss, -value)
# we invert the value prediction for the parent of the above node layer because the player's turn is flipped every turn
return -value, depth, mv_list
def _run_single_playout(self,
state: GameState,
parent_node: Node,
pipe_id=0,
depth=1,
chosen_nodes=[]):
"""
This function works recursively until a leaf or terminal node is reached.
It ends by backpropagating the value of the new expanded node or by propagating the value of a terminal state.
:param state_: Current game-state for the evaluation. This state differs between the treads
:param parent_node: Current parent-node of the selected node. In the first expansion this is the root node.
:param depth: Current depth for the evaluation. Depth is increased by 1 for every recusive call
:param chosen_nodes: List of moves which have been taken in the current path. For each selected child node this list
is expanded by one move recursively.
:param chosen_nodes: List of all nodes that this thread has explored with respect to the root node
:return: -value: The inverse value prediction of the current board state. The flipping by -1 each turn is needed
because the point of view changes each half-move
depth: Current depth reach by this evaluation
mv_list: List of moves which have been selected
"""
# select a legal move on the chess board
node, move, child_idx = self._select_node(parent_node)
if move is None:
raise Exception(
"Illegal tree setup. A 'None' move was selected which souldn't be possible"
)
# update the visit counts to this node
# temporarily reduce the attraction of this node by applying a virtual loss /
# the effect of virtual loss will be undone if the playout is over
parent_node.apply_virtual_loss_to_child(child_idx, self.virtual_loss)
if depth == 1:
state = GameState(deepcopy(state.get_pythonchess_board()))
# apply the selected move on the board
state.apply_move(move)
# append the selected move to the move list
# append the chosen child idx to the chosen_nodes list
chosen_nodes.append(child_idx)
if node is None:
# get the transposition-key which is used as an identifier for the board positions in the look-up table
transposition_key = state.get_transposition_key()
# check if the addressed fen exist in the look-up table
# note: It's important to use also the halfmove-counter here, otherwise the system can create an infinite
# feed-back-loop
key = (transposition_key, state.get_halfmove_counter())
# expand and evaluate the new board state (the node wasn't found in the look-up table)
# its value will be backpropagated through the tree and flipped after every layer
# receive a free available pipe
my_pipe = self.my_pipe_endings[pipe_id]
if self.send_batches is True:
my_pipe.send(state.get_state_planes())
# this pipe waits for the predictions of the network inference service
[value, policy_vec] = my_pipe.recv()
else:
state_planes = state.get_state_planes()
self.batch_state_planes[pipe_id] = state_planes
my_pipe.send(pipe_id)
result_channel = my_pipe.recv()
value = np.array(self.batch_value_results[result_channel])
policy_vec = np.array(
self.batch_policy_results[result_channel])
# initialize is_leaf by default to false
is_leaf = False
# check if the current player has won the game
# (we don't need to check for is_lost() because the game is already over
# if the current player checkmated his opponent)
is_won = False
is_check = False
if state.is_check() is True:
is_check = True
if state.is_won() is True:
is_won = True
if is_won is True:
value = -1
is_leaf = True
legal_moves = []
p_vec_small = None
# establish a mate in one connection in order to stop exploring different alternatives
parent_node.mate_child_idx = child_idx
# get the value from the leaf node (the current function is called recursively)
# check if you can claim a draw - its assumed that the draw is always claimed
elif self.can_claim_threefold_repetition(transposition_key, chosen_nodes) or \
state.get_pythonchess_board().can_claim_fifty_moves() is True:
value = 0
is_leaf = True
legal_moves = []
p_vec_small = None
else:
# get the current legal move of its board state
legal_moves = state.get_legal_moves()
if len(legal_moves) < 1:
raise Exception(
'No legal move is available for state: %s' % state)
# extract a sparse policy vector with normalized probabilities
try:
p_vec_small = get_probs_of_move_list(
policy_vec,
legal_moves,
is_white_to_move=state.is_white_to_move(),
normalize=True)
except KeyError:
raise Exception('Key Error for state: %s' % state)
# convert all legal moves to a string if the option check_mate_in_one was enabled
if self.check_mate_in_one is True:
str_legal_moves = str(state.get_legal_moves())
else:
str_legal_moves = ''
# clip the visit nodes for all nodes in the search tree except the director opp. move
clip_low_visit = self.use_pruning and depth != 1
# create a new node
new_node = Node(value, p_vec_small, legal_moves, str_legal_moves,
is_leaf, transposition_key, clip_low_visit)
if depth == 1:
# disable uncertain moves from being visited by giving them a very bad score
if is_leaf is False:
if self.root_node_prior_policy[
child_idx] < 1e-3 and value * -1 < self.root_node.v:
with parent_node.lock:
value = 99
if value < 0: # and state.are_pocket_empty(): #and pipe_id == 0:
# test of adding dirichlet noise to a new node
new_node.apply_dirichlet_noise_to_prior_policy(
epsilon=self.dirichlet_epsilon * .02,
alpha=self.dirichlet_alpha)
if self.use_pruning is False:
# include a reference to the new node in the look-up table
self.node_lookup[key] = new_node
with parent_node.lock:
# add the new node to its parent
parent_node.child_nodes[child_idx] = new_node
# check if we have reached a leaf node
elif node.is_leaf is True:
value = node.v
else:
# get the value from the leaf node (the current function is called recursively)
value, depth, chosen_nodes = self._run_single_playout(
state, node, pipe_id, depth + 1, chosen_nodes)
# revert the virtual loss and apply the predicted value by the network to the node
parent_node.revert_virtual_loss_and_update(child_idx,
self.virtual_loss, -value)
# we invert the value prediction for the parent of the above node layer because the player's turn is flipped every turn
return -value, depth, chosen_nodes