def play_arena(model):
game = GobangGame(col=12, row=4, nir=7, defender=-1)
heur = Heuristic(game)
heuristic = Heuristic(game).random_play
model_player = lambda b, p: np.argmax(model.predict(h.b))
arena = Arena.Arena(model_player, heuristic, game, display=display)
return arena.playGames(100, verbose=True)
def setUpClass(cls):
print("setUpClass()")
cls.arena = Arena.Arena().get()
# create some pokemon and teams
cls.p1 = Pokemon.Pokemon("Charizard", 15, "Fire", 100, 150, 50)
cls.p2 = Pokemon.Pokemon("Pikachu", 1, "Electric", 50, 50, 25)
cls.p3 = Pokemon.Pokemon("Squirtle", 23, "Grass", 75, 85, 30)
cls.p4 = Pokemon.Pokemon("Machamp", 5, "Fighting", 50, 75, 45)
cls.p5 = Pokemon.Pokemon("Charmander", 13, "Fire", 50, 100, 40)
cls.p6 = Pokemon.Pokemon("Digglet", 151, "Earth", 50, 75, 35)
cls.p7 = Pokemon.Pokemon("Ghastly", 150, "Fire", 100, 150, 50)
cls.p8 = Pokemon.Pokemon("Raichu", 12, "Electric", 50, 50, 25)
cls.p9 = Pokemon.Pokemon("Bulbasaur", 24, "Grass", 75, 80, 30)
cls.p10 = Pokemon.Pokemon("Machop", 50, "Fighting", 55, 75, 45)
cls.p11 = Pokemon.Pokemon("Charmander", 17, "Fire", 50, 100, 40)
cls.p12 = Pokemon.Pokemon("Dugtrio", 78, "Earth", 50, 75, 35)
cls.p13 = Pokemon.Pokemon("Ghastly", 150, "Fire", 100, 150, 50)
cls.p14 = Pokemon.Pokemon("Raichu", 12, "Electric", 50, 50, 25)
cls.p15 = Pokemon.Pokemon("Bulbasaur", 24, "Grass", 75, 80, 30)
cls.p16 = Pokemon.Pokemon("Machop", 50, "Fighting", 55, 75, 45)
cls.p17 = Pokemon.Pokemon("Charmander", 17, "Fire", 50, 100, 40)
cls.p18 = Pokemon.Pokemon("Dugtrio", 78, "Earth", 50, 75, 35)
cls.teamOne = Team.Team(cls.p1, cls.p2, cls.p3, cls.p4, cls.p5, cls.p6)
cls.teamTwo = Team.Team(cls.p7, cls.p8, cls.p9, cls.p10, cls.p11,
cls.p12)
cls.teamThree = Team.Team(cls.p13, cls.p14, cls.p15, cls.p16, cls.p17,
cls.p18)
def startArena(self, monster):
"""
Instantiates the arena against a monster and changes the stage
:param monster:
"""
self.isOverworld = False
self.arena = Arena(self.player, monster, self.x, self.y)
def arena_hook(self, result_queue):
arena = Arena.Arena(self.p1p,
self.p2p,
self.g,
display=display,
result_queue=result_queue)
arena.playGames(2, verbose=True)
def experiment(m):
for c in range(6):
rp = RandomPlayer(g).play
mcts = MCTSAgent(g, iters=100000000, c=c, rollout_iter=1, time=m).play
arena_rp_hp = Arena.Arena(mcts, rp, g, display=display)
wins, loss, draw = arena_rp_hp.playGames(100, verbose=False)
data.append([m, c, wins, loss, draw])
return data
def experiment(m):
for rep in range(5):
rp = RandomPlayer(g).play
mcs = MCSAgent(g, nSims=100000000, time=m).play
arena_rp_hp = Arena.Arena(mcs, rp, g, display=display)
wins, loss, draw = arena_rp_hp.playGames(100, verbose=False)
data.append([m, rep, wins, loss, draw])
return data
def main():
arena = Arena.Arena()
player1 = Player.Player('Wojtek', 11, Stats.hp, Stats.str, Stats.agi, 1, 'X')
player2 = Player.Player('Seba',14, Stats.hp, Stats.str, Stats.agi, 0, 'O')
arena.generate(player1.position, player2.position)
now_playing = player1
prev_playing = player2
arena.show(player1.position, player2.position)
Window.Window(arena, now_playing, prev_playing)
def __init__(self, model):
self.game = GobangGame(col=12, row=4, nir=7, defender=-1)
self.heuristic = Heuristic(self.game)
heuristic_player = Heuristic(self.game).random_play
model_player = lambda b, p: Model_Arena.model_player(self, b, p, model)
self.arena = Arena.Arena(model_player,
heuristic_player,
self.game,
display=display)
def execute_game_test(game, neural_net):
rp = RandomPlayer(game).play
args = dotdict({'numMCTSSims': 25, 'cpuct': 1.0})
mcts = MCTS(game, neural_net(game), args)
n1p = lambda x: np.argmax(mcts.getActionProb(x, temp=0))
arena = Arena.Arena(n1p, rp, game)
print(arena.playGames(2, verbose=False))
def startArena(self, monsterIndex):
"""
Instantiates the arena against a monster and changes the stage
:param monster:
"""
self.isOverworld = False
self.arena = Arena(self, self.player, monsterIndex)
self.currentMonsterHealthBar = HealthBar(self.monsters[monsterIndex])
self.arena.draw(self.screen)
self.screen.print()
def runGame(self):
for i in range(10):
globals()["bird" + str(i)] = Bird()
globals()["bird" + str(i) + "Show"] = 1
globals()["bird" + str(i)].birdPosition = (BirdPosition[0],
np.random.randint(
200, 300))
vector = Vector
arena = Arena()
pipeHeight = arena.upperPipe1.get_height()
running = True
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
surface = pygame.Surface(screen.get_size())
surface = surface.convert()
clock = pygame.time.Clock()
passing = [1] * 10
while running:
clock.tick(30)
arena.moveImage()
arena.drawBackground(surface)
arena.drawPipe(surface)
arena.drawBase(surface)
arena.drawScore(surface)
sum = 0
for i in range(10):
if passing[i] == 1:
globals()["bird" + str(i) +
"Show"], pipePosition = self.gameOver(
eval("bird" + str(i)), arena)
eval("bird" + str(i)).drawBIrd(surface)
eval("bird" + str(i)).movement()
passing[i] = globals()["bird" + str(i) + "Show"]
horizontalDistance, verticalDistance = vector.distance(
eval("bird" + str(i)).birdPosition, pipePosition,
pipeHeight)
input = np.array([horizontalDistance, verticalDistance])
# Working with Neural Network
feedForward = self.neuralNetwork.feedForward(
input,
eval("neuralNetwork" + str(i))[0],
eval("neuralNetwork" + str(i))[1])
eval("bird" + str(i)).neuralNetworkJump(feedForward)
elif passing[i] == 0:
continue
screen.blit(surface, (0, 0))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if np.sum(passing) == 0:
break
def experiment(m):
for c in range(6):
mcts = MCTSAgent(g, iters=100000000, c=c, rollout_iter=1, time=m).play
if player == 'rp':
opponent = RandomPlayer(g).play
else:
opponent = OneStepLookaheadConnect4Player(g, verbose=False).play
arena_rp_hp = Arena.Arena(mcts, opponent, g, display=display)
wins, loss, draw = arena_rp_hp.playGames(100, verbose=False)
data.append([m, c, wins, loss, draw])
return data
def experiment(m):
for rep in range(5):
if player == 'rp':
pl = RandomPlayer(g).play
else:
pl = OneStepLookaheadConnect4Player(g, verbose=False).play
mcs = MCSAgent(g, nSims=100000000, time=m).play
arena_rp_hp = Arena.Arena(mcs, pl, g, display=display)
wins, loss, draw = arena_rp_hp.playGames(100, verbose=False)
data.append([m, rep, wins, loss, draw])
return data
def run_game():
pygame.init()
crash_sound = pygame.mixer.Sound("Crash.wav")
pygame.mixer.music.load("Background.wav")
screen = pygame.display.set_mode((800, 650))
pygame.display.set_caption("Snake")
endgame = False
arena = Arena.Arena(screen)
snake = Snake.Snake(screen, arena)
arena.snake = snake
scoreboard1 = Scoreboard.Scoreboard(screen)
highscore = scoreboard1.check_high_score()
scoreboard1.prep_high_score(highscore)
scoreboard1.show_high_score()
arena.update_food()
snake.blitme()
arena.draw_walls()
arena.draw_food()
scoreboard1.prep_score()
scoreboard1.show_score()
pygame.display.flip()
print(len(snake.positions))
time.sleep(2)
pygame.mixer.music.play(-1)
while True:
if endgame == False:
if snake.collided():
pygame.mixer.music.stop()
crash_sound.play()
endgame = True
time.sleep(2)
if snake.eaten_food():
print("Snake has eaten food")
snake.extend = True
arena.destroy_food()
arena.update_food()
arena.draw_food()
scoreboard1.score += 10
scoreboard1.prep_score()
scoreboard1.show_score()
if endgame == False:
snake.move()
time.sleep(0.3)
else:
scoreboard1.incr_high_score(highscore, scoreboard1.score)
highscore = scoreboard1.check_high_score()
scoreboard1.prep_high_score(highscore)
scoreboard1.show_high_score()
scoreboard1.show_msg("Game Over")
snake.check_events()
pygame.display.flip()
def tour():
pathAtt = './HistoryLog/Go/'
Rcand = {
'R1_10': [pathAtt + 'R_Ver1_checkpoint/7/', 'checkpoint_11.pth.tar'],
'R1_40': [pathAtt + 'R_Ver1_checkpoint/7/', 'checkpoint_47.pth.tar'],
'R1_B': [pathAtt + 'R_Ver1_checkpoint/7/', 'best.pth.tar'],
'R2_B': [pathAtt + 'R_Ver2_checkpoint/7/', 'best.pth.tar'],
'R3_B': [pathAtt + 'R_Ver3_checkpoint/7/', 'best.pth.tar']
}
Ccand = {
'C_10': [pathAtt + 'C_Ver1_checkpoint/7/', 'checkpoint_6.pth.tar'],
'C_40': [pathAtt + 'C_Ver1_checkpoint/7/', 'checkpoint_40.pth.tar'],
'C_B': [pathAtt + 'C_Ver1_checkpoint/7/', 'best.pth.tar']
}
compares = [('R1_10', 'C_10'), ('R1_40', 'C_40'), ('R1_B', 'C_B'),
('R2_B', 'C_B'), ('R3_B', 'C_B'), ('R1_B', 'R2_B'),
('R1_B', 'R3_B'), ('R2_B', 'R3_B')]
res = []
for c in [('R1_10', 'C_10')]:
print(c)
p1type = 'RES' if c[0][0] == 'R' else 'CNN'
p2type = 'RES' if c[1][0] == 'R' else 'CNN'
p1checkpoint = Rcand[c[0]] if c[0][0] == 'R' else Ccand[c[0]]
p2checkpoint = Rcand[c[1]] if c[1][0] == 'R' else Ccand[c[1]]
print(p1type, p2type)
print(p1checkpoint, p2checkpoint)
Net1 = nn(g, t=p1type)
Net1.load_checkpoint(p1checkpoint[0], p1checkpoint[1])
Args1 = dotdict({'numMCTSSims': 3000, 'cpuct': 17.5})
MCTS1 = MCTS(g, Net1, Args1)
Player1 = lambda x: np.argmax(MCTS1.getActionProb(x, temp=0))
Net2 = nn(g, t=p2type)
Net2.load_checkpoint(p2checkpoint[0], p2checkpoint[1])
Args2 = dotdict({
'numMCTSSims': 3000 if p2type == 'RNN' else 250,
'cpuct': 17.5 if p2type == 'RNN' else 3.0
})
MCTS2 = MCTS(g, Net2, Args2)
Player2 = lambda x: np.argmax(MCTS2.getActionProb(x, temp=0))
arena = Arena.Arena(Player1, Player2, g, display=display)
_res = arena.playGames(10, verbose=True)
res.append(_res)
result = {'1win': [], '2win': [], 'draw': []}
for r in res:
result['1win'].append(r[0])
result['2win'].append(r[1])
result['draw'].append(r[2])
pd.DataFrame(data=result).to_csv('reuslt.csv')
def execute_game_test_greedy(game, neural_net):
gp = GreedyPlayer(game).play
args = dotdict({'numMCTSSims': 25, 'cpuct': 1.0})
mcts = MCTS(game, neural_net(game), args)
n1p = lambda x: np.argmax(mcts.getActionProb(x, temp=0))
arena = Arena.Arena(n1p, gp, game)
print('Greedy Opponent...')
wins, losses, draws = arena.playGames(2, verbose=True, display=False)
print(f'Wins = {wins}')
print(f'Losses = {losses}')
print(f'Draws = {draws}')
def runBird(self, individu, display=False):
vector = Vector
arena = Arena()
pipeHeight = arena.upperPipe1.get_height()
bird = Bird()
running = True
age = 0
if display:
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
surface = pygame.Surface(screen.get_size())
surface = surface.convert()
clock = pygame.time.Clock()
while running:
arena.moveImage()
# Draw Arena
if display:
arena.drawBackground(surface)
arena.drawPipe(surface)
arena.drawBase(surface)
arena.drawScore(surface)
# Draw Bird
bird.drawBIrd(surface)
bird.movement()
running, pipePosition = self.gameOver(bird, arena)
# Working with vector
horizontalDistance, verticalDistance = vector.distance(
bird.birdPosition, pipePosition, pipeHeight)
input = np.array([horizontalDistance, verticalDistance])
#Working with Neural Network
feedForward = self.neuralNetowk.feedForward(
input, individu[0], individu[1])
bird.neuralNetworkJump(feedForward)
if display:
clock.tick(30)
screen.blit(surface, (0, 0))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bird.jump(event.key)
age += 1
return arena.score + age
def Main(self):
if self.quit == False:
Handler = pygame.event.get()
self.screen.fill((0, 0, 0))
if self.state == "World":
if self.area == None:
self.area = self.area = Area.Area(
Wself.player("default.dfile"), "teron")
temp = self.area.step(Handler)
if temp != None:
if temp[0] == "Fight":
self.arena = Arena.Arena(Bself.player("default.dfile"),
temp[1])
self.state = "Fight"
if self.state == "Title":
temp = self.Test.step(self.screen, Handler, [])
if temp != None:
self.state = temp
if self.state == "Fight":
#if pygame.mixer.music.get_busy()==False:
# pygame.mixer.music.load('resc/Brainkrieg.ogg')
# pygame.mixer.music.play()
temp = self.arena.step(self.screen, Handler)
if temp != None:
t2 = []
for ID in temp:
for c in range(0, len(self.area.grid)):
if self.area.grid[c][
0].group == "Bug" and self.area.grid[c][
0].id == ID:
t2.append(c)
t2.sort(reverse=True)
for num in t2:
self.area.grid.pop(num)
del t2
self.state = "World"
#pygame.mixer.music.stop()
self.fps = self.getFPS()
self.screen.blit(self.font.render(self.fps, 0, (255, 0, 0)),
(0, 0))
self.timer.tick(30)
pygame.display.flip()
self.getQuit(Handler)
else:
exit()
def player_vs_nnet(results_folder, player, games, chunk):
g = Connect4Game()
results = []
chunk_number, files = chunk
for file in files:
nn = NNet(g)
nn.load_checkpoint(results_folder, file)
args = dotdict({'numMCTSSims': 25, 'cpuct': 5.0})
mcts1 = MCTS(g, nn, args)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
arena = Arena.Arena(n1p, player, g, display=display)
result = arena.playGames(games, verbose=False)
results.append(list(result))
return chunk_number, results
def Async_Play(game,args,iter_num,bar):
bar.suffix = "iter:{i}/{x} | Total: {total:} | ETA: {eta:}".format(
i=iter_num+1,x=args.numPlayGames,total=bar.elapsed_td, eta=bar.eta_td)
bar.next()
# set gpu
if(args.multiGPU):
if(iter_num%2==0):
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
else:
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
else:
os.environ["CUDA_VISIBLE_DEVICES"] = args.setGPU
# set gpu growth
config = tf.ConfigProto()
config.gpu_options.allow_growth=True
sess = tf.Session(config=config)
# create NN
model1 = NNet(game)
model2 = NNet(game)
# try load weight
try:
model1.load_checkpoint(folder=args.model1Folder, filename=args.model1FileName)
except:
print("load model1 fail")
pass
try:
model2.load_checkpoint(folder=args.model2Folder, filename=args.model2FileName)
except:
print("load model2 fail")
pass
# create MCTS
mcts1 = MCTS(game, model1, args)
mcts2 = MCTS(game, model2, args)
# each process play 2 games
arena = Arena.Arena(lambda x: np.argmax(mcts1.getActionProb(x, temp=0)),
lambda x: np.argmax(mcts2.getActionProb(x, temp=0)), game)
arena.displayBar = False
oneWon,twoWon, draws = arena.playGames(2)
return oneWon,twoWon, draws
def Async_Arena(iter_num, game, args):
#set gpu
gpus = args.setGPU.split(',')
os.environ["CUDA_VISIBLE_DEVICES"] = gpus[iter_num%len(gpus)]
#set gpu memory grow
config = tf.ConfigProto()
config.gpu_options.allow_growth=True
sess = tf.Session(config=config)
# create separate seeds for each worker
np.random.seed(iter_num)
#nnet = NNet(g)
#nnet.load_checkpoint('./temp/','best.pth.tar')
nnet = None
heuristic = Heuristic(game).random_play
mcts1 = MCTS(game, nnet, args)
arena = Arena.Arena(None, heuristic, game, display=display, mcts=mcts1)
data = arena.playGames(args.numPerProcessSelfPlay, verbose=False)
folder = 'temp_measure1/{}'.format(iter_num)
if not os.path.exists(folder):
os.makedirs(folder)
print("Done ".format(iter_num))
temp = []
for j in data:
for trainData in j:
temp += trainData
iterations_data = [temp]
filename = os.path.join(folder, 'trainhistory.pth.tar'+".examples")
with open(filename, "wb+") as f:
Pickler(f).dump(iterations_data)
f.closed
return data
def updateArena(self):
self.vector = Vector
self.arena = Arena()
self.pipeHeight = self.arena.upperPipe1.get_height()
self.pipeWidth = self.arena.upperPipe1.get_width()
self.bird = Bird()
self.runing = True
while self.runing == True:
self.clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.runing = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.bird.jump(event.key)
self.arena.moveImage()
#Draw Arena
self.arena.drawBackground(self.surface)
self.arena.drawPipe(self.surface)
self.arena.drawBase(self.surface)
self.arena.drawScore(self.surface)
#Draw Bird
self.bird.drawBIrd(self.surface)
self.bird.movement()
self.gameOver()
horizontalDistance, verticalDistance = self.vector.distance(
self.bird.birdPosition, self.pipePosition, self.pipeHeight)
self.screen.blit(self.surface, (0, 0))
# pygame.display.flip()
pygame.display.update()
g = Connect4Game()
# all players
rp = RandomPlayer(g).play
gp = OneStepLookaheadConnect4Player(g).play
hp = HumanConnect4Player(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./temp/', 'best.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
if human_vs_cpu:
player2 = hp
else:
n2 = NNet(g)
n1.load_checkpoint('./pretrained_models/connect4/pytorch/',
'8x8_100checkpoints_best.pth.tar')
args2 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
arena = Arena.Arena(n1p, player2, g, display=Connect4Game.display)
print(arena.playGames(2, verbose=True))
'./temp/20_8checkpoints/', # The checkpoint file that store all NN.
})
if __name__ == "__main__":
g = OthelloGame(8) # Define the game
# All players
rp = RandomPlayer(g).play
gp = GreedyOthelloPlayer(g).play
# The first iteration is the random player play with other players
print("Iteration 0")
# Random players
print('Random players')
arena_r = Arena.Arena(rp, rp, g, display=OthelloGame.display)
print(arena_r.playGames(args.numGames, verbose=True))
# Greedy players
print('Greedy players')
arena_g = Arena.Arena(rp, gp, g, display=OthelloGame.display)
print(arena_g.playGames(args.numGames, verbose=True))
# For other iterations, it is the MCTS player play with other players
for i in range(1, args.numIters):
print('Iteration', i)
filename = 'checkpoint_{i}.pth.tar'.format(i=i)
# player
n1 = NNet(g)
n1.load_checkpoint(args.checkpoint, filename)
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
import numpy as np
from utils import *
"""
use this script to play manually with the best temp agent.
"""
g = Game()
hp = HumanPlayer(g).play
rp = RandomPlayer(g).play
sp = StaticChessPlayer(g).play
try:
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./temp/', 'best.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
ap = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
except ValueError:
print('warning: no AI found')
ap = None
player1 = ap
player2 = rp
arena = Arena.Arena(player1, player2, g, display=Game.display)
print(arena.playGames(2, verbose=True))
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = TicTacToeGame(3)
# all players
rp = RandomPlayer(g).play
# gp = TicTacToePlayer(g).play
hp = HumanTicTacToePlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./pretrained_models/tictactoe/keras/','best-25eps-25sim-10epch.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct':1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
n2 = NNet(g)
n2.load_checkpoint('/dev/8x50x25/','best.pth.tar')
args2 = dotdict({'numMCTSSims': 25, 'cpuct':1.0})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
arena = Arena.Arena(rp, n1p, g, display=display)
print(arena.playGames(2, verbose=True))
# Time is in microseconds
# Put big number of iterations in order to be stoped by the time
mcs = MCSAgent(g, nSims=1000000, time=300000).play
# Same here in mcts
mcts = MCTSAgent(g, iters=1000000, c=1, rollout_iter=100, time=10000000).play
#
# For fix epsilon-greedy put dc=1
# For dynamical epsilon-greedy put e.g. dc=0.99
ql = QAgent(game=g, episodes=4500, lr=0.1, epsilon=0.2, dc=1, e_min=0.001)
# The Q-Agent will be trained first and then play in arena
ql.train()
# Use the ql_player in the Arena
ql_player = ql.play
#
#One = OneStepLookaheadConnect4Player(g).play
#
#hp = HumanConnect4Player(g).play
#hp = HumanTicTacToePlayer(g).play
#
# op=OneStepLookaheadConnect4Player(g).play
#
###### PLAY IN ARENA ###############
start = time()
arena_rp_hp = Arena.Arena(ql_player, mcts, g, display=display)
print('')
print(arena_rp_hp.playGames(6, verbose=False))
print('Time Elapsed: ' + str(round(time() - start)) + ' secs')
import numpy as np
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = GobangGame()
# all players
rp = RandomPlayer(g).play
gp = GreedyGobangPlayer(g).play
hp = HumanGobangPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./temp/', 'best.pth.tar')
args1 = dotdict({'numMCTSSims': 50, 'cpuct': 1.0})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
#n2 = NNet(g)
#n2.load_checkpoint('/dev/8x50x25/','best.pth.tar')
#args2 = dotdict({'numMCTSSims': 25, 'cpuct':1.0})
#mcts2 = MCTS(g, n2, args2)
#n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
arena = Arena.Arena(n1p, hp, g, display=display)
print(arena.playGames(2, verbose=True))
lstm64 = lambda x: np.argmax(mcts5.getActionProb(x, temp=0))
n6 = LSTM128(g)
n6.load_checkpoint('./othlstm128temp/', 'best.pth.tar')
args6 = dotdict({'numMCTSSims': 25, 'cpuct': 1.0})
mcts6 = MCTS(g, n6, args6)
lstm128 = lambda x: np.argmax(mcts6.getActionProb(x, temp=0))
n7 = LSTM256(g)
n7.load_checkpoint('./othlstm256temp/', 'best.pth.tar')
args7 = dotdict({'numMCTSSims': 25, 'cpuct': 1.0})
mcts7 = MCTS(g, n7, args7)
lstm256 = lambda x: np.argmax(mcts7.getActionProb(x, temp=0))
print('CNN vs NN64')
arena = Arena.Arena(cnn, nn64, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('CNN vs NN128')
arena = Arena.Arena(cnn, nn128, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('cnn vs nn256')
arena = Arena.Arena(cnn, nn256, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('CNN vs lstm64')
arena = Arena.Arena(cnn, lstm64, g, display=display)
print(arena.playGames(30, verbose=False)) #True))
print('CNN vs lstm128')
"""
human_vs_cpu = True
g = DotsAndBoxesGame(3)
# all players
rp = RandomPlayer(g).play
hp = HumanPlayer(g).play
# nnet players
n1 = NNet(g)
n1.load_checkpoint('./pretrained_models/exact_win/', 'checkpoint_282.pth.tar')
args1 = dotdict({'numMCTSSims': 800, 'cpuct': 2.5})
mcts1 = MCTS(g, n1, args1)
n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
if human_vs_cpu:
player2 = hp
else:
n2 = NNet(g)
n2.load_checkpoint('./pretrained_models/temp/',
'1217-25-exact_win.pth.tar')
args2 = dotdict({'numMCTSSims': 200, 'cpuct': 3.75})
mcts2 = MCTS(g, n2, args2)
n2p = lambda x: np.argmax(mcts2.getActionProb(x, temp=0))
player2 = n2p # Player 2 is neural network if it's cpu vs cpu.
#arena = Arena.Arena(n1p, player2, g, display=DotsAndBoxesGame.display)
arena = Arena.Arena(n1p, player2, g, display=DotsAndBoxesGame.display)
print(arena.playGames(2, verbose=True))
