"""Run Eval once.

with tf.Session() as sess:

ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)

if ckpt and ckpt.model_checkpoint_path:

# Restores from checkpoint

saver.restore(sess, ckpt.model_checkpoint_path)

# Assuming model_checkpoint_path looks something like:

# /my-favorite-path/cifar10_train/model.ckpt-0,

# extract global_step from it.

global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]

else:

print('No checkpoint file found')

return

# Start the queue runners.

coord = tf.train.Coordinator()

try:

threads = []

for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):

threads.extend(qr.create_threads(sess, coord=coord, daemon=True,

start=True))

num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size))

true_count = 0 # Counts the number of correct predictions.

total_sample_count = num_iter * FLAGS.batch_size

step = 0

while step < num_iter and not coord.should_stop():

predictions = sess.run([top_k_op])

true_count += np.sum(predictions)

step += 1

# Compute precision @ 1.

precision = true_count / total_sample_count

print('%s: precision @ 1 = %.3f' % (datetime.now(), precision))

print(top_k_op)

summary = tf.Summary()

summary.ParseFromString(sess.run(summary_op))

summary.value.add(tag='Precision @ 1', simple_value=precision)

summary_writer.add_summary(summary, global_step)

except Exception as e: # pylint: disable=broad-except

coord.request_stop(e)

coord.request_stop()

"""Eval CIFAR-10 for a number of steps."""

with tf.Graph().as_default() as g:

# Get images and labels for CIFAR-10.

eval_data = FLAGS.eval_data == 'test'

images, labels = cifar10.inputs(eval_data=eval_data)

# Build a Graph that computes the logits predictions from the

# inference model.

logits = cifar10.inference(images)

# Calculate predictions.

top_k_op = tf.nn.in_top_k(logits, labels, 1)

print(top_k_op)

# Restore the moving average version of the learned variables for eval.

variable_averages = tf.train.ExponentialMovingAverage(

cifar10.MOVING_AVERAGE_DECAY)

variables_to_restore = variable_averages.variables_to_restore()

saver = tf.train.Saver(variables_to_restore)

# Build the summary operation based on the TF collection of Summaries.

summary_op = tf.summary.merge_all()

summary_writer = tf.summary.FileWriter(FLAGS.eval_dir, g)

while True:

eval_once(saver, summary_writer, top_k_op, summary_op)

if FLAGS.run_once:

break

"""Train CIFAR-10 for a number of steps."""

with tf.Graph().as_default():

global_step = tf.contrib.framework.get_or_create_global_step()

# Get images and labels for CIFAR-10.

# Force input pipeline to CPU:0 to avoid operations sometimes ending up on

# GPU and resulting in a slow down.

with tf.device('/cpu:0'):

images, labels = cifar10.distorted_inputs()

# Build a Graph that computes the logits predictions from the

# inference model.

logits = cifar10.inference(images)

# Calculate loss.

loss = cifar10.loss(logits, labels)

# Build a Graph that trains the model with one batch of examples and

# updates the model parameters.

train_op = cifar10.train(loss, global_step)

saver = tf.train.Saver(tf.global_variables())

# Build an initialization operation to run below.

init = tf.global_variables_initializer()

# Start running operations on the Graph. allow_soft_placement must be set to

# True to build towers on GPU, as some of the ops do not have GPU

# implementations.

sess = tf.Session(config=tf.ConfigProto(

allow_soft_placement=True,

log_device_placement=FLAGS.log_device_placement))

sess.run(init)

# Start the queue runners.

tf.train.start_queue_runners(sess=sess)

for step in xrange(FLAGS.max_steps):

start_time = time.time()

_, loss_value = sess.run([train_op, loss])

duration = time.time() - start_time

assert not np.isnan(loss_value), 'Model diverged with loss = NaN'

if step % 10 == 0:

num_examples_per_step = FLAGS.batch_size

examples_per_sec = num_examples_per_step / duration

sec_per_batch = duration

format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '

'sec/batch)')

print (format_str % (datetime.now(), step, loss_value,

examples_per_sec, sec_per_batch))

# Save the model checkpoint periodically.

if step % 1000 == 0 or (step + 1) == FLAGS.max_steps:

checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')

saver.save(sess, checkpoint_path, global_step=step)

#cifar10.maybe_download_and_extract()

if tf.gfile.Exists(FLAGS.train_dir):

tf.gfile.DeleteRecursively(FLAGS.train_dir)

tf.gfile.MakeDirs(FLAGS.train_dir)