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)
