def main(_): # TODO: do not pass source label in target mode (it's not needed!) """Main function for Deep-Reconstruction Classification Network - DRCN""" tf.reset_default_graph() # Load source and target data set source_size = 32 target_size = 32 if FLAGS.source == 'mnist': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnist(FLAGS.channel_size, False) elif FLAGS.source == 'mnistm': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.source == 'svhn': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_svhn(FLAGS.channel_size, False) else: sys.exit('For the source set you have to choose one of [svhn, mnist, mnistm]!') if FLAGS.target == 'mnist': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnist(FLAGS.channel_size, False) elif FLAGS.target == 'mnistm': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.target == 'svhn': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_svhn(FLAGS.channel_size, False) else: sys.exit('For the target set you have to choose one of [svhn, mnist, mnistm]!') # Create data placeholders. placeholder_x_s = tf.placeholder(tf.float32, shape=[None, source_size, source_size, FLAGS.channel_size]) placeholder_y_s = tf.placeholder(tf.int32, shape=[None]) placeholder_x_t = tf.placeholder(tf.float32, shape=[None, target_size, target_size, FLAGS.channel_size]) placeholder_y_t = tf.placeholder(tf.int32, shape=[None]) placeholder_training = tf.placeholder_with_default(tf.constant(True), shape=[]) ds_source, ds_target = create_dataset(placeholder_x_s, placeholder_y_s, placeholder_x_t, placeholder_y_t) iterator = tf.data.Iterator.from_structure(ds_source.output_types, ds_source.output_shapes) x, y = iterator.get_next() # Init model drcn = Model(FLAGS.opt) drcn.train_source(x, y, placeholder_training) if FLAGS.source_only.lower() == 'false': drcn.train_target(x, y) source_iterator = iterator.make_initializer(ds_source) target_iterator = iterator.make_initializer(ds_target) # Configs saver = tf.train.Saver() config = tf.ConfigProto() config.gpu_options.allow_growth = True # Stats source_acc_train = [] source_acc_test = [] target_acc_train = [] target_acc_test = [] source_loss_train = [] target_loss_train = [] with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) if tf.train.latest_checkpoint(FLAGS.model_dir) is not None: saver.restore(sess, tf.train.latest_checkpoint(FLAGS.model_dir)) for epoch in range(FLAGS.total_epochs): print('Epoch: ', epoch) if FLAGS.source_only.lower() == 'false': sess.run(target_iterator, feed_dict={placeholder_x_t: x_train_t, placeholder_y_t: y_train_t}) i = 0 total_loss = 0 total_acc = 0 try: with tqdm(total=len(x_train_t)) as pbar: while True: _, out_loss, source_acc = sess.run([drcn.optimize_reconstruction, drcn.rec_loss, drcn.target_class_acc], feed_dict={placeholder_training: False}) i += 1 total_loss += out_loss total_acc += source_acc pbar.update(FLAGS.batch_size) # pbar.write(str(source_acc)) except tf.errors.OutOfRangeError: print('Done with train target epoch.') print(total_acc / i) print(total_loss / i) target_acc_train.append((epoch, total_acc/float(i))) target_loss_train.append((epoch, total_loss/float(i))) sess.run(target_iterator, feed_dict={placeholder_x_t: x_test_t, placeholder_y_t: y_test_t}) i = 0 total_loss = 0 total_acc = 0 try: with tqdm(total=len(x_test_t)) as pbar: while True: out_loss, source_acc = sess.run([drcn.source_class_loss, drcn.source_class_acc], feed_dict={placeholder_training: False}) i += 1 total_loss += out_loss total_acc += source_acc pbar.update(FLAGS.batch_size) except tf.errors.OutOfRangeError: print('Done with evaluation target epoch.') print(total_acc / i) print(total_loss / i) target_acc_test.append((epoch, total_acc / float(i))) sess.run(source_iterator, feed_dict={placeholder_x_s: x_train_s, placeholder_y_s: y_train_s}) i = 0 total_loss = 0 total_acc = 0 try: with tqdm(total=len(x_train_s)) as pbar: while True: _, out_loss, source_acc = sess.run([drcn.optimize_class, drcn.source_class_loss, drcn.source_class_acc]) i += 1 total_loss += out_loss total_acc += source_acc pbar.update(FLAGS.batch_size) except tf.errors.OutOfRangeError: print('Done with source train epoch.') print(total_acc/i) print(total_loss/i) source_acc_train.append((epoch, total_acc/float(i))) source_loss_train.append((epoch, total_loss/float(i))) sess.run(source_iterator, feed_dict={placeholder_x_s: x_test_s, placeholder_y_s: y_test_s}) i = 0 total_loss = 0 total_acc = 0 try: with tqdm(total=len(x_test_s)) as pbar: while True: out_loss, source_acc = sess.run([drcn.source_class_loss, drcn.source_class_acc], feed_dict={placeholder_training: False}) i += 1 total_loss += out_loss total_acc += source_acc pbar.update(FLAGS.batch_size) except tf.errors.OutOfRangeError: print('Done with evaluation source epoch.') print(total_acc / i) print(total_loss / i) source_acc_test.append((epoch, total_acc/float(i))) saver.save(sess, FLAGS.model_dir, global_step=epoch) # Save stats for visualization with open(os.path.join(FLAGS.model_dir, 'stats.pkl'), 'wb') as f: pickle.dump({'source_acc_train': source_acc_train, 'source_acc_test': source_acc_test, 'target_acc_train': target_acc_train, 'target_acc_test': target_acc_test, 'source_loss_train': source_loss_train, 'target_loss_train': target_loss_train}, f)
def main(_): # TODO: do not pass source label in target mode (it's not needed!) """Main function for Adversarial Discriminative Domain Adaptation - ADDA""" tf.reset_default_graph() if FLAGS.step == 'source': # Pretrain source classifier on SVHN dataset. (x_train, y_train), (x_test, y_test) = dp.load_mnist(channel_size=FLAGS.channel_size) # Configurations first iter_ratio = math.ceil((x_train.shape[0] / FLAGS.batch_size)) print(iter_ratio) # MNIST image shape is 28 x 28 feature_columns = [ tf.feature_column.numeric_column("source", shape=(28, 28, FLAGS.channel_size)) ] # Set up the session config session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True config = tf.estimator.RunConfig(save_checkpoints_steps=int(iter_ratio), log_step_count_steps=None, session_config=session_config) # Set up the estimator classifier = tf.estimator.Estimator( model_fn=estimator_model_fn, model_dir="./model_m2mm/source_model", params={ 'feature_columns': feature_columns, 'iter_ratio': iter_ratio, 'channel_size': FLAGS.channel_size }, config=config) # Define hooks logging_hook = tf.train.LoggingTensorHook(tensors={ "loss": "loss", "source_class_acc": "source_class_acc" }, every_n_iter=100) # Set up train and eval specs train_spec = tf.estimator.TrainSpec( input_fn=tf.estimator.inputs.numpy_input_fn( {'source': x_train}, {'labels': y_train}, shuffle=True, batch_size=128, num_epochs=FLAGS.total_epochs), hooks=[logging_hook]) eval_spec = tf.estimator.EvalSpec( input_fn=tf.estimator.inputs.numpy_input_fn({'source': x_test}, {'labels': y_test}, shuffle=True, batch_size=128, num_epochs=1), steps=None, throttle_secs=300) # Train and evaluate tf.estimator.train_and_evaluate(classifier, train_spec, eval_spec) if FLAGS.step == 'target': # Load MNIST dataset (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnist( channel_size=FLAGS.channel_size, truncate=True) # Load MNIST-M dataset (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnistm() # Configurations first iter_ratio = math.ceil((x_train_s.shape[0] / FLAGS.batch_size)) print(iter_ratio) # MNIST shape is 28 x 28 pixels (transformed to three channels) # MNIST-M shape is 32 x 32 pixels with 3 channels feature_columns = [ tf.feature_column.numeric_column("source", shape=(28, 28, FLAGS.channel_size)), tf.feature_column.numeric_column("target", shape=(32, 32, FLAGS.channel_size)) ] # Set up the session config session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True config = tf.estimator.RunConfig(save_checkpoints_steps=1000, log_step_count_steps=None, session_config=session_config) # Set up the estimator classifier = tf.estimator.Estimator( model_fn=estimator_model_fn, model_dir="./model_m2mm/adversarial_model", params={ 'feature_columns': feature_columns, 'iter_ratio': iter_ratio, 'channel_size': FLAGS.channel_size }, config=config) # Define hooks logging_hook = tf.train.LoggingTensorHook(tensors={ "loss_gen": "loss_gen", "loss_adv": "loss_adv", "target_class_acc": "target_class_acc", "source_class_acc": "source_class_acc", "target_class_acc_enc": "target_class_acc_enc" }, every_n_iter=100) # Set up train and eval specs train_spec = tf.estimator.TrainSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_train_s, 'target': x_train_t }, { 'label_s': y_train_s, 'label_t': y_train_t }, shuffle=True, batch_size=128, num_epochs=FLAGS.total_epochs), hooks=[logging_hook]) eval_spec = tf.estimator.EvalSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_test_s, 'target': x_test_t }, { 'label_s': y_test_s, 'label_t': y_test_t }, shuffle=True, batch_size=128, num_epochs=1), steps=None, throttle_secs=300) # Train and evaluate tf.estimator.train_and_evaluate(classifier, train_spec, eval_spec)
def main(_): """Main function for Domain Adaptation by Neural Networks - DANN""" tf.reset_default_graph() # Load source and target data set if FLAGS.source == 'mnist': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnist( FLAGS.channel_size, FLAGS.truncate_mnist.lower() == 'true') elif FLAGS.source == 'mnistm': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.source == 'svhn': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_svhn( FLAGS.channel_size, FLAGS.truncate_svhn.lower() == 'true') else: sys.exit( 'For the source set you have to choose one of [svhn, mnist, mnistm]!' ) if FLAGS.target == 'mnist': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnist( FLAGS.channel_size, FLAGS.truncate_mnist.lower() == 'true') elif FLAGS.target == 'mnistm': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.target == 'svhn': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_svhn( FLAGS.channel_size, FLAGS.truncate_svhn.lower() == 'true') else: sys.exit( 'For the target set you have to choose one of [svhn, mnist, mnistm]!' ) # Configurations first iter_ratio = math.ceil((x_train_s.shape[0] / FLAGS.batch_size)) print(iter_ratio) # We are working with transformed MNIST dataset => image shape is 28x28x3 feature_columns = [ tf.feature_column.numeric_column("x_s", shape=(32, 32, FLAGS.channel_size)), tf.feature_column.numeric_column("x_t", shape=(32, 32, FLAGS.channel_size)) ] # Set up the session config session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True config = tf.estimator.RunConfig(save_checkpoints_steps=int(iter_ratio), log_step_count_steps=100, session_config=session_config) # Set up the estimator classifier = tf.estimator.Estimator(model_fn=estimator_model_fn, model_dir=FLAGS.model_dir, params={ 'feature_columns': feature_columns, 'iter_ratio': iter_ratio, 'source_size': 32, 'target_size': 32 }, config=config) if FLAGS.mode == 'train': # Set up logging in training mode "test_source_acc": "test_source_acc", # "test_target_acc": "test_target_acc" train_hook = tf.train.LoggingTensorHook(tensors={ "lr": "learning_rate", "loss": "loss", "source_class_acc": "source_class_acc" }, every_n_iter=100) # Train and evaluate DANN train_spec = tf.estimator.TrainSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'x_s': x_train_s, 'x_t': x_train_t }, { 'y_s': y_train_s, 'y_t': y_train_t }, shuffle=True, batch_size=128, num_epochs=FLAGS.total_epochs), max_steps=int(iter_ratio * FLAGS.total_epochs), hooks=[train_hook]) eval_spec = tf.estimator.EvalSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'x_s': x_test_s, 'x_t': x_test_t }, { 'y_s': y_test_s, 'y_t': y_test_t }, shuffle=True, batch_size=128, num_epochs=1, ), steps=None, throttle_secs=1) tf.estimator.train_and_evaluate(classifier, train_spec, eval_spec) elif FLAGS.mode == 'eval': classifier.evaluate(input_fn=tf.estimator.inputs.numpy_input_fn( { 'x_s': x_test_s, 'x_t': x_test_t }, { 'y_s': y_test_s, 'y_t': y_test_t }, shuffle=True, batch_size=128, num_epochs=1, )) else: assert FLAGS.mode == 'predict', '-mode flag has to be one of "train", "predict".'
def main(_): # TODO: do not pass source label in target mode (it's not needed!) """Main function for Adversarial Discriminative Domain Adaptation - ADDA""" tf.reset_default_graph() # Load source and target data set source_size = 32 target_size = 32 if FLAGS.source == 'mnist': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnist( FLAGS.channel_size, FLAGS.truncate_mnist.lower() == 'true') elif FLAGS.source == 'mnistm': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.source == 'svhn': (x_train_s, y_train_s), (x_test_s, y_test_s) = dp.load_svhn( FLAGS.channel_size, FLAGS.truncate_svhn.lower() == 'true') else: sys.exit( 'For the source set you have to choose one of [svhn, mnist, mnistm]!' ) if FLAGS.target == 'mnist': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnist( FLAGS.channel_size, FLAGS.truncate_mnist.lower() == 'true') elif FLAGS.target == 'mnistm': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_mnistm(FLAGS.channel_size) elif FLAGS.target == 'svhn': (x_train_t, y_train_t), (x_test_t, y_test_t) = dp.load_svhn( FLAGS.channel_size, FLAGS.truncate_svhn.lower() == 'true') else: sys.exit( 'For the target set you have to choose one of [svhn, mnist, mnistm]!' ) # Configurations first iter_ratio = math.ceil((x_train_s.shape[0] / FLAGS.batch_size)) # Start training from here if FLAGS.step == 'source': feature_columns = [ tf.feature_column.numeric_column("source", shape=(source_size, source_size, FLAGS.channel_size)), tf.feature_column.numeric_column("target", shape=(target_size, target_size, FLAGS.channel_size)) ] # Set up the session config session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True config = tf.estimator.RunConfig(save_checkpoints_steps=int(iter_ratio), log_step_count_steps=iter_ratio, session_config=session_config) # Set up the estimator classifier = tf.estimator.Estimator(model_fn=estimator_model_fn, model_dir=FLAGS.source_model, params={ 'feature_columns': feature_columns, 'iter_ratio': iter_ratio, 'channel_size': FLAGS.channel_size, 'source_size': source_size, 'target_size': target_size }, config=config) # Define hooks logging_hook = tf.train.LoggingTensorHook(tensors={ "loss": "loss", "source_class_acc": "source_class_acc" }, every_n_iter=iter_ratio) # Set up train and eval specs train_spec = tf.estimator.TrainSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_train_s, 'target': x_train_t }, { 'label_s': y_train_s, 'label_t': y_train_t }, shuffle=True, batch_size=FLAGS.batch_size, num_epochs=FLAGS.total_epochs), max_steps=int(iter_ratio * FLAGS.total_epochs), hooks=[logging_hook]) eval_spec = tf.estimator.EvalSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_test_s, 'target': x_test_t }, { 'label_s': y_test_s, 'label_t': y_test_t }, shuffle=True, batch_size=FLAGS.batch_size, num_epochs=1), steps=None, throttle_secs=1) # Train and evaluate tf.estimator.train_and_evaluate(classifier, train_spec, eval_spec) if FLAGS.step == 'target': feature_columns = [ tf.feature_column.numeric_column("source", shape=(source_size, source_size, FLAGS.channel_size)), tf.feature_column.numeric_column("target", shape=(target_size, target_size, FLAGS.channel_size)) ] # Set up the session config session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True config = tf.estimator.RunConfig(save_checkpoints_steps=iter_ratio, log_step_count_steps=iter_ratio, session_config=session_config) # Set up the estimator classifier = tf.estimator.Estimator(model_fn=estimator_model_fn, model_dir=FLAGS.target_model, params={ 'feature_columns': feature_columns, 'iter_ratio': iter_ratio, 'channel_size': FLAGS.channel_size, 'source_size': source_size, 'target_size': target_size }, config=config) # Define hooks logging_hook = tf.train.LoggingTensorHook(tensors={ "learning_rate": "learning_rate", "loss_gen": "loss_gen", "loss_adv": "loss_adv", "target_class_acc": "target_class_acc", "source_class_acc": "source_class_acc" }, every_n_iter=iter_ratio - 1) # Set up train and eval specs train_spec = tf.estimator.TrainSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_train_s, 'target': x_train_t }, { 'label_s': y_train_s, 'label_t': y_train_t }, shuffle=True, batch_size=FLAGS.batch_size, num_epochs=FLAGS.total_epochs), max_steps=int(iter_ratio * FLAGS.total_epochs), hooks=[logging_hook]) eval_spec = tf.estimator.EvalSpec( input_fn=tf.estimator.inputs.numpy_input_fn( { 'source': x_test_s, 'target': x_test_t }, { 'label_s': y_test_s, 'label_t': y_test_t }, shuffle=True, batch_size=FLAGS.batch_size, num_epochs=1), steps=None, throttle_secs=1) # Train and evaluate tf.estimator.train_and_evaluate(classifier, train_spec, eval_spec)