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 build_single_inceptionv1(train_tfdata, is_train, dropout_keep_prob): with slim.arg_scope(inception.inception_v1_arg_scope()): identity, end_points = inception.inception_v1(train_tfdata, dropout_keep_prob = dropout_keep_prob, is_training=is_train) net = slim.avg_pool2d(end_points['Mixed_5c'], [7, 7], stride=1, scope='MaxPool_0a_7x7') net = slim.dropout(net, dropout_keep_prob, scope='Dropout_0b') feature = tf.squeeze(net, [1, 2]) return identity, feature
def eval(x, num_classes=110): with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( x, num_classes=num_classes, is_training=False, scope='InceptionV1') pred1 = tf.argmax(end_points_inc_v1['Predictions'], 1) # rescale pixle range from [-1, 1] to [0, 255] for resnet_v1 and vgg's input image = (((x + 1.0) * 0.5) * 255.0) 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( 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['resnet_v1_50/logits'], [1, 2]) end_points_res_v1_50['probs'] = tf.nn.softmax( end_points_res_v1_50['logits']) pred2 = tf.argmax(end_points_res_v1_50['probs'], 1) # 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(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']) pred3 = tf.argmax(end_points_vgg_16['probs'], 1) return [pred1, pred2, pred3]
def _build_graph(self, inputs): orig_image = inputs[0] with tp.symbolic_functions.guided_relu(): with slim.arg_scope(inception.inception_v1_arg_scope()): image = tf.expand_dims(((orig_image / 255) - 0.5) * 2, 0) logits, _ = inception.inception_v1(image, 1001, False) tp.symbolic_functions.saliency_map(logits, orig_image, name="saliency")
def non_target_graph(x, y, i, x_max, x_min, grad): eps = 2.0 * max_epsilon / 255.0 alpha = eps / num_iter num_classes = 110 with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( x, 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 image = (((x + 1.0) * 0.5) * 255.0) 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( 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['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(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']) ######################## # Using model predictions as ground truth to avoid label leaking pred = tf.argmax( end_points_inc_v1['Predictions'] + end_points_res_v1_50['probs'] + end_points_vgg_16['probs'], 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 = (end_points_inc_v1['Logits'] + end_points_res_v1_50['logits'] + end_points_vgg_16['logits']) / 3.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 = 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 target_graph(x, y, i, x_max, x_min, grad): eps = 2.0 * max_epsilon / 255.0 alpha = eps / num_iter num_classes = 110 #input image size[224,224,3] images3 = tf.image.resize_bilinear(input_diversity(x), [224, 224], align_corners=False) with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( images3, 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 image1 = (((input_diversity(x) + 1.0) * 0.5) * 255.0) processed_imgs_res_v1_50 = preprocess_for_model(image1, '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( 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['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) image2 = (((input_diversity(x) + 1.0) * 0.5) * 255.0) processed_imgs_vgg_16 = preprocess_for_model(image2, 'vgg_16') with slim.arg_scope(vgg.vgg_arg_scope()): logits_vgg_16, end_points_vgg_16 = vgg.vgg_16( 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']) one_hot = tf.one_hot(y, num_classes) logits = (end_points_inc_v1['Logits'] + end_points_res_v1_50['logits'] + end_points_vgg_16['logits']) / 3.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 = 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, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) noise = momentum * grad + noise noise = noise / tf.reshape(tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) noise1 = tf.image.resize_images(noise, [140, 140], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) print("noise shape:", noise.shape) noise1 = alpha * tf.clip_by_value(tf.round(noise1), -2, 2) noise_paded = tf.pad(noise1,[[0, 0], [42, 42], [42, 42], [0, 0]], constant_values=0.) x = x - noise_paded x = tf.clip_by_value(x, x_min, x_max) print("x.shape:", x.shape) i = tf.add(i, 1) return x, y, i, x_max, x_min, noise
def testModelHasExpectedNumberOfParameters(self): batch_size = 5 height, width = 224, 224 inputs = tf.random_uniform((batch_size, height, width, 3)) with slim.arg_scope(inception.inception_v1_arg_scope()): inception.inception_v1_base(inputs) total_params, _ = slim.model_analyzer.analyze_vars( slim.get_model_variables()) self.assertAlmostEqual(5607184, total_params)
def target_graph(x, y, i, x_max, x_min, grad): eps = 2.0 * max_epsilon / 255.0 alpha = eps / num_iter num_classes = 110 with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( x, 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 image = (((x + 1.0) * 0.5) * 255.0) 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( 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['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(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']) ######################## one_hot = tf.one_hot(y, num_classes) ######################## logits = (end_points_inc_v1['Logits'] + end_points_res_v1_50['logits'] + end_points_vgg_16['logits']) / 3.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.reshape( tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) noise = momentum * grad + noise noise = noise / tf.reshape( tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [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
def build_single_inceptionv1(train_tfdata, is_train, dropout_keep_prob): with slim.arg_scope(inception.inception_v1_arg_scope()): identity, end_points = inception.inception_v1( train_tfdata, dropout_keep_prob=dropout_keep_prob, is_training=is_train) net = slim.avg_pool2d(end_points['Mixed_5c'], [7, 7], stride=1, scope='MaxPool_0a_7x7') net = slim.dropout(net, dropout_keep_prob, scope='Dropout_0b') feature = tf.squeeze(net, [1, 2]) return identity, feature
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_v1_arg_scope()): logits, _ = inception.inception_v1(image, num_classes, is_training=False, spatial_squeeze=False) probabilities = tf.nn.softmax(logits) init_fn = slim.assign_from_checkpoint_fn('inception_v1.ckpt', slim.get_model_variables('InceptionV1')) with tf.Session() as sess: init_fn(sess) saver = tf.train.Saver(tf.global_variables()) saver.save(sess, "output/"+name)
def _forward_pass(self, input_layer, trainable=True): with slim.arg_scope(inception.inception_v1_arg_scope()): input_shape = input_layer.get_shape().as_list() batch_size = input_shape[0] logits, _ = inception.inception_v1(input_layer, self._hyparams.num_classes, is_training=False, spatial_squeeze=False) logits = tf.reshape(logits, (batch_size, self._hyparams.num_classes)) probabilities = tf.nn.softmax(logits) return probabilities
def ens_model(x): #input remains in[0,1] image = (x * 255.0) num_classes = 110 processed_incv1 = 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( processed_incv1, num_classes=num_classes, is_training=False, scope='InceptionV1') 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( 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['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(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']) ######################## #one_hot = tf.one_hot(y, num_classes) ######################## logits = (end_points_inc_v1['Logits'] + end_points_res_v1_50['logits'] + end_points_vgg_16['logits']) / 3.0 print('logits.shape:', logits.shape) return logits
def restore_model(self): with tf.Graph().as_default(): # Prepare graph self.x_input = tf.placeholder(tf.float32, shape=self.input_shape) with tf.contrib.slim.arg_scope(inception.inception_v1_arg_scope()): _, end_points = inception.inception_v1(self.x_input, num_classes=self.nb_classes, is_training=False) self.pre_labels = tf.argmax(end_points['Predictions'], 1) self.features = end_points['Mixed_5c'] # Restore Model saver = tf.train.Saver(tf.contrib.slim.get_model_variables()) session_creator = tf.train.ChiefSessionCreator( scaffold=tf.train.Scaffold(saver=saver), checkpoint_filename_with_path=FLAGS.checkpoint_path) self.sess = tf.train.MonitoredSession(session_creator=session_creator)
def compute_embedding_inception_v1(inputs, embedding_dim=64, is_training=True, dropout_keep_prob=0.8, scope='InceptionV1', l2_normalize=True): """Compute embedding with inception v1.""" with tf.variable_scope(scope, 'InceptionV1', [inputs, embedding_dim]) as scope: with slim.arg_scope([layers.batch_norm, layers.dropout], is_training=is_training): with slim.arg_scope(inception.inception_v1_arg_scope()): net, end_points = inception.inception_v1_base(inputs, scope=scope) net = layers.avg_pool2d(net, [7, 7], stride=1, scope='AvgPool_0a_7x7') net = layers.dropout(net, dropout_keep_prob, scope='Dropout_0b') base_variables = slim.get_variables_to_restore( exclude=['global_step']) # Embedding bottleneck. net = layers.conv2d(net, embedding_dim, [1, 1], activation_fn=None, normalizer_fn=None, scope='Bottleneck') embedding = tf.squeeze(net, [1, 2], name='SpatialSqueeze') if l2_normalize: embedding = tf.nn.l2_normalize(embedding, dim=1) end_points['embeddings'] = embedding bottleneck_variables = tf.contrib.framework.get_variables( scope='InceptionV1/Bottleneck') return embedding, end_points, base_variables, bottleneck_variables
def non_target_mi_fgsm_attack(input_dir, output_dir): # some parameter #eps = 2.0 * max_epsilon / 255.0 eps = max_epsilon batch_shape = [batch_size, 224, 224, 3] #_check_or_create_dir(output_dir) with tf.Graph().as_default(): # Prepare graph raw_inputs = tf.placeholder(tf.uint8, shape=[None, 224, 224, 3]) # preprocessing for model input, # note that images for all classifier will be normalized to be in [-1, 1] #processed_imgs = preprocess_for_model(raw_inputs, 'inception_v1') x_input = 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([batch_size]), tf.int64) #y = tf.placeholder(tf.int32, shape=[batch_size]) y = tf.constant(np.zeros([batch_size]), tf.int64) i = tf.constant(0) #grad = tf.zeros(shape=batch_shape) if rand_init: grad = tf.random_uniform(tf.shape(x_input), tf.cast(-0.05, x_input.dtype), tf.cast(0.05, x_input.dtype), dtype=x_input.dtype) else: grad = tf.zeros(tf.shape(x_input)) adv_x = x_input + grad adv_x = tf.clip_by_value(adv_x, x_min, x_max) #ori_x,x_adv, _, _, _, _, _ = tf.while_loop(stop, non_target_graph, [x_input, adv_x, y, i, x_max, x_min, grad]) #training setting train_img = tf.placeholder(tf.float32, shape=[None, 224, 224, 3]) train_label = tf.placeholder(tf.float32, shape=[None, 110]) with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( train_img, num_classes=num_classes, is_training=True, scope='InceptionV1') predict = tf.argmax(tf.nn.softmax(end_points_inc_v1['Logits']), 1) logits = end_points_inc_v1['Logits'] cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=train_label, logits=logits)) learning_rate = tf.placeholder(tf.float32, name='learning_rate') optimizer = tf.train.GradientDescentOptimizer( learning_rate=learning_rate) train = optimizer.minimize(cost) accuracy = tf.reduce_mean( tf.cast(tf.equal(predict, tf.argmax(train_label, 1)), tf.float32)) ori_x, x_adv, _, _, _, _, _ = tf.while_loop( stop, non_target_graph, [x_input, adv_x, y, i, x_max, x_min, grad]) # Run computation s1 = tf.train.Saver(slim.get_model_variables(scope='InceptionV1')) s2 = tf.train.Saver(slim.get_model_variables(scope='resnet_v1_50')) s3 = tf.train.Saver(slim.get_model_variables(scope='vgg_16')) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) s1.restore(sess, model_checkpoint_map['inception_v1']) s2.restore(sess, model_checkpoint_map['resnet_v1_50']) s3.restore(sess, model_checkpoint_map['vgg_16']) for time in range(epoch_num): train_acc = [] count = 0 train_loss = [] val_acc = [] val_loss = [] epoch_learning_rate = init_learning_rate for filenames, raw_images, true_labels in load_images_with_true_label( input_dir): raw_images = list(raw_images) adv_images = sess.run( x_adv, feed_dict={x_input: np.array(raw_images[:16])}) raw_images[:16] = list(adv_images) labels = one_hot(true_labels, 110) img = (np.array(raw_images) + 1.0) * 0.5 * 255.0 img = preprocess_for_model(img, model_type, train=True) train_feed_dict = { train_img: img, train_label: labels, learning_rate: epoch_learning_rate } a, batch_loss = sess.run([train, cost], feed_dict=train_feed_dict) batch_acc = accuracy.eval(feed_dict=train_feed_dict) train_acc.append(batch_acc) train_loss.append(batch_loss) count += 1 if count % 100 == 0: print('acc: ', np.mean(np.array(train_acc)), ' loss: ', np.mean(np.array(train_loss))) #break for filenames, raw_images, true_labels in load_images_with_true_label( output_dir, train=False): raw_images = list(raw_images) adv_images = sess.run( x_adv, feed_dict={x_input: np.array(raw_images[:16])}) raw_images[:16] = list(adv_images) labels = one_hot(true_labels, 110) img = (np.array(raw_images) + 1.0) * 0.5 * 255.0 img = preprocess_for_model(img, model_type, train=True) train_feed_dict = { train_img: img, train_label: labels, learning_rate: epoch_learning_rate } pre, batch_acc = sess.run([predict, accuracy], feed_dict=train_feed_dict) val_acc.append(batch_acc) val_loss.append(batch_loss) count += 1 #break #print(pre,'\n',true_labels,batch_acc) print('val_acc: ', np.mean(np.array(val_acc)), ' loss: ', np.mean(np.array(val_loss))) s1.save(sess=sess, save_path='./train_model/%s_%s.ckpt' % (model_type, time))
checkpoint_dir = os.path.join(CHECKPOINT_DIR, model_name, str(l_rate)) # VAL_SUMMARY_DIR = "/data/summary/flowers/val" # log_dir = os.path.join(VAL_SUMMARY_DIR, model_name, str(l_rate), datetime.datetime.now().strftime("%Y%m%d-%H%M")) flowers_data_dir = "/data/flowers" batch_size = 10 image_size = inception.inception_v1.default_image_size val_dataset = flowers.get_split('validation', flowers_data_dir) # Load the data images, labels = dataset.load_batch( val_dataset, batch_size, height=image_size, width=image_size, is_training=False) # Create the model: with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(images, num_classes=5, is_training=False) predictions = tf.argmax(logits, 1) checkpoint_path = tf.train.latest_checkpoint(checkpoint_dir) init_fn = slim.assign_from_checkpoint_fn( checkpoint_path, slim.get_variables_to_restore()) # Choose the metrics to compute: names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ "accuracy": slim.metrics.streaming_accuracy(predictions, labels), 'precision': slim.metrics.streaming_precision(predictions, labels), }) # Evaluate the model using 1000 batches of data:
def create_model(images, labels): """ This methods initialize the inception v1 model with weights generated from training on the ImageNet dataset for all layers expect the last. The last layer is adjusted to output only 9 classes (instead of the 1000 required for ImageNet). Note also that the methods set the model for fine-tuning meaning that during training only the last layer's weights can change. :param images: A tensor containing the images. :param labels: A tensor representing the correct labels for the images. :return restore_op: The operation used to restore the weights of the model. :return feed_dict: The feed_dict used for restoring the model. :return train_op: The train_op used to train the model. :return metrics_to_values: The metrics collected when training. :return metrics_to_updates: The metrics update op used when training. """ with slim.arg_scope(inception.inception_v1_arg_scope()): # Load the deep learning model. logits, end_points = inception.inception_v1(images, num_classes=NUM_CLASSES, is_training=False) # We are going to train only the last layer of the model. trainable_layer = 'InceptionV1/Logits/Conv2d_0c_1x1' variables_to_restore = slim.get_variables_to_restore( exclude=[trainable_layer]) variables_to_train = slim.get_variables_by_suffix('', trainable_layer) # Transform the labels into one hot encoding. one_hot_labels = tf.one_hot( labels, NUM_CLASSES, ) # Define the loss function. loss = tf.losses.softmax_cross_entropy( one_hot_labels, end_points['Logits'], ) # Select the optimizer. optimizer = tf.train.AdamOptimizer(1e-4) # Create a train op. train_op = tf.contrib.training.create_train_op( loss, optimizer, variables_to_train=variables_to_train, ) predictions = tf.argmax(end_points['Predictions'], 1, name="predictions") metrics_to_values, metrics_to_updates = \ slim.metrics.aggregate_metric_map({ 'accuracy': tf.metrics.accuracy(predictions, labels), 'mean_loss': tf.metrics.mean(loss), }) # Define load predefined model operation. restore_op, feed_dict = slim.assign_from_checkpoint( 'inception_v1.ckpt', variables_to_restore) return ( restore_op, feed_dict, train_op, metrics_to_values, metrics_to_updates, )
def non_target_graph(ori_x, x, y, i, x_max, x_min, grad): #[x_input, adv_x, y, i, x_max, x_min, grad] #eps = 2.0 * max_epsilon / 255.0 eps = max_epsilon alpha = eps_iter num_classes = 110 #image = robust_resize(x) image = input_diversity(x) with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( image, num_classes=num_classes, is_training=False) # rescale pixle range from [-1, 1] to [0, 255] for resnet_v1 and vgg's input #image = (((image + 1.0) * 0.5) * 255.0) image = (image + 1.0) * 0.5 * 255.0 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( 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['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(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']) image = (image / 255.0) * 2.0 - 1.0 with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_adv, end_points_inc_adv = inception.inception_v1( image, num_classes=num_classes, is_training=False, scope='inception_adv') image = (image + 1.0) * 0.5 * 255.0 #processed_imgs_res_v1_50 = preprocess_for_model(image, 'resnet_v1_50') #with slim.arg_scope(resnet_v1.resnet_arg_scope()): # logits_res_adv, end_points_res_adv = resnet_v1.resnet_v1_50( # processed_imgs_res_v1_50, num_classes=num_classes,is_training=False,scope='adv_resnet') #end_points_res_adv['logits'] = tf.squeeze(end_points_res_adv['adv_resnet/logits'], [1, 2]) #end_points_res_adv['probs'] = tf.nn.softmax(end_points_res_v1_50['logits']) processed_imgs_vgg_16 = preprocess_for_model(image, 'vgg_16') with slim.arg_scope(vgg.vgg_arg_scope()): logits_vgg_adv, end_points_vgg_adv = vgg.vgg_16( processed_imgs_vgg_16, num_classes=num_classes, is_training=False, scope='adv_vgg') end_points_vgg_adv['logits'] = end_points_vgg_adv['adv_vgg/fc8'] end_points_vgg_adv['probs'] = tf.nn.softmax(end_points_vgg_adv['logits']) ######################## #logits = tf.cond(tf.less(i,cond_number),lambda: end_points_vgg_16['logits'],lambda:end_points_vgg_16['logits']) logits = (0.8*end_points_inc_v1['Logits'] + 1.1*end_points_res_v1_50['logits'] \ + 0.6*end_points_vgg_16['logits'] + end_points_inc_adv['Logits'] \ + end_points_vgg_adv['logits']) \ /6.5 # logits = tf.cond(tf.less(i,cond_number),lambda: logits,lambda:end_points_vgg_16['logits']) prediction = (end_points_inc_v1['Predictions'] + end_points_res_v1_50['probs'] \ + end_points_vgg_16['probs'] + end_points_inc_adv['Predictions'] \ + end_points_vgg_adv['probs']) \ /5.0 pred = tf.argmax(prediction, 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, label_smoothing=0.0, weights=1.0) #another loss function #loss = tf.reshape(tf.nn.top_k(prediction,110)[0][:,0],[10,1])-tf.reshape(\ # tf.nn.top_k(prediction,110)[0][:,109],[10,1]) #item1 = tf.reshape(tf.cast(tf.equal(pred,y),tf.float32),[batch_size,1]) #item2 = tf.reshape(tf.cast(tf.equal(pred,y),tf.float32)-1.0,[batch_size,1]) #loss = item1 * loss + item2 * loss loss = 1.0 * cross_entropy # +0.2* loss noise = tf.gradients(loss, x)[0] kernel = gkern(7, 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.reduce_mean(tf.abs(noise), [1,2,3], keep_dims=True) noise = noise / tf.reshape( tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) #noise = clip_eta(noise, ord = 2, eps=eps) noise = momentum * grad + noise noise = noise / tf.reshape( tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) perturb = tf.clip_by_value(tf.round(noise), -10, 10) x = x + alpha * perturb # x = x + alpha * tf.sign(noise) x = tf.clip_by_value(x, -1.0, 1.0) #part_x,x = change_size(ori_x,x,size = crop_size) #x = x+part_x ############################PGD################ #eta = x - ori_x #eta = clip_eta(eta, ord = 2, eps=eps) #x = ori_x + eta #x = tf.clip_by_value(x, x_min, x_max) ############################################## i = tf.add(i, 1) #random_noise = tf.random_normal(x.shape,6/255,6/255,dtype=x.dtype) #x = tf.cond(tf.less(i,num_iter),lambda: x,lambda:random_noise+x) #x = tf.clip_by_value(x, -1, 1) return ori_x, x, y, i, x_max, x_min, noise
def non_target_graph(ori_x, x, y, i, x_max, x_min, grad): #eps = 2.0 * max_epsilon / 255.0 eps = max_epsilon alpha = eps_iter num_classes = 110 #image = preprocess_for_model(x, 'inception_v1') #image = x * 2.0 -1.0 image = input_diversity(x) with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_v1, end_points_inc_v1 = inception.inception_v1( image, 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 image = ((image + 1.0) * 0.5) * 255.0 #image = (image + 1.0)*0.5 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( 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['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) 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(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']) image = (image / 255.0) * 2.0 - 1.0 with slim.arg_scope(inception.inception_v1_arg_scope()): logits_inc_adv, end_points_inc_adv = inception.inception_v1( image, num_classes=num_classes, is_training=False, scope='inception_adv') image = (image + 1.0) * 0.5 * 255.0 #processed_imgs_res_v1_50 = preprocess_for_model(image, 'resnet_v1_50') #with slim.arg_scope(resnet_v1.resnet_arg_scope()): # logits_res_adv, end_points_res_adv = resnet_v1.resnet_v1_50( # processed_imgs_res_v1_50, num_classes=num_classes,is_training=False,scope='adv_resnet') #end_points_res_adv['logits'] = tf.squeeze(end_points_res_adv['adv_resnet/logits'], [1, 2]) #end_points_res_adv['probs'] = tf.nn.softmax(end_points_res_v1_50['logits']) processed_imgs_vgg_16 = preprocess_for_model(image, 'vgg_16') with slim.arg_scope(vgg.vgg_arg_scope()): logits_vgg_adv, end_points_vgg_adv = vgg.vgg_16( processed_imgs_vgg_16, num_classes=num_classes, is_training=False, scope='adv_vgg') end_points_vgg_adv['logits'] = end_points_vgg_adv['adv_vgg/fc8'] end_points_vgg_adv['probs'] = tf.nn.softmax(end_points_vgg_adv['logits']) ######################## # Using model predictions as ground truth to avoid label leaking one_hot = tf.one_hot(y, num_classes) logits = (end_points_inc_v1['Logits'] + end_points_res_v1_50['logits'] \ + end_points_vgg_16['logits'] + end_points_inc_adv['Logits'] \ + end_points_vgg_adv['logits']) \ /5.0 logits = tf.cond(tf.less(i, cond_number), lambda: logits, lambda: end_points_vgg_16['logits']) cross_entropy = tf.losses.softmax_cross_entropy(one_hot, logits, label_smoothing=0.0, weights=1.0) noise = tf.gradients(cross_entropy, x)[0] kernel = gkern(7, 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, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) noise = momentum * grad + noise noise = noise / tf.reshape( tf.contrib.keras.backend.std(tf.reshape(noise, [batch_size, -1]), axis=1), [batch_size, 1, 1, 1]) x = x - alpha * tf.clip_by_value(tf.round(noise), -10, 10) x = tf.clip_by_value(x, x_min, x_max) i = tf.add(i, 1) ############################PGD################ #eta = x - ori_x #eta = clip_eta(eta, ord = np.inf, eps=eps) #x = ori_x + eta #x = tf.clip_by_value(x, x_min, x_max) ############################################## return ori_x, x, y, i, x_max, x_min, noise