def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) ######################### # Preprocess the inputs # ######################### source_dataset = dataset_factory.get_dataset(FLAGS.source_dataset, split_name='train', dataset_dir=FLAGS.dataset_dir) num_source_classes = source_dataset.num_classes source_images, source_labels = dataset_factory.provide_batch( FLAGS.source_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 32, FLAGS.num_preprocessing_threads) source_label = tf.argmax(source_labels['classes'], 1) del source_labels['classes'] target_dataset = dataset_factory.get_dataset(FLAGS.target_dataset, split_name='test', dataset_dir=FLAGS.dataset_dir) target_images, target_labels = dataset_factory.provide_batch( FLAGS.target_dataset, 'test', FLAGS.dataset_dir, FLAGS.num_readers, 1, FLAGS.num_preprocessing_threads) target_label = tf.argmax(target_labels['classes'], -1) del target_labels['classes'] num_target_classes = target_dataset.num_classes #################### # Define the model # #################### gen, dis, cls = pixelda_model.create_model(target_images, source_images, num_target_classes) cls['target_task_logits'] = tf.argmax(cls['target_task_logits'], -1) net, layers = classifier.LeNet(target_images, False, num_target_classes, reuse_private=False, private_scope='target', reuse_shared=False, shared_scope='target') net = tf.argmax(net, -1) with slim.queues.QueueRunners(sess): #######################################pixelda transfer#################################### cls_var = util.collect_vars('classifier') util.evalutation(sess, cls['target_task_logits'], target_label, num_target_classes, '../PixelDA/snapshot', 'pixelda', target_dataset.num_samples, cls_var, target_images) #######################################evaluate adda############################################ target_vars = util.collect_vars('target') target_vars = util.copyKeySet(cls_var, target_vars) util.evalutation(sess, net, target_label, num_target_classes, 'snapshot', 'adda_pixelda', target_dataset.num_samples, target_vars, target_images)
def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) target_dataset = dataset_factory.get_dataset(FLAGS.target_dataset, split_name='test', dataset_dir=FLAGS.dataset_dir) target_images, target_labels = dataset_factory.provide_batch( FLAGS.target_dataset, 'test', FLAGS.dataset_dir, FLAGS.num_readers, 1, FLAGS.num_preprocessing_threads) target_label = tf.argmax(target_labels['classes'], -1) del target_labels['classes'] num_target_classes = target_dataset.num_classes #################### # Define the model # #################### net, layers = classifier.LeNet(target_images, False, num_target_classes, reuse_private=False, private_scope='source_only', reuse_shared=False, shared_scope='source_only') net = tf.argmax(net, -1) sess.run(tf.global_variables_initializer()) with slim.queues.QueueRunners(sess): #######################################evaluate source only#################################### util.evalutation(sess, net, target_label, num_target_classes, 'ADDA/snapshot', 'LeNet_mnist', target_dataset.num_samples, target_images) #######################################evaluate adda############################################ util.evalutation(sess, net, target_label, num_target_classes, 'ADDA/snapshot', 'adda_lenet_mnist_minstm', target_dataset.num_samples, target_images)
def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) seed = random.randrange(2**32 - 2) logging.info('Using random seed {}'.format(seed)) random.seed(seed) np.random.seed(seed + 1) tf.set_random_seed(seed + 2) ######################### # Preprocess the inputs # ######################### source_dataset = dataset_factory.get_dataset(FLAGS.source_dataset, split_name='train', dataset_dir=FLAGS.dataset_dir) num_source_classes = source_dataset.num_classes source_images, _ = dataset_factory.provide_batch( FLAGS.source_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 128, FLAGS.num_preprocessing_threads) target_dataset = dataset_factory.get_dataset(FLAGS.target_dataset, split_name='train', dataset_dir=FLAGS.dataset_dir) num_target_classes = target_dataset.num_classes target_images, _ = dataset_factory.provide_batch( FLAGS.target_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 128, FLAGS.num_preprocessing_threads) if num_source_classes != num_target_classes: raise ValueError( 'Source and Target datasets must have same number of classes. ' 'Are %d and %d' % (num_source_classes, num_target_classes)) gen, dis, cls, transLayer = pixelda_model.create_model( target_images, source_images, num_source_classes) target_net, target_layers = classifier.LeNet(target_images, False, num_target_classes, reuse_private=False, private_scope='target', reuse_shared=False, shared_scope='target') source_net = cls['transferred_task_logits'] # 어떤 레이어를 비슷하게 쫒아갈 것인지 여기서 결정 source_net = transLayer['fc3'] target_net = target_layers['fc3'] # adversarial network - 다차원일 때 1차원으로 펴주기 위한 것이기는하나.. 이미 벡터라서 예제에는 의미가 없다. source_net = tf.reshape(source_net, [-1, int(source_net.get_shape()[-1])]) target_net = tf.reshape(target_net, [-1, int(target_net.get_shape()[-1])]) # 각 net에서 올라온것을 Batch처럼 보고 사용함 adversary_net = tf.concat([source_net, target_net], 0) source_adversary_label = tf.zeros([tf.shape(source_net)[0]], tf.int32) # source가 들어오면 0으로 맞추게 target_adversary_label = tf.ones([tf.shape(target_net)[0]], tf.int32) # target이 들어오면 1로 맞추게 adversary_label = tf.concat( [source_adversary_label, target_adversary_label], 0) adversary_logits = adversary.adversarial_discriminator( adversary_net, [500, 500]) #################Loss Define########################################## mapping_loss = tf.losses.sparse_softmax_cross_entropy( 1 - adversary_label, adversary_logits) # Mapping Loss는 네트워크가 못 맞출 수록 낮음 adversary_loss = tf.losses.sparse_softmax_cross_entropy( adversary_label, adversary_logits) # Adv loss는 잘 맞출 수록 낮음 gan_var = util.collect_vars('generator') cls_var = util.collect_vars('classifier') target_vars = util.collect_vars('target') adversary_vars = util.collect_vars('adversary') target_vars = util.copyKeySet(cls_var, target_vars) lr_var = tf.Variable(FLAGS.lr, name='learning_rate', trainable=False) optimizer = tf.train.AdamOptimizer(lr_var, 0.5) mapping_step = optimizer.minimize( mapping_loss, var_list=list( target_vars.values())) # adversary_ft가 잘 못맞추게 target var를 학습한다 adversary_step = optimizer.minimize( adversary_loss, var_list=list( adversary_vars.values())) # adversary_ft가 잘 맞출수 있게 학습한다. 구분되게 # restore weights => 이 부분 수정해야함. gan, cls 로드할 수 있게 sess.run(tf.global_variables_initializer()) output_dir = os.path.join('../PixelDA/snapshot', 'pixelda') if os.path.isdir(output_dir): weights = tf.train.latest_checkpoint(output_dir) logging.info('Restoring weights from {}:'.format(weights)) logging.info(' Restoring generator model:') for src, tgt in gan_var.items(): logging.info(' {:30} -> {:30}'.format(src, tgt.name)) gen_restorer = tf.train.Saver(var_list=gan_var) gen_restorer.restore(sess, weights) logging.info('Restoring weights from {}:'.format(weights)) logging.info(' Restoring classifier model:') for src, tgt in cls_var.items(): logging.info(' {:30} -> {:30}'.format(src, tgt.name)) cls_restorer = tf.train.Saver(var_list=cls_var) cls_restorer.restore(sess, weights) logging.info(' Restoring target model:') for src, tgt in target_vars.items(): logging.info(' {:30} -> {:30}'.format(src, tgt.name)) target_restorer = tf.train.Saver(var_list=target_vars) target_restorer.restore(sess, weights) else: return output_dir = os.path.join('snapshot', 'adda_pixelda') if not os.path.exists(output_dir): os.mkdir(output_dir) mapping_losses = deque(maxlen=10) adversary_losses = deque(maxlen=10) bar = tqdm(range(FLAGS.iteration)) bar.set_description('{} (lr: {:.0e})'.format('adda_pixelda', FLAGS.lr)) bar.refresh() #tensorboard writer = tf.summary.FileWriter(output_dir, sess.graph) display = 10 stepsize = None with slim.queues.QueueRunners(sess): for i in bar: #g-step mapping_loss_val, _ = sess.run([mapping_loss, mapping_step]) mapping_losses.append(mapping_loss_val) #d-step adversary_loss_val, _ = sess.run([adversary_loss, adversary_step]) adversary_losses.append(adversary_loss_val) if i % display == 0: logging.info( '{:20} Mapping: {:10.4f} (avg: {:10.4f})' ' Adversary: {:10.4f} (avg: {:10.4f})'.format( 'Iteration {}:'.format(i), mapping_loss_val, np.mean(mapping_losses), adversary_loss_val, np.mean(adversary_losses))) if stepsize is not None and (i + 1) % stepsize == 0: lr = sess.run(lr_var.assign(FLAGS.lr * 0.1)) logging.info('Changed learning rate to {:.0e}'.format(lr)) bar.set_description('{} (lr: {:.0e})'.format( 'adda_lenet_svhn_mnist', lr)) if (i + 1) % FLAGS.snapshot == 0: snapshot_path = target_restorer.save( sess, os.path.join(output_dir, 'adda_lenet_svhn_mnist'), global_step=i + 1) logging.info('Saved snapshot to {}'.format(snapshot_path))
def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) ######################### # Preprocess the inputs # ######################### source_dataset = dataset_factory.get_dataset(FLAGS.source_dataset, split_name='test', dataset_dir=FLAGS.dataset_dir) num_source_classes = source_dataset.num_classes source_images, source_labels = dataset_factory.provide_batch( FLAGS.source_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 1, FLAGS.num_preprocessing_threads) source_label = tf.argmax(source_labels['classes'], 1) del source_labels['classes'] target_dataset = dataset_factory.get_dataset(FLAGS.target_dataset, split_name='test', dataset_dir=FLAGS.dataset_dir) target_images, target_labels = dataset_factory.provide_batch( FLAGS.target_dataset, 'test', FLAGS.dataset_dir, FLAGS.num_readers, 1, FLAGS.num_preprocessing_threads) target_label = tf.argmax(target_labels['classes'], -1) del target_labels['classes'] num_target_classes = target_dataset.num_classes if num_source_classes != num_target_classes: raise ValueError( 'Source and Target datasets must have same number of classes. ' 'Are %d and %d' % (num_source_classes, num_target_classes)) gen, dis, cls = pixelda_model.create_model(target_images, source_images, num_source_classes) cls['target_task_logits'] = tf.argmax(cls['target_task_logits'], -1) cls['transferred_task_logits'] = tf.argmax(cls['transferred_task_logits'], -1) cls['source_task_logits'] = tf.argmax(cls['source_task_logits'], -1) # Use the entire split by default num_examples = target_dataset.num_samples # cls_var_dict = util.collect_vars('classifier') # cls_restorer = tf.train.Saver(var_list=cls_var_dict) # gen_var_dict = util.collect_vars('generator') # gen_restorer = tf.train.Saver(var_list=gen_var_dict) restorer = tf.train.Saver() sess.run(tf.global_variables_initializer()) output_dir = os.path.join('PixelDA/snapshot', 'pixelda') if os.path.isdir(output_dir): weights = tf.train.latest_checkpoint(output_dir) logging.info('Evaluating {}'.format(weights)) # print all tensors in checkpoint file # chkp.print_tensors_in_checkpoint_file(weights, tensor_name='', all_tensors=True) # cls_restorer.restore(sess, weights) # gen_restorer.restore(sess, weights) restorer.restore(sess, weights) else: logging.info('Not Found'.format(output_dir)) return False class_correct = np.zeros(num_source_classes, dtype=np.int32) class_counts = np.zeros(num_source_classes, dtype=np.int32) # classification loss with slim.queues.QueueRunners(sess): plt.figure() for i in range(16): np_image, np_gen = sess.run([source_images, gen]) _, height, width, _ = np_image.shape plt.subplot(4, 8, 2 * i + 1) plt.imshow(np_image[0]) plt.title('%d x %d' % (height, width)) plt.subplot(4, 8, 2 * i + 2) np_gen[0] /= 2 np_gen[0] += 0.5 plt.imshow(np_gen[0]) plt.title('%d x %d' % (height, width)) plt.axis('off') plt.show() for i in tqdm(range(num_examples)): predictions, gt = sess.run( [cls['target_task_logits'], target_label]) class_counts[gt[0]] += 1 if predictions[0] == gt[0]: class_correct[gt[0]] += 1 logging.info('Class accuracies:') logging.info(' ' + util.format_array(class_correct / class_counts)) logging.info('Overall accuracy:') logging.info(' ' + str(np.sum(class_correct) / np.sum(class_counts))) return True
def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) seed = random.randrange(2**32 - 2) logging.info('Using random seed {}'.format(seed)) random.seed(seed) np.random.seed(seed + 1) tf.set_random_seed(seed + 2) ######################### # Preprocess the inputs # ######################### source_dataset = dataset_factory.get_dataset(FLAGS.source_dataset, split_name='train', dataset_dir=FLAGS.dataset_dir) num_source_classes = source_dataset.num_classes source_images, source_labels = dataset_factory.provide_batch( FLAGS.source_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 32, FLAGS.num_preprocessing_threads) source_label = tf.argmax(source_labels['classes'], 1) del source_labels['classes'] target_dataset = dataset_factory.get_dataset(FLAGS.target_dataset, split_name='test', dataset_dir=FLAGS.dataset_dir) target_images, _ = dataset_factory.provide_batch( FLAGS.target_dataset, 'test', FLAGS.dataset_dir, FLAGS.num_readers, 32, FLAGS.num_preprocessing_threads) num_target_classes = target_dataset.num_classes if num_source_classes != num_target_classes: raise ValueError( 'Source and Target datasets must have same number of classes. ' 'Are %d and %d' % (num_source_classes, num_target_classes)) gen, dis, cls = pixelda_model.create_model(target_images, source_images, num_source_classes, True) generator_vars = util.collect_vars('generator') discriminator_vars = util.collect_vars('discriminator') classfier_vars = util.collect_vars('classifier') gen_op = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'generator') dis_op = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'discriminator') cls_op = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'classifier') up_op_total = gen_op + dis_op + cls_op + tf.trainable_variables() gen_loss = pixelda_losses.g_step_loss(source_images, source_label, dis, cls, num_source_classes) d_loss = pixelda_losses.d_step_loss(dis, cls, source_label, num_source_classes) # dis_loss = pixelda_losses.discriminator_loss(dis) # cls_loss = pixelda_losses.classification_loss(cls, source_label, num_source_classes) learning_rate = tf.train.exponential_decay( FLAGS.lr, tf.train.get_or_create_global_step(), decay_steps=20000, decay_rate=0.95, staircase=True) optimizer = tf.train.AdamOptimizer(learning_rate, beta1=0.5) dstep_po = dis_op + cls_op with tf.control_dependencies(dstep_po): dis_step = optimizer.minimize( d_loss, var_list=list(discriminator_vars.values()) + list(classfier_vars.values())) with tf.control_dependencies(gen_op): gen_step = optimizer.minimize(gen_loss, var_list=list(generator_vars.values())) # with tf.control_dependencies(dis_op): # dis_step = optimizer.minimize(dis_loss, var_list=list(discriminator_vars.values())) # with tf.control_dependencies(gen_op): # gen_step = optimizer.minimize(gen_loss, var_list=list(generator_vars.values())) # with tf.control_dependencies(cls_op): # cls_step = optimizer.minimize(cls_loss, var_list=list(classfier_vars.values())) # dis_var_list = dis_op + list(discriminator_vars.values()) # gen_vars_list = gen_op + list(generator_vars.values()) # cls_vars_list = cls_op + list(classfier_vars.values()) # dis_step = optimizer.minimize(dis_loss, var_list=dis_var_list) # gen_step = optimizer.minimize(gen_loss, var_list=gen_vars_list) # cls_step = optimizer.minimize(cls_loss, var_list=cls_vars_list) sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() output_dir = os.path.join('PixelDA/snapshot', 'pixelda') if not os.path.exists(output_dir): os.mkdir(output_dir) dis_losses = deque(maxlen=10) gen_losses = deque(maxlen=10) cls_losses = deque(maxlen=10) bar = tqdm(range(FLAGS.iteration)) bar.set_description('{} (lr: {:.0e})'.format('pixelda', FLAGS.lr)) bar.refresh() #tensorboard writer = tf.summary.FileWriter(output_dir, sess.graph) display = 10 stepsize = None with slim.queues.QueueRunners(sess): for i in bar: # d-step # dis_loss_val, _ = sess.run([dis_loss, dis_step]) # dis_losses.append(dis_loss_val) # cls_loss_val, _ = sess.run([cls_loss, cls_step]) # cls_losses.append(cls_loss_val) dstep_loss_val, _ = sess.run([d_loss, dis_step]) dis_losses.append(dstep_loss_val) # g-step gen_loss_val, _ = sess.run([gen_loss, gen_step]) gen_losses.append(gen_loss_val) if i % display == 0: cur_lr = sess.run(learning_rate) logging.info('learning rate : {:10.4f}'.format(cur_lr)) logging.info( '{:20} dstep loss: {:10.4f} (avg: {:10.4f})' ' gen loss: {:10.4f} (avg: {:10.4f})'.format( 'Iteration {}:'.format(i), dstep_loss_val, np.mean(dis_losses), gen_loss_val, np.mean(gen_losses))) if (i + 1) % FLAGS.snapshot == 0: snapshot_path = saver.save(sess, os.path.join(output_dir, 'pixelda'), global_step=i + 1) logging.info('Saved snapshot to {}'.format(snapshot_path))
def main(_): util.config_logging() config = tf.ConfigProto(device_count=dict(GPU=1)) config.gpu_options.allow_growth = True sess = tf.Session(config=config) seed = random.randrange(2**32 - 2) logging.info('Using random seed {}'.format(seed)) random.seed(seed) np.random.seed(seed + 1) tf.set_random_seed(seed + 2) ######################### # Preprocess the inputs # ######################### source_dataset = dataset_factory.get_dataset(FLAGS.source_dataset, split_name='train', dataset_dir=FLAGS.dataset_dir) num_source_classes = source_dataset.num_classes source_images, source_labels = dataset_factory.provide_batch( FLAGS.source_dataset, 'train', FLAGS.dataset_dir, FLAGS.num_readers, 32, FLAGS.num_preprocessing_threads) source_labels['class'] = tf.argmax(source_labels['classes'], 1) del source_labels['classes'] #################### # Define the model # #################### net, layers = classifier.LeNet(source_images, False, num_source_classes, reuse_private=False, private_scope='source', reuse_shared=False, shared_scope='source') class_loss = tf.losses.sparse_softmax_cross_entropy( source_labels['class'], net) loss = tf.losses.get_total_loss() lr = FLAGS.lr lr_var = tf.Variable(lr, name='learning_rate', trainable=False) optimizer = tf.train.MomentumOptimizer(lr_var, 0.99) step = optimizer.minimize(loss) sess.run(tf.global_variables_initializer()) model_vars = util.collect_vars('source') saver = tf.train.Saver(var_list=model_vars) output_dir = os.path.join('ADDA/snapshot', 'LeNet_mnist') if not os.path.exists(output_dir): os.mkdir(output_dir) losses = deque(maxlen=10) bar = tqdm(range(FLAGS.iteration)) bar.set_description('{} (lr: {:.0e})'.format('LeNet_mnist', lr)) bar.refresh() display = 10 stepsize = None with slim.queues.QueueRunners(sess): for i in bar: loss_val, _ = sess.run([loss, step]) losses.append(loss_val) if i % display == 0: logging.info('{:20} {:10.4f} (avg: {:10.4f})'.format( 'Iteration {}:'.format(i), loss_val, np.mean(losses))) if stepsize is not None and (i + 1) % stepsize == 0: lr = sess.run(lr_var.assign(lr * 0.1)) logging.info('Changed learning rate to {:.0e}'.format(lr)) bar.set_description('{} (lr: {:.0e})'.format( 'LeNet_mnist', lr)) if (i + 1) % FLAGS.snapshot == 0: snapshot_path = saver.save(sess, os.path.join( output_dir, 'LeNet_mnist'), global_step=i + 1) logging.info('Saved snapshot to {}'.format(snapshot_path)) sess.close() return