def test_5():
# random vs minimax depth = 4
O_win = 0
X_win = 0
draw = 0
for i in range(100):
game = TicTacToe()
p1 = RandomPlayer(game, 'O')
p2 = MinimaxPlayer(game, 'X', 4)
while not game.is_finished():
p1.make_move()
p2.make_move()
if game.result == 'O':
O_win += 1
elif game.result == 'X':
X_win += 1
else:
draw += 1
print('Random (O) vs minimax depth = 4 (X):')
print('O: ', O_win)
print('X: ', X_win)
print('draw: ', draw)
def main(): # win_move_pairs game0 = Game(RandomPlayer(), RandomPlayer()) score, winmoves = game0.play() print(len(winmoves)) for e in winmoves: print(e)
def test_2():
# random vs full minimax
O_win = 0
X_win = 0
draw = 0
states_tree = minimax_full(State())
for i in range(100):
game = TicTacToe()
p1 = FullPlayer(game, 'O', states_tree)
p2 = RandomPlayer(game, 'X')
while not game.is_finished():
p1.make_move()
p2.make_move()
if game.result == 'O':
O_win += 1
elif game.result == 'X':
X_win += 1
else:
draw += 1
print('Random (O) vs full minimax (X):')
print('O: ', O_win)
print('X: ', X_win)
print('draw: ', draw)
def __init__(self):
self.round = 1
self.game = 1
self.finished = False
self.winner = None
self.last_move = None
# do cross-platform clear screen
# os.system(['clear', 'cls'][os.name == 'nt'])
print("Welcome to Conniption Board Game")
print("Should Player 1 be a Human/AI/Random?")
while self.players[0] == None:
choice = str(input("Type 'H'/'A'/'R': "))
if choice.lower() == "human" or choice.lower() == "h":
name = str(input("What is Player 1's name? "))
self.players[0] = HumanPlayer(name, self.colors[0],
self.MAX_FLIP)
elif choice.lower() == "ai" or choice.lower() == "a":
name = str(input("What is Player 1's name? "))
diff = int(input("Enter difficulty for this AI (1 - 4) "))
self.players[0] = AIPlayer(name, self.colors[0], self.MAX_FLIP,
diff + 1)
elif choice.lower() == "random" or choice.lower() == "r":
name = str(input("What is Player 1's name? "))
self.players[0] = RandomPlayer(name, self.colors[0],
self.MAX_FLIP)
else:
print("Invalid choice, please try again")
print("{0} will be {1}".format(self.players[0].name, self.colors[0]))
print("Should Player 2 be a Human/AI/Random?")
while self.players[1] == None:
choice = str(input("Type 'H'/'A'/'R': "))
if choice.lower() == "human" or choice.lower() == "h":
name = str(input("What is Player 2's name? "))
self.players[1] = HumanPlayer(name, self.colors[1],
self.MAX_FLIP)
elif choice.lower() == "ai" or choice.lower() == "a":
name = str(input("What is Player 2's name? "))
diff = int(input("Enter difficulty for this AI (1 - 4) "))
self.players[1] = AIPlayer(name, self.colors[1], self.MAX_FLIP,
diff + 1)
elif choice.lower() == "random" or choice.lower() == "r":
name = str(input("What is Player 2's name? "))
self.players[1] = RandomPlayer(name, self.colors[1],
self.MAX_FLIP)
else:
print("Invalid choice, please try again")
print("{0} will be {1}".format(self.players[1].name, self.colors[1]))
# x always goes first (arbitrary choice on my part)
self.turn = self.players[0]
self.board = []
for i in range(6):
self.board.append([])
for j in range(7):
self.board[i].append(' ')
class Tester:
dealer = Dealer(FrenchDeck(12345))
dealer.add_player('lia9 ', ConservativePlayer(), PlayerBank(100))
dealer.add_player('lia8 ', RandomPlayer(), PlayerBank(100))
dealer.add_player('lia7 ', ConservativePlayer(), PlayerBank(100))
dealer.add_player('lia6 ', RandomPlayer(), PlayerBank(100))
dealer.take_bets()
dealer.deal_initial_hand()
dealer.deal_player_hands()
dealer.deal_dealer_hand()
dealer.settle_bets()
print(str(dealer))
def test_1():
# random vs random
O_win = 0
X_win = 0
draw = 0
for i in range(100):
game = TicTacToe()
p1 = RandomPlayer(game, 'O')
p2 = RandomPlayer(game, 'X')
while not game.is_finished():
p1.make_move()
p2.make_move()
if game.result == 'O':
O_win += 1
elif game.result == 'X':
X_win += 1
else:
draw += 1
print('Random vs random:')
print('O: ', O_win)
print('X: ', X_win)
print('draw: ', draw)
def test_set_piece(self):
player1 = RandomPlayer()
player1.set_piece(Board.X)
self.assertEqual(Board.X, player1.piece)
player2 = RandomPlayer()
player2.set_piece(Board.O)
self.assertEqual(Board.O, player2.piece)
def test_net_random(net, n_games, showbar=False):
# returns fraction of games won against random adversary
return play_n_games(n_games,
NetPlayer(net),
RandomPlayer(),
randomize=True,
showbar=showbar)[1] / n_games
def get_placement(self, board, piece, pieces):
win, pos = self.has_winning_pos(board, piece)
if win:
return pos
else:
#return super(NovicePlayer, self).get_placement(board, piece, pieces)
return RandomPlayer.get_placement(self, board, piece, pieces)
def test_select_players(self, select_mock):
select_mock.side_effect = [RandomPlayer(), HumanPlayer()]
player1, player2 = self.console._select_players()
self.assertIsInstance(player1, RandomPlayer)
self.assertIsInstance(player2, HumanPlayer)
self.assertEqual([call(Board.X), call(Board.O)],
select_mock.call_args_list)
def __init__(self, args):
parsed_args = self._parse_args(args)
self.num_games = parsed_args.num_games
self.num_batches = parsed_args.num_batches
self.player1 = self._init_player(parsed_args)
self.player2 = self._init_player(parsed_args)
self.random_player = RandomPlayer()
def get_placement(self, board, piece, pieces):
win, pos = self.has_winning_pos(board, piece)
if win:
return pos
else:
#return super(NovicePlayer, self).get_placement(board, piece, pieces)
return RandomPlayer.get_placement(self, board, piece, pieces)
def start_human_vs_ai_game(self):
self.clear_buttons()
self.team_black = HumanPlayer(self, self.board, Team.Black)
self.team_red = RandomPlayer(self, self.board, Team.Red)
self.start_game()
def test_rl_player(num_samples):
p1 = RLPlayer('X')
p2 = RandomPlayer('O')
# p1 = RandomPlayer('X')
# p2 = RLPlayer('O')
# play a number of games
winners = []
for i in range(0,num_samples):
# flip a coin as to who gets to go first
coin = np.random.uniform()
file = open("games/game_" + str(i) + ".txt","w")
if (coin < 0.5):
winner = play_game(p1,p2,file)
else:
winner = play_game(p2,p1,file)
file.close()
print("AFTER GAME: ", i)
p1.dump_q_values()
winners.append(winner)
x_wins = 0.0
o_wins = 0.0
cat_games = 0.0
num_games = 0.0
for i in range(0,len(winners)):
num_games += 1.0
winner = winners[i]
if winner is None:
print("NO WINNER FOR GAME ", i)
cat_games += 1
else:
print("WINNER FOR GAME ", i, ": ", winner.player)
if (winner.player == 'X'):
x_wins += 1
else:
o_wins += 1
if (num_games > 0) and (num_games % 100 == 0):
x_percent = x_wins / num_games
o_percent = o_wins / num_games
cat_percent = cat_games / num_games
# reset statistics
num_games = 0
x_wins = 0.0
o_wins = 0.0
cat_games = 0.0
print("X: ", x_percent, " O: ", o_percent, " CAT: ", cat_percent)
p1.finish()
def __init__(self, args):
parsed_args = self._parse_args(args)
self.num_games = parsed_args.num_games
self.player1 = self.get_and_load_player(parsed_args.learning_type,
Board.X)
self.player2 = self.get_and_load_player(parsed_args.learning_type,
Board.O)
self.random_player = RandomPlayer()
def start_bot_trainer(num_trials):
start = time.time()
initial_weights = [
0.9, 0.71, 0.77, 0.39, 0.13, 0.01, 0.02, 0.01, 0.021, 0.01, 0.033,
0.01, 0.16, 0.18
]
for i in range(num_trials):
# 'algorithm' field is irrelevant here, just a placeholder. We specify it under Register Players.
initial_weights = train_bots('agent1', RandomPlayer(), 'agent2',
RandomPlayer(), initial_weights)
print("Iteration %d complete: Weights are now: %s\n" %
(i, str(initial_weights)))
end = time.time()
print("\nTime taken to train: %.4f seconds" % (end - start))
print("Final Weights: %s" % str(initial_weights))
def main():
net = PolicyNet()
net.read_weights_from_file('./weights/policy_2.0_2017-12-04T21:08:08.381535')
player2 = RandomPlayer()
player1 = MCTPlayer()
game = Game(player1, player2)
print()
game.play(log=True)
def single_deep_qlearning_testing_game(player,
x_deep_player=True,
verbose=False):
board = Board()
if x_deep_player:
x = player
x.setBoard(board)
o = RandomPlayer(board, OH)
else:
x = RandomPlayer(board, CROSS)
o = player
o.setBoard(board)
game = Game(board, x, o)
game.play_game(verbose)
return game.board.getWinningSign()
def make_smarter(dict_number):
qlearner = Q_learning_agent()
random_player = RandomPlayer()
qlearner.alpha = 0.5
qlearner.epsilon = 0.2
qlearner.varyA_E = True
if dict_number > 0:
qlearner.load_dict(dict_number)
battle(qlearner, random_player, int(qlearner.LEARN_GAMES), False)
class TestRandomPlayer(unittest.TestCase):
def setUp(self):
self.player = RandomPlayer()
self.board = Board()
self.player.set_board(self.board)
self.func = Mock()
def test_constructor_initializes_board_and_piece_to_none(self):
player = RandomPlayer()
self.assertIsNone(player.piece)
self.assertIsNone(player.board)
def test_set_board(self):
self.assertEqual(self.board, self.player.board)
def test_set_piece(self):
player1 = RandomPlayer()
player1.set_piece(Board.X)
self.assertEqual(Board.X, player1.piece)
player2 = RandomPlayer()
player2.set_piece(Board.O)
self.assertEqual(Board.O, player2.piece)
@patch('random_player.random.choice')
def test_get_move_returns_random_available_move(self, choice_mock):
choice_mock.side_effect = MockRandom(5).choice
assert_get_move_is(self, self.player, self.board, 7, Board.X,
"---|-XO|---")
def test_indicate_move(self):
self.assertEqual("My move is 4", self.player.indicate_move(3))
def test_run_if_computer_runs_function_if_random_player(self):
run_if_computer(self.player, self.func)
self.func.assert_called_once_with()
def test_run_if_learner_does_not_run_function_if_random_player(self):
run_if_learner(self.player, self.func)
self.func.assert_not_called()
def test_run_if_human_does_not_run_function_if_random_player(self):
run_if_human(self.player, self.func)
self.func.assert_not_called()
def test1():
env = Environment(RandomPlayer('O'))
agent = RLPlayer('X')
episode = Episode(agent, env)
board = p.empty_board()
agent, final_board = episode.execute(board)
return agent, final_board
def testMinimax():
# qlearner = Q_learning_agent()
random_player = RandomPlayer()
minimax = Minimax()
minimax_old = Minimax_old()
minimax_old2 = Minimax_old2()
# qlearner.fight()
# player1: Player instance.always X
# player2: Player instance.always O
p1_stats = [0, 0, 0]
p2_stats = [0, 0, 0]
player1 = minimax
player2 = random_player
for i in range(int(TEST_GAMES)):
go = Game(GAME_SIZE)
go.verbose = True
go.new_board()
result = go.play(player1, player2, True)
p1_stats[result] += 1
for i in range(int(TEST_GAMES)):
go = Game(GAME_SIZE)
go.verbose = True
go.new_board()
result = go.play(player2, player1, True)
if result == 1:
result = 2
elif result == 2:
result = 1
p2_stats[result] += 1
print(p1_stats, p2_stats)
p1_stats = [round(x / TEST_GAMES * 100.0, 1) for x in p1_stats]
# sys.stdout = open("Minimax_resutls.txt", "a")
if True:
print('_' * 60)
print('{:>15}(X) | Wins:{}% Draws:{}% Losses:{}%'.format(
player1.__class__.__name__, p1_stats[1], p1_stats[0],
p1_stats[2]).center(50))
print('{:>15}(O) | Wins:{}% Draws:{}% Losses:{}%'.format(
player2.__class__.__name__, p1_stats[2], p1_stats[0],
p1_stats[1]).center(50))
print('_' * 60)
print()
p2_stats = [round(x / TEST_GAMES * 100.0, 1) for x in p2_stats]
if True:
print('_' * 60)
print('{:>15}(X) | Wins:{}% Draws:{}% Losses:{}%'.format(
player2.__class__.__name__, p2_stats[1], p2_stats[0],
p2_stats[2]).center(50))
print('{:>15}(O) | Wins:{}% Draws:{}% Losses:{}%'.format(
player1.__class__.__name__, p2_stats[2], p2_stats[0],
p2_stats[1]).center(50))
print('_' * 60)
print()
def testQlearner(dict_num):
qlearner = Q_learning_agent()
random_player = RandomPlayer()
minimax = Minimax_old2()
qlearner_server = Q_learning_agent()
if dict_num > 0:
qlearner.fight(dict_num)
dict_num = 10
qlearner_server.fight(dict_num)
# if dict_num > 0:
# qlearner.load_dict(dict_num)
# player1: Player instance.always X
# player2: Player instance.always O
p1_stats = [0, 0, 0]
p2_stats = [0, 0, 0]
player1 = minimax
player2 = qlearner_server
for i in range(int(TEST_GAMES)):
go = Game(GAME_SIZE)
go.verbose = False
go.new_board()
result = go.play(player1, player2, False)
p1_stats[result] += 1
for i in range(int(TEST_GAMES)):
go = Game(GAME_SIZE)
go.verbose = False
go.new_board()
result = go.play(player2, player1, False)
p2_stats[result] += 1
print(p1_stats, p2_stats)
p1_stats = [round(x / TEST_GAMES * 100.0, 1) for x in p1_stats]
if True:
print('_' * 60)
print('{:>15}(X) | Wins:{}% Draws:{}% Losses:{}%'.format(
player1.__class__.__name__, p1_stats[1], p1_stats[0],
p1_stats[2]).center(50))
print('{:>15}(O) | Wins:{}% Draws:{}% Losses:{}%'.format(
player2.__class__.__name__, p1_stats[2], p1_stats[0],
p1_stats[1]).center(50))
print('_' * 60)
print()
p2_stats = [round(x / TEST_GAMES * 100.0, 1) for x in p2_stats]
if True:
print('_' * 60)
print('{:>15}(X) | Wins:{}% Draws:{}% Losses:{}%'.format(
player2.__class__.__name__, p2_stats[1], p2_stats[0],
p2_stats[2]).center(50))
print('{:>15}(O) | Wins:{}% Draws:{}% Losses:{}%'.format(
player1.__class__.__name__, p2_stats[2], p2_stats[0],
p2_stats[1]).center(50))
print('_' * 60)
print()
def make_smarter(dict_number):
qlearner = Q_learning_agent()
random_player = RandomPlayer()
minimax = Minimax()
minimax_old = Minimax_old()
qlearner.alpha = 0.7
qlearner.epsilon = 0.1
qlearner.varyA_E = False
if dict_number > -1:
qlearner.load_dict(dict_number)
battle(qlearner, minimax_old, int(qlearner.LEARN_GAMES), False)
def single_qlearning_testing_game(q_test,
x_qlearning=True,
single_q_player=True,
verbose=False):
board = Board()
if not x_qlearning and single_q_player:
x = RandomPlayer(board, CROSS)
else:
x = QLearningPlayer(board, CROSS)
if single_q_player and x_qlearning:
o = RandomPlayer(board, OH)
else:
o = QLearningPlayer(board, OH)
game = Game(board, x, o)
game.play_game(verbose, q_test)
# train qlearning table some more
q_test.trainOnSingleGame(game, verbose=verbose)
return game.board.getWinningSign()
def play_game(rows, cols):
board = Board(rows, cols)
winner = None
loser = None
game_over = False
p1 = RandomPlayer()
p2 = RandomPlayer()
turn = 0
while not game_over:
turn += 1
if turn % 2 == 0:
move = p1.get_move(board)
board.update(move)
if board.is_terminal():
game_over = True
winner = p2
loser = p1
elif turn % 2 == 1:
move = p2.get_move(board)
board.update(move)
if board.is_terminal():
game_over = True
winner = p1
loser = p2
return winner.moves, loser.moves
def parse_arguments():
parser = ArgumentParser()
parser.add_argument('-n1',
'--agent_name1',
help="Name of agent 1",
default="Your agent",
type=str)
parser.add_argument('-a1',
'--agent1',
help="Agent 1",
default=RandomPlayer())
parser.add_argument('-n2',
'--agent_name2',
help="Name of agent 2",
default="Your agent",
type=str)
parser.add_argument('-a2',
'--agent2',
help="Agent 2",
default=RandomPlayer())
args = parser.parse_args()
return args.agent_name1, args.agent1, args.agent_name2, args.agent2
def player_factory(name):
"""
Returns a new player object of the given type
"""
players = {
"RANDOM": RandomPlayer(),
"GREEDY": GreedyPlayer(),
"MINIMAX": MinimaxPlayer(),
"EXPECTIMAX": ExpectimaxPlayer(),
"IDS": IterativeDeepeningPlayer(),
"ALPHABETA": AlphaBetaPlayer(),
"HEURISTIC": HeuristicPlayer(),
"MINIMAX3": MinimaxPlayer(3),
"MINIMAX1": MinimaxPlayer(1)
}
return players[name]
def __init__(self):
"""
Initializing the game objects.
p1 is always the current player
p2 is always the other player
"""
self.board = Board()
#self.p1 = SimplePlayer(Disk.DARK)
#self.p1 = InteractivePlayer(Disk.DARK)
#self.p2 = InteractivePlayer(Disk.LIGHT)
#self.p1 = RandomPlayer(Disk.DARK)
self.p2 = RandomPlayer(Disk.LIGHT)
self.p1 = Player06(Disk.DARK)
self.rules = Rules()
self.ui = UI()
def gen_games_from_pop(nets, n_games, showbar=False):
global BAR_V
global BAR
if showbar:
BAR_V = 0
BAR = progressbar.ProgressBar(maxval=len(nets)*n_games, \
widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.SimpleProgress()])
BAR.start()
for i, net in enumerate(nets):
# print("net {} playing {} games".format(i, n_games))
# if showbar: bar.update(i+1)
win_data = play_n_games(n_games,
NetPlayer(net),
RandomPlayer(),
randomize=True,
show=False,
showbar=showbar)[0]
if showbar: BAR.finish()
return win_data
def __init__(self, saved_weights=None):
""" Initialize Attributes. """
# board attributes
self.size = 5 # board (go) size
self.go = GO(self.size) # initialize the board (go)
# training params
# mine, adjust this manually to set training process
# --------------------------------------------------------------------
self.R = 200 # num of simulations (rollouts) for each move
self.check_freq = 50 # the frequency to check performance
self.game_batch_num = 5000 # total batch number of selfplays
self.test_num = 50 # test games number
# --------------------------------------------------------------------
# github preset, do not change
self.lr = 2e-3 # learning rate of the whole process
self.lr_coef = 1.0 # adaptively adjust lr based on KL
self.temp = 1.0 # the temperature param controlling exploration
self.C = 5 # hyperparameter controls the weight of prior probs
self.buffer_size = 10000 # buffer size for data retrieving
self.batch_size = 512 # mini-batch size for training
self.data_buffer = deque(maxlen=self.buffer_size) # data buffer
self.play_batch_size = 1 # batch size for playing each time
self.epochs = 5 # num of train_steps for each update
self.kl_targ = 0.02 # kl target
self.best_win_ratio = 0.0 # best_win_ratio to compare models
# set policy-value net
self.pv_net = PolicyValueNet(self.size, saved_weights)
# set my player
self.mcts_player = MyPlayer(self.pv_net.policy,
c=self.C,
r=self.R,
is_selfplay=True,
is_train=True)
# set opponent players to evaluate performance
self.op_player_n = 0
self.op_players = [
RandomPlayer(),
GreedyPlayer(),
AggressivePlayer(),
SmartPlayer()
]