def predict_slim(sample_images, print_func=print): """ Code modified from here: [https://github.com/tensorflow/models/issues/429] """ # Setup preprocessing input_tensor = tf.placeholder(tf.float32, shape=(None, 299, 299, 3), name='input_image') scaled_input_tensor = tf.scalar_mul((1.0 / 255), input_tensor) scaled_input_tensor = tf.subtract(scaled_input_tensor, 0.5) scaled_input_tensor = tf.multiply(scaled_input_tensor, 2.0) # Setup session sess = tf.Session() arg_scope = slim_irv2.inception_resnet_v2_arg_scope() with slim.arg_scope(arg_scope): _, end_points = slim_irv2.inception_resnet_v2(scaled_input_tensor, is_training=False) # Load the model print_func("Loading TF-slim checkpoint...") saver = tf.train.Saver() saver.restore(sess, SLIM_CKPT) # Make prediction predict_values = [] for image in sample_images: im = Image.open(image).resize((299, 299)) arr = np.expand_dims(np.array(im), axis=0) y_pred = sess.run([end_points['Predictions']], feed_dict={input_tensor: arr}) y_pred = y_pred[0].ravel() y_pred = y_pred[1:] / y_pred[1:].sum() # remove background class and renormalize print_func("{} class={} prob={}".format(image, np.argmax(y_pred), np.max(y_pred))) predict_values.append(y_pred) return predict_values
def _extract_proposal_features(self, preprocessed_inputs, scope): """Extracts first stage RPN features. Extracts features using the first half of the Inception Resnet v2 network. We construct the network in `align_feature_maps=True` mode, which means that all VALID paddings in the network are changed to SAME padding so that the feature maps are aligned. Args: preprocessed_inputs: A [batch, height, width, channels] float32 tensor representing a batch of images. scope: A scope name. Returns: rpn_feature_map: A tensor with shape [batch, height, width, depth] Raises: InvalidArgumentError: If the spatial size of `preprocessed_inputs` (height or width) is less than 33. ValueError: If the created network is missing the required activation. """ if len(preprocessed_inputs.get_shape().as_list()) != 4: raise ValueError('`preprocessed_inputs` must be 4 dimensional, got a ' 'tensor of shape %s' % preprocessed_inputs.get_shape()) with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope( weight_decay=self._weight_decay)): # Forces is_training to False to disable batch norm update. with slim.arg_scope([slim.batch_norm], is_training=self._train_batch_norm): with tf.variable_scope('InceptionResnetV2', reuse=self._reuse_weights) as scope: return inception_resnet_v2.inception_resnet_v2_base( preprocessed_inputs, final_endpoint='PreAuxLogits', scope=scope, output_stride=self._first_stage_features_stride, align_feature_maps=True)
def _extract_box_classifier_features(self, proposal_feature_maps, scope): """Extracts second stage box classifier features. This function reconstructs the "second half" of the Inception ResNet v2 network after the part defined in `_extract_proposal_features`. Args: proposal_feature_maps: A 4-D float tensor with shape [batch_size * self.max_num_proposals, crop_height, crop_width, depth] representing the feature map cropped to each proposal. scope: A scope name. Returns: proposal_classifier_features: A 4-D float tensor with shape [batch_size * self.max_num_proposals, height, width, depth] representing box classifier features for each proposal. """ with tf.variable_scope('InceptionResnetV2', reuse=self._reuse_weights): with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope( weight_decay=self._weight_decay)): # Forces is_training to False to disable batch norm update. with slim.arg_scope([slim.batch_norm], is_training=self._train_batch_norm): with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'): with tf.variable_scope('Mixed_7a'): with tf.variable_scope('Branch_0'): tower_conv = slim.conv2d(proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv_1 = slim.conv2d( tower_conv, 384, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_1'): tower_conv1 = slim.conv2d( proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv1_1 = slim.conv2d( tower_conv1, 288, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_2'): tower_conv2 = slim.conv2d( proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv2_1 = slim.conv2d(tower_conv2, 288, 3, scope='Conv2d_0b_3x3') tower_conv2_2 = slim.conv2d( tower_conv2_1, 320, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_3'): tower_pool = slim.max_pool2d( proposal_feature_maps, 3, stride=2, padding='VALID', scope='MaxPool_1a_3x3') net = tf.concat( [tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool], 3) net = slim.repeat(net, 9, inception_resnet_v2.block8, scale=0.20) net = inception_resnet_v2.block8(net, activation_fn=None) proposal_classifier_features = slim.conv2d( net, 1536, 1, scope='Conv2d_7b_1x1') return proposal_classifier_features
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 # should keep original x here for output with slim.arg_scope(inception_v3.inception_v3_arg_scope()): logits_v3, end_points_v3 = inception_v3.inception_v3( input_diversity(x), num_classes=num_classes, is_training=False) with slim.arg_scope(inception_v4.inception_v4_arg_scope()): logits_v4, end_points_v4 = inception_v4.inception_v4( input_diversity(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( input_diversity(x), num_classes=num_classes, is_training=False, reuse=True) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits_resnet, end_points_resnet = resnet_v2.resnet_v2_152( input_diversity(x), num_classes=num_classes, is_training=False) logits = (logits_v3 + logits_v4 + logits_res_v2 + logits_resnet) / 4 auxlogits = (end_points_v3['AuxLogits'] + end_points_v4['AuxLogits'] + end_points_res_v2['AuxLogits']) / 3 cross_entropy = tf.losses.softmax_cross_entropy(y, logits, label_smoothing=0.0, weights=1.0) cross_entropy += tf.losses.softmax_cross_entropy(y, auxlogits, label_smoothing=0.0, weights=0.4) 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.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 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 num_classes = 1001 batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] tf.logging.set_verbosity(tf.logging.INFO) print(time.time() - start_time) with tf.Graph().as_default(): # Prepare graph 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) with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): _, end_points = inception_resnet_v2.inception_resnet_v2( x_input, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) y = tf.one_hot(predicted_labels, num_classes) i = tf.constant(0) grad = tf.zeros(shape=batch_shape) x_adv, _, _, _, _, _ = tf.while_loop( stop, graph, [x_input, y, i, x_max, x_min, grad]) # Run computation s1 = tf.train.Saver(slim.get_model_variables(scope='InceptionV3')) s5 = tf.train.Saver(slim.get_model_variables(scope='InceptionV4')) s6 = tf.train.Saver( slim.get_model_variables(scope='InceptionResnetV2')) s8 = tf.train.Saver(slim.get_model_variables(scope='resnet_v2')) with tf.Session() as sess: s1.restore(sess, FLAGS.checkpoint_path_inception_v3) s5.restore(sess, FLAGS.checkpoint_path_inception_v4) s6.restore(sess, FLAGS.checkpoint_path_inception_resnet_v2) s8.restore(sess, FLAGS.checkpoint_path_resnet) print(time.time() - start_time) for filenames, images in load_images(FLAGS.input_dir, batch_shape): adv_images = sess.run(x_adv, feed_dict={x_input: images}) save_images(adv_images, filenames, FLAGS.output_dir) print(time.time() - start_time)
def __init__(self, num_classes): self.num_classes = num_classes with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): self.network_fn_incep_res = inception_resnet_v2.inception_resnet_v2 with slim.arg_scope(vgg.vgg_arg_scope()): self.network_fn_vgg16 = vgg.vgg_16 with slim.arg_scope(resnet_v2.resnet_arg_scope()): self.network_fn_res = resnet_v2.resnet_v2_152 with slim.arg_scope(inception_utils.inception_arg_scope()): self.network_fn_incepv3 = inception_v3.inception_v3 self.network_fn_incepv4 = inception_v4.inception_v4 self.network_fn_alex = AlexNet() self.build = False
def feature_extractor(image_path, options=None): """Runs a trained version of inception-resnet-v2 on an image and extracts the inputs from the final layer before the fully connected stages. Args: image_path: the path to the image options: in this case options is not used Return: an array of features which depending on the config options """ # size of images inc-resnet is compatible with image_size = inception_resnet_v2.inception_resnet_v2.default_image_size checkpoint_path = os.path.join( dir, 'checkpoints/inception_resnet_v2_2016_08_30.ckpt') image_string = urllib2.urlopen(image_path).read() # JPEG format converted to unit8 tensor image = tf.image.decode_jpeg(image_string, channels=3) # inception specific pre processing processed_image = inception_preprocessing.preprocess_image( image, image_size, image_size, is_training=False) # the model accepts images in batches processed_images = tf.expand_dims(processed_image, 0) with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()): logits, end_points = inception_resnet_v2.inception_resnet_v2( processed_images, num_classes=1001, is_training=False) weights_from_file = slim.get_variables_to_restore(exclude=['logits']) init_fn = slim.assign_from_checkpoint_fn(checkpoint_path, weights_from_file) # last layer before fully connected layer features = end_points['PreLogitsFlatten'] # run the image through the network with tf.Session() as sess: init_fn(sess) features = sess.run([features]) return features[0][0]
def _build(self, x_input=None): reuse = True if self.built else None if x_input is None: x_input = self.input with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()): logits, end_points = inception_resnet_v2.inception_resnet_v2( x_input, num_classes=self.num_classes, is_training=False, reuse=reuse) self.built = True self.end_points = end_points self.logits = logits if not self.ckpt_loaded: saver = tf.train.Saver(slim.get_model_variables()) saver.restore(self.sess, ckpt_dir + 'inception_resnet_v2.ckpt') self.ckpt_loaded = True
def _extract_proposal_features(self, preprocessed_inputs, scope): """Extracts first stage RPN features. Extracts features using the first half of the Inception Resnet v2 network. We construct the network in `align_feature_maps=True` mode, which means that all VALID paddings in the network are changed to SAME padding so that the feature maps are aligned. Args: preprocessed_inputs: A [batch, height, width, channels] float32 tensor representing a batch of images. scope: A scope name. Returns: rpn_feature_map: A tensor with shape [batch, height, width, depth] Raises: InvalidArgumentError: If the spatial size of `preprocessed_inputs` (height or width) is less than 33. ValueError: If the created network is missing the required activation. """ if len(preprocessed_inputs.get_shape().as_list()) != 4: raise ValueError( '`preprocessed_inputs` must be 4 dimensional, got a ' 'tensor of shape %s' % preprocessed_inputs.get_shape()) shape_assert = tf.Assert( tf.logical_and( tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33), tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)), ['image size must at least be 33 in both height and width.']) with tf.control_dependencies([shape_assert]): with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope( weight_decay=self._weight_decay)): # Forces is_training to False to disable batch norm update. with slim.arg_scope([slim.batch_norm], is_training=False): with tf.variable_scope('InceptionResnetV2', reuse=self._reuse_weights) as scope: rpn_feature_map, _ = ( inception_resnet_v2.inception_resnet_v2_base( preprocessed_inputs, final_endpoint='PreAuxLogits', scope=scope, output_stride=self. _first_stage_features_stride, align_feature_maps=True)) return rpn_feature_map
def graph(x, y, i, x_max, x_min, grad, eg): eps = 2.0 * FLAGS.max_epsilon / 255.0 num_iter = FLAGS.num_iter alpha = eps / num_iter num_classes = 1001 ro = 0.9 beta = 0.89 v = 0.1 eg = ro * eg + (1 - ro) * tf.square(grad) rms = tf.sqrt(eg + 0.000000001) x_n = x + (alpha / rms)*grad with slim.arg_scope(inception_v3.inception_v3_arg_scope()): logits_v3, end_points_v3 = inception_v3.inception_v3( input_diversity(x_n), num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE) with slim.arg_scope(inception_v4.inception_v4_arg_scope()): logits_v4, end_points_v4 = inception_v4.inception_v4( input_diversity(x_n), num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE) 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( input_diversity(x_n), num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits_resnet, end_points_resnet = resnet_v2.resnet_v2_101( input_diversity(x_n), num_classes=num_classes, is_training=False, scope='resnet_v2_101', reuse=tf.AUTO_REUSE) logits = (logits_v3 + logits_v4 + logits_res_v2 + logits_resnet) / 4 auxlogits = (end_points_v3['AuxLogits'] + end_points_v4['AuxLogits'] + end_points_res_v2['AuxLogits']) / 3 cross_entropy = tf.losses.softmax_cross_entropy(y, logits, label_smoothing=0.0, weights=1.0) cross_entropy += tf.losses.softmax_cross_entropy(y, auxlogits, label_smoothing=0.0, weights=0.4) noise = tf.gradients(cross_entropy, x_n)[0] noise = tf.nn.depthwise_conv2d(noise, stack_kernel, strides=[1, 1, 1, 1], padding='SAME') noise1 = noise / tf.reduce_mean(tf.abs(noise), [1, 2, 3], keep_dims=True) noise = beta * grad + (1-beta) * noise1 noise2 = (1-v) * noise + v * noise1 x = x + alpha * tf.sign(noise2) x = tf.clip_by_value(x, x_min, x_max) i = tf.add(i, 1) return x, y, i, x_max, x_min, noise, eg
def graph(x, adv, y, t_y, i, x_max, x_min, grad, amplification): target_one_hot = tf.one_hot(t_y, 1001) true_one_hot = tf.one_hot(y, 1001) eps = 2.0 * FLAGS.max_epsilon / 255.0 num_iter = FLAGS.num_iter alpha = eps / num_iter alpha_beta = alpha gamma = alpha_beta 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( # adv, num_classes=num_classes, is_training=False, reuse = True) # auxlogit_v3 = end_points_v3['AuxLogits'] with slim.arg_scope(inception_v4.inception_v4_arg_scope()): logits_v4, end_points_v4 = inception_v4.inception_v4( adv, num_classes=num_classes, is_training=False, reuse=True) auxlogit_v4 = end_points_v4['AuxLogits'] with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits_resnet_152, end_points_resnet = resnet_v2.resnet_v2_152( adv, num_classes=num_classes, is_training=False, reuse=True) with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()): logits_Incres, end_points_IR = inception_resnet_v2.inception_resnet_v2( adv, num_classes=num_classes, is_training=False, reuse=True) auxlogit_IR = end_points_IR['AuxLogits'] logits = (logits_Incres + logits_resnet_152 + logits_v4) / 3.0 auxlogit = (auxlogit_IR + auxlogit_v4) / 2.0 target_cross_entropy = tf.losses.softmax_cross_entropy(target_one_hot, logits, label_smoothing=0.0, weights=1.0) target_cross_entropy += tf.losses.softmax_cross_entropy( target_one_hot, auxlogit, label_smoothing=0.0, weights=1.0) noise = tf.gradients(target_cross_entropy, adv)[0] adv = adv - alpha * n_staircase_sign(noise, num_of_K) adv = tf.clip_by_value(adv, x_min, x_max) i = tf.add(i, 1) return x, adv, y, t_y, i, x_max, x_min, noise, amplification
def graph(x, y, i, x_max, x_min, grad, eps_inside): num_iter = FLAGS.num_iter alpha = eps_inside / 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, scope='Ens3AdvInceptionV3') 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(resnet_v2.resnet_arg_scope()): logits_resnet, end_points_resnet = resnet_v2.resnet_v2_50( x, num_classes=num_classes, is_training=False) pred = tf.argmax( end_points_v3['Predictions'] + end_points_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 + logits_res_v2 + logits_resnet) / 3 auxlogits = (end_points_v3['AuxLogits'] + end_points_res_v2['AuxLogits']) / 2 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] 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, eps_inside
def graph(x, y, i, grad): num_classes = 1001 x = x 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(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_v4['Predictions'] + end_points_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 return x, y, i, grad
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 predict_slim(sample_images, print_func=print): """ Code modified from here: [https://github.com/tensorflow/models/issues/429] """ # Setup preprocessing input_tensor = tf.placeholder(tf.float32, shape=(None, 299, 299, 3), name='input_image') scaled_input_tensor = tf.scalar_mul((1.0 / 255), input_tensor) scaled_input_tensor = tf.subtract(scaled_input_tensor, 0.5) scaled_input_tensor = tf.multiply(scaled_input_tensor, 2.0) # Setup session sess = tf.Session() arg_scope = slim_irv2.inception_resnet_v2_arg_scope() with tf_slim.arg_scope(arg_scope): _, end_points = slim_irv2.inception_resnet_v2(scaled_input_tensor, is_training=False) # Load the model print_func("Loading TF-slim checkpoint...") saver = tf.train.Saver() saver.restore(sess, SLIM_CKPT) # Make prediction predict_values = [] for image in sample_images: im = Image.open(image).resize((299, 299)) arr = np.expand_dims(np.array(im), axis=0) y_pred = sess.run([end_points['Predictions']], feed_dict={input_tensor: arr}) y_pred = y_pred[0].ravel() y_pred = y_pred[1:] / y_pred[1:].sum( ) # remove background class and renormalize print_func("{} class={} prob={}".format(image, np.argmax(y_pred), np.max(y_pred))) predict_values.append(y_pred) return predict_values
def model_fn(images, labels, num_classes, mode): with tf.contrib.slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): logits, end_points = inception_resnet_v2.inception_resnet_v2( images, num_classes, is_training=(mode == tf.estimator.ModeKeys.TRAIN)) predictions = { 'classes': tf.argmax(input=logits, axis=1), 'probabilities': tf.nn.softmax(logits, name='softmax_tensor') } if mode == tf.estimator.ModeKeys.PREDICT: return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) exclude = ['InceptionResnetV2/Logits', 'InceptionResnetV2/AuxLogits'] variables_to_restore = tf.contrib.slim.get_variables_to_restore( exclude=exclude) scopes = {os.path.dirname(v.name) for v in variables_to_restore} tf.train.init_from_checkpoint('inception_resnet_v2_2016_08_30.ckpt', {s + '/': s + '/' for s in scopes}) tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits) total_loss = tf.losses.get_total_loss( ) #obtain the regularization losses as well # Configure the training op if mode == tf.estimator.ModeKeys.TRAIN: global_step = tf.train.get_or_create_global_step() optimizer = tf.train.AdamOptimizer(learning_rate=0.00002) train_op = optimizer.minimize(total_loss, global_step) else: train_op = None return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions, loss=total_loss, train_op=train_op)
def __init__(self): self.sessIR = tf.Session() self.labels_names = self.imagenet_labels() self.image_sizeIR = inception_resnet_v2.inception_resnet_v2.default_image_size # Define Inception Resnet v2 neural network self.processed_imagesIR = tf.placeholder(tf.float32, shape=(None, self.image_sizeIR, self.image_sizeIR, 3)) with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): logitsIR, _ = inception_resnet_v2.inception_resnet_v2( self.processed_imagesIR, num_classes=1001, is_training=False) self.probabilitiesIR = tf.nn.softmax(logitsIR) # Load saved checkpoint for Resnet v2 neural network checkpoints_dir = './checkpoints' init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'inception_resnet_v2_2016_08_30.ckpt'), slim.get_model_variables('InceptionResnetV2')) init_fn(self.sessIR)
def net_inception(images, is_training=True, num_classes_finetune=10, finetune_dropout_keep=0.75): # from tensorflow.contrib import slim # from nets import inception_resnet_v2 as inception with slim.arg_scope([slim.conv2d, slim.fully_connected]): with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): net, end_points = inception.inception_resnet_v2(images, num_classes=None, is_training=is_training) end_points["baseline"] = net # # add finetune layer, with adjusted dropout_keep_prob # net = slim.flatten(net) net = slim.dropout(net, finetune_dropout_keep, is_training=is_training, scope='Dropout') end_points['PreLogitsFlatten'] = net logits = slim.fully_connected(net, num_classes_finetune, activation_fn=None, scope='Logits') end_points['finetune'] = end_points['Logits'] = logits end_points['Predictions'] = tf.nn.softmax(logits, name='Predictions') return [net, end_points]
def main(_): # eps = FLAGS.max_epsilon / 255.0 eps = 2.0 / 255.0 batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] num_classes = 1001 tf.logging.set_verbosity(tf.logging.INFO) origin_preds = {} flip_preds = {} all_filenames = [] # Origin with tf.Graph().as_default(): # Prepare graph # x_input is a binary image (converted in the load_images phase) x_input = tf.placeholder(tf.float32, shape=batch_shape) with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): _, end_points = inception_resnet_v2.inception_resnet_v2( x_input, num_classes=num_classes, is_training=False) predictions = end_points['Predictions'] # 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): pred = sess.run(predictions, feed_dict={x_input: images}) for filename, p in zip(filenames, list(pred)): origin_preds[filename] = p # Keep the filename as well all_filenames.append(filename) # Flip # tf.reset_default_graph() with tf.Graph().as_default(): # Prepare graph # x_input is a binary image (converted in the load_images phase) x_input = tf.placeholder(tf.float32, shape=batch_shape) x_input_flip = tf.image.flip_left_right(x_input) with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): _, end_points = inception_resnet_v2.inception_resnet_v2( x_input_flip, num_classes=num_classes, is_training=False) predictions = end_points['Predictions'] # 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): pred = sess.run(predictions, feed_dict={x_input: images}) for filename, p in zip(filenames, list(pred)): flip_preds[filename] = p # Merge for filename in all_filenames: p = (origin_preds[filename] + flip_preds[filename]) / 2 p_str = " ".join([str(i) for i in list(p)]) out_file.write('{0},{1}\n'.format(filename, p_str))