def freeze_model(name): #checkpoints_dir = '/data/huang/behaviour/data/tfmodel' OUTPUT_PB_FILENAME = 'inception_resnet_v2_behaviour_371_9_25_{}k.pb'.format(name[0:3]) NUM_CLASSES = 371 tensorName_v4='InceptionResnetV2/Logits/Predictions' with tf.Graph().as_default(): image_placeholder = tf.placeholder(tf.float32, shape=(1,512,512,3), name='input_image') with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, probabilities = inception.inception_resnet_v2(image_placeholder, num_classes = NUM_CLASSES, is_training=False) #model_path = tf.train.latest_checkpoint(checkpoints_dir) model_path = '/data/huang/behaviour/data/tfmodel/model_backup/model.ckpt-{}'.format(name) init_fn = slim.assign_from_checkpoint_fn( model_path, slim.get_model_variables()) with tf.Session() as sess: # Now call the initialization function within the session init_fn(sess) constant_graph = convert_variables_to_constants(sess, sess.graph_def, ["input_image",tensorName_v4]) tf.train.write_graph(constant_graph, '.', OUTPUT_PB_FILENAME, as_text=False)
def classify_from_url(url): 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_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=1001, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, checkpoints_filename), slim.get_model_variables(model_name)) 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], names[index]))
def __call__(self, image_input, training=False, keep_prob=1.0): """ Runs the CNN producing the embeddings and the gradients. :param image_input: Image input to produce embeddings for. [batch_size, image_size, image_size, 1] :param training: A flag indicating training or evaluation :param keep_prob: A tf placeholder of type tf.float32 indicating the amount of dropout applied :return: Embeddings of size [batch_size, 2048] """ weight_decay = FLAGS.weight_decay activation_fn = tf.nn.relu end_points = {} with slim.arg_scope( inception.inception_resnet_v2_arg_scope( weight_decay=FLAGS.weight_decay)): with tf.variable_scope("", reuse=self.reuse): with tf.variable_scope(None, 'InceptionResnetV2', [image_input]) as scope: with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=training): net, end_points = inception.inception_resnet_v2_base( image_input, scope=scope, activation_fn=activation_fn) feature_map = end_points['PreAuxLogits'] self.reuse = True return feature_map
def __call__(self, x_input, batch_size=None, is_training=False): """Constructs model and return probabilities for given input.""" reuse = True if self.built else None with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): with tf.variable_scope(self.name): min_pooled = -tf.nn.max_pool(-x_input, ksize=[1, 10, 10, 1], strides=[1, 1, 1, 1], padding='SAME') max_pooled = tf.nn.max_pool(x_input, ksize=[1, 10, 10, 1], strides=[1, 1, 1, 1], padding='SAME') avg_pooled = (min_pooled + max_pooled) / 2 compress_pooled = avg_pooled + (x_input - avg_pooled) * ( tf.sign(max_pooled - min_pooled - 0.3) + 1) / 2 logits, end_points = inception.inception_resnet_v2( compress_pooled, num_classes=self.num_classes, is_training=is_training, reuse=reuse) preds = tf.argmax(logits, axis=1) self.built = True self.logits = logits self.preds = preds return logits
def testNoBatchNormScaleByDefault(self): height, width = 299, 299 num_classes = 1000 inputs = tf.placeholder(tf.float32, (1, height, width, 3)) with tf.contrib.slim.arg_scope(inception.inception_resnet_v2_arg_scope()): inception.inception_resnet_v2(inputs, num_classes, is_training=False) self.assertEqual(tf.global_variables('.*/BatchNorm/gamma:0$'), [])
def __call__(self, feat_a, feat_b, training=False, spatial_matching=True): """ This module calculates the cosine distance between each of the support set embeddings and the target image embeddings. :param support_set: The embeddings of the support set images, tensor of shape [sequence_length, batch_size, 64] :param input_image: The embedding of the target image, tensor of shape [batch_size, 64] :param name: Name of the op to appear on the graph :param training: Flag indicating training or evaluation (True/False) :return: A tensor with cosine similarities of shape [batch_size, sequence_length, 1] """ with slim.arg_scope( inception.inception_resnet_v2_arg_scope( use_batch_norm=True, weight_decay=FLAGS.weight_decay)): with tf.variable_scope("", reuse=self.reuse): with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=training): eps = 1e-10 if spatial_matching: concated_representation = tf.concat([feat_a, feat_b], axis=3) net = slim.conv2d(concated_representation, 2048, [3, 3], scope='Match_1a_3x3') net = slim.conv2d(net, 2048, [3, 3], scope='Match_1b_3x3') # net = slim.max_pool2d(net, [2, 2], scope='Match_pool2') net = slim.flatten(net) else: net = tf.concat([feat_a, feat_b], axis=1) # aux_logits = slim.dropout(aux_logits, 0.75, scope='Dropout_match',is_training=training) net = slim.fully_connected(net, 1024, activation_fn=tf.nn.relu, scope='Match_Prelogits1') net = slim.dropout(net, 0.50, scope='Dropout_match', is_training=training) net = slim.fully_connected(net, 1024, activation_fn=tf.nn.relu, scope='Match_Prelogits2') net = slim.dropout(net, 0.50, scope='Dropout_match', is_training=training) net = slim.fully_connected(net, 2, activation_fn=None, scope='Match_logits') self.reuse = True return net
def testBatchNormScale(self): height, width = 299, 299 num_classes = 1000 inputs = tf.placeholder(tf.float32, (1, height, width, 3)) with tf.contrib.slim.arg_scope( inception.inception_resnet_v2_arg_scope(batch_norm_scale=True)): inception.inception_resnet_v2(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 inception_resnet_v2(inputs, is_training, opts): with slim.arg_scope(inception.inception_resnet_v2_arg_scope( weight_decay=opts.weight_decay, batch_norm_decay=opts.batch_norm_decay, batch_norm_epsilon=opts.batch_norm_epsilon, activation_fn=tf.nn.relu)): return inception.inception_resnet_v2( inputs, num_classes=opts.num_classes, is_training=is_training, dropout_keep_prob=opts.dropout_keep_prob, reuse=None, create_aux_logits=opts.create_aux_logits, global_pool=opts.global_pool)
def __call__(self, x_input, batch_size=None, is_training=False): """Constructs model and return probabilities for given input.""" reuse = True if self.built else None with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): with tf.variable_scope(self.ckpt): logits, end_points = inception.inception_resnet_v2( x_input, num_classes=self.num_classes, is_training=is_training, reuse=reuse) preds = tf.argmax(logits, axis=1) self.built = True self.logits = logits self.preds = preds return logits
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[4]) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, end_points = inception.inception_resnet_v2( 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 output
def freeze_model(name): checkpoints_dir = '/data/huang/behaviour/data/tfmodel' OUTPUT_PB_FILENAME = 'inception_resnet_v2_behaviour_309_4_10_{}k.pb'.format( name[0:3]) NUM_CLASSES = 309 tensorName_v4 = 'InceptionResnetV2/Logits/Predictions' image_size = inception.inception_resnet_v2.default_image_size with tf.Graph().as_default(): input_image_t = tf.placeholder(tf.string, name='input_image') image = tf.image.decode_jpeg(input_image_t, channels=3) processed_image = inception_preprocessing.preprocess_for_eval( image, image_size, image_size, central_fraction=None) processed_images = tf.expand_dims(processed_image, 0) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=NUM_CLASSES, is_training=False) # Apply softmax function to the logits (output of the last layer of the network) probabilities = tf.nn.softmax(logits) #model_path = tf.train.latest_checkpoint(checkpoints_dir) model_path = '/data/huang/behaviour/data/tfmodel/model_backup/model.ckpt-{}'.format( name) init_fn = slim.assign_from_checkpoint_fn(model_path, slim.get_model_variables()) with tf.Session() as sess: # Now call the initialization function within the session init_fn(sess) constant_graph = convert_variables_to_constants( sess, sess.graph_def, ["input_image", "DecodeJpeg", tensorName_v4]) tf.train.write_graph(constant_graph, '.', OUTPUT_PB_FILENAME, as_text=False)
def __call__(self, x_input, batch_size=None, is_training=False): """Constructs model and return probabilities for given input.""" reuse = True if self.built else None with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): with tf.variable_scope(self.name): avg_pooled = tf.nn.avg_pool(x_input, ksize=[1, 6, 6, 1], strides=[1, 1, 1, 1], padding='SAME') logits, end_points = inception.inception_resnet_v2( avg_pooled, num_classes=self.num_classes, is_training=is_training, reuse=reuse) preds = tf.argmax(logits, axis=1) self.built = True self.logits = logits self.preds = preds return logits
def configure_inception_resnet(self): try: from nets import inception from datasets import dataset_utils except: import sys print( "Make sure you have installed tensorflow/models and it's accessible in the environment" ) print("export PYTHONPATH=/home/ubuntu/models/slim") sys.exit() image_size = inception.inception_resnet_v2.default_image_size self.crop_generator = deepprofiler.imaging.cropping.SingleImageCropGenerator( self.config, self.dset) # Setup pretrained model network_input = crop_transform(self.raw_crops, image_size) url = self.config["profiling"]["url"] checkpoint = self.config["profiling"]["checkpoint"] if not os.path.isfile(checkpoint): dataset_utils.download_and_uncompress_tarball( url, os.path.dirname(checkpoint)) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, self.endpoints = inception.inception_resnet_v2( network_input, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn(checkpoint, slim.get_model_variables()) # Session configuration configuration = tf.ConfigProto() configuration.gpu_options.allow_growth = True configuration.gpu_options.visible_device_list = self.config[ "profiling"]["gpu"] self.sess = tf.Session(config=configuration) init_fn(self.sess) self.crop_generator.start(self.sess)
def profile(config, dset): crop_shape = ( config["sampling"]["box_size"], # height config["sampling"]["box_size"], # width len(config["image_set"]["channels"]) # channels ) crop_generator = deepprofiler.imaging.cropping.SingleImageCropGenerator(config, dset) num_channels = len(config["image_set"]["channels"]) # Setup pretrained model raw_crops = tf.placeholder(tf.float32, shape=(None, crop_shape[0], crop_shape[1], crop_shape[2])) network_input = crop_transform(raw_crops) url = config["profiling"]["url"] checkpoint = config["profiling"]["checkpoint"] if not os.path.isfile(checkpoint): dataset_utils.download_and_uncompress_tarball(url, os.path.dirname(checkpoint)) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, endpoints = inception.inception_resnet_v2(network_input, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn(checkpoint, slim.get_model_variables()) # Session configuration configuration = tf.ConfigProto() configuration.gpu_options.allow_growth = True configuration.gpu_options.visible_device_list = config["profiling"]["gpu"] sess = tf.Session(config=configuration) init_fn(sess) crop_generator.start(sess) def check(meta): output_file = config["profiling"]["output_dir"] + "/{}_{}_{}.npz" output_file = output_file.format( meta["Metadata_Plate"], meta["Metadata_Well"], meta["Metadata_Site"]) # Check if features were computed before if os.path.isfile(output_file): print("Already done:", output_file) return False else: return True # Function to process a single image def extract_features(key, image_array, meta): output_file = config["profiling"]["output_dir"] + "/{}_{}_{}.npz" output_file = output_file.format( meta["Metadata_Plate"], meta["Metadata_Well"], meta["Metadata_Site"]) batch_size = config["validation"]["minibatch"] image_key, image_names, outlines = dset.getImagePaths(meta) total_crops, pads = crop_generator.prepare_image( sess, image_array, meta, config["validation"]["sample_first_crops"] ) # Initialize data buffer data = np.zeros(shape=(num_channels, total_crops, num_features)) b = 0 start = tic() # Extract features in batches batches = [] for batch in crop_generator.generate(sess): crops = batch[0] feats = sess.run(endpoints['PreLogitsFlatten'], feed_dict={raw_crops:crops}) feats = np.reshape(feats, (num_channels, batch_size, num_features)) data[:, b * batch_size:(b + 1) * batch_size, :] = feats b += 1 batches.append(batch) # Remove paddings and concatentate features of all channels if pads > 0: data = data[:, :-pads, :] data = np.moveaxis(data, 0, 1) data = np.reshape(data, (data.shape[0], data.shape[1]*data.shape[2])) # Save features np.savez_compressed(output_file, f=data) toc(image_key + " (" + str(data.shape[0]-pads) + " cells)", start) # Save crops TODO: parameterize saving crops or a sample of them. if False: batch_data = {"total_crops": total_crops, "pads": pads, "batches": batches} with open(output_file.replace(".npz", ".pkl"), "wb") as batch_file: pickle.dump(batch_data, batch_file) dset.scan(extract_features, frame="all", check=check) print("Profiling: done")
#取物体类别名 names = imagenet.create_readable_names_for_imagenet_labels() #slim下载 https://github.com/tensorflow/models slim = tf.contrib.slim #使用inception_resnet_v2的模型文件, checkpoint_file = 'inception_resnet_v2/inception_resnet_v2_2016_08_30.ckpt' #将要识别的图片文件名 sample_images = ['img.jpg', 'ps.jpg'] input_imgs = tf.placeholder("float", [None, image_size, image_size, 3]) #Load the model sess = tf.Session() #arg_scope定义相同命名空间下的输出节点。 arg_scope = inception.inception_resnet_v2_arg_scope() with slim.arg_scope(arg_scope): logits, end_points = inception.inception_resnet_v2(input_imgs, is_training=False) saver = tf.train.Saver() saver.restore(sess, checkpoint_file) for image in sample_images: reimg = Image.open(image).resize((image_size, image_size)) reimg = np.array(reimg) reimg = reimg.reshape(-1, image_size, image_size, 3) plt.figure() p1 = plt.subplot(121)
def export(): with tf.Graph().as_default(): # build inference model # imagenet labels names = imagenet.create_readable_names_for_imagenet_labels() names_tensor = tf.constant(names.values()) names_lookup_table = tf.contrib.lookup.index_to_string_table_from_tensor( names_tensor) # input transformation serialized_tf_example = tf.placeholder(tf.string, name='tf_example') feature_configs = { 'image/encoded': tf.FixedLenFeature(shape=[], dtype=tf.string), } tf_example = tf.parse_example(serialized_tf_example, feature_configs) jpegs = tf_example['image/encoded'] images = tf.map_fn(preprocess_image, jpegs, dtype=tf.float32) # run inference with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): # inception resnet models logits, end_points = inception.inception_resnet_v2( images, num_classes=NUM_CLASSES + 1, is_training=False) # logits = tf.Print(logits, [logits]) probs = tf.nn.softmax(logits) # transform output to topk result topk_probs, topk_indices = tf.nn.top_k(probs, NUM_TOP_CLASSES) topk_names = names_lookup_table.lookup(tf.to_int64(topk_indices)) init_fn = slim.assign_from_checkpoint_fn( os.path.join(FLAGS.checkpoint_dir, 'inception_resnet_v2_2016_08_30.ckpt'), slim.get_model_variables('InceptionResnetV2')) # sess config config = tf.ConfigProto( # device_count = { # 'GPU': 0 # }, gpu_options={ 'allow_growth': 1, # 'per_process_gpu_memory_fraction': 0.01 }, allow_soft_placement=True, log_device_placement=False, ) with tf.Session(config=config) as sess: init_fn(sess) # init on 2017.10.22 # note: look into the graphdef for prelogits as image features # print('Graph Node Tensor Name:') # for node_tensor in tf.get_default_graph().as_graph_def().node: # if str(node_tensor.name).startswith('InceptionResnetV2/Logits'): # print str(node_tensor.name) prelogits = sess.graph.get_tensor_by_name( 'InceptionResnetV2/Logits/Flatten/flatten/Reshape:0') # an optional alternative # prelogits = end_points['PreLogitsFlatten'] # export inference model. output_path = os.path.join( tf.compat.as_bytes(FLAGS.output_dir), tf.compat.as_bytes(str(FLAGS.model_version))) print 'Exporting trained model to', output_path builder = tf.saved_model.builder.SavedModelBuilder(output_path) # build the signature_def_map. predict_inputs_tensor_info = tf.saved_model.utils.build_tensor_info( jpegs) classes_output_tensor_info = tf.saved_model.utils.build_tensor_info( topk_names) scores_output_tensor_info = tf.saved_model.utils.build_tensor_info( topk_probs) prelogits_output_tensor_info = tf.saved_model.utils.build_tensor_info( prelogits) prediction_signature = ( tf.saved_model.signature_def_utils.build_signature_def( inputs={'images': predict_inputs_tensor_info}, outputs={ 'classes': classes_output_tensor_info, 'scores': scores_output_tensor_info, 'prelogits': prelogits_output_tensor_info }, method_name=tf.saved_model.signature_constants. PREDICT_METHOD_NAME)) legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op') builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={ 'predict_images': prediction_signature, }, legacy_init_op=legacy_init_op) builder.save() print 'Successfully exported model to %s' % FLAGS.output_dir
sorted_inds_list = [] names_list = [] prob_list = [] names_list.append( os.listdir( "/home/vb/Desktop/inception_resnet_v2/dataset/data_tag1/image/")) with tf.Graph().as_default(): image_input = tf.read_file(org_img_path) image = tf.image.decode_jpeg(image_input, 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 slim1.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=10, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim1.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'model.ckpt-1'), slim1.get_model_variables('InceptionResnetV2')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) prob_list.append(probabilities[0, 0:]) sorted_inds_list.append([ i[0] for i in sorted(enumerate(-prob_list[0]), key=lambda x: x[1])
def profile(config, dset): # Variables and cropping comp. graph num_channels = len(config["image_set"]["channels"]) num_classes = dset.numberOfClasses() input_vars = learning.training.input_graph(config) images = input_vars["labeled_crops"][0] labels = tf.one_hot(input_vars["labeled_crops"][1], num_classes) # Setup pretrained model crop_shape = input_vars["shapes"]["crops"][0] raw_crops = tf.placeholder(tf.float32, shape=(None, crop_shape[0], crop_shape[1], crop_shape[2])) network_input = crop_transform(raw_crops) url = config["profiling"]["url"] checkpoint = config["profiling"]["checkpoint"] if not os.path.isfile(checkpoint): dataset_utils.download_and_uncompress_tarball( url, os.path.dirname(checkpoint)) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, endpoints = inception.inception_resnet_v2(network_input, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn(checkpoint, slim.get_model_variables()) # Session configuration configuration = tf.ConfigProto() configuration.gpu_options.allow_growth = True configuration.gpu_options.visible_device_list = config["profiling"]["gpu"] sess = tf.Session(config=configuration) init_fn(sess) def check(meta): output_file = config["profiling"]["output_dir"] + "/{}_{}_{}.npz" output_file = output_file.format(meta["Metadata_Plate"], meta["Metadata_Well"], meta["Metadata_Site"]) # Check if features were computed before if os.path.isfile(output_file): print("Already done:", output_file) return False else: return True # Function to process a single image def extract_features(key, image_array, meta): output_file = config["profiling"]["output_dir"] + "/{}_{}_{}.npz" output_file = output_file.format(meta["Metadata_Plate"], meta["Metadata_Well"], meta["Metadata_Site"]) # Prepare image and crop locations batch_size = config["training"]["minibatch"] image_key, image_names = dset.getImagePaths(meta) locations = [ learning.cropping.getLocations(image_key, config, randomize=False) ] if len(locations[0]) == 0: print("Empty locations set:", str(key)) return # Pad last batch with empty locations pads = batch_size - len(locations[0]) % batch_size zero_pads = np.zeros(shape=(pads, 2), dtype=np.int32) pad_data = pandas.DataFrame(columns=locations[0].columns, data=zero_pads) locations[0] = pandas.concat((locations[0], pad_data)) # Prepare boxes, indices, labels and push the image to the queue labels_data = [meta[config["training"]["label_field"]]] boxes, box_ind, labels_data = learning.cropping.prepareBoxes( locations, labels_data, config) images_data = np.reshape(image_array, input_vars["shapes"]["batch"]) sess.run( input_vars["enqueue_op"], { input_vars["image_ph"]: images_data, input_vars["boxes_ph"]: boxes, input_vars["box_ind_ph"]: box_ind, input_vars["labels_ph"]: labels_data }) # Collect crops of from the queue items = sess.run(input_vars["queue"].size()) #TODO: move the channels to the last axis data = np.zeros(shape=(num_channels, len(locations[0]), num_features)) b = 0 start = tic() while items >= batch_size: # Compute features in a batch of crops crops = sess.run(images) feats = sess.run(endpoints['PreLogitsFlatten'], feed_dict={raw_crops: crops}) # TODO: move the channels to the last axis using np.moveaxis feats = np.reshape(feats, (num_channels, batch_size, num_features)) data[:, b * batch_size:(b + 1) * batch_size, :] = feats items = sess.run(input_vars["queue"].size()) b += 1 # Save features # TODO: save data with channels in the last axis np.savez_compressed(output_file, f=data[:, :-pads, :]) toc(image_key + " (" + str(data.shape[1] - pads) + ") cells", start) dset.scan(extract_features, frame="all", check=check) print("Profiling: done")
def __call__(self, Q, K, V, num_heads, training=False, scope=""): """ This module calculates the cosine distance between each of the support set embeddings and the target image embeddings. :param support_set: The embeddings of the support set images, tensor of shape [sequence_length, batch_size, 64] :param input_image: The embedding of the target image, tensor of shape [batch_size, 64] :param name: Name of the op to appear on the graph :param training: Flag indicating training or evaluation (True/False) :return: A tensor with cosine similarities of shape [batch_size, sequence_length, 1] """ d_model = V.get_shape().as_list()[-1] d_key = d_model / num_heads d_value = d_model / num_heads batch_norm_params = { 'decay': 0.9997, 'epsilon': 0.001, 'fused': None, # Use fused batch norm if possible. } normalizer_fn = slim.batch_norm normalizer_params = batch_norm_params heads = [] with slim.arg_scope( inception.inception_resnet_v2_arg_scope( use_batch_norm=True, weight_decay=FLAGS.weight_decay)): with tf.variable_scope(scope, reuse=self.reuse): with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=training): for HeadIdx in range(num_heads): query = slim.conv2d(Q, d_key, [1, 1], scope='QueryRep-' + str(HeadIdx)) query = tf.reshape(query, [ query.get_shape().as_list()[0], -1, query.get_shape().as_list()[3] ]) key = slim.conv2d(K, d_key, [1, 1], scope='KeyRep-' + str(HeadIdx)) key = tf.reshape(key, [ key.get_shape().as_list()[0], -1, key.get_shape().as_list()[3] ]) value = slim.conv2d(V, d_value, [1, 1], scope='ValueRep-' + str(HeadIdx)) value = tf.reshape(value, [ value.get_shape().as_list()[0], -1, value.get_shape().as_list()[3] ]) head = Attention(query, key, value) heads.append(head) heads = tf.concat(heads, axis=2) # heads = slim.fully_connected(heads, d_model,activation_fn=tf.nn.relu, # normalizer_fn=normalizer_fn, normalizer_params=normalizer_params) # use conv2d? return heads
def main(_): batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] num_classes = 1001 # max_epsilon over checking # get original images origin_img_list=np.sort(glob.glob(FLAGS.origin_img_dir+"*.png")); origin_imgs=np.zeros((len(origin_img_list),FLAGS.image_height,FLAGS.image_width,3),dtype=float); for i in range(len(origin_img_list)): origin_imgs[i]=imread(origin_img_list[i],mode='RGB').astype(np.float); # get adv images adv_img_list=np.sort(glob.glob(FLAGS.input_dir+"*.png")); adv_imgs=np.zeros((len(adv_img_list),FLAGS.image_height,FLAGS.image_width,3),dtype=float); for i in range(len(adv_img_list)): adv_imgs[i]=imread(adv_img_list[i],mode='RGB').astype(np.float); epsilon_list=np.linalg.norm(np.reshape(abs(origin_imgs-adv_imgs),[-1,FLAGS.image_height*FLAGS.image_width*3]),ord=np.inf,axis=1); #print(epsilon_list);exit(1); over_epsilon_list=np.zeros((len(origin_img_list),2),dtype=object); cnt=0; for i in range(len(origin_img_list)): file_name=origin_img_list[i].split("/")[-1]; file_name=file_name.split(".")[0]; over_epsilon_list[i,0]=file_name; if(epsilon_list[i]>FLAGS.max_epsilon): over_epsilon_list[i,1]="1"; cnt+=1; tf.logging.set_verbosity(tf.logging.INFO) with tf.Graph().as_default(): # Prepare graph x_input = tf.placeholder(tf.float32, shape=batch_shape) if(FLAGS.checkpoint_file_name=="inception_v3.ckpt"): with slim.arg_scope(inception.inception_v3_arg_scope()): _, end_points = inception.inception_v3( x_input, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) elif(FLAGS.checkpoint_file_name=="inception_v4.ckpt"): with slim.arg_scope(inception.inception_v4_arg_scope()): _, end_points = inception.inception_v4( x_input, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) elif(FLAGS.checkpoint_file_name=="inception_resnet_v2_2016_08_30.ckpt"): with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, end_points = inception.inception_resnet_v2( x_input, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) elif(FLAGS.checkpoint_file_name=="resnet_v2_101.ckpt"): x_input2 = tf.image.resize_bilinear(x_input,[224,224],align_corners=False); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v2.resnet_v2_101( x_input2, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1) elif(FLAGS.checkpoint_file_name=="resnet_v2_50.ckpt"): x_input2 = tf.image.resize_bilinear(x_input,[224,224],align_corners=False); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v2.resnet_v2_50( x_input2, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1) elif(FLAGS.checkpoint_file_name=="resnet_v2_152.ckpt"): x_input2 = tf.image.resize_bilinear(x_input,[224,224],align_corners=False); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v2.resnet_v2_152( x_input2, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1) elif(FLAGS.checkpoint_file_name=="inception_v1.ckpt"): x_input2 = tf.image.resize_bilinear(x_input,[224,224],align_corners=False); with slim.arg_scope(inception.inception_v1_arg_scope()): _, end_points = inception.inception_v1( x_input2, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) elif(FLAGS.checkpoint_file_name=="inception_v2.ckpt"): x_input2 = tf.image.resize_bilinear(x_input,[224,224],align_corners=False); with slim.arg_scope(inception.inception_v2_arg_scope()): _, end_points = inception.inception_v2( x_input2, num_classes=num_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) # Resnet v1 and vgg are not working now elif(FLAGS.checkpoint_file_name=="vgg_16.ckpt"): x_input_list=tf.unstack(x_input,FLAGS.batch_size,0); for i in range(FLAGS.batch_size): x_input_list[i]=vgg_preprocessing.preprocess_image(x_input_list[i],224,224); x_input2=tf.stack(x_input_list,0); with slim.arg_scope(vgg.vgg_arg_scope()): _, end_points = vgg.vgg_16( x_input2, num_classes=num_classes-1, is_training=False) predicted_labels = tf.argmax(end_points['vgg_16/fc8'], 1)+1 elif(FLAGS.checkpoint_file_name=="vgg_19.ckpt"): x_input_list=tf.unstack(x_input,FLAGS.batch_size,0); for i in range(FLAGS.batch_size): x_input_list[i]=vgg_preprocessing.preprocess_image(x_input_list[i],224,224); x_input2=tf.stack(x_input_list,0); with slim.arg_scope(vgg.vgg_arg_scope()): _, end_points = vgg.vgg_19( x_input2, num_classes=num_classes-1, is_training=False) predicted_labels = tf.argmax(end_points['vgg_19/fc8'], 1)+1 elif(FLAGS.checkpoint_file_name=="resnet_v1_50.ckpt"): x_input_list=tf.unstack(x_input,FLAGS.batch_size,0); for i in range(FLAGS.batch_size): x_input_list[i]=vgg_preprocessing.preprocess_image(x_input_list[i],224,224); x_input2=tf.stack(x_input_list,0); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v1.resnet_v1_50( x_input, num_classes=num_classes-1, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1)+1 elif(FLAGS.checkpoint_file_name=="resnet_v1_101.ckpt"): x_input_list=tf.unstack(x_input,FLAGS.batch_size,0); for i in range(FLAGS.batch_size): x_input_list[i]=vgg_preprocessing.preprocess_image(x_input_list[i],224,224); x_input2=tf.stack(x_input_list,0); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v1.resnet_v1_101( x_input2, num_classes=num_classes-1, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1)+1 elif(FLAGS.checkpoint_file_name=="resnet_v1_152.ckpt"): x_input_list=tf.unstack(x_input,FLAGS.batch_size,0); for i in range(FLAGS.batch_size): x_input_list[i]=vgg_preprocessing.preprocess_image(x_input_list[i],224,224); x_input2=tf.stack(x_input_list,0); with slim.arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = resnet_v1.resnet_v1_152( x_input2, num_classes=num_classes-1, is_training=False) predicted_labels = tf.argmax(end_points['predictions'], 1)+1 # Run computation saver = tf.train.Saver(slim.get_model_variables()) session_creator = tf.train.ChiefSessionCreator( scaffold=tf.train.Scaffold(saver=saver), checkpoint_filename_with_path=FLAGS.checkpoint_path+FLAGS.checkpoint_file_name, master=FLAGS.master) f=open(FLAGS.true_label,"r"); t_label_list=np.array([i[:-1].split(",") for i in f.readlines()]); score=0; with tf.train.MonitoredSession(session_creator=session_creator) as sess: with tf.gfile.Open(FLAGS.output_file, 'w') as out_file: for filenames, images in load_images(FLAGS.input_dir, batch_shape): labels = sess.run(predicted_labels, feed_dict={x_input: images}) for filename, label in zip(filenames, labels): f_name=filename.split(".")[0]; t_label=int(t_label_list[t_label_list[:,0]==f_name,1][0]); if(t_label!=label): if(over_epsilon_list[over_epsilon_list[:,0]==f_name,1]!="1"): score+=1; #out_file.write('{0},{1}\n'.format(filename, label)) print("Over max epsilon#: "+str(cnt)); print(str(FLAGS.max_epsilon)+" max epsilon Score: "+str(score));
def get_inf(img_path): checkpoints_dir = ckpt_dir FLAGS = tf.app.flags.FLAGS slim1 = tf.contrib.slim slim2 = tf.contrib.slim slim3 = tf.contrib.slim image_size = inception.inception_resnet_v2.default_image_size f = open(tag_dir, "w") org_img_path = img_path sorted_inds_list = [] names_list = [] prob_list = [] names_list.append(os.listdir(label_list1)) with tf.Graph().as_default(): image_input = tf.read_file(org_img_path) image = tf.image.decode_jpeg(image_input, 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 slim1.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=10, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim1.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'model.ckpt-1'), slim1.get_model_variables('InceptionResnetV2')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) prob_list.append(probabilities[0, 0:]) sorted_inds_list.append([ i[0] for i in sorted(enumerate(-prob_list[0]), key=lambda x: x[1]) ]) names_list.append(os.listdir(label_list2)) with tf.Graph().as_default(): image_input = tf.read_file(org_img_path) image = tf.image.decode_jpeg(image_input, 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 slim2.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=7, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim2.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'model.ckpt-2'), slim2.get_model_variables('InceptionResnetV2')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) prob_list.append(probabilities[0, 0:]) sorted_inds_list.append([ i[0] for i in sorted(enumerate(-prob_list[1]), key=lambda x: x[1]) ]) names_list.append(os.listdir(label_list3)) with tf.Graph().as_default(): image_input = tf.read_file(org_img_path) image = tf.image.decode_jpeg(image_input, 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 slim3.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(processed_images, num_classes=4, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim3.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'model.ckpt-3'), slim3.get_model_variables('InceptionResnetV2')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) prob_list.append(probabilities[0, 0:]) sorted_inds_list.append([ i[0] for i in sorted(enumerate(-prob_list[2]), key=lambda x: x[1]) ]) ret_str = '' for n in range(len(names_list)): names_list[n].sort() index = sorted_inds_list[n][0] ret_str += '#%s' % names_list[n][index] f.write(ret_str)
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_resnet_v2_2016_08_30.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_resnet_v2.default_image_size feat_conv = [] feat_fc = [] probs = [] 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_resnet_v2_arg_scope()): logits, endpoints = inception.inception_resnet_v2( preprocessed_images, is_training=False) pre_pool = endpoints['Conv2d_7b_1x1'] pre_logits_flatten = endpoints['PreLogitsFlatten'] probabilities = endpoints['Predictions'] 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) temp_conv, temp_fc, prob = sess.run( [pre_pool, pre_logits_flatten, probabilities], feed_dict={input_batch: current_batch}) # feat_conv.append(temp_conv.astype('float32')) feat_fc.append(temp_fc[:j + 1].astype('float32')) probs.append(prob[:j + 1].astype('float32')) return np.concatenate(feat_fc, axis=0), np.concatenate(probs, axis=0)
def inference(images, isTrainingRun=True, isTrainingFromScratch=True): images = tf.to_float(images) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): probabilities, end_points = inception.inception_resnet_v2( images, 1001, is_training=False) #isTrainingRun if isTrainingFromScratch: variables_to_restore = slim.get_variables_to_restore(exclude=[ 'InceptionResnetV2/AuxLogits', 'InceptionResnetV2/Logits' ]) backbone_init_fn = slim.assign_from_checkpoint_fn( checkpoint_file, variables_to_restore) with tf.name_scope('COMMON_ENTRANCE'): with tf.variable_scope('COMMON_ENTRANCE'): CME_GCN_1 = LayerBlocks.global_conv_module( end_points['Conv2d_7b_1x1'], end_points['Conv2d_7b_1x1'].get_shape()[3], name='CME_GCN_1', k=7) CME_Atrous_1 = LayerBlocks.atrousPyramid_small( end_points['Conv2d_7b_1x1'], name="CME_Atrous_1", allow_r16=False, training=isTrainingRun) Mixed_6a_conv = tf.contrib.layers.conv2d(end_points['Mixed_6a'], 164, (2, 2), padding='VALID', activation_fn=tf.nn.relu) Mixed_6a_dil = tf.contrib.layers.conv2d(Mixed_6a_conv, 64, kernel_size=3, rate=2, padding='SAME') Mixed_5b_conv = tf.contrib.layers.conv2d(end_points['Mixed_5b'], 156, (4, 4), padding='VALID', activation_fn=tf.nn.relu) Mixed_5b_dil = tf.contrib.layers.conv2d(Mixed_5b_conv, 64, kernel_size=3, rate=2, padding='SAME') CME_1 = tf.concat([CME_Atrous_1, CME_GCN_1], 3) CME_2 = tf.concat([Mixed_6a_conv, Mixed_6a_dil], 3) CME_3 = tf.concat([Mixed_5b_conv, Mixed_5b_dil], 3) print("end_points['Conv2d_7b_1x1'] : " + str(end_points['Conv2d_7b_1x1'].get_shape()[:])) print("end_points['Mixed_6a'] : " + str(end_points['Mixed_6a'].get_shape()[:])) print("end_points['Mixed_5b'] : " + str(end_points['Mixed_5b'].get_shape()[:])) print("CME_GCN_1 : " + str(CME_GCN_1.get_shape()[:])) print("CME_Atrous_1 : " + str(CME_Atrous_1.get_shape()[:])) print("Mixed_6a_conv : " + str(Mixed_6a_conv.get_shape()[:])) print("Mixed_6a_dil : " + str(Mixed_6a_dil.get_shape()[:])) print("Mixed_5b_conv : " + str(Mixed_5b_conv.get_shape()[:])) print("Mixed_5b_dil : " + str(Mixed_5b_dil.get_shape()[:])) print("CME_1 : " + str(CME_1.get_shape()[:])) print("CME_2 : " + str(CME_2.get_shape()[:])) print("CME_3 : " + str(CME_3.get_shape()[:])) CME_1 = tf.layers.conv2d(CME_1, 1024, (1, 1), activation=tf.nn.relu, padding='VALID') print("CME_1 red. : " + str(CME_1.get_shape()[:])) with tf.name_scope('NEUTRAL_Branch'): with tf.variable_scope('NEUTRAL_Branch_1'): n_up_1 = LayerBlocks.up_project(CME_1, size=[3, 3, 1024, 96], id='n_2x_a', stride=1, training=isTrainingRun) n_up_2 = LayerBlocks.up_project(n_up_1, size=[3, 3, 96, 64], id='n_2x_b', stride=1, training=isTrainingRun) n_up_3 = LayerBlocks.up_project(n_up_2, size=[3, 3, 64, 32], id='n_2x_c', stride=1, training=isTrainingRun) n_up_4 = LayerBlocks.up_project(n_up_3, size=[3, 3, 32, 8], id='n_2x_d', stride=1, training=isTrainingRun) n_up_5 = LayerBlocks.up_project(n_up_4, size=[3, 3, 8, 4], id='n_2x_e', stride=1, training=isTrainingRun) print("n_up_1 : " + str(n_up_1.get_shape()[:])) print("n_up_2 : " + str(n_up_2.get_shape()[:])) print("n_up_3 : " + str(n_up_3.get_shape()[:])) print("n_up_4 : " + str(n_up_4.get_shape()[:])) print("n_up_5 : " + str(n_up_5.get_shape()[:])) with tf.variable_scope('NEUTRAL_Branch_mid'): n_up_1_mid = LayerBlocks.up_project(CME_2, size=[3, 3, 164, 16], id='n_2x_a_mid', stride=1, training=isTrainingRun) n_up_2_mid = LayerBlocks.up_project(n_up_1_mid, size=[3, 3, 16, 16], id='n_2x_b_mid', stride=1, training=isTrainingRun) n_up_3_mid = LayerBlocks.up_project(n_up_2_mid, size=[3, 3, 16, 8], id='n_2x_c_mid', stride=1, training=isTrainingRun) n_up_4_mid = LayerBlocks.up_project(n_up_3_mid, size=[3, 3, 8, 4], id='n_2x_d_mid', stride=1, training=isTrainingRun) print("n_up_1_mid : " + str(n_up_1_mid.get_shape()[:])) print("n_up_2_mid : " + str(n_up_2_mid.get_shape()[:])) print("n_up_3_mid : " + str(n_up_3_mid.get_shape()[:])) print("n_up_4_mid : " + str(n_up_4_mid.get_shape()[:])) with tf.variable_scope('NEUTRAL_Branch_high'): n_up_1_high = LayerBlocks.up_project(CME_3, size=[3, 3, 156, 16], id='n_2x_a_high', stride=1, training=isTrainingRun) n_up_2_high = LayerBlocks.up_project(n_up_1_high, size=[3, 3, 16, 8], id='n_2x_b_high', stride=1, training=isTrainingRun) n_up_3_high = LayerBlocks.up_project(n_up_2_high, size=[3, 3, 8, 4], id='n_2x_c_high', stride=1, training=isTrainingRun) print("n_up_1_high : " + str(n_up_1_high.get_shape()[:])) print("n_up_2_high : " + str(n_up_2_high.get_shape()[:])) print("n_up_3_high : " + str(n_up_3_high.get_shape()[:])) with tf.name_scope('DEPTH_Branch'): with tf.variable_scope('DEPTH_Branch'): s_up_0 = LayerBlocks.boundary_refine(CME_1, name='BR_s_up_0', training=isTrainingRun) s_up_0 = slim.convolution2d_transpose(s_up_0, 384, [3, 3], [2, 2], activation_fn=tf.nn.relu) sem_mix_0 = tf.concat([s_up_0, CME_2], 3) s_up_1 = LayerBlocks.boundary_refine(sem_mix_0, name='BR_s_up_1', training=isTrainingRun) s_up_1 = slim.convolution2d_transpose(s_up_1, 64, [3, 3], [2, 2], activation_fn=tf.nn.relu) dil_s_up_1 = tf.contrib.layers.conv2d(s_up_1, 48, kernel_size=3, rate=2) sem_mix_1 = tf.concat([s_up_1, n_up_2, dil_s_up_1, CME_3], 3) s_up_2 = LayerBlocks.boundary_refine(sem_mix_1, name='BR_s_up_2', training=isTrainingRun) s_up_2 = slim.convolution2d_transpose(s_up_2, 64, [3, 3], [2, 2], activation_fn=tf.nn.relu) dil_s_up_2 = tf.contrib.layers.conv2d(s_up_2, 32, kernel_size=3, rate=4) sem_mix_2 = tf.concat([s_up_2, n_up_3, dil_s_up_2], 3) s_up_3 = LayerBlocks.boundary_refine(sem_mix_2, name='BR_s_up_3', training=isTrainingRun) s_up_3 = slim.convolution2d_transpose(s_up_3, 64, [3, 3], [2, 2], activation_fn=tf.nn.relu) dil_s_up_3 = tf.contrib.layers.conv2d(s_up_3, 32, kernel_size=3, rate=8) sem_mix_3 = tf.concat([s_up_3, n_up_4, dil_s_up_3], 3) s_up_4 = LayerBlocks.boundary_refine(sem_mix_3, name='BR_s_up_4', training=isTrainingRun) s_up_4 = slim.convolution2d_transpose(s_up_4, 64, [3, 3], [2, 2], activation_fn=tf.nn.relu) dil_s_up_4 = tf.contrib.layers.conv2d(s_up_4, 32, kernel_size=3, rate=8) sem_mix_4 = tf.concat( [s_up_4, n_up_5, n_up_4_mid, n_up_3_high, dil_s_up_4], 3) print("sem_mix_4 : " + str(sem_mix_4.get_shape()[:])) depth_endpoint = tf.layers.conv2d(sem_mix_4, 1, (1, 1), activation=tf.nn.relu, padding='VALID') depth_endpoint = tf.minimum( LayerBlocks.boundary_refine(depth_endpoint, name='depth_endpoint', training=isTrainingRun), 16896) print("s_up_1 : " + str(s_up_1.get_shape()[:])) print("s_up_2 : " + str(s_up_2.get_shape()[:])) print("s_up_3 : " + str(s_up_3.get_shape()[:])) print("s_up_4 : " + str(s_up_4.get_shape()[:])) print("depth_endpoint: " + str(depth_endpoint.get_shape()[:])) if isTrainingFromScratch: return backbone_init_fn, depth_endpoint return depth_endpoint
from scipy import misc img = misc.imread('lena_299.png') print(img.shape) inputs = np.ones((1, 299, 299, 3), dtype=np.float32) inputs[0, 0, 0, 0] = -1 #inputs[0] = img print(inputs.mean()) print(inputs.std()) inputs = tf.pack(inputs) # tensorflow normalization # https://github.com/tensorflow/models/blob/master/slim/preprocessing/inception_preprocessing.py#L273 #inputs = tf.sub(inputs, 0.5) #inputs = tf.mul(inputs, 2.0) with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): logits, _ = inception.inception_resnet_v2(inputs, num_classes=1001, is_training=False) with tf.Session() as sess: # Initialize model 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(sess) # Display model variables
def main(_): batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] num_classes = 1001 ensemble_type = FLAGS.ensemble_type tf.logging.set_verbosity(tf.logging.INFO) checkpoint_path_list = [ FLAGS.checkpoint_path_inception_v1, FLAGS.checkpoint_path_inception_v2, FLAGS.checkpoint_path_inception_v3, FLAGS.checkpoint_path_inception_v4, FLAGS.checkpoint_path_inception_resnet_v2, FLAGS.checkpoint_path_resnet_v1_101, FLAGS.checkpoint_path_resnet_v1_152, FLAGS.checkpoint_path_resnet_v2_101, FLAGS.checkpoint_path_resnet_v2_152, FLAGS.checkpoint_path_vgg_16, FLAGS.checkpoint_path_vgg_19 ] normalization_method = [ 'default', 'default', 'default', 'default', 'global', 'caffe_rgb', 'caffe_rgb', 'default', 'default', 'caffe_rgb', 'caffe_rgb' ] pred_list = [] for idx, checkpoint_path in enumerate(checkpoint_path_list, 1): with tf.Graph().as_default(): if int(FLAGS.test_idx) == 20 and idx in [3]: continue if int(FLAGS.test_idx) in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ] and int(FLAGS.test_idx) != idx: continue # Prepare graph if idx in [1, 2, 6, 7, 10, 11]: _x_input = tf.placeholder(tf.float32, shape=batch_shape) x_input = tf.image.resize_images(_x_input, [224, 224]) else: _x_input = tf.placeholder(tf.float32, shape=batch_shape) x_input = _x_input x_input = image_normalize(x_input, normalization_method[idx - 1]) if idx == 1: with slim.arg_scope(inception.inception_v1_arg_scope()): _, end_points = inception.inception_v1( x_input, num_classes=num_classes, is_training=False) elif idx == 2: with slim.arg_scope(inception.inception_v2_arg_scope()): _, end_points = inception.inception_v2( x_input, num_classes=num_classes, is_training=False) elif idx == 3: with slim.arg_scope(inception.inception_v3_arg_scope()): _, end_points = inception.inception_v3( x_input, num_classes=num_classes, is_training=False) elif idx == 4: with slim.arg_scope(inception.inception_v4_arg_scope()): _, end_points = inception.inception_v4( x_input, num_classes=num_classes, is_training=False) elif idx == 5: with slim.arg_scope(inception.inception_resnet_v2_arg_scope()): _, end_points = inception.inception_resnet_v2( x_input, num_classes=num_classes, is_training=False) elif idx == 6: with slim.arg_scope(resnet_v1.resnet_arg_scope()): _, end_points = resnet_v1.resnet_v1_101(x_input, num_classes=1000, is_training=False) elif idx == 7: with slim.arg_scope(resnet_v1.resnet_arg_scope()): _, end_points = resnet_v1.resnet_v1_152(x_input, num_classes=1000, is_training=False) elif idx == 8: with slim.arg_scope(resnet_v2.resnet_arg_scope()): _, end_points = resnet_v2.resnet_v2_101( x_input, num_classes=num_classes, is_training=False) elif idx == 9: with slim.arg_scope(resnet_v2.resnet_arg_scope()): _, end_points = resnet_v2.resnet_v2_152( x_input, num_classes=num_classes, is_training=False) elif idx == 10: with slim.arg_scope(vgg.vgg_arg_scope()): _, end_points = vgg.vgg_16(x_input, num_classes=1000, is_training=False) end_points['predictions'] = tf.nn.softmax( end_points['vgg_16/fc8']) elif idx == 11: with slim.arg_scope(vgg.vgg_arg_scope()): _, end_points = vgg.vgg_19(x_input, num_classes=1000, is_training=False) end_points['predictions'] = tf.nn.softmax( end_points['vgg_19/fc8']) #end_points = tf.reduce_mean([end_points1['Predictions'], end_points2['Predictions'], end_points3['Predictions'], end_points4['Predictions']], axis=0) #predicted_labels = tf.argmax(end_points, 1) # Run computation saver = tf.train.Saver(slim.get_model_variables()) session_creator = tf.train.ChiefSessionCreator( scaffold=tf.train.Scaffold(saver=saver), checkpoint_filename_with_path=checkpoint_path, master=FLAGS.master) pred_in = [] filenames_list = [] with tf.train.MonitoredSession( session_creator=session_creator) as sess: for filenames, images in load_images(FLAGS.input_dir, batch_shape): #if idx in [1,2,6,7,10,11]: # # 16x299x299x3 # images = zoom(images, (1, 0.7491638795986622, 0.7491638795986622, 1), order=2) filenames_list.extend(filenames) end_points_dict = sess.run(end_points, feed_dict={_x_input: images}) if idx in [6, 7, 10, 11]: end_points_dict['predictions'] = \ np.concatenate([np.zeros([FLAGS.batch_size, 1]), np.array(end_points_dict['predictions'].reshape(-1, 1000))], axis=1) try: pred_in.extend(end_points_dict['Predictions'].reshape( -1, num_classes)) except KeyError: pred_in.extend(end_points_dict['predictions'].reshape( -1, num_classes)) pred_list.append(pred_in) if ensemble_type == 'mean': pred = np.mean(pred_list, axis=0) labels = np.argmax( pred, axis=1 ) # model_num X batch X class_num ==(np.mean)==> batch X class_num ==(np.argmax)==> batch elif ensemble_type == 'vote': pred = np.argmax( pred_list, axis=2 ) # model_num X batch X class_num ==(np.mean)==> batch X class_num ==(np.argmax)==> batch labels = np.median(pred, axis=0) with tf.gfile.Open(FLAGS.output_file, 'w') as out_file: for filename, label in zip(filenames_list, labels): out_file.write('{0},{1}\n'.format(filename, label))
def main(opt): config = tf.ConfigProto(allow_soft_placement=True) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.1) config.gpu_options.allow_growth = True jpg_path = opt.image_path images_lists = [] for subdir, dirs, files in os.walk(jpg_path): for f in files: f = f.strip() images_lists.append(os.path.join(jpg_path, f)) att_dir = os.path.join(opt.out_dir, opt.att_dir) fc_dir = os.path.join(opt.out_dir, opt.fc_dir) if not tf.gfile.Exists(fc_dir): tf.gfile.MakeDirs(fc_dir) if not tf.gfile.Exists(att_dir): tf.gfile.MakeDirs(att_dir) checkpoints_dir = opt.model_path slim = tf.contrib.slim image_size = inception.inception_resnet_v2.default_image_size tf_image = tf.placeholder(tf.string, None) image = tf.image.decode_jpeg(tf_image, 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_resnet_v2_arg_scope()): tf_feats_att, tf_feats_fc = inception.inception_resnet_v2( processed_images, num_classes=1001, is_training=False) init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'inception_resnet_v2_2016_08_30.ckpt'), slim.get_model_variables('InceptionResnetV2')) with tf.Session(config=config) as sess: init_fn(sess) for idx, image_path in enumerate(images_lists): image_name = os.path.basename(image_path) image_id = get_image_id(image_name) time_start = time.time() url = 'file://' + image_path image_string = urllib.request.urlopen(url).read() feat_conv, feat_fc = sess.run([tf_feats_att, tf_feats_fc], feed_dict={tf_image: image_string}) feat_conv = np.squeeze(feat_conv) feat_fc = np.squeeze(feat_fc) np.save(os.path.join(fc_dir, str(image_id)), feat_fc) np.savez_compressed(os.path.join(att_dir, str(image_id)), feat=feat_conv) time_end = time.time() print('{} {} {:.5f}'.format(idx, image_name, time_end - time_start))