def __init__(self, killer=False): if killer: game_info = lookup.by_name("draughts_killer_10x10") else: game_info = lookup.by_name("draughts_10x10") super().__init__(game_info) self.board_desc = desc.BoardDesc(10)
def pretty_board(board_size, sm): assert board_size == 8 or board_size == 10 game_info = lookup.by_name( "reversi") if board_size == 8 else lookup.by_name("reversi_10x10") from ggplib.util.symbols import SymbolFactory as_str = game_info.model.basestate_to_str(sm.get_current_state()) sf = SymbolFactory() print list(sf.to_symbols(as_str)) mapping = {} control = None for s in sf.to_symbols(as_str): if s[1][0] == "control": control = s[1][1] else: assert s[1][0] == "cell" key = int(s[1][1]), int(s[1][2]) mapping[key] = s[1][3] lines = [] line_len = board_size * 4 + 1 lines.append(" +" + "-" * (line_len - 2) + "+") for i in reversed(range(1, board_size + 1)): ll = [" %2s |" % i] for j in reversed(range(1, board_size + 1)): key = j, i if key in mapping: if mapping[key] == "black": ll.append(" %s |" % u"\u2659") else: assert mapping[key] in ("red", "white") ll.append(" %s |" % u"\u265F") else: ll.append(" |") lines.append("".join(ll)) if i > 1: lines.append(" " + "-" * line_len) lines.append(" +" + "-" * (line_len - 2) + "+") if board_size == 8: lines.append(" " + ' '.join(' %s ' % c for c in 'abcdefgh')) else: lines.append(" " + ' '.join(' %s ' % c for c in 'abcdef')) print print print "\n".join(lines) print "Control:", control
def test_simple(): for game in games: sm = lookup.by_name(game).get_sm() bs_0 = sm.get_initial_state() bs_1 = sm.new_base_state() bs_1.assign(bs_0) for i in range(3): advance_state(sm, bs_1) assert bs_0 != bs_1 l0 = decode_state(encode_state(bs_0.to_list())) l1 = decode_state(encode_state(bs_1.to_list())) decode_bs_0 = sm.new_base_state() decode_bs_1 = sm.new_base_state() decode_bs_0.from_list(l0) decode_bs_1.from_list(l1) assert bs_0.to_string() == bs_0.to_string() assert decode_bs_0 == bs_0 assert decode_bs_0.hash_code() == bs_0.hash_code() print len(decode_bs_0.to_string()) print len(bs_0.to_string()) #assert decode_bs_0.to_string() == bs_0.to_string() assert decode_bs_1 == bs_1 assert decode_bs_1.hash_code() == bs_1.hash_code() assert decode_bs_1.to_string() == bs_1.to_string()
def test_speed(): import time for game in games: print "doing", game sm = lookup.by_name(game).get_sm() # a couple of states bs_0 = sm.get_initial_state() bs_1 = sm.new_base_state() bs_1.assign(bs_0) for i in range(5): advance_state(sm, bs_1) # encode states encoded_0 = encode_state(bs_0.to_list()) encoded_1 = encode_state(bs_1.to_list()) assert decode_state(encoded_0) == fast_decode_state(encoded_0) assert decode_state(encoded_1) == fast_decode_state(encoded_1) s = time.time() for i in range(10000): l0 = decode_state(encoded_0) l1 = decode_state(encoded_1) print "time taken %.3f msecs" % ((time.time() - s) * 1000) s = time.time() for i in range(10000): l0 = fast_decode_state(encoded_0) l1 = fast_decode_state(encoded_1) print "time taken %.3f msecs" % ((time.time() - s) * 1000)
def test_config_channel_last(): man = get_manager() for game in games: # create GenerationDescription generation_descr = templates.default_generation_desc(game) generation_descr.channel_last = True # lookup game in manager transformer = man.get_transformer(game, generation_descr) print transformer.x_cords # look game from database game_info = lookup.by_name(game) assert game == game_info.game sm = game_info.get_sm() basestate = sm.get_initial_state() print "rows x cols", transformer.num_rows, transformer.num_cols print print transformer.state_to_channels(basestate.to_list()) basestate = advance_state(game_info.get_sm(), basestate) print print transformer.state_to_channels(basestate.to_list())
def test_tron(): import py.test py.test.skip("WIP") game = "tron_10x10" generation = "test_1" man = get_manager() # create a nn model_conf = templates.nn_model_config_template(game) generation_descr = templates.default_generation_desc( game, generation, multiple_policy_heads=True) nn = man.create_new_network(game, model_conf, generation_descr) game_info = lookup.by_name(game) sm = game_info.get_sm() basestate = sm.get_initial_state() policy, scores = nn.predict_1(basestate.to_list()) print policy, scores res = nn.predict_n([basestate.to_list(), basestate.to_list()]) assert len(res) == 2 and len(res[0]) == 2 and len(res[1]) == 2 print policy, scores
def do_data_samples(game): game_info = lookup.by_name(game) r = Rollout(game_info) # perform a bunch of rollouts unique_states = set() samples = [] try: for i in range(1000): r.run() sample = None for _ in range(10): sample = r.make_data(unique_states) if sample is not None: break if sample is None: print "DUPE NATION", i continue samples.append(sample) if i % 50 == 0: print i except KeyboardInterrupt: pass for s in samples: print s.final_score
def __init__(self, cross=False, match_cb=None): game = "amazonsLGcross" if cross else "amazons_10x10" self.cross = cross self.match_cb = match_cb game_info = lookup.by_name(game) super().__init__(game_info)
def test_config_previous_states(): man = get_manager() for game in games: # create GenerationMetaAttributes generation_descr = templates.default_generation_desc(game) generation_descr.num_previous_states = 2 # lookup game in manager transformer = man.get_transformer(game, generation_descr) print transformer.x_cords # look game from database game_info = lookup.by_name(game) assert game == game_info.game sm = game_info.get_sm() basestate0 = sm.get_initial_state() basestate1 = advance_state(game_info.get_sm(), basestate0) basestate2 = advance_state(game_info.get_sm(), basestate1) print "rows x cols", transformer.num_rows, transformer.num_cols print "num_channels", transformer.num_channels print "basestate0:" print transformer.state_to_channels(basestate0.to_list(), []) print "basestate1:" print transformer.state_to_channels(basestate1.to_list(), [basestate0.to_list()]) print "basestate2:" print transformer.state_to_channels( basestate2.to_list(), [basestate1.to_list(), basestate0.to_list()])
def on_configure(self, server, msg): attrutil.pprint(msg) if self.game_info is None: self.game_info = lookup.by_name(msg.game) self.sm = self.game_info.get_sm() else: self.game_info.game == msg.game self.self_play_conf = msg.self_play_conf self.latest_generation_name = msg.generation_name # refresh the neural network. May have to run some commands to get it. self.nn = None try: self.nn = get_manager().load_network(self.game_info.game, self.latest_generation_name) self.configure_self_play() except Exception as exc: log.error("error in on_configure(): %s" % exc) for l in traceback.format_exc().splitlines(): log.error(l) self.cmds_running = runprocs.RunCmds( self.conf.run_post_training_cmds, cb_on_completion=self.finished_cmds_running, max_time=180.0) self.cmds_running.spawn() return msgs.Ok("configured")
def test_tictactoe_take_win(): gm = GameMaster(lookup.by_name("ticTacToe")) # add two c++ players gm.add_player(get.get_player("ggtest1"), "xplayer") gm.add_player(get.get_player("ggtest1"), "oplayer") str_state = ''' (true (control xplayer)) (true (cell 2 2 x)) (true (cell 3 2 o)) (true (cell 3 3 x)) (true (cell 2 3 o)) (true (cell 3 1 b)) (true (cell 2 1 b)) (true (cell 1 3 b)) (true (cell 1 2 b)) (true (cell 1 1 b)) ''' gm.start(meta_time=30, move_time=2, initial_basestate=gm.convert_to_base_state(str_state)) # play a single move - should take win move = gm.play_single_move() assert str(move[0]) == "(mark 1 1)" assert str(move[1]) == "noop" gm.play_to_end(last_move=move) # check scores/depth make some sense assert gm.scores['xplayer'] == 100 assert gm.scores['oplayer'] == 0 assert gm.get_game_depth() == 1
def on_configure(self, server, msg): attrutil.pprint(msg) if self.game_info is None: self.game_info = lookup.by_name(msg.game) self.sm = self.game_info.get_sm() else: if self.game_info.game != msg.game: log.critical("Game changed to %s" % msg.game) sys.exit(1) self.self_play_conf = msg.self_play_conf self.latest_generation_name = msg.generation_name # refresh the neural network. May have to run some commands to get it. self.nn = None while self.nn is None: try: self.nn = get_manager().load_network(self.game_info.game, self.latest_generation_name) except Exception as exc: log.error("error in on_configure(): %s" % exc) for l in traceback.format_exc().splitlines(): log.error(l) time.sleep(1.0) self.configure_self_play() return msgs.Ok("configured")
def play_game(generation_name, player_clz, num_previous_states=1): game = "breakthrough" # ensure we have a network man = get_manager() generation_descr = templates.default_generation_desc( game, multiple_policy_heads=True, num_previous_states=num_previous_states) nn = man.create_new_network(game, "tiny", generation_descr) man.save_network(nn, generation_name) nn.summary() conf = get_default_conf(generation_name, max_dump_depth=2, playouts_per_iteration=42) attrutil.pprint(conf) gm = GameMaster(lookup.by_name(game)) gm.add_player(player_clz(conf), "white") gm.add_player(get.get_player("random"), "black") gm.start(meta_time=30, move_time=15) last_move = None while not gm.finished(): last_move = gm.play_single_move(last_move=last_move) gm.finalise_match(last_move) return gm
def lookup_all_games(): # ensure things are initialised from ggplib.util.init import setup_once setup_once() failed = [] known_to_fail = [ 'amazonsTorus_10x10', 'atariGoVariant_7x7', 'gt_two_thirds_4p', 'gt_two_thirds_6p', 'linesOfAction' ] for game in lookup.get_all_game_names(): if game not in known_to_fail: try: game_info = lookup.by_name(game, build_sm=False) assert game_info.game == game sm = game_info.get_sm() # run some depth charges to ensure we have valid statemachine interface.depth_charge(sm, 1) log.verbose("DONE GETTING Statemachine FOR GAME %s %s" % (game, sm)) except lookup.LookupFailed as exc: log.warning("Failed to lookup %s: %s" % (game, exc)) failed.append(game) if failed: log.error("Failed games %s" % (failed, )) assert False, failed
def test_speed_chess_network_sizes(): game = "speedChess" game_info = lookup.by_name(game) sm = game_info.get_sm() # create GenerationDescription def get_generation_descr(): generation_descr = templates.default_generation_desc(game) generation_descr.num_previous_states = 0 yield generation_descr generation_descr.num_previous_states = 2 yield generation_descr generation_descr.num_previous_states = 30 yield generation_descr generation_descr.multiple_policy_heads = True yield generation_descr man = get_manager() for descr in get_generation_descr(): transformer = man.get_transformer(game, descr) nn = man.create_new_network(game, "small", descr) nn.summary()
def test_basic_config(): man = get_manager() for game in games: # look game from database game_info = lookup.by_name(game) assert game == game_info.game sm = game_info.get_sm() basestate = sm.get_initial_state() # lookup game in manager transformer = man.get_transformer(game) print "rows x cols", transformer.num_rows, transformer.num_cols print transformer.x_cords print transformer.y_cords print print transformer.state_to_channels(basestate.to_list()) basestate = advance_state(game_info.get_sm(), basestate) print print transformer.state_to_channels(basestate.to_list()) basestate = advance_state(game_info.get_sm(), basestate) print transformer.state_to_channels(basestate.to_list())
def test_baduk(): def show(pred): win_0, win_1, draw = list(pred.scores) print "wins/draw", win_0, win_1, draw win_0 += draw / 2 win_1 += draw / 2 print "wins only", win_0, win_1, win_0 + win_1 man = get_manager() game = "baduk_9x9" # create a nn game_info = lookup.by_name(game) sm = game_info.get_sm() nn = man.load_network(game, "h3_11") nn.summary() basestate = sm.get_initial_state() predictions = nn.predict_1(basestate.to_list()) print predictions.policies, predictions.scores predictions = nn.predict_n([basestate.to_list(), basestate.to_list()]) assert len(predictions) == 2 and len(predictions[0].policies) == 2 and len(predictions[0].scores) == 3 show(predictions[0]) prevs = [] for i in range(4): prevs.append(basestate) basestate = advance_state(game_info.get_sm(), basestate) prediction = nn.predict_1(basestate.to_list(), [p.to_list() for p in prevs]) show(prediction)
def do_game(game, gen, players, meta_time, move_time): # ensure we have a network gm = GameMaster(get_gdl_for_game(game), verbose=False) info = lookup.by_name(game) for player, role in zip(players, gm.sm.get_roles()): gm.add_player(player, role) roles = gm.sm.get_roles() match_info = create_match_info(meta_time, move_time, len(roles), game, [p.get_name() for p, r in gm.players], False) # save match_info update_match_info(game, match_info) gm.start(meta_time=meta_time, move_time=move_time) the_bs = gm.sm.new_base_state() gm.sm.get_current_state(the_bs) set_initial_state(match_info, basestate_to_str(info.model, the_bs)) last_move = None while not gm.finished(): last_move = gm.play_single_move(last_move) gm.sm.get_current_state(the_bs) add_to_next(match_info, list(last_move), basestate_to_str(info.model, the_bs)) update_match_info(game, match_info) gm.play_to_end(last_move) set_goals(match_info, [gm.get_score(r) for _, r in gm.players]) update_match_info(game, match_info)
def do_transformer(num_previous_states): game = "breakthrough" game_info = lookup.by_name(game) sm = game_info.get_sm() man = get_manager() # only multiple_policy_heads supported in c++ generation_descr = templates.default_generation_desc( game, multiple_policy_heads=True, num_previous_states=num_previous_states) t = man.get_transformer(game, generation_descr) # create transformer wrapper object c_transformer = cppinterface.create_c_transformer(t) nn = man.create_new_network(game, "small", generation_descr) verbose = True total_predictions = 0 total_s0 = 0 total_s1 = 0 total_s2 = 0 for ii in range(10): print ii start = time.time() array = c_transformer.test(cppinterface.sm_to_ptr(sm)) total_s0 += time.time() - start sz = len(array) / (t.num_channels * t.channel_size) total_predictions += sz array = array.reshape(sz, t.num_channels, t.num_cols, t.num_rows) total_s1 += time.time() - start if verbose: np.set_printoptions(threshold=np.inf, formatter={'float_kind': float_formatter0}) print array # test we can actually predict res = nn.get_model().predict(array, batch_size=sz) # print res[0].shape # print res[1].shape total_s2 += time.time() - start if verbose: np.set_printoptions(threshold=np.inf, formatter={'float_kind': float_formatter1}) print res print total_predictions, "time taken", [ s * 1000 for s in (total_s0, total_s1, total_s2) ]
def __init__(self, short_50=False): if short_50: game = "chess_15d" else: game = "chess_50d" self.game_info = lookup.by_name(game) super().__init__(self.game_info)
def __init__(self, train_config, transformer, do_data_augmentation=False): # take a copy of the initial train_config assert isinstance(train_config, confs.TrainNNConfig) self.transformer = transformer self.do_data_augmentation = do_data_augmentation # lookup via game_name (this gets statemachine & statemachine model) self.game_info = lookup.by_name(train_config.game) self.update_config(attrutil.clone(train_config)) self.cb = None
def create_sm(board_desc, fen, killer_mode=False): from ggplib.db import lookup basestate_as_list = board_desc.state_from_fen(fen) if killer_mode: info = lookup.by_name("draughts_killer_10x10") else: info = lookup.by_name("draughts_10x10") # will dupe / and reset sm = info.get_sm() # want to create a GGP basestate basestate = sm.new_base_state() for i, v in enumerate(basestate_as_list): basestate.set(i, v) sm.update_bases(basestate) return sm
def determine_cords(game): # go through each base by "base term" and determine if is # (a) control # (b) a useful control # (c) a cord state # (d) something else game_info = lookup.by_name(game) for b in game_info.model.bases: print b
def test_depth_charges(): board_desc = desc.BoardDesc(10) for game in ("draughts_10x10", "draughts_killer_10x10"): info = lookup.by_name(game) # will dupe / and reset sm = info.get_sm() joint_move = sm.get_joint_move() base_state = sm.new_base_state() role_count = len(sm.get_roles()) all_scores = [[] for i in range(role_count)] s = time.time() ITERATIONS = 100 total_depth = 0 for ii in range(ITERATIONS): sm.reset() board_desc.print_board_sm(sm) while not sm.is_terminal(): for role_index, role in enumerate(sm.get_roles()): ls = sm.get_legal_state(role_index) choice = ls.get_legal(random.randrange(0, ls.get_count())) joint_move.set(role_index, choice) # play move, the base_state will be new state sm.next_state(joint_move, base_state) # update the state machine to new state sm.update_bases(base_state) board_desc.print_board_sm(sm) total_depth += 1 for ri in range(role_count): all_scores[ri].append(sm.get_goal_value(ri)) total_time = time.time() - s print all_scores print "average depth", total_depth / float(ITERATIONS) print(total_time / float(ITERATIONS)) * 1000 print "running %s for 2 seconds in C" % game from ggplib.interface import depth_charge msecs_taken, rollouts, num_state_changes = depth_charge(sm, 2) print "====================================================" print "ran for %.3f seconds, state changes %s, rollouts %s" % ( (msecs_taken / 1000.0), num_state_changes, rollouts) print "rollouts per second: %s" % (rollouts / (msecs_taken / 1000.0))
def main_2(game_name, seconds_to_run): game_info = lookup.by_name(game_name) sm = game_info.get_sm() msecs_taken, rollouts, num_state_changes = go(sm, seconds_to_run) log.info("====================================================") log.info("performance test game %s" % game_name) log.info("ran for %.3f seconds, state changes %s, rollouts %s" % ((msecs_taken / 1000.0), num_state_changes, rollouts)) log.info("rollouts per second: %s" % (rollouts / (msecs_taken / 1000.0))) log.info("====================================================")
def get_game_info(board_size): # add players if board_size == 8: game = "breakthrough" elif board_size == 7: game = "bt_7" elif board_size == 6: game = "breakthroughSmall" else: assert "board_size not supported" return lookup.by_name(game)
def test_tictactoe_cpp_play(): gm = GameMaster(lookup.by_name("ticTacToe")) # add two c++ players gm.add_player(get.get_player("random"), "xplayer") gm.add_player(get.get_player("legal"), "oplayer") gm.start(meta_time=10, move_time=5) gm.play_to_end() # check scores/depth make some sense assert sum(gm.scores.values()) == 100 assert 5 <= gm.get_game_depth() <= 9
def test_more(): for game in games: print "doing", game sm = lookup.by_name(game).get_sm() bs_0 = sm.get_initial_state() bs_1 = sm.new_base_state() bs_1.assign(bs_0) for i in range(5): advance_state(sm, bs_1) assert bs_0 != bs_1 # states to compare decode_bs_0 = sm.new_base_state() decode_bs_1 = sm.new_base_state() decode_direct_bs_0 = sm.new_base_state() decode_direct_bs_1 = sm.new_base_state() # encode as before en_0 = encode_state(bs_0.to_list()) en_1 = encode_state(bs_1.to_list()) # decode as before l0 = decode_state(en_0) l1 = decode_state(en_1) decode_bs_0.from_list(l0) decode_bs_1.from_list(l1) # decode directly decode_direct_bs_0.from_string(base64.decodestring(en_0)) decode_direct_bs_1.from_string(base64.decodestring(en_1)) # all checks assert decode_bs_0 == bs_0 assert decode_bs_0.hash_code() == bs_0.hash_code() assert decode_bs_0.to_string() == bs_0.to_string() assert decode_direct_bs_0 == bs_0 assert decode_direct_bs_0.hash_code() == bs_0.hash_code() assert decode_direct_bs_0.to_string() == bs_0.to_string() assert decode_bs_1 == bs_1 assert decode_bs_1.hash_code() == bs_1.hash_code() assert decode_bs_1.to_string() == bs_1.to_string() assert decode_direct_bs_1 == bs_1 assert decode_direct_bs_1.hash_code() == bs_1.hash_code() assert decode_direct_bs_1.to_string() == bs_1.to_string() print "good", game
def game_test(game, pretty_board, advance_state_count): # game stuff info = lookup.by_name(game) transformer = get_manager().get_transformer(game) # the translator t = sym.create_translator(info, transformer.game_desc, transformer.get_symmetries_desc()) # start with a statemachine - and advance 5 moves sm = info.get_sm() sm.reset() basestate = sm.get_initial_state() for i in range(advance_state_count): basestate = advance_state(sm, basestate) sm.update_bases(basestate) # print board & moves print "original board:" pretty_board(sm) prescription = sym.Prescription(transformer.get_symmetries_desc()) translated_basestate = sm.new_base_state() # do all reflections / rotations in prescription for do_reflection, rot_count in prescription: print "reflection", do_reflection, "rotations", rot_count # translate state/moves basestate_list = t.translate_basestate(basestate.to_list(), do_reflection, rot_count) basestate2_list = t.translate_basestate_faster(basestate.to_list(), do_reflection, rot_count) assert basestate_list == basestate2_list translated_moves = translate_moves(sm, basestate, t, do_reflection, rot_count) translated_basestate.from_list(basestate_list) assert all_moves(sm, translated_basestate) == translated_moves sm.update_bases(translated_basestate) # print board & moves pretty_board(sm) for role, moves in all_moves(sm, translated_basestate): print role, moves
def play(player_white, player_black, move_time=0.5): gm = GameMaster(lookup.by_name(GAME), verbose=True) gm.add_player(player_white, "white") gm.add_player(player_black, "black") gm.start(meta_time=15, move_time=move_time) move = None while not gm.finished(): # print out the board pretty_board(BOARD_SIZE, gm.sm) move = gm.play_single_move(last_move=move) gm.finalise_match(move)