def bulid_Net(image):
image = tf.reshape(image, [-1, 32, 32, 3])
with tf.variable_scope(name_or_scope='CifarNet', reuse=tf.AUTO_REUSE):
arg_scope = cifarnet.cifarnet_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_point = cifarnet.cifarnet(image)
probs = tf.nn.softmax(logits) # probabilities
return logits, probs, end_point
def _test(sess):
image_placeholder = tf.placeholder(tf.float32,
[FLAGS.batch_size, 32, 32, 3])
label_placeholder = tf.placeholder(tf.float32,
[FLAGS.batch_size, FLAGS.class_number])
with slim.arg_scope(cifarnet.cifarnet_arg_scope()):
logits, endpoints = cifarnet.cifarnet(image_placeholder)
top_k_op = tf.nn.in_top_k(logits, label_placeholder, FLAGS.top_k)
variable_to_restore = slim.get_model_variables()
restorer = tf.train.Saver(variable_to_restore)
checkpoint = tf.train.latest_checkpoint(FLAGS.logdir)
restorer.restore(sess, checkpoint)
print('---Successfully restored from %s---' % FLAGS.lordir)
dataset = DatasetCifar(FLAGS.dataset_dir,
one_hot=True,
class_number=FLAGS.class_number)
batch_count = 0
true_count = 0
while True:
try:
test_images, test_labels = dataset.next_test_batch()
test_images = np.array(test_images)
test_labels = np.array(test_labels)
predictions = sess.run(top_k_op,
feed_dict={
image_placeholder: test_iamges,
label_placeholder: test_labels
})
true_count += np.sum(predictions)
batch_count += 1
except OutOfRangeError:
precision = true_count / (batch_count * FLAGS.batch_size)
print('-----------------------------')
print('| Precision is %f |' % precision)
print('-----------------------------')
break
def _train(sess):
with tf.name_scope('data_input'):
image_batch, label_batch = setup_train_input(sess)
with tf.name_scope('Network'):
with slim.arg_scope(cifarnet.cifarnet_arg_scope()):
logits, end_points = cifarnet.cifarnet(image_batch)
with tf.name_scope('X_entropy_loss'):
x_entropy_loss = slim.losses.softmax_cross_entropy(
label_batch,
logits,
label_smoothing=FLAGS.label_smoothing,
weights=1.0)
with tf.name_scope('total_loss'):
total_loss = slim.losses.get_total_loss()
with tf.name_scope('global_step'):
global_step = tf.train.get_or_create_global_step()
incr_global_step = tf.assign(global_step, global_step + 1)
with tf.name_scope('train'):
learning_rate = _configure_learning_rate(
50000, global_step) #to be modified with val
optimizer = _configure_optimizer(learning_rate)
var_to_train = [var for var in tf.trainable_variables()]
gradients = optimizer.compute_gradients(total_loss,
var_list=var_to_train)
train_op = optimizer.apply_gradients(gradients)
init_op = tf.global_variables_initializer()
sess.run(init_op)
saver = tf.train.Saver(max_to_keep=5)
with tf.name_scope('Summary'):
# Add summaries for end_points.
for end_point in end_points:
x = end_points[end_point]
tf.summary.histogram('activations/' + end_point, x)
tf.summary.scalar('sparsity/' + end_point, tf.nn.zero_fraction(x))
# Add summaries for losses.
for loss in tf.get_collection(tf.GraphKeys.LOSSES):
tf.summary.scalar('losses/%s' % loss.op.name, loss)
tf.summary.scalar('total_loss', total_loss)
# Add summaries for variables.
for variable in slim.get_model_variables():
tf.summary.histogram(variable.op.name, variable)
tf.summary.scalar('learning_rate', learning_rate)
summary_writer = tf.summary.FileWriter(FLAGS.logdir, graph=sess.graph)
summary_op = tf.summary.merge_all()
step = 0
max_step = math.ceil(50000 * FLAGS.num_epoch * 10 / FLAGS.batch_size)
start_time = time.time()
print('Start training...')
print('Batch size: %d, number of epoch: %d' %
(FLAGS.batch_size, FLAGS.num_epoch))
while True:
try:
options = None
run_metadata = None
if should_log(FLAGS.trace_freq, step, max_step):
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
fetches = {
'train': train_op,
'global_step': global_step,
'incr_global_step': incr_global_step
}
if should_log(FLAGS.log_freq, step, max_step):
fetches['x_entropy_loss'] = x_entropy_loss
fetches['total_loss'] = total_loss
if should_log(FLAGS.sum_freq, step, max_step):
fetches['summary'] = summary_op
results = sess.run(fetches,
options=options,
run_metadata=run_metadata)
current_time = time.time()
process_time = current_time - start_time
remain_time = (max_step - step + 1) * process_time / (step + 1)
if should_log(FLAGS.log_freq, step, max_step):
print(
'-------------------------------------------------------------------------------'
)
print(
'Global step: %d, X_loss: %.4f, total loss: %.4f, process time: %d mins, remain time: %d mins'
% (results['global_step'], results['x_entropy_loss'],
results['total_loss'], process_time / 60,
remain_time / 60))
if should_log(FLAGS.sum_freq, step, max_step):
summary_writer.add_summary(results['summary'])
if should_log(FLAGS.trace_freq, step, max_step):
print('Recording trace...')
summary_writer.add_run_metadata(
run_metadata, 'step_%d' % results['global_step'])
if should_log(FLAGS.save_freq, step, max_step):
print('Saving model...')
saver.save(sess,
os.path.join(FLAGS.logdir, 'model'),
global_step=results['global_step'])
step = step + 1
except tf.errors.OutOfRangeError:
print(
'----------------------------------------------------------------------------------'
)
print('Done training!')
current_time = time.time()
process_time = current_time - start_time
print(
'Total training time is %d hours and %d minutes' %
(math.floor(process_time / 3600),
(process_time - math.floor(process_time / 3600) * 3600) / 60))
break
y_valid, y_train = y_train[:50], y_train[50:300]
X_test = X_test[:50]
y_test = y_test[:50]
reset_graph()
X = tf.placeholder(tf.float32, shape=[None, 32, 32, 3], name="X")
y = tf.placeholder(tf.int32, shape=[None], name="y")
step = tf.placeholder(tf.float32, name='step')
n_epochs = 50
batch_size = 20
max_checks_without_progress = 20
checks_without_progress = 0
best_loss = np.infty
with tf.name_scope("resnet"):
with slim.arg_scope(cifarnet.cifarnet_arg_scope()):
logits, end_points = cifarnet.cifarnet(X)
with tf.name_scope("loss"):
xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits, labels=y)
loss = tf.reduce_mean(xentropy)
with tf.name_scope("train"):
change_lr = lr_step(step)
optimizer = tf.train.MomentumOptimizer(
learning_rate=change_lr, momentum=0.9)
training_op = optimizer.minimize(loss)
with tf.name_scope("eval"):
correct = tf.nn.in_top_k(logits, y, 1)
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))
init = tf.global_variables_initializer()
saver = tf.train.Saver()
