def generate_moves_with_feature_based_probs_Go5(board):
from feature import Features_weight
from feature import Feature
assert len(Features_weight) != 0
moves = []
gamma_sum = 0.0
empty_points = board.get_empty_points()
color = board.current_player
probs = np.zeros(board.maxpoint + 1)
all_board_features = Feature.find_all_features(board)
for move in empty_points:
if board.check_legal(move, color) and not board.is_eye(move, color):
moves.append(move)
probs[move] = Feature.compute_move_gamma(Features_weight, all_board_features[move])
gamma_sum += probs[move]
#Append Pass to the list of moves
moves.append("PASS")
#Compute gamma for Pass move
probs[len(probs) - 1] = Feature.compute_move_gamma(Features_weight, all_board_features["PASS"])
#Add it to gamma sum
gamma_sum += probs[len(probs) - 1]
if len(moves) != 0:
assert gamma_sum != 0.0
for m in moves:
if m == "PASS":
probs[len(probs) - 1] = probs[len(probs) - 1] / gamma_sum
else:
probs[m] = probs[m] / gamma_sum
return moves, probs
def expand(self, board, color):
"""
Expands tree by creating new children.
"""
moves = board.get_empty_points()
probs = {}
gamma_sum = 0.0
all_board_features = Feature.find_all_features(board)
for move in moves:
if move not in self._children:
if board.check_legal(move, color) and not board.is_eye(move, color):
self._children[move] = TreeNode(self)
self._children[move]._move = move
#Tell it to use knowledge. default to not
self._children[move]._use_knowledge = self._use_knowledge
#Compute the probability for each child move
if self._use_knowledge == "probabilistic":
probs[move] = Feature.compute_move_gamma(Features_weight, all_board_features[move])
gamma_sum += probs[move]
#passing is always allowed
self._children[PASS] = TreeNode(self)
self._children[PASS]._move = PASS
if self._use_knowledge == "probabilistic":
moves.append(PASS)
probs[PASS] = Feature.compute_move_gamma(Features_weight, all_board_features["PASS"])
gamma_sum += probs[PASS]
#Normalize
if len(moves) != 0:
assert gamma_sum != 0.0
for m in moves:
probs[m] = probs[m] / gamma_sum
best_move = max(probs.items(), key = lambda x: x[1])[0]
best_move_prob = probs[best_move]
b_win_sum, n_visit_sum = 0,0
for move in moves:
childSim = sim(move, probs[move], best_move_prob, 10)
self._children[move]._black_wins = childSim.wins
b_win_sum += childSim.wins
self._children[move]._n_visits = childSim.sim
n_visit_sum += childSim.sim
#self._black_wins += b_win_sum
#self._n_visits += n_visit_sum
self._expanded = True
def prior_knowledge_cmd(self, args):
moves = []
gamma_sum = 0.0
empty_points = self.board.get_empty_points()
color = self.board.current_player
#probs = np.zeros(self.board.maxpoint)
probs = {}
all_board_features = Feature.find_all_features(self.board)
for move in empty_points:
if self.board.check_legal(
move, color) and not self.board.is_eye(move, color):
moves.append(move)
probs[move] = Feature.compute_move_gamma(
Features_weight, all_board_features[move])
gamma_sum += probs[move]
#passing is always allowed, add it
moves.append("PASS")
probs["PASS"] = Feature.compute_move_gamma(Features_weight,
all_board_features["PASS"])
gamma_sum += probs["PASS"]
if len(moves) != 0:
assert gamma_sum != 0.0
for m in moves:
probs[m] = probs[m] / gamma_sum
best_move = max(probs.items(), key=lambda x: x[1])[0]
best_move_prob = probs[best_move]
result = []
for i in moves:
if i == "PASS":
result.append(sim(i, probs[i], best_move_prob, 10))
else:
result.append(
sim(GoBoardUtil.sorted_point_string([i], self.board.NS),
probs[i], best_move_prob, 10))
result.sort(key=sim.move)
result.sort(reverse=True, key=sim.winrate)
response = ""
for i in result:
if i.move == "PASS":
response += "Pass " + str(i.wins) + " " + str(i.sim) + " "
else:
response += i.move + " " + str(i.wins) + " " + str(i.sim) + " "
self.respond(response[:-1])
def calc_prior_knowledge(self, board):
from feature import Features_weight
from feature import Feature
# initialization
all_board_features = Feature.find_all_features(board)
probs = {}
p_max = 0
gamma_sum = 0.0
# calculate probabilistic
for move in self._children:
probs[move] = Feature.compute_move_gamma(Features_weight, \
all_board_features[move])
gamma_sum += probs[move]
for m in self._children:
probs[m] = probs[m] / gamma_sum
# find the largest probability 'p_max'
if probs[m] > p_max:
p_max = probs[m]
# calculate/assign the number of sims and wins to each of the expanded children
for m in self._children:
sim = 10 * probs[m] / p_max
winrate = 0.5 + probs[m] / p_max * 0.5
win = winrate * sim
self._children[m]._n_visits = int(round(sim))
self._children[m]._black_wins = int(round(win))
# For the root only, initialize its _black_wins and _n_visits with the
# sum of its children's _black_wins and _n_visits.
# this will avoid problems with computing log np in the UCT formula if np=0.
if self.is_root():
sum_visits = 0; sum_wins = 0
for m in self._children:
sum_visits += self._children[m]._n_visits
sum_wins += self._children[m]._black_wins
self._n_visits = sum_visits
self._black_wins = sum_wins
def get_the_prob(move, board):
from feature import Features_weight
from feature import Feature
assert len(Features_weight) != 0
all_board_features = Feature.find_all_features(board)
return Feature.compute_move_gamma(Features_weight,
all_board_features[move])
def prob_moves(board):
from feature import Feature
from feature import Features_weight
num_features= Feature.find_all_features(board)
#print(num_features)
#print(Features_weight)
dict1={}
problist=[]
for item in num_features:
#print(item)
if item =="PASS":
#gamma=Feature.compute_move_gamma(Features_weight, num_features[item])
#dict1[item]=gamma
continue
else:
move = GoBoardUtil.format_point(GoBoardUtil.point_to_coord(item,board.NS))
#print(move)
gamma=Feature.compute_move_gamma(Features_weight, num_features[item])
dict1[move]=gamma
problist.append(gamma)
#print(gamma)
norm = [float(i)/sum(problist) for i in problist]
norm.sort(reverse=True)
dict2={}
for item in dict1:
dict2[item]=float(dict1[item])/sum(dict1.values())
sorted(dict2.values(),reverse=True)
#print(dict2)
return dict2
def get_move_prob(self):
moves = GoBoardUtil.generate_random_moves(self.board) # legal and not eye-filling
features = Feature.find_all_features(self.board)
gammas_sum = 0
move_gammas = dict()
if len(Features_weight) != 0:
for move in moves:
move_gammas[move] = Feature.compute_move_gamma(Features_weight, features[move])
gammas_sum += move_gammas[move]
# normalize to get probability
if gammas_sum:
for move in move_gammas.keys():
move_gammas[move] /= gammas_sum
if move_gammas and gammas_sum:
move_prob_tuples = [(self.board.point_to_string(k), v) for (k, v) in move_gammas.items()]
# sort list by probability and alphabetic order
# based on
# http://stackoverflow.com/questions/5212870/sorting-a-python-list-by-two-criteria
# answered by jaap on Stack Overflow http://stackoverflow.com/users/1186954/jaap
move_prob_tuples = sorted(move_prob_tuples, key=lambda k:(-k[1], k[0][0], k[0][1]))
else:
move_prob_tuples = list()
move_prob_tuples.append(('pass', 1))
return move_prob_tuples
def generate_all_policy_moves(board, pattern, check_selfatari):
"""
generate a list of policy moves on board for board.current_player.
Use in UI only. For playing, use generate_move_with_filter
which is more efficient
"""
from feature import Feature
from feature import Features_weight
gammas_sum = 0.0
prob = {}
moves = board.get_empty_points()
all_board_features = Feature.find_all_features(board)
for move in moves:
if board.check_legal(move,
board.current_player) and not board.is_eye(
move, board.current_player):
if len(Features_weight) != 0:
# when we have features weight, use that to compute knowledge (gamma) of each move
assert move in all_board_features
prob[move] = Feature.compute_move_gamma(
Features_weight, all_board_features[move])
gammas_sum += prob[move]
for k, v in prob.items():
prob[k] = v / gammas_sum
ret = sorted(prob.items(), key=lambda x: (x[1], x[0]), reverse=True)
return ret
def expand_without_pass(self, board, color):
"""Expands tree by creating new children.
"""
gammas_sum = 0.0
moves = board.get_empty_points()
all_board_features = Feature.find_all_features(board)
for move in moves:
if move not in self._children:
if board.check_legal(move,
color) and not board.is_eye(move, color):
self._children[move] = TreeNode(self)
self._children[move]._move = move
if len(Features_weight) != 0:
# when we have features weight, use that to compute knowledge (gamma) of each move
assert move in all_board_features
self._children[
move]._prob_simple_feature = Feature.compute_move_gamma(
Features_weight, all_board_features[move])
gammas_sum += self._children[move]._prob_simple_feature
# Normalize to get probability
if len(Features_weight) != 0 and gammas_sum != 0.0:
for move in moves:
if move in self._children:
if board.check_legal(
move, color) and not board.is_eye(move, color):
self._children[
move]._prob_simple_feature = self._children[
move]._prob_simple_feature / gammas_sum
self._expanded = True
def generate_moves_with_feature_based_probs(board):
from feature import Features_weight
from feature import Feature
assert len(Features_weight) != 0
moves = []
gamma_sum = 0.0
# need to include PASS move
totalPoints = board.maxpoint + 1
empty_points = board.get_empty_points()
color = board.current_player
probs = np.zeros(totalPoints)
all_board_features = Feature.find_all_features(board)
for move in empty_points:
if board.check_legal(move,
color) and not board.is_eye(move, color):
moves.append(move)
probs[move] = Feature.compute_move_gamma(
Features_weight, all_board_features[move])
gamma_sum += probs[move]
# need to apply the pass move now
moves.append("PASS")
probs[-1] = Feature.compute_move_gamma(Features_weight,
all_board_features["PASS"])
gamma_sum += probs[-1]
if len(moves) != 0:
assert gamma_sum != 0.0
for m in moves:
# calculate pass move probability now
if m == 'PASS':
probs[-1] = probs[-1] / gamma_sum
else:
probs[m] = probs[m] / gamma_sum
return moves, probs
def probability(self, board):
from feature import Features_weight
from feature import Feature
# print(Features_weight)
assert len(Features_weight) != 0
#legal moves
moves = []
gamma_sum = 0.0
legal_moves_broad = Feature.legal_moves_on_board(board)
legal_moves = []
for elem in legal_moves_broad:
if not board.is_eye(elem, board.current_player):
legal_moves.append(elem)
legal_moves.append(0)
probs = np.zeros(board.maxpoint)
feature_legal_move = Feature.find_all_features(board)
for move in legal_moves:
if move == 0:
probs[move] = Feature.compute_move_gamma(Features_weight, feature_legal_move['PASS'])
else:
probs[move] = Feature.compute_move_gamma(Features_weight, feature_legal_move[move])
gamma_sum += probs[move]
if len(legal_moves) != 0.0:
assert gamma_sum != 0.0
for m in legal_moves:
probs[m] = probs[m]/gamma_sum
return legal_moves, probs
def prior_knowledge_cmd(self, args):
# move = self.go_engine.get_move(self.board, color)
# initialization
all_board_features = Feature.find_all_features(self.board)
probs = {}
p_max = 0
gamma_sum = 0.0
moves = [PASS]
knowledge = []
# find all legal moves
color = self.board.current_player
for m in self.board.get_empty_points():
if self.board.check_legal(
m, color) and not self.board.is_eye(m, color):
moves.append(m)
# calculate probabilistic
for m in moves:
probs[m] = Feature.compute_move_gamma(Features_weight, \
all_board_features[m])
gamma_sum += probs[m]
for m in moves:
probs[m] = probs[m] / gamma_sum
# find the largest probability 'p_max'
if probs[m] > p_max:
p_max = probs[m]
# calculate the numner of sims and wins
for m in moves:
sim = 10 * probs[m] / p_max
winrate = 0.5 + probs[m] / p_max * 0.5
win = winrate * sim
if m == PASS:
m = None
knowledge.append(
(self.board.point_to_string(m), winrate, sim, win))
# sort by the (true, not rounded) winrate in descending order
# break ties in alphanumeric order of the move
knowledge.sort(key=lambda move: (-move[1], move[0]))
output = []
for move in knowledge:
m, winrate, sim, win = move
output.append(m + ' ' + str(int(round(win))) + ' ' +
str(int(round(sim))))
self.respond(' '.join(output))
def generate_moves_with_feature_based_probs(board, color):
from feature import Features_weight
from feature import Feature
assert len(Features_weight) != 0
moves = []
gamma_sum = 0.0
empty_points = board.get_empty_points()
probs = np.zeros(board.maxpoint)
all_board_features = Feature.find_all_features(board)
for move in empty_points:
if board.check_legal(move, color) and not board.is_eye(move, color):
moves.append(move)
probs[move] = Feature.compute_move_gamma(Features_weight,
all_board_features[move])
gamma_sum += probs[move]
if len(moves) != 0:
assert gamma_sum != 0.0
for m in moves:
probs[m] = probs[m] / gamma_sum
return moves, probs
