def train_warmup(): """ if there are few samples, warmup at first""" sup_images_iterator, sup_labels_iterator, input_sess, input_threads, input_coord = init_iterators( ) model.reset_optimizer(sess) for step in range(FLAGS.max_steps): unsup_images, _ = sess.run(unsup_images_iterator) si, sl = input_sess.run([sup_images_iterator, sup_labels_iterator]) _, summaries, train_loss = sess.run( [train_op, summary_op, model.train_loss], { t_unsup_images: unsup_images, walker_weight: FLAGS.walker_weight, proximity_weight: 0, visit_weight: 0.1 + apply_envelope("lin", step, 0.4, FLAGS.warmup_steps, 0), t_logit_weight: 0.5, # FLAGS.logit_weight, t_l1_weight: FLAGS.l1_weight, t_sup_images: si, t_sup_labels: sl, t_learning_rate: 5e-5 + apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) }) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print('Train loss: %.2f ' % train_loss) print() test_summary = tf.Summary(value=[ tf.Summary.Value(tag='Test Err', simple_value=test_err) ]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) input_coord.request_stop() input_coord.join(input_threads) input_sess.close()
def train_finetune(lr=0.001, steps=FLAGS.max_steps): sup_images_iterator, sup_labels_iterator, input_sess, input_threads, input_coord = init_iterators( ) model.reset_optimizer(sess) for step in range(int(steps)): unsup_images, _ = sess.run(unsup_images_iterator) si, sl = input_sess.run([sup_images_iterator, sup_labels_iterator]) _, summaries, train_loss = sess.run( [train_op, summary_op, model.train_loss], { t_unsup_images: unsup_images, walker_weight: 1, proximity_weight: 0, visit_weight: 1, t_l1_weight: 0, t_logit_weight: 1, t_learning_rate: lr, t_sup_images: si, t_sup_labels: sl }) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print('Train loss: %.2f ' % train_loss) print() test_summary = tf.Summary(value=[ tf.Summary.Value(tag='Test Err', simple_value=test_err) ]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) input_coord.request_stop() input_coord.join(input_threads) input_sess.close()
def main(_): train_images, train_labels = mnist_tools.get_data('train') test_images, test_labels = mnist_tools.get_data('test') # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else None sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) graph = tf.Graph() with graph.as_default(): model = semisup.SemisupModel(semisup.architectures.mnist_model, NUM_LABELS, IMAGE_SHAPE) # Set up inputs. t_unsup_images, _ = semisup.create_input(train_images, train_labels, FLAGS.unsup_batch_size) t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_unsup_emb = model.image_to_embedding(t_unsup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. model.add_semisup_loss(t_sup_emb, t_unsup_emb, t_sup_labels, visit_weight=FLAGS.visit_weight) model.add_logit_loss(t_sup_logit, t_sup_labels) t_learning_rate = tf.train.exponential_decay(FLAGS.learning_rate, model.step, FLAGS.decay_steps, FLAGS.decay_factor, staircase=True) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in xrange(FLAGS.max_steps): _, summaries = sess.run([train_op, summary_op]) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print() test_summary = tf.Summary(value=[ tf.Summary.Value(tag='Test Err', simple_value=test_err) ]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) saver.save(sess, FLAGS.logdir, model.step) coord.request_stop() coord.join(threads)
def main(_): train_images, train_labels = mnist_tools.get_data('train') test_images, test_labels = mnist_tools.get_data('test') # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else np.random.randint( 0, 1000) print('Seed:', seed) sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) # add twos, fours, and sixes if FLAGS.testadd: num_to_add = 10 for i in range(10): items = np.where(train_labels == i)[0] inds = np.random.choice(len(items), num_to_add, replace=False) sup_by_label[i] = np.vstack( [sup_by_label[i], train_images[items[inds]]]) add_random_samples = 0 if add_random_samples > 0: rng = np.random.RandomState() indices = rng.choice(len(train_images), add_random_samples, False) for i in indices: l = train_labels[i] sup_by_label[l] = np.vstack([sup_by_label[l], [train_images[i]]]) print(l) graph = tf.Graph() with graph.as_default(): model = semisup.SemisupModel(semisup.architectures.mnist_model, NUM_LABELS, IMAGE_SHAPE, dropout_keep_prob=0.8) # Set up inputs. if FLAGS.random_batches: sup_lbls = np.asarray( np.hstack([ np.ones(len(i)) * ind for ind, i in enumerate(sup_by_label) ]), np.int) sup_images = np.vstack(sup_by_label) t_sup_images, t_sup_labels = semisup.create_input( sup_images, sup_lbls, FLAGS.sup_per_batch * NUM_LABELS) else: t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. if FLAGS.semisup: if FLAGS.equal_cls_unsup: allimgs_bylabel = semisup.sample_by_label( train_images, train_labels, 5000, NUM_LABELS, seed) t_unsup_images, _ = semisup.create_per_class_inputs( allimgs_bylabel, FLAGS.sup_per_batch) else: t_unsup_images, _ = semisup.create_input( train_images, train_labels, FLAGS.unsup_batch_size) t_unsup_emb = model.image_to_embedding(t_unsup_images) model.add_semisup_loss(t_sup_emb, t_unsup_emb, t_sup_labels, walker_weight=FLAGS.walker_weight, visit_weight=FLAGS.visit_weight, proximity_weight=FLAGS.proximity_weight) model.add_logit_loss(t_sup_logit, t_sup_labels) t_learning_rate = tf.train.exponential_decay(FLAGS.learning_rate, model.step, FLAGS.decay_steps, FLAGS.decay_factor, staircase=True) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in range(FLAGS.max_steps): _, summaries = sess.run([train_op, summary_op]) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print() test_summary = tf.Summary(value=[ tf.Summary.Value(tag='Test Err', simple_value=test_err) ]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) saver.save(sess, FLAGS.logdir, model.step) coord.request_stop() coord.join(threads)
def main(_): FLAGS.emb_size = 128 optimizer = 'adam' train_images, train_labels = mnist_tools.get_data('train') test_images, test_labels = mnist_tools.get_data('test') # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else np.random.randint(0, 1000) print('Seed:', seed) sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) graph = tf.Graph() with graph.as_default(): model_func = semisup.architectures.mnist_model if FLAGS.dropout_keep_prob < 1: model_func = semisup.architectures.mnist_model_dropout model = semisup.SemisupModel(model_func, NUM_LABELS, IMAGE_SHAPE, optimizer=optimizer, emb_size=FLAGS.emb_size, dropout_keep_prob=FLAGS.dropout_keep_prob) # Set up inputs. t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) t_unsup_images = tf.placeholder("float", shape=[None] + IMAGE_SHAPE) proximity_weight = tf.placeholder("float", shape=[]) visit_weight = tf.placeholder("float", shape=[]) walker_weight = tf.placeholder("float", shape=[]) t_logit_weight = tf.placeholder("float", shape=[]) t_l1_weight = tf.placeholder("float", shape=[]) t_learning_rate = tf.placeholder("float", shape=[]) t_unsup_emb = model.image_to_embedding(t_unsup_images) model.add_semisup_loss( t_sup_emb, t_unsup_emb, t_sup_labels, walker_weight=walker_weight, visit_weight=visit_weight, proximity_weight=proximity_weight) model.add_logit_loss(t_sup_logit, t_sup_labels, weight=t_logit_weight) model.add_emb_regularization(t_sup_emb, weight=t_l1_weight) model.add_emb_regularization(t_unsup_emb, weight=t_l1_weight) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() sess = tf.InteractiveSession(graph=graph) unsup_images_iterator = semisup.create_input(train_images, train_labels, FLAGS.unsup_batch_size) tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) use_new_visit_loss = False for step in range(FLAGS.max_steps): unsup_images, _ = sess.run(unsup_images_iterator) if use_new_visit_loss: _, summaries, train_loss = sess.run([train_op, summary_op, model.train_loss], { t_unsup_images: unsup_images, walker_weight: FLAGS.walker_weight, proximity_weight: 0.3 + apply_envelope("lin", step, 0.7, FLAGS.warmup_steps, 0) - apply_envelope("lin", step, FLAGS.visit_weight, 2000, FLAGS.warmup_steps), t_logit_weight: FLAGS.logit_weight, t_l1_weight: FLAGS.l1_weight, visit_weight: apply_envelope("lin", step, FLAGS.visit_weight, 2000, FLAGS.warmup_steps), t_learning_rate: 5e-5 + apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) }) else: _, summaries, train_loss = sess.run([train_op, summary_op, model.train_loss], { t_unsup_images: unsup_images, walker_weight: FLAGS.walker_weight, visit_weight: 0.3 + apply_envelope("lin", step, 0.7, FLAGS.warmup_steps, 0), proximity_weight: 0, t_logit_weight: FLAGS.logit_weight, t_l1_weight: FLAGS.l1_weight, t_learning_rate: 5e-5 + apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) }) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print('Train loss: %.2f ' % train_loss) print() test_summary = tf.Summary( value=[tf.Summary.Value( tag='Test Err', simple_value=test_err)]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step)
def main(_): if FLAGS.logdir is not None: FLAGS.logdir = FLAGS.logdir + '/t_mnist_eval' try: shutil.rmtree(FLAGS.logdir) except OSError as e: print ("Error: %s - %s." % (e.filename, e.strerror)) train_images, train_labels = mnist_tools.get_data('train') test_images, test_labels = mnist_tools.get_data('test') # Sample labeled training subset. if FLAGS.sup_seed >= 0: seed = FLAGS.sup_seed elif FLAGS.sup_seed == -2: seed = FLAGS.sup_per_class else: seed = np.random.randint(0, 1000) print('Seed:', seed) sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) graph = tf.Graph() with graph.as_default(): model = semisup.SemisupModel(semisup.architectures.mnist_model, NUM_LABELS, IMAGE_SHAPE, dropout_keep_prob=FLAGS.dropout_keep_prob) # Set up inputs. t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. if FLAGS.semisup: t_unsup_images, _ = semisup.create_input(train_images, train_labels, FLAGS.unsup_batch_size) t_unsup_emb = model.image_to_embedding(t_unsup_images) model.add_semisup_loss( t_sup_emb, t_unsup_emb, t_sup_labels, walker_weight=FLAGS.walker_weight, visit_weight=FLAGS.visit_weight) #model.add_emb_regularization(t_unsup_emb, weight=FLAGS.l1_weight) model.add_logit_loss(t_sup_logit, t_sup_labels, weight=FLAGS.logit_weight) #model.add_emb_regularization(t_sup_emb, weight=FLAGS.l1_weight) t_learning_rate = tf.placeholder("float", shape=[]) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() if FLAGS.logdir is not None: summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) learning_rate_ = FLAGS.learning_rate for step in range(FLAGS.max_steps): lr = learning_rate_ if step < FLAGS.warmup_steps: lr = 1e-6 + semisup.apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) _, summaries = sess.run([train_op, summary_op], { t_learning_rate: lr }) sys.stderr.write("\rstep: %d" % step) sys.stdout.flush() if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('\nStep: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) if FLAGS.logdir is not None: sum_values = { 'Test error': test_err } summary_writer.add_summary(summaries, step) for key, value in sum_values.items(): summary = tf.Summary( value=[tf.Summary.Value(tag=key, simple_value=value)]) summary_writer.add_summary(summary, step) if step % FLAGS.decay_steps == 0 and step > 0: learning_rate_ = learning_rate_ * FLAGS.decay_factor coord.request_stop() coord.join(threads) print('FINAL RESULTS:') print('Test error: %.2f %%' % (test_err)) print('final_score', 1 - test_err/100) print('@@test_error:%.4f' % (test_err/100)) print('@@train_loss:%.4f' % 0) print('@@reg_loss:%.4f' % 0) print('@@estimated_error:%.4f' % 0) print('@@centroid_norm:%.4f' % 0) print('@@emb_norm:%.4f' % 0) print('@@k_score:%.4f' % 0) print('@@svm_score:%.4f' % 0)
def main(_): if FLAGS.logdir is not None: # FLAGS.logdir = FLAGS.logdir + '/t_' + datetime.now().strftime("%m_%d_%Y_%H_%M_%S") _unsup_batch_size = FLAGS.unsup_batch_size if FLAGS.semisup else 0 FLAGS.logdir = "{0}/i{1}_e{2}_s{3}_un{4}_d{5}_{6}_w{7}".format( FLAGS.logdir, image_shape[0], FLAGS.emb_size, FLAGS.sup_per_class, _unsup_batch_size, FLAGS.decay_steps, int(FLAGS.decay_factor * 100), FLAGS.warmup_steps) try: shutil.rmtree(FLAGS.logdir) except OSError as e: print("Error: %s - %s." % (e.filename, e.strerror)) # Load image data from npy file train_images, test_images, train_labels, test_labels = dataset_tools.get_data( one_hot=False, test_size=FLAGS.test_size, image_shape=image_shape) unique, counts = np.unique(test_labels, return_counts=True) testset_distribution = dict(zip(unique, counts)) train_X, train_Y = semisup.sample_by_label_v2(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, np.random.randint(0, 100)) def aug(image, label): return apply_augmentation( image, target_shape=image_shape, params=dataset_tools.augmentation_params), label def aug_unsup(image): return apply_augmentation(image, target_shape=image_shape, params=dataset_tools.augmentation_params) graph = tf.Graph() with graph.as_default(): # Create function that defines the network. architecture = getattr(semisup.architectures, FLAGS.architecture) model_function = partial(architecture, new_shape=None, img_shape=IMAGE_SHAPE, batch_norm_decay=FLAGS.batch_norm_decay, emb_size=FLAGS.emb_size) model = semisup.SemisupModel(model_function, NUM_LABELS, IMAGE_SHAPE, emb_size=FLAGS.emb_size, dropout_keep_prob=FLAGS.dropout_keep_prob) # Set up supervised inputs. t_images = tf.placeholder("float", shape=[None] + image_shape) t_labels = tf.placeholder(train_labels.dtype, shape=[None]) dataset = Dataset.from_tensor_slices((t_images, t_labels)) # Apply augmentation if FLAGS.augmentation: dataset = dataset.map(aug) dataset = dataset.shuffle(buffer_size=FLAGS.sup_per_class * NUM_LABELS) dataset = dataset.repeat().batch(FLAGS.sup_per_class * NUM_LABELS) iterator = dataset.make_initializable_iterator() t_sup_images, t_sup_labels = iterator.get_next() # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. if FLAGS.semisup: unsup_t_images = tf.placeholder("float", shape=[None] + image_shape) unsup_dataset = Dataset.from_tensor_slices(unsup_t_images) # Apply augmentation if FLAGS.augmentation: unsup_dataset = unsup_dataset.map(aug_unsup) unsup_dataset = unsup_dataset.shuffle( buffer_size=FLAGS.unsup_batch_size) unsup_dataset = unsup_dataset.repeat().batch( FLAGS.unsup_batch_size) unsup_iterator = unsup_dataset.make_initializable_iterator() t_unsup_images = unsup_iterator.get_next() t_unsup_emb = model.image_to_embedding(t_unsup_images) model.add_semisup_loss(t_sup_emb, t_unsup_emb, t_sup_labels, walker_weight=FLAGS.walker_weight, visit_weight=FLAGS.visit_weight) #model.add_emb_regularization(t_unsup_emb, weight=FLAGS.l1_weight) else: model.loss_aba = tf.constant(0) model.visit_loss = tf.constant(0) t_logit_loss = model.add_logit_loss(t_sup_logit, t_sup_labels, weight=FLAGS.logit_weight) # t_logit_loss = tf.constant(0) #model.add_emb_regularization(t_sup_emb, weight=FLAGS.l1_weight) t_learning_rate = tf.placeholder("float", shape=[]) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() if FLAGS.logdir is not None: summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: sess.run(iterator.initializer, feed_dict={ t_images: train_X, t_labels: train_Y }) if FLAGS.semisup: sess.run(unsup_iterator.initializer, feed_dict={unsup_t_images: train_images}) tf.global_variables_initializer().run() if FLAGS.restore_checkpoint is not None: variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='net') restorer = tf.train.Saver(var_list=variables) restorer.restore(sess, FLAGS.restore_checkpoint) learning_rate_ = FLAGS.learning_rate for step in range(FLAGS.max_steps): lr = learning_rate_ if step < FLAGS.warmup_steps: lr = 1e-6 + semisup.apply_envelope( "log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) step_start_time = time.time() _, summaries, train_loss, aba_loss, visit_loss, logit_loss = sess.run( [ train_op, summary_op, model.train_loss, model.loss_aba, model.visit_loss, t_logit_loss ], {t_learning_rate: lr}) if not FLAGS.run_in_background: sys.stderr.write("\rstep: %d, Step time: %.4f sec" % (step, (time.time() - step_start_time))) sys.stdout.flush() # sup_images = sess.run(d_sup_image if (step + 1) % FLAGS.eval_interval == 0 or step == 99 or step == 0: print('\n=======================') print('Step: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Target:', testset_distribution) print('Test error: %.2f%%' % test_err) print('Learning rate:', lr) print('train_loss:', train_loss) if FLAGS.semisup: print('walker_loss_aba:', aba_loss) print('visit_loss:', visit_loss) print('logit_loss:', logit_loss) print('Image shape:', IMAGE_SHAPE) print('emb_size: ', FLAGS.emb_size) print('sup_per_class: ', FLAGS.sup_per_class) if FLAGS.semisup: print('unsup_batch_size: ', FLAGS.unsup_batch_size) print('semisup: ', FLAGS.semisup) print('augmentation: ', FLAGS.augmentation) print('decay_steps: ', FLAGS.decay_steps) print('decay_factor: ', FLAGS.decay_factor) print('warmup_steps: ', FLAGS.warmup_steps) if FLAGS.semisup: print('walker_weight: ', FLAGS.walker_weight) print('visit_weight: ', FLAGS.visit_weight) print('logit_weight: ', FLAGS.logit_weight) print('=======================\n') if FLAGS.logdir is not None: sum_values = {'Test error': test_err} summary_writer.add_summary(summaries, step) for key, value in sum_values.items(): summary = tf.Summary(value=[ tf.Summary.Value(tag=key, simple_value=value) ]) summary_writer.add_summary(summary, step) if FLAGS.logdir is not None and (step + 1) % 5000 == 0: path = saver.save(sess, FLAGS.logdir + '/checkpoint', model.step) print('@@model_path:%s' % path) if step % FLAGS.decay_steps == 0 and step > 0: learning_rate_ = learning_rate_ * FLAGS.decay_factor
def main(_): unsup_multiplier = NUM_TRAIN_IMAGES / NUM_LABELS / FLAGS.sup_per_class print(unsup_multiplier) # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else None graph = tf.Graph() with graph.as_default(): model = semisup.SemisupModel(semisup.architectures.densenet_model, NUM_LABELS, IMAGE_SHAPE) # Set up inputs. train_sup, train_labels_sup = data.build_input(FLAGS.cifar, os.path.join(FLAGS.dataset_dir, TRAIN_FILE), batch_size=FLAGS.sup_batch_size, mode='train', subset_factor=unsup_multiplier) if FLAGS.unsup_batch_size > 0: train_unsup, train_labels_unsup = data.build_input(FLAGS.cifar, os.path.join(FLAGS.dataset_dir, TRAIN_FILE), batch_size=FLAGS.unsup_batch_size, mode='train') test_images, test_labels = data.build_input(FLAGS.cifar, os.path.join(FLAGS.dataset_dir, TEST_FILE), batch_size=TEST_BATCH_SIZE, mode='test') # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(train_sup) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. if FLAGS.unsup_batch_size > 0: t_unsup_emb = model.image_to_embedding(train_unsup) model.add_semisup_loss( t_sup_emb, t_unsup_emb, train_labels_sup, visit_weight=FLAGS.visit_weight) model.add_logit_loss(t_sup_logit, train_labels_sup) t_learning_rate = tf.train.exponential_decay( FLAGS.learning_rate, model.step, FLAGS.decay_epochs * steps_per_epoch, FLAGS.decay_factor, staircase=True) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) last_epoch = -1 for step in range(FLAGS.max_epochs * int(steps_per_epoch)): _, summaries, tl = sess.run([train_op, summary_op, model.train_loss]) epoch = math.floor(step / steps_per_epoch) if (epoch >= 0 and epoch % FLAGS.eval_interval == 0) or epoch == 1: if epoch == last_epoch: #don't log twice for same epoch continue last_epoch = epoch num_total_batches = 10000 / TEST_BATCH_SIZE print('Epoch: %d' % epoch) t_imgs, t_lbls = model.get_images(test_images, test_labels, num_total_batches, sess) test_pred = model.classify(t_imgs).argmax(-1) conf_mtx = semisup.confusion_matrix(t_lbls, test_pred, NUM_LABELS) test_err = (t_lbls != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print() t_imgs, t_lbls = model.get_images(train_sup, train_labels_sup, num_total_batches, sess) train_pred = model.classify(t_imgs).argmax(-1) train_err = (t_lbls != train_pred).mean() * 100 print('Train error: %.2f %%' % train_err) test_summary = tf.Summary( value=[tf.Summary.Value( tag='Test Err', simple_value=test_err)]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) saver.save(sess, FLAGS.logdir, model.step) coord.request_stop() coord.join(threads)
def main(_): train_images, train_labels = mnist_tools.get_data('train') test_images, test_labels = mnist_tools.get_data('test') # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else None sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) import numpy as np if 0: indices = [374, 2507, 9755, 12953, 16507, 16873, 23474, 23909, 30280, 35070, 49603, 50106, 51171, 51726, 51805, 55205, 57251, 57296, 57779, 59154] + \ [16644, 45576, 52886, 42140, 29201, 7767, 24, 134, 8464, 15022, 15715, 15602, 11030, 3898, 10195, 1454, 3290, 5293, 5806, 274] indices = [374, 2507, 9755, 12953, 16507, 16873, 23474, 23909, 30280, 35070, 49603, 50106, 51171, 51726, 51805, 55205, 57251, 57296, 57779, 59154] + \ [9924, 34058, 53476, 15715, 6428, 33598, 33464, 41753, 21250, 26389, 12950, 12464, 3795, 6761, 5638, 3952, 8300, 5632, 1475, 1875] sup_by_label = [ [] for i in range(NUM_LABELS)] for ind in indices: i = train_labels[ind] sup_by_label[i] = sup_by_label[i] + [train_images[ind]] for i in range(10): sup_by_label[i] = np.asarray(sup_by_label[i]) sup_by_label = np.asarray(sup_by_label) add_random_samples = 20 if add_random_samples > 0: rng = np.random.RandomState() indices = rng.choice(len(train_images), add_random_samples, False) for i in indices: l = train_labels[i] sup_by_label[l] = np.vstack([sup_by_label[l], [train_images[i]]]) graph = tf.Graph() with graph.as_default(): model = semisup.SemisupModel(semisup.architectures.mnist_model, NUM_LABELS, IMAGE_SHAPE) # Set up inputs. t_unsup_images, _ = semisup.create_input(train_images, train_labels, FLAGS.unsup_batch_size) t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_unsup_emb = model.image_to_embedding(t_unsup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. model.add_semisup_loss( t_sup_emb, t_unsup_emb, t_sup_labels, visit_weight=FLAGS.visit_weight) model.add_logit_loss(t_sup_logit, t_sup_labels) t_learning_rate = tf.train.exponential_decay( FLAGS.learning_rate, model.step, FLAGS.decay_steps, FLAGS.decay_factor, staircase=True) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in range(FLAGS.max_steps): _, summaries = sess.run([train_op, summary_op]) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print() test_summary = tf.Summary( value=[tf.Summary.Value( tag='Test Err', simple_value=test_err)]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) saver.save(sess, FLAGS.logdir, model.step) coord.request_stop() coord.join(threads)
def main(_): # Sample labeled training subset. train_images, train_labels = data.load_training_data(FLAGS.cifar) test_images, test_labels = data.load_test_data(FLAGS.cifar) print(train_images.shape, train_labels.shape) # Sample labeled training subset. seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else np.random.randint(0, 1000) print('Seed:', seed) sup_by_label = semisup.sample_by_label(train_images, train_labels, FLAGS.sup_per_class, NUM_LABELS, seed) graph = tf.Graph() with graph.as_default(): def augment(image): # image_size = 28 # image = tf.image.resize_image_with_crop_or_pad( # image, image_size+4, image_size+4) # image = tf.random_crop(image, [image_size, image_size, 3]) image = tf.image.random_flip_left_right(image) # Brightness/saturation/constrast provides small gains .2%~.5% on cifar. # image = tf.image.random_brightness(image, max_delta=63. / 255.) # image = tf.image.random_saturation(image, lower=0.5, upper=1.5) # image = tf.image.random_contrast(image, lower=0.2, upper=1.8) return image model_func = getattr(semisup.architectures, FLAGS.model) model = semisup.SemisupModel(model_func, NUM_LABELS, IMAGE_SHAPE, emb_size=256, dropout_keep_prob=FLAGS.dropout_keep_prob, augmentation_function=augment) if FLAGS.random_batches: sup_lbls = np.asarray(np.hstack([np.ones(len(i)) * ind for ind, i in enumerate(sup_by_label)]), np.int) sup_images = np.vstack(sup_by_label) batch_size = FLAGS.sup_per_batch * NUM_LABELS t_sup_images, t_sup_labels = semisup.create_input(sup_images, sup_lbls, batch_size) else: t_sup_images, t_sup_labels = semisup.create_per_class_inputs( sup_by_label, FLAGS.sup_per_batch) # Compute embeddings and logits. t_sup_emb = model.image_to_embedding(t_sup_images) t_sup_logit = model.embedding_to_logit(t_sup_emb) # Add losses. if FLAGS.semisup: if FLAGS.equal_cls_unsup: allimgs_bylabel = semisup.sample_by_label(train_images, train_labels, int(NUM_TRAIN_IMAGES / NUM_LABELS), NUM_LABELS, seed) t_unsup_images, _ = semisup.create_per_class_inputs( allimgs_bylabel, FLAGS.sup_per_batch) else: t_unsup_images, _ = semisup.create_input(train_images, train_labels, FLAGS.unsup_batch_size) t_unsup_emb = model.image_to_embedding(t_unsup_images) proximity_weight = tf.placeholder("float", shape=[]) visit_weight = tf.placeholder("float", shape=[]) walker_weight = tf.placeholder("float", shape=[]) model.add_semisup_loss( t_sup_emb, t_unsup_emb, t_sup_labels, walker_weight=walker_weight, visit_weight=visit_weight, proximity_weight=proximity_weight) model.add_logit_loss(t_sup_logit, t_sup_labels) t_learning_rate = tf.train.exponential_decay( FLAGS.learning_rate, model.step, FLAGS.decay_steps, FLAGS.decay_factor, staircase=True) train_op = model.create_train_op(t_learning_rate) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in range(FLAGS.max_steps): feed_dict={} if FLAGS.semisup: if FLAGS.proximity_loss: feed_dict = { walker_weight: FLAGS.walker_weight,#0.1 + apply_envelope("lin", step, FLAGS.walker_weight, 500, FLAGS.decay_steps), visit_weight: 0, proximity_weight: FLAGS.visit_weight#0.1 + apply_envelope("lin", step,FLAGS.visit_weight, 500, FLAGS.decay_steps), #t_logit_weight: FLAGS.logit_weight, #t_learning_rate: 5e-5 + apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) } else: feed_dict = { walker_weight: FLAGS.walker_weight,#0.1 + apply_envelope("lin", step, FLAGS.walker_weight, 500, FLAGS.decay_steps), visit_weight: FLAGS.visit_weight, #0.1 + apply_envelope("lin", step,FLAGS.visit_weight, 500, FLAGS.decay_steps), proximity_weight: 0 #t_logit_weight: FLAGS.logit_weight, #t_learning_rate: 5e-5 + apply_envelope("log", step, FLAGS.learning_rate, FLAGS.warmup_steps, 0) } _, summaries, train_loss = sess.run([train_op, summary_op, model.train_loss], feed_dict) if (step + 1) % FLAGS.eval_interval == 0 or step == 99: print('Step: %d' % step) test_pred = model.classify(test_images, sess).argmax(-1) conf_mtx = semisup.confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print() test_summary = tf.Summary( value=[tf.Summary.Value( tag='Test Err', simple_value=test_err)]) summary_writer.add_summary(summaries, step) summary_writer.add_summary(test_summary, step) #saver.save(sess, FLAGS.logdir, model.step) coord.request_stop() coord.join(threads)