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(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 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)
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)
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):
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):
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)
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)
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(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
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])
