def test_print_layer_info(): """ print layer name, input tensor and output tensor :return: """ images_placeholder = tf.placeholder(tf.float32, shape=(None, image_height, image_width, 3), name='image') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') prelogits = sphere_network.infer(images_placeholder, embedding_size) prelogits = slim.batch_norm(prelogits, is_training=phase_train_placeholder, epsilon=1e-5, scale=True, scope='softmax_bn') embeddings = tf.identity(prelogits) operations = tf.get_default_graph().get_operations() for operation in operations: print("Operation:{}".format(operation.name)) for k in operation.inputs: print("{} Input: {} {}".format(operation.name, k.name, k.get_shape())) for k in operation.outputs: print("{} Output:{}".format(operation.name, k.name)) print("\n")
def __init__(self, weight_file): config = tf.ConfigProto(log_device_placement=False) config.gpu_options.allow_growth = True self.__graph = tf.Graph() with self.__graph.as_default(): self.__session = tf.Session(config=config, graph=self.__graph) self.images_placeholder = tf.placeholder(tf.float32, shape=(None, image_height, image_width, 3), name='image') self.phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') prelogits = sphere_network.infer(self.images_placeholder, embedding_size) prelogits = slim.batch_norm( prelogits, is_training=self.phase_train_placeholder, epsilon=1e-5, scale=True, scope='softmax_bn') self.embeddings = tf.identity(prelogits) saver = tf.train.Saver(tf.global_variables(), max_to_keep=3) saver.restore(self.__session, weight_file)
def main(args): #network = importlib.import_module(args.model_def) subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir) if not os.path.isdir( log_dir): # Create the log directory if it doesn't exist os.makedirs(log_dir) model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir) if not os.path.isdir( model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) # Write arguments to a text file utils.write_arguments_to_file(args, os.path.join(log_dir, 'arguments.txt')) # Store some git revision info in a text file in the log directory src_path, _ = os.path.split(os.path.realpath(__file__)) utils.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) train_set = utils.get_dataset(args.data_dir) #train_set = facenet.dataset_from_list2(args.data_dir,'dataset/casia_maxpy_mtcnnpy_182',error_classes=[],drop_key='AsianStarCropBig_YES') nrof_classes = len(train_set) print('nrof_classes: ', nrof_classes) image_list, label_list = utils.get_image_paths_and_labels(train_set) image_list = np.array(image_list) label_list = np.array(label_list, dtype=np.int32) dataset_size = len(image_list) single_batch_size = args.people_per_batch * args.images_per_person indices = range(dataset_size) np.random.shuffle(indices) def _sample_people_softmax(x): global softmax_ind if softmax_ind >= dataset_size: np.random.shuffle(indices) softmax_ind = 0 true_num_batch = min(single_batch_size, dataset_size - softmax_ind) sample_paths = image_list[indices[softmax_ind:softmax_ind + true_num_batch]] sample_labels = label_list[indices[softmax_ind:softmax_ind + true_num_batch]] softmax_ind += true_num_batch return (np.array(sample_paths), np.array(sample_labels, dtype=np.int32)) def _sample_people(x): '''We sample people based on tf.data, where we can use transform and prefetch. ''' image_paths, num_per_class = sample_people( train_set, args.people_per_batch * (args.num_gpus - 1), args.images_per_person) labels = [] for i in range(len(num_per_class)): labels.extend([i] * num_per_class[i]) return (np.array(image_paths), np.array(labels, dtype=np.int32)) def _parse_function(filename, label): file_contents = tf.read_file(filename) image = tf.image.decode_image(file_contents, channels=3) #image = tf.image.decode_jpeg(file_contents, channels=3) print(image.shape) if args.random_crop: print('use random crop') image = tf.random_crop(image, [args.image_size, args.image_size, 3]) else: print('Not use random crop') #image.set_shape((args.image_size, args.image_size, 3)) image.set_shape((None, None, 3)) image = tf.image.resize_images(image, size=(args.image_height, args.image_width)) #print(image.shape) if args.random_flip: image = tf.image.random_flip_left_right(image) #pylint: disable=no-member #image.set_shape((args.image_size, args.image_size, 3)) image.set_shape((args.image_height, args.image_width, 3)) if debug: image = tf.cast(image, tf.float32) else: image = tf.image.per_image_standardization(image) return image, label #train_set = facenet.dataset_from_list(args.data_dir,'dataset/ms_mp',keys=['MultiPics']) #train_set = facenet.dataset_from_list(args.data_dir,'dataset/ms_mp') gpus = [0, 1] #gpus = [0] print('Model directory: %s' % model_dir) print('Log directory: %s' % log_dir) if args.pretrained_model: print('Pre-trained model: %s' % os.path.expanduser(args.pretrained_model)) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False, name='global_step') # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') #the image is generated by sequence with tf.device("/cpu:0"): softmax_dataset = tf_data.Dataset.range(args.epoch_size * args.max_nrof_epochs * 100) softmax_dataset = softmax_dataset.map(lambda x: tf.py_func( _sample_people_softmax, [x], [tf.string, tf.int32])) softmax_dataset = softmax_dataset.flat_map(_from_tensor_slices) softmax_dataset = softmax_dataset.map(_parse_function, num_threads=8, output_buffer_size=2000) softmax_dataset = softmax_dataset.batch(args.num_gpus * single_batch_size) softmax_iterator = softmax_dataset.make_initializable_iterator() softmax_next_element = softmax_iterator.get_next() softmax_next_element[0].set_shape( (args.num_gpus * single_batch_size, args.image_height, args.image_width, 3)) softmax_next_element[1].set_shape(args.num_gpus * single_batch_size) batch_image_split = tf.split(softmax_next_element[0], args.num_gpus) batch_label_split = tf.split(softmax_next_element[1], args.num_gpus) learning_rate = tf.train.exponential_decay( learning_rate_placeholder, global_step, args.learning_rate_decay_epochs * args.epoch_size, args.learning_rate_decay_factor, staircase=True) tf.summary.scalar('learning_rate', learning_rate) print('Using optimizer: {}'.format(args.optimizer)) if args.optimizer == 'ADAGRAD': opt = tf.train.AdagradOptimizer(learning_rate) elif args.optimizer == 'MOM': opt = tf.train.MomentumOptimizer(learning_rate, 0.9) tower_losses = [] tower_cross = [] tower_dist = [] tower_th = [] for i in range(args.num_gpus): with tf.device("/gpu:" + str(i)): with tf.name_scope("tower_" + str(i)) as scope: with slim.arg_scope([slim.model_variable, slim.variable], device="/cpu:0"): with tf.variable_scope( tf.get_variable_scope()) as var_scope: reuse = False if i == 0 else True #with slim.arg_scope(resnet_v2.resnet_arg_scope(args.weight_decay)): #prelogits, end_points = resnet_v2.resnet_v2_50(batch_image_split[i],is_training=True, # output_stride=16,num_classes=args.embedding_size,reuse=reuse) #prelogits, end_points = network.inference(batch_image_split[i], args.keep_probability, # phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, # weight_decay=args.weight_decay, reuse=reuse) if args.network == 'slim_sphere': prelogits = network.infer(batch_image_split[i]) elif args.network == 'densenet': with slim.arg_scope( densenet.densenet_arg_scope( args.weight_decay)): #prelogits, endpoints = densenet.densenet_small(batch_image_split[i],num_classes=args.embedding_size,is_training=True,reuse=reuse) prelogits, endpoints = densenet.densenet_small_middle( batch_image_split[i], num_classes=args.embedding_size, is_training=True, reuse=reuse) prelogits = tf.squeeze(prelogits, axis=[1, 2]) #prelogits = slim.batch_norm(prelogits, is_training=True, decay=0.997,epsilon=1e-5,scale=True,updates_collections=tf.GraphKeys.UPDATE_OPS,reuse=reuse,scope='softmax_bn') if args.loss_type == 'softmax': cross_entropy_mean = utils.softmax_loss( prelogits, batch_label_split[i], len(train_set), args.weight_decay, reuse) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) tower_cross.append(cross_entropy_mean) #loss = cross_entropy_mean + args.weight_decay*tf.add_n(regularization_losses) loss = cross_entropy_mean + tf.add_n( regularization_losses) tower_dist.append(0) tower_cross.append(cross_entropy_mean) tower_th.append(0) tower_losses.append(loss) elif args.loss_type == 'scatter' or args.loss_type == 'coco': label_reshape = tf.reshape( batch_label_split[i], [single_batch_size]) label_reshape = tf.cast( label_reshape, tf.int64) if args.loss_type == 'scatter': scatter_loss, _ = utils.weight_scatter_speed( prelogits, label_reshape, len(train_set), reuse, weight=args.weight, scale=args.scale) else: scatter_loss, _ = utils.coco_loss( prelogits, label_reshape, len(train_set), reuse, alpha=args.alpha, scale=args.scale) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) loss = scatter_loss[ 'loss_total'] + args.weight_decay * tf.add_n( regularization_losses) tower_dist.append(scatter_loss['loss_dist']) tower_cross.append(0) tower_th.append(scatter_loss['loss_th']) tower_losses.append(loss) #loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss') tf.get_variable_scope().reuse_variables() total_loss = tf.reduce_mean(tower_losses) total_cross = tf.reduce_mean(tower_cross) total_dist = tf.reduce_mean(tower_dist) total_th = tf.reduce_mean(tower_th) losses = {} losses['total_loss'] = total_loss losses['total_cross'] = total_cross losses['total_dist'] = total_dist losses['total_th'] = total_th debug_info = {} debug_info['logits'] = prelogits #debug_info['end_points'] = end_points debug_info['batch_image_split'] = batch_image_split debug_info['batch_label_split'] = batch_label_split #debug_info['endpoints'] = endpoints grads = opt.compute_gradients(total_loss, tf.trainable_variables(), colocate_gradients_with_ops=True) apply_gradient_op = opt.apply_gradients(grads, global_step=global_step) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = tf.group(apply_gradient_op) save_vars = [ var for var in tf.global_variables() if 'Adagrad' not in var.name and 'global_step' not in var.name ] check_nan = tf.add_check_numerics_ops() debug_info['check_nan'] = check_nan #saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) saver = tf.train.Saver(save_vars, max_to_keep=3) # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # Start running operations on the Graph. gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=args.gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)) # Initialize variables sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder: True}) sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder: True}) #sess.run(iterator.initializer) sess.run(softmax_iterator.initializer) summary_writer = tf.summary.FileWriter(log_dir, sess.graph) coord = tf.train.Coordinator() tf.train.start_queue_runners(coord=coord, sess=sess) with sess.as_default(): #pdb.set_trace() if args.pretrained_model: print('Restoring pretrained model: %s' % args.pretrained_model) saver.restore(sess, os.path.expanduser(args.pretrained_model)) # Training and validation loop epoch = 0 while epoch < args.max_nrof_epochs: step = sess.run(global_step, feed_dict=None) epoch = step // args.epoch_size if debug: debug_train(args, sess, train_set, epoch, image_batch_gather, enqueue_op, batch_size_placeholder, image_batch_split, image_paths_split, num_per_class_split, image_paths_placeholder, image_paths_split_placeholder, labels_placeholder, labels_batch, num_per_class_placeholder, num_per_class_split_placeholder, len(gpus)) # Train for one epoch train(args, sess, epoch, len(gpus), debug_info, learning_rate_placeholder, phase_train_placeholder, global_step, losses, train_op, summary_op, summary_writer, args.learning_rate_schedule_file) # Save variables and the metagraph if it doesn't exist already save_variables_and_metagraph(sess, saver, summary_writer, model_dir, subdir, step) # Evaluate on LFW return model_dir
def main(args): #network = importlib.import_module(args.model_def) subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir) if not os.path.isdir( log_dir): # Create the log directory if it doesn't exist os.makedirs(log_dir) model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir) if not os.path.isdir( model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) # Write arguments to a text file utils.write_arguments_to_file(args, os.path.join(log_dir, 'arguments.txt')) # Store some git revision info in a text file in the log directory src_path, _ = os.path.split(os.path.realpath(__file__)) utils.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) train_set = utils.get_dataset(args.data_dir) nrof_classes = len(train_set) print('nrof_classes: ', nrof_classes) image_list, label_list = utils.get_image_paths_and_labels(train_set) image_list = np.array(image_list) print('total images: {}'.format(len(image_list))) label_list = np.array(label_list, dtype=np.int32) dataset_size = len(image_list) data_reader = DataGenerator(image_list, label_list, args.batch_size) print('Model directory: %s' % model_dir) print('Log directory: %s' % log_dir) if args.pretrained_model: print('Pre-trained model: %s' % os.path.expanduser(args.pretrained_model)) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False, name='global_step') # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') images_placeholder = tf.placeholder(tf.float32, [None, 112, 96, 3], name='images_placeholder') labels_placeholder = tf.placeholder(tf.int32, [None], name='labels_placeholder') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') learning_rate = tf.train.exponential_decay( learning_rate_placeholder, global_step, args.learning_rate_decay_epochs * args.epoch_size, args.learning_rate_decay_factor, staircase=True) tf.summary.scalar('learning_rate', learning_rate) print('Using optimizer: {}'.format(args.optimizer)) if args.optimizer == 'ADAGRAD': opt = tf.train.AdagradOptimizer(learning_rate) elif args.optimizer == 'MOM': opt = tf.train.MomentumOptimizer(learning_rate, 0.9) if args.network == 'sphere_network': prelogits = network.infer(images_placeholder) else: raise Exception('Not supported network: {}'.format(args.loss_type)) if args.loss_type == 'softmax': cross_entropy_mean = utils.softmax_loss(prelogits, labels_placeholder, len(train_set), args.weight_decay, False) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) #loss = cross_entropy_mean + args.weight_decay*tf.add_n(regularization_losses) loss = cross_entropy_mean + args.weight_decay * tf.add_n( regularization_losses) #loss = cross_entropy_mean else: raise Exception('Not supported loss type: {}'.format( args.loss_type)) #loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss') losses = {} losses['total_loss'] = loss losses['softmax_loss'] = cross_entropy_mean debug_info = {} debug_info['prelogits'] = prelogits grads = opt.compute_gradients(loss, tf.trainable_variables()) train_op = opt.apply_gradients(grads, global_step=global_step) #save_vars = [var for var in tf.global_variables() if 'Adagrad' not in var.name and 'global_step' not in var.name] save_vars = tf.global_variables() #saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) saver = tf.train.Saver(save_vars, max_to_keep=3) # Build the summary operation based on the TF collection of Summaries. # Start running operations on the Graph. gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=args.gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)) # Initialize variables sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder: True}) sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder: True}) with sess.as_default(): #pdb.set_trace() if args.pretrained_model: print('Restoring pretrained model: %s' % args.pretrained_model) saver.restore(sess, os.path.expanduser(args.pretrained_model)) # Training and validation loop epoch = 0 while epoch < args.max_nrof_epochs: step = sess.run(global_step, feed_dict=None) epoch = step // args.epoch_size # Train for one epoch train(args, sess, epoch, images_placeholder, labels_placeholder, data_reader, debug, learning_rate_placeholder, global_step, losses, train_op, args.learning_rate_schedule_file) # Save variables and the metagraph if it doesn't exist already model_dir = args.models_base_dir checkpoint_path = os.path.join(model_dir, 'model-%s.ckpt' % 'softmax') saver.save(sess, checkpoint_path, global_step=step, write_meta_graph=False) # Evaluate on LFW return model_dir
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) #pdb.set_trace() # Get the paths for the corresponding images paths, actual_issame = lfw.get_paths( os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) # Load the model #facenet.load_model(args.model) # Get input and output tensors #image_size = images_placeholder.get_shape()[1] # For some reason this doesn't work for frozen graphs image_size = args.image_size print('image size', image_size) #images_placeholder = tf.placeholder(tf.float32,shape=(None,image_size,image_size,3),name='image') images_placeholder = tf.placeholder(tf.float32, shape=(None, args.image_height, args.image_width, 3), name='image') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') #with slim.arg_scope(resnet_v1.resnet_arg_scope(False)): if args.network_type == 'resnet50': with slim.arg_scope(resnet_v2.resnet_arg_scope(False)): prelogits, end_points = resnet_v2.resnet_v2_50( images_placeholder, is_training=phase_train_placeholder, num_classes=256, output_stride=16) #prelogits, end_points = resnet_v2.resnet_v2_50(images_placeholder,is_training=phase_train_placeholder,num_classes=256,output_stride=8) #prelogits, end_points = resnet_v2_modify.resnet_v2_50(images_placeholder,is_training=phase_train_placeholder,num_classes=256) #prelogits = slim.batch_norm(prelogits, is_training=phase_train_placeholder,epsilon=1e-5, scale=True,scope='softmax_bn') prelogits = tf.squeeze(prelogits, [1, 2], name='SpatialSqueeze') elif args.network_type == 'sphere_network': prelogits = network.infer(images_placeholder) if args.fc_bn: prelogits = slim.batch_norm( prelogits, is_training=phase_train_placeholder, epsilon=1e-5, scale=True, scope='softmax_bn') #embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') embeddings = tf.identity(prelogits) #saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) saver = tf.train.Saver(tf.global_variables(), max_to_keep=3) saver.restore(sess, args.model) if args.save_model: saver.save(sess, './tmp_saved_model', global_step=1) return 0 embedding_size = embeddings.get_shape()[1] # Run forward pass to calculate embeddings print('Runnning forward pass on LFW images') batch_size = args.lfw_batch_size nrof_images = len(paths) nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size)) if args.do_flip: embedding_size *= 2 emb_array = np.zeros((nrof_images, embedding_size)) else: emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches): start_index = i * batch_size print('handing {}/{}'.format(start_index, nrof_images)) end_index = min((i + 1) * batch_size, nrof_images) paths_batch = paths[start_index:end_index] #images = facenet.load_data(paths_batch, False, False, image_size,True,image_size) #images = facenet.load_data2(paths_batch, False, False, args.image_height,args.image_width,True,) images = utils.load_data(paths_batch, False, True, args.image_height, args.image_width, True, (args.image_height, args.image_width)) feed_dict = { images_placeholder: images, phase_train_placeholder: False } feats = sess.run(embeddings, feed_dict=feed_dict) if args.do_flip: images_flip = utils.load_data( paths_batch, False, True, args.image_height, args.image_width, True, (args.image_height, args.image_width)) feed_dict = { images_placeholder: images_flip, phase_train_placeholder: False } feats_flip = sess.run(embeddings, feed_dict=feed_dict) feats = np.concatenate((feats, feats_flip), axis=1) #feats = (feats+feats_flip)/2 #images = facenet.load_data(paths_batch, False, False, 160,True,182) #images = facenet.load_data(paths_batch, False, False, image_size,src_size=256) #feed_dict = { images_placeholder:images, phase_train_placeholder:True} #pdb.set_trace() #feats = facenet.prewhiten(feats) feats = utils.l2_normalize(feats) emb_array[start_index:end_index, :] = feats #pdb.set_trace() tpr, fpr, accuracy, val, val_std, far = lfw.evaluate( emb_array, actual_issame, nrof_folds=args.lfw_nrof_folds) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) auc = metrics.auc(fpr, tpr) print('Area Under Curve (AUC): %1.3f' % auc) eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.) print('Equal Error Rate (EER): %1.3f' % eer)
def main_train(args): subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir) if not os.path.isdir( log_dir): # Create the log directory if it doesn't exist os.makedirs(log_dir) model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir) if not os.path.isdir( model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) # Write arguments to a text file utils.write_arguments_to_file(args, os.path.join(log_dir, 'arguments.txt')) # Store some git revision info in a text file in the log directory src_path, _ = os.path.split(os.path.realpath(__file__)) utils.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) train_set = utils.dataset_from_list( args.train_data_dir, args.train_list_dir) # class objects in a list #----------------------class definition------------------------------------- ''' class ImageClass(): "Stores the paths to images for a given class" def __init__(self, name, image_paths): self.name = name self.image_paths = image_paths def __str__(self): return self.name + ', ' + str(len(self.image_paths)) + ' images' def __len__(self): return len(self.image_paths) ''' nrof_classes = len(train_set) print('nrof_classes: ', nrof_classes) image_list, label_list = utils.get_image_paths_and_labels(train_set) print('total images: ', len(image_list)) # label is in the form scalar. image_list = np.array(image_list) label_list = np.array(label_list, dtype=np.int32) dataset_size = len(image_list) single_batch_size = args.class_per_batch * args.images_per_class indices = list(range(dataset_size)) np.random.shuffle(indices) def _sample_people_softmax(x): # loading the images in batches. global softmax_ind if softmax_ind >= dataset_size: np.random.shuffle(indices) softmax_ind = 0 true_num_batch = min(single_batch_size, dataset_size - softmax_ind) sample_paths = image_list[indices[softmax_ind:softmax_ind + true_num_batch]] sample_images = [] for item in sample_paths: sample_images.append(np.load(str(item))) #print(item) #print(type(sample_paths[0])) sample_labels = label_list[indices[softmax_ind:softmax_ind + true_num_batch]] softmax_ind += true_num_batch return (np.expand_dims(np.array(sample_images, dtype=np.float32), axis=4), np.array(sample_labels, dtype=np.int32)) print('Model directory: %s' % model_dir) print('Log directory: %s' % log_dir) if args.pretrained_model: print('Pre-trained model: %s' % os.path.expanduser(args.pretrained_model)) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False, name='global_step') # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') #the image is generated by sequence with tf.device("/cpu:0"): softmax_dataset = tf.data.Dataset.range(args.epoch_size * args.max_nrof_epochs) softmax_dataset = softmax_dataset.map(lambda x: tf.py_func( _sample_people_softmax, [x], [tf.float32, tf.int32])) softmax_dataset = softmax_dataset.flat_map(_from_tensor_slices) softmax_dataset = softmax_dataset.batch(single_batch_size) softmax_iterator = softmax_dataset.make_initializable_iterator() softmax_next_element = softmax_iterator.get_next() softmax_next_element[0].set_shape( (single_batch_size, args.image_height, args.image_width, args.image_width, 1)) softmax_next_element[1].set_shape(single_batch_size) batch_image_split = softmax_next_element[0] # batch_image_split = tf.expand_dims(batch_image_split, axis = 4) batch_label_split = softmax_next_element[1] learning_rate = tf.train.exponential_decay( learning_rate_placeholder, global_step, args.learning_rate_decay_epochs * args.epoch_size, args.learning_rate_decay_factor, staircase=True) tf.summary.scalar('learning_rate', learning_rate) print('Using optimizer: {}'.format(args.optimizer)) if args.optimizer == 'ADAGRAD': opt = tf.train.AdagradOptimizer(learning_rate) elif args.optimizer == 'SGD': opt = tf.train.GradientDescentOptimizer(learning_rate) elif args.optimizer == 'MOM': opt = tf.train.MomentumOptimizer(learning_rate, 0.9) elif args.optimizer == 'ADAM': opt = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999, epsilon=0.1) else: raise Exception("Not supported optimizer: {}".format( args.optimizer)) losses = {} with slim.arg_scope([slim.model_variable, slim.variable], device="/cpu:0"): with tf.variable_scope(tf.get_variable_scope()) as var_scope: reuse = False if args.network == 'sphere_network': prelogits = network.infer(batch_image_split, args.embedding_size) else: raise Exception("Not supported network: {}".format( args.network)) if args.fc_bn: prelogits = slim.batch_norm(prelogits, is_training=True, decay=0.997,epsilon=1e-5,scale=True,\ updates_collections=tf.GraphKeys.UPDATE_OPS,reuse=reuse,scope='softmax_bn') if args.loss_type == 'softmax': cross_entropy_mean = utils.softmax_loss( prelogits, batch_label_split, len(train_set), 1.0, reuse) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) loss = cross_entropy_mean + args.weight_decay * tf.add_n( regularization_losses) print('************************' + ' Computing the softmax loss') losses['total_loss'] = cross_entropy_mean losses['total_reg'] = args.weight_decay * tf.add_n( regularization_losses) elif args.loss_type == 'lmcl': label_reshape = tf.reshape(batch_label_split, [single_batch_size]) label_reshape = tf.cast(label_reshape, tf.int64) coco_loss = utils.cos_loss(prelogits, label_reshape, len(train_set), reuse, alpha=args.alpha, scale=args.scale) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) loss = coco_loss + args.weight_decay * tf.add_n( regularization_losses) print('************************' + ' Computing the lmcl loss') losses['total_loss'] = coco_loss losses['total_reg'] = args.weight_decay * tf.add_n( regularization_losses) elif args.loss_type == 'center': # center loss center_loss, centers, centers_update_op = get_center_loss(prelogits, label_reshape, args.center_loss_alfa, \ args.num_class_train) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) loss = center_loss + args.weight_decay * tf.add_n( regularization_losses) print('************************' + ' Computing the center loss') losses['total_loss'] = center_loss losses['total_reg'] = args.weight_decay * tf.add_n( regularization_losses) elif args.loss_type == 'lmccl': cross_entropy_mean = utils.softmax_loss( prelogits, batch_label_split, len(train_set), 1.0, reuse) label_reshape = tf.reshape(batch_label_split, [single_batch_size]) label_reshape = tf.cast(label_reshape, tf.int64) coco_loss = utils.cos_loss(prelogits, label_reshape, len(train_set), reuse, alpha=args.alpha, scale=args.scale) center_loss, centers, centers_update_op = get_center_loss(prelogits, label_reshape, args.center_loss_alfa, \ args.num_class_train) regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) reg_loss = args.weight_decay * tf.add_n( regularization_losses) loss = coco_loss + reg_loss + args.center_weighting * center_loss + cross_entropy_mean losses[ 'total_loss_center'] = args.center_weighting * center_loss losses['total_loss_lmcl'] = coco_loss losses['total_loss_softmax'] = cross_entropy_mean losses['total_reg'] = reg_loss grads = opt.compute_gradients(loss, tf.trainable_variables(), colocate_gradients_with_ops=True) apply_gradient_op = opt.apply_gradients(grads, global_step=global_step) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) # used for updating the centers in the center loss. if args.loss_type == 'lmccl' or args.loss_type == 'center': with tf.control_dependencies([centers_update_op]): with tf.control_dependencies(update_ops): train_op = tf.group(apply_gradient_op) else: with tf.control_dependencies(update_ops): train_op = tf.group(apply_gradient_op) save_vars = [ var for var in tf.global_variables() if 'Adagrad' not in var.name and 'global_step' not in var.name ] saver = tf.train.Saver(save_vars, max_to_keep=3) # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # Start running operations on the Graph. gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=args.gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)) # Initialize variables sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder: True}) sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder: True}) #sess.run(iterator.initializer) sess.run(softmax_iterator.initializer) summary_writer = tf.summary.FileWriter(log_dir, sess.graph) coord = tf.train.Coordinator() tf.train.start_queue_runners(coord=coord, sess=sess) with sess.as_default(): if args.pretrained_model: print('Restoring pretrained model: %s' % args.pretrained_model) saver.restore(sess, os.path.expanduser(args.pretrained_model)) # Training and validation loop epoch = 0 while epoch < args.max_nrof_epochs: step = sess.run(global_step, feed_dict=None) epoch = step // args.epoch_size if debug: debug_train(args, sess, train_set, epoch, image_batch_gather,\ enqueue_op,batch_size_placeholder, image_batch_split,image_paths_split,num_per_class_split, image_paths_placeholder,image_paths_split_placeholder, labels_placeholder, labels_batch,\ num_per_class_placeholder,num_per_class_split_placeholder,len(gpus)) # Train for one epoch if args.loss_type == 'lmccl' or args.loss_type == 'center': train_contain_center(args, sess, epoch, learning_rate_placeholder, phase_train_placeholder, global_step, losses, train_op, summary_op, summary_writer, '', centers_update_op) else: train(args, sess, epoch, learning_rate_placeholder, phase_train_placeholder, global_step, losses, train_op, summary_op, summary_writer, '') # Save variables and the metagraph if it doesn't exist already save_variables_and_metagraph(sess, saver, summary_writer, model_dir, subdir, step) return model_dir
def extract_features(model, source, destination, image_height, image_width, prewhiten, fc_bn, feature_size): if path.isfile(source): full_path = True source_list = np.sort(np.loadtxt(source, dtype=np.str)) else: full_path = False source_list = listdir(source) with tf.Graph().as_default(): with tf.Session() as sess: images_placeholder = tf.placeholder(tf.float32, shape=(None, image_height, image_width, 3), name='image') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') prelogits = network.infer(images_placeholder, feature_size) if fc_bn: prelogits = slim.batch_norm( prelogits, is_training=phase_train_placeholder, epsilon=1e-5, scale=True, scope='softmax_bn') embeddings = tf.identity(prelogits) saver = tf.train.Saver(tf.global_variables(), max_to_keep=3) saver.restore(sess, model) for image_name in source_list: if not full_path: image_path = path.join(source, image_name) else: image_path = image_name image_name = path.split(image_name)[1] if not image_path.lower().endswith('.png') and not image_path.lower().endswith('.jpg') \ and not image_path.lower().endswith('.bmp'): continue dest_path = destination if full_path: sub_folder = path.basename( path.normpath(path.split(image_path)[0])) dest_path = path.join(destination, sub_folder) if not path.exists(dest_path): makedirs(dest_path) features_name = path.join(dest_path, image_name[:-3] + 'npy') images = utils.load_data([image_path], False, False, image_height, image_width, prewhiten, (image_height, image_width)) feed_dict = { images_placeholder: images, phase_train_placeholder: False } feats = sess.run(embeddings, feed_dict=feed_dict) feats = utils.l2_normalize(feats) np.save(features_name, feats)
def test(args): with tf.Graph().as_default(): with tf.Session() as sess: #saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) saver = tf.train.Saver(tf.global_variables()) saver.restore(sess, args.model) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.test_list_dir)) # Get the paths for the corresponding images paths, actual_issame = lfw.get_paths( os.path.expanduser(args.test_data_dir), pairs, args.test_list_dir) image_size = args.image_size print('image size', image_size) images_placeholder = tf.placeholder(tf.float32, shape=(None, args.image_height, args.image_width, args.image_width), name='image') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') #network definition. prelogits1 = network.infer(images_placeholder, args.embedding_size) if args.fc_bn: print('do batch norm after network') prelogits = slim.batch_norm( prelogits1, is_training=phase_train_placeholder, epsilon=1e-5, scale=True, scope='softmax_bn') #embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') embeddings = tf.identity(prelogits) embedding_size = embeddings.get_shape()[1] # Run forward pass to calculate embeddings print('Runnning forward pass on testing images') batch_size = args.test_batch_size nrof_images = len(paths) nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches): start_index = i * batch_size print('handing {}/{}'.format(start_index, nrof_images)) end_index = min((i + 1) * batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = utils.load_data(paths_batch, False, False, args.image_height,args.image_width,False,\ (args.image_height,args.image_width)) feed_dict = { images_placeholder: images, phase_train_placeholder: False } feats, a = sess.run([embeddings, prelogits], feed_dict=feed_dict) # do not know for sure whether we should turn this on? it depends. feats = utils.l2_normalize(feats) emb_array[start_index:end_index, :] = feats tpr, fpr, accuracy, val, val_std, far = lfw.evaluate( emb_array, actual_issame, 0.001, nrof_folds=args.test_nrof_folds) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) auc = metrics.auc(fpr, tpr) print('Area Under Curve (AUC): %1.3f' % auc) # eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.) #fill_value="extrapolate" print('Equal Error Rate (EER): %1.3f' % eer) tpr1, fpr1, accuracy1, val1, val_std1, far1 = lfw.evaluate( emb_array, actual_issame, 0.0001, nrof_folds=args.test_nrof_folds) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy1), np.std(accuracy1))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val1, val_std1, far1)) auc = metrics.auc(fpr1, tpr1) print('Area Under Curve (AUC): %1.3f' % auc) # eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr1, tpr1) (x), 0., 1.) #fill_value="extrapolate" print('Equal Error Rate (EER): %1.3f' % eer)