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