def dry_run_load(checkpoint_file, scope):
with tf.Graph().as_default():
x_input = tf.placeholder(tf.float32, shape=BATCH_SHAPE)
x_adv = x_input
with slim.arg_scope(inception.inception_v3_arg_scope()):
inception.inception_v3(x_input,
num_classes=NUM_CLASSES,
is_training=False,
scope=scope)
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
x_adv,
num_classes=NUM_CLASSES,
is_training=False,
reuse=True,
scope=scope)
saver = tf.train.Saver(slim.get_model_variables(scope=scope))
with tf.Session().as_default() as sess:
saver.restore(sess, checkpoint_file)
tf_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
print(len(tf_vars))
print(tf_vars[0])
def main(_):
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input, num_classes=num_classes, is_training=False)
predicted_labels = tf.argmax(end_points['Predictions'], 1)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master)
with tf.train.MonitoredSession(session_creator=session_creator) as sess:
with tf.gfile.Open(FLAGS.output_file, 'w') as out_file:
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
labels = sess.run(predicted_labels, feed_dict={x_input: images})
for filename, label in zip(filenames, labels):
out_file.write('{0},{1}\n'.format(filename, label))
def predict_inception(file_path):
x = tf.placeholder(tf.float32, shape=[None, 299, 299, 3], name='x')
with slim.arg_scope(inception.inception_v3_arg_scope()):
# (logits, 層の情報の集合)
logits, _ = inception.inception_v3(x,
num_classes=1001,
is_training=False)
softmax = tf.nn.softmax(logits)
top_labels = tf.nn.top_k(logits, 5)[1]
# predictions = end_points['Predictions']
saver = tf.train.Saver()
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
saver.restore(sess, "inception_v3_2016_08_28/inception_v3.ckpt")
img = load_image(file_path).eval()[np.newaxis, :, :, :]
print(img.shape)
print(img.dtype)
pred_i = top_labels.eval(feed_dict={x: img}).flatten()
pred_logits = softmax.eval(feed_dict={x: img}).flatten()[pred_i]
return [(CLASS_NAME_DICT[i], p) for i, p in zip(pred_i, pred_logits)]
def main(_):
"""Run the sample defense"""
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
nb_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input, num_classes=nb_classes, is_training=False
)
predicted_labels = tf.argmax(end_points["Predictions"], 1)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master,
)
with tf.train.MonitoredSession(session_creator=session_creator) as sess:
with tf.gfile.Open(FLAGS.output_file, "w") as out_file:
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
labels = sess.run(predicted_labels, feed_dict={x_input: images})
for filename, label in zip(filenames, labels):
out_file.write("{0},{1}\n".format(filename, label))
def conv_tower_fn(self, images, is_training=True, reuse=None):
"""Computes convolutional features using the InceptionV3 model.
Args:
images: A tensor of shape [batch_size, height, width, channels].
is_training: whether is training or not.
reuse: whether or not the network and its variables should be reused. To
be able to reuse 'scope' must be given.
Returns:
A tensor of shape [batch_size, OH, OW, N], where OWxOH is resolution of
output feature map and N is number of output features (depends on the
network architecture).
"""
mparams = self._mparams["conv_tower_fn"]
logging.debug("Using final_endpoint=%s", mparams.final_endpoint)
with tf.variable_scope("conv_tower_fn/INCE"):
if reuse:
tf.get_variable_scope().reuse_variables()
with slim.arg_scope(inception.inception_v3_arg_scope()):
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
net, _ = inception.inception_v3_base(
images, final_endpoint=mparams.final_endpoint)
return net
def inception_v3(inputs,
num_classes=1000,
is_training=True,
dropout_keep_prob=0.8,
spatial_squeeze=True,
scope='InceptionV3'):
with slim.arg_scope(inception.inception_v3_arg_scope(
batch_norm_decay=BATCH_NORM_DECAY,
batch_norm_epsilon=BATCH_NORM_EPSILON)):
with slim.arg_scope(
[slim.conv2d, slim.fully_connected, slim.batch_norm],trainable=True):
with slim.arg_scope(
[slim.batch_norm, slim.dropout], is_training=is_training):
net, _ = inception.inception_v3_base(
inputs,
scope=scope)
with tf.variable_scope('Logits'):
kernel_size = _reduced_kernel_size_for_small_input(net, [8, 8])
net = tf.contrib.layers.avg_pool2d(
net,
kernel_size,
padding='VALID')
if is_training:
net = tf.contrib.layers.dropout(
net, keep_prob=dropout_keep_prob)
logits = tf.contrib.layers.conv2d(
net,
num_classes, [1, 1],
activation_fn=None,
normalizer_fn=None)
if spatial_squeeze:
logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
return logits
def load(self, **kwargs):
session = kwargs["session"]
assert isinstance(session, tf.Session)
x_input = tf.placeholder(self.x_dtype, shape=(None, ) + self.x_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
inception.inception_v3(x_input,
num_classes=self.n_class,
is_training=False,
reuse=tf.AUTO_REUSE)
model_path = get_model_path('ens4_adv_inception_v3')
if not os.path.exists(model_path):
os.makedirs(model_path)
urllib.request.urlretrieve(
'http://download.tensorflow.org/models/ens4_adv_inception_v3_2017_08_18.tar.gz',
os.path.join(model_path,
'ens4_adv_inception_v3_2017_08_18.tar.gz'),
show_progress)
tar = tarfile.open(
os.path.join(model_path,
'ens4_adv_inception_v3_2017_08_18.tar.gz'))
file_names = tar.getnames()
for file_name in file_names:
tar.extract(file_name, model_path)
saver = tf.train.Saver(slim.get_model_variables(scope='InceptionV3'))
saver.restore(session,
os.path.join(model_path, 'ens4_adv_inception_v3.ckpt'))
def create_model(x, reuse=None):
"""Create model graph.
Args:
x: input images
reuse: reuse parameter which will be passed to underlying variable scopes.
Should be None first call and True every subsequent call.
Returns:
(logits, end_points) - tuple of model logits and enpoints
Raises:
ValueError: if model type specified by --model_name flag is invalid.
"""
if FLAGS.model_name == 'inception_v3':
with slim.arg_scope(inception.inception_v3_arg_scope()):
return inception.inception_v3(x,
num_classes=NUM_CLASSES,
is_training=False,
reuse=reuse)
elif FLAGS.model_name == 'inception_resnet_v2':
with slim.arg_scope(
inception_resnet_v2.inception_resnet_v2_arg_scope()):
return inception_resnet_v2.inception_resnet_v2(
x, num_classes=NUM_CLASSES, is_training=False, reuse=reuse)
else:
raise ValueError('Invalid model name: %s' % (FLAGS.model_name))
def pred(full_image_path):
images = np.zeros(importer.batch_shape, np.float32)
image = imread(full_image_path, mode='RGB').astype(
np.float32) * 2.0 / 255.0 - 1.0
images[0, :, :, :] = image
graph_eval = tf.Graph()
with graph_eval.as_default():
x_input = tf.placeholder(tf.float32, shape=importer.batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input, num_classes=importer.num_classes, is_training=False)
predicted_labels = tf.argmax(end_points['Predictions'], 1)
session_creator = tf.train.ChiefSessionCreator(
checkpoint_filename_with_path=importer.checkpoint_path,
master=importer.tensorflow_master)
#TODO: I run out of memory when loading all images to the memory,
# Make one image prediction in each iteration
#image_iterator = importer.load_images_generator(importer.input_dir_images, importer.batch_shape)
with tf.train.MonitoredSession(
session_creator=session_creator) as sess:
filename = os.path.basename(full_image_path)
true_classes = importer.filename_to_class([filename])
predicted_classes = sess.run(predicted_labels,
feed_dict={x_input: images})
print("True class: {}, predicted: {}".format(
true_classes, predicted_classes))
def inference(inputs, is_training=True):
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(inputs,
num_classes=1000,
is_training=is_training)
logits = tf.nn.sigmoid(logits)
return logits
def print_accuracy(images,
true_labels,
jpeg_reconstruct=False,
jpeg_quality=23):
tf.reset_default_graph()
with tf.Graph().as_default(): # Prepare graph
x_input = tf.placeholder(tf.float32, shape=[100, 299, 299, 3])
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(x_input,
num_classes=1001,
is_training=False)
predicted_labels = tf.argmax(end_points['Predictions'], 1)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path='./inception-v3/inception_v3.ckpt')
with tf.train.MonitoredSession(
session_creator=session_creator) as sess:
if jpeg_reconstruct:
images = (images + 1.0) / 2.0
images = jpeg(images, quality=jpeg_quality)
images = images * 2.0 - 1.0
labels = np.zeros(1000)
for i in range(10):
labels[i * 100:(i + 1) * 100] = sess.run(
predicted_labels,
feed_dict={x_input: images[i * 100:(i + 1) * 100, :]})
accuracy = np.sum(labels == true_labels) / len(labels)
return accuracy
def graph(x, y, i, x_max, x_min, grad):
eps = 2.0 * FLAGS.max_epsilon / 255.0
eps_iter = 2.0 / 255.0
num_classes = 1001
momentum = FLAGS.momentum
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(input_diversity(x),
num_classes=num_classes,
is_training=False)
pred = tf.argmax(end_points['Predictions'], 1)
# here is the way to stable gt lables
first_round = tf.cast(tf.equal(i, 0), tf.int64)
y = first_round * pred + (1 - first_round) * y
one_hot = tf.one_hot(y, num_classes)
cross_entropy = tf.losses.softmax_cross_entropy(one_hot, logits)
# compute the gradient info
noise = tf.gradients(cross_entropy, x)[0]
noise = noise / tf.reduce_mean(tf.abs(noise), [1, 2, 3], keep_dims=True)
# accumulate the gradient
noise = momentum * grad + noise
x = x + eps_iter * tf.sign(noise)
x = tf.clip_by_value(x, x_min, x_max)
i = tf.add(i, 1)
return x, y, i, x_max, x_min, noise
def conv_tower_fn(self, images, is_training=True, reuse=None):
"""Computes convolutional features using the InceptionV3 model.
Args:
images: A tensor of shape [batch_size, height, width, channels].
is_training: whether is training or not.
reuse: whether or not the network and its variables should be reused. To
be able to reuse 'scope' must be given.
Returns:
A tensor of shape [batch_size, OH, OW, N], where OWxOH is resolution of
output feature map and N is number of output features (depends on the
network architecture).
"""
mparams = self._mparams['conv_tower_fn']
logging.debug('Using final_endpoint=%s', mparams.final_endpoint)
with tf.variable_scope('conv_tower_fn/INCE'):
if reuse:
tf.get_variable_scope().reuse_variables()
with slim.arg_scope(inception.inception_v3_arg_scope()):
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
net, _ = inception.inception_v3_base(
images, final_endpoint=mparams.final_endpoint)
return net
def build_model(model_name, inputs, num_classes, is_training, dropout_keep_prob):
use_fcn = False
if model_name.find('fcn') >= 0:
use_fcn = True
model_base_name = model_name[0:-4]
else:
model_base_name = model_name
if model_base_name == 'vgg16':
net = vgg16_base(inputs)
elif model_base_name == 'inception_v1':
with slim.arg_scope(inception.inception_v1_arg_scope()):
net, _ = inception.inception_v1_base(inputs)
elif model_base_name == 'inception_v2':
with slim.arg_scope(inception.inception_v2_arg_scope()):
net, _ = inception.inception_v2_base(inputs)
elif model_base_name == 'inception_v3':
with slim.arg_scope(inception.inception_v3_arg_scope()):
net, _ = inception.inception_v3_base(inputs)
else:
raise Exception('model {} is not existed'.format(model_name))
with tf.variable_scope('not_pretrained'):
if use_fcn:
net = fully_convolutional_networks(net, num_classes, is_training, dropout_keep_prob)
else:
net = fully_connected_networks(net, num_classes, is_training, dropout_keep_prob)
return net
def __init__(self, sess, dim=299):
self.batch_shape = [16, dim, dim, 3]
self._num_classes = 1001
self._scope = 'InceptionV3'
self._weights_file = './Weights/inception_v3.ckpt'
output_layer = 'Conv2d_1a_3x3'
#
# network inputs
#
self.x_tf = tf.placeholder(tf.float32, shape=self.batch_shape)
#
# network outputs
#
with slim.arg_scope(inception.inception_v3_arg_scope()):
with arg_scope([layers_lib.batch_norm, layers_lib.dropout], is_training=False): # we truncate before these layers, so this is not really necessary...
net, endpoints = inception.inception_v3_base(self.x_tf, final_endpoint=output_layer, scope=self._scope)
self.output = endpoints[output_layer]
#
# load weights
#
saver = tf.train.Saver(slim.get_model_variables(scope=self._scope))
saver.restore(sess, self._weights_file)
def main(_):
# Images for inception classifier are normalized to be in [-1, 1] interval,
# eps is a difference between pixels so it should be in [0, 2] interval.
# Renormalizing epsilon from [0, 255] to [0, 2].
eps = 2.0 * FLAGS.max_epsilon / 255.0
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
nb_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
all_images_taget_class = load_target_class(FLAGS.input_dir)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(x_input,
num_classes=nb_classes,
is_training=False)
target_class_input = tf.placeholder(tf.int32, shape=[FLAGS.batch_size])
one_hot_target_class = tf.one_hot(target_class_input, nb_classes)
cross_entropy = tf.losses.softmax_cross_entropy(one_hot_target_class,
logits,
label_smoothing=0.1,
weights=1.0)
cross_entropy += tf.losses.softmax_cross_entropy(
one_hot_target_class,
end_points["AuxLogits"],
label_smoothing=0.1,
weights=0.4,
)
x_adv = x_input - eps * tf.sign(
tf.gradients(cross_entropy, x_input)[0])
x_adv = tf.clip_by_value(x_adv, -1.0, 1.0)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master,
)
with tf.train.MonitoredSession(
session_creator=session_creator) as sess:
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
target_class_for_batch = [
all_images_taget_class[n] for n in filenames
] + [0] * (FLAGS.batch_size - len(filenames))
adv_images = sess.run(
x_adv,
feed_dict={
x_input: images,
target_class_input: target_class_for_batch,
},
)
save_images(adv_images, filenames, FLAGS.output_dir)
def build_single_inceptionv3(train_tfdata, is_train, dropout_keep_prob, reduce_dim = False):
train_tfdata_resize = tf.image.resize_images(train_tfdata, (299, 299))
with slim.arg_scope(inception.inception_v3_arg_scope()):
identity, end_points = inception.inception_v3(train_tfdata_resize, dropout_keep_prob = dropout_keep_prob, is_training=is_train)
feature = slim.flatten(end_points['Mixed_7c'])
if reduce_dim:
feature = slim.fully_connected(feature, 256, scope='feat')
return identity, feature
def __init__(self, num_classes, x_input):
self.num_classes = num_classes
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input,
num_classes=importer.num_classes,
is_training=False,
reuse=False)
def testModelHasExpectedNumberOfParameters(self):
batch_size = 5
height, width = 299, 299
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(inception.inception_v3_arg_scope()):
inception.inception_v3_base(inputs)
total_params, _ = slim.model_analyzer.analyze_vars(slim.get_model_variables())
self.assertAlmostEqual(21802784, total_params)
def testModelHasExpectedNumberOfParameters(self):
batch_size = 5
height, width = 299, 299
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(inception.inception_v3_arg_scope()):
inception.inception_v3_base(inputs)
total_params, _ = slim.model_analyzer.analyze_vars(
slim.get_model_variables())
self.assertAlmostEqual(21802784, total_params)
def conv_tower_fn(self,images, is_training = True, reuse = None):
mparams = self._mparams['conv_tower_fn']
logging.debug('Using final_endpoint=%s',mparams.final_endpoint)
if reuse:
tf.get_variable_scope().reuse_variables()
with slim.arg_scope(inception.inception_v3_arg_scope()): #用slim.arg_scope设置默认参数，但是，设置参数需要用于被@add_arg_scope修饰过的参数，见源码
with slim.arg_scope([slim.batch_norm,slim.dropout],is_training=is_training):
net,_ = inception.inception_v3_base(images,final_endpoint=mparams.final_endpoint)
return net
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
x_input, num_classes=self.num_classes, is_training=False, reuse=tf.AUTO_REUSE, scope=self.scope)
self.built = True
return logits, end_points
def __call__(self, inputs, training):
with slim.arg_scope(inception.inception_v3_arg_scope()):
inputs = inputs / 255. * 2. - 1.
self.inputs = inputs = tf.image.resize_images(inputs, (299, 299))
_, end_points = inception.inception_v3(
inputs, num_classes=self.num_classes, is_training=training)
logits = end_points["Logits"]
if self.mapping:
logits = tf.gather(logits, self.label_map, axis=-1)
return logits
def init_model(self):
if self.initialized:
""" Model has already been built"""
return
input_node = tf.placeholder(tf.float32, shape=self.input_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
input_node, num_classes=self.num_classes, is_training=False, dropout_keep_prob=1.0)
self.saver = tf.train.Saver(slim.get_model_variables(scope='InceptionV3'))
self.initialized = True
def build(self,
inputs,
input_pixel_size,
is_training,
scope='img_inception'):
"""Inception for BEV feature extraction
Args:
inputs: a tensor of size [batch_size, height, width, channels].
input_pixel_size: size of the input (H x W)
is_training: True for training, False fo validation/testing.
scope: Optional scope for the variables.
Returns:
The net, a rank-4 tensor of size [batch, height_out, width_out,
channels_out] and end_points dict.
"""
inception_config = self.config
with tf.variable_scope(scope, 'img_inception', [inputs]) as scope:
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
if inception_config.inception_v == 'inception_v1':
with slim.arg_scope(inception.inception_v1_arg_scope()):
net, end_points = inception.inception_v1_base(
inputs, scope=scope)
elif inception_config.inception_v == 'inception_v2':
with slim.arg_scope(inception.inception_v2_arg_scope()):
net, end_points = inception.inception_v2_base(
inputs, scope=scope)
elif inception_config.inception_v == 'inception_v3':
with slim.arg_scope(inception.inception_v3_arg_scope()):
net, end_points = inception.inception_v3_base(
inputs, scope=scope)
else:
raise ValueError('Invalid Inception version {},'.format(
inception_config.inception_v))
with tf.variable_scope('upsampling'):
# This feature extractor downsamples the input by a factor
# of 32
downsampling_factor = 32
downsampled_shape = input_pixel_size / downsampling_factor
upsampled_shape = downsampled_shape * \
inception_config.upsampling_multiplier
feature_maps_out = tf.image.resize_bilinear(
net, upsampled_shape)
return feature_maps_out, end_points
def get_logits_prob(self, batch_input):
"""
Prediction from the model on a single batch.
:param batch_input: the input batch. Must be from size [?, 299, 299, 3]
:return: the logits and probabilities for the batch
"""
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, _ = inception.inception_v3(batch_input, num_classes=1001, is_training=False)
logits = logits[:, 1:]
probs = tf.squeeze(tf.nn.softmax(logits))
return logits, probs
def main(_):
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
layer_names = FLAGS.feature_layer.split(',')
output_databases = FLAGS.output_database.split(',')
poolings = FLAGS.feature_pool.split(',')
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(x_input,
num_classes=num_classes,
is_training=False)
# feature_layer = tf.squeeze(end_points['PreLogits'])
# feature_layer = slim.avg_pool2d(end_points[FLAGS.feature_layer], (8, 8))
# Global Pool
feature_layers = []
if 'avg_pool' in poolings:
feature_layers += [
tf.reduce_mean(end_points[l], axis=(1, 2)) for l in layer_names
]
if 'max_pool' in poolings:
feature_layers += [
tf.reduce_max(end_points[l], axis=(1, 2)) for l in layer_names
]
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master)
envs = [
lmdb.open(out_db, map_size=1e12) for out_db in output_databases
]
with tf.train.MonitoredSession(
session_creator=session_creator) as sess:
for filenames, images in tqdm(
load_images(FLAGS.input_dir, batch_shape)):
list_of_features = sess.run(feature_layers,
feed_dict={x_input: images})
for env, features in zip(envs, list_of_features):
with env.begin(write=True) as txn:
for filename, feature in zip(filenames, features):
txn.put(filename, feature)
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input, num_classes=self.num_classes, is_training=False,
reuse=reuse)
self.built = True
output = end_points['Predictions']
probs = output.op.inputs[0]
return probs
def fprop(self, x, **kwargs):
reuse = True if self._built else None
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(x, num_classes=self.n_classes,
is_training=False, reuse=reuse)
self._built = True
output = end_points['Predictions']
# Strip off the extra reshape op at the output
probs = output.op.inputs[0]
end_points['logits'] = logits
end_points['probs'] = probs
return end_points
def Eval(x_img, y):
input_image = 2 * x_img / 255 - 1
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits_inception_v3, end_points_inception_v3 = inception.inception_v3(
input_image,
num_classes=110,
is_training=False,
scope='InceptionV3',
reuse=tf.AUTO_REUSE)
inc_label = tf.argmax(end_points_inception_v3['Predictions'][0], -1)
y_inc = end_points_inception_v3['Predictions'][0][y[0]]
return inc_label, y_inc
def setup_model():
# Create graph
X = tf.placeholder(tf.float32, shape=[None, height, width, channels])
with slim.arg_scope(inception.inception_v3_arg_scope()):
net, end_points = inception.inception_v3(X,
num_classes=1001,
is_training=False)
saver = tf.train.Saver()
return saver
def run(name, image_size, num_classes):
with tf.Graph().as_default():
image = tf.placeholder("float", [1, image_size, image_size, 3], name="input")
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, _ = inception.inception_v3(image, num_classes, is_training=False, spatial_squeeze=False)
probabilities = tf.nn.softmax(logits)
init_fn = slim.assign_from_checkpoint_fn('inception_v3.ckpt', slim.get_model_variables('InceptionV3'))
with tf.Session() as sess:
init_fn(sess)
saver = tf.train.Saver(tf.global_variables())
saver.save(sess, "output/"+name)
def get_probs(self, x_input):
"""Constructs model and return probabilities for given input."""
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input,
num_classes=importer.num_classes,
is_training=False,
reuse=True)
output = end_points['Predictions']
probs = output.op.inputs[0]
return probs
def __call__(self, input_node):
"""
input_node: should be a place holder passing the input image whose shape =[1,299,299,3] and values are
in the [0,1] range.
"""
normalized_input = input_node * 2.0 - 1.0
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
normalized_input, num_classes=self.num_classes, is_training=False, dropout_keep_prob=1.0, reuse=True)
predictions_node = end_points['Predictions']
output_node = tf.argmax(predictions_node, axis=1)
return logits, output_node
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
with slim.arg_scope(inception.inception_v3_arg_scope()):
_, end_points = inception.inception_v3(
x_input,
num_classes=self.num_classes,
is_training=False,
reuse=True)
output = end_points['Logits']
logits = output.op.inputs[0]
return logits
def run(name, image_size, num_classes):
with tf.Graph().as_default():
image = tf.placeholder("float", [1, image_size, image_size, 3], name="input")
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, _ = inception.inception_v3(image, num_classes, is_training=False, spatial_squeeze=False)
probabilities = tf.nn.softmax(logits)
init_fn = slim.assign_from_checkpoint_fn('inception_v3.ckpt', slim.get_model_variables('InceptionV3'))
with tf.Session() as sess:
init_fn(sess)
saver = tf.train.Saver(tf.global_variables())
saver.save(sess, "output/"+name)
def predict(self,preprocessed_inputs):
"""
Runs inference on model
Args:
preprocessed_inputs: processed batch to go to model
Returns:
pre_logits: layer right before the logits
"""
with slim.arg_scope(inception.inception_v3_arg_scope()):
_,end_points = inception.inception_v3(
preprocessed_inputs,num_classes=1001,is_training=self._is_training,reuse=self._reuse)
return end_points['PreLogits']
def main(_):
# Images for inception classifier are normalized to be in [-1, 1] interval,
# eps is a difference between pixels so it should be in [0, 2] interval.
# Renormalizing epsilon from [0, 255] to [0, 2].
eps = 2.0 * FLAGS.max_epsilon / 255.0
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
all_images_taget_class = load_target_class(FLAGS.input_dir)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
x_input, num_classes=num_classes, is_training=False)
target_class_input = tf.placeholder(tf.int32, shape=[FLAGS.batch_size])
one_hot_target_class = tf.one_hot(target_class_input, num_classes)
cross_entropy = tf.losses.softmax_cross_entropy(one_hot_target_class,
logits,
label_smoothing=0.1,
weights=1.0)
cross_entropy += tf.losses.softmax_cross_entropy(one_hot_target_class,
end_points['AuxLogits'],
label_smoothing=0.1,
weights=0.4)
x_adv = x_input - eps * tf.sign(tf.gradients(cross_entropy, x_input)[0])
x_adv = tf.clip_by_value(x_adv, -1.0, 1.0)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master)
with tf.train.MonitoredSession(session_creator=session_creator) as sess:
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
target_class_for_batch = (
[all_images_taget_class[n] for n in filenames]
+ [0] * (FLAGS.batch_size - len(filenames)))
adv_images = sess.run(x_adv,
feed_dict={
x_input: images,
target_class_input: target_class_for_batch
})
save_images(adv_images, filenames, FLAGS.output_dir)
def __call__(self, x_input, return_logits=False):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(inception.inception_v3_arg_scope()):
# Inception preprocessing uses [-1, 1]-scaled input.
x_input = x_input * 2.0 - 1.0
_, end_points = inception.inception_v3(
x_input, num_classes=self.num_classes, is_training=False,
reuse=reuse)
self.built = True
self.logits = end_points['Logits']
# Strip off the extra reshape op at the output
self.probs = end_points['Predictions'].op.inputs[0]
if return_logits:
return self.logits
else:
return self.probs
def create_model(x, reuse=None):
"""Create model graph.
Args:
x: input images
reuse: reuse parameter which will be passed to underlying variable scopes.
Should be None first call and True every subsequent call.
Returns:
(logits, end_points) - tuple of model logits and enpoints
Raises:
ValueError: if model type specified by --model_name flag is invalid.
"""
if FLAGS.model_name == 'inception_v3':
with slim.arg_scope(inception.inception_v3_arg_scope()):
return inception.inception_v3(
x, num_classes=NUM_CLASSES, is_training=False, reuse=reuse)
elif FLAGS.model_name == 'inception_resnet_v2':
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
return inception_resnet_v2.inception_resnet_v2(
x, num_classes=NUM_CLASSES, is_training=False, reuse=reuse)
else:
raise ValueError('Invalid model name: %s' % (FLAGS.model_name))
