def analyze_game_first_move_working_version_for_heatmap_animation(file_name): a = np.zeros((3, 3)) games = UT.read_games(file_name) first_move_stats_dict = {} T = 0 m = 0 fig = plt.figure() for each_game in games: if each_game.get("winner") != "D": r, c = each_game.get("sequence")[0].get("xy") rc_move = (r, c) first_move_stats_dict[rc_move] = first_move_stats_dict.get( rc_move, 0) + 1 a[r][c] += 1 T += 1 if m % 10 == 0: draw_heat_map(a, T) plt.draw() plt.pause(0.01) plt.clf() print("Total Count: %d" % T) plt.show() # plt.imshow(a, cmap='hot', interpolation='nearest') return first_move_stats_dict, a
def analyze_game(file_name): games = UT.read_games(file_name) winning_count = {} average_num_moves_per_game = {} first_move_stats = {} for i in range(len(games)): each_game = games[i] a_player = each_game.get("winner") num_moves = len(each_game.get("sequence")) if a_player in average_num_moves_per_game: average_num_moves_per_game[a_player].append(num_moves) else: average_num_moves_per_game[a_player] = [num_moves] winning_count[a_player] = winning_count.get(a_player, 0) + 1 if a_player != "Draw": first_move_info = each_game.get("sequence")[0] first_move = tuple(first_move_info.get("xy")) first_move_stats[first_move] = first_move_stats.get(first_move, 0) + 1 move_tree = build_session_second_degree(games) first_move_stats_sorted = sorted(first_move_stats.items(), key=lambda kv: kv[1], reverse=True) return winning_count, move_tree, average_num_moves_per_game, first_move_stats_sorted
def parse_data_example(filename): # games is a list, an array, where each cell in the array holds a dictionary format for each game per line from the filename games = UT.read_games(filename) winning_count = {} x_wins = 0 o_wins = 0 ties = 0 winning_count_dict = {} for i in range(len(games)): ## each i holds a game log, which is represented in a dictionary format each_game = games[i] # once you have a dictionary obj, you can retrieve a value for a key by # adict.get("mykey") <-- adict is a dictionary obj; "mykey" is a key name000 player_winner = each_game.get("winner") winning_count_dict[player_winner] = winning_count_dict.get( player_winner, 0) + 1 if player_winner == "X": x_wins += 1 elif player_winner == "O": o_wins += 1 elif player_winner == "D": ties += 1 game_sequence_in_list = each_game.get("sequence") play_modes = each_game.get("play_modes") print("Winner is: %s. First move: %s." % (player_winner, game_sequence_in_list[0].get("turn"))) print("X win-rate:", winning_count_dict.get("X") / len(games)) print("O win-rate:", o_wins / len(games)) print("Draw rate:", ties / len(games))
def animation_heatmap(file_name): games = UT.read_games(file_name) games_win_by_O = [] Writer = animation.writers['ffmpeg'] writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800) T = len(games) focused_result = "O" fig = plt.figure() skip_by = 1 c_ = 0 board_size = 5 first_move_winingstat = np.zeros((board_size, board_size)) for each_game in games: if each_game.get("winner") == focused_result: # and c_ % skip_by == 0 : games_win_by_O.append(each_game) if c_ == 0: board_size = each_game.get("board_size", 5) r, c = each_game.get("sequence")[0].get("xy") first_move_winingstat[r][c] += 1 c_ += 1 #print(np.array(first_move_winingstat)/c_) T = len(games_win_by_O) a = np.zeros((board_size, board_size)) index_to_keep_processed ={} def animate(i): global C each_game_local = games_win_by_O[i] # games[i] # somehow this callback function cals the first element (e.g. at index 0) twice; if i in index_to_keep_processed: return else: index_to_keep_processed[i] = 1 #print("focused player: %s, this_game_player: %s" % (focused_result, each_game.get("winner"))) plt.clf() #print("HHH") if each_game_local.get("winner") == focused_result: r, c = each_game_local.get("sequence")[0].get("xy") a[r][c] += 1 C += 1 draw_heat_map(a, C) anim = animation.FuncAnimation(fig, animate, frames=T, interval=10) anim.save('first_move_winningRate_animation.mp4', writer=writer) print("Total Win: %d" % len(games_win_by_O)) print(np.divide(a, len(games_win_by_O)))
def analyze_game(file_name): games = UT.read_games(file_name) winning_count = {} for i in range(len(games)): each_game = games[i] a_player = each_game.get("winner") winning_count[a_player] = winning_count.get(a_player, 0) + 1 move_tree = build_session_second_degree(games) return winning_count, move_tree
def animation_heatmap(file_name): a = np.zeros((3, 3)) games = UT.read_games(file_name) games_win_by_O = [] Writer = animation.writers['ffmpeg'] writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800) T = len(games) focused_result = "O" fig = plt.figure() skip_by = 1 c_ = 0 for each_game in games: if each_game.get( "winner") == focused_result: # and c_ % skip_by == 0 : games_win_by_O.append(each_game) c_ += 1 T = len(games_win_by_O) def animate(i): global C each_game = games_win_by_O[i] # games[i] #print("focused player: %s, this_game_player: %s" % (focused_result, each_game.get("winner"))) plt.clf() if each_game.get("winner") == focused_result: r, c = each_game.get("sequence")[0].get("xy") a[r][c] += 1 C += 1 draw_heat_map(a, C) anim = animation.FuncAnimation(fig, animate, frames=T, interval=10) anim.save('first_move_winningRate_animation.mp4', writer=writer) print("Total Win: %d" % C)
def parse_jsons_example(filename): # games is a list, an array, where each cell in the array holds a dictionary format for each game per line from the filename games_in_jsons = UT.read_games(filename) list_of_dic = [] training_samples = [] weight_of_lost_samples_from_x = 10 weight_of_winning_samples_from_o = 20 moves_to_prevent_losing = [] moves_to_enhance_winning = [] for i in range(len(games_in_jsons)): # TO-DO # 1) create an-empty list for init-game # 2) create list of list ## each i holds a game log, which is represented in a dictionary format each_game_in_a_json = games_in_jsons[i] # once you have a dictionary obj, you can retrieve a value for a key by # adict.get("mykey") <-- adict is a dictionary obj; "mykey" is a key name000 dict_move_set = {} dict_move_set["move_sequence"] = None dict_move_set["player_winner"] = None board_size = each_game_in_a_json.get("board_size", 5) individual_sequence = ["_"] * (board_size**2) list_of_individual_sequence = [] player_winner = each_game_in_a_json.get("winner") moves_in_sequence_per_game = each_game_in_a_json.get("sequence") copy_list = individual_sequence[:] list_of_individual_sequence.append(updated_list_parse(copy_list)) for each_move_dict in range(len(moves_in_sequence_per_game)): #list_of_individual_sequence.append(individual_sequence) turn_for_this_move = moves_in_sequence_per_game[ each_move_dict].get("turn") move_made_for_this_move = moves_in_sequence_per_game[ each_move_dict].get("position") # for this game and movements so far, a list is created... and then # need to be appended to the list of list individual_sequence[move_made_for_this_move - 1] = turn_for_this_move copy_list = individual_sequence[:] current_state = updated_list_parse(copy_list) list_of_individual_sequence.append(current_state) # for moves from each game, we can generate training data for player O # every even index from the sequence is for player O, except 0 if player_winner == "O": if each_move_dict > 0 and each_move_dict % 2 == 1: # then each_move_dict-1 is x; and each_move_dict is y indices x = list_of_individual_sequence[-2] y = list_of_individual_sequence[-1] multi_y = np.subtract(y, x) a_max = np.amax(multi_y) multi_y = np.true_divide(multi_y, a_max).astype(int) training_samples.append((x, y, multi_y)) # Now we can collect another data by replacing a winning position made by X with O # that is, final third position becomes x; and the final postion made by X becomes Y # we can work on the "list_of_individual_sequence", not above for loop if player_winner == "X": x = list_of_individual_sequence[-3] ## y_1 will contains 2 and 1 -- 2 for O and 1 for X; ## so we only need to find a position of 1 for y y_1 = list_of_individual_sequence[-1] multi_y = np.subtract(y_1, x) final_position_made_by_x = np.where(multi_y == 1)[0][0] y = x[:] y[final_position_made_by_x] = 2 multi_y = get_multi_class_format(x, y) moves_to_prevent_losing.append((x, y, multi_y)) for a_weight in range(weight_of_lost_samples_from_x): training_samples.append((x, y, multi_y)) # Now I can add more weight to winner of "O" for the last two movements # to let the game know the winning position explicitly if player_winner == "O": x = list_of_individual_sequence[-2] y = list_of_individual_sequence[-1] multi_y = get_multi_class_format(x, y) moves_to_enhance_winning.append((x, y, multi_y)) for a_weight in range(weight_of_winning_samples_from_o): training_samples.append((x, y, multi_y)) dict_move_set["player_winner"] = player_winner dict_move_set["move_sequence"] = list_of_individual_sequence #(list_of_individual_sequence) list_of_dic.append(dict_move_set) focused_samples = [moves_to_enhance_winning, moves_to_prevent_losing] return list_of_dic, training_samples, focused_samples
def visualize_historical_games(filename): for each_game in UT.read_games(file_name): parse_history(each_game)
"Starting simulation of Ramdom_MCTS_bigger_board -- %d times" % args.n) start_time = time.time() for i in range(10): #t = threading.Thread(target=RANDOM_vs_MCTS_bigger_board_thread, args=(args.n,)) #threads.append(t) #t.start() t = multiprocessing.Process( target=RANDOM_vs_MCTS_bigger_board_thread, args=(args.n, )) time.sleep(1) procs.append(t) t.start() print("Elapsed time: %d" % (time.time() - start_time)) #[proc.join() for proc in threads] [proc.join() for proc in procs] #run_n_simulations(3, "random_vs_mcts") #human_vs_MCTS() #MCTS_vs_MODEL(1000) #MCTS_vs_MCTS() #MCTS_vs_RANDOM(100) elif GAME_MODE == LOAD_PLAY: all_games = UT.read_games("./game_output.log") sampled_games = np.random.choice(all_games, 3) c = 0 print(len(sampled_games)) for index, each_item in enumerate(sampled_games): Game.parse_history(each_item, index) print(c)
def analyze_game(file_name): games = UT.read_games(file_name) winning_count = {} for each_game in games: a_player = each_game.get("winner") winning_count[a_player] = winning_count.get(a_player) + 1
def parse_jsons_example(filename): # games is a list, an array, where each cell in the array holds a dictionary format for each game per line from the filename games_in_jsons = UT.read_games(filename) list_of_dic = [] training_samples =[] for i in range(len(games_in_jsons)): # TO-DO # 1) create an-empty list for init-game # 2) create list of list dict_move_set = {} dict_move_set["move_sequence"] = None dict_move_set["player_winner"] = None individual_sequence = ["_"] * 9 list_of_individual_sequence = [] ## each i holds a game log, which is represented in a dictionary format each_game_in_a_json = games_in_jsons[i] # once you have a dictionary obj, you can retrieve a value for a key by # adict.get("mykey") <-- adict is a dictionary obj; "mykey" is a key name000 player_winner = each_game_in_a_json.get("winner") moves_in_sequence_per_game = each_game_in_a_json.get("sequence") copy_list = individual_sequence[:] list_of_individual_sequence.append(updated_list_parse(copy_list)) for each_move_dict in range(len(moves_in_sequence_per_game)): #list_of_individual_sequence.append(individual_sequence) turn_for_this_move = moves_in_sequence_per_game[each_move_dict].get("turn") move_made_for_this_move = moves_in_sequence_per_game[each_move_dict].get("position") # for this game and movements so far, a list is created... and then # need to be appended to the list of list individual_sequence[move_made_for_this_move - 1] = turn_for_this_move copy_list = individual_sequence[:] current_state = updated_list_parse(copy_list) list_of_individual_sequence.append(current_state) # for moves from each game, we can generate training data for player O # every even index from the sequence is for player O, except 0 if player_winner == "O": if each_move_dict > 0 and each_move_dict % 2 == 1: # then each_move_dict-1 is x; and each_move_dict is y indices x = list_of_individual_sequence[-2] y = list_of_individual_sequence[-1] multi_y = np.subtract(y, x) a_max = np.amax(multi_y) multi_y = np.true_divide(multi_y, a_max).astype(int) training_samples.append((x, y, multi_y)) dict_move_set["player_winner"] = player_winner dict_move_set["move_sequence"] = list_of_individual_sequence list_of_dic.append(dict_move_set) return list_of_dic, training_samples