def __init__(self, w_decay, keep_p, optimizer, input_shape=[None, 28, 28], input_reshape=[-1, 28, 28, 1]): self.img_size = inception.inception_v1.default_image_size self.features = tf.placeholder(tf.float32, input_shape) self.images = tf.reshape(self.features, input_reshape) self.images = tf.image.resize_images(self.images, [self.img_size, self.img_size]) self.labels = tf.placeholder(tf.float32, [None, 10]) self.labels = tf.cast(self.labels, tf.int32) with tf.variable_scope("Inception") as scope: self.train_digits, _ = inception.inception_v1(self.images, num_classes=10, is_training=True) scope.reuse_variables() self.pred_digits, _ = inception.inception_v1(self.images, num_classes=10, is_training=False) self.logits = self.pred_digits self.correct_prediction = tf.equal(tf.argmax(self.pred_digits, 1), tf.argmax(self.labels, 1)) self.accuracy = tf.reduce_mean( tf.cast(self.correct_prediction, "float")) self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( labels=self.labels, logits=self.train_digits)) self.train_op = optimizer.minimize(self.loss)
def testNoBatchNormScaleByDefault(self): height, width = 224, 224 num_classes = 1000 inputs = tf.placeholder(tf.float32, (1, height, width, 3)) with slim.arg_scope(inception.inception_v1_arg_scope()): inception.inception_v1(inputs, num_classes, is_training=False) self.assertEqual(tf.global_variables('.*/BatchNorm/gamma:0$'), [])
def testBatchNormScale(self): height, width = 224, 224 num_classes = 1000 inputs = tf.placeholder(tf.float32, (1, height, width, 3)) with slim.arg_scope( inception.inception_v1_arg_scope(batch_norm_scale=True)): inception.inception_v1(inputs, num_classes, is_training=False) gamma_names = set( v.op.name for v in tf.global_variables('.*/BatchNorm/gamma:0$')) self.assertGreater(len(gamma_names), 0) for v in tf.global_variables('.*/BatchNorm/moving_mean:0$'): self.assertIn(v.op.name[:-len('moving_mean')] + 'gamma', gamma_names)
def testTrainEvalWithReuse(self): train_batch_size = 5 eval_batch_size = 2 height, width = 224, 224 num_classes = 1000 train_inputs = tf.random_uniform((train_batch_size, height, width, 3)) inception.inception_v1(train_inputs, num_classes) eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3)) logits, _ = inception.inception_v1(eval_inputs, num_classes, reuse=True) predictions = tf.argmax(logits, 1) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) output = sess.run(predictions) self.assertEquals(output.shape, (eval_batch_size,))
def __set_up_inception(self): self.num_clss = self.config["Model"]["InceptionV1"]["num_clss"] self.map_path = self.config["Model"]["InceptionV1"]["map_path"] self.X = tf.placeholder(tf.float32, shape=[ None, self.config["image"]["height"], self.config["image"]["width"], self.config["image"]["num_channels"] ]) with slim.arg_scope(inception.inception_v1_arg_scope()): self.logits, self.end_points = inception.inception_v1( self.X, num_classes=self.num_clss, is_training=False, m_w=self.config["mantissa_width"], e_w=self.config["exponent_width"], s_w=self.config["shared_exponent_width"], alter=self.config["quantize"], debug=self.config["debug_layer"]) self.predictions = self.end_points["Predictions"] self.variables_to_restore = slim.get_variables_to_restore() self.init_assign_fn = slim.assign_from_checkpoint_fn( self.config["to_ckpt"] + self.config["Model"]["InceptionV1"]["ckpt_path"], self.variables_to_restore)
def build(self, dataset, image_height, image_width, num_classes, is_training): images, labels = self._load_batch(dataset, height=image_height, width=image_width) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception_v1_arg_scope()): logits, end_points = inception_v1(images, num_classes=num_classes, is_training=is_training) # Specify the loss function: one_hot_labels = slim.one_hot_encoding(labels, num_classes) loss = slim.losses.softmax_cross_entropy(logits, one_hot_labels) # Create some summaries to visualize the training process: tf.summary.scalar('losses/Total Loss', loss) if is_training: # Specify the optimizer and create the train op: optimizer = tf.train.RMSPropOptimizer(learning_rate=0.01) variables_to_train = [] for scope in self.trainable_scopes: variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope) variables_to_train.extend(variables) variables = slim.get_model_variables("InceptionV1/Logits") exec_op = slim.learning.create_train_op(loss, optimizer, variables_to_train=variables) else: exec_op = end_points['Predictions'] if self.checkpoints_file is not None: self.init_fn = self._get_init_fn() return exec_op, tf.get_default_graph()
def evaluate_inceptionV1_bin(batch_size): with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) global_step = slim.get_or_create_global_step() # Summary dataset = plantVSnoplant.get_split('validation', plantVSnoplant_data_dir) images,labels = load_batch(dataset, batch_size = batch_size, k=0, r=[], is_training =False) with slim.arg_scope(inception.inception_v1_arg_scope(weight_decay=weight_decay)): logits, _ = inception.inception_v1(images, num_classes=2, is_training=False) total_output = [] total_labels = [] total_images = [] with tf.Session() as sess: coord = tf.train.Coordinator() saver = tf.train.Saver() saver.restore(sess, tf.train.latest_checkpoint(train_inceptionV1_bin_dir)) threads = tf.train.start_queue_runners(sess=sess, coord=coord) for i in range(batch_size): print('step: %d/%d' % (i, batch_size)) o, l , image= sess.run([logits, labels, images[0]]) o = tf.reduce_sum(o, 0)/float(5) total_output.append(o) total_labels.append(l[0]) total_images.append(image) coord.request_stop() coord.join(threads) total_output = tf.stack(total_output,0) total_output = tf.nn.softmax(total_output) labels = tf.constant(total_labels) total_images = sess.run(tf.stack(total_images,0)) top1_op = tf.nn.in_top_k(total_output, labels, 1) top1_acc = sess.run(tf.reduce_mean(tf.cast(top1_op, tf.float32))) print(top1_acc) top5_op = tf.nn.in_top_k(total_output, labels, 5) top5_acc = sess.run(tf.reduce_mean(tf.cast(top5_op, tf.float32))) print(top5_acc) accuracy1_sum = tf.summary.scalar('top1_accuracy', top1_acc) accuracy5_sum = tf.summary.scalar('top5_accuracy', top5_acc) images_sum = tf.summary.image("input_images", total_images, batch_size) accuracy1, accuracy5, image_batch, step = sess.run([accuracy1_sum,accuracy5_sum,images_sum, global_step]) writer = tf.summary.FileWriter(eval_inceptionV1_bin_dir) writer.add_summary(accuracy1, step) writer.add_summary(accuracy5, step) writer.add_summary(image_batch)
def testLogitsNotSqueezed(self): num_classes = 25 images = tf.random_uniform([1, 224, 224, 3]) logits, _ = inception.inception_v1(images, num_classes=num_classes, spatial_squeeze=False) with self.test_session() as sess: tf.global_variables_initializer().run() logits_out = sess.run(logits) self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
def testLogitsNotSqueezed(self): num_classes = 25 images = tf.random_uniform([1, 224, 224, 3]) logits, _ = inception.inception_v1(images, num_classes=num_classes, spatial_squeeze=False) with self.test_session() as sess: tf.initialize_all_variables().run() logits_out = sess.run(logits) self.assertListEqual(list(logits_out.shape), [1, 1, 1, num_classes])
def train_inceptionV1(log_steps,save_summaries_sec,save_interval_secs,num_iterations = num_iterations_inception): with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES)) global_step = slim.get_or_create_global_step() dataset = plantclef2015.get_split('train', plant_data_dir) images,labels = load_batch(dataset, batch_size = batch_size, k=num_patches_inception, r=r_rotations_inception) # Add Images to summaries summaries.add(tf.summary.image("input_images", images, batch_size)) # Create the models with slim.arg_scope(inception.inception_v1_arg_scope(weight_decay=weight_decay)): logits, _ = inception.inception_v1(images, num_classes=1000, is_training=True) # Specify the loss function: one_hot_labels = slim.one_hot_encoding(labels, dataset.num_classes) loss(logits, one_hot_labels) #slim.losses.softmax_cross_entropy(logits, one_hot_labels) total_loss = slim.losses.get_total_loss() # Create some summaries to visualize the training process: for variable in slim.get_model_variables(): summaries.add(tf.summary.histogram(variable.op.name, variable)) summaries.add(tf.summary.scalar('losses/Total_Loss', total_loss)) # Specify the optimizer and create the train op: learning_rate = tf.train.exponential_decay(start_learning_rate, global_step,updating_iteration_for_learning_rate, updating_gamma, staircase=True) optimizer = tf.train.MomentumOptimizer(learning_rate= learning_rate, momentum=momentum) train_op = slim.learning.create_train_op(total_loss, optimizer) summaries.add(tf.summary.scalar('training/Learning_Rate', learning_rate)) summary_op = tf.summary.merge(list(summaries), name='summary_op') # Run the training: final_loss = slim.learning.train( train_op, logdir=train_inceptionV1_dir, log_every_n_steps=log_steps, global_step=global_step, number_of_steps= num_iterations, summary_op=summary_op, init_fn=get_init_fn_V1(), save_summaries_secs=save_summaries_sec, save_interval_secs=save_interval_secs) print('Finished training. Last batch loss %f' % final_loss)
def extract_feat(frames_name): """ Reference: 1. Vasili's codes 2. https://github.com/tensorflow/models/issues/429#issuecomment-277885861 """ slim_dir = "/home/xyang/workspace/models/research/slim" checkpoints_dir = slim_dir + "/pretrain" checkpoints_file = checkpoints_dir + '/inception_v1.ckpt' batch_size = 256 sys.path.append(slim_dir) from nets import inception import tensorflow as tf slim = tf.contrib.slim image_size = inception.inception_v1.default_image_size feat = [] with tf.Graph().as_default(): input_batch = tf.placeholder(dtype=tf.uint8, shape=(batch_size, 300, 300, 3)) resized_images = tf.image.resize_images( tf.image.convert_image_dtype(input_batch, dtype=tf.float32), [image_size, image_size] ) preprocessed_images = tf.multiply(tf.subtract(resized_images, 0.5), 2.0) # Create the model, use the default arg scope to configure # the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, endpoints = inception.inception_v1(preprocessed_images, num_classes=1001, is_training=False) pool5 = endpoints['AvgPool_0a_7x7'] with tf.Session() as sess: saver = tf.train.Saver() saver.restore(sess, checkpoints_file) for i in range(0, len(frames_name), batch_size): print (i, '/', len(frames_name)) current_batch = np.zeros((batch_size, 300, 300, 3), dtype=np.uint8) for j in range(batch_size): if i+j == len(frames_name): j -= 1 break img = Image.open(frames_name[i+j]).convert('RGB').resize((300,300)) current_batch[j] = np.array(img) feat_batch = sess.run(pool5, feed_dict={input_batch: current_batch}) feat_batch = np.squeeze(feat_batch) feat.append(feat_batch[:j+1].astype('float32')) return np.concatenate(feat, axis=0)
def predict(train_dir, test_dir, output_file, num_classes): """ Loads weights from a TF model and makes predictions. Arguments: train_dir: directory of trained model test_dir: directory of test images (split into folders by class) output_file: output file to store predictions num_classes: number of classes of prediction Returns: Outpiuts a file output_file with predictions """ train_dir = train_dir test_path = test_dir output = output_file nb_classes = num_classes print('Start to read images!') image_list = get_test_images(test_path) processed_images = tf.placeholder(tf.float32, shape=(None, image_size, image_size, 3)) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(processed_images, num_classes=nb_classes, is_training=False) def predict_fn(images): return session.run(probabilities, feed_dict={processed_images: images}) probabilities = tf.nn.softmax(logits) #Loads in latest training checkpoint checkpoint_path = tf.train.latest_checkpoint(train_dir) init_fn = slim.assign_from_checkpoint_fn(checkpoint_path,slim.get_variables_to_restore()) init_fn(session) print('Start to transform images!') images = transform_img_fn(image_list) fto = open(output, 'w') print('Start doing predictions!') preds = predict_fn(images) print (len(preds)) for p in range(len(preds)): print (image_list[p], preds[p,:], np.argmax(preds[p,:])) fto.write(image_list[p]) for j in range(len(preds[p,:])): fto.write('\t' + str(preds[p, j])) fto.write('\n') fto.close()
def adapt_pretrain_imagenet_to_flower(): import os from datasets import flowers from nets import inception from preprocessing import inception_preprocessing slim = tf.contrib.slim image_size = inception.inception_v1.default_image_size def get_init_fn(): checkpoint_exclude_scopes = [ 'InceptionV1/Logits', 'InceptionV1/AuxLogits' ] exclusions = [scope.strip() for scope in checkpoint_exclude_scopes] variables_to_restore = [] for var in slim.get_model_variables(): excluded = False for exclusion in exclusions: if var.op.name.startswith(exclusion): excluded = True break if not excluded: variables_to_restore.append(var) return slim.assign_from_checkpoint_fn( os.path.join(checkpoint_dir, 'inception_v1.ckpt'), variables_to_restore) with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) dataset = flowers.get_split('train', flower_data_dir) images, _, labels = load_batch(dataset, height=image_size, width=image_size) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1( images, num_classes=dataset.num_classes, is_training=True) 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.scalar_summary('losses/Total Loss', total_loss) optimizer = tf.train.AdamOptimizer(learning_rate=0.01) train_op = slim.learning.create_train_op(total_loss, optimizer) final_loss = slim.learning.train(train_op, logdir=train_dir, init_fn=get_init_fn(), number_of_steps=2) print("Finished training. Las batch loss %f" % final_loss)
def testBuildPreLogitsNetwork(self): batch_size = 5 height, width = 224, 224 num_classes = None inputs = tf.random_uniform((batch_size, height, width, 3)) net, end_points = inception.inception_v1(inputs, num_classes) self.assertTrue(net.op.name.startswith('InceptionV1/Logits/AvgPool')) self.assertListEqual(net.get_shape().as_list(), [batch_size, 1, 1, 1024]) self.assertFalse('Logits' in end_points) self.assertFalse('Predictions' in end_points)
def testBuildClassificationNetwork(self): batch_size = 5 height, width = 224, 224 num_classes = 1000 inputs = tf.random_uniform((batch_size, height, width, 3)) logits, end_points = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith("InceptionV1/Logits")) self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes]) self.assertTrue("Predictions" in end_points) self.assertListEqual(end_points["Predictions"].get_shape().as_list(), [batch_size, num_classes])
def testBuildClassificationNetwork(self): batch_size = 5 height, width = 224, 224 num_classes = 1000 inputs = tf.random_uniform((batch_size, height, width, 3)) logits, end_points = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith('InceptionV1/Logits')) self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes]) self.assertTrue('Predictions' in end_points) self.assertListEqual(end_points['Predictions'].get_shape().as_list(), [batch_size, num_classes])
def get_network_logits_and_endpoints(network, images): if(network == 'inceptionV1'): with slim.arg_scope(inception.inception_v1_arg_scope(weight_decay=weight_decay)): logits, endpoints = inception.inception_v1(images, num_classes=1000, is_training=False) elif(network == 'vgg16'): with slim.arg_scope(vgg.vgg_arg_scope(weight_decay=weight_decay)): logits, endpoints = vgg.vgg_16(images, num_classes=1000, is_training=False) return logits,endpoints
def testEvaluation(self): batch_size = 2 height, width = 224, 224 num_classes = 1000 eval_inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = inception.inception_v1(eval_inputs, num_classes, is_training=False) predictions = tf.argmax(logits, 1) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) output = sess.run(predictions) self.assertEquals(output.shape, (batch_size,))
def testEvaluation(self): batch_size = 2 height, width = 224, 224 num_classes = 1000 eval_inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = inception.inception_v1(eval_inputs, num_classes, is_training=False) predictions = tf.argmax(logits, 1) with self.test_session() as sess: sess.run(tf.initialize_all_variables()) output = sess.run(predictions) self.assertEquals(output.shape, (batch_size,))
def apply_pretrained_model(): import numpy as np import os import tensorflow as tf import urllib2 from datasets import imagenet from nets import inception from preprocessing import inception_preprocessing slim = tf.contrib.slim batch_size = 3 image_size = inception.inception_v1.default_image_size with tf.Graph().as_default(): url = 'https://upload.wikimedia.org/wikipedia/commons/7/70/EnglishCockerSpaniel_simon.jpg' image_string = urllib2.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.inception_v1_arg_scope()): logits, _ = inception.inception_v1(processed_images, num_classes=1001, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoint_dir, 'inception_v1.ckpt'), slim.get_model_variables('InceptionV1')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) probabilities = probabilities[0, 0:] sorted_inds = [ i[0] for i in sorted(enumerate(-probabilities), key=lambda x: x[1]) ] plt.figure() plt.imshow(np_image.astype(np.uint8)) plt.axis('off') plt.show() names = imagenet.create_readable_names_for_imagenet_labels() for i in range(5): index = sorted_inds[i] print('Probabity %0.2f%% => [%s]' % (probabilities[index], names[index]))
def eval(adv_imgs, labels, x_inputs, total_score, total_count): image = (((adv_imgs + 1.0) * 0.5) * 255.0) processed_imgs_inv1 = 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_imgs_inv1, num_classes=FLAGS.num_classes, is_training=False, scope='InceptionV1', reuse=True) pred_inception = tf.argmax(end_points_inc_v1['Predictions'], 1) # 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( processed_imgs_res_v1_50, num_classes=FLAGS.num_classes, is_training=False, scope='resnet_v1_50', reuse=True) 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']) pred_resnet = tf.argmax(end_points_res_v1_50['probs'], 1) processed_imgs_inv3 = preprocess_for_model(image, 'inception_v3') with slim.arg_scope(inception_v3.inception_v3_arg_scope()): logits_res_inception_v3, end_points_inception_v3 = inception_v3.inception_v3( processed_imgs_inv3, num_classes=FLAGS.num_classes, is_training=False, scope='InceptionV3', reuse=True) pred_inception_v3 = tf.argmax(end_points_inception_v3['Predictions'], 1) processed_imgs_inv_res = preprocess_for_model(image, 'inception_resnet_v2') with slim.arg_scope(inception_resnet_v2.inception_resnet_v2_arg_scope()): logits_res_inception_resnet, end_points_inception_resnet = inception_resnet_v2.inception_resnet_v2( processed_imgs_inv_res, num_classes=FLAGS.num_classes, is_training=False, scope='InceptionResnetV2') pred_ince_res = tf.argmax(end_points_inception_resnet['Predictions'], 1) for i in range(adv_imgs.shape[0]): def f1(total_score, total_count): total_score = tf.add(total_score, 64) return total_score, total_count def f2(total_score, total_count): adv = (((adv_imgs[i] + 1.0) * 0.5) * 255.0) ori = (((x_inputs[i] + 1.0) * 0.5) * 255.0) diff = tf.reshape(adv, [-1, 3]) - tf.reshape(ori, [-1, 3]) distance = tf.reduce_mean(tf.sqrt(tf.reduce_sum(tf.square(diff), axis=1))) total_score = tf.add(total_score, distance) total_count = tf.add(total_count, 1) return total_score, total_count total_score, total_count = tf.cond(tf.equal(pred_inception[i], labels[i]), lambda: f2(total_score, total_count), lambda: f1(total_score, total_count)) total_score, total_count = tf.cond(tf.equal(pred_resnet[i], labels[i]), lambda: f2(total_score, total_count), lambda: f1(total_score, total_count)) # total_score, total_count = tf.cond(tf.equal(pred_inception_v3[i], labels[i]), lambda: f2(total_score, total_count), lambda: f1(total_score, total_count)) total_score, total_count = tf.cond(tf.equal(pred_ince_res[i], labels[i]), lambda: f2(total_score, total_count), lambda: f1(total_score, total_count)) return total_score, total_count
def testUnknowBatchSize(self): batch_size = 1 height, width = 224, 224 num_classes = 1000 inputs = tf.placeholder(tf.float32, (None, height, width, 3)) logits, _ = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith("InceptionV1/Logits")) self.assertListEqual(logits.get_shape().as_list(), [None, num_classes]) images = tf.random_uniform((batch_size, height, width, 3)) with self.test_session() as sess: sess.run(tf.initialize_all_variables()) output = sess.run(logits, {inputs: images.eval()}) self.assertEquals(output.shape, (batch_size, num_classes))
def testUnknowBatchSize(self): batch_size = 1 height, width = 224, 224 num_classes = 1000 inputs = tf.placeholder(tf.float32, (None, height, width, 3)) logits, _ = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith('InceptionV1/Logits')) self.assertListEqual(logits.get_shape().as_list(), [None, num_classes]) images = tf.random_uniform((batch_size, height, width, 3)) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) output = sess.run(logits, {inputs: images.eval()}) self.assertEquals(output.shape, (batch_size, num_classes))
def inception_v1(inputs, is_training, opts): with slim.arg_scope(inception.inception_v1_arg_scope( weight_decay=opts.weight_decay, use_batch_norm=opts.use_batch_norm, batch_norm_decay=opts.batch_norm_decay, batch_norm_epsilon=opts.batch_norm_epsilon, activation_fn=tf.nn.relu)): return inception.inception_v1( inputs, num_classes=opts.num_classes, is_training=is_training, dropout_keep_prob=opts.dropout_keep_prob, prediction_fn=slim.softmax, spatial_squeeze=opts.spatial_squeeze, reuse=None, global_pool=opts.global_pool)
def __call__(self, x_input): """Constructs model and return probabilities for given input.""" reuse = True if self.built else None x_input = image_normalize(x_input, normalization_method[0]) x_input = tf.image.resize_images(x_input, [224, 224]) with slim.arg_scope(inception.inception_v1_arg_scope()): _, end_points = inception.inception_v1( x_input, num_classes=self.num_classes, is_training=False, reuse=reuse) self.built = True output = end_points['Predictions'] # Strip off the extra reshape op at the output probs = output.op.inputs[0] return probs
def testUnknownImageShape(self): tf.reset_default_graph() batch_size = 2 height, width = 224, 224 num_classes = 1000 input_np = np.random.uniform(0, 1, (batch_size, height, width, 3)) with self.test_session() as sess: inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3)) logits, end_points = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith("InceptionV1/Logits")) self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes]) pre_pool = end_points["Mixed_5c"] feed_dict = {inputs: input_np} tf.initialize_all_variables().run() pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict) self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
def model_fn(features, labels, mode): from nets import inception slim = tf.contrib.slim labels = tf.squeeze(labels, axis=1) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, end_points = inception.inception_v1(features, num_classes=2, is_training=True) if mode == tf.estimator.ModeKeys.TRAIN: loss = tf.reduce_mean( tf.losses.sparse_softmax_cross_entropy(logits=logits, labels=labels)) return TFEstimatorSpec(mode, predictions=logits, loss=loss) else: raise NotImplementedError
def testUnknownImageShape(self): tf.reset_default_graph() batch_size = 2 height, width = 224, 224 num_classes = 1000 input_np = np.random.uniform(0, 1, (batch_size, height, width, 3)) with self.test_session() as sess: inputs = tf.placeholder(tf.float32, shape=(batch_size, None, None, 3)) logits, end_points = inception.inception_v1(inputs, num_classes) self.assertTrue(logits.op.name.startswith('InceptionV1/Logits')) self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes]) pre_pool = end_points['Mixed_5c'] feed_dict = {inputs: input_np} tf.global_variables_initializer().run() pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict) self.assertListEqual(list(pre_pool_out.shape), [batch_size, 7, 7, 1024])
def eval_adapt_pretrained_to_flower(): import numpy as np import tensorflow as tf from datasets import flowers from nets import inception slim = tf.contrib.slim image_size = inception.inception_v1.default_image_size batch_size = 8 with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) dataset = flowers.get_split('train', flower_data_dir) images, images_raw, labels = load_batch(dataset, height=image_size, width=image_size) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1( images, num_classes=dataset.num_classes, is_training=True) probabilities = tf.nn.softmax(logits) checkpoint_path = tf.train.latest_checkpoint(train_dir) init_fn = slim.assign_from_checkpoint_fn( checkpoint_path, slim.get_variables_to_restore()) with tf.Session() as sess: with slim.queues.QueueRunners(sess): sess.run(tf.initialize_local_variables()) init_fn(sess) np_probabilities, np_images_raw, np_labels = sess.run( [probabilities, images_raw, labels]) for i in xrange(batch_size): image = np_images_raw[i, :, :, :] true_label = np_labels[i] predicted_label = np.argmax(np_probabilities[i, :]) predicted_name = dataset.labels_to_names[ predicted_label] true_name = dataset.labels_to_names[true_label] plt.figure() plt.imshow(image.astype(np.uint8)) plt.title('Ground Truth: [%s], Prediction [%s]' % (true_name, predicted_name)) plt.axis('off') plt.show()
def inception_tst(): with tf.Graph().as_default(): url = 'https://upload.wikimedia.org/wikipedia/commons/7/70/EnglishCockerSpaniel_simon.jpg' 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) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(processed_images, num_classes=1001, is_training=False) probabilities = tf.nn.softmax(logits) variables_to_restore = slim.get_variables() print(len(variables_to_restore)) # pprint(variables_to_restore) variables_to_restore = slim.get_model_variables() print(len(variables_to_restore)) return init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'inception_v1.ckpt'), slim.get_model_variables('InceptionV1')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) probabilities = probabilities[0, 0:] sorted_inds = [ i[0] for i in sorted(enumerate(-probabilities), key=lambda x: x[1]) ] plt.figure() plt.imshow(np_image.astype(np.uint8)) plt.axis('off') plt.show() names = imagenet.create_readable_names_for_imagenet_labels() for i in range(5): index = sorted_inds[i] print('Probability %0.2f%% => [%s]' % (probabilities[index] * 100, names[index]))
def predict(train_dir, test_dir, num_classes): """ Loads weights from a TF model and makes predictions. Arguments: train_dir: directory of trained model test_dir: directory of test images (split into folders by class) num_classes: number of classes of prediction Returns: Returns logits in the order of test images given and nparray of predictions """ processed_images = tf.placeholder(tf.float32, shape=(None, image_size, image_size, 3)) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(processed_images, num_classes=num_classes, is_training=False) probabilities = tf.nn.softmax(logits) def predict_fn(images): return session.run(probabilities, feed_dict={processed_images: images}) #Loads in latest training checkpoint checkpoint_path = tf.train.latest_checkpoint(train_dir) init_fn = slim.assign_from_checkpoint_fn(checkpoint_path, slim.get_variables_to_restore()) init_fn(session) image_list = get_test_images(test_dir) images = transform_img_fn(image_list) predicted_probs = predict_fn(images) predictions = np.empty((len(predicted_probs), )) for example in range(len(predicted_probs)): predictions[example] = np.argmax(predicted_probs[example, :]) return predicted_probs, predictions
def label_test(): image_size = inception.inception_v1.default_image_size batch_size = 12 with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) dataset = flowers.get_split('validation', flowers_data_dir) images, images_raw, labels = load_batch(dataset, height=image_size, width=image_size) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(images, num_classes=dataset.num_classes, is_training=True) probabilities = tf.nn.softmax(logits) checkpoint_path = tf.train.latest_checkpoint(train_dir) init_fn = slim.assign_from_checkpoint_fn( checkpoint_path, slim.get_variables_to_restore()) with tf.Session() as sess: with slim.queues.QueueRunners(sess): sess.run(tf.initialize_local_variables()) init_fn(sess) np_probabilities, np_images_raw, np_labels = sess.run( [probabilities, images, labels]) for i in range(batch_size): image = np_images_raw[i, :, :, :] true_label = np_labels[i] predicted_label = np.argmax(np_probabilities[i, :]) predicted_name = dataset.labels_to_names[predicted_label] true_name = dataset.labels_to_names[true_label] plt.figure() plt.imshow(image / (image.max() - image.min())) # plt.imshow(image.astype(np.uint8)) plt.title('Ground Truth: [%s], Prediction [%s]' % (true_name, predicted_name)) plt.axis('off') plt.show()
def load_inception_model(network_config, net_input=None): with slim.arg_scope(inception.inception_v1_arg_scope()): if net_input is None: net_input = tf.placeholder("float", [None, image_size, image_size, 3], name='nn_input') logits, end_points = inception.inception_v1(net_input, num_classes=1001, is_training=True) init_fn = slim.assign_from_checkpoint_fn( os.path.join('./checkpoints', 'inception_v1.ckpt'), slim.get_model_variables('InceptionV1')) return logits, end_points, init_fn, net_input
def eval(): # This might take a few minutes. image_size = inception.inception_v1.default_image_size with tf.Graph().as_default(): #tf.logging.set_verbosity(tf.logging.INFO) dataset = flowers.get_split('train', flowers_data_dir) images, images_raw, labels = load_batch(dataset, height=image_size, width=image_size) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(images, num_classes=dataset.num_classes, is_training=True) predictions = tf.argmax(logits, 1) checkpoint_path = tf.train.latest_checkpoint(train_dir) init_fn = slim.assign_from_checkpoint_fn( checkpoint_path, slim.get_variables_to_restore()) # Define the metrics: names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ 'eval/Accuracy': slim.metrics.streaming_accuracy(predictions, labels), 'eval/Recall@5': slim.metrics.streaming_sparse_recall_at_k(logits, labels, 5) }) print('Running evaluation Loop...') checkpoint_path = tf.train.latest_checkpoint(train_dir) metric_values = slim.evaluation.evaluate_once( master='', checkpoint_path=checkpoint_path, logdir=train_dir, eval_op=list(names_to_updates.values()), final_op=list(names_to_values.values())) names_to_values = dict(zip(names_to_values.keys(), metric_values)) for name in names_to_values: print('%s: %f' % (name, names_to_values[name]))
def build(self, dataset, image_height, image_width, num_classes, is_training): images, labels = self._load_batch(dataset, height=image_height, width=image_width) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception_v1_arg_scope()): logits, end_points = inception_v1(images, num_classes=num_classes, is_training=is_training) # Specify the loss function: one_hot_labels = slim.one_hot_encoding(labels, num_classes) loss = slim.losses.softmax_cross_entropy(logits, one_hot_labels) # Create some summaries to visualize the training process: tf.summary.scalar('losses/Total Loss', loss) if is_training: # Specify the optimizer and create the train op: optimizer = tf.train.RMSPropOptimizer(learning_rate=0.01) variables_to_train = [] for scope in self.trainable_scopes: variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope) variables_to_train.extend(variables) variables = slim.get_model_variables("InceptionV1/Logits") exec_op = slim.learning.create_train_op( loss, optimizer, variables_to_train=variables) else: exec_op = end_points['Predictions'] if self.checkpoints_file is not None: self.init_fn = self._get_init_fn() return exec_op, tf.get_default_graph()
def fine_tune(): with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) dataset = flowers.get_split('train', flowers_data_dir) images, _, labels = load_batch(dataset, height=image_size, width=image_size) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(images, num_classes=dataset.num_classes, is_training=True) # Specify the loss function: 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() # Create some summaries to visualize the training process: tf.summary.scalar('losses/Total Loss', total_loss) # Specify the optimizer and create the train op: optimizer = tf.train.AdamOptimizer(learning_rate=0.01) train_op = slim.learning.create_train_op(total_loss, optimizer) # Run the training: final_loss = slim.learning.train( train_op, logdir=train_dir, init_fn=get_init_fn(), number_of_steps=1000, # For speed, we just do 1 epoch save_interval_secs=600, save_summaries_secs=6000, log_every_n_steps=1, ) print('Finished training. Last batch loss %f' % final_loss)
EPOCHS = 1 classes = util.pkl_load(workspace.class_pkl) csv_files = workspace.test_csvs graph = tf.Graph() with graph.as_default(): tf.logging.set_verbosity(tf.logging.INFO) fp_placeholder = tf.placeholder(tf.string) image = read_one_image(fp_placeholder) images = tf.reshape(image, [1, 224, 224, 3]) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(images, num_classes=len(classes), is_training=False) probabilities = tf.nn.softmax(logits) checkpoint = tf.train.latest_checkpoint(os.path.join(workspace.inception_cpkt, 'log')) init_fn = slim.assign_from_checkpoint_fn( checkpoint, slim.get_model_variables()) with tf.Session(graph=graph) as sess: init_fn(sess) top1 = 0 top5 = 0 total = 0 # there is prob a better way to do this will all TF but # this will do for calculating accuracy. for csv_fp in workspace.test_csvs:
slim = tf.contrib.slim image_size = inception.inception_v1.default_image_size with tf.Graph().as_default(): #url = 'https://upload.wikimedia.org/wikipedia/commons/7/70/EnglishCockerSpaniel_simon.jpg' #url = 'https://pbs.twimg.com/media/B5B9ZsvIgAATiC6.jpg' url=sys.argv[1] image_string = urllib2.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) # Create the model, use the default arg scope to configure the batch norm parameters. with slim.arg_scope(inception.inception_v1_arg_scope()): logits, _ = inception.inception_v1(processed_images, num_classes=1001, is_training=False) probabilities = tf.nn.softmax(logits) checkpoints_dir='slim_pretrained' init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'inception_v1.ckpt'), slim.get_variables_to_restore()) #slim.get_model_variables()) #slim.get_model_variables('InceptionV1')) #saver= tf.train.Saver(tf.all_variables()) #saver= tf.train.Saver(list(set(slim.get_model_variables()) | set(tf.trainable_variables()))) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) probabilities = probabilities[0, 0:] sorted_inds = [i[0] for i in sorted(enumerate(-probabilities), key=lambda x:x[1])] #saver.save(sess,'/home/sankit/Documents/cv-tricks/models/slim/my-saved/inception_v1.ckpt')