Foreword
introduced in the previous blog, how to use dlib calibration Face (python dlib learning (a): Face Detection), feature extraction 68 points (python dlib Learning (II): facial feature point calibration). This time to work on the basis of the two above, the information extracted into the face of a 128-dimensional vector space. In this vector space, the same person's face closer, farther from the different face. Measurement using Euclidean distance, Euclidean distance calculation is not complicated.
Two-dimensional case:
Distance = (X1-X2) 2+ (Y1-Y2) 2 ------------------ √
Distance = (X1-X2) 2+ (Y1 -y2) 2
Three-dimensional case:
Distance = (X1-X2) 2+ (Y1-Y2) 2+ (Z1-Z2) 2 ------------------------ √ ----
Distance = (X1-X2) 2+ (Y1-Y2) 2+ (Z1-Z2) 2
The case where it can be extended to 128 dimensions.
Judging threshold commonly used is 0.6, that is, if the Euclidean distance vector space of two human faces than 0.6, that is not the same person identified; if the Euclidean distance is less than 0.6, it is considered to be the same person. This distance can also be determined by your own, as long as the effect is better.
Experiments using two models:
shape_predictor_68_face_landmarks.dat：
http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
dlib_face_recognition_resnet_model_v1.dat:
http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2
Folder Contents:
Both models folder on the model, the test on the faces in the picture, just at a few pictures himself on the line.
Complete engineering Download Link:
http://pan.baidu.com/s/1boCDZ7T
1 program
not talk nonsense, directly on the code.
# -*- coding: utf-8 -*-
import sys
import dlib
import cv2
import os
import glob
current_path = os.getcwd () # Get the current path
# model path
predictor_path current_path + = "\\ \\ shape_predictor_68_face_landmarks.dat Model"
face_rec_model_path current_path + = "\\ \\ dlib_face_recognition_resnet_model_v1.dat Model"
# test image path
faces_folder_path = current_path + "\\ faces \\"
# 读入模型
detector = dlib.get_frontal_face_detector()
shape_predictor = dlib.shape_predictor(predictor_path)
face_rec_model = dlib.face_recognition_model_v1(face_rec_model_path)
img_path in glob.glob, and for (the os.path.join (faces_folder_path, "* .jpg")):
Print ( "Processing File: {}." the format (img_path))
# OpenCV read the image, and displays
img = cv2. imread (img_path, cv2.IMREAD_COLOR)
# OpenCV format image is converted into a bgr rgb format
B, G, R & lt cv2.split = (IMG)
IMG2 cv2.merge = ([R & lt, G, B])
dets = detector (img, 1) # face calibration
print ( "Number of faces detected: {}". format (len (dets)))
for index, face in enumerate(dets):
print('face {}; left {}; top {}; right {}; bottom {}'.format(index, face.left(), face.top(), face.right(), face.bottom()))
shape = shape_predictor(img2, face) # 提取68个特征点
for i, pt in enumerate(shape.parts()):
#print('Part {}: {}'.format(i, pt))
pt_pos = (pt.x, pt.y)
cv2.circle(img, pt_pos, 2, (255, 0, 0), 1)
#print(type(pt))
#print("Part 0: {}, Part 1: {} ...".format(shape.part(0), shape.part(1)))
cv2.namedWindow(img_path+str(index), cv2.WINDOW_AUTOSIZE)
cv2.imshow(img_path+str(index), img)
face_descriptor = face_rec_model.compute_face_descriptor (img2, shape) # 128 calculates a face-dimensional vector
print (face_descriptor)
cv2.waitKey = K (0)
cv2.destroyAllWindows ()
. 1
2
. 3
. 4
. 5
. 6
. 7
. 8
. 9
10
. 11
12 is
13 is
14
15
16
. 17
18 is
. 19
20 is
21 is
22 is
23 is
24
25
26 is
27
28
29
30
31 is
32
33 is
34 is
35
36
37 [
38 is
39
40
41 is
42 is
43 is
44 is
45
46 is
47
48
49
procedure 1 The results
Part of the printed results:
F.: \ The Python \ my_dlib_codes \ face_recognition> Python my_face_recogniton.py
Processing File: F.: \ The Python \ my_dlib_codes \ face_recognition \ Faces \ jobs.jpg
Number The Detected Faces of:. 1
face 0; left 184; Top 64; 339 right; bottom 219
-0.179784
0.15487
0.10509
-0.0973604
-0.19153
0.000418252
-0.0357536
-0.0206766
0.129741
-0.0628359
....
. 1
2
. 3
. 4
. 5
. 6
. 7
. 8
. 9
10
. 11
12 is
13 is
14
15
behind the pile on the face in the figure is 128-dimensional vector space value.
2 program
in front of just test it, the use of value to those who ask to. Here I packaged a little, to achieve than functional. Did not add much stuff, so I do not do a repeat.
# -*- coding: utf-8 -*-
import sys
import dlib
import cv2
import os
import glob
import numpy as np
def comparePersonData(data1, data2):
diff = 0
# for v1, v2 in data1, data2:
# diff += (v1 - v2)**2
for i in xrange(len(data1)):
diff += (data1[i] - data2[i])**2
diff = np.sqrt(diff)
print diff
if(diff < 0.6):
print "It's the same person"
else:
print "It's not the same person"
def savePersonData(face_rec_class, face_descriptor):
if face_rec_class.name == None or face_descriptor == None:
return
filePath = face_rec_class.dataPath + face_rec_class.name + '.npy'
vectors = np.array([])
for i, num in enumerate(face_descriptor):
vectors = np.append(vectors, num)
# print(num)
print('Saving files to :'+filePath)
np.save(filePath, vectors)
return vectors
def loadPersonData(face_rec_class, personName):
if personName == None:
return
filePath = face_rec_class.dataPath + personName + '.npy'
vectors = np.load(filePath)
print(vectors)
return vectors
class face_recognition(object):
def __init__(self):
self.current_path = os.getcwd() # 获取当前路径
self.predictor_path = self.current_path + "\\model\\shape_predictor_68_face_landmarks.dat"
self.face_rec_model_path = self.current_path + "\\model\\dlib_face_recognition_resnet_model_v1.dat"
self.faces_folder_path = self.current_path + "\\faces\\"
self.dataPath = self.current_path + "\\data\\"
self.detector = dlib.get_frontal_face_detector()
self.shape_predictor = dlib.shape_predictor(self.predictor_path)
self.face_rec_model = dlib.face_recognition_model_v1(self.face_rec_model_path)
self.name = None
self.img_bgr = None
self.img_rgb = None
self.detector = dlib.get_frontal_face_detector()
self.shape_predictor = dlib.shape_predictor(self.predictor_path)
self.face_rec_model = dlib.face_recognition_model_v1(self.face_rec_model_path)
def inputPerson(self, name='people', img_path=None):
if img_path == None:
print('No file!\n')
return
+ + = Self.faces_folder_path img_name # img_name
the self.name name =
self.img_bgr = cv2.imread (self.current_path img_path +)
# OpenCV bgr the image format is converted into the format rgb
b, g, r = cv2.split ( self. img_bgr)
self.img_rgb cv2.merge = ([R & lt, G, B])
def create128DVectorSpace(self):
dets = self.detector(self.img_rgb, 1)
print("Number of faces detected: {}".format(len(dets)))
for index, face in enumerate(dets):
print('face {}; left {}; top {}; right {}; bottom {}'.format(index, face.left(), face.top(), face.right(), face.bottom()))
shape = self.shape_predictor(self.img_rgb, face)
face_descriptor = self.face_rec_model.compute_face_descriptor(self.img_rgb, shape)
# print(face_descriptor)
# for i, num in enumerate(face_descriptor):
# print(num)
# print(type(num))
return face_descriptor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61 is
62 is
63 is
64
65
66
67
68
69
70
71 is
72
73 is
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
Program 2 Results
Test Code 1:
fc face_rec AS Import
face_rec = fc.face_recognition () # create objects
face_rec.inputPerson (name = 'jobs', img_path = '\\ faces \\ jobs.jpg') # name written in the first person name, img_name as a picture name, careful to put the faces folder
vector = face_rec.create128DVectorSpace extracted 128-dimensional vector () #, dlib.vector object classes
stored person_data1 = fc.savePersonData (face_rec, vector) # the extracted data to a data file folder, to facilitate the operation returns numpy array, or the same content
# Import second image, and extracts a feature vector
face_rec.inputPerson (name = 'jobs2', img_path = '\\ \\ jobs2.jpg Faces')
Vector face_rec.create128DVectorSpace = () # 128-dimensional vector extraction is dlib. Object class vector
person_data2 = fc.savePersonData (face_rec, vector)
# Euclidean distance calculation to determine whether the same person
fc.comparePersonData (person_data1, person_data2)
. 1
2
. 3
. 4
. 5
. 6
. 7
. 8
. 9
10
. 11
12 is
13 is
if the data folder already model files, can be imported directly:
fc face_rec AS Import
face_rec = fc.face_recognition () # create the object
person_data1 = fc.loadPersonData (face_rec, 'jobs ') # save the information to create a class, but also to keep up with the names behind the program will look for the corresponding npy in the data file files, such as this is 'jobs.npy'
person_data2 = fc.loadPersonData (face_rec, 'jobs2') introduced into the second picture #
fc.comparePersonData (person_data1, person_data2) # calculate Euclidean distance, determines whether or not the same person
. 1
2
. 3
. 4
5
program 2 results
the Python 2.7.10 | Anaconda 2.3.0 ( 'bit-64) | (default, On May 28, 2015, 16:44:52) [v.1500 the MSC 64' bit (the AMD64)] ON Win32
the Type "Help", "Copyright", "Credits" or "License" for More Information.
Anaconda IS Brought to you by Continuum Analytics.
Please the Check OUT: http://continuum.io/thanks and https://binstar.org
>>> import face_rec as fc
>>> face_rec = fc.face_recognition()
>>> face_rec.inputPerson(name='jobs', img_path='\\faces\\jobs.jpg')
>>> vector = face_rec.create128DVectorSpace()
Number of faces detected: 1
face 0; left 184; top 64; right 339; bottom 219
>>> person_data1 = fc.savePersonData(face_rec, vector )
Saving files to :F:\Python\my_dlib_codes\face_recognition\data\jobs.npy
>>> face_rec.inputPerson(name='jobs2', img_path='\\faces\\jobs2.jpg')
>>> vector = face_rec.create128DVectorSpace()
Number of faces detected: 1
face 0; left 124; top 39; right 253; bottom 168
>>> person_data2 = fc.savePersonData(face_rec, vector )
Saving files to :F:\Python\my_dlib_codes\face_recognition\data\jobs2.npy
>>> fc.comparePersonData(person_data1, person_data2)
0.490491048429
It's the same person
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
官方例程
#!/usr/bin/python
# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
#
# This example shows how to use dlib's face recognition tool. This tool maps
# an image of a human face to a 128 dimensional vector space where images of
# the same person are near to each other and images from different people are
# far apart. Therefore, you can perform face recognition by mapping faces to
# the 128D space and then checking if their Euclidean distance is small
# enough.
#
# When using a distance threshold of 0.6, the dlib model obtains an accuracy
# of 99.38% on the standard LFW face recognition benchmark, which is
# comparable to other state-of-the-art methods for face recognition as of
# February 2017. This accuracy means that, when presented with a pair of face
# images, the tool will correctly identify if the pair belongs to the same
# person or is from different people 99.38% of the time.
#
# Finally, for an in-depth discussion of how dlib's tool works you should
# refer to the C++ example program dnn_face_recognition_ex.cpp and the
# attendant documentation referenced therein.
#
#
#
#
# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE
# You can install dlib using the command:
# pip install dlib
#
# Alternatively, if you want to compile dlib yourself then go into the dlib
# root folder and run:
# python setup.py install
# or
# python setup.py install --yes USE_AVX_INSTRUCTIONS
# if you have a CPU that supports AVX instructions, since this makes some
# things run faster. This code will also use CUDA if you have CUDA and cuDNN
# installed.
#
# Compiling dlib should work on any operating system so long as you have
# CMake and boost-python installed. On Ubuntu, this can be done easily by
# running the command:
# sudo apt-get install libboost-python-dev cmake
#
# Also note that this example requires scikit-image which can be installed
# via the command:
# pip install scikit-image
# Or downloaded from http://scikit-image.org/download.html.
import sys
import os
import dlib
import glob
from skimage import io
if len(sys.argv) != 4:
print(
"Call this program like this:\n"
" ./face_recognition.py shape_predictor_68_face_landmarks.dat dlib_face_recognition_resnet_model_v1.dat ../examples/faces\n"
"You can download a trained facial shape predictor and recognition model from:\n"
" http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2\n"
" http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2")
exit()
predictor_path = sys.argv[1]
face_rec_model_path = sys.argv[2]
faces_folder_path = sys.argv[3]
# Load all the models we need: a detector to find the faces, a shape predictor
# to find face landmarks so we can precisely localize the face, and finally the
# face recognition model.
detector = dlib.get_frontal_face_detector()
sp = dlib.shape_predictor(predictor_path)
facerec = dlib.face_recognition_model_v1(face_rec_model_path)
win = dlib.image_window ()
# Now process all the images
for f in glob.glob(os.path.join(faces_folder_path, "*.jpg")):
print("Processing file: {}".format(f))
img = io.imread(f)
win.clear_overlay()
win.set_image(img)
# Ask the detector to find the bounding boxes of each face. The 1 in the
# second argument indicates that we should upsample the image 1 time. This
# will make everything bigger and allow us to detect more faces.
dets = detector(img, 1)
print("Number of faces detected: {}".format(len(dets)))
# Now process each face we found.
for k, d in enumerate(dets):
print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format(
k, d.left(), d.top(), d.right(), d.bottom()))
# Get the landmarks/parts for the face in box d.
shape = sp(img, d)
# Draw the face landmarks on the screen so we can see what face is currently being processed.
win.clear_overlay()
win.add_overlay(d)
win.add_overlay(shape)
# Compute the 128D vector that describes the face in img identified by
# shape. In general, if two face descriptor vectors have a Euclidean
# distance between them less than 0.6 then they are from the same
# person, otherwise they are from different people. Here we just print
# the vector to the screen.
face_descriptor = facerec.compute_face_descriptor(img, shape)
print(face_descriptor)
# It should also be noted that you can also call this function like this:
# face_descriptor = facerec.compute_face_descriptor(img, shape, 100)
# The version of the call without the 100 gets 99.13% accuracy on LFW
# while the version with 100 gets 99.38%. However, the 100 makes the
# call 100x slower to execute, so choose whatever version you like. To
# explain a little, the 3rd argument tells the code how many times to
# jitter/resample the image. When you set it to 100 it executes the
# face descriptor extraction 100 times on slightly modified versions of
# the face and returns the average result. You could also pick a more
# middle value, such as 10, which is only 10x slower but still gets an
# LFW accuracy of 99.3%.
dlib.hit_enter_to_continue ()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
1 16
117
1 18
119
120
121
122
tucao:
dlib is very convenient, without spending much time will be able to do some of their intended function. Official documents said very detailed, very easy to get started. Look at this document (dlib python api) almost able to learn to use. Tutor has arranged for postgraduate study task, but also busy back up. While I was learning dlib October before opening the pit, in order to finish the job I have finished sorting these things as soon as possible. Later to return to the "bubble building" life.
Original link: https: //blog.csdn.net/hongbin_xu/article/details/78390982