def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
# Load the model
print('Loading model "%s"' % args.model_file)
facenet.load_model(args.model_file)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
tpr, fpr, accuracy, val, val_std, far = lfw.validate(sess,
paths, actual_issame, args.seed, 60,
images_placeholder, phase_train_placeholder, embeddings, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
facenet.plot_roc(fpr, tpr, 'NN4')
def main(args):
align = align_dlib.AlignDlib(os.path.expanduser(args.dlib_face_predictor))
image_paths = [args.image1, args.image2]
landmarkIndices = align_dlib.AlignDlib.OUTER_EYES_AND_NOSE
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading model "%s"' % args.model_file)
facenet.load_model(args.model_file)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
image_size = int(images_placeholder.get_shape()[1])
# Run forward pass to calculate embeddings
images = load_and_align_data(image_paths, image_size, align, landmarkIndices)
feed_dict = { images_placeholder: images, phase_train_placeholder: False }
emb = sess.run(embeddings, feed_dict=feed_dict)
dist = np.sqrt(np.mean(np.square(np.subtract(emb[0,:], emb[1,:]))))
print('Distance between the embeddings: %3.6f' % dist)
def main(args):
images, cout_per_image, nrof_samples = load_and_align_data(args.image_files,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)
classifier_filename_exp = os.path.expanduser(args.classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
print('Loaded classifier model from file "%s"\n' % classifier_filename_exp)
predictions = model.predict_proba(emb)
best_class_indices = np.argmax(predictions, axis=1)
best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]
k=0
#print predictions
for i in range(nrof_samples):
print("\npeople in image %s :" %(args.image_files[i]))
for j in range(cout_per_image[i]):
print('%s: %.3f' % (class_names[best_class_indices[k]], best_class_probabilities[k]))
k+=1
def loadArg():
path1 = './shape_predictor_68_face_landmarks.dat'
path2 = './20160514-234418/model.ckpt-500000'
align = align_dlib.AlignDlib(os.path.expanduser(path1))
landmarkIndices = align_dlib.AlignDlib.OUTER_EYES_AND_NOSE
# Load the model
print("load model")
facenet.load_model(path2)
return align,landmarkIndices
def main(args):
train_set = facenet.get_dataset(args.data_dir)
image_list, label_list = facenet.get_image_paths_and_labels(train_set)
label_strings = [name for name in os.listdir(os.path.expanduser(args.data_dir)) if os.path.isdir(os.path.join(os.path.expanduser(args.data_dir), 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)
np.save(args.labels_strings_name, label_strings)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
# Load the model
print('Model directory: %s' % args.model_dir)
meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(args.model_dir))
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
facenet.load_model(args.model_dir, meta_file, ckpt_file)
# 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")
image_size = images_placeholder.get_shape()[1]
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Runnning forward pass on LFW images')
batch_size = args.lfw_batch_size
nrof_images = len(paths)
nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches):
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)
tpr, fpr, accuracy, val, val_std, far = lfw.evaluate(emb_array,
actual_issame, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
auc = metrics.auc(fpr, tpr)
print('Area Under Curve (AUC): %1.3f' % auc)
eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.)
print('Equal Error Rate (EER): %1.3f' % eer)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# create output directory if it doesn't exist
output_dir = os.path.expanduser(args.output_dir)
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
# load the model
print("Loading trained model...\n")
meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(args.trained_model_dir))
facenet.load_model(args.trained_model_dir, meta_file, ckpt_file)
# grab all image paths and labels
print("Finding image paths and targets...\n")
data = load_files(args.data_dir, load_content=False, shuffle=False)
labels_array = data['target']
paths = data['filenames']
# 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")
image_size = images_placeholder.get_shape()[1]
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Generating embeddings from images...\n')
start_time = time.time()
batch_size = args.batch_size
nrof_images = len(paths)
nrof_batches = int(np.ceil(1.0*nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in xrange(nrof_batches):
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, do_random_crop=False, do_random_flip=False, image_size=image_size, do_prewhiten=True)
feed_dict = { images_placeholder:images, phase_train_placeholder:False}
emb_array[start_index:end_index,:] = sess.run(embeddings, feed_dict=feed_dict)
time_avg_forward_pass = (time.time() - start_time) / float(nrof_images)
print("Forward pass took avg of %.3f[seconds/image] for %d images\n" % (time_avg_forward_pass, nrof_images))
print("Finally saving embeddings and gallery to: %s" % (output_dir))
# save the gallery and embeddings (signatures) as numpy arrays to disk
np.save(os.path.join(output_dir, "gallery.npy"), labels_array)
np.save(os.path.join(output_dir, "signatures.npy"), emb_array)
def main(argv=None):
pairs = read_pairs(os.path.expanduser(FLAGS.lfw_pairs))
paths, actual_issame = get_paths(os.path.expanduser(FLAGS.lfw_dir), pairs)
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading model "%s"' % FLAGS.model_file)
facenet.load_model(FLAGS.model_file)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
image_size = images_placeholder.get_shape()[1]
# Run forward pass to calculate embeddings
nrof_images = len(paths)
nrof_batches = int(nrof_images / FLAGS.batch_size)
emb_list = []
for i in range(nrof_batches):
start_time = time.time()
paths_batch = paths[i*FLAGS.batch_size:(i+1)*FLAGS.batch_size]
images = facenet.load_data(paths_batch, False, False, image_size)
feed_dict = { images_placeholder: images, phase_train_placeholder: False }
emb_list += sess.run([embeddings], feed_dict=feed_dict)
duration = time.time() - start_time
print('Calculated embeddings for batch %d of %d: time=%.3f seconds' % (i+1,nrof_batches, duration))
emb_array = np.vstack(emb_list) # Stack the embeddings to a nrof_examples_per_epoch x 128 matrix
# Calculate evaluation metrics
thresholds = np.arange(0, 4, 0.01)
embeddings1 = emb_array[0::2]
embeddings2 = emb_array[1::2]
tpr, fpr, accuracy = facenet.calculate_roc(thresholds, embeddings1, embeddings2, np.asarray(actual_issame), FLAGS.seed)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
thresholds = np.arange(0, 4, 0.001)
val, val_std, far = facenet.calculate_val(thresholds, embeddings1, embeddings2, np.asarray(actual_issame), 1e-3, FLAGS.seed)
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
facenet.plot_roc(fpr, tpr, 'NN4')
def main(args):
images = load_and_align_data(args.image_files, args.image_size, args.margin, args.gpu_memory_fraction)
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Model directory: %s' % args.model_dir)
meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(args.model_dir))
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
facenet.load_model(args.model_dir, meta_file, ckpt_file)
# 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(args.image_files)
print('Images:')
for i in range(nrof_images):
print('%1d: %s' % (i, args.image_files[i]))
print('')
# Print distance matrix
print('Distance matrix')
print(' ', end='')
for i in range(nrof_images):
print(' %1d ' % i, end='')
print('')
for i in range(nrof_images):
print('%1d ' % i, end='')
for j in range(nrof_images):
dist = np.sqrt(np.sum(np.square(np.subtract(emb[i,:], emb[j,:]))))
print(' %1.4f ' % dist, end='')
print('')
def main(args):
align = align_dlib.AlignDlib(os.path.expanduser(args.dlib_face_predictor))
#image_paths = [args.image1, args.image2]
landmarkIndices = align_dlib.AlignDlib.OUTER_EYES_AND_NOSE
images_list = get_image_paths(args.image_folder)
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading model "%s"' % args.model_file)
facenet.load_model(args.model_file)
while True:
# Get input and output tensors
#image_paths = [args.image1, args.image2]
#image_paths = [images_list[0],images_list[1],images_list[2]]
image_paths = images_list
pdb.set_trace()
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
#image_size = int(images_placeholder.get_shape()[1])
image_size = 96
# Run forward pass to calculate embeddings
images = load_and_align_data(image_paths, image_size, align, landmarkIndices)
feed_dict = { images_placeholder: images, phase_train_placeholder: False }
emb = sess.run(embeddings, feed_dict=feed_dict)
#dist = np.sqrt(np.sum(np.square(np.subtract(emb[0,:], emb[1,:]))))
n = len(image_paths)
dist = np.zeros([n,n])
for i in range(n):
for j in range(n):
dist[i,j] = np.dot(emb[i,:],emb[j,:])
print('Cosine distance between the embeddings: ')
print(dist)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs)
image_paths_placeholder = tf.placeholder(tf.string, shape=(None,1), name='image_paths')
labels_placeholder = tf.placeholder(tf.int32, shape=(None,1), name='labels')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
control_placeholder = tf.placeholder(tf.int32, shape=(None,1), name='control')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
nrof_preprocess_threads = 4
image_size = (args.image_size, args.image_size)
eval_input_queue = data_flow_ops.FIFOQueue(capacity=2000000,
dtypes=[tf.string, tf.int32, tf.int32],
shapes=[(1,), (1,), (1,)],
shared_name=None, name=None)
eval_enqueue_op = eval_input_queue.enqueue_many([image_paths_placeholder, labels_placeholder, control_placeholder], name='eval_enqueue_op')
image_batch, label_batch = facenet.create_input_pipeline(eval_input_queue, image_size, nrof_preprocess_threads, batch_size_placeholder)
# Load the model
input_map = {'image_batch': image_batch, 'label_batch': label_batch, 'phase_train': phase_train_placeholder}
facenet.load_model(args.model, input_map=input_map)
# Get output tensor
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
#
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
evaluate(sess, eval_enqueue_op, image_paths_placeholder, labels_placeholder, phase_train_placeholder, batch_size_placeholder, control_placeholder,
embeddings, label_batch, paths, actual_issame, args.lfw_batch_size, args.lfw_nrof_folds, args.distance_metric, args.subtract_mean,
args.use_flipped_images, args.use_fixed_image_standardization)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model metagraph and checkpoint
print('Model directory: %s' % args.model_dir)
meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(args.model_dir))
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
facenet.load_model(args.model_dir, meta_file, ckpt_file)
output_node_names = 'embeddings'
whitelist_names = []
for node in sess.graph.as_graph_def().node:
if node.name.startswith('InceptionResnetV1') or node.name.startswith('embeddings') or node.name.startswith('phase_train'):
print(node.name)
whitelist_names.append(node.name)
output_graph_def = graph_util.convert_variables_to_constants(
sess, sess.graph.as_graph_def(), output_node_names.split(","),
variable_names_whitelist=whitelist_names)
with tf.gfile.GFile(args.output_file, 'wb') as f:
f.write(output_graph_def.SerializeToString())
print("%d ops in the final graph." % len(output_graph_def.node)) #pylint: disable=no-member
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--path', help='Path of the video you want to test on.', default=0)
args = parser.parse_args()
# Cai dat cac tham so can thiet
MINSIZE = 20
THRESHOLD = [0.6, 0.7, 0.7]
FACTOR = 0.709
IMAGE_SIZE = 182
INPUT_IMAGE_SIZE = 160
CLASSIFIER_PATH = 'Models/facemodel.pkl'
VIDEO_PATH = args.path
FACENET_MODEL_PATH = 'Models/20180402-114759.pb'
# Load model da train de nhan dien khuon mat - thuc chat la classifier
with open(CLASSIFIER_PATH, 'rb') as file:
model, class_names = pickle.load(file)
print("Custom Classifier, Successfully loaded")
with tf.Graph().as_default():
# Cai dat GPU neu co
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
# Load model MTCNN phat hien khuon mat
print('Loading feature extraction model')
facenet.load_model(FACENET_MODEL_PATH)
# Lay tensor input va output
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]
# Cai dat cac mang con
pnet, rnet, onet = align.detect_face.create_mtcnn(sess, "src/align")
people_detected = set()
person_detected = collections.Counter()
# Lay hinh anh tu file video
cap = cv2.VideoCapture(VIDEO_PATH)
while (cap.isOpened()):
# Doc tung frame
ret, frame = cap.read()
# Phat hien khuon mat, tra ve vi tri trong bounding_boxes
bounding_boxes, _ = align.detect_face.detect_face(frame, MINSIZE, pnet, rnet, onet, THRESHOLD, FACTOR)
faces_found = bounding_boxes.shape[0]
try:
# Neu co it nhat 1 khuon mat trong frame
if faces_found > 0:
det = bounding_boxes[:, 0:4]
bb = np.zeros((faces_found, 4), dtype=np.int32)
for i in range(faces_found):
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# Cat phan khuon mat tim duoc
cropped = frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :]
scaled = cv2.resize(cropped, (INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE),
interpolation=cv2.INTER_CUBIC)
scaled = facenet.prewhiten(scaled)
scaled_reshape = scaled.reshape(-1, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, 3)
feed_dict = {images_placeholder: scaled_reshape, phase_train_placeholder: False}
emb_array = sess.run(embeddings, feed_dict=feed_dict)
# Dua vao model de classifier
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]
# Lay ra ten va ty le % cua class co ty le cao nhat
best_name = class_names[best_class_indices[0]]
print("Name: {}, Probability: {}".format(best_name, best_class_probabilities))
# Ve khung mau xanh quanh khuon mat
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0), 2)
text_x = bb[i][0]
text_y = bb[i][3] + 20
# Neu ty le nhan dang > 0.5 thi hien thi ten
if best_class_probabilities > 0.5:
name = class_names[best_class_indices[0]]
else:
# Con neu <=0.5 thi hien thi Unknow
name = "Unknown"
# Viet text len tren frame
cv2.putText(frame, name, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 255, 255), thickness=1, lineType=2)
cv2.putText(frame, str(round(best_class_probabilities[0], 3)), (text_x, text_y + 17),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 255, 255), thickness=1, lineType=2)
person_detected[best_name] += 1
except:
pass
# Hien thi frame len man hinh
cv2.imshow('Face Recognition', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def restore_facenet_model(model_path):
# load the model
print('Loading feature extraction model')
facenet.load_model(model_path)
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
# # classes = ['circle', 'diamond', 'egg', 'long', 'polygon', 'square', 'triangle'] #train human name
# with open(config.classes_map, 'rb') as f:
# class_names = pickle.load(f)
# print(class_names)
print('Loading feature extraction model')
modeldir = args.model_params
facenet.load_model(resource_path(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]
classifier_filename = os.path.join(args.clf_dir, args.clf_name)
classifier_filename_exp = resource_path(
os.path.expanduser(classifier_filename))
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
print('load classifier file-> %s' % classifier_filename_exp)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
load_start = time.time()
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)
# 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)
print(f"Loaded in {time.time() - load_start}s")
print("=======================================\n")
if (args.mode=='TRAIN'):
print("# Training data....... ")
print('Number of classes: %d' % len(dataset))
print('Number of images: %d\n' % len(paths))
train_start = time.time()
# 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)
print(f"Trained in {time.time()-train_start}s")
elif (args.mode=='CLASSIFY'):
# Classify images
classify_time = time.time()
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)
print("=============================================")
print(f"finished in {time.time()-classify_time}s")
def main(argv=None):
pairs = read_pairs(os.path.expanduser(FLAGS.lfw_pairs))
paths, actual_issame = get_paths(os.path.expanduser(FLAGS.lfw_dir), pairs)
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading model "%s"' % FLAGS.model_file)
facenet.load_model(FLAGS.model_file)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
image_size = int(images_placeholder.get_shape()[1])
# Run test on LFW to check accuracy for different horizontal/vertical translations of input images
if True:
offsets = np.arange(-30, 31, 3)
horizontal_offset_accuracy = [None] * len(offsets)
for idx, offset in enumerate(offsets):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings, paths, actual_issame, translate_images, (offset,0))
print('Hoffset: %1.3f Accuracy: %1.3f+-%1.3f' % (offset, np.mean(accuracy), np.std(accuracy)))
horizontal_offset_accuracy[idx] = np.mean(accuracy)
vertical_offset_accuracy = [None] * len(offsets)
for idx, offset in enumerate(offsets):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings, paths, actual_issame, translate_images, (0,offset))
print('Voffset: %1.3f Accuracy: %1.3f+-%1.3f' % (offset, np.mean(accuracy), np.std(accuracy)))
vertical_offset_accuracy[idx] = np.mean(accuracy)
fig = plt.figure(1)
plt.plot(offsets, horizontal_offset_accuracy, label='Horizontal')
plt.plot(offsets, vertical_offset_accuracy, label='Vertical')
plt.legend()
plt.grid(True)
plt.title('Translation invariance on LFW')
plt.xlabel('Offset [pixels]')
plt.ylabel('Accuracy')
plt.show()
result_dir = os.path.expanduser(FLAGS.model_dir)
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_translation.png'))
save_result(offsets, horizontal_offset_accuracy, os.path.join(result_dir, 'invariance_translation_horizontal.txt'))
save_result(offsets, vertical_offset_accuracy, os.path.join(result_dir, 'invariance_translation_vertical.txt'))
# Run test on LFW to check accuracy for different rotation of input images
if True:
angles = np.arange(-30, 31, 3)
rotation_accuracy = [None] * len(angles)
for idx, angle in enumerate(angles):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings, paths, actual_issame, rotate_images, angle)
print('Angle: %1.3f Accuracy: %1.3f+-%1.3f' % (angle, np.mean(accuracy), np.std(accuracy)))
rotation_accuracy[idx] = np.mean(accuracy)
fig = plt.figure(2)
plt.plot(angles, rotation_accuracy)
plt.grid(True)
plt.title('Rotation invariance on LFW')
plt.xlabel('Angle [deg]')
plt.ylabel('Accuracy')
plt.show()
result_dir = os.path.expanduser(FLAGS.model_dir)
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_rotation.png'))
save_result(angles, rotation_accuracy, os.path.join(result_dir, 'invariance_rotation.txt'))
# Run test on LFW to check accuracy for different scaling of input images
if True:
scales = np.arange(0.5, 1.5, 0.05)
scale_accuracy = [None] * len(scales)
for scale_idx, scale in enumerate(scales):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings, paths, actual_issame, scale_images, scale)
print('Scale: %1.3f Accuracy: %1.3f+-%1.3f' % (scale, np.mean(accuracy), np.std(accuracy)))
scale_accuracy[scale_idx] = np.mean(accuracy)
fig = plt.figure(3)
plt.plot(scales, scale_accuracy)
plt.grid(True)
plt.title('Scale invariance on LFW')
plt.xlabel('Scale')
plt.ylabel('Accuracy')
plt.show()
result_dir = os.path.expanduser(FLAGS.model_dir)
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_scale.png'))
save_result(scales, scale_accuracy, os.path.join(result_dir, 'invariance_scale.txt'))
def __init__(self):
self.sess = tf.Session()
with self.sess.as_default():
facenet.load_model(facenet_model_checkpoint)
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Get the paths for the corresponding images
vinayak = [
'datasets/kar_Vin_aligned/vinayak/' + f
for f in os.listdir('datasets/kar_Vin_aligned/vinayak')
]
karthik = [
'datasets/kar_Vin_aligned/karthik/' + f
for f in os.listdir('datasets/kar_Vin_aligned/karthik')
]
ashish = [
'datasets/kar_Vin_aligned/Ashish/' + f
for f in os.listdir('datasets/kar_Vin_aligned/Ashish')
]
saurabh = [
'datasets/kar_Vin_aligned/Saurabh/' + f
for f in os.listdir('datasets/kar_Vin_aligned/Saurabh')
]
hari = [
'datasets/kar_Vin_aligned/Hari/' + f
for f in os.listdir('datasets/kar_Vin_aligned/Hari')
]
paths = vinayak + karthik + ashish + saurabh + hari
#np.save("images.npy",paths)
# 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")
images_placeholder = tf.image.resize_images(
images_placeholder, (160, 160))
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")
image_size = args.image_size
embedding_size = embeddings.get_shape()[1]
extracted_dict = {}
# Run forward pass to calculate embeddings
for i, filename in enumerate(paths):
images = facenet.load_image(filename, False, False, image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
feature_vector = sess.run(embeddings, feed_dict=feed_dict)
extracted_dict[filename] = feature_vector
if (i % 100 == 0):
print("completed", i, " images")
with open('extracted_dict.pickle', 'wb') as f:
pickle.dump(extracted_dict, f)
def main(args, q1, q2, q3):
minsize = 20
threshold = [0.6, 0.7, 0.7]
factor = 0.709
image_size = 182
input_image_size = 160
global fg, fg2
fg2 = 405
fg = 404
# comment out these lines if you do not want video recording
# USE FOR RECORDING VIDEO
fourcc = cv2.VideoWriter_fourcc(*'X264')
# Get the path of the classifier and load it
project_root_folder = os.path.join(os.path.abspath(__file__), "..\\..")
classifier_path = project_root_folder + "\\trained_classifier\\our_newglint_classifier201015.pkl"
print(classifier_path)
with open(classifier_path, 'rb') as f:
(model, class_names) = pickle.load(f)
print("Loaded classifier file")
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.7)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
# Bounding box
pnet, rnet, onet = align.detect_face.create_mtcnn(sess, project_root_folder + "\\src\\align")
# Get the path of the facenet model and load it
facenet_model_path = project_root_folder + "\\facenet_model\\20170512-110547\\20170512-110547.pb"
facenet.load_model(facenet_model_path)
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]
# Start video capture
people_detected = set()
person_detected = collections.Counter()
cv2.namedWindow('Face Detection and Identification', 0)
width = 640
height = 480
video_recording = cv2.VideoWriter(args.respath + '/res_video/output.avi', fourcc, 7,
(int(width), int(height)))
total_frames_passed = 0
unknowpeople = 0
knowpeople = 0
while True:
try:
if len(q1) == 0:
continue
frame = q1.pop()
if args.flip == True:
frame = cv2.flip(frame, 1)
except Exception as e:
break
# Skip frames if video is to be sped up
if args.video_speedup:
total_frames_passed += 1
if total_frames_passed % args.video_speedup != 0:
continue
bounding_boxes, points = align.detect_face.detect_face(frame, minsize, pnet, rnet, onet, threshold, factor)
faces_found = bounding_boxes.shape[0]
## 识别框
# cv2.putText(frame, 'Identification Box', (190, 60), cv2.FONT_HERSHEY_COMPLEX_SMALL,
# 1, (0, 0, 255),
# thickness=2,
# lineType=1)
windowname = "测温请靠近！"
frame = cv2ImgAddText(frame, windowname, 235, 60, (155, 0, 0), 25)
cv2.rectangle(frame, (185, 95), (430, 400), (165, 245, 25), 2)
if faces_found > 0:
det = bounding_boxes[:, 0:4]
bb = np.zeros((faces_found, 4), dtype=np.int32)
for i in range(faces_found):
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (255, 150, 0),
2) # boxing face
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(frame[0]) or bb[i][3] >= len(frame):
print('face is inner of range!')
continue
cropped = frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :] # 这里是把检测到的人脸进行裁减出来
scaled = cv2.resize(cropped, (input_image_size, input_image_size), # 将裁剪出来的人脸resize成统一大小
interpolation=cv2.INTER_CUBIC)
# cv2.imshow("Cropped and scaled", scaled)
# cv2.waitKey(1)
scaled = facenet.prewhiten(scaled) # 这里应该是把裁剪出来的人脸进行图像处理的结果
# cv2.imshow("\"Whitened\"", scaled)
# cv2.waitKey(1)
scaled_reshape = scaled.reshape(-1, input_image_size, input_image_size, 3)
feed_dict = {images_placeholder: scaled_reshape, phase_train_placeholder: False}
emb_array = sess.run(embeddings, feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
#print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
person_id = best_class_indices[0]
# print(predictions[0][x])
best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]
best_name = class_names[best_class_indices[0]]
print("Name_all: {}, Probability: {}".format(best_name, best_class_probabilities))
#这里是找到识别区域中最大的脸，进行测温
if args.use_tem == True:
if bb[i][0]>180 and bb[i][2]<435 and bb[i][1]>70 and bb[i][3]<408:
xmin = bb[i][0].astype(int)
xmax = bb[i][2].astype(int)
ymin = bb[i][1].astype(int)
ymax = bb[i][3].astype(int)
h = ymax - ymin
w = xmax - xmin
area = h * w
print('-----------------------------------------------面积', area)
if area >= 245*305*0.08:# 245*305*0.08 = 5978
try:
tems = q2.pop()
diss = q3.pop()
except:
tems = 0
diss = 0
#tems, diss, jz = temperature()
if tems > 20:
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
cv2.putText(frame, '{}'.format(tems), (bb[i][0]+5, bb[i][1]+35),
font,
2, (55, 255, 30), thickness=2, lineType=2)
#if 100 < diss < 500:
if tems <= 37:
fg = 0
#print('----------------------------------main fg:',fg)
else:
fg = 1
# print('----------------------------------main fg:',fg)
# else:
# fg = 404
else:
fg = 404
else:
fg = 404
#print('----------------------------------main fg:', fg)
#在检测框上标注是别人id及score
if best_class_probabilities > 0.3:
#print("{} : {}".format(person_id, str(best_class_probabilities[0])[0:4]))
id_score = "{}:{}".format(person_id, str(best_class_probabilities[0])[0:4])
font = cv2.FONT_HERSHEY_COMPLEX_SMALL # cv2.FONT_HERSHEY_SCRIPT_COMPLEX #cv2.FONT_HERSHEY_COMPLEX_SMALL,
cv2.putText(frame, id_score, (bb[i][0] + 5, bb[i][1] - 3),
font,
1, (0, 0, 200), thickness=2, lineType=3)
#进行人脸识别
if best_class_probabilities > args.knowperson_threshold: # 0.90:
# cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0),
# 2) # boxing face
knowpeople += 1
print("Name_True_rec: {}, Probability: {}".format(best_name, best_class_probabilities))
text_xmin = bb[i][0]
text_y = bb[i][3] + 20
text_ymax = bb[i][3] + 30
text_ymin = bb[i][3]
text_xmax = bb[i][2]
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0),
2) # boxing face
# cv2.rectangle(frame, (text_xmin, text_ymin), (text_xmax, text_ymax), (0, 255, 0),
# cv2.FILLED) # name box
font = cv2.FONT_HERSHEY_COMPLEX_SMALL # cv2.FONT_HERSHEY_SCRIPT_COMPLEX #cv2.FONT_HERSHEY_COMPLEX_SMALL,
cv2.putText(frame, class_names[best_class_indices[0]], (text_xmin+5, text_y),
font,
1, (14, 173, 238), thickness=2, lineType=3)
person_detected[best_name] += 1
# 设置签到门槛，确保不错误识别
if best_class_probabilities > 0.95:
signin(class_names[best_class_indices[0]], frame)
if bb[i][0] > 180 and bb[i][2] < 435 and bb[i][1] > 70 and bb[i][3] < 408:
fg2 = 2
#print('----------------------------------main fg:', fg)
else:
fg2 = 405
#print('----------------------------------main fg:', fg)
#进行陌生人判断
elif best_class_probabilities < args.unknowperson_threshold: # 0.6:
# cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0),
# 2) # boxing face
#这里对unknow进行干扰过滤，防止误触发
unknowpeople += 1 #这行和下五行的可行性待验证！！！
if knowpeople == 20:
knowpeople = 0
unknowpeople = 0
#print('unknowpeople:',unknowpeople)
if unknowpeople % 1 == 0:
text_x = bb[i][0]
text_y = bb[i][3] + 20
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 0, 255),
2) # boxing face
cv2.putText(frame, 'unknow', (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 200), thickness=1, lineType=2)
print("Name_unknow_rec: unknow, Probability: {}".format(best_class_probabilities))
unknowpeople = 0
# 陌生人脸帧留档
if args.record_unknow == True:
for x in range(20):
if not x % 10 == 0:
continue
if best_class_probabilities < args.stranger_threshold: # 0.5:
strange_in_time = str(time.strftime('%Y-%m-%d_%H-%M-%S'))
# print(strange_in_time)
cv2.imwrite(args.respath + "/stranger/" + strange_in_time + ".jpg", frame)
for person, count in person_detected.items():
if count > 4:
print("Person Detected: {}, Count: {}".format(person, count))
people_detected.add(person)
# cv2.putText(frame, "People detected so far:", (20, 20), cv2.FONT_HERSHEY_PLAIN,
# 1, (255, 0, 0), thickness=1, lineType=2)
fg2 = 405
mainwindowname = "人脸验证及测温系统"
frame = cv2ImgAddText(frame, mainwindowname, 20, 20, (255, 255, 155), 20)
if args.beauty == True:
frame = beautiful(frame)
cv2.imshow("Face Detection and Identification", frame)
if args.record == True:
video_recording.write(frame)
if cv2.waitKey(1) & 0xFF == 27:
break
# #当前线程数
# xcs = len(threading.enumerate())
# print("当前线程数：{}".format(xcs))
print("-----------------------------------------------检测识别")
video_recording.release()
#video_capture.release()
cv2.destroyAllWindows()
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# create output directory if it doesn't exist
output_dir = os.path.expanduser(args.output_dir)
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
# load the model
print("Loading trained model...\n")
meta_file, ckpt_file = facenet.get_model_filenames(
os.path.expanduser(args.trained_model_dir))
facenet.load_model(args.trained_model_dir)
# grab all image paths and labels
print("Finding image paths and targets...\n")
data = load_files(args.data_dir, load_content=False, shuffle=False)
labels_array = data['target']
paths = data['filenames']
# 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")
image_size = images_placeholder.get_shape()[1]
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Generating embeddings from images...\n')
start_time = time.time()
batch_size = args.batch_size
nrof_images = len(paths)
nrof_batches = int(np.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data(paths_batch,
do_random_crop=False,
do_random_flip=False,
image_size=image_size,
do_prewhiten=True)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
time_avg_forward_pass = (time.time() -
start_time) / float(nrof_images)
print(
"Forward pass took avg of %.3f[seconds/image] for %d images\n"
% (time_avg_forward_pass, nrof_images))
for emb_idx, emb in enumerate(emb_array):
norm_emb = emb / np.linalg.norm(emb)
print(norm_emb)
encoded_word = ""
q = 30
for i, wi in enumerate(norm_emb):
val = wi * q
val_abs = math.fabs(val)
prefix = ("F" if val > 0 else "f")
if (val_abs < 0.5):
val = 0
else:
val = math.floor(val_abs)
for j in range(val):
encoded_word += prefix + str(i)
print("----> " + str(emb_idx))
print(encoded_word)
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)
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)
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为两两比较的列表,列表的元素为有2个元素的元祖,actual_issame为列表,表示每个元素是否为同一个人
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) #capacity代表队列容量
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(),
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_out = tf.train.Saver(tf.trainable_variables(), max_to_keep=3) #max_to_keep代表保存最近的3个模型;如果设置为0或None,则代表保存每一个模型,会占用很大内存(不推荐)
# 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) #设置GPU显存占用率
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)
# tensorflow中的多进程管理,下面两条语句通常配套使用
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)
facenet.load_model(pretrained_model)
# Training and validation loop
print('Running softmax 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_out, 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:
# 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
paths, actual_issame = lfw.get_paths(
os.path.expanduser(args.lfw_dir), pairs)
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 1),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int32,
shape=(None, 1),
name='labels')
batch_size_placeholder = tf.placeholder(tf.int32,
name='batch_size')
control_placeholder = tf.placeholder(tf.int32,
shape=(None, 1),
name='control')
phase_train_placeholder = tf.placeholder(tf.bool,
name='phase_train')
nrof_preprocess_threads = 4
image_size = (args.image_size, args.image_size)
eval_input_queue = data_flow_ops.FIFOQueue(
capacity=2000000,
dtypes=[tf.string, tf.int32, tf.int32],
shapes=[(1, ), (1, ), (1, )],
shared_name=None,
name=None)
eval_enqueue_op = eval_input_queue.enqueue_many(
[
image_paths_placeholder, labels_placeholder,
control_placeholder
],
name='eval_enqueue_op')
image_batch, label_batch = facenet.create_input_pipeline(
eval_input_queue, image_size, nrof_preprocess_threads,
batch_size_placeholder)
# Load the model
input_map = {
'image_batch': image_batch,
'label_batch': label_batch,
'phase_train': phase_train_placeholder
}
facenet.load_model(args.model, input_map=input_map)
# Get output tensor
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
#
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
evaluate(sess, eval_enqueue_op, image_paths_placeholder,
labels_placeholder, phase_train_placeholder,
batch_size_placeholder, control_placeholder, embeddings,
label_batch, paths, actual_issame, args.lfw_batch_size,
args.lfw_nrof_folds, args.distance_metric,
args.subtract_mean, args.use_flipped_images,
args.use_fixed_image_standardization)
def main(args, q1, q2, q3):
input_image_size = 160
global fg, fg2, fg3, temwork
fg = 404
fg2 = 405
fg3 = 406
temwork = 0
# comment out these lines if you do not want video recording
# USE FOR RECORDING VIDEO
fourcc = cv2.VideoWriter_fourcc(*'X264')
# Get the path of the classifier and load it
project_root_folder = os.path.join(os.path.abspath(__file__), "..\\..")
# classifier_path = project_root_folder + "\\trained_classifier\\our_newglint_classifier_512_201028.pkl" # 512维facenet人脸识别模型
classifier_path = project_root_folder + "\\trained_classifier\\our_newglint_classifier_128_201029-5.pkl" # 128维facenet人脸识别模型
# print(classifier_path)
with open(classifier_path, 'rb') as f:
(model, class_names) = pickle.load(f)
print("Loaded classifier file")
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.7)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
# Get the path of the facenet model and load it
# facenet_model_path = project_root_folder + "\\facenet_model\\20180402-114759\\20180402-114759.pb" # 512维facenet预训练模型
facenet_model_path = project_root_folder + "\\facenet_model\\20170512-110547\\20170512-110547.pb" # 128维facenet预训练模型
facenet.load_model(facenet_model_path)
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]
# Start video capture
people_detected = set()
person_detected = collections.Counter()
cv2.namedWindow('Face Detection and Identification', 0)
while True:
if len(q1) == 0:
continue
frame = q1.pop()
height = frame.shape[0]
width = frame.shape[1]
break
video_recording = cv2.VideoWriter(
args.respath + '/res_video/output_{}.avi'.format(
time.strftime('%Y-%m-%d_%H-%M-%S')), fourcc, 10,
(width, height))
total_frames_passed = 0
unknowpeople = 0
knowpeople = 0
# 循环读取缓存序列中的视频帧
while True:
# time.sleep(0.05)
try:
if len(q1) == 0:
continue
frame = q1.pop()
h = frame.shape[0]
w = frame.shape[1]
# print(h, w)
if args.flip == True:
frame = cv2.flip(frame, 1)
except Exception as e:
break
# Skip frames if video is to be sped up
if args.video_speedup:
total_frames_passed += 1
if total_frames_passed % args.video_speedup != 0:
continue
# bounding_boxes返回[class_id, conf, xmin, ymin, xmax, ymax]
start = time.time()
bounding_boxes = detect_face(frame,
conf_thresh=0.5,
iou_thresh=0.4,
target_shape=(260, 260),
draw_result=False,
show_result=False)
# print(bounding_boxes)
end = time.time()
# print("detect face: ", end-start)
faces_found = len(bounding_boxes)
## 识别框
windowname = "测温请靠近！"
xmin = int(w / 2 - 120)
ymin = int(h / 2 - 180)
xmax = int(w / 2 + 120)
ymax = int(h / 2 + 120)
frame2 = cv2ImgAddText(frame, windowname, xmin + 38, ymin - 80,
(155, 0, 0), 25)
cv2.rectangle(frame2, (xmin, ymin - 30), (xmax, ymax),
(165, 245, 25), 1)
window_area = (xmax - xmin) * (ymax - ymin + 30)
det = bounding_boxes
if faces_found > 0:
temwork = 1
bb = np.zeros((faces_found, 4), dtype=np.int32)
for i in range(faces_found):
bb[i][0] = det[i][2]
bb[i][1] = det[i][3]
bb[i][2] = det[i][4]
bb[i][3] = det[i][5]
class_id = det[i][0] # 戴口罩判断
conf = det[i][1] # 口罩检测分数
cv2.rectangle(frame2, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (255, 150, 0),
2) # boxing face
if class_id == 0:
color = (0, 255, 0)
fg3 = 406
else:
color = (0, 0, 255)
fg3 = 3
# cv2.putText(frame, "%s:%.2f" % (id2class[class_id], conf), (bb[i][0], bb[i][3]+40),
# cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, thickness=1, lineType=2)
cv2.putText(frame2,
"%s" % (id2class[class_id]),
(bb[i][0], bb[i][1] - 20),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
0.8,
color,
thickness=1,
lineType=2)
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(
frame[0]) or bb[i][3] >= len(frame):
# print('face is inner of range!')
continue
cropped = frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i]
[2], :] # 这里是把检测到的人脸进行裁减出来
# cv2.imshow('cropped', cropped)
# cv2.waitKey(1)
scaled = cv2.resize(
cropped,
(input_image_size,
input_image_size), # 将裁剪出来的人脸resize成统一大小
interpolation=cv2.INTER_CUBIC)
scaled = facenet.prewhiten(
scaled) # 这里应该是把裁剪出来的人脸进行图像处理的结果
scaled_reshape = scaled.reshape(
-1, input_image_size, input_image_size, 3)
feed_dict = {
images_placeholder: scaled_reshape,
phase_train_placeholder: False
}
emb_array = sess.run(embeddings, feed_dict=feed_dict)
pre_start = time.time()
predictions = model.predict_proba(emb_array)
# print(predictions)
pre_end = time.time()
# print("predict face: ", pre_end-pre_start)
best_class_indices = np.argmax(
predictions, axis=1) # 按行比较数组的大小，返回最大数的索引
person_id = best_class_indices[0]
# print(predictions[0][x])
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
best_name = class_names[best_class_indices[0]]
# print("Name_all: {}, Probability: {}".format(best_name, best_class_probabilities))
# 这里是找到识别区域中最大的脸，进行测温
if args.use_tem == True:
if bb[i][0] > xmin - 80 and bb[i][
2] < xmax + 80 and bb[i][
1] > ymin - 80 and bb[i][3] < ymax + 80:
box_xmin = bb[i][0].astype(int)
box_xmax = bb[i][2].astype(int)
box_ymin = bb[i][1].astype(int)
box_ymax = bb[i][3].astype(int)
h = box_ymax - box_ymin
w = box_xmax - box_xmin
area = h * w
# print('-----------------------------------------------面积', area)
if area >= window_area * 0.2:
try:
tems = q2.pop()
diss = q3.pop()
except:
if len(q2) == 0:
tems = tems
if len(q3) == 0:
diss = diss
# tems = 0 # round(random.uniform(36.1, 36.5), 1)
# tems, diss, jz = temperature()
if tems > 20:
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
cv2.putText(
frame2,
'{}'.format(tems),
(bb[i][0] + 5, bb[i][1] + 30),
font,
2, (55, 255, 30),
thickness=2,
lineType=1)
if 100 < diss < 900:
if tems <= 37:
fg = 0
# print('----------------------------------main fg:',fg)
create_dir_not_exist(
args.respath +
"/high_temperature")
else:
cv2.putText(frame2,
'{}'.format(tems),
(bb[i][0] + 5,
bb[i][1] + 30),
font,
2, (55, 30, 255),
thickness=2,
lineType=1)
fg = 1
high_tem_time = str(
time.strftime(
'%Y-%m-%d_%H-%M-%S'))
cv2.imwrite(
args.respath +
"/high_temperature/" +
high_tem_time + ".jpg",
frame2)
# print('----------------------------------main fg:',fg)
else:
fg = 404
else:
pass # fg = 404
else:
fg = 404
# print('----------------------------------main fg:', fg)
# 在检测框上标注是别人id及score
if best_class_probabilities > 0.3:
# print("{} : {}".format(person_id, str(best_class_probabilities[0])[0:4]))
# id_score = "{}:{}".format(person_id, str(best_class_probabilities[0])[0:4])
id_score = "%d:%.2f" % (
person_id, best_class_probabilities[0])
font = cv2.FONT_HERSHEY_COMPLEX_SMALL # cv2.FONT_HERSHEY_SCRIPT_COMPLEX #cv2.FONT_HERSHEY_COMPLEX_SMALL,
cv2.putText(frame2,
id_score, (bb[i][0], bb[i][1] - 3),
font,
0.8, (0, 0, 200),
thickness=1,
lineType=2)
# 进行人脸识别
if best_class_probabilities > args.knowperson_threshold: # 0.90:
# cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0),
# 2) # boxing face
knowpeople += 1
# print("Name_True_rec: {}, Probability: {}".format(best_name, best_class_probabilities))
text_xmin = bb[i][0]
text_y = bb[i][3] + 20
text_ymax = bb[i][3] + 30
text_ymin = bb[i][3]
text_xmax = bb[i][2]
cv2.rectangle(frame2, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (0, 255, 0),
2) # boxing face
# cv2.rectangle(frame, (text_xmin, text_ymin), (text_xmax, text_ymax), (0, 255, 0),
# cv2.FILLED) # name box
font = cv2.FONT_HERSHEY_COMPLEX_SMALL # cv2.FONT_HERSHEY_SCRIPT_COMPLEX #cv2.FONT_HERSHEY_COMPLEX_SMALL,
cv2.putText(frame2,
class_names[best_class_indices[0]],
(text_xmin, text_y),
font,
0.8, (14, 173, 238),
thickness=1,
lineType=2)
person_detected[best_name] += 1
# 设置签到门槛，确保不错误识别
if best_class_probabilities > 0.95:
signin(class_names[best_class_indices[0]])
if bb[i][0] > xmin - 80 and bb[i][
2] < xmax + 80 and bb[i][
1] > ymin - 80 and bb[i][
3] < ymax + 80:
fg2 = 2
# print('----------------------------------main fg:', fg)
else:
fg2 = 405
# print('----------------------------------main fg:', fg)
else:
fg2 = 405
# print('----------------------------------main fg:', fg)
# 进行陌生人判断
elif best_class_probabilities < args.unknowperson_threshold: # 0.6:
# cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0),
# 2) # boxing face
# 这里对unknow进行干扰过滤，防止误触发
unknowpeople += 1 # 这行和下五行的可行性待验证！！！
if knowpeople == 20:
knowpeople = 0
unknowpeople = 0
# print('unknowpeople:',unknowpeople)
if unknowpeople % 1 == 0:
text_x = bb[i][0]
text_y = bb[i][3] + 20
cv2.rectangle(frame2, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]),
(0, 0, 255), 2) # boxing face
cv2.putText(frame2,
'Unknow', (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
0.8, (0, 0, 200),
thickness=1,
lineType=2)
# print("Name_unknow_rec: unknow, Probability: {}".format(best_class_probabilities))
unknowpeople = 0
# 陌生人脸帧留档
create_dir_not_exist(args.respath +
"/stranger")
create_dir_not_exist(args.respath +
"/stranger_with_box")
if args.record_unknow == True:
for x in range(20):
if not x % 10 == 0:
continue
if best_class_probabilities < args.stranger_threshold: # 0.5:
strange_in_time = str(
time.strftime(
'%Y-%m-%d_%H-%M-%S'))
# print(strange_in_time)
cv2.imwrite(
args.respath + "/stranger/" +
strange_in_time + ".jpg",
frame)
cv2.imwrite(
args.respath +
"/stranger_with_box/" +
strange_in_time + ".jpg",
frame2)
for person, count in person_detected.items():
if count > 4:
# print("Person Detected: {}, Count: {}".format(person, count))
people_detected.add(person)
else:
temwork = 0
fg2 = 405
fg3 = 406
mainwindowname = "人脸验证及测温系统"
frame2 = cv2ImgAddText(frame2, mainwindowname, 20, 20,
(255, 255, 155), 20)
# 加入美颜输出视频
if args.beauty == True:
frame2 = beautiful(frame2)
cv2.imshow("Face Detection and Identification", frame2)
if args.record == True:
video_recording.write(frame2)
if cv2.waitKey(1) & 0xFF == 27:
break
# #当前线程数
# xcs = len(threading.enumerate())
# print("当前线程数：{}".format(xcs))
# print("-----------------------------------------------检测识别")
video_recording.release()
# video_capture.release()
cv2.destroyAllWindows()
def main(args):
# filename = '/home/ydwu/tmp/gen_bin/cfp/Protocol/Pair_list_P.txt'
filename = '/home/ydwu/tmp/gen_bin/cfp/Protocol/Pair_list_F.txt'
num_list = []
image_list = []
with open(filename, 'r') as file_to_read:
while True:
lines = file_to_read.readline() # 整行读取数据
print(lines)
if not lines:
break
pass
l = lines.split()
num_list.append(l[0])
image_list.append(l[1])
# fetch the classes (labels as strings) exactly as it's done in get_dataset
path_exp = os.path.expanduser(args.data_dir)
classes_name = []
img_name = []
for path in os.listdir(path_exp):
# if os.path.isdir(path):
for tpath in os.listdir(os.path.join(path_exp, path)):
classes_name.append(path)
img_name.append(tpath)
sess_2 = tf.Session()
my_head_pose_estimator = CnnHeadPoseEstimator(sess_2) # Head pose estimation object
# Load the weights from the configuration folders
my_head_pose_estimator.load_roll_variables("roll/cnn_cccdd_30k.tf")
my_head_pose_estimator.load_pitch_variables("pitch/cnn_cccdd_30k.tf")
my_head_pose_estimator.load_yaw_variables("yaw/cnn_cccdd_30k.tf")
with tf.Graph().as_default():
# 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))
# with tf.Session() as sess:
with sess.as_default():
# 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))
pose_array = np.zeros((nrof_images, 1))
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
# images = facenet.load_data(image_list[i*batch_size:n], False, False, args.image_size)
images, pose = facenet.ydwu_load_data_v2(image_list[i * batch_size:n], False, False, args.image_size, my_head_pose_estimator)
# print("pose = ", pose)
pose_array[i * batch_size:n, :] = pose
feed_dict = { images_placeholder: images, phase_train_placeholder:False }
# Use the facenet model to calcualte embeddings
embed = sess.run(embeddings, feed_dict=feed_dict)
# print("embed = ", embed)
emb_array[i*batch_size:n, :] = embed
print('Completed batch', i+1, 'of', nrof_batches)
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))
with sess.as_default():
stiched_model_saver = tf.train.import_meta_graph('/home/ydwu/tmp/gen_bin/dream_module/model.ckpt.meta')
stiched_model_saver.restore(sess, '/home/ydwu/tmp/gen_bin/dream_module/model.ckpt-896000')
stitch_emb = tf.get_default_graph().get_tensor_by_name('dream/input:0')
stitch_yaw = tf.get_default_graph().get_tensor_by_name('dream/yaw:0')
stitch_output = tf.get_default_graph().get_tensor_by_name('dream/output:0')
# yaw_degree = 50
yaw = BaseDataset.norm_angle(pose_array)
mapped_profile_emb = sess.run(stitch_output,
feed_dict={stitch_emb: emb_array,
stitch_yaw: np.reshape(yaw, newshape=(-1, 1))})
run_time = time.time() - start_time
print('Run time: ', run_time)
feat_dim = 128
data_num = mapped_profile_emb.shape[0]
feat_file = '/home/ydwu/tmp/gen_bin/' + args.bin_name
with open(feat_file, 'wb') as bin_f:
bin_f.write(st.pack('ii', data_num, feat_dim))
for j in range(data_num):
bin_f.write(st.pack('f' * feat_dim, *tuple(mapped_profile_emb[j, :])))
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
# Load the model
print('Model directory: %s' % args.model_dir)
meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(args.model_dir))
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
facenet.load_model(args.model_dir, meta_file, ckpt_file)
# 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")
image_size = images_placeholder.get_shape()[1]
embedding_size = embeddings.get_shape()[1]
image_size = image_size.value
# pdb.set_trace()
# Run forward pass to calculate embeddings
print('Runnning forward pass on LFW images')
batch_size = args.lfw_batch_size
nrof_images = len(paths)
nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
print('nrof_batches :{}'.format(nrof_batches))
all_time = 0
for i in range(nrof_batches):
start_index = i*batch_size
end_index = min((i+1)*batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
# pdb.set_trace()
images = facenet.load_data(paths_batch, False, False, image_size)
feed_dict = {images_placeholder:images}
start = time()
emb_array[start_index:end_index,:] = sess.run(embeddings, feed_dict=feed_dict)
end = time()
all_time += (end - start)
print('index: {} time: {}'.format(i, (end-start)))
# pdb.set_trace()
print('all_time :', all_time)
msgpack_numpy.dump((paths, emb_array, actual_issame), open('lfw_feature.p', 'wb'))
tpr, fpr, accuracy, val, val_std, far = lfw.evaluate(emb_array,
args.seed, actual_issame, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
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):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(
os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
# Load the model
print('Model directory: %s' % args.model_dir)
meta_file, ckpt_file = facenet.get_model_filenames(
os.path.expanduser(args.model_dir))
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
facenet.load_model(args.model_dir, meta_file, ckpt_file)
# 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")
image_size = images_placeholder.get_shape()[1]
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Runnning forward pass on LFW images')
batch_size = args.lfw_batch_size
nrof_images = len(paths)
nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches):
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)
tpr, fpr, accuracy, val, val_std, far = lfw.evaluate(
emb_array, actual_issame, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' %
(np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' %
(val, val_std, far))
auc = metrics.auc(fpr, tpr)
print('AUC=: %1.3f' % auc)
eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x),
0., 1.)
print('EER=: %1.3f' % eer)
# Plot ROC curve
facenet.plot_roc(fpr, tpr, 'NN4')
def main(args):
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
result_dir = '../data/'
plt.ioff() # Disable interactive plotting mode
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading model "%s"' % args.model_file)
facenet.load_model(args.model_file)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
image_size = int(images_placeholder.get_shape()[1])
# Run test on LFW to check accuracy for different horizontal/vertical translations of input images
if args.nrof_offsets>0:
step = 3
offsets = np.asarray([x*step for x in range(-args.nrof_offsets//2+1, args.nrof_offsets//2+1)])
horizontal_offset_accuracy = [None] * len(offsets)
for idx, offset in enumerate(offsets):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings,
paths, actual_issame, translate_images, (offset,0), 60, args.orig_image_size, args.seed)
print('Hoffset: %1.3f Accuracy: %1.3f+-%1.3f' % (offset, np.mean(accuracy), np.std(accuracy)))
horizontal_offset_accuracy[idx] = np.mean(accuracy)
vertical_offset_accuracy = [None] * len(offsets)
for idx, offset in enumerate(offsets):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings,
paths, actual_issame, translate_images, (0,offset), 60, args.orig_image_size, args.seed)
print('Voffset: %1.3f Accuracy: %1.3f+-%1.3f' % (offset, np.mean(accuracy), np.std(accuracy)))
vertical_offset_accuracy[idx] = np.mean(accuracy)
fig = plt.figure(1)
plt.plot(offsets, horizontal_offset_accuracy, label='Horizontal')
plt.plot(offsets, vertical_offset_accuracy, label='Vertical')
plt.legend()
plt.grid(True)
plt.title('Translation invariance on LFW')
plt.xlabel('Offset [pixels]')
plt.ylabel('Accuracy')
# plt.show()
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_translation.png'))
save_result(offsets, horizontal_offset_accuracy, os.path.join(result_dir, 'invariance_translation_horizontal.txt'))
save_result(offsets, vertical_offset_accuracy, os.path.join(result_dir, 'invariance_translation_vertical.txt'))
# Run test on LFW to check accuracy for different rotation of input images
if args.nrof_angles>0:
step = 3
angles = np.asarray([x*step for x in range(-args.nrof_offsets//2+1, args.nrof_offsets//2+1)])
rotation_accuracy = [None] * len(angles)
for idx, angle in enumerate(angles):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings,
paths, actual_issame, rotate_images, angle, 60, args.orig_image_size, args.seed)
print('Angle: %1.3f Accuracy: %1.3f+-%1.3f' % (angle, np.mean(accuracy), np.std(accuracy)))
rotation_accuracy[idx] = np.mean(accuracy)
fig = plt.figure(2)
plt.plot(angles, rotation_accuracy)
plt.grid(True)
plt.title('Rotation invariance on LFW')
plt.xlabel('Angle [deg]')
plt.ylabel('Accuracy')
# plt.show()
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_rotation.png'))
save_result(angles, rotation_accuracy, os.path.join(result_dir, 'invariance_rotation.txt'))
# Run test on LFW to check accuracy for different scaling of input images
if args.nrof_scales>0:
step = 0.05
scales = np.asarray([x*step+1 for x in range(-args.nrof_offsets//2+1, args.nrof_offsets//2+1)])
scale_accuracy = [None] * len(scales)
for scale_idx, scale in enumerate(scales):
accuracy = evaluate_accuracy(sess, images_placeholder, phase_train_placeholder, image_size, embeddings,
paths, actual_issame, scale_images, scale, 60, args.orig_image_size, args.seed)
print('Scale: %1.3f Accuracy: %1.3f+-%1.3f' % (scale, np.mean(accuracy), np.std(accuracy)))
scale_accuracy[scale_idx] = np.mean(accuracy)
fig = plt.figure(3)
plt.plot(scales, scale_accuracy)
plt.grid(True)
plt.title('Scale invariance on LFW')
plt.xlabel('Scale')
plt.ylabel('Accuracy')
# plt.show()
print('Saving results in %s' % result_dir)
fig.savefig(os.path.join(result_dir, 'invariance_scale.png'))
save_result(scales, scale_accuracy, os.path.join(result_dir, 'invariance_scale.txt'))
def _main():
args = get_args()
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
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, './models/')
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
print('Loading feature extraction model')
modeldir = './models/facenet/20190310-055158'
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]
classifier_filename = './myclassifier/my_classifier.pkl'
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
print('load classifier file-> %s' % classifier_filename_exp)
video_capture = cv2.VideoCapture(0)
c = 0
print('Start Recognition!')
prevTime = 0
myYolo = YOLO(args)
while True:
ret, frame = video_capture.read()
# frame = cv2.resize(frame, (0,0), fx=0.5, fy=0.5) #resize frame (optional)
curTime = time.time() # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
#print(frame.shape[0])
#print(frame.shape[1])
image = Image.fromarray(frame)
img, bounding_boxes = myYolo.detect_image(image)
# Remove the bounding boxes with low confidence
nrof_faces = len(bounding_boxes)
## Use MTCNN to get the bounding boxes
# bounding_boxes, _ = detect_face.detect_face(frame, minsize, pnet, rnet, onet, threshold, factor)
# nrof_faces = bounding_boxes.shape[0]
#print('Detected_FaceNum: %d' % nrof_faces)
if nrof_faces > 0:
# det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
# cropped = []
# scaled = []
# scaled_reshape = []
bb = np.zeros((nrof_faces,4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = bounding_boxes[i][0]
bb[i][1] = bounding_boxes[i][1]
bb[i][2] = bounding_boxes[i][2]
bb[i][3] = bounding_boxes[i][3]
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(frame[0]) or bb[i][3] >= len(frame):
print('face is inner of range!')
continue
# cropped.append(frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :])
# cropped[0] = facenet.flip(cropped[0], False)
# scaled.append(misc.imresize(cropped[0], (image_size, image_size), interp='bilinear'))
# scaled[0] = cv2.resize(scaled[0], (input_image_size,input_image_size),
# interpolation=cv2.INTER_CUBIC)
# scaled[0] = facenet.prewhiten(scaled[0])
# scaled_reshape.append(scaled[0].reshape(-1,input_image_size,input_image_size,3))
# feed_dict = {images_placeholder: scaled_reshape[0], phase_train_placeholder: False}
cropped = (frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :])
print("{0} {1} {2} {3}".format(bb[i][0], bb[i][1], bb[i][2], bb[i][3]))
cropped = facenet.flip(cropped, False)
scaled = (misc.imresize(cropped, (image_size, image_size), interp='bilinear'))
scaled = cv2.resize(scaled, (input_image_size,input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled = facenet.prewhiten(scaled)
scaled_reshape = (scaled.reshape(-1,input_image_size,input_image_size,3))
feed_dict = {images_placeholder: scaled_reshape, phase_train_placeholder: False}
emb_array[0, :] = sess.run(embeddings, feed_dict=feed_dict)
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]
print(best_class_probabilities)
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0), 2)
text_x = bb[i][0]
text_y = bb[i][3] + 20
# for H_i in HumanNames:
# if HumanNames[best_class_indices[0]] == H_i:
result_names = class_names[best_class_indices[0]] if best_class_probabilities[0] > 0.45 else "Unknown"
#print(result_names)
cv2.putText(frame, result_names, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255), thickness=1, lineType=2)
else:
print('Unable to align')
sec = curTime - prevTime
prevTime = curTime
fps = 1 / (sec)
str = 'FPS: %2.3f' % fps
text_fps_x = len(frame[0]) - 150
text_fps_y = 20
cv2.putText(frame, str, (text_fps_x, text_fps_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), thickness=1, lineType=2)
# c+=1
cv2.imshow('Video', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
# #video writer
# out.release()
cv2.destroyAllWindows()
def job2():
print('start job2')
mode = 'TRAIN'
# data_dir = 'data_align_en'
data_dir = './video_image_align_410'
model = './models/20180408-102900'
classifier_filename = './models/classifier_align_en_final_0404_1.pkl'
use_split_dataset = False
test_data_dir = './test'
batch_size = 90
image_size = 160
seed = 666
min_nrof_images_per_class = 20
nrof_train_images_per_class = 10
with tf.Graph().as_default():
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) 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)
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
print('Calculating features for images')
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):
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)
classifier_filename_exp = os.path.expanduser(classifier_filename)
if (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 (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 identify_face(img_path):
present_ids = []
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
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)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
HumanNames = os.listdir(train_img)
HumanNames.sort()
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]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
# video_capture = cv2.VideoCapture("akshay_mov.mp4")
c = 0
print('Start Recognition!')
prevTime = 0
# ret, frame = video_capture.read()
frame = cv2.imread(img_path)
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i], (image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i], (input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
# print(best_class_indices)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
print(best_class_probabilities)
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (0, 255, 0),
2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
print('Result Indices: ', best_class_indices[0])
present_ids.append(best_class_indices[0])
print(HumanNames)
for H_i in HumanNames:
# print(H_i)
if HumanNames[best_class_indices[0]] == H_i:
result_names = HumanNames[
best_class_indices[0]]
if best_class_probabilities[0] < 0.4:
result_names = 'Unknown'
cv2.putText(frame,
result_names, (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
0.3, (0, 0, 255),
thickness=1,
lineType=2)
cv2.imwrite('./output/full-class.jpg', frame)
else:
print('Unable to align')
'''
cv2.imshow('Image', frame)
if cv2.waitKey(1000000) & 0xFF == ord('q'):
sys.exit("Thanks")
cv2.destroyAllWindows()
'''
#print(present_ids)
return present_ids
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
np.random.seed(seed=args.seed)
for sub_dir in [x[0] for x in os.walk(args.data_dir)]:
for file in os.listdir(sub_dir):
if not file.startswith(
"cropped_") and not sub_dir == args.data_dir:
print("removing ", os.path.join(str(sub_dir), file))
os.remove(os.path.join(str(sub_dir), file))
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
elif (args.mode == 'CLASSIFY_IMAGE'):
dataset = train_set
else:
dataset = facenet.get_dataset(args.data_dir)
label_names = []
for img_class in dataset:
label_names.append(img_class.name)
# 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))
print("Total number of batches: ", nrof_batches_per_epoch)
# 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)
# print("Done with batch", i)
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 = SVC(C=1, kernel='rbf', probability=True, gamma=2)
# with open("training_data.pkl",'wb') as train_file:
# pickle.dump([emb_array,labels],train_file)
with open("training_data.pkl", 'rb') as train_file:
[emb_array, labels] = pickle.load(train_file)
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))
results = np.equal(best_class_indices, labels)
for i in range(20):
print(
100 - i * 5, "percentile in failed classes",
np.percentile(best_class_probabilities[results == 0],
100 - i * 5))
print(
i * 5, "percentile in successful classes",
np.percentile(best_class_probabilities[results == 1],
i * 5))
print('Accuracy: %.3f' % accuracy)
elif (args.mode == 'CLASSIFY_IMAGE'):
with tf.Graph().as_default():
with tf.Session() as sess:
# Load the model
print('Loading feature extraction model')
facenet.load_model(args.model)
for i in range(15):
print(
classify_image_by_URL(
input("Enter URL of image to classify\n"),
args, sess))
def main(args):
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False)) as sess:
# Read the file containing the pairs used for testing
if args.lfw_pairs == None:
paths, actual_issame = crossFire(getImages(os.path.expanduser(args.lfw_dir)))
print("Crossfire check:", len(actual_issame), "pairs to be checked.")
else:
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs)
print("Pair file check:", len(actual_issame), "pairs to be checked.")
# 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")
#image_size = images_placeholder.get_shape()[1] # For some reason this doesn't work for frozen graphs
image_size = args.image_size
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Runnning forward pass on LFW images')
batch_size = args.lfw_batch_size
nrof_images = len(paths)
nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches):
print('Compute batch:', i, '/', nrof_batches, end='\r')
start_index = i*batch_size
end_index = min((i+1)*batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data2(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()
print('--- Evaluate ---')
tpr, fpr, accuracy, bestThreshold, minThreshold, maxThreshold, val, val_std, far, thresholdAtVal = lfw.evaluate(emb_array,
actual_issame, nrof_folds=args.lfw_nrof_folds)
print()
print('--- Verify using Euclidian distance ---')
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
#print('Accuracy array:', accuracy)
print('Best threshold: %1.3f' % bestThreshold)
print('Minimal threshold of hit rate @ 100%%: %1.3f' % minThreshold)
print('Maximum threshold of false alarm rate @ 0%%: %1.3f' % maxThreshold)
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
print('Threshold @ %1.3f' % thresholdAtVal)
auc = metrics.auc(fpr, tpr)
# plt.clf()
# plt.plot(fpr, tpr, '.')
# plt.savefig('euclidian_distance_auc.jpg')
print('Area Under Curve (AUC): %1.3f' % auc)
eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.)
print('Equal Error Rate (EER): %1.3f' % eer)
tpr, fpr, accuracy, bestThreshold, minThreshold, maxThreshold, val, val_std, far, thresholdAtVal = lfw.evaluate(emb_array,
actual_issame, nrof_folds=args.lfw_nrof_folds, distance_metric=1)
print()
print("--- Verify using Cosine Similarity ---")
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
#print('Accuracy array:', accuracy)
print('Best threshold: %1.3f' % bestThreshold)
print('Minimal threshold of hit rate @ 100%%: %1.3f' % minThreshold)
print('Maximum threshold of false alarm rate @ 0%%: %1.3f' % maxThreshold)
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
print('Threshold @ %1.3f' % thresholdAtVal)
auc = metrics.auc(fpr, tpr)
# plt.clf()
# plt.plot(fpr, tpr, '.')
# plt.savefig('cosine_similarity_auc.jpg')
print('Area Under Curve (AUC): %1.3f' % auc)
eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.)
print('Equal Error Rate (EER): %1.3f' % eer)
import matplotlib.pyplot as plt
# def realtime_recognition():
minsize = 20
threshold = [0.6, 0.7, 0.7]
factor = 0.709
image_size = 160
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, None)
print('Loading feature extraction model')
facenet.load_model('/home/wjc/Documents/code/face_test/models')
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]
classifier_filename_exp = os.path.expanduser('new_models.pkl')
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
print(class_names)
print('Loaded classifier model from file "%s"' %
classifier_filename_exp)
def __init__(self):
self.sess = tf.Session()
with self.sess.as_default():
facenet.load_model(facenet_model_checkpoint)
def main():
model = "20190128-123456/3001w-train.pb"
pairs = lfw.read_pairs('../database/npairs.txt')
paths, actual_issame = lfw.get_paths('F:/aface-clean-rename2', pairs)
true_pairs = []
false_pairs = []
with tf.Graph().as_default():
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))
with sess.as_default():
# Load the 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")
for i in range(len(pairs)):
print(paths[2 * i])
img1 = cv2.imread(paths[2 * i])
img2 = cv2.imread(paths[2 * i + 1])
frame1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
frame2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
f1 = []
f2 = []
prewhitened1 = facenet.prewhiten(frame1)
f1.append(prewhitened1)
prewhitened2 = facenet.prewhiten(frame2)
f2.append(prewhitened2)
feed_dict = {
images_placeholder: f1,
phase_train_placeholder: False
}
emb1 = sess.run(embeddings, feed_dict=feed_dict)
feed_dict = {
images_placeholder: f2,
phase_train_placeholder: False
}
emb2 = sess.run(embeddings, feed_dict=feed_dict)
sim = dot(emb1, emb2.T)
sim = sim * 0.5 + 0.5
if actual_issame[i] == True:
true_pairs.append(sim)
else:
false_pairs.append(sim)
thresholds = np.arange(0, 1, 0.01)
total_ratelist = []
total_rightnum = 0
total_rightnum2 = 0
f = open('../database/restlt.txt', 'w')
f.truncate()
for threshold in thresholds:
# print(threshold)
true_num = 0
false_num = 0
for i in range(len(true_pairs)):
if float(true_pairs[i]) > threshold:
true_num = true_num + 1
for j in range(len(false_pairs)):
if float(false_pairs[j]) < threshold:
false_num = false_num + 1
if (true_num + false_num) >= total_rightnum2:
total_rightnum2 = true_num + false_num
print(total_rightnum2)
print(threshold, ':',
format(float(total_rightnum2) / float(len(pairs)), '.4f'))
total_rightnum = true_num + false_num
f.writelines([
str(threshold), ' ',
str(format(float(total_rightnum) / float(len(pairs)), '.4f')), '\n'
])
f.close()
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])
pnet, rnet, onet = align.detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 183
input_image_size = 160
HumanNames = os.listdir(train_img)
HumanNames.sort()
print('Loading Modal')
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]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
video_capture = cv2.VideoCapture(1)
c = 0
print('Start Recognition')
def face_detection(image_path, thresh_hold):
dist = []
name_tmp = []
Emb_data = []
image_tmp = []
minsize = 20
with tf.Graph().as_default():
with tf.Session() as sess:
#print('开始加载模型')
# Load the model
model_checkpoint_path = 'model_check_point/20180408-102900'
facenet.load_model(model_checkpoint_path)
#print('建立facenet embedding模型')
# 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")
#print('模型建立完毕！')
#print('载入人脸库>>>>>>>>')
#start_time = time.time()
for items in os.listdir(pic_store):
emb_data1 = []
name_tmp.append(items)
images_tmp, count, pnet, rnet, onet = load_and_align_data(
items, 160, 44, 1.0)
for i in range(9):
emb_data = sess.run(embeddings,
feed_dict={
images_placeholder: images_tmp,
phase_train_placeholder: False
})
emb_data = emb_data.sum(axis=0)
emb_data1.append(emb_data)
emb_data1 = np.array(emb_data1)
emb_data = emb_data1.sum(axis=0)
Emb_data.append(np.true_divide(emb_data, 9 * count))
#print(len(Emb_data))
#print('-'*50)
#nrof_images = len(name_tmp)
for filename in os.listdir(image_path):
frame = cv2.imread(image_path + filename)
print('image {}'.format(image_path + filename))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if gray.ndim == 2:
img = to_rgb(gray)
bounding_boxes, _ = detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold, factor)
if len(bounding_boxes) < 1:
#print('nobody appears :0')
return
else:
img_size = np.asarray(frame.shape)[0:2]
#nrof_faces = bounding_boxes.shape[0]#一张图中的人脸数目
#print('找到人脸数目为：{}'.format(nrof_faces))
dist_matrix = np.zeros((1, 2))
#print(dist_matrix.shape)
for item, face_position in enumerate(bounding_boxes):
#print('*'*50)
face_position = face_position.astype(int) # 人脸的位置
#print((int(face_position[0]), int( face_position[1])))
det = np.squeeze(bounding_boxes[item, 0:4])
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - 44 / 2, 0)
bb[1] = np.maximum(det[1] - 44 / 2, 0)
bb[2] = np.minimum(det[2] + 44 / 2, img_size[1])
bb[3] = np.minimum(det[3] + 44 / 2, img_size[0])
cropped = frame[bb[1]:bb[3], bb[0]:bb[2], :]
aligned = misc.imresize(cropped,
(image_size, image_size),
interp='bilinear') #裁剪人脸在图像中
prewhitened = facenet.prewhiten(
aligned) #利用facenet进行矩阵对比
image_tmp.append(prewhitened)
image = np.stack(image_tmp)
emb_data = sess.run(embeddings,
feed_dict={
images_placeholder: image,
phase_train_placeholder: False
})
image_tmp.pop()
for i in range(len(Emb_data)):
dist.append(
np.sqrt(
np.sum(
np.square(
np.subtract(
emb_data[len(emb_data) - 1, :],
Emb_data[i])))))
dist_np = np.array(dist)
dist_np = dist_np.reshape((1, len(Emb_data)))
#print(dist_np)
dist_matrix = np.concatenate((dist_matrix, dist_np),
axis=0)
dist = []
dist_matrix = np.delete(dist_matrix, 0, axis=0)
min_index = np.argmin(dist_matrix,
axis=0).tolist() # [2,2]
min_arg = np.min(
dist_matrix,
axis=0).tolist() # [0.66275054 0.91318572]
#start_time = time.time()
if min(min_arg) > thresh_hold:
print('i dont know this man')
elif max(min_arg) < thresh_hold:
if min_index[0] == min_index[1]:
a = min_arg.index(min(min_arg))
print('he is {}'.format(a + 1))
else:
print('they are 1 and 2')
else:
b = min_arg.index(min(min_arg))
print('he is {}'.format(b + 1))
#print('time is {}'.format(time.time()-start_time))
print('*' * 50)
from sklearn.svm import SVC
with tf.Graph().as_default():
with tf.Session() as sess:
datadir = './output/'
dataset = facenet.get_dataset(datadir)
paths, labels = facenet.get_image_paths_and_labels(dataset)
print('Number of classes: %d' % len(dataset))
print('Number of images: %d' % len(paths))
print('Loading feature extraction model')
modeldir = './models/facenet/20190310-055158'
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 = 1000
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):
start_index = i * batch_size
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--path',
help='Path of the video you want to test on.',
default=0)
args = parser.parse_args()
MINSIZE = 20
THRESHOLD = [0.6, 0.7, 0.7]
FACTOR = 0.709
IMAGE_SIZE = 182
INPUT_IMAGE_SIZE = 160
CLASSIFIER_PATH = 'Models/facemodel.pkl'
VIDEO_PATH = args.path
FACENET_MODEL_PATH = 'Models/20180402-114759.pb'
# Load The Custom Classifier
with open(CLASSIFIER_PATH, 'rb') as file:
model, class_names = pickle.load(file)
print("Custom Classifier, Successfully loaded")
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
# Load the model
print('Loading feature extraction model')
facenet.load_model(FACENET_MODEL_PATH)
# 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]
pnet, rnet, onet = align.detect_face.create_mtcnn(
sess, "src/align")
people_detected = set()
person_detected = collections.Counter()
cap = VideoStream(src=0).start()
while (True):
frame = cap.read()
frame = imutils.resize(frame, width=600)
frame = cv2.flip(frame, 1)
bounding_boxes, _ = align.detect_face.detect_face(
frame, MINSIZE, pnet, rnet, onet, THRESHOLD, FACTOR)
faces_found = bounding_boxes.shape[0]
try:
if faces_found > 1:
cv2.putText(frame,
"Only one face", (0, 100),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 255, 255),
thickness=1,
lineType=2)
elif faces_found > 0:
det = bounding_boxes[:, 0:4]
bb = np.zeros((faces_found, 4), dtype=np.int32)
for i in range(faces_found):
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
print(bb[i][3] - bb[i][1])
print(frame.shape[0])
print((bb[i][3] - bb[i][1]) / frame.shape[0])
if (bb[i][3] - bb[i][1]) / frame.shape[0] > 0.25:
cropped = frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :]
scaled = cv2.resize(
cropped,
(INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE),
interpolation=cv2.INTER_CUBIC)
scaled = facenet.prewhiten(scaled)
scaled_reshape = scaled.reshape(
-1, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, 3)
feed_dict = {
images_placeholder: scaled_reshape,
phase_train_placeholder: False
}
emb_array = sess.run(embeddings,
feed_dict=feed_dict)
print(emb_array.shape)
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]
best_name = class_names[best_class_indices[0]]
print("Name: {}, Probability: {}".format(
best_name, best_class_probabilities))
if best_class_probabilities > 0.8:
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]),
(0, 255, 0), 2)
text_x = bb[i][0]
text_y = bb[i][3] + 20
name = class_names[best_class_indices[0]]
cv2.putText(frame,
name, (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 255, 255),
thickness=1,
lineType=2)
cv2.putText(
frame,
str(
round(best_class_probabilities[0],
3)), (text_x, text_y + 17),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (255, 255, 255),
thickness=1,
lineType=2)
person_detected[best_name] += 1
else:
name = "Unknown"
except:
pass
cv2.imshow('Face Recognition', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()