def main(_): bst_acc = 0.0 acc_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) start = time.time() for tn_batch in range(tn_num_batch): tn_image_np, tn_label_np = mnist.train.next_batch(flags.batch_size) feed_dict = { tn_tch.image_ph: tn_image_np, tn_tch.hard_label_ph: tn_label_np } _, summary = sess.run([tn_tch.pre_update, summary_op], feed_dict=feed_dict) writer.add_summary(summary, tn_batch) if flags.log_accuracy: feed_dict = { vd_tch.image_ph: mnist.test.images, vd_tch.hard_label_ph: mnist.test.labels, } acc = sess.run(vd_tch.accuracy, feed_dict=feed_dict) acc_list.append(acc) if (tn_batch + 1) % eval_interval != 0: continue else: if (tn_batch + 1) % eval_interval != 0: continue feed_dict = { vd_tch.image_ph: mnist.test.images, vd_tch.hard_label_ph: mnist.test.labels, } acc = sess.run(vd_tch.accuracy, feed_dict=feed_dict) bst_acc = max(acc, bst_acc) tot_time = time.time() - start global_step = sess.run(tn_tch.global_step) avg_time = (tot_time / global_step) * (mnist.train.num_examples / flags.batch_size) print('#%08d curacc=%.4f curbst=%.4f tot=%.0fs avg=%.2fs/epoch' % (tn_batch, acc, bst_acc, tot_time, avg_time)) if acc < bst_acc: continue tn_tch.saver.save(utils.get_session(sess), flags.tch_model_ckpt) tot_time = time.time() - start print('#mnist=%d bstacc=%.4f et=%.0fs' % (tn_size, bst_acc, tot_time)) if flags.log_accuracy: utils.create_pardir(flags.all_learning_curve_p) pickle.dump(acc_list, open(flags.all_learning_curve_p, 'wb'))
def main(_): best_prec = 0.0 prec_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) start = time.time() for tn_batch in range(tn_num_batch): tn_image_np, _, tn_label_np = yfccdata.next_batch(flags, sess) feed_dict = { tn_gen.image_ph: tn_image_np, tn_gen.hard_label_ph: tn_label_np } _, summary = sess.run([tn_gen.pre_update, summary_op], feed_dict=feed_dict) writer.add_summary(summary, tn_batch) prec = yfcceval.compute_prec(flags, sess, vd_gen) prec_list.append(prec) if (tn_batch + 1) % eval_interval != 0: continue best_prec = max(prec, best_prec) tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) avg_time = (tot_time / global_step) * (tn_data_size / flags.batch_size) print('#%08d prec@%d=%.4f best=%.4f tot=%.0fs avg=%.2fs/epoch' % (global_step, flags.cutoff, prec, best_prec, tot_time, avg_time)) if prec < best_prec: continue tn_gen.saver.save(utils.get_session(sess), flags.gen_model_ckpt) tot_time = time.time() - start print('best@%d=%.4f et=%.0fs' % (flags.cutoff, best_prec, tot_time)) utils.create_pardir(flags.all_learning_curve_p) pickle.dump(prec_list, open(flags.all_learning_curve_p, 'wb'))
def main(_): utils.create_pardir(flags.model_run) id_to_label = utils.load_id_to_label(flags.dataset) fout = open(flags.model_run, 'w') with tf.train.MonitoredTrainingSession() as sess: tn_model.saver.restore(sess, model_ckpt) if hasattr(vd_model, 'text_ph'): feed_dict = { vd_model.image_ph: image_np, vd_model.text_ph: text_np, } else: feed_dict = { vd_model.image_ph: image_np, } logit_np = sess.run(vd_model.logits, feed_dict=feed_dict) for imgid, logit_np in zip(imgid_np, logit_np): sorted_labels = (-logit_np).argsort() fout.write('%s' % (imgid)) for label in sorted_labels: fout.write(' %s %.4f' % (id_to_label[label], logit_np[label])) fout.write('\n') fout.close() print('result saved in %s' % flags.model_run)
def main(_): best_prec, bst_epk = 0.0, 0 epk_score_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) tn_dis.saver.restore(sess, flags.dis_model_ckpt) tn_gen.saver.restore(sess, flags.gen_model_ckpt) tn_tch.saver.restore(sess, flags.tch_model_ckpt) start = time.time() ini_dis = yfcceval.compute_prec(flags, sess, vd_dis) ini_gen = yfcceval.compute_prec(flags, sess, vd_gen) ini_tch = yfcceval.compute_prec(flags, sess, vd_tch) print('ini dis=%.4f gen=%.4f tch=%.4f' % (ini_dis, ini_gen, ini_tch)) batch_d, batch_g, batch_t = -1, -1, -1 for epoch in range(flags.num_epoch): num_batch_d = math.ceil(flags.num_dis_epoch * tn_size / flags.batch_size) for _ in range(num_batch_d): batch_d += 1 image_d, text_d, label_dat_d = yfccdata_d.next_batch(flags, sess) feed_dict = {tn_gen.image_ph:image_d} label_gen_d = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_gen_d, gen_label_d = utils.gan_dis_sample(flags, label_dat_d, label_gen_d) feed_dict = {tn_tch.image_ph:image_d, tn_tch.text_ph:text_d} label_tch_d = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_tch_d, tch_label_d = utils.gan_dis_sample(flags, label_dat_d, label_tch_d) feed_dict = { tn_dis.image_ph:image_d, tn_dis.gen_sample_ph:sample_gen_d, tn_dis.gen_label_ph:gen_label_d, tn_dis.tch_sample_ph:sample_tch_d, tn_dis.tch_label_ph:tch_label_d, } _, summary_d = sess.run([tn_dis.gan_update, dis_summary_op], feed_dict=feed_dict) writer.add_summary(summary_d, batch_d) num_batch_t = math.ceil(flags.num_tch_epoch * tn_size / flags.batch_size) for _ in range(num_batch_t): batch_t += 1 image_t, text_t, label_dat_t = yfccdata_t.next_batch(flags, sess) feed_dict = {tn_tch.image_ph:image_t, tn_tch.text_ph:text_t} label_tch_t = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_t = utils.generate_label(flags, label_dat_t, label_tch_t) feed_dict = {tn_dis.image_ph:image_t, tn_dis.tch_sample_ph:sample_t} reward_t = sess.run(tn_dis.tch_rewards, feed_dict=feed_dict) feed_dict = {vd_gen.image_ph:image_t} soft_logit_t = sess.run(vd_gen.logits, feed_dict=feed_dict) feed_dict = { tn_tch.image_ph:image_t, tn_tch.text_ph:text_t, tn_tch.sample_ph:sample_t, tn_tch.reward_ph:reward_t, tn_tch.hard_label_ph:label_dat_t, tn_tch.soft_logit_ph:soft_logit_t, } _, summary_t = sess.run([tn_tch.kdgan_update, tch_summary_op], feed_dict=feed_dict) writer.add_summary(summary_t, batch_t) num_batch_g = math.ceil(flags.num_gen_epoch * tn_size / flags.batch_size) for _ in range(num_batch_g): batch_g += 1 image_g, text_g, label_dat_g = yfccdata_g.next_batch(flags, sess) feed_dict = {tn_tch.image_ph:image_g, tn_tch.text_ph:text_g} logit_tch_g = sess.run(tn_tch.logits, feed_dict=feed_dict) # print('tch label {}'.format(logit_tch_g.shape)) feed_dict = {tn_gen.image_ph:image_g} label_gen_g = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_g = utils.generate_label(flags, label_dat_g, label_gen_g) feed_dict = {tn_dis.image_ph:image_g, tn_dis.gen_sample_ph:sample_g} reward_g = sess.run(tn_dis.gen_rewards, feed_dict=feed_dict) feed_dict = { tn_gen.image_ph:image_g, tn_gen.hard_label_ph:label_dat_g, tn_gen.soft_logit_ph:logit_tch_g, tn_gen.sample_ph:sample_g, tn_gen.reward_ph:reward_g, } _, summary_g = sess.run([tn_gen.kdgan_update, gen_summary_op], feed_dict=feed_dict) writer.add_summary(summary_g, batch_g) if (batch_g + 1) % eval_interval != 0: continue scores = yfcceval.compute_score(flags, sess, vd_gen) p3, p5, f3, f5, ndcg3, ndcg5, ap, rr = scores # print('p3=%.4f p5=%.4f f3=%.4f f5=%.4f ndcg3=%.4f ndcg5=%.4f ap=%.4f rr=%.4f' % # (p3, p5, f3, f5, ndcg3, ndcg5, ap, rr)) epk_score_list.append((scores)) prec = yfcceval.compute_prec(flags, sess, vd_gen) if prec > best_prec: bst_epk = epoch best_prec = max(prec, best_prec) tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) avg_time = (tot_time / global_step) * (tn_size / flags.batch_size) print('#%08d@%d prec@%d=%.4f best@%d=%.4f tot=%.0fs avg=%.2fs/epoch' % (global_step, epoch, flags.cutoff, prec, bst_epk, best_prec, tot_time, avg_time)) if prec < best_prec: continue # save if necessary tot_time = time.time() - start print('best@%d=%.4f et=%.0fs' % (bst_epk, best_prec, tot_time)) utils.create_pardir(flags.epk_learning_curve_p) pickle.dump(epk_score_list, open(flags.epk_learning_curve_p, 'wb'))
def main(_): bst_acc = 0.0 acc_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) tn_dis.saver.restore(sess, flags.dis_model_ckpt) tn_gen.saver.restore(sess, flags.gen_model_ckpt) feed_dict = { vd_dis.image_ph: dis_mnist.test.images, vd_dis.hard_label_ph: dis_mnist.test.labels, } ini_dis = sess.run(vd_dis.accuracy, feed_dict=feed_dict) feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } ini_gen = sess.run(vd_gen.accuracy, feed_dict=feed_dict) print('ini dis=%.4f ini gen=%.4f' % (ini_dis, ini_gen)) # exit() start = time.time() batch_d, batch_g = -1, -1 for epoch in range(flags.num_epoch): for dis_epoch in range(flags.num_dis_epoch): # print('epoch %03d dis_epoch %03d' % (epoch, dis_epoch)) num_batch_d = math.ceil(tn_size / flags.batch_size) for image_np_d, label_dat_d in dis_datagen.generate( batch_size=flags.batch_size): # for _ in range(num_batch_d): # image_np_d, label_dat_d = dis_mnist.train.next_batch(flags.batch_size) batch_d += 1 feed_dict = {tn_gen.image_ph: image_np_d} label_gen_d, = sess.run([tn_gen.labels], feed_dict=feed_dict) # print('label_dat_d={} label_gen_d={}'.format(label_dat_d.shape, label_gen_d.shape)) sample_np_d, label_np_d = utils.gan_dis_sample_dev( flags, label_dat_d, label_gen_d) feed_dict = { tn_dis.image_ph: image_np_d, tn_dis.sample_ph: sample_np_d, tn_dis.dis_label_ph: label_np_d, } _, summary_d = sess.run( [tn_dis.gan_update, dis_summary_op], feed_dict=feed_dict) writer.add_summary(summary_d, batch_d) for gen_epoch in range(flags.num_gen_epoch): # print('epoch %03d gen_epoch %03d' % (epoch, gen_epoch)) num_batch_g = math.ceil(tn_size / flags.batch_size) for image_np_g, label_dat_g in gen_datagen.generate( batch_size=flags.batch_size): # for _ in range(num_batch_g): # image_np_g, label_dat_g = gen_mnist.train.next_batch(flags.batch_size) batch_g += 1 feed_dict = {tn_gen.image_ph: image_np_g} label_gen_g, = sess.run([tn_gen.labels], feed_dict=feed_dict) sample_np_g = utils.generate_label(flags, label_dat_g, label_gen_g) # sample_np_g, rescale_np_g = utils.generate_label(flags, label_dat_g, label_gen_g) # print(sample_np_g.shape, rescale_np_g.shape) feed_dict = { tn_dis.image_ph: image_np_g, tn_dis.sample_ph: sample_np_g, } reward_np_g, = sess.run([tn_dis.rewards], feed_dict=feed_dict) # reward_np_g *= rescale_np_g # print(reward_np_g) feed_dict = { tn_gen.image_ph: image_np_g, tn_gen.sample_ph: sample_np_g, tn_gen.reward_ph: reward_np_g, } _, summary_g = sess.run( [tn_gen.gan_update, gen_summary_op], feed_dict=feed_dict) writer.add_summary(summary_g, batch_g) if flags.collect_cr_data: feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) acc_list.append(acc) if (batch_g + 1) % eval_interval != 0: continue else: if (batch_g + 1) % eval_interval != 0: continue feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) bst_acc = max(acc, bst_acc) tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) avg_time = (tot_time / global_step) * (tn_size / flags.batch_size) print( '#%08d curacc=%.4f curbst=%.4f tot=%.0fs avg=%.2fs/epoch' % (batch_g, acc, bst_acc, tot_time, avg_time)) if acc <= bst_acc: continue # save gen parameters if necessary tot_time = time.time() - start print('#mnist=%d bstacc=%.4f et=%.0fs' % (tn_size, bst_acc, tot_time)) if flags.collect_cr_data: utils.create_pardir(flags.all_learning_curve_p) pickle.dump(acc_list, open(flags.all_learning_curve_p, 'wb'))
def main(_): best_prec = 0.0 prec_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) tn_dis.saver.restore(sess, flags.dis_model_ckpt) tn_gen.saver.restore(sess, flags.gen_model_ckpt) ini_dis = yfcceval.compute_prec(flags, sess, vd_dis) ini_gen = yfcceval.compute_prec(flags, sess, vd_gen) print('ini dis=%.4f gen=%.4f' % (ini_dis, ini_gen)) start = time.time() batch_d, batch_g = -1, -1 for epoch in range(flags.num_epoch): num_batch_d = math.ceil(flags.num_dis_epoch * tn_data_size / flags.batch_size) for _ in range(num_batch_d): batch_d += 1 image_np_d, _, label_dat_d = yfccdata_d.next_batch(flags, sess) feed_dict = {tn_gen.image_ph: image_np_d} label_gen_d = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_np_d, label_np_d = utils.gan_dis_sample( flags, label_dat_d, label_gen_d) feed_dict = { tn_dis.image_ph: image_np_d, tn_dis.sample_ph: sample_np_d, tn_dis.dis_label_ph: label_np_d, } _, summary_d = sess.run([tn_dis.gan_update, dis_summary_op], feed_dict=feed_dict) writer.add_summary(summary_d, batch_d) num_batch_g = math.ceil(flags.num_gen_epoch * tn_data_size / flags.batch_size) for _ in range(num_batch_g): batch_g += 1 image_np_g, _, label_dat_g = yfccdata_g.next_batch(flags, sess) feed_dict = {tn_gen.image_ph: image_np_g} label_gen_g = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_np_g = utils.generate_label(flags, label_dat_g, label_gen_g) feed_dict = { tn_dis.image_ph: image_np_g, tn_dis.sample_ph: sample_np_g, } reward_np_g = sess.run(tn_dis.rewards, feed_dict=feed_dict) feed_dict = { tn_gen.image_ph: image_np_g, tn_gen.sample_ph: sample_np_g, tn_gen.reward_ph: reward_np_g, } _, summary_g = sess.run([tn_gen.gan_update, gen_summary_op], feed_dict=feed_dict) writer.add_summary(summary_g, batch_g) prec = yfcceval.compute_prec(flags, sess, vd_gen) prec_list.append(prec) if (batch_g + 1) % eval_interval != 0: continue best_prec = max(prec, best_prec) tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) avg_time = (tot_time / global_step) * (tn_data_size / flags.batch_size) print( '#%08d prec@%d=%.4f best=%.4f tot=%.0fs avg=%.2fs/epoch' % (global_step, flags.cutoff, prec, best_prec, tot_time, avg_time)) if prec < best_prec: continue # hit_v = utils.evaluate(flags, sess, vd_gen, bt_list_v) # tot_time = time.time() - start # print('#%03d curbst=%.4f %.0fs' % (epoch, hit_v, tot_time)) # figure_data.append((epoch, hit_v)) # if hit_v <= best_prec: # continue # best_prec = hit_v tot_time = time.time() - start print('best@%d=%.4f et=%.0fs' % (flags.cutoff, best_prec, tot_time)) utils.create_pardir(flags.all_learning_curve_p) pickle.dump(prec_list, open(flags.all_learning_curve_p, 'wb'))
def main(_): bst_gen_acc, bst_tch_acc, bst_eph = 0.0, 0.0, 0 acc_list = [] writer = tf.summary.FileWriter(config.logs_dir, graph=tf.get_default_graph()) with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) tn_dis.saver.restore(sess, flags.dis_model_ckpt) tn_gen.saver.restore(sess, flags.gen_model_ckpt) tn_tch.saver.restore(sess, flags.tch_model_ckpt) feed_dict = { vd_dis.image_ph: dis_mnist.test.images, vd_dis.hard_label_ph: dis_mnist.test.labels, } ini_dis = sess.run(vd_dis.accuracy, feed_dict=feed_dict) feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } ini_gen = sess.run(vd_gen.accuracy, feed_dict=feed_dict) print('ini dis=%.4f ini gen=%.4f' % (ini_dis, ini_gen)) # exit() start = time.time() batch_d, batch_g, batch_t = -1, -1, -1 for epoch in range(flags.num_epoch): for dis_epoch in range(flags.num_dis_epoch): # print('epoch %03d dis_epoch %03d' % (epoch, dis_epoch)) # num_batch_d = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_d): # image_d, label_dat_d = dis_mnist.train.next_batch(flags.batch_size) for image_d, label_dat_d in dis_datagen.generate( batch_size=flags.batch_size): batch_d += 1 # feed_dict = {tn_gen.image_ph:image_d} # label_gen_d = sess.run(tn_gen.labels, feed_dict=feed_dict) # sample_gen_d, dis_label_gen = utils.gan_dis_sample(flags, label_dat_d, label_gen_d) # feed_dict = { # tn_dis.image_ph:image_d, # tn_dis.sample_ph:sample_gen_d, # tn_dis.dis_label_ph:dis_label_gen, # } # sess.run(tn_dis.gan_update, feed_dict=feed_dict) feed_dict = {tn_tch.image_ph: image_d} label_tch_d = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_tch_d, dis_label_tch = utils.gan_dis_sample( flags, label_dat_d, label_tch_d) feed_dict = { tn_dis.image_ph: image_d, tn_dis.sample_ph: sample_tch_d, tn_dis.dis_label_ph: dis_label_tch, } sess.run(tn_dis.gan_update, feed_dict=feed_dict) for tch_epoch in range(flags.num_tch_epoch): # num_batch_t = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_t): # image_t, label_dat_t = tch_mnist.train.next_batch(flags.batch_size) for image_t, label_dat_t in tch_datagen.generate( batch_size=flags.batch_size): batch_t += 1 feed_dict = {tn_tch.image_ph: image_t} label_tch_t = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_t = utils.generate_label(flags, label_dat_t, label_tch_t) feed_dict = { tn_dis.image_ph: image_t, tn_dis.sample_ph: sample_t, } reward_t = sess.run(tn_dis.rewards, feed_dict=feed_dict) feed_dict = { tn_tch.image_ph: image_t, tn_tch.sample_ph: sample_t, tn_tch.reward_ph: reward_t, } if flags.kdgan_model != config.kdgan_odgan_flag: feed_dict = {vd_gen.image_ph: image_t} soft_logit_t = sess.run(vd_gen.logits, feed_dict=feed_dict) feed_dict = { tn_tch.image_ph: image_t, tn_tch.sample_ph: sample_t, tn_tch.reward_ph: reward_t, tn_tch.hard_label_ph: label_dat_t, tn_tch.soft_logit_ph: soft_logit_t, } sess.run(tn_tch.kdgan_update, feed_dict=feed_dict) if (batch_t + 1) % eval_interval != 0: continue feed_dict = { vd_tch.image_ph: gen_mnist.test.images, vd_tch.hard_label_ph: gen_mnist.test.labels, } tch_acc = sess.run(vd_tch.accuracy, feed_dict=feed_dict) # bst_tch_acc = max(tch_acc, bst_tch_acc) # print('#%08d tchcur=%.4f tchbst=%.4f' % (batch_t, tch_acc, bst_tch_acc)) for gen_epoch in range(flags.num_gen_epoch): # print('epoch %03d gen_epoch %03d' % (epoch, gen_epoch)) # num_batch_g = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_g): # image_g, label_dat_g = gen_mnist.train.next_batch(flags.batch_size) for image_g, label_dat_g in gen_datagen.generate( batch_size=flags.batch_size): batch_g += 1 feed_dict = {tn_gen.image_ph: image_g} label_gen_g = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_g = utils.generate_label(flags, label_dat_g, label_gen_g) feed_dict = { tn_dis.image_ph: image_g, tn_dis.sample_ph: sample_g, } reward_g = sess.run(tn_dis.rewards, feed_dict=feed_dict) feed_dict = {vd_tch.image_ph: image_g} soft_logit_g = sess.run(vd_tch.logits, feed_dict=feed_dict) feed_dict = { tn_gen.image_ph: image_g, tn_gen.sample_ph: sample_g, tn_gen.reward_ph: reward_g, tn_gen.hard_label_ph: label_dat_g, tn_gen.soft_logit_ph: soft_logit_g, } sess.run(tn_gen.kdgan_update, feed_dict=feed_dict) if flags.collect_cr_data: feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) acc_list.append(acc) if (batch_g + 1) % eval_interval != 0: continue else: if (batch_g + 1) % eval_interval != 0: continue feed_dict = { vd_gen.image_ph: gen_mnist.test.images, vd_gen.hard_label_ph: gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) if acc > bst_gen_acc: bst_gen_acc = max(acc, bst_gen_acc) bst_eph = epoch tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) avg_time = (tot_time / global_step) * (tn_size / flags.batch_size) print( '#%08d gencur=%.4f genbst=%.4f tot=%.0fs avg=%.2fs/epoch' % (batch_g, acc, bst_gen_acc, tot_time, avg_time)) if acc <= bst_gen_acc: continue # save gen parameters if necessary tot_time = time.time() - start bst_gen_acc *= 100 bst_eph += 1 print('#mnist=%d kdgan_%s@%d=%.2f et=%.0fs' % (tn_size, flags.kdgan_model, bst_eph, bst_gen_acc, tot_time)) if flags.collect_cr_data: utils.create_pardir(flags.all_learning_curve_p) pickle.dump(acc_list, open(flags.all_learning_curve_p, 'wb'))
def main(_): bst_gen_acc, bst_tch_acc, bst_eph = 0.0, 0.0, 0 utils.create_if_nonexist(flags.gradient_dir) if flags.log_accuracy: acc_history = [] if flags.evaluate_tch: tch_history = [] with tf.train.MonitoredTrainingSession() as sess: sess.run(init_op) tn_dis.saver.restore(sess, flags.dis_model_ckpt) tn_gen.saver.restore(sess, flags.gen_model_ckpt) tn_tch.saver.restore(sess, flags.tch_model_ckpt) feed_dict = { vd_dis.image_ph:dis_mnist.test.images, vd_dis.hard_label_ph:dis_mnist.test.labels, } ini_dis = sess.run(vd_dis.accuracy, feed_dict=feed_dict) feed_dict = { vd_gen.image_ph:gen_mnist.test.images, vd_gen.hard_label_ph:gen_mnist.test.labels, } ini_gen = sess.run(vd_gen.accuracy, feed_dict=feed_dict) print('ini dis=%.4f ini gen=%.4f' % (ini_dis, ini_gen)) # exit() start = time.time() batch_d, batch_g, batch_t = -1, -1, -1 gumbel_times = (math.log(flags.gumbel_end_temperature / flags.gumbel_temperature) / math.log(flags.gumbel_temperature_decay_factor)) for epoch in range(flags.num_epoch): for dis_epoch in range(flags.num_dis_epoch): # print('epoch %03d dis_epoch %03d' % (epoch, dis_epoch)) # num_batch_d = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_d): # image_d, label_dat_d = dis_mnist.train.next_batch(flags.batch_size) for image_d, label_dat_d in dis_datagen.generate(batch_size=flags.batch_size): batch_d += 1 feed_dict = {tn_gen.image_ph:image_d} label_gen_d = sess.run(tn_gen.labels, feed_dict=feed_dict) sample_gen_d, gen_label_d = utils.gan_dis_sample(flags, label_dat_d, label_gen_d) feed_dict = {tn_tch.image_ph:image_d} label_tch_d = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_tch_d, tch_label_d = utils.gan_dis_sample(flags, label_dat_d, label_tch_d) feed_dict = { tn_dis.image_ph:image_d, tn_dis.gen_sample_ph:sample_gen_d, tn_dis.gen_label_ph:gen_label_d, tn_dis.tch_sample_ph:sample_tch_d, tn_dis.tch_label_ph:tch_label_d, } sess.run(tn_dis.gan_update, feed_dict=feed_dict) for tch_epoch in range(flags.num_tch_epoch): # num_batch_t = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_t): # image_t, label_dat_t = tch_mnist.train.next_batch(flags.batch_size) for image_t, label_dat_t in tch_datagen.generate(batch_size=flags.batch_size): batch_t += 1 feed_dict = {tn_tch.image_ph:image_t} label_tch_t = sess.run(tn_tch.labels, feed_dict=feed_dict) sample_t = utils.generate_label(flags, label_dat_t, label_tch_t) feed_dict = { tn_dis.image_ph:image_t, tn_dis.tch_sample_ph:sample_t, } reward_t = sess.run(tn_dis.tch_rewards, feed_dict=feed_dict) feed_dict = {vd_gen.image_ph:image_t} soft_logit_t = sess.run(vd_gen.logits, feed_dict=feed_dict) feed_dict = { tn_tch.image_ph:image_t, tn_tch.sample_ph:sample_t, tn_tch.reward_ph:reward_t, tn_tch.hard_label_ph:label_dat_t, tn_tch.soft_logit_ph:soft_logit_t, } sess.run(tn_tch.kdgan_update, feed_dict=feed_dict) if not flags.evaluate_tch: continue if (batch_t + 1) % eval_interval != 0: continue feed_dict = { vd_tch.image_ph:gen_mnist.test.images, vd_tch.hard_label_ph:gen_mnist.test.labels, } tch_acc = sess.run(vd_tch.accuracy, feed_dict=feed_dict) bst_tch_acc = max(tch_acc, bst_tch_acc) print('#%08d tchcur=%.4f tchbst=%.4f' % (batch_t, tch_acc, bst_tch_acc)) tch_history.append(tch_acc) #### gumbel softmax if flags.enable_gumbel: if (epoch + 1) % max(int(flags.num_epoch / gumbel_times), 1) == 0: sess.run(tn_gen.gt_update) for gen_epoch in range(flags.num_gen_epoch): batch = -1 # num_batch_g = math.ceil(tn_size / flags.batch_size) # for _ in range(num_batch_g): # image_g, label_dat_g = gen_mnist.train.next_batch(flags.batch_size) for image_g, label_dat_g in gen_datagen.generate(batch_size=flags.batch_size): batch_g += 1 batch += 1 epk_bat = '%d.%d' % (epoch*flags.num_gen_epoch+gen_epoch, batch) ggrads_file = path.join(flags.gradient_dir, 'kdgan_ggrads.%s.p' % epk_bat) kgrads_file = path.join(flags.gradient_dir, 'kdgan_kgrads.%s.p' % epk_bat) feed_dict = {tn_gen.image_ph:image_g} if not flags.enable_gumbel: label_gen_g = sess.run(tn_gen.labels, feed_dict=feed_dict) else: label_gen_g = sess.run(tn_gen.gumbel_labels, feed_dict=feed_dict) sample_g = utils.generate_label(flags, label_dat_g, label_gen_g) feed_dict = { tn_dis.image_ph:image_g, tn_dis.gen_sample_ph:sample_g, } reward_g = sess.run(tn_dis.gen_rewards, feed_dict=feed_dict) # reward_g[reward_g>0.5] = 0.7 # reward_g[reward_g<0.5] = 0.3 feed_dict = {vd_tch.image_ph:image_g} soft_logit_g = sess.run(vd_tch.logits, feed_dict=feed_dict) # print(sample_g.shape, reward_g.shape, image_g.shape, soft_logit_g.shape) # exit() feed_dict = { tn_gen.image_ph:image_g, tn_gen.sample_ph:sample_g, tn_gen.reward_ph:reward_g, tn_gen.hard_label_ph:label_dat_g, tn_gen.soft_logit_ph:soft_logit_g, } # sess.run(tn_gen.kdgan_update, feed_dict=feed_dict) if flags.log_gradient: fetches = [tn_gen.kdgan_ggrads, tn_gen.kdgan_kgrads, tn_gen.kdgan_update] kdgan_ggrads, kdgan_kgrads, _ = sess.run(fetches, feed_dict=feed_dict) pickle.dump(kdgan_ggrads, open(ggrads_file, 'wb')) pickle.dump(kdgan_kgrads, open(kgrads_file, 'wb')) else: sess.run(tn_gen.kdgan_update, feed_dict=feed_dict) if flags.log_accuracy: feed_dict = { vd_gen.image_ph:gen_mnist.test.images, vd_gen.hard_label_ph:gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) acc_history.append(acc) if (batch_g + 1) % eval_interval != 0: continue else: if (batch_g + 1) % eval_interval != 0: continue feed_dict = { vd_gen.image_ph:gen_mnist.test.images, vd_gen.hard_label_ph:gen_mnist.test.labels, } acc = sess.run(vd_gen.accuracy, feed_dict=feed_dict) if acc > bst_gen_acc: bst_gen_acc = max(acc, bst_gen_acc) bst_eph = epoch tot_time = time.time() - start global_step = sess.run(tn_gen.global_step) # avg_time = (tot_time / global_step) * (tn_size / flags.batch_size) if flags.evaluate_tch: gen_tch_pct =100 * bst_gen_acc / bst_tch_acc print('#%08d/%08d gencur=%.4f genbst=%.4f (%.2f) tot=%.0fs' % (batch_g, tot_batch, acc, bst_gen_acc, gen_tch_pct, tot_time)) else: print('#%08d/%08d gencur=%.4f genbst=%.4f tot=%.0fs' % (batch_g, tot_batch, acc, bst_gen_acc, tot_time)) stdout.flush() if acc <= bst_gen_acc: continue # save gen parameters if necessary gumbel_temperature = sess.run(tn_gen.gumbel_temperature) print('gumbel_temperature=%.4f' % gumbel_temperature) tot_time = time.time() - start bst_gen_acc *= 100 bst_eph += 1 print('#mnist=%d kdgan@%d=%.2f et=%.0fs' % (tn_size, bst_eph, bst_gen_acc, tot_time)) if flags.log_accuracy: utils.create_pardir(flags.acc_file) pickle.dump(acc_history, open(flags.acc_file, 'wb')) if flags.evaluate_tch: utils.create_pardir(flags.tch_file) pickle.dump(tch_history, open(flags.tch_file, 'wb'))