def computer_EHS(card, sample_count):
win_count = 0
draw_count = 0
all_cards = get_all_cards()
available_card = copy.deepcopy(all_cards)
for j in card:
available_card.remove(j)
for i in range(sample_count):
print(" {0} th iter".format(i))
board_opponent_card = random.sample(available_card, 7)
board_card = board_opponent_card[:5]
opponent_card = board_opponent_card[5:]
card_string = list_to_string(card)
board_string = list_to_string(board_card)
opponent_string = list_to_string(opponent_card)
if judging(card_string, opponent_string,board_string) == 0:
win_count += 1
elif judging(card_string, opponent_string, board_string) == 2:
draw_count += 1
win_rate = win_count / sample_count
draw_rate = draw_count / sample_count
EHS = win_rate + draw_rate / 2
print("-----------------------------")
print("win_rate:", win_rate)
print("draw_rate:", draw_rate)
print("EHS:", EHS)
return EHS
def _computer_pre_flop_card_win_comb(self, hand, state):
win_rate = 0
count = 0
available_card = copy.deepcopy(self.cards)
for card in state:
available_card.remove(card)
board_cards = list(combinations(available_card, 3))
print('board count:', comb(10, 3))
for board_card in board_cards:
board_card = list(board_card)
turn_available_card = copy.deepcopy(available_card)
for i in board_card:
turn_available_card.remove(i)
board = board_card[0] + board_card[1] + board_card[2]
for turn_card in turn_available_card:
turn_board = board + turn_card
river_available_card = copy.deepcopy(turn_available_card)
river_available_card.remove(turn_card)
assert len(
river_available_card
) == 6, "The number of river available card is not 6"
assert len(
turn_board) // 2 == 4, "The number of turn board is not 4"
for river_card in river_available_card:
river_board = turn_board + river_card
opponent_available_card = copy.deepcopy(
river_available_card)
opponent_available_card.remove(river_card)
assert len(
opponent_available_card
) == 5, "The number of opponent available card is not 5"
assert len(
river_board
) // 2 == 5, "the number of the river board is not 5"
opponent_cards = list(
combinations(opponent_available_card, 2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent,
river_board) == 0 or judging(
hand, opponent, river_board) == 2:
win_rate += 1
count += 1
win_rate = round(win_rate / count, 2)
return win_rate
def _computer_turn_card_win(self, hand, board):
win_rate = 0
count = 0
used_card_list = hand + board
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
for card in used_card_list:
available_card.remove(card)
for i in range(self.river_sample_count):
river_board = copy.deepcopy(board)
river_card = random.sample(available_card, 1)
river_board.append(river_card[0])
opponent_available_card = copy.deepcopy(available_card)
opponent_available_card.remove(river_card[0])
board_card = self.list_to_string(river_board)
assert len(
board_card) // 2 == 5, "the number of the river board is not 5"
for _ in range(self.opponent_sample_count):
opponent_card = random.sample(opponent_available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand_card, opponent, board_card) == 0:
win_rate += 1
count += 1
win_rate = win_rate / count
win_rate = round(win_rate, 2)
return win_rate
def _computer_river_card_category(self, hand, board):
out_win_rate = 0
used_card_list = hand + board
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
board_card = self.list_to_string(board)
for card in used_card_list:
available_card.remove(card)
for i in range(self.opponent_sample_count):
opponent_card = random.sample(available_card,2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand_card, opponent, board_card) == 0:
out_win_rate += 1
out_win_rate = out_win_rate / self.opponent_sample_count
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_river)):
distance = math.pow(self.centroids_river[i][0]-out_win_rate, 2)
# distance = emd(np.array(win_rate), np.array(self.centroids_river[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
def generate_turn_data_comb(self, hand, public, state):
out = [0] * settings.river_cluster_count
turn_available_card = copy.deepcopy(self.cards)
for card in state:
turn_available_card.remove(card)
for card in turn_available_card:
board_card = public + card
opponent_available_card = copy.deepcopy(turn_available_card)
opponent_available_card.remove(card)
out_win_rate = 0
opponent_cards = list(combinations(opponent_available_card,2))
for i in opponent_cards:
opponent_card = list(i)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, board_card) == 0:
out_win_rate += 1
out_win_rate = out_win_rate / len(opponent_cards)
min_distance_index = 0
min_distance = 10000
for i in range(settings.river_cluster_count):
distance = math.pow(self.centroids_river[i][0] - out_win_rate, 2)
# distance = emd(np.array(win_rate), np.array(centroids[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
out[min_distance_index] += 1
if self.normalize_flag:
sum_out = sum(out)
for i in range(len(out)):
out[i] = out[i] / sum_out
return out
def _computer_turn_card_category(self, hand, board):
used_card_list = hand + board
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
for card in used_card_list:
available_card.remove(card)
cha = [float(0)] * len(self.centroids_river)
# matrix_river = np.array([[0, 1 / 3.0, 2 / 3.0], [1 / 3.0, 0, 1 / 3.0], [2 / 3.0, 1 / 3.0, 0]])
# matrix_river = self.computer_distance_matrix('river')
for i in range(self.river_sample_count):
river_board = copy.deepcopy(board)
river_card = random.sample(available_card, 1)
river_board.append(river_card[0])
opponent_available_card = copy.deepcopy(available_card)
opponent_available_card.remove(river_card[0])
board_card = self.list_to_string(river_board)
assert len(board_card) // 2 == 5, "the number of the river board is not 5"
win_rate = 0
for _ in range(self.opponent_sample_count):
opponent_card = random.sample(opponent_available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
# win_rate[judging(hand_card, opponent, board_card)] += 1 / self.opponent_sample_count
if judging(hand_card, opponent, board_card) == 0:
win_rate += 1
win_rate = win_rate / self.opponent_sample_count
river_min_distance_index = 0
river_min_distance = 10000
for j in range(len(self.centroids_river)):
# distance = emd(np.array(win_rate), np.array(self.centroids_river[j]), matrix_river)
distance = math.pow(win_rate-self.centroids_river[j][0], 2)
if distance < river_min_distance:
# print(i)
river_min_distance_index = j
river_min_distance = distance
cha[river_min_distance_index] += 1
# print(cha)
if self.normalize_flag:
sum_cha = sum(cha)
for i in range(len(cha)):
cha[i] = cha[i] / sum_cha
matrix = self.computer_distance_matrix('turn')
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_turn)):
distance = emd(np.array(cha), np.array(self.centroids_turn[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
def _computer_river_card_win_comb(self, hand, board, state):
out_win_rate = 0
available_card = copy.deepcopy(self.cards)
count = 0
for card in state:
available_card.remove(card)
opponent_cards = list(combinations(available_card, 2))
for card in opponent_cards:
# print('{0} th iter'.format(count))
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, board) == 0 or judging(
hand, opponent, board) == 2:
out_win_rate += 1
count += 1
out_win_rate = out_win_rate / count
out_win_rate = round(out_win_rate, 2)
return out_win_rate
def generate_river_data_comb(self, hand, public, state):
out_win_rate = 0
opponent_available_card = copy.deepcopy(self.cards)
for i in state:
opponent_available_card.remove(i)
# print(win_rate)
opponent_cards = list(combinations(opponent_available_card,2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, public) == 0:
out_win_rate += 1
#
return [out_win_rate / len(opponent_cards)]
def _computer_pre_flop_card_win(self, hand):
win_rate = 0
count = 0
used_card_list = hand
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
for card in used_card_list:
available_card.remove(card)
for k in range(self.board_sample_count):
board = random.sample(available_card, 3)
turn_available_card = copy.deepcopy(available_card)
for board_card in board:
turn_available_card.remove(board_card)
for i in range(self.turn_sample_count):
turn_board = copy.deepcopy(board)
turn_card = random.sample(turn_available_card, 1)
turn_board.append(turn_card[0])
river_available_card = copy.deepcopy(turn_available_card)
river_available_card.remove(turn_card[0])
assert len(
river_available_card
) == 6, "The number of river available card is not 6"
assert len(
turn_board) == 4, "The number of turn board is not 4"
for j in range(self.river_sample_count):
river_board = copy.deepcopy(turn_board)
river_card = random.sample(river_available_card, 1)
river_board.append(river_card[0])
opponent_available_card = copy.deepcopy(
river_available_card)
opponent_available_card.remove(river_card[0])
board_card = self.list_to_string(river_board)
assert len(
opponent_available_card
) == 5, "The number of opponent available card is not 5"
assert len(
board_card
) // 2 == 5, "the number of the river board is not 5"
for _ in range(self.opponent_sample_count):
opponent_card = random.sample(opponent_available_card,
2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand_card, opponent, board_card) == 0:
win_rate += 1
count += 1
win_rate = round(win_rate / count, 2)
return win_rate
def _computer_turn_card_win_comb(self, hand, board, state):
win_rate = 0
count = 0
available_card = copy.deepcopy(self.cards)
for card in state:
available_card.remove(card)
for river_card in available_card:
river_board = board + river_card
opponent_available_card = copy.deepcopy(available_card)
opponent_available_card.remove(river_card)
assert len(river_board
) // 2 == 5, "the number of the river board is not 5"
opponent_cards = list(combinations(opponent_available_card, 2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, river_board) == 0 or judging(
hand, opponent, river_board) == 2:
win_rate += 1
count += 1
win_rate = round(win_rate / count, 2)
return win_rate
def _computer_turn_card_category_comb(self, hand, board, state):
available_card = copy.deepcopy(self.cards)
for card in state:
available_card.remove(card)
cha = [float(0)] * len(self.centroids_river)
for river_card in available_card:
river_board = board + river_card
opponent_available_card = copy.deepcopy(available_card)
opponent_available_card.remove(river_card)
assert len(river_board) // 2 == 5, "the number of the river board is not 5"
win_rate = 0
opponent_cards = list(combinations(opponent_available_card,2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, river_board) == 0:
win_rate += 1
win_rate = win_rate / len(opponent_cards)
river_min_distance_index = 0
river_min_distance = 10000
for j in range(len(self.centroids_river)):
distance = math.pow(win_rate - self.centroids_river[j][0], 2)
if distance < river_min_distance:
river_min_distance_index = j
river_min_distance = distance
cha[river_min_distance_index] += 1
if self.normalize_flag:
sum_cha = sum(cha)
for i in range(len(cha)):
cha[i] = cha[i] / sum_cha
matrix = self.computer_distance_matrix('turn')
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_turn)):
distance = emd(np.array(cha), np.array(self.centroids_turn[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
def generate_river_data(self,state):
out_win_rate = 0
hand_card = random.sample(state, settings.hold_card_count)
hand = hand_card[0] + hand_card[1]
board_available_card = copy.deepcopy(state)
for card in hand_card:
board_available_card.remove(card)
public = board_available_card[0] + board_available_card[1] + board_available_card[2] + board_available_card[3] + board_available_card[4]
opponent_available_card = copy.deepcopy(self.cards)
for i in state:
opponent_available_card.remove(i)
# print(win_rate)
for i in range(settings.opponent_sample_count):
opponent_card = random.sample(opponent_available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent,public) == 0:
out_win_rate += 1
#
return [out_win_rate / settings.opponent_sample_count]
def generate_turn_data(self, state):
out = [0]* settings.river_cluster_count
hand_card = random.sample(state, settings.hold_card_count)
hand = hand_card[0] + hand_card[1]
board_available_card = copy.deepcopy(state)
for card in hand_card:
board_available_card.remove(card)
public = board_available_card[0] + board_available_card[1] + board_available_card[2] + board_available_card[3]
turn_available_card = copy.deepcopy(self.cards)
for card in state:
turn_available_card.remove(card)
for i in range(settings.river_sample_count):
turn_card = random.sample(turn_available_card,1)
board_card = public + turn_card[0]
opponent_available_card = copy.deepcopy(turn_available_card)
opponent_available_card.remove(turn_card[0])
out_win_rate = 0
for i in range(settings.opponent_sample_count):
opponent_card = random.sample(opponent_available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, board_card) == 0:
out_win_rate += 1
out_win_rate = out_win_rate / settings.opponent_sample_count
min_distance_index = 0
min_distance = 10000
for i in range(settings.river_cluster_count):
distance = math.pow(self.centroids_river[i][0] - out_win_rate, 2)
# distance = emd(np.array(win_rate), np.array(centroids[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
out[min_distance_index] += 1
if self.normalize_flag:
sum_out = sum(out)
for i in range(len(out)):
out[i] = out[i] / sum_out
return out
def _computer_river_card_win(self, hand, board):
out_win_rate = 0
count = 0
used_card_list = hand + board
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
board_card = self.list_to_string(board)
for card in used_card_list:
available_card.remove(card)
for i in range(self.opponent_sample_count):
print('{0} th iter'.format(count))
opponent_card = random.sample(available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand_card, opponent, board_card) == 0:
out_win_rate += 1
count += 1
out_win_rate = out_win_rate / count
out_win_rate = round(out_win_rate, 2)
return out_win_rate
def _computer_river_card_category_comb(self, hand, board, state):
out_win_rate = 0
available_card = copy.deepcopy(self.cards)
for card in state:
available_card.remove(card)
opponent_cards = list(combinations(available_card,2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, board) == 0:
out_win_rate += 1
out_win_rate = out_win_rate / len(opponent_cards)
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_river)):
distance = math.pow(self.centroids_river[i][0]-out_win_rate, 2)
# distance = emd(np.array(win_rate), np.array(self.centroids_river[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
def _computer_flop_card_category_comb(self, hand, board, state):
available_card = copy.deepcopy(self.cards)
for card in state:
available_card.remove(card)
cha_2 = [float(0)] * len(self.centroids_turn)
matrix_turn = self.computer_distance_matrix('turn')
for turn_card in available_card:
turn_board = board + turn_card
river_available_card = copy.deepcopy(available_card)
river_available_card.remove(turn_card)
assert len(river_available_card) == 6, "The number of river available card is not 6"
assert len(turn_board) // 2 == 4, "The number of turn board is not 4"
cha = [float(0)] * len(self.centroids_river)
for river_card in river_available_card:
river_board = turn_board + river_card
opponent_available_card = copy.deepcopy(river_available_card)
opponent_available_card.remove(river_card)
assert len(opponent_available_card) == 5, "The number of opponent available card is not 5"
assert len(river_board) // 2 == 5, "the number of the river board is not 5"
win_rate = 0
opponent_cards = list(combinations(opponent_available_card, 2))
for card in opponent_cards:
opponent_card = list(card)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand, opponent, river_board) == 0:
win_rate += 1
win_rate = win_rate / len(opponent_cards)
river_min_distance_index = 0
river_min_distance = 10000
for index in range(len(self.centroids_river)):
# distance = emd(np.array(win_rate), np.array(self.centroids_river[index]), matrix_river)
distance = math.pow(win_rate - self.centroids_river[index][0], 2)
if distance < river_min_distance:
river_min_distance_index = index
river_min_distance = distance
cha[river_min_distance_index] += 1
if self.normalize_flag:
sum_cha = sum(cha)
for i in range(len(cha)):
cha[i] = cha[i] / sum_cha
turn_min_distance_index = 0
turn_min_distance = 10000
for turn_index in range(len(self.centroids_turn)):
distance = emd(np.array(cha), np.array(self.centroids_turn[turn_index]), matrix_turn)
if distance < turn_min_distance:
# print(i)
turn_min_distance_index = turn_index
turn_min_distance = distance
cha_2[turn_min_distance_index] += 1
if self.normalize_flag:
sum_cha2 = sum(cha_2)
for i in range(len(cha_2)):
cha_2[i] = cha_2[i] / sum_cha2
matrix = self.computer_distance_matrix('flop')
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_flop)):
distance = emd(np.array(cha_2), np.array(self.centroids_flop[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
def _computer_flop_card_category(self, hand, board):
used_card_list = hand + board
available_card = copy.deepcopy(self.cards)
hand_card = self.list_to_string(hand)
for card in used_card_list:
available_card.remove(card)
cha_2 = [float(0)] * len(self.centroids_turn)
matrix_turn = self.computer_distance_matrix('turn')
for i in range(self.turn_sample_count):
turn_board = copy.deepcopy(board)
turn_card = random.sample(available_card,1)
turn_board.append(turn_card[0])
river_available_card = copy.deepcopy(available_card)
river_available_card.remove(turn_card[0])
assert len(river_available_card) == 6, "The number of river available card is not 6"
assert len(turn_board) == 4, "The number of turn board is not 4"
cha = [float(0)] * len(self.centroids_river)
# matrix_river = np.array([[0, 1 / 3.0, 2 / 3.0], [1 / 3.0, 0, 1 / 3.0], [2 / 3.0, 1 / 3.0, 0]])
for j in range(self.river_sample_count):
river_board = copy.deepcopy(turn_board)
river_card = random.sample(river_available_card, 1)
river_board.append(river_card[0])
opponent_available_card = copy.deepcopy(river_available_card)
opponent_available_card.remove(river_card[0])
board_card = self.list_to_string(river_board)
assert len(opponent_available_card) == 5, "The number of opponent available card is not 5"
assert len(board_card) // 2 == 5, "the number of the river board is not 5"
win_rate = 0
for _ in range(self.opponent_sample_count):
opponent_card = random.sample(opponent_available_card, 2)
opponent = opponent_card[0] + opponent_card[1]
if judging(hand_card, opponent, board_card) == 0:
win_rate += 1
win_rate = win_rate / self.opponent_sample_count
river_min_distance_index = 0
river_min_distance = 10000
for index in range(len(self.centroids_river)):
# distance = emd(np.array(win_rate), np.array(self.centroids_river[index]), matrix_river)
distance = math.pow(win_rate - self.centroids_river[index][0], 2)
if distance < river_min_distance:
river_min_distance_index = index
river_min_distance = distance
cha[river_min_distance_index] += 1
turn_min_distance_index = 0
turn_min_distance = 10000
for turn_index in range(len(self.centroids_turn)):
distance = emd(np.array(cha), np.array(self.centroids_turn[turn_index]), matrix_turn)
if distance < turn_min_distance:
# print(i)
turn_min_distance_index = turn_index
turn_min_distance = distance
cha_2[turn_min_distance_index] += 1
matrix = self.computer_distance_matrix('flop')
min_distance_index = 0
min_distance = 10000
for i in range(len(self.centroids_flop)):
distance = emd(np.array(cha_2), np.array(self.centroids_flop[i]), matrix)
if distance < min_distance:
# print(i)
min_distance_index = i
min_distance = distance
return min_distance_index + 1
