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)