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 speed_test():
ITERATIONS = 3
man = get_manager()
# get data
train_config = config()
# get nn to test speed on
transformer = man.get_transformer(train_config.game)
trainer = train.TrainManager(train_config, transformer)
nn_model_config = templates.nn_model_config_template(train_config.game, "small", transformer)
generation_descr = templates.default_generation_desc(train_config.game)
trainer.get_network(nn_model_config, generation_descr)
data = trainer.gather_data()
res = []
batch_size = 4096
sample_count = len(data.inputs)
keras_model = trainer.nn.get_model()
# warm up
for i in range(2):
idx, end_idx = i * batch_size, (i + 1) * batch_size
print i, idx, end_idx
inputs = np.array(data.inputs[idx:end_idx])
res.append(keras_model.predict(inputs, batch_size=batch_size))
print res[0]
for _ in range(ITERATIONS):
res = []
times = []
gc.collect()
print 'Starting speed run'
num_batches = sample_count / batch_size + 1
print "batches %s, batch_size %s, inputs: %s" % (num_batches,
batch_size,
len(data.inputs))
for i in range(num_batches):
idx, end_idx = i * batch_size, (i + 1) * batch_size
inputs = np.array(data.inputs[idx:end_idx])
print "inputs", len(inputs)
s = time.time()
Y = keras_model.predict(inputs, batch_size=batch_size)
times.append(time.time() - s)
print "outputs", len(Y[0])
print "times taken", times
print "total_time taken", sum(times)
print "predictions per second", sample_count / float(sum(times))
def create_new_network(self, game, nn_model_conf=None, generation_descr=None):
if generation_descr is None:
generation_descr = templates.default_generation_desc(game)
transformer = self.get_transformer(game, generation_descr)
if isinstance(nn_model_conf, str):
nn_model_conf = templates.nn_model_config_template(game,
network_size_hint=nn_model_conf,
transformer=transformer)
elif nn_model_conf is None:
nn_model_conf = templates.nn_model_config_template(game,
network_size_hint="small",
transformer=transformer)
assert isinstance(nn_model_conf, confs.NNModelConfig)
assert isinstance(generation_descr, datadesc.GenerationDescription)
keras_model = get_network_model(nn_model_conf, generation_descr)
return NeuralNetwork(transformer, keras_model, generation_descr)
def test_nn_model_config_template():
game = "breakthrough"
gen_prefix = "x1"
prev_states = 1
gen_desc = templates.default_generation_desc(
game,
gen_prefix,
multiple_policy_heads=True,
num_previous_states=prev_states)
transformer = man.get_transformer(game, gen_desc)
model = templates.nn_model_config_template("breakthrough", "small",
transformer)
attrutil.pprint(model)
keras_model = get_network_model(model, gen_desc)
network = NeuralNetwork(transformer, keras_model, gen_desc)
print network
network.summary()
def go():
ITERATIONS = 3
man = get_manager()
# get data
train_config = config()
# get nn to test speed on
transformer = man.get_transformer(train_config.game)
trainer = train.TrainManager(train_config, transformer)
nn_model_config = templates.nn_model_config_template(train_config.game, "small", transformer)
generation_descr = templates.default_generation_desc(train_config.game)
trainer.get_network(nn_model_config, generation_descr)
data = trainer.gather_data()
r = Runner(trainer.gather_data(), trainer.nn.get_model())
r.warmup()
def get_nn_model(game, transformer, size="small"):
config = templates.nn_model_config_template(game, size, transformer)
config.cnn_filter_size = 128
config.cnn_kernel_size = 3
config.dropout_rate_policy = 0.25
config.dropout_rate_value = 0.5
config.input_channels = 3
config.input_columns = 8
config.input_rows = 8
config.l2_regularisation = False
config.multiple_policies = True
config.policy_dist_count = [
155,
155
]
config.residual_layers = 8
config.role_count = 2
config.value_hidden_size = 256
config.leaky_relu = False
return config
def test_save_load_net():
man = get_manager()
game = "breakthrough"
generation = "gen_1"
generation_descr = templates.default_generation_desc(game, generation)
transformer = man.get_transformer(game, generation_descr)
model_conf = templates.nn_model_config_template(game, "tiny", transformer)
nn = man.create_new_network(game, model_conf, generation_descr)
nn.summary()
man.save_network(nn)
assert man.can_load(game, generation)
nn2 = man.load_network(game, generation)
nn2.summary()
assert nn is not nn2
assert nn.generation_descr.name == generation
assert nn.generation_descr.name == nn2.generation_descr.name
assert nn.gdl_bases_transformer is nn2.gdl_bases_transformer
def test_net_sizes_with_l2():
man = get_manager()
for game in games:
generation_descr = templates.default_generation_desc(game, name="L2_1")
transformer = man.get_transformer(game, generation_descr)
# create a nn
for size in "tiny medium".split():
print
print size
model_conf = templates.nn_model_config_template(
game, size, transformer)
model_conf.l2_regularisation = True
model_conf.dropout_rate_value = -1
model_conf.dropout_rate_policy = -1
nn = man.create_new_network(game, model_conf, generation_descr)
nn.summary()
print
# print "hit return to compile"
# raw_input()
nn.compile()
def get_nn_model(game, transformer, size="small"):
config = templates.nn_model_config_template(game, size, transformer)
assert config.multiple_policies
assert config.cnn_kernel_size == 3
assert not config.l2_regularisation
# v1
# config.cnn_filter_size = 64
# config.residual_layers = 6
# config.value_hidden_size = 128
# abuse these for v2
config.cnn_filter_size = 96
config.residual_layers = -1
config.value_hidden_size = 0
config.dropout_rate_policy = 0.25
config.dropout_rate_value = 0.5
config.role_count = 2
config.leaky_relu = False
return config
def test_trainer_update_config():
# we need the data for this test
conf = get_conf_reversi()
# create a transformer
man = get_manager()
generation_descr = templates.default_generation_desc(conf.game)
generation_descr.num_previous_states = 2
generation_descr.multiple_policy_heads = True
transformer = man.get_transformer(conf.game, generation_descr)
# create the manager
trainer = train.TrainManager(conf, transformer, next_generation_prefix="x2test")
nn_model_config = templates.nn_model_config_template(conf.game, "tiny", transformer)
trainer.get_network(nn_model_config, generation_descr)
data = trainer.gather_data()
print data
trainer.do_epochs(data)
trainer.save()
