def main(args): dataset = facenet.get_dataset(args.dir) paths, _ = facenet.get_image_paths_and_labels(dataset) t = np.zeros((len(paths))) x = time.time() for i, path in enumerate(paths): start_time = time.time() with open(path, mode='rb') as f: _ = f.read() duration = time.time() - start_time t[i] = duration if i % 1000 == 0 or i == len(paths) - 1: print('File %d/%d Total time: %.2f Avg: %.3f Std: %.3f' % (i, len(paths), time.time() - x, np.mean(t[0:i]) * 1000, np.std(t[0:i]) * 1000))
def main(args): train_set = facenet.get_dataset(args.data_dir) image_list, label_list = facenet.get_image_paths_and_labels(train_set) # fetch the classes (labels as strings) exactly as it's done in get_dataset path_exp = os.path.expanduser(args.data_dir) classes = [path for path in os.listdir(path_exp) \ if os.path.isdir(os.path.join(path_exp, path))] classes.sort() # get the label strings label_strings = [name for name in classes if \ os.path.isdir(os.path.join(path_exp, name))] images = load_and_align_data(image_list, args.image_size, args.margin, args.gpu_memory_fraction) with tf.Graph().as_default(): with tf.Session() as sess: # Load the model facenet.load_model(args.model) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") # Run forward pass to calculate embeddings feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb = sess.run(embeddings, feed_dict=feed_dict) nrof_images = len(image_list) # export emedings and labels label_list = np.array(label_list) np.save(args.embeddings_name, emb) label_strings = np.array(label_strings) np.save(args.labels_strings_name, label_strings[label_list])
def main(): image_size = 96 old_dataset = '/home/david/datasets/facescrub/fs_aligned_new_oean/' new_dataset = '/home/david/datasets/facescrub/facescrub_110_96/' eq = 0 num = 0 l = [] dataset = facenet.get_dataset(old_dataset) for cls in dataset: new_class_dir = os.path.join(new_dataset, cls.name) for image_path in cls.image_paths: try: filename = os.path.splitext(os.path.split(image_path)[1])[0] new_filename = os.path.join(new_class_dir, filename + '.png') #print(image_path) if os.path.exists(new_filename): a = facenet.load_data([image_path, new_filename], False, False, image_size, do_prewhiten=False) if np.array_equal(a[0], a[1]): eq += 1 num += 1 err = np.sum(np.square(np.subtract(a[0], a[1]))) #print(err) l.append(err) if err > 2000: fig = plt.figure(1) p1 = fig.add_subplot(121) p1.imshow(a[0]) p2 = fig.add_subplot(122) p2.imshow(a[1]) print('%6.1f: %s\n' % (err, new_filename)) pass else: pass #print('File not found: %s' % new_filename) except: pass
def train(server, cluster_spec, args, ctx): task_index = ctx.task_index num_workers = len(cluster_spec['worker']) is_chief = task_index == 0 local_data_path = args.local_data_path data_dir = os.path.join(local_data_path, "train") val_dir = os.path.join(local_data_path, "val") val_pairs = os.path.join(local_data_path, "pairs.txt") subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') log_dir = args.workspace + "/logs/" + subdir checkpoint_dir = args.checkpoint_dir if args.checkpoint_dir else (args.workspace + "/models/" + subdir) if task_index == 0: if not tf.gfile.Exists(args.workspace): tf.gfile.MakeDirs(args.workspace) if not tf.gfile.Exists(checkpoint_dir): tf.gfile.MakeDirs(checkpoint_dir) if not tf.gfile.Exists(log_dir): tf.gfile.MakeDirs(log_dir) seed = random.SystemRandom().randint(0, 10240) print("Random seed: " + str(seed)) np.random.seed(seed=seed) train_set = facenet.get_dataset(data_dir) print('Model directory: %s' % checkpoint_dir) print('Log directory: %s' % log_dir) # Read the file containing the pairs used for testing pairs = read_pairs(val_pairs) # Get the paths for the corresponding images val_image_paths, actual_issame = get_paths(val_dir, pairs) with tf.device(tf.train.replica_device_setter(worker_device="/job:worker/task:%d" % task_index, cluster=cluster_spec)): tf.set_random_seed(seed) # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 3), name='image_paths') labels_placeholder = tf.placeholder(tf.int64, shape=(None, 3), name='labels') input_queue = data_flow_ops.FIFOQueue(capacity=10000, dtypes=[tf.string, tf.int64], shapes=[(3,), (3,)], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder]) nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) image = tf.image.decode_image(file_contents, channels=3) processed_image = vgg_preprocessing.preprocess_image(image, args.image_size, args.image_size, is_training=False, bgr=True) if args.random_flip: processed_image = tf.image.random_flip_left_right(processed_image) images.append(processed_image) images_and_labels.append([images, label]) image_batch, labels_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) image_batch = tf.identity(image_batch, 'image_batch') image_batch = tf.identity(image_batch, 'input') labels_batch = tf.identity(labels_batch, 'label_batch') with slim.arg_scope(resnet_v1.resnet_arg_scope(weight_decay=args.weight_decay)): val_logits, _ = resnet_v1.resnet_v1_101_triplet(image_batch, embedding_size=args.embedding_size, is_training=phase_train_placeholder) loader = tf.train.Saver() global_step = tf.train.get_or_create_global_step() embeddings = tf.squeeze(val_logits['triplet_pre_embeddings'], [1, 2], name='feat_embeddings/squeezed') embeddings = tf.nn.l2_normalize(embeddings, 1, 1e-10, name='embeddings') # Split embeddings into anchor, positive and negative and calculate triplet loss anchor, positive, negative = tf.unstack(tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1) triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha) 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) # Calculate the total losses regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss') tf.summary.scalar('learning_rate', learning_rate) tf.summary.scalar('triplet_loss', triplet_loss) tf.summary.scalar('total_losses', total_loss) train_layers = ['logits', 'mutli_task'] var_list = [] for v in tf.global_variables(): splits = v.name.split("/") if len(splits) > 2 and splits[1] in train_layers: var_list.append(v) train_op, opt = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, var_list, sync_replicas=args.sync_replicas, replicas_to_aggregate=num_workers) summary_op = tf.summary.merge_all() saver = tf.train.Saver() hooks = [] if args.sync_replicas: hooks += [opt.make_session_run_hook(is_chief)] sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, device_filters=['/job:ps', '/job:worker/task:%d' % task_index]) #sess_config.operation_timeout_in_ms=80000 save_path = os.path.join(checkpoint_dir, "model.ckpt") with tf.train.MonitoredTrainingSession(master=server.target, is_chief=is_chief, config=sess_config, hooks=hooks, save_summaries_steps=None, save_summaries_secs=None, stop_grace_period_secs=30) as sess: # Training and validation loop summary_writer = tf.summary.FileWriter(log_dir, sess.graph) if is_chief else None if is_chief: loader.restore(sess, args.pretrained_ckpt) step = 0 while True: if is_chief: # checkpoint_path = os.path.join(checkpoint_dir, 'model-%s.ckpt' % "test") # saver.save(sess._sess._sess._sess._sess, checkpoint_path, global_step=step, write_meta_graph=False) evaluate(sess, val_image_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size, args.lfw_nrof_folds, step, summary_writer, args.embedding_size) saver.save(sess._sess._sess._sess._sess, save_path, global_step = step) # Train for one epoch step = _train(args, sess, train_set, image_paths_placeholder, labels_placeholder, labels_batch, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings, total_loss, train_op, args.embedding_size, triplet_loss, summary_op, summary_writer) return checkpoint_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) # Store some git revision info in a text file in the log directory src_path,_ = os.path.split(os.path.realpath(__file__)) facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) random.seed(args.seed) print (args.data_dir) train_set = facenet.get_dataset(args.data_dir) if args.filter_filename: train_set = filter_dataset(train_set, os.path.expanduser(args.filter_filename), args.filter_percentile, args.filter_min_nrof_images_per_class) nrof_classes = len(train_set) print('Model directory: %s' % model_dir) print('Log directory: %s' % log_dir) pretrained_model = None if args.pretrained_model: pretrained_model = os.path.expanduser(args.pretrained_model) print('Pre-trained model: %s' % pretrained_model) if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # Get a list of image paths and their labels image_list, label_list = facenet.get_image_paths_and_labels(train_set) assert len(image_list)>0, 'The dataset should not be empty' # Create a queue that produces indices into the image_list and label_list labels = ops.convert_to_tensor(label_list, dtype=tf.int32) range_size = array_ops.shape(labels)[0] index_queue = tf.train.range_input_producer(range_size, num_epochs=None, shuffle=True, seed=None, capacity=32) index_dequeue_op = index_queue.dequeue_many(args.batch_size*args.epoch_size, 'index_dequeue') learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None,1), name='image_paths') labels_placeholder = tf.placeholder(tf.int64, shape=(None,1), name='labels') input_queue = data_flow_ops.FIFOQueue(capacity=100000, dtypes=[tf.string, tf.int64], shapes=[(1,), (1,)], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder], name='enqueue_op') nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) image = tf.image.decode_image(file_contents) if args.random_rotate: image = tf.py_func(facenet.random_rotate_image, [image], tf.uint8) if args.random_crop: image = tf.random_crop(image, [args.image_size, args.image_size, 3]) else: image = tf.image.resize_image_with_crop_or_pad(image, args.image_size, args.image_size) 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)) images.append(tf.image.per_image_standardization(image)) images_and_labels.append([images, label]) image_batch, label_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) image_batch = tf.identity(image_batch, 'image_batch') image_batch = tf.identity(image_batch, 'input') label_batch = tf.identity(label_batch, 'label_batch') print('Total number of classes: %d' % nrof_classes) print('Total number of examples: %d' % len(image_list)) print('Building training graph') # Build the inference graph prelogits, _ = network.inference(image_batch, args.keep_probability, phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, weight_decay=args.weight_decay) logits = slim.fully_connected(prelogits, len(train_set), activation_fn=None, weights_initializer=tf.truncated_normal_initializer(stddev=0.1), weights_regularizer=slim.l2_regularizer(args.weight_decay), scope='Logits', reuse=False) embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Add center loss if args.center_loss_factor>0.0: prelogits_center_loss, _ = facenet.center_loss(prelogits, label_batch, args.center_loss_alfa, nrof_classes) tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_center_loss * args.center_loss_factor) 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) # Calculate the average cross entropy loss across the batch cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=label_batch, logits=logits, name='cross_entropy_per_example') cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy') tf.add_to_collection('losses', cross_entropy_mean) # Calculate the total losses regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables(), args.log_histograms) # Create a saver saver = tf.train.Saver(tf.trainable_variables(), 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, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_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 pretrained_model: print('Restoring pretrained model: %s' % pretrained_model) saver.restore(sess, pretrained_model) # Training and validation loop print('Running training') 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, image_list, label_list, index_dequeue_op, enqueue_op, image_paths_placeholder, labels_placeholder, learning_rate_placeholder, phase_train_placeholder, batch_size_placeholder, global_step, total_loss, train_op, summary_op, summary_writer, regularization_losses, 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 if args.lfw_dir: evaluate(sess, enqueue_op, image_paths_placeholder, labels_placeholder, phase_train_placeholder, batch_size_placeholder, embeddings, label_batch, lfw_paths, actual_issame, args.lfw_batch_size, args.lfw_nrof_folds, log_dir, step, summary_writer) sess.close() return model_dir
def main(args): dataset = facenet.get_dataset(args.dataset_dir) with tf.Graph().as_default(): # Get a list of image paths and their labels image_list, label_list = facenet.get_image_paths_and_labels(dataset) nrof_images = len(image_list) image_indices = range(nrof_images) image_batch, label_batch = facenet.read_and_augment_data( image_list, image_indices, args.image_size, args.batch_size, None, False, False, False, nrof_preprocess_threads=4, shuffle=False) model_exp = os.path.expanduser(args.model_file) with gfile.FastGFile(model_exp, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) input_map = {'input': image_batch, 'phase_train': False} tf.import_graph_def(graph_def, input_map=input_map, name='net') embeddings = tf.get_default_graph().get_tensor_by_name( "net/embeddings:0") with tf.Session() as sess: tf.train.start_queue_runners(sess=sess) embedding_size = int(embeddings.get_shape()[1]) nrof_batches = int(math.ceil(nrof_images / args.batch_size)) nrof_classes = len(dataset) label_array = np.array(label_list) class_names = [cls.name for cls in dataset] nrof_examples_per_class = [len(cls.image_paths) for cls in dataset] class_variance = np.zeros((nrof_classes, )) class_center = np.zeros((nrof_classes, embedding_size)) distance_to_center = np.ones((len(label_list), )) * np.NaN emb_array = np.zeros((0, embedding_size)) idx_array = np.zeros((0, ), dtype=np.int32) lab_array = np.zeros((0, ), dtype=np.int32) index_arr = np.append(0, np.cumsum(nrof_examples_per_class)) for i in range(nrof_batches): t = time.time() emb, idx = sess.run([embeddings, label_batch]) emb_array = np.append(emb_array, emb, axis=0) idx_array = np.append(idx_array, idx, axis=0) lab_array = np.append(lab_array, label_array[idx], axis=0) for cls in set(lab_array): cls_idx = np.where(lab_array == cls)[0] if cls_idx.shape[0] == nrof_examples_per_class[cls]: # We have calculated all the embeddings for this class i2 = np.argsort(idx_array[cls_idx]) emb_class = emb_array[cls_idx, :] emb_sort = emb_class[i2, :] center = np.mean(emb_sort, axis=0) diffs = emb_sort - center dists_sqr = np.sum(np.square(diffs), axis=1) class_variance[cls] = np.mean(dists_sqr) class_center[cls, :] = center distance_to_center[ index_arr[cls]:index_arr[cls + 1]] = np.sqrt(dists_sqr) emb_array = np.delete(emb_array, cls_idx, axis=0) idx_array = np.delete(idx_array, cls_idx, axis=0) lab_array = np.delete(lab_array, cls_idx, axis=0) print('Batch %d in %.3f seconds' % (i, time.time() - t)) print('Writing filtering data to %s' % args.data_file_name) mdict = { 'class_names': class_names, 'image_list': image_list, 'label_list': label_list, 'distance_to_center': distance_to_center } with h5py.File(args.data_file_name, 'w') as f: for key, value in iteritems(mdict): f.create_dataset(key, data=value)
paths = cls.image_paths # Remove classes with less than min_nrof_images_per_class if len(paths)>=min_nrof_images_per_class: np.random.shuffle(paths) train_set.append(facenet.ImageClass(cls.name, paths[:nrof_train_images_per_class])) test_set.append(facenet.ImageClass(cls.name, paths[nrof_train_images_per_class:])) return train_set, test_set with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(seed=seed) if use_split_dataset: dataset_tmp = facenet.get_dataset(data_dir) train_set, test_set = split_dataset(dataset_tmp, min_nrof_images_per_class, nrof_train_images_per_class) if (mode=='TRAIN'): dataset = train_set elif (mode=='CLASSIFY'): dataset = test_set else: dataset = facenet.get_dataset(data_dir) # Check that there are at least one training image per class for cls in dataset: assert(len(cls.image_paths)>0, 'There must be at least one image for each class in the dataset') paths, labels = facenet.get_image_paths_and_labels(dataset)
def main(args): sleep(random.random()) output_dir = os.path.expanduser(args.output_dir) if not os.path.exists(output_dir): os.makedirs(output_dir) # Store some git revision info in a text file in the log directory src_path, _ = os.path.split(os.path.realpath(__file__)) facenet.store_revision_info(src_path, output_dir, ' '.join(sys.argv)) dataset = facenet.get_dataset(args.input_dir) print('Creating networks and loading parameters') with tf.Graph().as_default(): gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=args.gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False)) with sess.as_default(): pnet, rnet, onet = align.detect_face.create_mtcnn(sess, None) minsize = 20 # minimum size of face threshold = [0.6, 0.7, 0.7] # three steps's threshold factor = 0.709 # scale factor # Add a random key to the filename to allow alignment using multiple processes random_key = np.random.randint(0, high=99999) bounding_boxes_filename = os.path.join( output_dir, 'bounding_boxes_%05d.txt' % random_key) with open(bounding_boxes_filename, "w") as text_file: nrof_images_total = 0 nrof_successfully_aligned = 0 if args.random_order: random.shuffle(dataset) for cls in dataset: output_class_dir = os.path.join(output_dir, cls.name) if not os.path.exists(output_class_dir): os.makedirs(output_class_dir) if args.random_order: random.shuffle(cls.image_paths) for image_path in cls.image_paths: nrof_images_total += 1 filename = os.path.splitext(os.path.split(image_path)[1])[0] output_filename = os.path.join(output_class_dir, filename + '.png') print(image_path) if not os.path.exists(output_filename): try: img = misc.imread(image_path) except (IOError, ValueError, IndexError) as e: errorMessage = '{}: {}'.format(image_path, e) print(errorMessage) else: if img.ndim < 2: print('Unable to align "%s"' % image_path) text_file.write('%s\n' % (output_filename)) continue if img.ndim == 2: img = facenet.to_rgb(img) img = img[:, :, 0:3] bounding_boxes, _ = align.detect_face.detect_face( img, minsize, pnet, rnet, onet, threshold, factor) nrof_faces = bounding_boxes.shape[0] if nrof_faces > 0: det = bounding_boxes[:, 0:4] det_arr = [] img_size = np.asarray(img.shape)[0:2] if nrof_faces > 1: if args.detect_multiple_faces: for i in range(nrof_faces): det_arr.append(np.squeeze(det[i])) else: bounding_box_size = ( det[:, 2] - det[:, 0]) * (det[:, 3] - det[:, 1]) img_center = img_size / 2 offsets = np.vstack([ (det[:, 0] + det[:, 2]) / 2 - img_center[1], (det[:, 1] + det[:, 3]) / 2 - img_center[0] ]) offset_dist_squared = np.sum( np.power(offsets, 2.0), 0) index = np.argmax( bounding_box_size - offset_dist_squared * 2.0 ) # some extra weight on the centering det_arr.append(det[index, :]) else: det_arr.append(np.squeeze(det)) for i, det in enumerate(det_arr): det = np.squeeze(det) bb = np.zeros(4, dtype=np.int32) bb[0] = np.maximum(det[0] - args.margin / 2, 0) bb[1] = np.maximum(det[1] - args.margin / 2, 0) bb[2] = np.minimum(det[2] + args.margin / 2, img_size[1]) bb[3] = np.minimum(det[3] + args.margin / 2, img_size[0]) cropped = img[bb[1]:bb[3], bb[0]:bb[2], :] scaled = misc.imresize( cropped, (args.image_size, args.image_size), interp='bilinear') nrof_successfully_aligned += 1 filename_base, file_extension = os.path.splitext( output_filename) if args.detect_multiple_faces: output_filename_n = "{}_{}{}".format( filename_base, i, file_extension) else: output_filename_n = "{}{}".format( filename_base, file_extension) misc.imsave(output_filename_n, scaled) text_file.write('%s %d %d %d %d\n' % (output_filename_n, bb[0], bb[1], bb[2], bb[3])) else: print('Unable to align "%s"' % image_path) text_file.write('%s\n' % (output_filename)) print('Total number of images: %d' % nrof_images_total) print('Number of successfully aligned images: %d' % nrof_successfully_aligned)
def main(args): img_mean = np.array([134.10714722, 102.52040863, 87.15436554]) img_stddev = np.sqrt( np.array([3941.30175781, 2856.94287109, 2519.35791016])) vae_def = importlib.import_module(args.vae_def) vae = vae_def.Vae(args.latent_var_size) gen_image_size = vae.get_image_size() subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') 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) log_file_name = os.path.join(model_dir, 'logs.h5') # Write arguments to a text file facenet.write_arguments_to_file(args, os.path.join(model_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__)) facenet.store_revision_info(src_path, model_dir, ' '.join(sys.argv)) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) train_set = facenet.get_dataset(args.data_dir) image_list, _ = facenet.get_image_paths_and_labels(train_set) # Create the input queue input_queue = tf.train.string_input_producer(image_list, shuffle=True) nrof_preprocess_threads = 4 image_per_thread = [] for _ in range(nrof_preprocess_threads): file_contents = tf.read_file(input_queue.dequeue()) image = tf.image.decode_image(file_contents, channels=3) image = tf.image.resize_image_with_crop_or_pad( image, args.input_image_size, args.input_image_size) image.set_shape((args.input_image_size, args.input_image_size, 3)) image = tf.cast(image, tf.float32) #pylint: disable=no-member image_per_thread.append([image]) images = tf.train.batch_join(image_per_thread, batch_size=args.batch_size, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=False) # Normalize images_norm = (images - img_mean) / img_stddev # Resize to appropriate size for the encoder images_norm_resize = tf.image.resize_images( images_norm, (gen_image_size, gen_image_size)) # Create encoder network mean, log_variance = vae.encoder(images_norm_resize, True) epsilon = tf.random_normal((tf.shape(mean)[0], args.latent_var_size)) std = tf.exp(log_variance / 2) latent_var = mean + epsilon * std # Create decoder network reconstructed_norm = vae.decoder(latent_var, True) # Un-normalize reconstructed = (reconstructed_norm * img_stddev) + img_mean # Create reconstruction loss if args.reconstruction_loss_type == 'PLAIN': images_resize = tf.image.resize_images( images, (gen_image_size, gen_image_size)) reconstruction_loss = tf.reduce_mean( tf.reduce_sum(tf.pow(images_resize - reconstructed, 2))) elif args.reconstruction_loss_type == 'PERCEPTUAL': network = importlib.import_module(args.model_def) reconstructed_norm_resize = tf.image.resize_images( reconstructed_norm, (args.input_image_size, args.input_image_size)) # Stack images from both the input batch and the reconstructed batch in a new tensor shp = [-1] + images_norm.get_shape().as_list()[1:] input_images = tf.reshape( tf.stack([images_norm, reconstructed_norm_resize], axis=0), shp) _, end_points = network.inference(input_images, 1.0, phase_train=False, bottleneck_layer_size=128, weight_decay=0.0) # Get a list of feature names to use for loss terms feature_names = args.loss_features.replace(' ', '').split(',') # Calculate L2 loss between original and reconstructed images in feature space reconstruction_loss_list = [] for feature_name in feature_names: feature_flat = slim.flatten(end_points[feature_name]) image_feature, reconstructed_feature = tf.unstack(tf.reshape( feature_flat, [2, args.batch_size, -1]), num=2, axis=0) reconstruction_loss = tf.reduce_mean(tf.reduce_sum( tf.pow(image_feature - reconstructed_feature, 2)), name=feature_name + '_loss') reconstruction_loss_list.append(reconstruction_loss) # Sum up the losses in for the different features reconstruction_loss = tf.add_n(reconstruction_loss_list, 'reconstruction_loss') else: pass # Create KL divergence loss kl_loss = kl_divergence_loss(mean, log_variance) kl_loss_mean = tf.reduce_mean(kl_loss) total_loss = args.alfa * kl_loss_mean + args.beta * reconstruction_loss learning_rate = tf.train.exponential_decay( args.initial_learning_rate, global_step, args.learning_rate_decay_steps, args.learning_rate_decay_factor, staircase=True) # Calculate gradients and make sure not to include parameters for the perceptual loss model opt = tf.train.AdamOptimizer(learning_rate) grads = opt.compute_gradients(total_loss, var_list=get_variables_to_train()) # Apply gradients apply_gradient_op = opt.apply_gradients(grads, global_step=global_step) with tf.control_dependencies([apply_gradient_op]): train_op = tf.no_op(name='train') # Create a saver saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) facenet_saver = tf.train.Saver(get_facenet_variables_to_restore()) # Start running operations on the Graph gpu_memory_fraction = 1.0 gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) coord = tf.train.Coordinator() tf.train.start_queue_runners(coord=coord, sess=sess) with sess.as_default(): if args.reconstruction_loss_type == 'PERCEPTUAL': if not args.pretrained_model: raise ValueError( 'A pretrained model must be specified when using perceptual loss' ) pretrained_model_exp = os.path.expanduser( args.pretrained_model) print('Restoring pretrained model: %s' % pretrained_model_exp) facenet_saver.restore(sess, pretrained_model_exp) log = { 'total_loss': np.zeros((0, ), np.float), 'reconstruction_loss': np.zeros((0, ), np.float), 'kl_loss': np.zeros((0, ), np.float), 'learning_rate': np.zeros((0, ), np.float), } step = 0 print('Running training') while step < args.max_nrof_steps: start_time = time.time() step += 1 save_state = step > 0 and (step % args.save_every_n_steps == 0 or step == args.max_nrof_steps) if save_state: _, reconstruction_loss_, kl_loss_mean_, total_loss_, learning_rate_, rec_ = sess.run( [ train_op, reconstruction_loss, kl_loss_mean, total_loss, learning_rate, reconstructed ]) img = facenet.put_images_on_grid(rec_, shape=(16, 8)) misc.imsave( os.path.join(model_dir, 'reconstructed_%06d.png' % step), img) else: _, reconstruction_loss_, kl_loss_mean_, total_loss_, learning_rate_ = sess.run( [ train_op, reconstruction_loss, kl_loss_mean, total_loss, learning_rate ]) log['total_loss'] = np.append(log['total_loss'], total_loss_) log['reconstruction_loss'] = np.append( log['reconstruction_loss'], reconstruction_loss_) log['kl_loss'] = np.append(log['kl_loss'], kl_loss_mean_) log['learning_rate'] = np.append(log['learning_rate'], learning_rate_) duration = time.time() - start_time print( 'Step: %d \tTime: %.3f \trec_loss: %.3f \tkl_loss: %.3f \ttotal_loss: %.3f' % (step, duration, reconstruction_loss_, kl_loss_mean_, total_loss_)) if save_state: print('Saving checkpoint file') checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step, write_meta_graph=False) print('Saving log') with h5py.File(log_file_name, 'w') as f: for key, value in iteritems(log): f.create_dataset(key, data=value)
def main(args): #此处导入的是:models.inception_resnet_v1模型,以后再看怎么更改模型 network = importlib.import_module(args.model_def) #用当前日期来命名模型 subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') #日志保存在c:\\users\\Administrator\logs\facenet\ 文件夹里 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) # 把参数写在日志文件中 facenet.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__)) #arg_string:'E:/facenet/train_tripletloss.py' output_dir:'C:\\Users\\Administrator/logs/facenet\\20180314-181556' facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) #获取数据集,train_set是包含文件路径与标签的集合 #先输入一个父路径 path:'E:/facenet/data/lfw_160',接着输入每个子路径 # 输出:一个list,每个元素是一个ImageClass,里边包含图片地址的list(image_paths)以及对应的人名(name)[以后可能会直接调用这几个属性] train_set = facenet.get_dataset(args.data_dir) 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)) if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths( os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) #建立图 #with语句适用于对资源进行访问的场合,确保使用过程中是否发生异常都会执行必要嘚瑟“清理”操作 with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # 学习率 Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') #批大小 batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') #用于判断是训练还是测试 phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') #图像路径 image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 3), name='image_paths') # 图像标签 labels_placeholder = tf.placeholder(tf.int64, shape=(None, 3), name='labels') #新建一个队列,数据流操作,fifo先入先出 input_queue = data_flow_ops.FIFOQueue(capacity=100000, dtypes=[tf.string, tf.int64], shapes=[(3, ), (3, )], shared_name=None, name=None) #enqueue_many返回的是一个操作 enqueue_op = input_queue.enqueue_many( [image_paths_placeholder, labels_placeholder]) nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) image = tf.image.decode_image(file_contents, channels=3) if args.random_crop: image = tf.random_crop( image, [args.image_size, args.image_size, 3]) else: image = tf.image.resize_image_with_crop_or_pad( image, args.image_size, args.image_size) 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)) images.append(tf.image.per_image_standardization(image)) images_and_labels.append([images, label]) image_batch, labels_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) image_batch = tf.identity(image_batch, 'image_batch') image_batch = tf.identity(image_batch, 'input') labels_batch = tf.identity(labels_batch, 'label_batch') # Build the inference (构造计算图) #其中prelogits是最后一层的输出 prelogits, _ = network.inference( image_batch, args.keep_probability, phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, weight_decay=args.weight_decay) #L2正则化(范化)函数 # embeddings = tf.nn.l2_normalize(输入向量, L2范化的维数(取0(列L2范化)或1(行L2范化)), 泛化的最小值边界, name='embeddings') embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Split embeddings into anchor, positive and negative and calculate triplet loss anchor, positive, negative = tf.unstack( tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1) triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha) #将指数衰减应用在学习率上 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) # 计算损失 regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) #构建L2正则化 total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters # 确定优化方法并根据损失函数求梯度,在这里,每更行一次参数,global_step会加1 train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables()) # Create a saver创建一个saver用来保存或者从内存中回复一个模型参数 saver = tf.train.Saver(tf.trainable_variables(), 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上分配的最大内存 gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=args.gpu_memory_fraction) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) # 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}) #写log文件 summary_writer = tf.summary.FileWriter(log_dir, sess.graph) #获取线程坐标 coord = tf.train.Coordinator() #将队列中的多用sunner开始执行 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 #将所有数据过一遍的次数 默认500 while epoch < args.max_nrof_epochs: step = sess.run(global_step, feed_dict=None) #epoch_size是一个epoch中批的个数,这个epoch是全局的批处理个数以一个epoch中。。。这个epoch将用于求学习率 epoch = step // args.epoch_size # Train for one epoch train(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file, args.embedding_size, anchor, positive, negative, triplet_loss) # 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 if args.lfw_dir: evaluate(sess, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size, args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size) return model_dir
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(seed=args.seed) #입력한 폴더에서 데이터셋 나눠서 if args.use_split_dataset: dataset_tmp = facenet.get_dataset(args.data_dir) train_set, test_set = split_dataset(dataset_tmp, args.min_nrof_images_per_class, args.nrof_train_images_per_class) if (args.mode=='TRAIN'): dataset = train_set elif (args.mode=='CLASSIFY'): dataset = test_set #입력한 폴더대로 else: dataset = facenet.get_dataset(args.data_dir) # Check that there are at least one training image per class for cls in dataset: assert(len(cls.image_paths)>0, 'There must be at least one image for each class in the dataset') paths, labels = facenet.get_image_paths_and_labels(dataset)#'[datasets\\test\\yeojingoo\\2019010302124_0.jpg',...] , labels_flat: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1] print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) # Load the model print('Loading feature extraction model') facenet.load_model(args.model) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] # Run forward pass to calculate embeddings print('Calculating features for images') nrof_images = len(paths) nrof_batches_per_epoch = int(math.ceil(1.0*nrof_images / args.batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): start_index = i*args.batch_size end_index = min((i+1)*args.batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data_npy(paths_batch, False, False, args.image_size) feed_dict = { images_placeholder:images, phase_train_placeholder:False } emb_array[start_index:end_index,:] = sess.run(embeddings, feed_dict=feed_dict) # 여기서 임베딩값 np.save("emb.npy", emb_array) classifier_filename_exp = os.path.expanduser(args.classifier_filename)#절대경로로 바꿔줌 if (args.mode=='TRAIN'): # Train classifier print('Training classifier') model = GaussianNB() #model = SVC(kernel='linear', probability=True) model.fit(emb_array, labels) #분석 print("분석") print(model.classes_) print(model.class_count_) print(model.class_prior_) # Create a list of class names class_names = [ cls.name.replace('_', ' ') for cls in dataset] # Saving classifier model with open(classifier_filename_exp, 'wb') as outfile: pickle.dump((model, class_names), outfile) print('Saved classifier model to file "%s"' % classifier_filename_exp) elif (args.mode=='CLASSIFY'): # Classify images print('===Testing classifier===') with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) with open('models\datasets_classifier.pkl', 'rb') as file: data_list = [] while True: try: data = pickle.load(file) except EOFError: print("end") break data_list.append(data) print(data_list) print('Loaded classifier model from file "%s"' % classifier_filename_exp) print("model: ", model) #예측 predictions = model.predict_proba(emb_array) best_class_indices = np.argmax(predictions, axis=1) print(predictions) best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]#49장 이미지에 대해 이미지 순서 - 최고 예측 이미지 인덱스 print("np.arange(len(best_class_indices)): ", np.arange(len(best_class_indices))) print("best_class_probabilities: ",best_class_probabilities) for i in range(len(best_class_indices)): print('%4d %s: %.3f' % (i, class_names[best_class_indices[i]], best_class_probabilities[i])) accuracy = np.mean(np.equal(best_class_indices, labels)) print('Accuracy: %.3f' % accuracy)
def main(args): network = importlib.import_module(args.model_def, 'inference') 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) subdirmaxlin= subdir+'_lin_max' #fbtian_max maxlin_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdirmaxlin)#fbtian_max if not os.path.exists(maxlin_dir):#fbtian_max os.makedirs(maxlin_dir)#fbtian_max subdirmax= subdir+'_max' #fbtian_max modelmax_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdirmax)#fbtian_max if not os.path.exists(modelmax_dir):#fbtian_max os.makedirs(modelmax_dir)#fbtian_max # Store some git revision info in a text file in the log directory if not args.no_store_revision_info: src_path,_ = os.path.split(os.path.realpath(__file__)) facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) train_set = facenet.get_dataset(args.data_dir) #for i in range(args.send2): # np.random.shuffle(np.arange(10)) 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)) if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None,3), name='image_paths') labels_placeholder = tf.placeholder(tf.int64, shape=(None,3), name='labels') input_queue = data_flow_ops.FIFOQueue(capacity=100000, dtypes=[tf.string, tf.int64], shapes=[(3,), (3,)], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder]) nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] fb_count=0 for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) print('filename:%s'%filename ) image = tf.image.decode_png(file_contents) if args.random_crop: print('args.random_crop') #fbtian_add image = tf.random_crop(image, [args.image_size, args.image_size, 3]) else: #print('else not args.random_crop') #come in fbtian_add image = tf.image.resize_image_with_crop_or_pad(image, args.image_size, args.image_size) if args.random_flip: print('args.random_flip') image = tf.image.random_flip_left_right(image) if 1 : image = tf.image.random_brightness(image, max_delta=0.2) #Random brightness transformation image = tf.image.random_contrast(image, lower=0.2, upper=1.0)#Random contrast transformation fb_count+=1 #pylint: disable=no-member# fbtian_add image.set_shape((args.image_size, args.image_size, 3)) images.append(tf.image.per_image_standardization(image)) images_and_labels.append([images, label]) print('fb_count:%d'%fb_count) image_batch, labels_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) image_batch = tf.identity(image_batch, 'input') ##fbtian batch_norm_params = { # Decay for the moving averages 'decay': 0.995, # epsilon to prevent 0s in variance 'epsilon': 0.001, # force in-place updates of mean and variance estimates 'updates_collections': None, # Moving averages ends up in the trainable variables collection 'variables_collections': [ tf.GraphKeys.TRAINABLE_VARIABLES ], # Only update statistics during training mode 'is_training': phase_train_placeholder } # Build the inference graph prelogits, _ = network.inference(image_batch, args.keep_probability, phase_train=phase_train_placeholder, weight_decay=args.weight_decay) pre_embeddings = slim.fully_connected(prelogits, args.embedding_size, activation_fn=None, weights_initializer=tf.truncated_normal_initializer(stddev=0.1), weights_regularizer=slim.l2_regularizer(args.weight_decay), normalizer_fn=slim.batch_norm, normalizer_params=batch_norm_params, scope='Bottleneck', reuse=False) embeddings = tf.nn.l2_normalize(pre_embeddings, 1, 1e-10, name='embeddings') # Split embeddings into anchor, positive and negative and calculate triplet loss anchor, positive, negative = tf.unstack(tf.reshape(embeddings, [-1,3,args.embedding_size]), 3, 1) triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha) 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) # Calculate the total losses regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables()) # Create a saver saver = tf.train.Saver(tf.trainable_variables(), 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)) config = tf.ConfigProto(allow_soft_placement=True) ########################################### gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.7)################################### config.gpu_options.allow_growth = True########################################### #sess = tf.Session(config=config)########################################### sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,intra_op_parallelism_threads=8)) # 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}) 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 acc_tmp=0 val_tmp=0 while epoch < args.max_nrof_epochs: step = sess.run(global_step, feed_dict=None) print(global_step ) epoch = step // args.epoch_size # Train for one epoch train(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file, args.embedding_size, anchor, positive, negative, triplet_loss) # 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 if args.lfw_dir: acc,val=evaluate(sess, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size, args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size) print('starting to save the maxacc and maxval ') #fbtian_max if acc>acc_tmp: #fbtian_max maxmodel_path = os.path.join(maxlin_dir, 'model-%s.ckpt_accmax'%subdir) #fbtian_max saver.save(sess, maxmodel_path, write_meta_graph=False)#fbtian_max shutil.copy( maxmodel_path+'.data-00000-of-00001', modelmax_dir) shutil.copy( maxmodel_path+'.index', modelmax_dir) acc_tmp=acc #fbtian_max if val>val_tmp: #fbtian_max maxmodel_path = os.path.join(maxlin_dir, 'model-%s.ckpt_valmax'%subdir) #fbtian_max saver.save(sess, maxmodel_path, write_meta_graph=False)#fbtian_max shutil.copy( maxmodel_path+'.data-00000-of-00001', modelmax_dir) shutil.copy( maxmodel_path+'.index', modelmax_dir) val_tmp=val #fbtian print('end to save the maxacc and maxval ') #fbtian sess.close() return model_dir
def main(args): print(args.model_def) network = importlib.import_module(args.model_def, 'inference') print(1111) 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) # Store some git revision info in a text file in the log directory src_path, _ = os.path.split(os.path.realpath(__file__)) facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) train_set = facenet.get_dataset(args.data_dir) 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)) if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths( os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 3), name='image_paths') labels_placeholder = tf.placeholder(tf.int64, shape=(None, 3), name='labels') input_queue = data_flow_ops.FIFOQueue(capacity=100000, dtypes=[tf.string, tf.int64], shapes=[(3, ), (3, )], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many( [image_paths_placeholder, labels_placeholder]) nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) image = tf.image.decode_png(file_contents) if args.random_crop: image = tf.random_crop( image, [args.image_size, args.image_size, 3]) else: image = tf.image.resize_image_with_crop_or_pad( image, args.image_size, args.image_size) 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)) images.append(tf.image.per_image_standardization(image)) images_and_labels.append([images, label]) image_batch, labels_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) # Build the inference graph prelogits, _ = network.inference( image_batch, args.keep_probability, phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, weight_decay=args.weight_decay) embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Split embeddings into anchor, positive and negative and calculate triplet loss anchor, positive, negative = tf.unstack( tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1) triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha) 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) # Calculate the total losses regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables()) # Create a saver saver = tf.train.Saver(tf.trainable_variables(), 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)) # 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}) 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 # Train for one epoch train(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file, args.embedding_size, anchor, positive, negative, triplet_loss) # 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 if args.lfw_dir: evaluate(sess, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size, args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size) sess.close() return model_dir
def main(args): align = align_dlib.AlignDlib(os.path.expanduser(args.dlib_face_predictor)) landmarkIndices = align_dlib.AlignDlib.OUTER_EYES_AND_NOSE output_dir = os.path.expanduser(args.output_dir) if not os.path.exists(output_dir): os.makedirs(output_dir) # Store some git revision info in a text file in the log directory src_path,_ = os.path.split(os.path.realpath(__file__)) facenet.store_revision_info(src_path, output_dir, ' '.join(sys.argv)) dataset = facenet.get_dataset(args.input_dir) random.shuffle(dataset) # Scale the image such that the face fills the frame when cropped to crop_size scale = float(args.face_size) / args.image_size nrof_images_total = 0 nrof_prealigned_images = 0 nrof_successfully_aligned = 0 for cls in dataset: output_class_dir = os.path.join(output_dir, cls.name) if not os.path.exists(output_class_dir): os.makedirs(output_class_dir) random.shuffle(cls.image_paths) for image_path in cls.image_paths: nrof_images_total += 1 filename = os.path.splitext(os.path.split(image_path)[1])[0] output_filename = os.path.join(output_class_dir, filename+'.png') if not os.path.exists(output_filename): try: img = misc.imread(image_path) except (IOError, ValueError, IndexError) as e: errorMessage = '{}: {}'.format(image_path, e) print(errorMessage) else: if img.ndim == 2: img = facenet.to_rgb(img) if args.use_center_crop: scaled = misc.imresize(img, args.prealigned_scale, interp='bilinear') sz1 = scaled.shape[1]/2 sz2 = args.image_size/2 aligned = scaled[int(sz1-sz2):int(sz1+sz2),int(sz1-sz2):int(sz1+sz2),:] else: aligned = align.align(args.image_size, img, landmarkIndices=landmarkIndices, skipMulti=False, scale=scale) if aligned is not None: print(image_path) nrof_successfully_aligned += 1 misc.imsave(output_filename, aligned) elif args.prealigned_dir: # Face detection failed. Use center crop from pre-aligned dataset class_name = os.path.split(output_class_dir)[1] image_path_without_ext = os.path.join(os.path.expanduser(args.prealigned_dir), class_name, filename) # Find the extension of the image exts = ('jpg', 'png') for ext in exts: temp_path = image_path_without_ext + '.' + ext image_path = '' if os.path.exists(temp_path): image_path = temp_path break try: img = misc.imread(image_path) except (IOError, ValueError, IndexError) as e: errorMessage = '{}: {}'.format(image_path, e) print(errorMessage) else: scaled = misc.imresize(img, args.prealigned_scale, interp='bilinear') sz1 = scaled.shape[1]/2 sz2 = args.image_size/2 cropped = scaled[(sz1-sz2):(sz1+sz2),(sz1-sz2):(sz1+sz2),:] print(image_path) nrof_prealigned_images += 1 misc.imsave(output_filename, cropped) else: print('Unable to align "%s"' % image_path) print('Total number of images: %d' % nrof_images_total) print('Number of successfully aligned images: %d' % nrof_successfully_aligned) print('Number of pre-aligned images: %d' % nrof_prealigned_images)
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(seed=args["seed"]) if args["use_split_dataset"]: dataset_tmp = facenet.get_dataset(args["data_dir"]) train_set, test_set = split_dataset( dataset_tmp, args["min_nrof_images_per_class"], args["nrof_train_images_per_class"]) if (args["mode"] == 'TRAIN'): dataset = train_set elif (args["mode"] == 'CLASSIFY'): dataset = test_set else: dataset = facenet.get_dataset(args["data_dir"]) # Check that there are at least one training image per class for cls in dataset: assert(len(cls.image_paths) > 0, 'There must be at least one image for each class in the dataset') paths, labels = facenet.get_image_paths_and_labels(dataset) print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) # Load the model print('Loading feature extraction model') facenet.load_model(args["model"]) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] # Run forward pass to calculate embeddings print('Calculating features for images') nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0*nrof_images / args["batch_size"])) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): start_index = i*args["batch_size"] end_index = min((i+1)*args["batch_size"], nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data( paths_batch, False, False, args["image_size"]) feed_dict = {images_placeholder: images, phase_train_placeholder: False} emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) classifier_filename_exp = os.path.expanduser( args["classifier_filename"]) if (args["mode"] == 'TRAIN'): # Train classifier print('Training classifier') model = SVC(kernel='linear', probability=True) model.fit(emb_array, labels) # Create a list of class names class_names = [cls.name.replace('_', ' ') for cls in dataset] # Saving classifier model with open(classifier_filename_exp, 'wb') as outfile: pickle.dump((model, class_names), outfile) print('Saved classifier model to file "%s"' % classifier_filename_exp) elif (args["mode"] == 'CLASSIFY'): # Classify images print('Testing classifier') with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) print('Loaded classifier model from file "%s"' % classifier_filename_exp) predictions = model.predict_proba(emb_array) best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[np.arange( len(best_class_indices)), best_class_indices] for i in range(len(best_class_indices)): print('%4d %s: %.3f' % ( i, class_names[best_class_indices[i]], best_class_probabilities[i])) accuracy = np.mean(np.equal(best_class_indices, labels)) print('Accuracy: %.3f' % accuracy)
def main(args): network = importlib.import_module(args.model_def) image_size = (args.image_size, args.image_size) subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') # 用当前时间作为文件夹名称 log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir) # log保存路径 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) stat_file_name = os.path.join(log_dir, 'stat.h5') # Write arguments to a text file 这个文件保存一些训练时候用到的超参数信息 facenet.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__)) facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) random.seed(args.seed) dataset = facenet.get_dataset(args.data_dir) # 训练数据路径 if args.filter_filename: dataset = filter_dataset(dataset, os.path.expanduser(args.filter_filename), args.filter_percentile, args.filter_min_nrof_images_per_class) # 数据集划分为训练集和验证集 if args.validation_set_split_ratio > 0.0: train_set, val_set = facenet.split_dataset( dataset, args.validation_set_split_ratio, args.min_nrof_val_images_per_class, 'SPLIT_IMAGES') else: train_set, val_set = dataset, [] # 分类的数量,即训练集中的文件夹数量 nrof_classes = len(train_set) print('Model directory: %s' % model_dir) print('Log directory: %s' % log_dir) pretrained_model = None # 预训练模型 if args.pretrained_model: pretrained_model = os.path.expanduser(args.pretrained_model) print('Pre-trained model: %s' % pretrained_model) # 测试用的lfw数据的路径 if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths( os.path.expanduser(args.lfw_dir), pairs) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # Get a list of image paths and their labels # 获取训练图像路径和对应的标签 image_list, label_list = facenet.get_image_paths_and_labels(train_set) assert len(image_list) > 0, 'The training set should not be empty' # 用于验证的图像的路径和对应的标签 val_image_list, val_label_list = facenet.get_image_paths_and_labels( val_set) # Create a queue that produces indices into the image_list and label_list labels = ops.convert_to_tensor(label_list, dtype=tf.int32) range_size = array_ops.shape(labels)[0] index_queue = tf.train.range_input_producer(range_size, num_epochs=None, shuffle=True, seed=None, capacity=32) index_dequeue_op = index_queue.dequeue_many( args.batch_size * args.epoch_size, 'index_dequeue') learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 1), name='image_paths') labels_placeholder = tf.placeholder(tf.int32, shape=(None, 1), name='labels') control_placeholder = tf.placeholder(tf.int32, shape=(None, 1), name='control') nrof_preprocess_threads = 4 # 先入先出队列 input_queue = data_flow_ops.FIFOQueue( capacity=2000000, dtypes=[tf.string, tf.int32, tf.int32], shapes=[(1, ), (1, ), (1, )], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many( [image_paths_placeholder, labels_placeholder, control_placeholder], name='enqueue_op') image_batch, label_batch = facenet.create_input_pipeline( input_queue, image_size, nrof_preprocess_threads, batch_size_placeholder) image_batch = tf.identity(image_batch, 'image_batch') image_batch = tf.identity(image_batch, 'input') label_batch = tf.identity(label_batch, 'label_batch') print('Number of classes in training set: %d' % nrof_classes) print('Number of examples in training set: %d' % len(image_list)) print('Number of classes in validation set: %d' % len(val_set)) print('Number of examples in validation set: %d' % len(val_image_list)) print('Building training graph') # Build the inference graph prelogits, _ = network.inference( image_batch, args.keep_probability, phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, weight_decay=args.weight_decay) logits = slim.fully_connected( prelogits, len(train_set), activation_fn=None, weights_initializer=slim.initializers.xavier_initializer(), weights_regularizer=slim.l2_regularizer(args.weight_decay), scope='Logits', reuse=False) # 标准化 embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Norm for the prelogits eps = 1e-4 prelogits_norm = tf.reduce_mean( tf.norm(tf.abs(prelogits) + eps, ord=args.prelogits_norm_p, axis=1)) tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_norm * args.prelogits_norm_loss_factor) # Add center loss prelogits_center_loss, _ = facenet.center_loss(prelogits, label_batch, args.center_loss_alfa, nrof_classes) tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_center_loss * args.center_loss_factor) 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) # Calculate the average cross entropy loss across the batch cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=label_batch, logits=logits, name='cross_entropy_per_example') cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy') tf.add_to_collection('losses', cross_entropy_mean) correct_prediction = tf.cast( tf.equal(tf.argmax(logits, 1), tf.cast(label_batch, tf.int64)), tf.float32) accuracy = tf.reduce_mean(correct_prediction) # Calculate the total losses regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables(), args.log_histograms) # Create a saver saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=1, save_relative_paths=True) # 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, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_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 pretrained_model: # print('Restoring pretrained model: %s' % pretrained_model) # saver.restore(sess, tf.train.latest_checkpoint(pretrained_model)) if args.pretrained_model: print('Restoring pretrained model: %s' % args.pretrained_model) ckpt = tf.train.get_checkpoint_state(args.pretrained_model) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) # Training and validation loop print('Running training') nrof_steps = args.max_nrof_epochs * args.epoch_size nrof_val_samples = int( math.ceil(args.max_nrof_epochs / args.validate_every_n_epochs) ) # Validate every validate_every_n_epochs as well as in the last epoch stat = { 'loss': np.zeros((nrof_steps, ), np.float32), 'center_loss': np.zeros((nrof_steps, ), np.float32), 'reg_loss': np.zeros((nrof_steps, ), np.float32), 'xent_loss': np.zeros((nrof_steps, ), np.float32), 'prelogits_norm': np.zeros((nrof_steps, ), np.float32), 'accuracy': np.zeros((nrof_steps, ), np.float32), 'val_loss': np.zeros((nrof_val_samples, ), np.float32), 'val_xent_loss': np.zeros((nrof_val_samples, ), np.float32), 'val_accuracy': np.zeros((nrof_val_samples, ), np.float32), 'lfw_accuracy': np.zeros((args.max_nrof_epochs, ), np.float32), 'lfw_valrate': np.zeros((args.max_nrof_epochs, ), np.float32), 'learning_rate': np.zeros((args.max_nrof_epochs, ), np.float32), 'time_train': np.zeros((args.max_nrof_epochs, ), np.float32), 'time_validate': np.zeros((args.max_nrof_epochs, ), np.float32), 'time_evaluate': np.zeros((args.max_nrof_epochs, ), np.float32), 'prelogits_hist': np.zeros((args.max_nrof_epochs, 1000), np.float32), } for epoch in range(1, args.max_nrof_epochs + 1): step = sess.run(global_step, feed_dict=None) # Train for one epoch t = time.time() cont = train( args, sess, epoch, image_list, label_list, index_dequeue_op, enqueue_op, image_paths_placeholder, labels_placeholder, learning_rate_placeholder, phase_train_placeholder, batch_size_placeholder, control_placeholder, global_step, total_loss, train_op, summary_op, summary_writer, regularization_losses, args.learning_rate_schedule_file, stat, cross_entropy_mean, accuracy, learning_rate, prelogits, prelogits_center_loss, args.random_rotate, args.random_crop, args.random_flip, prelogits_norm, args.prelogits_hist_max, args.use_fixed_image_standardization) stat['time_train'][epoch - 1] = time.time() - t if not cont: break t = time.time() if len(val_image_list) > 0 and ( (epoch - 1) % args.validate_every_n_epochs == args.validate_every_n_epochs - 1 or epoch == args.max_nrof_epochs): validate(args, sess, epoch, val_image_list, val_label_list, enqueue_op, image_paths_placeholder, labels_placeholder, control_placeholder, phase_train_placeholder, batch_size_placeholder, stat, total_loss, regularization_losses, cross_entropy_mean, accuracy, args.validate_every_n_epochs, args.use_fixed_image_standardization) stat['time_validate'][epoch - 1] = time.time() - t # Save variables and the metagraph if it doesn't exist already save_variables_and_metagraph(sess, saver, summary_writer, model_dir, subdir, epoch) # Evaluate on LFW t = time.time() if args.lfw_dir: evaluate(sess, enqueue_op, image_paths_placeholder, labels_placeholder, phase_train_placeholder, batch_size_placeholder, control_placeholder, embeddings, label_batch, lfw_paths, actual_issame, args.lfw_batch_size, args.lfw_nrof_folds, log_dir, step, summary_writer, stat, epoch, args.lfw_distance_metric, args.lfw_subtract_mean, args.lfw_use_flipped_images, args.use_fixed_image_standardization) stat['time_evaluate'][epoch - 1] = time.time() - t print('Saving statistics') with h5py.File(stat_file_name, 'w') as f: for key, value in stat.items(): f.create_dataset(key, data=value) return model_dir
def do_POST(self): #stamp = time.time() if self.headers['content-type'] == 'application/json': global images_placeholder global embeddings global phase_train_placeholder global embedding_size global svm_model global class_names global schools global model length = int(self.headers['content-length']) request = json.loads(self.rfile.read(length)) if request['request'] == 'Compare': request['face'][0] = BytesIO( base64.b64decode(request['face'][0])) request['face'][1] = BytesIO( base64.b64decode(request['face'][1])) print('!!!!!!:', request['face'][0], request['face'][1]) img1 = misc.imread(request['face'][0], mode='RGB') img2 = misc.imread(request['face'][1], mode='RGB') img1, box1, _ = cut_face(img1) img2, box2, _ = cut_face(img2) if len(img1) > 1 or len(img2) > 1: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'description': 'There are more than one face in an image' }).encode()) img1 = img1[0] img2 = img2[0] f1 = model.get_feature(img1) f2 = model.get_feature(img2) dist = np.sum(np.square(f1 - f2)) # sim = np.dot(f1, f2.T) # print('dist,sim',dist,sim) sim = get_sim(dist) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'similarity': str(sim), 'description': '' }).encode()) elif request['request'] == 'AddFace': pic = BytesIO(base64.b64decode(request['face'])) img = misc.imread(pic, mode='RGB') images, box, bgr = cut_face(img) if len(images) == 1: person_path = os.path.join(args.images_dir, request['SchoolId'], request['PersonId']) if not os.path.exists(person_path): os.makedirs(person_path) files = os.listdir(person_path) pic_name = request['PersonId'] + str(len(files) + 1) + '.png' pic_path = os.path.join(person_path, pic_name) cv2.imwrite(pic_path, bgr[0]) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'FileId': os.path.basename(pic_path), 'description': '' }).encode()) elif len(images) == 0: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'FileId': '', 'description': 'no face detected' }).encode()) return else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'FileId': '', 'description': 'more than one face detected' }).encode()) return elif request['request'] == 'DelFace': response = 'ok' school_path = os.path.join(args.images_dir, request['SchoolId']) if os.path.isdir(school_path): for person in request['PersonId']: person_path = os.path.join(school_path, person[0]) if os.path.isdir(person_path): if person[1] == '*': for file_name in os.listdir(person_path): os.remove( os.path.join(person_path, file_name)) os.rmdir(person_path) else: for i in range(1, len(person)): file_path = os.path.join( person_path, person[i]) if os.path.isfile(file_path): os.remove(file_path) else: response = 'error' else: response = 'error' else: response = 'error' if response == 'ok': self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': response, 'description': '' }).encode()) else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'description': 'some or all deletion failed' }).encode()) elif request['request'] == 'GetFaceList': if request['SchoolId'] == '*': self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'list': os.listdir(args.images_dir), 'description': '' }).encode()) elif request['PersonId'] == '*': path = os.path.join(args.images_dir, request['SchoolId']) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'list': os.listdir(path), 'description': '' }).encode()) elif request['FileId'] == '*': path = os.path.join(args.images_dir, request['SchoolId'], request['PersonId']) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'list': os.listdir(path), 'description': '' }).encode()) else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'list': {}, 'description': 'no such file' }).encode()) elif request['request'] == 'GetFaceImage': path = os.path.join(args.images_dir, request['SchoolId'], request['PersonId'], request['FileId']) if os.path.isfile(path): with open(path, 'rb') as f: image = str(base64.b64encode(f.read())) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'face': image, 'description': '' }).encode()) else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'face': '', 'description': 'no such file' }).encode()) elif request['request'] == 'Train': path = os.path.join(args.images_dir, request['SchoolId']) if os.path.isdir(path): dataset = facenet.get_dataset(path) if len(dataset) < 2: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'description': 'number of person less than 2' }).encode()) return for cls in dataset: assert len( cls.image_paths ) > 0 #'There must be at least one image for each class in the dataset' paths, labels = facenet.get_image_paths_and_labels(dataset) print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) print('Calculating features for images') emb_array = [] num_of_images = len(paths) ind = 0 for path in paths: # print("path of img " , path) img_tem = misc.imread(path) img, box, _ = cut_face(img_tem) # print("path of img " , len(img)) if len(img) < 1 or len(img) > 1: lbl = labels.pop(ind) continue else: ind += 1 img = img[0] img_emb = model.get_feature(img) emb_array.append(img_emb) # print('lenth of emb_array' , len(emb_array)) # print('lenth of emb_array' , len(emb_array) , ' length of labels' , len(labels)) emb_arrar = np.array(emb_array) print('Training classifier') # new_svm_model = SVC(kernel='linear', probability=False) # print(cpu_count()) SGDmodel = SGDClassifier(loss="log", max_iter=100, penalty="l2", n_jobs=cpu_count() - 1, shuffle=True) SGDmodel.fit(emb_array, labels) new_emb = [] lastidx = -1 # Create a list of class names new_class_names = [cls.name for cls in dataset] for i in range(len(labels)): if labels[i] == lastidx: new_emb[lastidx].append(emb_array[i]) else: new_emb.append([emb_array[i]]) lastidx = labels[i] #print(emb_array[0:5] , new_emb[0:5]) svm_model_path = '{}/{}.pkl'.format( args.classifier_dir, request['SchoolId']) # Saving classifier model with open(svm_model_path, 'wb') as outfile: pickle.dump((SGDmodel, new_class_names, new_emb), outfile, protocol=2) print('Saved classifier to file ', svm_model_path) schools[request['SchoolId']] = school() schools[request['SchoolId']].svm_model = SGDmodel schools[request['SchoolId']].class_names = new_class_names schools[request['SchoolId']].emb = new_emb self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'description': '' }).encode()) else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'description': 'no such school' }).encode()) elif request['request'] == 'Predict': if request['SchoolId'] in schools.keys(): request['face'] = BytesIO(base64.b64decode( request['face'])) img1 = misc.imread(request['face'], mode='RGB') images, boxes, _ = cut_face(img1) if len(boxes) == 0: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'predict': [], 'boxes': [], 'description': 'no face detected' }).encode()) return emb = [] for image in images: emb.append(model.get_feature(image)) emb = np.array(emb) predict = [] path = os.path.join(args.images_dir, request['SchoolId']) num_of_people = len(os.listdir(path)) predictions = schools[ request['SchoolId']].svm_model.predict_proba(emb) predict_index = np.argmax(predictions, axis=1) best_class_indices = [] best_class_probabilities = [] count = min(num_of_people, 1) for i in range(count): tmp_best_class_indices = np.argmax(predictions, axis=1) tmp_best_class_probabilities = predictions[ np.arange(len(tmp_best_class_indices)), tmp_best_class_indices] best_class_indices.append(tmp_best_class_indices) best_class_probabilities.append( tmp_best_class_probabilities) predictions[np.arange(len(tmp_best_class_indices)), tmp_best_class_indices] = 0 for i in range(len(best_class_indices[0])): print('%4d' % i) for j in range(len(best_class_indices)): print('j:', j) print('%s: %.3f' % (schools[request['SchoolId']].class_names[ best_class_indices[j][i]], best_class_probabilities[j][i])) print('best_class_indices[0]:', best_class_indices[0]) similarity = [] for i in range(len(best_class_indices)): tmp = best_class_indices[i] tmp_sim = [] for j in range(len(tmp)): dist = 0 for k in range( len(schools[request['SchoolId']].emb[ tmp[j]])): dist += np.sum( np.square( np.subtract( emb[j], schools[request['SchoolId']].emb[ tmp[j]][k]))) dist /= len( schools[request['SchoolId']].emb[tmp[j]]) tmp_sim.append(get_sim(dist)) similarity.append(tmp_sim) print('best_class_indices[0]:', best_class_indices[0]) for i in range(len(predict_index)): dist = 0 for j in range( len(schools[request['SchoolId']].emb[ predict_index[i]])): dist += np.sum( np.square( np.subtract( emb[i], schools[request['SchoolId']].emb[ predict_index[i]][j]))) dist /= len( schools[request['SchoolId']].emb[predict_index[i]]) if dist > args.same_person_threshold: predict.append('stranger') else: #tmp = [] for k in range(len(best_class_indices)): # print("?????\n\n\n") # print(len(best_class_indices)) predict.append([ schools[request['SchoolId']].class_names[ best_class_indices[k][i]], similarity[k][i] ]) #predict.append(tmp) print('predict', predict) self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'ok', 'predict': predict, 'boxes': boxes, 'description': '' }).encode()) else: self.send_response(400) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write( json.dumps({ 'response': 'error', 'predict': [], 'boxes': [], 'description': 'no such school' }).encode()) else: self.send_error(404, 'Not a correct json: %s' % self.path)
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 facenet.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__)) # facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv)) np.random.seed(seed=args.seed) # Fetch dataets # VGGface2 print('Fetch VGGface2 as source dataset at {}'.format( args.vggface2_train_dir)) src_train_set = facenet.get_dataset(args.vggface2_train_dir) # validation_set = facenet.get_dataset(args.vggface2_val_dir) # COX S2V print('Fetch COX-S2V as target dataset at {}'.format(args.cox_video_dir)) cox_dataset = cox.cox_data(args.cox_still_dir, args.cox_video_dir, args.cox_pairs) train_folds = [0, 1, 2] evaluation_folds = [3, 4, 5, 6, 7, 8, 9] # cox_train_list = cox_dataset.get_dataset(train_folds) # cox_val_list = list(itertools.chain.from_iterable(fold_list[3:10])) tgt_train_set = cox_dataset.get_dataset(train_folds, video_only=True) # tgt_val_set = cox.get_video_dataset(args.cox_video_dir, cox_val_list) cox_paths, cox_issame = cox_dataset.get_pairs(evaluation_folds) 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)) if args.lfw_dir: print('LFW directory: %s' % args.lfw_dir) # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images lfw_paths, actual_issame = lfw.get_paths( os.path.expanduser(args.lfw_dir), pairs) # Get the paths for embeddings projection # Get the paths for embeddings projection lfw_proj_paths, lfw_proj_labels = lfw.get_paths_from_file( args.lfw_dir, args.lfw_projection) cox_proj_paths, cox_proj_labels = cox_dataset.get_paths_from_file( args.cox_projection) # Combine projection paths projection_paths = lfw_proj_paths + cox_proj_paths proj_labels = lfw_proj_labels + cox_proj_labels # Create label map if does not exist metadata_filename = 'meta.tsv' emb_dir = os.path.join(os.path.expanduser(log_dir), 'emb') if not os.path.isdir( emb_dir): # Create the log directory if it doesn't exist os.makedirs(emb_dir) with open(os.path.join(emb_dir, metadata_filename), "w") as meta_file: csvWriter = csv.writer(meta_file, delimiter='\t') csvWriter.writerows(np.array([proj_labels]).T) with tf.Graph().as_default(): tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) # Placeholder for the learning rate learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate') batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 4), name='image_paths') labels_placeholder = tf.placeholder(tf.int64, shape=(None, 4), name='labels') input_queue = data_flow_ops.FIFOQueue(capacity=100000, dtypes=[tf.string, tf.int64], shapes=[(4, ), (4, )], shared_name=None, name=None) enqueue_op = input_queue.enqueue_many( [image_paths_placeholder, labels_placeholder]) nrof_preprocess_threads = 4 images_and_labels = [] for _ in range(nrof_preprocess_threads): filenames, label = input_queue.dequeue() images = [] for filename in tf.unstack(filenames): file_contents = tf.read_file(filename) image = tf.image.decode_image(file_contents, channels=3) if args.random_crop: image = tf.random_crop( image, [args.image_size, args.image_size, 3]) else: image = tf.image.resize_image_with_crop_or_pad( image, args.image_size, args.image_size) 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)) images.append(tf.image.per_image_standardization(image)) images_and_labels.append([images, label]) image_batch, labels_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size_placeholder, shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True, capacity=4 * nrof_preprocess_threads * args.batch_size, allow_smaller_final_batch=True) image_batch = tf.identity(image_batch, 'image_batch') image_batch = tf.identity(image_batch, 'input') labels_batch = tf.identity(labels_batch, 'label_batch') # Build the inference graph prelogits, _ = network.inference( image_batch, args.keep_probability, phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size, weight_decay=args.weight_decay) embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Split embeddings into anchor, positive and negative and calculate triplet loss anchor, positive, negative, target = tf.unstack( tf.reshape(embeddings, [-1, 4, args.embedding_size]), 4, 1) loss, adv_loss, triplet_loss = adversarialloss.quadruplets_loss( anchor, positive, negative, target, args.alpha, args.lamb, args.zeta) # triplet_loss = tripletloss.triplet_loss(anchor, positive, negative, args.alpha) # adv_loss = adversarialloss.adversarial_loss(anchor, target, args.alpha) 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) # Calculate the total losses regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([loss] + regularization_losses, name='total_loss') reg_loss = tf.add_n(regularization_losses, name='total_loss') # Build a Graph that trains the model with one batch of examples and updates the model parameters train_op = facenet.train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables()) # Create a saver saver = tf.train.Saver(tf.trainable_variables(), 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)) # 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}) 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 # save_embeddings(sess, projection_paths, epoch, embeddings, labels_batch, image_paths_placeholder, # labels_placeholder, # batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, # args.batch_size, emb_dir, args.embedding_size, tag='lfw') # # # Evaluate on COX # evaluate(sess, cox_paths, embeddings, labels_batch, image_paths_placeholder, # labels_placeholder, # batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, # enqueue_op, # cox_issame, args.batch_size, # args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size, # tag='cox') # # if args.lfw_dir: # evaluate(sess, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder, # batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size, # args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size) # Train for one epoch train(args, sess, src_train_set, tgt_train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch, batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings, total_loss, triplet_loss, adv_loss, reg_loss, train_op, summary_writer, args.learning_rate_schedule_file, args.embedding_size) # 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): train_set = facenet.get_dataset(args.data_dir) image_list, label_list = facenet.get_image_paths_and_labels(train_set) # fetch the classes (labels as strings) exactly as it's done in get_dataset path_exp = os.path.expanduser(args.data_dir) classes = [path for path in os.listdir(path_exp) \ if os.path.isdir(os.path.join(path_exp, path))] classes.sort() # get the label strings label_strings = [name for name in classes if \ os.path.isdir(os.path.join(path_exp, name))] with tf.Graph().as_default(): with tf.Session() as sess: # Load the model facenet.load_model(args.model_dir) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") # Run forward pass to calculate embeddings nrof_images = len(image_list) print('Number of images: ', nrof_images) batch_size = args.image_batch if nrof_images % batch_size == 0: nrof_batches = nrof_images // batch_size else: nrof_batches = (nrof_images // batch_size) + 1 print('Number of batches: ', nrof_batches) embedding_size = embeddings.get_shape()[1] emb_array = np.zeros((nrof_images, embedding_size)) start_time = time.time() for i in range(nrof_batches): if i == nrof_batches - 1: n = nrof_images else: n = i * batch_size + batch_size # Get images for the batch if args.is_aligned is True: images = facenet.load_data(image_list[i * batch_size:n], False, False, args.image_size) else: images = load_and_align_data(image_list[i * batch_size:n], args.image_size, args.margin, args.gpu_memory_fraction) feed_dict = { images_placeholder: images, phase_train_placeholder: False } # Use the facenet model to calcualte embeddings embed = sess.run(embeddings, feed_dict=feed_dict) emb_array[i * batch_size:n, :] = embed print('Completed batch', i + 1, 'of', nrof_batches) run_time = time.time() - start_time print('Run time: ', run_time) # export emedings and labels label_list = np.array(label_list) np.save(args.embeddings_name, emb_array) np.save(args.labels_name, label_list) label_strings = np.array(label_strings) np.save(args.labels_strings_name, label_strings[label_list])