def _setup_multitask_learn(self, model_name: str):
self._setup_learn(config.seed)
if self.max_scheduler_timesteps is None:
self.max_scheduler_timesteps = config.max_timesteps
self.learning_rate_schedule = utils.Scheduler(
initial_value=self.initial_learning_rate,
n_values=self.max_scheduler_timesteps,
schedule=self.lr_schedule,
init_step=self.num_timesteps)
tbw = TensorboardWriter(self.graph, self.tensorboard_log, model_name)
if tbw is not None:
self.episode_reward = EpisodeRewardCalculator(
[key for key in self.env_dict.keys()], self.n_envs_per_task,
tbw.writer)
else:
self.episode_reward = EpisodeRewardCalculator(
[key for key in self.env_dict.keys()], self.n_envs_per_task,
None)
return tbw
import utils sched = utils.Scheduler() sched.use_simulated(True) sched.stop_action(-1)
network_file = utils.all_files_under(FLAGS.load_model_dir,
extension=".json")
weight_file = utils.all_files_under(FLAGS.load_model_dir, extension=".h5")
assert len(network_file) == 1 and len(weight_file) == 1
with open(network_file[0], 'r') as f:
network = model_from_json(f.read())
network.load_weights(weight_file[0])
network = model.set_optimizer(network)
else:
network = model.dr_network_segmentation_as_input()
network.summary()
with open(os.path.join(model_out_dir, "network.json"), 'w') as f:
f.write(network.to_json())
# start training
scheduler = utils.Scheduler(schedules)
for epoch in range(n_epochs):
# update step sizes, learning rates
scheduler.update_steps(epoch)
K.set_value(network.optimizer.lr, scheduler.get_lr())
# train on the training set
start_time = time.time()
losses, accs = [], []
for fnames, fundus_rescale_mean_subtract_lesions, grades in train_batch_fetcher(
):
loss, acc = network.train_on_batch(
fundus_rescale_mean_subtract_lesions, grades)
losses += [loss] * fundus_rescale_mean_subtract_lesions.shape[0]
accs += [acc] * fundus_rescale_mean_subtract_lesions.shape[0]
utils.print_metrics(epoch + 1,
elif FLAGS.discriminator=='image':
d, d_out_shape = discriminator_image(img_size, n_filters_d,init_lr)
else:
d, d_out_shape = discriminator_dummy(img_size, n_filters_d,init_lr)
utils.make_trainable(d, False)
gan=GAN(g,d,img_size, n_filters_g, n_filters_d,alpha_recip, init_lr)
generator=pretrain_g(g, img_size, n_filters_g, init_lr)
g.summary()
d.summary()
gan.summary()
with open(os.path.join(model_out_dir,"g_{}_{}.json".format(FLAGS.discriminator,FLAGS.ratio_gan2seg)),'w') as f:
f.write(g.to_json())
# start training
scheduler=utils.Scheduler(n_train_imgs//batch_size, n_train_imgs//batch_size, schedules, init_lr) if alpha_recip>0 else utils.Scheduler(0, n_train_imgs//batch_size, schedules, init_lr)
print "training {} images :".format(n_train_imgs)
for n_round in range(n_rounds):
# train D
utils.make_trainable(d, True)
for i in range(scheduler.get_dsteps()):
real_imgs, real_vessels = next(train_batch_fetcher)
d_x_batch, d_y_batch = utils.input2discriminator(real_imgs, real_vessels, g.predict(real_imgs,batch_size=batch_size), d_out_shape)
loss, acc = d.train_on_batch(d_x_batch, d_y_batch)
# train G (freeze discriminator)
utils.make_trainable(d, False)
for i in range(scheduler.get_gsteps()):
real_imgs, real_vessels = next(train_batch_fetcher)
g_x_batch, g_y_batch=utils.input2gan(real_imgs, real_vessels, d_out_shape)
def main(_):
vocab = Vocab()
vocab.load_from_pickle()
reader = Reader(vocab)
config_proto = tf.ConfigProto()
config_proto.gpu_options.allow_growth = True
with tf.Graph().as_default(), tf.Session(config=config_proto) as session:
with tf.variable_scope("Model") as scope:
if cfg.training:
with tf.variable_scope("LR"):
g_lr = tf.get_variable("g_lr",
shape=[],
initializer=tf.zeros_initializer,
trainable=False)
d_lr = tf.get_variable("d_lr",
shape=[],
initializer=tf.zeros_initializer,
trainable=False)
g_optimizer = utils.get_optimizer(g_lr, cfg.g_optimizer)
d_optimizer = utils.get_optimizer(d_lr, cfg.d_optimizer)
model = EncoderDecoderModel(vocab,
True,
use_gan=cfg.use_gan,
g_optimizer=g_optimizer,
d_optimizer=d_optimizer)
scope.reuse_variables()
eval_model = EncoderDecoderModel(vocab,
False,
use_gan=cfg.use_gan)
else:
test_model = EncoderDecoderModel(vocab,
False,
use_gan=cfg.use_gan)
scope.reuse_variables()
generator = EncoderDecoderModel(vocab,
False,
use_gan=cfg.use_gan,
generator=True)
decode_op = beam_decode_op(generator, vocab, cfg.beam_size)
saver = tf.train.Saver()
try:
# try to restore a saved model file
saver.restore(session, cfg.load_file)
print("Model restored from", cfg.load_file)
except ValueError:
if cfg.training:
tf.initialize_all_variables().run()
print("No loadable model file, new model initialized.")
else:
print("You need to provide a valid model file for testing!")
sys.exit(1)
if cfg.training:
steps = 0
train_perps = []
valid_perps = []
session.run(tf.assign(g_lr, cfg.g_learning_rate))
session.run(tf.assign(d_lr, cfg.d_learning_rate))
if cfg.sc_use_kld_weight:
min_kld_weight = cfg.anneal_max - 1e-4
else:
min_kld_weight = -1
scheduler = utils.Scheduler(cfg.min_d_acc, cfg.max_d_acc,
cfg.max_perplexity, min_kld_weight,
cfg.sc_list_size, cfg.sc_decay)
for i in range(cfg.max_epoch):
print("\nEpoch: %d" % (i + 1))
perplexity, steps = run_epoch(i, session, model, generator,
reader.training(), vocab, saver,
steps, cfg.max_steps, scheduler,
cfg.use_gan, cfg.gen_every,
decode_op)
print("Epoch: %d Train Perplexity: %.3f" % (i + 1, perplexity))
train_perps.append(perplexity)
if cfg.validate_every > 0 and (i +
1) % cfg.validate_every == 0:
perplexity, _ = run_epoch(i, session,
eval_model, generator,
reader.validation(), vocab, None,
0, -1, None, cfg.use_gan, -1,
decode_op)
print("Epoch: %d Validation Perplexity: %.3f" %
(i + 1, perplexity))
valid_perps.append(perplexity)
else:
valid_perps.append(None)
print('Train:', train_perps)
print('Valid:', valid_perps)
if steps >= cfg.max_steps:
break
else:
print('\nTesting')
perplexity, _ = run_epoch(0, session, test_model, generator,
reader.testing(), vocab, None, 0,
cfg.max_steps, None, cfg.use_gan, -1,
decode_op)
print("Test Perplexity: %.3f" % perplexity)
