from naive import NAIVE as model
model = model(model_params)
os.system("figlet -w 50 -f slant naive")
# build the model graph
metrics = model.build(data_iter)
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
if flags.training_method == 'sgd':
optimizer = tf.train.GradientDescentOptimizer(flags.lr)
elif flags.training_method == 'adam':
optimizer = tf.train.AdamOptimizer(flags.lr)
elif flags.training_method == 'adadelta':
optimizer = tf.train.AdadeltaOptimizer(flags.lr, epsilon=1e-6)
train_op_without_wrd_emb = get_train_op(optimizer, model.loss, model.wrd_emb,
global_step, .0)
train_op_with_wrd_emb = get_train_op(optimizer, model.loss, model.wrd_emb,
global_step, flags.embedding_lr)
# _ _ _
# _ __ ___ ___ __| | ___| | _ __ ___ ___ ___ _ __ __| | ___ _ __
# | '_ ` _ \ / _ \ / _` |/ _ \ | | '__/ _ \/ __/ _ \| '__/ _` |/ _ \ '__|
# | | | | | | (_) | (_| | __/ | | | | __/ (_| (_) | | | (_| | __/ |
# |_| |_| |_|\___/ \__,_|\___|_| |_| \___|\___\___/|_| \__,_|\___|_|
# merge tensorboard summary
summary = None
if flags.debug:
summary = tf.summary.merge_all()
train_writer = tf.summary.FileWriter('summary/train', sess.graph)
# dev_writer = tf.summary.FileWriter('summary/dev', sess.graph)
def main(_):
data_tr, labels_tr, data_te, labels_te, unlabeled = input_data.load_data(
FLAGS.dataset_name, FLAGS.num_labeled)
print(" train shapes:", data_tr.shape, labels_tr.shape)
print(" test shapes:", data_te.shape, labels_te.shape)
print("unlabeled shapes:", unlabeled.shape)
data_tr_batch, labels_tr_batch = u.load_shuffle_batch(
data_tr,
labels_tr,
batch_size=FLAGS.batch_size,
capacity=FLAGS.batch_size * 100,
min_after_dequeue=FLAGS.batch_size * 20)
data_te_batch, labels_te_batch = u.load_batch(data_te, labels_te,
FLAGS.batch_size)
data_unlabeled_batch, _ = u.load_batch(unlabeled,
np.zeros(unlabeled.shape[0]),
FLAGS.batch_size)
with tf.variable_scope('model') as scope:
model = models.get_model(FLAGS.model_name)
logits_tr = model(data_tr_batch, is_training=True)
scope.reuse_variables()
logits_te = model(data_te_batch, is_training=False)
loss_tr = u.get_supervised_loss(logits=logits_tr, labels=labels_tr_batch)
loss_te = u.get_supervised_loss(logits=logits_te, labels=labels_te_batch)
acc_tr = u.get_accuracy(logits_tr, labels_tr_batch)
acc_te = u.get_accuracy(logits_te, labels_te_batch)
step = tf.Variable(0, trainable=False, dtype=tf.int32)
optimizer = u.get_optimizer(FLAGS.optimizer_type, FLAGS.learning_rate,
step, FLAGS.lr_decay_steps,
FLAGS.lr_decay_factor)
train_op = u.get_train_op(optimizer, loss_tr, step)
with tf.Session() as sess:
def eval_test():
loss = 0.0
acc = 0.0
eval_iters = int(data_te.shape[0] / FLAGS.batch_size)
for j in range(eval_iters):
l, a = sess.run([loss_te, acc_te])
loss += l
acc += a
loss /= eval_iters
acc /= eval_iters
return loss, acc
# initialize the variables
init_op = tf.global_variables_initializer()
sess.run(init_op)
# initialize the queue threads to start to shovel data
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for i in tqdm(range(FLAGS.num_iters)):
_, cur_loss_tr, cur_acc_tr = sess.run([train_op, loss_tr, acc_tr])
if i % FLAGS.eval_interval == 0:
print('train loss: %.4f train acc: %.4f' %
(cur_loss_tr, cur_acc_tr))
cur_loss_te, cur_acc_te = eval_test()
print(' test loss: %.4f test acc: %.4f' %
(cur_loss_te, cur_acc_te))
# stop our queue threads and properly close the session
coord.request_stop()
coord.join(threads)
sess.close()
def main(_):
data_tr, labels_tr, data_te, labels_te, unlabeled = input_data.load_mnist(
num_labeled=FLAGS.num_labeled)
print(" train shapes:", data_tr.shape, labels_tr.shape)
print(" test shapes:", data_te.shape, labels_te.shape)
print("unlabeled shapes:", unlabeled.shape)
data_tr_batch, labels_tr_batch = u.load_shuffle_batch(
data_tr,
labels_tr,
batch_size=FLAGS.batch_size,
capacity=FLAGS.batch_size * 100,
min_after_dequeue=FLAGS.batch_size * 20)
data_te_batch, labels_te_batch = u.load_batch(data_te, labels_te,
FLAGS.batch_size)
with tf.variable_scope('model') as scope:
logits_tr = models.mnist_supervised_rasmus(data_tr_batch,
is_training=True)
scope.reuse_variables()
logits_te = models.mnist_supervised_rasmus(data_te_batch,
is_training=False)
loss_tr = u.get_supervised_loss(logits=logits_tr, labels=labels_tr_batch)
loss_te = u.get_supervised_loss(logits=logits_te, labels=labels_te_batch)
acc_tr = u.get_accuracy(logits_tr, labels_tr_batch)
acc_te = u.get_accuracy(logits_te, labels_te_batch)
step = tf.Variable(0, trainable=False, dtype=tf.int32)
optimizer = u.get_adam_rasmus(step=step,
learning_rate=FLAGS.learning_rate,
num_total_iters=FLAGS.num_iters,
decay_first=FLAGS.decay_first)
train_op = u.get_train_op(optimizer, loss_tr, step)
with tf.Session() as sess:
def eval_test():
loss = 0.0
acc = 0.0
eval_iters = int(data_te.shape[0] / FLAGS.batch_size)
for j in range(eval_iters):
l, a = sess.run([loss_te, acc_te])
loss += l
acc += a
loss /= eval_iters
acc /= eval_iters
return loss, acc
# initialize the variables
init_op = tf.global_variables_initializer()
sess.run(init_op)
# initialize the queue threads to start to shovel data
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for i in tqdm(range(FLAGS.num_iters)):
_, cur_loss_tr, cur_acc_tr = sess.run([train_op, loss_tr, acc_tr])
if FLAGS.eval_interval is not None and i % FLAGS.eval_interval == 0:
print('train loss: %.4f train acc: %.4f' %
(cur_loss_tr, cur_acc_tr))
cur_loss_te, cur_acc_te = eval_test()
print(' test loss: %.4f test acc: %.4f' %
(cur_loss_te, cur_acc_te))
print('\nOPTIMIZATION FINISHED!')
final_loss_te, final_acc_te = eval_test()
print('FINAL TEST LOSS: %.4f FINAL TEST ACC: %.4f' %
(final_loss_te, final_acc_te))
# stop our queue threads and properly close the session
coord.request_stop()
coord.join(threads)
sess.close()
def main(_):
data_tr, labels_tr, data_te, labels_te, unlabeled = input_data.load_cifar10(
num_labeled=FLAGS.num_labeled)
print(" train shapes:", data_tr.shape, labels_tr.shape)
print(" test shapes:", data_te.shape, labels_te.shape)
print("unlabeled shapes:", unlabeled.shape)
data_tr_batch, labels_tr_batch = u.load_shuffle_batch(
data_tr,
labels_tr,
batch_size=FLAGS.batch_size,
capacity=FLAGS.batch_size * 100,
min_after_dequeue=FLAGS.batch_size * 20)
data_te_batch, labels_te_batch = u.load_batch(data_te, labels_te,
FLAGS.batch_size)
unlabeled_batch, _ = u.load_shuffle_batch(
unlabeled,
unlabeled,
batch_size=FLAGS.batch_size,
capacity=FLAGS.batch_size * 100,
min_after_dequeue=FLAGS.batch_size * 20)
bn_decay = 0.9
ema = tf.train.ExponentialMovingAverage(decay=bn_decay)
bn_assigns = []
logits_tr, _, _, _ = models.cifar10_gamma(data_tr_batch,
is_training=True,
is_unlabeled=False,
ema=ema,
bn_assigns=bn_assigns,
batch_norm_decay=bn_decay,
noise_std=0.3)
# _, _, crt, cln = models.cifar10_gamma(unlabeled_batch, is_training=False, is_unlabeled=True,
# ema=ema, bn_assigns=bn_assigns, batch_norm_decay=bn_decay, noise_std=0.3)
_, logits_te, _, _ = models.cifar10_gamma(data_te_batch,
is_training=False,
is_unlabeled=False,
ema=ema,
bn_assigns=bn_assigns,
batch_norm_decay=bn_decay,
noise_std=0.0)
loss_tr = u.get_supervised_loss(logits=logits_tr, labels=labels_tr_batch)
# loss_tr = u.get_supervised_loss(logits=logits_tr, labels=labels_tr_batch) + u.get_denoising_loss(crt, cln, 4.0)
loss_te = u.get_supervised_loss(logits=logits_te, labels=labels_te_batch)
acc_tr = u.get_accuracy(logits_tr, labels_tr_batch)
acc_te = u.get_accuracy(logits_te, labels_te_batch)
step = tf.Variable(0, trainable=False, dtype=tf.int32)
optimizer = u.get_adam_rasmus(step=step,
learning_rate=FLAGS.learning_rate,
num_total_iters=FLAGS.num_iters,
decay_first=FLAGS.decay_first)
train_op = u.get_train_op(optimizer, loss_tr, step, bn_assigns=bn_assigns)
with tf.Session() as sess:
def eval_test():
loss = 0.0
acc = 0.0
eval_iters = int(data_te.shape[0] / FLAGS.batch_size)
for j in range(eval_iters):
l, a = sess.run([loss_te, acc_te])
loss += l
acc += a
loss /= eval_iters
acc /= eval_iters
return loss, acc
# initialize the variables
init_op = tf.global_variables_initializer()
sess.run(init_op)
# initialize the queue threads to start to shovel data
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
print('\nOPTIMIZATION STARTED!')
for i in tqdm(range(FLAGS.num_iters)):
_, cur_loss_tr, cur_acc_tr = sess.run([train_op, loss_tr, acc_tr])
if FLAGS.eval_interval is not None and i % FLAGS.eval_interval == 0:
print('train loss: %.4f train acc: %.4f' %
(cur_loss_tr, cur_acc_tr))
cur_loss_te, cur_acc_te = eval_test()
print(' test loss: %.4f test acc: %.4f' %
(cur_loss_te, cur_acc_te))
print('\nOPTIMIZATION FINISHED!')
final_loss_te, final_acc_te = eval_test()
print('FINAL TEST LOSS: %.4f FINAL TEST ACC: %.4f' %
(final_loss_te, final_acc_te))
# stop our queue threads and properly close the session
coord.request_stop()
coord.join(threads)
sess.close()
