def __init__(self):
self.train_dataset = imagenet.get_split(
'train',
FLAGS.data_dir,
labels_dir=FLAGS.labels_dir,
file_pattern=FLAGS.file_pattern)
self.eval_dataset = imagenet.get_split('validation',
FLAGS.data_dir,
labels_dir=FLAGS.labels_dir,
file_pattern=FLAGS.file_pattern)
self.image_preprocessing_fn = vgg_preprocessing.preprocess_image
model = layers_resnet.get_model(FLAGS.model)
self.network_fn = model(num_classes=self.train_dataset.num_classes)
self.batches_per_epoch = (self.train_dataset.num_samples /
FLAGS.batch_size)
def main(_):
if not FLAGS.output_file:
raise ValueError(
'You must supply the path to save to with --output_file')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default() as graph:
#dataset = dataset_factory.get_dataset(FLAGS.dataset_name, 'train',
# FLAGS.dataset_dir)
image_net = imagenet.get_split('train',
FLAGS.dataset_dir,
file_pattern=None,
reader=None)
inception_network_fn = inception_v4_get_network_fn(
num_classes=(image_net.num_classes - FLAGS.labels_offset),
is_training=False)
#pdb.set_trace()
image_size = inception_network_fn.default_image_size
input_shape = [FLAGS.batch_size, image_size, image_size, 3]
placeholder = tf.placeholder(name='input',
dtype=tf.float32,
shape=input_shape)
inception_network_fn(placeholder)
if FLAGS.quantize:
tf.contrib.quantize.create_eval_graph()
graph_def = graph.as_graph_def()
if FLAGS.write_text_graphdef:
tf.io.write_graph(graph_def,
os.path.dirname(FLAGS.output_file),
os.path.basename(FLAGS.output_file),
as_text=True)
else:
with gfile.GFile(FLAGS.output_file, 'wb') as f:
f.write(graph_def.SerializeToString())
def __call__(self, params):
"""Input function which provides a single batch for train or eval."""
batch_size = params['batch_size']
if FLAGS.use_data == 'real':
train_dataset = imagenet.get_split('train', FLAGS.data_dir)
eval_dataset = imagenet.get_split('validation', FLAGS.data_dir)
dataset = train_dataset if self.is_training else eval_dataset
capacity_multiplier = 20 if self.is_training else 2
min_multiplier = 10 if self.is_training else 1
provider = tf.contrib.slim.dataset_data_provider.DatasetDataProvider(
dataset=dataset,
num_readers=4,
common_queue_capacity=capacity_multiplier * batch_size,
common_queue_min=min_multiplier * batch_size)
image, label = provider.get(['image', 'label'])
image = vgg_preprocessing.preprocess_image(
image=image,
output_height=FLAGS.height,
output_width=FLAGS.width,
is_training=self.is_training,
resize_side_min=_RESIZE_SIDE_MIN,
resize_side_max=_RESIZE_SIDE_MAX)
images, labels = tf.train.batch(tensors=[image, label],
batch_size=batch_size,
num_threads=4,
capacity=5 * batch_size)
labels = tf.one_hot(labels, FLAGS.num_classes)
else:
images = tf.random_uniform(
[batch_size, FLAGS.height, FLAGS.width, 3],
minval=-1,
maxval=1)
labels = tf.random_uniform([batch_size],
minval=0,
maxval=999,
dtype=tf.int32)
labels = tf.one_hot(labels, FLAGS.num_classes)
return images, labels
def gen_data(split_name, dataset, batch_size, img_size=224, aug=False):
dataset = imagenet.get_split(split_name,
dataset,
file_pattern=None,
reader=None)
if split_name == 'train':
num_file_readers = 16
num_img_readers = 16
shuffle = True
batch_scale = 10
if aug:
preprocess_fn = preprocess_aug
else:
preprocess_fn = preprocess
else:
num_file_readers = 1
num_img_readers = 4
shuffle = False
batch_scale = 1
preprocess_fn = preprocess
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
num_readers=num_file_readers,
shuffle=shuffle,
common_queue_capacity=2 * batch_scale * batch_size,
common_queue_min=batch_scale * batch_size)
[image, label] = provider.get(['image', 'label'])
image = preprocess_fn(image, img_size, img_size)
images, labels = tf.train.batch([image, label],
batch_size=batch_size,
num_threads=num_img_readers,
capacity=5 * batch_size)
return images, labels
type=int,
default=None,
help='The number of steps to run before the first evaluation. Useful if '
'you have stopped partway through a training cycle.')
FLAGS = parser.parse_args()
_EVAL_STEPS = 50000 // FLAGS.eval_batch_size
# Scale the learning rate linearly with the batch size. When the batch size is
# 256, the learning rate should be 0.1.
_INITIAL_LEARNING_RATE = 0.1 * FLAGS.train_batch_size / 256
_MOMENTUM = 0.9
_WEIGHT_DECAY = 1e-4
train_dataset = imagenet.get_split('train', FLAGS.data_dir)
eval_dataset = imagenet.get_split('validation', FLAGS.data_dir)
image_preprocessing_fn = vgg_preprocessing.preprocess_image
network = resnet_model.resnet_v2(resnet_size=FLAGS.resnet_size,
num_classes=train_dataset.num_classes)
batches_per_epoch = train_dataset.num_samples / FLAGS.train_batch_size
def input_fn(is_training):
"""Input function which provides a single batch for train or eval."""
batch_size = FLAGS.train_batch_size if is_training else FLAGS.eval_batch_size
dataset = train_dataset if is_training else eval_dataset
capacity_multiplier = 20 if is_training else 2
min_multiplier = 10 if is_training else 1
def main(_):
if not FLAGS.dataset_dir:
raise ValueError(
'You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = tf.train.get_or_create_global_step()
###################
# Prepare dataset #
###################
dataset = imagenet.get_split(FLAGS.split_name, FLAGS.dataset_dir)
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size)
[dataset_image, label] = provider.get(['image', 'label'])
dataset_image = preprocess_for_eval(dataset_image, IMAGE_SIZE,
IMAGE_SIZE)
dataset_images, labels = tf.train.batch(
[dataset_image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
########################################
# Define the model and input exampeles #
########################################
create_model(tf.placeholder(tf.float32, shape=dataset_images.shape))
input_images = get_input_images(dataset_images)
logits, _ = create_model(input_images, reuse=True)
if FLAGS.moving_average_decay > 0:
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, tf_global_step)
variables_to_restore = variable_averages.variables_to_restore(
slim.get_model_variables())
variables_to_restore[tf_global_step.op.name] = tf_global_step
else:
variables_to_restore = slim.get_variables_to_restore()
######################
# Define the metrics #
######################
predictions = tf.argmax(logits, 1)
labels = tf.squeeze(labels)
names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({
'Accuracy':
slim.metrics.streaming_accuracy(predictions, labels),
'Recall_5':
slim.metrics.streaming_sparse_recall_at_k(
logits, tf.reshape(labels, [-1, 1]), 5),
})
######################
# Run evaluation #
######################
if FLAGS.max_num_batches:
num_batches = FLAGS.max_num_batches
else:
# This ensures that we make a single pass over all of the data.
num_batches = math.ceil(dataset.num_samples /
float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
tf.logging.info('Evaluating %s' % checkpoint_path)
top1_accuracy, top5_accuracy = slim.evaluation.evaluate_once(
master=FLAGS.master,
checkpoint_path=checkpoint_path,
logdir=None,
summary_op=None,
num_evals=num_batches,
eval_op=list(names_to_updates.values()),
final_op=[
names_to_values['Accuracy'], names_to_values['Recall_5']
],
variables_to_restore=variables_to_restore)
print('Top1 Accuracy: ', top1_accuracy)
print('Top5 Accuracy: ', top5_accuracy)
def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = tf.train.get_or_create_global_step()
###################
# Prepare dataset #
###################
dataset = imagenet.get_split(FLAGS.split_name, FLAGS.dataset_dir)
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size)
[dataset_image, label] = provider.get(['image', 'label'])
dataset_image = preprocess_for_eval(dataset_image, IMAGE_SIZE, IMAGE_SIZE)
dataset_images, labels = tf.train.batch(
[dataset_image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
########################################
# Define the model and input exampeles #
########################################
create_model(tf.placeholder(tf.float32, shape=dataset_images.shape))
input_images = get_input_images(dataset_images)
logits, _ = create_model(input_images, reuse=True)
if FLAGS.moving_average_decay > 0:
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, tf_global_step)
variables_to_restore = variable_averages.variables_to_restore(
slim.get_model_variables())
variables_to_restore[tf_global_step.op.name] = tf_global_step
else:
variables_to_restore = slim.get_variables_to_restore()
######################
# Define the metrics #
######################
predictions = tf.argmax(logits, 1)
labels = tf.squeeze(labels)
names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({
'Accuracy': slim.metrics.streaming_accuracy(predictions, labels),
'Recall_5': slim.metrics.streaming_sparse_recall_at_k(
logits, tf.reshape(labels, [-1, 1]), 5),
})
######################
# Run evaluation #
######################
if FLAGS.max_num_batches:
num_batches = FLAGS.max_num_batches
else:
# This ensures that we make a single pass over all of the data.
num_batches = math.ceil(dataset.num_samples / float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
tf.logging.info('Evaluating %s' % checkpoint_path)
top1_accuracy, top5_accuracy = slim.evaluation.evaluate_once(
master=FLAGS.master,
checkpoint_path=checkpoint_path,
logdir=None,
summary_op=None,
num_evals=num_batches,
eval_op=list(names_to_updates.values()),
final_op=[names_to_values['Accuracy'], names_to_values['Recall_5']],
variables_to_restore=variables_to_restore)
print('Top1 Accuracy: ', top1_accuracy)
print('Top5 Accuracy: ', top5_accuracy)
def __call__(self, params):
"""Input function which provides a single batch for train or eval."""
batch_size = params['batch_size']
if FLAGS.use_data == 'real' and FLAGS.use_slim:
train_dataset = imagenet.get_split('train', FLAGS.data_dir)
eval_dataset = imagenet.get_split('validation', FLAGS.data_dir)
dataset = train_dataset if self.is_training else eval_dataset
capacity_multiplier = 20 if self.is_training else 2
min_multiplier = 10 if self.is_training else 1
provider = tf.contrib.slim.dataset_data_provider.DatasetDataProvider(
dataset=dataset,
num_readers=4,
common_queue_capacity=capacity_multiplier * batch_size,
common_queue_min=min_multiplier * batch_size)
image, label = provider.get(['image', 'label'])
image = vgg_preprocessing.preprocess_image(
image=image,
output_height=FLAGS.height,
output_width=FLAGS.width,
is_training=self.is_training,
resize_side_min=_RESIZE_SIDE_MIN,
resize_side_max=_RESIZE_SIDE_MAX)
images, labels = tf.train.batch(tensors=[image, label],
batch_size=batch_size,
num_threads=4,
capacity=5 * batch_size)
labels = tf.one_hot(labels, FLAGS.num_classes)
elif FLAGS.use_data == 'real' and not FLAGS.use_slim:
train_dataset = imagenet.get_split('train',
FLAGS.data_dir,
use_slim=False)
eval_dataset = imagenet.get_split('validation',
FLAGS.data_dir,
use_slim=False)
dataset = train_dataset if self.is_training else eval_dataset
decoder = imagenet.get_decoder()
def prefetch_dataset(filename):
size = (FLAGS.prefetch_size
if FLAGS.prefetch_size > 0 else batch_size)
return tf.contrib.data.TFRecordDataset(
filename,
buffer_size=FLAGS.dataset_reader_buffer_size).prefetch(
size)
if FLAGS.input_files_shuffle_capacity > 0:
dataset = dataset.shuffle(FLAGS.input_files_shuffle_capacity)
dataset = dataset.repeat()
if FLAGS.prefetch_enabled:
dataset = dataset.interleave(prefetch_dataset,
cycle_length=FLAGS.num_readers,
block_length=batch_size)
if FLAGS.input_shuffle_capacity > 0:
dataset = dataset.shuffle(FLAGS.input_shuffle_capacity)
def parser(serialized_example):
image, label = decoder.decode(serialized_example,
['image', 'label'])
image = vgg_preprocessing.preprocess_image(
image=image,
output_height=FLAGS.height,
output_width=FLAGS.width,
is_training=self.is_training,
resize_side_min=_RESIZE_SIDE_MIN,
resize_side_max=_RESIZE_SIDE_MAX)
return image, tf.one_hot(label, FLAGS.num_classes)
dataset = dataset.map(parser,
num_threads=FLAGS.map_threads,
output_buffer_size=batch_size)
dataset = dataset.batch(batch_size)
images, labels = dataset.make_one_shot_iterator().get_next()
# TODO(xiejw,saeta): Consider removing the sharding dimension below.
images.set_shape(images.get_shape().merge_with(
tf.TensorShape([batch_size, None, None, None])))
labels.set_shape(labels.get_shape().merge_with(
tf.TensorShape([batch_size, None])))
else:
images = tf.random_uniform(
[batch_size, FLAGS.height, FLAGS.width, 3],
minval=-1,
maxval=1)
labels = tf.random_uniform([batch_size],
minval=0,
maxval=999,
dtype=tf.int32)
labels = tf.one_hot(labels, FLAGS.num_classes)
output_transform_fn = TensorTranspose(batch_size, is_input=False)
images = output_transform_fn(images)
return images, labels
def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = tf.train.get_or_create_global_step()
###################
# Prepare dataset #
###################
dataset = imagenet.get_split(FLAGS.split_name, FLAGS.dataset_dir)
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size)
[dataset_image, label] = provider.get(['image', 'label'])
dataset_image = preprocess_for_eval(dataset_image, IMAGE_SIZE, IMAGE_SIZE)
dataset_images, labels = tf.train.batch(
[dataset_image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
########################################
# Define the model and input exampeles #
########################################
create_model(tf.placeholder(tf.float32, shape=dataset_images.shape))
input_images = get_input_images(dataset_images)
logits, _ = create_model(input_images, reuse=True)
if FLAGS.moving_average_decay is not None:
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, tf_global_step)
variables_to_restore = variable_averages.variables_to_restore(
slim.get_model_variables())
variables_to_restore[tf_global_step.op.name] = tf_global_step
else:
variables_to_restore = slim.get_variables_to_restore()
######################
# Define the metrics #
######################
predictions = tf.argmax(logits, 1)
labels = tf.squeeze(labels)
names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({
'Accuracy': slim.metrics.streaming_accuracy(predictions, labels),
'Recall_5': slim.metrics.streaming_sparse_recall_at_k(
logits, tf.reshape(labels, [-1, 1]), 5),
})
######################
# Run evaluation #
######################
if FLAGS.max_num_batches:
num_batches = FLAGS.max_num_batches
else:
# This ensures that we make a single pass over all of the data.
num_batches = math.ceil(dataset.num_samples / float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
tf.logging.info('Evaluating %s' % checkpoint_path)
sess = tf.Session()
saver = tf.train.Saver(variables_to_restore)
saver.restore(sess, checkpoint_path)
tf.logging.info('Checkpoint restored')
tf.train.start_queue_runners(sess=sess)
init = tf.global_variables_initializer()
sess.run(init)
init = tf.local_variables_initializer()
sess.run(init)
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
tf.logging.info('Start Profiling')
eval_results = sess.run(list(names_to_updates.values()),
options=options, run_metadata=run_metadata)
cg = CompGraph('adv_imagenet_models', run_metadata, tf.get_default_graph())
tf.logging.info('Profiling finished')
cg_tensor_dict = cg.get_tensors()
cg_sorted_keys = sorted(cg_tensor_dict.keys())
cg_sorted_items = []
for cg_key in cg_sorted_keys:
cg_sorted_items.append(tf.shape(cg_tensor_dict[cg_key]))
cg_sorted_shape = sess.run(cg_sorted_items)
cg.op_analysis(dict(zip(cg_sorted_keys, cg_sorted_shape)),
'adv_imagenet_models.pickle')
top1_accuracy = eval_results[0]
top5_accuracy = eval_results[1]
#top1_accuracy, top5_accuracy = slim.evaluation.evaluate_once(
# master=FLAGS.master,
# checkpoint_path=checkpoint_path,
# logdir=None,
# summary_op=None,
# num_evals=num_batches,
# eval_op=list(names_to_updates.values()),
# final_op=[names_to_values['Accuracy'], names_to_values['Recall_5']],
# variables_to_restore=variables_to_restore)
print('Top1 Accuracy: ', top1_accuracy)
print('Top5 Accuracy: ', top5_accuracy)
def __call__(self, params):
"""Input function which provides a single batch for train or eval."""
batch_size = params['batch_size']
if FLAGS.use_data == 'real':
if self.is_training:
dataset = imagenet.get_split('train',
FLAGS.data_dir,
use_slim=False)
else:
dataset = imagenet.get_split('validation',
FLAGS.data_dir,
use_slim=False)
decoder = imagenet.get_decoder()
# the set of operations that follow are based on guidelines
# discussed in new pipeline best usage presentation.
if FLAGS.initial_shuffle_buffer_size > 0:
dataset = dataset.shuffle(
buffer_size=FLAGS.initial_shuffle_buffer_size)
dataset = dataset.repeat()
# use interleave() and prefetch() to read many files concurrently
def prefetch_map_fn(filename):
return tf.contrib.data.TFRecordDataset(
filename,
buffer_size=FLAGS.prefetch_dataset_buffer_size).prefetch(
FLAGS.prefetch_size or batch_size)
if FLAGS.prefetch_enabled:
dataset = dataset.interleave(prefetch_map_fn,
cycle_length=FLAGS.cycle_length,
block_length=FLAGS.block_length
or batch_size)
if FLAGS.followup_shuffle_buffer_size > 0:
dataset = dataset.shuffle(
buffer_size=FLAGS.followup_shuffle_buffer_size)
# use num_parallel_calls to parallelize map()
def parser(serialized_example):
image, label = decoder.decode(serialized_example,
['image', 'label'])
image = vgg_preprocessing.preprocess_image(
image=image,
output_height=FLAGS.height,
output_width=FLAGS.width,
is_training=self.is_training,
resize_side_min=_RESIZE_SIDE_MIN,
resize_side_max=_RESIZE_SIDE_MAX)
return image, label
dataset = dataset.map(parser,
num_parallel_calls=FLAGS.num_parallel_calls,
output_buffer_size=batch_size)
dataset = dataset.batch(batch_size)
# use prefetch to overlap producer and consumer
dataset = dataset.prefetch(1)
images, labels = dataset.make_one_shot_iterator().get_next()
labels = tf.one_hot(labels, FLAGS.num_classes, dtype=tf.int32)
if FLAGS.input_layout == 'NHWC':
images.set_shape([batch_size, FLAGS.height, FLAGS.width, 3])
else:
images.set_shape([batch_size, 3, FLAGS.height, FLAGS.width])
labels.set_shape([batch_size, FLAGS.num_classes])
else:
if FLAGS.input_layout == 'NHWC':
images = tf.random_uniform(
[batch_size, FLAGS.height, FLAGS.width, 3],
minval=-1,
maxval=1)
else:
images = tf.random_uniform(
[batch_size, 3, FLAGS.height, FLAGS.width],
minval=-1,
maxval=1)
labels = tf.random_uniform([batch_size],
minval=0,
maxval=999,
dtype=tf.int32)
labels = tf.one_hot(labels, FLAGS.num_classes)
images = tensor_transform_fn(images, params['output_perm'])
return images, labels
split_name = 'train'
dataset_dir = <PATH_TO_TFSLIM_IMAGENET_TFRECORDS>
# Recommended to run multiple of these scripts in parallel
num_images = 4000 #(1-million images)/(250 parallel runs)
random_seed = args.seed #set random seed (different for each run)
im_shape = 224
slim = tf.contrib.slim
#build the network
nets, sess, metamer_layers = build_network.main()
# metamer_layers is a list of strings which are the keys of nets
layers_activations = [nets[layer] for layer in metamer_layers]
dataset = get_split(split_name, dataset_dir)
data_provider = slim.dataset_data_provider.DatasetDataProvider(dataset,
shuffle=True,
seed=random_seed)
image_raw, label = data_provider.get(['image', 'label'])
image = tf.expand_dims(image_center_crop(image_raw, im_shape=im_shape), 0)
#all of the losses. shape=(num_image_pairs, num_layers)
spearman_r = []
with slim.queues.QueueRunners(sess):
for i in range(num_images):
#use the first 2 images then update the images_list index
image1 = sess.run(image)
image2 = sess.run(image)
spearman_r_pair = []
def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = slim.get_or_create_global_step()
######################
# Select the eval dataset #
######################
assert FLAGS.dataset_name == 'imagenet'
dataset = imagenet.get_split(FLAGS.dataset_split_name, FLAGS.dataset_dir)
####################
# Select the model #
####################
networks_map = {
'mobilenet_v1': mobilenet_v1.mobilenet_v1,
'mobilenet_v1_075': mobilenet_v1.mobilenet_v1_075,
'mobilenet_v1_050': mobilenet_v1.mobilenet_v1_050,
'mobilenet_v1_025': mobilenet_v1.mobilenet_v1_025,
}
name = FLAGS.model_name
num_classes=dataset.num_classes
if name not in networks_map:
raise ValueError('Name of network unknown %s' % name)
def network_fn(images):
arg_scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False)
with slim.arg_scope(arg_scope):
return networks_map[name](images, num_classes, is_training=False)
##############################################################
# Create a dataset provider that loads data from the dataset #
##############################################################
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size)
[image, label] = provider.get(['image', 'label'])
#####################################
# Select the preprocessing function #
#####################################
image = preprocess_for_eval(image, FLAGS.eval_image_size, FLAGS.eval_image_size)
print(FLAGS.batch_size)
images, labels = tf.train.batch(
[image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
print(images.shape, labels.shape)
####################
# Define the model #
####################
logits, _ = network_fn(images)
variables_to_restore = slim.get_variables_to_restore()
predictions = tf.argmax(logits, 1)
labels = tf.squeeze(labels)
# Define the metrics:
names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({
'Accuracy': slim.metrics.streaming_accuracy(predictions, labels),
'Recall_5': slim.metrics.streaming_recall_at_k(
logits, labels, 5),
})
# Print the summaries to screen.
for name, value in names_to_values.items():
summary_name = 'eval/%s' % name
op = tf.summary.scalar(summary_name, value, collections=[])
op = tf.Print(op, [value], summary_name)
tf.add_to_collection(tf.GraphKeys.SUMMARIES, op)
num_batches = math.ceil(dataset.num_samples / float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
tf.logging.info('Evaluating %s' % checkpoint_path)
print(checkpoint_path)
print(FLAGS.eval_dir)
print(num_batches)
print(list(names_to_updates.values()))
print(variables_to_restore)
slim.evaluation.evaluate_once(master='', checkpoint_path=checkpoint_path, logdir=FLAGS.eval_dir, num_evals=num_batches, eval_op=list(names_to_updates.values()), variables_to_restore=variables_to_restore)
parser.add_argument(
'--first_cycle_steps', type=int, default=None,
help='The number of steps to run before the first evaluation. Useful if '
'you have stopped partway through a training cycle.')
FLAGS = parser.parse_args()
_EVAL_STEPS = 50000 // FLAGS.eval_batch_size
# Scale the learning rate linearly with the batch size. When the batch size is
# 256, the learning rate should be 0.1.
_INITIAL_LEARNING_RATE = 0.1 * FLAGS.train_batch_size / 256
_MOMENTUM = 0.9
_WEIGHT_DECAY = 1e-4
train_dataset = imagenet.get_split('train', FLAGS.data_dir)
eval_dataset = imagenet.get_split('validation', FLAGS.data_dir)
image_preprocessing_fn = vgg_preprocessing.preprocess_image
network = resnet_model.resnet_v2(
resnet_size=FLAGS.resnet_size, num_classes=train_dataset.num_classes)
batches_per_epoch = train_dataset.num_samples / FLAGS.train_batch_size
def input_fn(is_training):
"""Input function which provides a single batch for train or eval."""
batch_size = FLAGS.train_batch_size if is_training else FLAGS.eval_batch_size
dataset = train_dataset if is_training else eval_dataset
capacity_multiplier = 20 if is_training else 2
min_multiplier = 10 if is_training else 1