def create_model(self,
images,
num_classes,
weight_decay=0.00004,
scope='Flowers',
reuse=None,
is_training=True):
"""Creates a base part of the Model (no gradients, no loss, no summaries).
Args:
images: A tensor of size [batch_size, height, width, channels].
num_classes: The number of predicted classes.
scope: Optional variable_scope.
reuse: Whether or not the network or its variables should be reused. To
be able to reuse 'scope' must be given.
is_training: Whether is training or not.
Returns:
A named tuple OutputEndpoints.
"""
with tf.variable_scope(scope, [images], reuse=reuse):
with slim.arg_scope(inception_v3.inception_v3_arg_scope(weight_decay=weight_decay)):
logits, endpoints = inception_v3.inception_v3(
inputs = images,
num_classes=num_classes,
is_training=is_training)
return logits, endpoints
def graph_small(x, target_class_input, i, x_max, x_min, grad):
eps = 2.0 * FLAGS.max_epsilon / 255.0
alpha = eps / 28
momentum = FLAGS.momentum
num_classes = 1001
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_ensadv_res_v2, end_points_ensadv_res_v2 = inception_resnet_v2.inception_resnet_v2(
x,
num_classes=num_classes,
is_training=False,
scope='EnsAdvInceptionResnetV2')
one_hot_target_class = tf.one_hot(target_class_input, num_classes)
logits = (logits_v3 + 2 * logits_ensadv_res_v2) / 3
auxlogits = (end_points_v3['AuxLogits'] +
2 * end_points_ensadv_res_v2['AuxLogits']) / 3
cross_entropy = tf.losses.softmax_cross_entropy(one_hot_target_class,
logits,
label_smoothing=0.0,
weights=1.0)
cross_entropy += tf.losses.softmax_cross_entropy(one_hot_target_class,
auxlogits,
label_smoothing=0.0,
weights=0.4)
noise = tf.gradients(cross_entropy, x)[0]
noise = noise / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise, [FLAGS.batch_size, -1]),
axis=1), [FLAGS.batch_size, 1, 1, 1])
noise = momentum * grad + noise
noise = noise / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise, [FLAGS.batch_size, -1]),
axis=1), [FLAGS.batch_size, 1, 1, 1])
x = x - alpha * tf.clip_by_value(tf.round(noise), -2, 2)
x = tf.clip_by_value(x, x_min, x_max)
i = tf.add(i, 1)
return x, target_class_input, i, x_max, x_min, noise
def modified_inception_v3(img, local, sex, age, reuse=None, trainable=True):
with tf.variable_scope("Logits", reuse=reuse) as scope:
with slim.arg_scope([slim.fully_connected],
scope="Logits",
reuse=reuse,
trainable=trainable):
local_fc = slim.fully_connected(local, 2048, scope="Local_FC")
local_logits = slim.fully_connected(local_fc,
7,
scope="Local_Logtis",
activation_fn=None,
normalizer_fn=None)
sex_fc = slim.fully_connected(sex, 2048, scope="Sex_FC")
sex_logits = slim.fully_connected(sex_fc,
7,
scope="Sex_Logtis",
activation_fn=None,
normalizer_fn=None)
age_fc = slim.fully_connected(age, 2048, scope="Age_FC")
age_logits = slim.fully_connected(age_fc,
7,
scope="Age_Logtis",
activation_fn=None,
normalizer_fn=None)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits, end_points = inception_v3.inception_v3(img,
num_classes=7,
create_aux_logits=False,
is_training=trainable,
reuse=reuse)
with tf.variable_scope(scope, auxiliary_name_scope=False) as scope1:
with tf.name_scope(scope1.original_name_scope) as scope2:
with slim.arg_scope([], scope=scope2, reuse=reuse):
logits = tf.add(tf.add(tf.add(local_logits, sex_logits),
age_logits),
logits,
name="Logits")
pred = slim.softmax(logits, scope="Prediction")
return logits, pred, end_points
def __init__(self, checkpoint_path):
self.sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True))
with tf.device("/gpu:0"):
self.inputs = tf.placeholder(tf.float32,
(None, image_size, image_size, 3))
preprocessed_images = tf.map_fn(
lambda input_img: inception_preprocessing.preprocess_image(
input_img, image_size, image_size, is_training=False),
self.inputs)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits, _ = inception_v3.inception_v3(preprocessed_images,
num_classes=1001,
is_training=False)
self.all_probabilities = tf.nn.softmax(logits)
init_fn = slim.assign_from_checkpoint_fn(
checkpoint_path, slim.get_model_variables("InceptionV3"))
init_fn(self.sess)
def graph(x, y, i, x_max, x_min, accum_s, accum_g):
eps = 2.0 * FLAGS.max_epsilon / 255.0
num_iter = FLAGS.num_iter
alpha = eps / num_iter
# momentum = FLAGS.momentum
num_classes = 1001
beta_1 = FLAGS.beta_1
beta_2 = FLAGS.beta_2
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x, num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE)
pred = tf.argmax(end_points_v3['Predictions'], 1)
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_v3)
grad = tf.gradients(cross_entropy, x)[0]
grad = grad / tf.reduce_mean(tf.abs(grad), [1, 2, 3], keep_dims=True)
accum_g = grad * (1 - beta_1) + accum_g * beta_1
accum_s = tf.multiply(grad, grad) * (1 - beta_2) + accum_s * beta_2
accum_g_hat = tf.divide(accum_g,
(1 - tf.pow(beta_1, tf.cast(i + 1, tf.float32))))
accum_s_hat = tf.divide(accum_s,
(1 - tf.pow(beta_2, tf.cast(i + 1, tf.float32))))
x = x + tf.multiply(tf.divide(alpha, tf.add(tf.sqrt(accum_s_hat), 1e-6)),
tf.sign(accum_g_hat))
x = tf.clip_by_value(x, x_min, x_max)
i = tf.add(i, 1)
return x, y, i, x_max, x_min, accum_s, accum_g
def get_features_vector(url):
try:
with tf.Graph().as_default():
image_string = urllib.urlopen(url).read()
image = tf.image.decode_jpeg(image_string, channels=3)
processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False)
processed_images = tf.expand_dims(processed_image, 0)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits, _ = inception_v3.inception_v3(processed_images, num_classes=1001, is_training=False)
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(checkpoints_dir, 'inception_v3.ckpt'),
slim.get_model_variables('InceptionV3')
)
with tf.Session() as sess:
init_fn(sess)
np_logits = sess.run([logits])
return np_logits
except Exception as e:
print(e)
def __init__(self):
batch_shape = [None, 299, 299, 3]
self.x_input = tf.placeholder(tf.float32, shape=batch_shape)
self.target_label = tf.placeholder(tf.int32, shape=[None])
target_onehot = tf.one_hot(self.target_label, 1001)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits, end_points = inception_v3.inception_v3(self.x_input,
num_classes=1001,
is_training=False)
self.predicted_labels = tf.argmax(end_points['Predictions'], 1)
#logits -= tf.reduce_min(logits)
#real = tf.reduce_max(logits * target_onehot, 1)
#other = tf.reduce_max(logits * (1 - target_onehot), 1)
#self.loss = other - real
self.loss = tf.nn.softmax_cross_entropy_with_logits(
labels=target_onehot, logits=logits)
self.grad = 2 * tf.gradients(self.loss, self.x_input)[0]
saver = tf.train.Saver(slim.get_model_variables(scope='InceptionV3'))
self.sess = tf.get_default_session()
saver.restore(self.sess, FLAGS.checkpoint_path)
def Grad(x, y, j, grad):
eps = 2.0 * FLAGS.max_epsilon / 255.0
num_iter = FLAGS.num_iter
alpha = eps / num_iter
momentum = FLAGS.momentum
num_classes = 1001
std = FLAGS.std
x = x + tf.random_normal(
shape=x.get_shape(), mean=0.0, stddev=std, dtype=tf.float32)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x, num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE)
pred = tf.argmax(end_points_v3['Predictions'], 1)
one_hot = tf.one_hot(y, num_classes)
cross_entropy = tf.losses.softmax_cross_entropy(one_hot, logits_v3)
noise = tf.gradients(cross_entropy, x)[0]
noise = grad + tf.sign(noise)
j = tf.add(j, 1)
return x, y, j, noise
def model(inputs, tag, num_class, is_training, regular=0.0001):
net = mean_image_subtraction(inputs)
if tag == 0:
return le_net(net, num_class, is_training, regular)
if tag == 1:
return vgg.vgg_16(net, num_classes=num_class,
is_training=is_training)[0]
if tag == 2:
with slim.arg_scope(resnet_v1.resnet_arg_scope()):
logits, end_points = resnet_v1.resnet_v1_50(
net,
num_classes=num_class,
is_training=is_training,
scope='resnet_v1_50')
return tf.squeeze(logits, [1, 2], name='SpatialSqueeze')
if tag == 3:
return inception_v3.inception_v3(net,
num_classes=num_class,
is_training=is_training,
scope='inception_v3')[0]
if tag == 4:
return inception_resnet_v2.inception_resnet_v2(
net, num_class, True, scope='incep_resnetv2')[0]
def get_features_vectors(urls):
result_logits = []
for i in range(len(urls)):
with tf.Graph().as_default():
try:
url = urls[i]
image_string = urllib.urlopen(url).read()
image = tf.image.decode_jpeg(image_string, channels=3)
processed_image = inception_preprocessing.preprocess_image(
image, image_size, image_size, is_training=False)
processed_images = tf.expand_dims(processed_image, 0)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits, _ = inception_v3.inception_v3(processed_images,
num_classes=1001,
is_training=False)
probabilities = tf.nn.softmax(logits)
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(checkpoints_dir, 'inception_v3.ckpt'),
slim.get_model_variables('InceptionV3'))
with tf.Session() as sess:
init_fn(sess)
np_image, np_logits, probabilities = sess.run(
[image, logits, probabilities])
probabilities = probabilities[0, 0:]
result_logits.append(np_logits)
print(url)
print(np_logits)
except Exception as e:
print(e)
continue
return result_logits
def model_fn(features, labels, mode, params):
logits, end_points = inception_v3(features, FLAGS.num_classes)
if mode in (tf.estimator.ModeKeys.PREDICT, tf.estimator.ModeKeys.EVAL):
predicted_indices = tf.argmax(input=logits, axis=1)
probabilities = end_points['Predictions']
if mode in (tf.estimator.ModeKeys.TRAIN, tf.estimator.ModeKeys.EVAL):
global_step = tf.train.get_or_create_global_step()
label_indices = tf.argmax(input=labels, axis=1)
loss = tf.losses.softmax_cross_entropy(onehot_labels=tf.one_hot(
labels, FLAGS.num_classes),
logits=logits)
if mode == tf.estimator.ModeKeys.PREDICT:
predictions = {
'classes': predicted_indices,
'probabilities': probabilities
}
export_outputs = {
'predictions': tf.estimator.export.PredictOutput(predictions)
}
return tf.estimator.EstimatorSpec(mode,
predictions=predictions,
export_outputs=export_outputs)
if mode == tf.estimator.ModeKeys.TRAIN:
optimizer = tf.train.RMSPropOptimizer(0.001, 0.9)
train_op = optimizer.minimize(loss, global_step=global_step)
return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
if mode == tf.estimator.ModeKeys.EVAL:
eval_metric_ops = {
'accuracy': tf.metrics.accuracy(label_indices, predicted_indices)
}
return tf.estimator.EstimatorSpec(mode,
loss=loss,
eval_metric_ops=eval_metric_ops)
def main(args):
# load the dataset
dataset = flowers.get_split('train', FLAGS.data_dir)
# dataset = cifar10.get_split('train', FLAGS.data_dir)
# load batch of dataset
images, image_raw, labels = load_flower_batch(dataset,
FLAGS.batch_size,
is_training=True)
#images, labels = load_mnist_batch(
# dataset,
# FLAGS.batch_size,
# is_training=True)
# run the image through the model
# predictions = lenet(images)
logits, end_points = inception_v3(images, dataset.num_classes)
# get the cross-entropy loss
one_hot_labels = slim.one_hot_encoding(labels, dataset.num_classes)
slim.losses.softmax_cross_entropy(logits, one_hot_labels)
total_loss = slim.losses.get_total_loss()
tf.summary.scalar('loss', total_loss)
# use RMSProp to optimize
optimizer = tf.train.RMSPropOptimizer(0.001, 0.9)
# create train op
train_op = slim.learning.create_train_op(total_loss,
optimizer,
summarize_gradients=True)
# run training
slim.learning.train(train_op,
FLAGS.train_log,
save_summaries_secs=30,
number_of_steps=5000,
save_interval_secs=60)
label_holder = tf.placeholder(shape=[input_size,7], dtype=tf.float32, name="Label_Holder")
img = tf.Variable(img_holder, name="Img_Var", trainable=False)
label = tf.Variable(label_holder, name="Label_Var", trainable=False)
img_assign = img.assign(img_holder, name="Img_Assign")
label_assign = label.assign(label_holder, name="Label_Assign")
# define validation holders/vars/assign operation
img_holder_val = tf.placeholder(shape=[input_size,299,299,3], dtype=tf.float32, name="Img_Holder_val")
label_holder_val = tf.placeholder(shape=[input_size,7], dtype=tf.float32, name="Label_Holder_val")
img_val = tf.Variable(img_holder_val, name="Img_Var_val", trainable=False)
label_val = tf.Variable(label_holder_val, name="Label_Var_val", trainable=False)
img_assign_val = img_val.assign(img_holder_val, name="Img_Assign_val")
label_assign_val = label_val.assign(label_holder_val, name="Label_Assign_val")
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
# This defines the network we need to train
logits, end_points = inception_v3.inception_v3(img, num_classes=7, create_aux_logits=False, is_training=True)
# This one just create an alis of the network above for validation
logits_val, _ = inception_v3.inception_v3(img_val, num_classes=7, create_aux_logits=False, is_training=False, reuse=tf.AUTO_REUSE)
# set up loss
loss = tf.losses.softmax_cross_entropy(label, logits)
# Use the following line to seperate validation loss from traning process
total_loss = tf.losses.get_total_loss()
# loss for validation just for summary purposes
loss_val = tf.losses.softmax_cross_entropy(label_val, logits_val, loss_collection="validation")
# set decay learning rate
learning_rate = tf.train.exponential_decay(START_LR, tf.train.get_or_create_global_step(), DECAY_STEP, DECAY_RATE)
# creat train op
opt = tf.train.AdamOptimizer(learning_rate)
# creat train fn that will be fed into a slim.train wrapper later
train_tensor = slim.learning.create_train_op(total_loss, optimizer=opt)
# Creat Summary
os.path.join(checkpoint_path, 'resnet_v2_101.ckpt')
}
if __name__ == '__main__':
f2l = load_labels('./dev_data/val_rs.csv')
input_dir = './outputs'
batch_shape = [50, 299, 299, 3]
num_classes = 1001
tf.logging.set_verbosity(tf.logging.ERROR)
with tf.Graph().as_default():
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x_input, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_adv_v3, end_points_adv_v3 = inception_v3.inception_v3(
x_input,
num_classes=num_classes,
is_training=False,
scope='AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens3_adv_v3, end_points_ens3_adv_v3 = inception_v3.inception_v3(
x_input,
num_classes=num_classes,
is_training=False,
scope='Ens3AdvInceptionV3')
def main(_):
start = time.clock()
# 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]
tf.logging.set_verbosity(tf.logging.INFO)
eps = 2.0 * FLAGS.max_epsilon / 255.0
num_iter = FLAGS.num_iter
alpha = eps / num_iter
momentum = FLAGS.momentum
num_classes = 1001
with tf.Session() as sess:
x = tf.placeholder(dtype=tf.float32, shape=batch_shape)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_adv_v3, end_points_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens3_adv_v3, end_points_ens3_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='Ens3AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens4_adv_v3, end_points_ens4_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='Ens4AdvInceptionV3')
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits_v4, end_points_v4 = inception_v4.inception_v4(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(
inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_res_v2, end_points_res_v2 = inception_resnet_v2.inception_resnet_v2(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(
inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_ensadv_res_v2, end_points_ensadv_res_v2 = inception_resnet_v2.inception_resnet_v2(
x,
num_classes=num_classes,
is_training=False,
scope='EnsAdvInceptionResnetV2')
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits_resnet, end_points_resnet = resnet_v2.resnet_v2_101(
x, num_classes=num_classes, is_training=False)
pred = tf.argmax(
end_points_v3['Predictions'] + end_points_adv_v3['Predictions'] + end_points_ens3_adv_v3['Predictions'] + \
end_points_ens4_adv_v3['Predictions'] + end_points_v4['Predictions'] + \
end_points_res_v2['Predictions'] + end_points_ensadv_res_v2['Predictions'] + end_points_resnet['predictions'], 1)
y = tf.placeholder(tf.int32, shape=[
FLAGS.batch_size,
])
one_hot = tf.one_hot(y, num_classes)
logits_dict = [
logits_v3, logits_adv_v3, logits_ens3_adv_v3, logits_ens4_adv_v3,
logits_v4, logits_res_v2, logits_ensadv_res_v2, logits_resnet
]
logits_gravity = tf.placeholder(dtype=tf.float32,
shape=[FLAGS.batch_size, 8])
logits0 = (logits_dict[0][0] * logits_gravity[0][0] + logits_dict[1][0] * logits_gravity[0][1] + logits_dict[2][0] * logits_gravity[0][2]\
+ logits_dict[3][0] * logits_gravity[0][3] + logits_dict[4][0] * logits_gravity[0][4] + logits_dict[5][0] * logits_gravity[0][5]\
+ logits_dict[6][0] * logits_gravity[0][6] + logits_dict[7][0] * logits_gravity[0][7]) / 36
logits1 = (logits_dict[0][1] * logits_gravity[1][0] + logits_dict[1][1] * logits_gravity[1][1] + logits_dict[2][1] * logits_gravity[1][2]\
+ logits_dict[3][1] * logits_gravity[1][3] + logits_dict[4][1] * logits_gravity[1][4] + logits_dict[5][1] * logits_gravity[1][5]\
+ logits_dict[6][1] * logits_gravity[1][6] + logits_dict[7][1] * logits_gravity[1][7]) / 36
logits0 = tf.reshape(logits0, [1, 1001])
logits1 = tf.reshape(logits1, [1, 1001])
logits = tf.concat([logits0, logits1], 0)
cross_entropy = tf.losses.softmax_cross_entropy(one_hot,
logits,
label_smoothing=0.0,
weights=1.0)
noise = tf.gradients(cross_entropy, x)[0]
noise = noise / tf.reduce_mean(
tf.abs(noise), [1, 2, 3], keep_dims=True
) # 可以改成 noise = noise / tf.reduce_sum(tf.abs(noise), [1, 2, 3], keep_dims=True)
grad = tf.placeholder(tf.float32, shape=batch_shape)
noise = momentum * grad + noise
adv = x + alpha * tf.sign(noise)
x_max = tf.placeholder(tf.float32, shape=batch_shape)
x_min = tf.placeholder(tf.float32, shape=batch_shape)
adv = tf.clip_by_value(adv, x_min, x_max)
# Run computation
s1 = tf.train.Saver(slim.get_model_variables(scope='InceptionV3'))
s2 = tf.train.Saver(slim.get_model_variables(scope='AdvInceptionV3'))
s3 = tf.train.Saver(
slim.get_model_variables(scope='Ens3AdvInceptionV3'))
s4 = tf.train.Saver(
slim.get_model_variables(scope='Ens4AdvInceptionV3'))
s5 = tf.train.Saver(slim.get_model_variables(scope='InceptionV4'))
s6 = tf.train.Saver(
slim.get_model_variables(scope='InceptionResnetV2'))
s7 = tf.train.Saver(
slim.get_model_variables(scope='EnsAdvInceptionResnetV2'))
s8 = tf.train.Saver(slim.get_model_variables(scope='resnet_v2'))
s1.restore(sess, FLAGS.checkpoint_path_inception_v3)
s2.restore(sess, FLAGS.checkpoint_path_adv_inception_v3)
s3.restore(sess, FLAGS.checkpoint_path_ens3_adv_inception_v3)
s4.restore(sess, FLAGS.checkpoint_path_ens4_adv_inception_v3)
s5.restore(sess, FLAGS.checkpoint_path_inception_v4)
s6.restore(sess, FLAGS.checkpoint_path_inception_resnet_v2)
s7.restore(sess, FLAGS.checkpoint_path_ens_adv_inception_resnet_v2)
s8.restore(sess, FLAGS.checkpoint_path_resnet)
sum = 0
failure_num = 0
l2_distance = 0
label_distance = 0
images = []
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
images = images.astype(np.float32) #不知道需不需要!!!!!!!!!!!!!!!!!!!!!!!
images_flatten_initial = images.reshape((2, 268203))
sum += len(filenames)
# 对于每个图片在迭代生成对抗样本的过程中，x_max和x_min 是不变的！！！！！！！
x_Max = np.clip(images + eps, -1.0, 1.0)
x_Min = np.clip(images - eps, -1.0, 1.0)
prediction = []
Noise = []
for i in range(FLAGS.num_iter):
if i == 0:
prediction = sess.run(pred, feed_dict={x: images})
print('true_label::::::::', prediction)
# x可能有问题!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
End_points_v3, End_points_adv_v3, End_points_ens3_adv_v3, End_points_ens4_adv_v3, End_points_v4, End_points_res_v2, End_points_ensadv_res_v2, End_points_resnet = \
sess.run([end_points_v3, end_points_adv_v3, end_points_ens3_adv_v3, end_points_ens4_adv_v3, end_points_v4, end_points_res_v2, end_points_ensadv_res_v2, end_points_resnet], feed_dict={x: images, y: prediction})
logits_proportion = []
for j in range(FLAGS.batch_size):
end_points_v3_Pred = End_points_v3['Predictions'][j][
prediction[j]]
end_points_adv_v3_Pred = End_points_adv_v3['Predictions'][
j][prediction[j]]
end_points_ens3_adv_v3_Pred = End_points_ens3_adv_v3[
'Predictions'][j][prediction[j]]
end_points_ens4_adv_v3_Pred = End_points_ens4_adv_v3[
'Predictions'][j][prediction[j]]
end_points_v4_Pred = End_points_v4['Predictions'][j][
prediction[j]]
end_points_res_v2_Pred = End_points_res_v2['Predictions'][
j][prediction[j]]
end_points_ensadv_res_v2_Pred = End_points_ensadv_res_v2[
'Predictions'][j][prediction[j]]
end_points_resnet_Pred = End_points_resnet['predictions'][
j][prediction[j]]
print('end_points_v3_Pred::::::', end_points_v3_Pred)
print('end_points_adv_v3_Pred::::::',
end_points_adv_v3_Pred)
print('end_points_ens3_adv_v3_Pred::::::',
end_points_ens3_adv_v3_Pred)
print('end_points_ens4_adv_v3_Pred::::::',
end_points_ens4_adv_v3_Pred)
print('end_points_v4_Pred::::::', end_points_v4_Pred)
print('end_points_res_v2_Pred::::::',
end_points_res_v2_Pred)
print('end_points_ensadv_res_v2_Pred::::::',
end_points_ensadv_res_v2_Pred)
print('end_points_resnet_Pred::::::',
end_points_resnet_Pred)
ens_Pred_Value = np.array([
end_points_v3_Pred, end_points_adv_v3_Pred,
end_points_ens3_adv_v3_Pred,
end_points_ens4_adv_v3_Pred, end_points_v4_Pred,
end_points_res_v2_Pred, end_points_ensadv_res_v2_Pred,
end_points_resnet_Pred
])
print('ens_Pred_Value:::::', ens_Pred_Value)
TopKFitIndx = np.argsort(ens_Pred_Value)
a = [0.0] * 8
for m in range(8):
a[TopKFitIndx[m]] = 8 - m
# a[m] = 1
logits_proportion.append(a)
if i == 0:
Grad = np.zeros(shape=[FLAGS.batch_size, 299, 299, 3],
dtype=np.float32)
Noise, images = sess.run(
[noise, adv],
feed_dict={
x: images,
y: prediction,
logits_gravity: logits_proportion,
grad: Grad,
x_max: x_Max,
x_min: x_Min
}) # x可能有问题!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
else:
Noise, images = sess.run(
[noise, adv],
feed_dict={
x: images,
y: prediction,
logits_gravity: logits_proportion,
grad: Noise,
x_max: x_Max,
x_min: x_Min
}) # Noise可能有问题!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
print('images::::::', images)
adv_prediction = sess.run(pred, feed_dict={x: images})
images_flatten_adv = images.reshape((2, 268203))
save_images(images, filenames, FLAGS.output_dir)
l2_diatance_list = np.linalg.norm(
(images_flatten_initial - images_flatten_adv),
axis=1,
keepdims=True)
for n in range(len(filenames)):
l2_distance += l2_diatance_list[n]
for j in range(len(filenames)):
label_distance += abs(prediction[j] - adv_prediction[j])
if int(prediction[j]) == adv_prediction[j]:
failure_num += 1
print('failure_num:::::', failure_num)
print('Prediction:::::::', adv_prediction)
print('sum::::', sum)
print('failure_num::::', failure_num)
rate_wrong = failure_num / sum
print('rate_wrong:::::::', rate_wrong)
print('l2_distance:::::::', l2_distance)
print('label_distance::::::', label_distance)
end = time.clock()
print('run time::::::::', end - start)
def target_graph(x, y, i, x_max, x_min, grad, label, x_ori):
eps = 2.0 * max_epsilon / 255.0
alpha = eps / num_iter
num_classes = FLAGS.num_classes
# find adversarial example in perlin noise direction
x = x + tf.random_uniform(tf.shape(x), minval=-1e-2, maxval=1e-2) * \
create_perlin_noise(seed=None, color=True, batch_size=FLAGS.batch_size, image_size=FLAGS.image_height, normalize=True, precalc_fade=None)
# dropout
x = generate_jitter_sample(x_ori, x, fade_eps=0, width=np.random.randint(low=1, high=12))
image = (((x + 1.0) * 0.5) * 255.0)
processed_imgs_in_v1 = preprocess_for_model(image, 'inception_v1')
with slim.arg_scope(inception.inception_v1_arg_scope()):
logits_inc_v1, end_points_inc_v1 = inception.inception_v1(
structure(processed_imgs_in_v1), num_classes=num_classes, is_training=False, scope='InceptionV1')
# rescale pixle range from [-1, 1] to [0, 255] for resnet_v1 and vgg's input
processed_imgs_res_v1_50 = preprocess_for_model(image, 'resnet_v1_50')
with slim.arg_scope(resnet_v1.resnet_arg_scope()):
logits_res_v1_50, end_points_res_v1_50 = resnet_v1.resnet_v1_50(
structure(processed_imgs_res_v1_50), num_classes=num_classes, is_training=False, scope='resnet_v1_50')
end_points_res_v1_50['logits'] = tf.squeeze(end_points_res_v1_50['while/resnet_v1_50/logits'], [1, 2])
end_points_res_v1_50['probs'] = tf.nn.softmax(end_points_res_v1_50['logits'])
# image = (((x + 1.0) * 0.5) * 255.0)#.astype(np.uint8)
processed_imgs_vgg_16 = preprocess_for_model(image, 'vgg_16')
with slim.arg_scope(vgg.vgg_arg_scope()):
logits_vgg_16, end_points_vgg_16 = vgg.vgg_16(
structure(processed_imgs_vgg_16), num_classes=num_classes, is_training=False, scope='vgg_16')
end_points_vgg_16['logits'] = end_points_vgg_16['vgg_16/fc8']
end_points_vgg_16['probs'] = tf.nn.softmax(end_points_vgg_16['logits'])
processed_imgs_in_v3 = preprocess_for_model(image, 'inception_v3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_in_v3, end_points_in_v3 = inception_v3.inception_v3(
structure_res(processed_imgs_in_v3), num_classes=num_classes, is_training=False, scope='InceptionV3')
processed_res_v2 = preprocess_for_model(image, 'resnet_v2_152')
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits_res_v2, end_points_res_v2 = resnet_v2.resnet_v2_152(
structure_res(processed_res_v2), num_classes=num_classes, is_training=False, scope='resnet_v2_152')
end_points_res_v2['logits'] = tf.squeeze(end_points_res_v2['resnet_v2_152/logits'], [1, 2])
end_points_res_v2['probs'] = tf.nn.softmax(end_points_res_v2['logits'])
one_hot = tf.one_hot(y, num_classes)
# separate the loss
cross_entropy_v1 = tf.losses.softmax_cross_entropy(one_hot,
end_points_inc_v1['Logits'],
label_smoothing=0.0,
weights=1.0)
cross_entropy_re = tf.losses.softmax_cross_entropy(one_hot,
end_points_res_v1_50['logits'],
label_smoothing=0.0,
weights=1.0)
cross_entropy_vgg = tf.losses.softmax_cross_entropy(one_hot,
end_points_vgg_16['logits'],
label_smoothing=0.0,
weights=1.0)
cross_entropy_re2 = tf.losses.softmax_cross_entropy(one_hot,
end_points_res_v2['logits'],
label_smoothing=0.0,
weights=1.0)
cross_entropy_v3 = tf.losses.softmax_cross_entropy(one_hot,
end_points_in_v3['Logits'],
label_smoothing=0.0,
weights=1.0)
pred = tf.argmax(end_points_inc_v1['Predictions'] + end_points_res_v1_50['probs'] + end_points_vgg_16['probs']+end_points_res_v2['probs'], 1)
first_round = tf.cast(tf.equal(i, 0), tf.int64)
label = first_round * pred + (1 - first_round) * label
noise_re = tf.gradients(cross_entropy_re,x)[0]
noise_re2 = tf.gradients(cross_entropy_re2,x)[0]
noise_v1 = tf.gradients(cross_entropy_v1,x)[0]
noise_vgg = tf.gradients(cross_entropy_vgg,x)[0]
noise_v3 = tf.gradients(cross_entropy_v3,x)[0]
noise_re = tf.Print(noise_re, [i, cross_entropy_re, cross_entropy_re2, cross_entropy_v1, cross_entropy_vgg, cross_entropy_v3])
noise_re = noise_re / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise_re, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise_re2 = noise_re2 / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise_re2, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise_v1 = noise_v1 / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise_v1, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise_vgg = noise_vgg / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise_vgg, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise_v3 = noise_v3 / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise_v3, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise = momentum * grad + noise_re + noise_re2 + noise_v1 + noise_vgg + noise_v3
noise = noise / tf.reshape(
tf.contrib.keras.backend.std(tf.reshape(noise, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
x = x - alpha * tf.clip_by_value(tf.round(noise), -2, 2)
x = tf.clip_by_value(x, x_min, x_max)
i = tf.add(i, 1)
return x, y, i, x_max, x_min, noise, label, x_ori
def graph(x, y, i, x_max, x_min, grad):
eps = 2.0 * FLAGS.max_epsilon / 255.0
num_iter = FLAGS.num_iter
alpha = eps / num_iter
momentum = FLAGS.momentum
num_classes = 1001
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_v3, end_points_v3 = inception_v3.inception_v3(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_adv_v3, end_points_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens3_adv_v3, end_points_ens3_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='Ens3AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens4_adv_v3, end_points_ens4_adv_v3 = inception_v3.inception_v3(
x,
num_classes=num_classes,
is_training=False,
scope='Ens4AdvInceptionV3')
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits_v4, end_points_v4 = inception_v4.inception_v4(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_res_v2, end_points_res_v2 = inception_resnet_v2.inception_resnet_v2(
x, num_classes=num_classes, is_training=False)
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_ensadv_res_v2, end_points_ensadv_res_v2 = inception_resnet_v2.inception_resnet_v2(
x,
num_classes=num_classes,
is_training=False,
scope='EnsAdvInceptionResnetV2')
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits_resnet, end_points_resnet = resnet_v2.resnet_v2_101(
x, num_classes=num_classes, is_training=False)
pred = tf.argmax(end_points_v3['Predictions'] + end_points_adv_v3['Predictions'] + end_points_ens3_adv_v3['Predictions'] + \
end_points_ens4_adv_v3['Predictions'] + end_points_v4['Predictions'] + \
end_points_res_v2['Predictions'] + end_points_ensadv_res_v2['Predictions'] + end_points_resnet['predictions'], 1)
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)
logits = (logits_v3 + 0.25 * logits_adv_v3 + logits_ens3_adv_v3 + \
logits_ens4_adv_v3 + logits_v4 + \
logits_res_v2 + logits_ensadv_res_v2 + logits_resnet) / 7.25
auxlogits = (end_points_v3['AuxLogits'] + 0.25 * end_points_adv_v3['AuxLogits'] + end_points_ens3_adv_v3['AuxLogits'] + \
end_points_ens4_adv_v3['AuxLogits'] + end_points_v4['AuxLogits'] + \
end_points_res_v2['AuxLogits'] + end_points_ensadv_res_v2['AuxLogits']) / 6.25
cross_entropy = tf.losses.softmax_cross_entropy(one_hot,
logits,
label_smoothing=0.0,
weights=1.0)
cross_entropy += tf.losses.softmax_cross_entropy(one_hot,
auxlogits,
label_smoothing=0.0,
weights=0.4)
noise = tf.gradients(cross_entropy, x)[0]
noise = noise / tf.reduce_mean(tf.abs(noise), [1, 2, 3], keep_dims=True)
noise = momentum * grad + noise
x = x + alpha * 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 graph(x, target_class_input, i, x_max, x_min, grad):
eps = 2.0 * FLAGS.max_epsilon / 255.0
alpha = eps / FLAGS.iterations
momentum = FLAGS.momentum
num_classes = 1001
x_div = input_diversity(x)
#x_div = x
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_adv_v3, end_points_adv_v3 = inception_v3.inception_v3(
x_div, num_classes=num_classes, is_training=False, scope='AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens3_adv_v3, end_points_ens3_adv_v3 = inception_v3.inception_v3(
x_div, num_classes=num_classes, is_training=False, scope='Ens3AdvInceptionV3')
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_ens4_adv_v3, end_points_ens4_adv_v3 = inception_v3.inception_v3(
x_div, num_classes=num_classes, is_training=False, scope='Ens4AdvInceptionV3')
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_ensadv_res_v2, end_points_ensadv_res_v2 = inception_resnet_v2.inception_resnet_v2(
x_div, num_classes=num_classes, is_training=False, scope='EnsAdvInceptionResnetV2')
with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()):
logits_adv_res_v2, end_points_adv_res_v2 = inception_resnet_v2.inception_resnet_v2(
x_div, num_classes=num_classes, is_training=False, scope='AdvInceptionResnetV2')
one_hot_target_class = tf.one_hot(target_class_input, num_classes)
logits = (logits_adv_v3 + logits_ens3_adv_v3 +
logits_ens4_adv_v3 + logits_ensadv_res_v2 + logits_adv_res_v2) / 5
auxlogits = (end_points_adv_v3['AuxLogits'] + end_points_ens3_adv_v3['AuxLogits'] +
end_points_ens4_adv_v3['AuxLogits'] + end_points_adv_res_v2['AuxLogits'] +
end_points_ensadv_res_v2['AuxLogits']) / 5
cross_entropy = tf.losses.softmax_cross_entropy(one_hot_target_class,
logits,
label_smoothing=0.0,
weights=1.0)
cross_entropy += tf.losses.softmax_cross_entropy(one_hot_target_class,
auxlogits,
label_smoothing=0.0,
weights=0.4)
noise = tf.gradients(cross_entropy, x)[0]
kernel = gkern(7, FLAGS.sig).astype(np.float32)
stack_kernel = np.stack([kernel, kernel, kernel]).swapaxes(2, 0)
stack_kernel = np.expand_dims(stack_kernel, 3)
noise = tf.nn.depthwise_conv2d(noise, stack_kernel, strides=[1, 1, 1, 1], padding='SAME')
noise = noise / tf.reshape(tf.contrib.keras.backend.std(tf.reshape(noise, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
noise = momentum * grad + noise
noise = noise / tf.reshape(tf.contrib.keras.backend.std(tf.reshape(noise, [FLAGS.batch_size, -1]), axis=1),
[FLAGS.batch_size, 1, 1, 1])
x = x - alpha * tf.clip_by_value(tf.round(noise), -2, 2)
x = tf.clip_by_value(x, x_min, x_max)
i = tf.add(i, 1)
return x, target_class_input, i, x_max, x_min, noise
processed_image = inception_preprocessing.preprocess_image(
image, image_size, image_size, is_training=False)
# 可以批量导入图像
# 第一个维度指定每批图片的张数
# 我们每次只导入一张图片
processed_images = tf.expand_dims(processed_image, 0)
# 创建模型，使用默认的arg scope参数
# arg_scope是slim library的一个常用参数
# 可以设置它指定网络层的参数，比如stride, padding 等等。
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
## num_classes=1001是对于imagenet而言的 至于为什么不是1000它的原网页有解释,如果是你的3类 写3就好了
logits, _ = inception_v3.inception_v3(processed_images,
num_classes=1001,
is_training=False)
# 我们在输出层使用softmax函数，使输出项是概率值
probabilities = tf.nn.softmax(logits)
# 创建一个函数，从checkpoint读入网络权值
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(checkpoints_dir, 'inception_v3.ckpt'),
slim.get_variables_to_restore())
with tf.Session() as sess:
# 加载权值
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
if gray[row][col] < 0.1:
color[row][col][0] = 0.0
color[row][col][1] = 0.0
color[row][col][2] = 0.0
gray = EliminateIsolatedPixels(color)
row_b, row_e, col_b, col_e = get_box_coord(gray)
box = color_orig[row_b:row_e, col_b:col_e]
return box
with graph.as_default():
images = tf.placeholder(tf.float32, shape=(None, 299, 299, 3))
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
_, end_points = inception_v3.inception_v3(images, is_training=False, num_classes=1001)
# Restore the checkpoint
sess = tf.Session(graph=graph)
saver = tf.train.Saver()
saver.restore(sess, ckpt_file)
# Construct the scalar neuron tensor.
logits = graph.get_tensor_by_name('InceptionV3/Logits/SpatialSqueeze:0')
neuron_selector = tf.placeholder(tf.int32)
y = logits[0][neuron_selector]
# Construct tensor for predictions.
prediction = tf.argmax(logits, 1)
def GetSalientImage(imagePath):
def run_test(read_csv, logger):
img_folder = '/home/zgwu/HandImages/long_video/test_frames/'
save_folder = '/home/zgwu/HandImages/long_video/double_frames/'
if not os.path.exists(save_folder):
os.mkdir(save_folder)
label_dict = read_test_csv_from(read_csv)
input_images = tf.placeholder(dtype=tf.float32,
shape=[None, 224, 224, 3],
name='input')
# placeholder holds an input tensor for classification
if ModelType == 'mobilenet':
out, end_points = mobilenet_v2.mobilenet(input_tensor=input_images,
num_classes=num_classes,
depth_multiplier=1.0,
is_training=False)
else:
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
out, end_points = inception_v3.inception_v3(
inputs=input_images,
num_classes=num_classes,
is_training=False)
detection_graph, sessd = detector_utils.load_inference_graph(
) # ssd to detect hands
saver = tf.train.Saver()
sess = tf.Session()
saver.restore(sess, CKPT)
CM = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
D = {
'num_pictures': 0,
'acc': 0,
'num_hands': 0,
'detect_t': 0.0,
'classify_t': 0.0,
'o': [0, 0, 0, 0, 0, 0, 0],
'd': [0, 0, 0, 0, 0, 0, 0],
'r': [0, 0, 0, 0, 0, 0, 0],
'tp': [0, 0, 0, 0, 0, 0, 0]
}
tot_count = 0
y_true, y_pred = [], []
label_matrix = np.empty((0, num_classes), dtype=int)
score_matrix = np.empty((0, num_classes), dtype=int)
for num_img, (img_name, frame_label) in enumerate(label_dict.items()):
tot_count += 1
if tot_count % 100 == 1:
print('Process {} --- {} / {}'.format(img_name, tot_count,
len(label_dict)))
l, t, r, b, clazz = frame_label
acc_index = labelsDict[clazz]
D['o'][acc_index] += 1 # confusion matrix
# filename = os.path.basename(img_name)
name, ext = os.path.splitext(img_name)
# print("Processing the image : " + name + " ... {}/{}".format(num_img+1, len(label_dict)))
key = cv2.waitKey(5) & 0xff ## Use Esc key to close the program
if key == 27:
break
if key == ord('p'):
cv2.waitKey(0)
image_raw = cv2.imread(os.path.join(img_folder, img_name))
image_np = cv2.resize(image_raw, (im_width, im_height))
try:
image_np = cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB)
except:
print("Error converting to RGB")
start = time.time() # set time
boxes, scores = detector_utils.detect_objects(image_np,
detection_graph, sessd)
hands = from_image_crop_boxes(num_hands_detect, score_thresh, scores,
boxes, im_width, im_height, 0.5)
endh = time.time() # detect hand
detect_t = endh - start
D['detect_t'] += detect_t
if not hands:
continue
else:
D['num_pictures'] += 1
D['d'][acc_index] += 1
for rank, rect in enumerate(hands):
D['num_hands'] += 1
left, top, right, bottom = rect
region = image_np[top:bottom, left:right]
region = cv2.resize(region, (224, 224), cv2.INTER_AREA)
# feed = np.expand_dims(region, axis=0) # maybe it's a wrong format to feed
img_data = tf.image.convert_image_dtype(np.array(region)[:, :,
0:3],
dtype=tf.float32) # RGB
# elements are in [0,1)
resized_img = tf.image.resize_images(img_data,
size=[224, 224],
method=0)
# decode an image
img = resized_img.eval(session=sess)
img.resize([1, 224, 224, 3])
# input an image array and inference to get predictions and set normal format
predictions = end_points['Predictions'].eval(
session=sess, feed_dict={input_images: img})
label = np.zeros((1, num_classes), dtype=int)
label[0, acc_index] = 1
label_matrix = np.append(label_matrix, label, axis=0)
score_matrix = np.append(score_matrix,
predictions.reshape([1, num_classes]),
axis=0)
#print(label, predictions.reshape([1, num_classes]))
predictions.resize([num_classes])
np.set_printoptions(precision=4, suppress=True)
index = int(np.argmax(predictions))
y_true.append(acc_index)
y_pred.append(index)
D['r'][index] += 1
msg = img_name + ' ' + clazz + ' ' + labelsStr[index]
CM[acc_index][index] += 1
if index == acc_index:
D['acc'] += 1
D['tp'][index] += 1
logger.info(msg)
if key == ord('s'):
region = cv2.cvtColor(region, cv2.COLOR_RGB2BGR)
cv2.imwrite(
frame_path + name + '_' + str(D['num_frames']) + '_' +
str(rank) + '.jpg', region)
cv2.waitKey(0)
endr = time.time()
classify_t = endr - endh
D['classify_t'] += classify_t
print(
"From {} pictures, we detect {} hands with {} accurate prediction ({:.2f})"
.format(tot_count, D['num_hands'], D['acc'],
D['acc'] / D['num_hands']))
result_log = '\n@@images_count: {} and detect_count: {}'.format(tot_count, D['num_pictures']) + \
'\n@@image_size: (width : {}, height: {})'.format(im_width, im_height) + \
'\n@@num_hand_detect: {} - {}%'.format(D['num_hands'], int(100 * D['num_hands'] / tot_count)) + \
'\n@@each_elapsed_time: (detect_hands: {:.4f}s, classify_hand: {:.4f}s)'.format(
D['detect_t'] / tot_count, D['classify_t'] / D['num_hands']) + \
'\n@@classify_result: Fist Admire Victory Okay None Palm Six' + \
'\n {: <6d}{: <8d}{: <9d}{: <6d}{: <6d}{: <6d}{} -- origin classes' \
'\n {: <6d}{: <8d}{: <9d}{: <6d}{: <6d}{: <6d}{} -- detect classes' \
'\n {: <6d}{: <8d}{: <9d}{: <6d}{: <6d}{: <6d}{} -- recognize count' \
'\n {: <6d}{: <8d}{: <9d}{: <6d}{: <6d}{: <6d}{} -- true positive' \
.format(D['o'][0], D['o'][1], D['o'][2], D['o'][3],D['o'][4], D['o'][5], D['o'][6],
D['d'][0], D['d'][1], D['d'][2], D['d'][3],D['d'][4], D['d'][5], D['d'][6],
D['r'][0], D['r'][1], D['r'][2], D['r'][3], D['r'][4], D['r'][5], D['r'][6],
D['tp'][0], D['tp'][1], D['tp'][2], D['tp'][3], D['tp'][4], D['tp'][5], D['tp'][6]) + \
'\n@@accuracy: {}/{} - {}%'.format(D['acc'], D['num_hands'], int(100 * D['acc'] / D['num_hands'])) + \
'\n' + '-' * 100 + \
'\n' + str(CM)
#print(result_log)
logger.info(result_log)
#print(classification_report(y_true, y_pred, target_names=labelsStr, digits=3))
logger.info(
str(
classification_report(y_true,
y_pred,
target_names=labelsStr,
digits=3)))
print(label_matrix.shape, score_matrix.shape)
# 计算每一类的ROC
fpr = dict()
tpr = dict()
roc_auc = dict()
# Compute micro-average ROC curve and ROC area（方法二）
fpr["micro"], tpr["micro"], _ = roc_curve(label_matrix.ravel(),
score_matrix.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
# FPR就是横坐标,TPR就是纵坐标
plt.plot(fpr["micro"],
tpr["micro"],
c='r',
lw=2,
alpha=0.7,
label=u'AUC=%.3f' % roc_auc["micro"])
plt.plot((0, 1), (0, 1), c='#808080', lw=1, ls='--', alpha=0.7)
plt.xlim((-0.01, 1.02))
plt.ylim((-0.01, 1.02))
plt.xticks(np.arange(0, 1.1, 0.1))
plt.yticks(np.arange(0, 1.1, 0.1))
plt.xlabel('False Positive Rate', fontsize=13)
plt.ylabel('True Positive Rate', fontsize=13)
plt.grid(b=True, ls=':')
plt.legend(loc='lower right', fancybox=True, framealpha=0.8, fontsize=12)
plt.title(u'The ROC and AUC of MobileNet Classifier.', fontsize=17)
plt.show()
"""
def main(_):
start = time.clock()
# 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]
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
x_adv_v3 = tf.placeholder(tf.float32, shape=batch_shape)
x_max = tf.clip_by_value(x_input + eps, -1.0, 1.0)
x_min = tf.clip_by_value(x_input - eps, -1.0, 1.0)
y = tf.constant(np.zeros([FLAGS.batch_size]), tf.int64)
i = tf.constant(0)
grad = tf.zeros(shape=batch_shape)
pred = tf.zeros(shape=[
2,
], dtype=tf.int64)
Prediction_adv_v3 = tf.zeros(shape=[
2,
], dtype=tf.int64)
x_adv, _, label, _, _, _, _, Pred = tf.while_loop(
stop, graph, [x_input, x_adv_v3, y, i, x_max, x_min, grad, pred])
with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
logits_adv_v3_one, end_points_adv_v3_one = inception_v3.inception_v3(
x_adv_v3,
num_classes=1001,
is_training=False,
reuse=True,
scope='AdvInceptionV3')
pred_adv_v3 = tf.argmax(end_points_adv_v3_one['Predictions'], axis=1)
# Run computation
s1 = tf.train.Saver(slim.get_model_variables(scope='InceptionV3'))
s2 = tf.train.Saver(slim.get_model_variables(scope='AdvInceptionV3'))
s3 = tf.train.Saver(
slim.get_model_variables(scope='Ens3AdvInceptionV3'))
s4 = tf.train.Saver(
slim.get_model_variables(scope='Ens4AdvInceptionV3'))
s5 = tf.train.Saver(slim.get_model_variables(scope='InceptionV4'))
s6 = tf.train.Saver(
slim.get_model_variables(scope='InceptionResnetV2'))
s7 = tf.train.Saver(
slim.get_model_variables(scope='EnsAdvInceptionResnetV2'))
s8 = tf.train.Saver(slim.get_model_variables(scope='resnet_v2'))
with tf.Session() as sess:
s1.restore(sess, FLAGS.checkpoint_path_inception_v3)
s2.restore(sess, FLAGS.checkpoint_path_adv_inception_v3)
s3.restore(sess, FLAGS.checkpoint_path_ens3_adv_inception_v3)
s4.restore(sess, FLAGS.checkpoint_path_ens4_adv_inception_v3)
s5.restore(sess, FLAGS.checkpoint_path_inception_v4)
s6.restore(sess, FLAGS.checkpoint_path_inception_resnet_v2)
s7.restore(sess, FLAGS.checkpoint_path_ens_adv_inception_resnet_v2)
s8.restore(sess, FLAGS.checkpoint_path_resnet)
sum = 0
loss_num = 0
l2_distance = 0
label_distance = 0
for filenames, images in load_images(FLAGS.input_dir, batch_shape):
images_flatten_initial = images.reshape((2, 268203))
sum += len(filenames)
# for i in range(len(filenames)):
# true_label.append(filenames[i].split('-')[2][:-4])
adv_images, true_label = sess.run([x_adv, label],
feed_dict={x_input: images})
print('adv_images::::', type(adv_images[0][0][0][0]),
adv_images.shape)
Prediction = sess.run(pred_adv_v3,
feed_dict={x_adv_v3: adv_images})
print('true_label::::::::', true_label)
images_flatten_adv = adv_images.reshape((2, 268203))
l2_diatance_list = np.linalg.norm(
(images_flatten_initial - images_flatten_adv),
axis=1,
keepdims=True)
for n in range(len(filenames)):
l2_distance += l2_diatance_list[n]
for j in range(len(filenames)):
label_distance += abs(true_label[j] - Prediction[j])
if int(true_label[j]) == Prediction[
j]: # The test tag is always 1 more than the real tag, so I subtract 1 here
loss_num += 1
print('sucess_num:::::', loss_num)
print('Prediction:::::::', Prediction)
save_images(adv_images, filenames, FLAGS.output_dir)
print('sum::::', sum)
print('loss_num::::', loss_num)
rate_wrong = loss_num / sum
print('rate_wrong:::::::', rate_wrong)
print('l2_distance:::::::', l2_distance)
print('label_distance::::::', label_distance)
end = time.clock()
print('run time::::::::', end - start)
