import utils.facenet as facenet
import utils.detect_face as detect_face
import random
from time import sleep
# Set allow_pickle=True
np_load_old = np.load
np.load = lambda *a, **k: np_load_old(*a, allow_pickle=True, **k)
output_dir_path = './aligned_img_db/'
output_dir = os.path.expanduser(output_dir_path)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
datadir = './img_db/'
dataset = facenet.get_dataset(datadir)
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, './npy')
# Config variables
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
image_size = 182
def main():
args = parse_args()
align_command = 'python align_dataset_mtcnn.py ' + args.input_dir + args.align_dir + ' --image_size 182' + ' --margin 44'
os.system(align_command)
print("-------- Alignment Completed ----------")
with tf.Graph().as_default():
with tf.Session() as sess:
np.random.seed(666)
datadir = args.align_dir
embeddingdir = "data/new_person_embedding/"
modeldir = args.model_path
dataset = facenet.get_dataset(datadir)
paths, labels = facenet.get_image_paths_and_labels(dataset)
print(labels)
# # Create a list of class names
#class_names = [cls.name.replace('_', ' ') for cls in dataset]
#label_name = [class_names[i] for i in labels]
print('Number of classes: {}'.format(len(dataset)))
print('Number of images: {}'.format(len(paths)))
print('Loading feature extraction model')
facenet.load_model(modeldir)
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]
print(embedding_size)
# Run forward pass to calculate embeddings
print('Calculating features for images')
batch_size = 200
image_size = 160
nrof_images = len(paths)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches_per_epoch):
print('{}/{}'.format(i, nrof_batches_per_epoch))
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
# store embedding and labels
np.savetxt(embeddingdir + 'embedding.csv',
emb_array,
delimiter=",")
with open(embeddingdir + 'label.csv', 'w') as f:
writer = csv.writer(f)
writer.writerows(zip(labels, paths))
# merge 2 embedding files
merge_embedding_files("data/embedding/", embeddingdir,
"embedding.csv")
merge_label_files("data/embedding/", embeddingdir, "label.csv")
# re-train the classifier
start = time.time()
fname = "data/embedding/label.csv"
labels = pd.read_csv(fname, header=None).as_matrix()[:, 1]
labels = map(itemgetter(1),
map(os.path.split, map(os.path.dirname,
labels))) # Get the directory.
print(labels)
print('list labels')
labels = list(labels)
print(labels)
fname = "data/embedding/embedding.csv"
embeddings = pd.read_csv(fname, header=None).as_matrix()
le = LabelEncoder().fit(labels)
class_names = list(le.classes_)
class_names = [i.replace("_", " ") for i in class_names]
labelsNum = le.transform(labels)
#print(labelsNum)
print(class_names)
print(labelsNum)
classifier_filename_exp = os.path.expanduser(
args.classifier_filename)
print('Start training classifier')
if (args.classifier == 'SVM'):
model = SVC(kernel='linear', probability=True)
elif (args.classifier == 'KNN'):
model = KNeighborsClassifier(n_neighbors=1)
elif (args.classifier == 'LinearSVC'):
model = LinearSVC(random_state=0, tol=1e-5)
else:
model = RandomForestClassifier(n_estimators=2000,
max_depth=100,
max_features='sqrt',
n_jobs=-1)
model.fit(embeddings, labelsNum)
print(
"Re-train the classifier took {} seconds.".format(time.time() -
start))
print('End training classifier')
print(le)
# 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)
print('Goodluck')
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(allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
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 = parse_args()
with tf.Graph().as_default():
with tf.Session() as sess:
np.random.seed(666)
datadir = args.align_dir
modeldir = args.model_path
dataset = facenet.get_dataset(datadir)
#f_map = "data/embedding/maps.csv"
paths, labels = facenet.get_image_paths_and_labels(dataset)
label1 = []
for i in paths:
person_name = i.split('/')[-2]
label1.append(person_name)
#map_test = pd.read_csv(f_map, header=None)
#labelnum = []
#for i in label1:
#ID = int(map_test.loc[map_test[1]==i, 0].values)
#labelnum.append(ID)
label1 = [i.replace("_", " ") for i in label1]
print('Number of classes: {}'.format(len(dataset)))
print('Number of images: {}'.format(len(paths)))
print('Loading feature extraction model')
facenet.load_model(modeldir)
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')
batch_size = 200
image_size = 160
nrof_images = len(paths)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches_per_epoch):
print('{}/{}'.format(i, nrof_batches_per_epoch))
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
print('Testing classifier')
classifier_filename_exp = os.path.expanduser(
args.classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
labelnum = []
for i in label1:
num = class_names.index(i)
labelnum.append(num)
print('Loaded classifier model from file "%s"' %
classifier_filename_exp)
print(class_names)
predictions = model.predict(emb_array)
print(predictions)
best_class_indices = predictions
#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]))
print(best_class_indices)
print('labelnum')
print(labelnum)
report = precision_recall_fscore_support(labelnum,
best_class_indices,
average='weighted')
print(report[2])
def main(args):
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_idx
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)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
model_good_dir = os.path.join(os.path.expanduser(args.models_good_dir), subdir)
if not os.path.isdir(log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
if not os.path.isdir(model_good_dir): # Create the model directory if it doesn't exist
os.makedirs(model_good_dir)
# Write arguments to a text file
facenet.write_arguments_to_file(
args, os.path.join(log_dir, 'arguments.txt'))
np.random.seed(seed=args.seed)
random.seed(args.seed)
train_set = facenet.get_dataset(args.data_dir)
if args.increased_data_dir:
increased_set = facenet.get_dataset(args.increased_data_dir)
train_set += increased_set
if args.filter_filename:
nrof_classes_before_filter = len(train_set)
train_set = filter_dataset(train_set, os.path.expanduser(args.filter_filename),
args.filter_percentile, args.filter_min_nrof_images_per_class)
print(str(len(train_set) - nrof_classes_before_filter)+" classes filtered")
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)
train_graph = tf.Graph()
with train_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=150000,
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, channels=3)
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)
if args.random_brightness:
image = tf.image.random_brightness(image, max_delta=0.5)
if args.random_contrast:
image = tf.image.random_contrast(image, 0.8, 1.2)
if args.random_saturation:
image = tf.image.random_saturation(image, 0.3, 0.5)
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')
image_max = tf.reduce_max(image_batch, name='image_max') #统计最大值
image_min = tf.reduce_min(image_batch, name='image_min') #统计最小值
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
# for inception_v3
# Note that is_training be set to True or False, not be placeholder.
prelogits, _ = network.inference(image_batch,
num_classes=None,
is_training=True,
dropout_keep_prob=args.keep_probability,
bottleneck_layer_size=args.embedding_size)
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)
# print("regularization_losses:"+str(regularization_losses))
total_loss = tf.add_n([cross_entropy_mean] +
regularization_losses, name='total_loss')
# for fake quantized train, add quantized nodes automatically.
train_graph = tf.get_default_graph()
tf.contrib.quantize.create_training_graph(input_graph=train_graph, quant_delay=0)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = facenet.train(total_loss, global_step, args.optimizer,
learning_rate, args.moving_average_decay, tf.global_variables(),
args.log_histograms, args.train_mode)
# print all vars
g_vars = tf.global_variables()
print("++++++++++++++++++++")
for g in g_vars:
print(g.name)
print("++++++++++++++++++++")
if pretrained_model:
# 指定加载某些变量的权重
all_vars = tf.trainable_variables()
#all_vars = tf.global_variables()
# 跳过加载某些层的权重
var_to_skip = [v for v in all_vars if v.name.startswith('Logits') or v.name.startswith('centers')]
print("got pretrained_mode, var_to_skip:\n" + " \n".join([x.name for x in var_to_skip]))
var_to_restore = [v for v in all_vars if not (v.name.startswith('Logits') or v.name.startswith('centers'))]
"""
g_list = tf.global_variables()
#bn_moving_vars = [g for g in g_list if "moving_mean" in g.name]
#bn_moving_vars += [g for g in g_list if "moving_variance" in g.name]
#act_quant_vars = [g for g in g_list if "act_quant" in g.name]
#var_to_restore += act_quant_vars
"""
saver = tf.train.Saver(all_vars, max_to_keep=20)
else:
var_list = tf.trainable_variables()
#var_list = tf.global_variables()
"""
g_list = tf.global_variables()
bn_moving_vars = [g for g in g_list if "moving_mean" in g.name]
bn_moving_vars += [g for g in g_list if "moving_variance" in g.name]
print("++++++++++++++++++++")
for g in bn_moving_vars:
print(g.name)
print("++++++++++++++++++++")
var_list += bn_moving_vars
"""
saver = tf.train.Saver(var_list, max_to_keep=20)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
train_global_init = tf.global_variables_initializer()
train_local_init = tf.local_variables_initializer()
# 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(train_global_init)
sess.run(train_local_init)
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)
"""
if args.lfw_dir:
print('evaluate on lfw with pretrained model: %s' %
pretrained_model)
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, 0, summary_writer)
"""
#tf.train.write_graph(sess.graph_def, model_dir, 'inception_v3_fake_quantized_train.pbtxt')
saver1 = tf.train.Saver(tf.global_variables(), max_to_keep=20)
# Training and validation loop
print('Running training')
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
print("step:", step)
epoch = step // args.epoch_size
#import ipdb; ipdb.set_trace()
# 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, image_max, image_min)
# Save variables and the metagraph if it doesn't exist already
ckpt_model = save_variables_and_metagraph(sess, saver1, summary_writer, model_dir, subdir, step)
print("ckpt_model name:", ckpt_model)
"""
if args.lfw_dir:
acc_dot = 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)
if acc_dot > 0.97:
print("get a good model,save it!!!,step:%d,acc_dot:%.3f" %(step, acc_dot))
ckpt_model = save_variables_and_metagraph(sess, saver1, summary_writer, model_good_dir, subdir, step)
"""
return model_dir
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
np.random.seed(seed=args.seed)
embeddingdir = "data/embedding/"
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)
# Create a new label list containing names instead of numbers
class_names = [cls.name.replace('_', ' ') for cls in dataset]
label_name = [class_names[i] for i in labels]
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]
print(embedding_size)
# 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)
# Store embedding and labels
np.savetxt(embeddingdir + 'embedding.csv',
emb_array,
delimiter=",")
with open(embeddingdir + 'label.csv', 'w') as f:
writer = csv.writer(f)
writer.writerows(zip(labels, paths))
classifier_filename_exp = os.path.expanduser(
args.classifier_filename)
if (args.mode == 'TRAIN'):
# Train classifier
print('Training classifier')
if (args.classifier == 'SVM'):
model = SVC(kernel='linear', probability=True)
elif (args.classifier == 'KNN'):
model = KNeighborsClassifier(n_neighbors=1)
elif (args.classifier == 'Softmax'):
model = LogisticRegression(random_state=0,
solver='lbfgs',
multi_class='multinomial')
else:
model = RandomForestClassifier(n_estimators=1000,
max_leaf_nodes=100,
n_jobs=-1)
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))
report = precision_recall_fscore_support(labels,
best_class_indices,
average='weighted')
print(report[2])
print('Accuracy: %.3f' % accuracy)