def rank_checkpoints(game, model_class, sims, cuda=False):
winning_model = NeuralNetwork(game, model_class, cuda=cuda)
contending_model = NeuralNetwork(game, model_class, cuda=cuda)
ckpts = winning_model.list_checkpoints()
num_opponents = game.get_num_players() - 1
current_winner = ckpts[0]
for contender in ckpts:
# Load contending player
contending_model.load(contender)
contending_player = DeepMCTSPlayer(game, contending_model, sims)
# Load winning player
winning_model.load(current_winner)
winners = [
DeepMCTSPlayer(game, winning_model, sims)
for _ in range(num_opponents)
]
scores, outcomes = play_match(game, [contending_player] + winners,
verbose=False,
permute=True)
score, outcome = scores[contending_player], outcomes[contending_player]
print("Current Champ: {} Challenger: {} Outcome: {} <{}> ".
format(current_winner, contender, outcome, score),
end="")
if outcome == "Win":
current_winner = contender
print("New Champ: {}".format(current_winner))
def test_two_sim_guess_it(self):
gi = TwoPlayerGuessIt()
pr = NeuralNetwork(gi, PriorNet)
p = DeepMCTSPlayer(gi, pr, 2)
init = gi.get_initial_state()
s = p.update_state(init)
s_gt = init
s_gt[0, 1, 0] = 1
s_gt[:, :, -1] = 1
self.assertTrue((s == s_gt).all())
def test_three_sim_guess_it(self):
for _ in range(100): # There should be no stochasticity (temp=0)
gi = TwoPlayerGuessIt()
pr = NeuralNetwork(gi, PriorNet)
p = DeepMCTSPlayer(gi, pr, 3)
init = gi.get_initial_state()
s = p.update_state(init)
s_gt = init.copy()
s_gt[0, 1, 0] = 1
s_gt[:, :, -1] = 1
self.assertTrue((s == s_gt).all())
def effective_model_power(checkpoint, game, model_class, sims, cuda=False):
my_model = NeuralNetwork(game, model_class, cuda=cuda)
my_model.load(checkpoint)
my_player = DeepMCTSPlayer(game, my_model, sims)
strength = 10
num_opponents = game.get_num_players() - 1
lost = False
while not lost:
contenders = [
UninformedMCTSPlayer(game, strength) for _ in range(num_opponents)
]
# Play main game
scores, outcomes = play_match(game, [my_player] + contenders,
verbose=False,
permute=True)
score, outcome = scores[my_player], outcomes[my_player]
if outcome == "Lose": lost = True
print("{} <{}> Opponent strength: {}".format(
outcome, round(score, 3), strength),
end="")
# Play control game
control_player = UninformedMCTSPlayer(game, sims)
scores, outcomes = play_match(game, [control_player] + contenders,
verbose=False,
permute=True)
score, outcome = scores[control_player], outcomes[control_player]
print(" (Control: {} <{}>)".format(outcome, round(score, 3)))
strength *= 2 # Opponent strength doubles every turn
def test_memory_guess_it(self):
gi = TwoPlayerGuessIt()
pr = NeuralNetwork(gi, PriorNet)
p = DeepMCTSPlayer(gi, pr, 2)
init = gi.get_initial_state()
s = p.update_state(init)
s_gt = init.copy()
s_gt[0, 1, 0] = 1
s_gt[:, :, -1] = 1
self.assertTrue((s == s_gt).all())
for _ in range(100):
s = p.update_state(init)
s_gt = init.copy()
s_gt[1, 1, 0] = 1
s_gt[:, :, -1] = 1
self.assertTrue((s == s_gt).all())
def one_vs_all(checkpoint, game, model_class, sims, cuda=False):
my_model = NeuralNetwork(game, model_class, cuda=cuda)
my_model.load(checkpoint)
contending_model = NeuralNetwork(game, model_class, cuda=cuda)
ckpts = my_model.list_checkpoints()
num_opponents = game.get_num_players() - 1
for contender in ckpts:
contending_model.load(contender)
my_player = DeepMCTSPlayer(game, my_model, sims)
contenders = [
DeepMCTSPlayer(game, contending_model, sims)
for _ in range(num_opponents)
]
scores, outcomes = play_match(game, [my_player] + contenders,
verbose=False,
permute=True)
score, outcome = scores[my_player], outcomes[my_player]
print("Challenger:", contender, "Outcome:", outcome, score)
def evaluate_against_uninformed(checkpoint,
game,
model_class,
my_sims,
opponent_sims,
cuda=False):
my_model = NeuralNetwork(game, model_class, cuda=cuda)
my_model.load(checkpoint)
num_opponents = game.get_num_players() - 1
uninformeds = [
UninformedMCTSPlayer(game, opponent_sims) for _ in range(num_opponents)
]
informed = DeepMCTSPlayer(game, my_model, my_sims)
scores = play_match(game, [informed] + uninformeds, permute=True)
print("Opponent strength: {} Scores: {}".format(opponent_sims, scores))
outcomes[p] = "Win"
return scores, outcomes
if __name__ == "__main__":
from players.human_player import HumanPlayer
from neural_network import NeuralNetwork
from models.minivgg import MiniVGG
from models.smallvgg import SmallVGG
from models.senet import SENet
from players.uninformed_mcts_player import UninformedMCTSPlayer
from players.deep_mcts_player import DeepMCTSPlayer
from games.connect4 import Connect4
from games.tictactoe import TicTacToe
from games.leapfrog import ThreePlayerLeapFrog
# Change these variable
game = Connect4()
ckpt = 775
nn = NeuralNetwork(game, SENet, cuda=True)
nn.load(ckpt)
# HumanPlayer(game),
# UninformedMCTSPlayer(game, simulations=1000)
# DeepMCTSPlayer(game, nn, simulations=50)
players = [HumanPlayer(game), DeepMCTSPlayer(game, nn, simulations=50)]
for _ in range(5):
print(play_match(game, players, verbose=True, permute=True))