def simulate():
assert os.path.exists('agz_bot_train.h5')
# load known best bot
if os.path.exists('agz_bot.h5'):
with h5py.File('agz_bot.h5', 'r') as best_bot:
best_agent = zero.load_zero_agent(best_bot)
else:
return True # learner bot wins! ... by default, since there is no best currently
# load learner bot
with h5py.File('agz_bot_train.h5') as learn_bot:
learner_agent = zero.load_zero_agent(learn_bot)
# randomly decide first move
black_agent = random.choice([best_agent, learner_agent])
white_agent = best_agent if black_agent is learner_agent else learner_agent
agents = {
Player.black: black_agent,
Player.white: white_agent,
}
game = GameState.new_game(
(learner_agent.encoder.board_size, learner_agent.encoder.board_size))
while not game.is_over():
next_move = agents[game.next_player].select_move(game)
game = game.apply_move(next_move)
game_result = scoring.compute_game_result(game)
game = None
del black_agent.model
del white_agent.model
black_agent = white_agent = None
import gc
K.clear_session()
gc.collect()
if game_result.winner == Player.black:
if black_agent is best_agent:
return False
else:
if white_agent is best_agent:
return False
return True # learner won this round
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--bind-address', default='127.0.0.1')
parser.add_argument('--port', '-p', type=int, default=5000)
args = parser.parse_args()
zero_agent = {
'zero': zero.load_zero_agent(h5py.File("bots/zeroagent_v1.hdf5", 'r'))
}
web_app = httpfrontend.get_web_app(zero_agent)
web_app.run(host=args.bind_address, port=args.port, threaded=False)
def load_agent(filename):
with h5py.File(filename, 'r') as h5file:
return zero.load_zero_agent(h5file)
first_won = False
if game_result.winner == Player.black:
if black_agent is first:
first_won = True
else:
if white_agent is first:
first_won = True
if first_won:
print("First agent wins!")
else:
print("Second agent wins!")
if __name__ == '__main__':
with h5py.File('agz_bot.h5', 'r') as bot_file:
bot1 = zero.load_zero_agent(bot_file)
# with h5py.File('agz_bot_i1_2stone_hc.h5', 'r') as bot_file:
# bot2 = zero.load_zero_agent(bot_file)
import dlgo.agent
bot2 = dlgo.agent.naive.RandomBot()
bot1.num_rounds = bot2.num_rounds = 1000
#bot1.c = bot2.c = 0.5
run(19, bot1, bot2)
self.game_state = self.game_state.apply_move(Move.resign())
self._stopped = True
elif pos.lower() == 'pass':
self.game_state = self.game_state.apply_move(Move.pass_turn())
self.sgf.append(';{}[]\n'.format(their_letter))
if self.game_state.last_move.is_pass:
self._stopped = True
else:
move = gtp_position_to_coords(pos)
self.game_state = self.game_state.apply_move(move)
self.sgf.append(';{0}[{1}]\n'.format(their_letter,
self.sgf.coordinates(move)))
if __name__ == "__main__":
import sys
sys.path.append('../../')
agz = zero.load_zero_agent(h5py.File('agz_bot.h5', 'r'))
agz.num_rounds = 400
gnu_go = LocalGtpBot(go_bot=agz,
termination=PassWhenOpponentPasses(),
handicap=0,
opponent='gnugo',
our_color='w')
gnu_go.run()
def generate_game(board_size, game_id_str, rounds_per_move=10, c=2.0):
start = time.time()
print(f'Generating {game_id_str}...')
game = GameState.new_game(board_size)
encoder = zero.ZeroEncoder(board_size)
# load current best agent, if any
# has to be able to pass through cPickle which is why we don't just reuse it
if os.path.exists('agz_bot.h5'):
with h5py.File('agz_bot.h5') as bot_file:
black_agent = zero.load_zero_agent(bot_file)
white_agent = zero.load_zero_agent(bot_file)
else:
print(f'WARN: using default model to generate {game_id_str}')
model = zero_model(board_size)
black_agent = zero.ZeroAgent(model, encoder, rounds_per_move=rounds_per_move, c=c)
white_agent = zero.ZeroAgent(model, encoder, rounds_per_move=rounds_per_move, c=c)
agents = {
Player.black: black_agent,
Player.white: white_agent,
}
c1 = zero.ZeroExperienceCollector()
c2 = zero.ZeroExperienceCollector()
black_agent.set_collector(c1)
white_agent.set_collector(c2)
c1.begin_episode()
c2.begin_episode()
while not game.is_over():
next_move = agents[game.next_player].select_move(game)
game = game.apply_move(next_move)
game_result = scoring.compute_game_result(game)
if game_result.winner == Player.black:
c1.complete_episode(1)
c2.complete_episode(-1)
else:
c1.complete_episode(-1)
c2.complete_episode(1)
combined = zero.combine_experience([c1, c2], board_size)
c1 = c2 = game_result = None
model = encoder = None
game = None
del black_agent.model
del white_agent.model
black_agent = white_agent = None
import gc
K.clear_session()
gc.collect()
return combined, game_id_str, time.time() - start