如何用 OpenCV、Python 和深度学习实现面部识别？

$ workon # optional
$ pip install dlib

$ workon <your env name here> # optional
$ git clone https://github.com/davisking/dlib.git
$ cd dlib
$ mkdir build
$ cd build
$ cmake .. -DUSE_AVX_INSTRUCTIONS=1
$ cmake --build .
$ cd ..
$ python setup.py install --yes USE_AVX_INSTRUCTIONS

$ workon <your env name here> # optional
$ git clone https://github.com/davisking/dlib.git
$ cd dlib
$ mkdir build
$ cd build
$ cmake .. -DDLIB_USE_CUDA=1 -DUSE_AVX_INSTRUCTIONS=1
$ cmake --build .
$ cd ..
$ python setup.py install --yes USE_AVX_INSTRUCTIONS --yes DLIB_USE_CUDA

$ workon <your env name here> # optional
$ pip install face_recognition

$ workon <your env name here> # optional
$ pip install imutils

$ tree --filelimit 10 --dirsfirst
.
├── dataset
│   ├── alan_grant [22 entries]
│   ├── claire_dearing [53 entries]
│   ├── ellie_sattler [31 entries]
│   ├── ian_malcolm [41 entries]
│   ├── john_hammond [36 entries]
│   └── owen_grady [35 entries]
├── examples
│   ├── example_01.png
│   ├── example_02.png
│   └── example_03.png
├── output
│   └── lunch_scene_output.avi
├── videos
│   └── lunch_scene.mp4
├── search_bing_api.py
├── encode_faces.py
├── recognize_faces_image.py
├── recognize_faces_video.py
├── recognize_faces_video_file.py
└── encodings.pickle

10 directories, 11 files

1# import the necessary packages
2from imutils import paths
3import face_recognition
4import argparse
5import pickle
6import cv2
7import os

1# construct the argument parser and parse the arguments
2ap = argparse.ArgumentParser()
3ap.add_argument("-i", "--dataset", required=True,
4    help="path to input directory of faces + images")
5ap.add_argument("-e", "--encodings", required=True,
6    help="path to serialized db of facial encodings")
7ap.add_argument("-d", "--detection-method", type=str, default="cnn",
8    help="face detection model to use: either `hog` or `cnn`")
9args = vars(ap.parse_args())

1# grab the paths to the input images in our dataset
2print("[INFO] quantifying faces...")
3imagePaths = list(paths.list_images(args["dataset"]))
4
5# initialize the list of known encodings and known names
6knownEncodings = []
7knownNames = []

 1# loop over the image paths
 2for (i, imagePath) in enumerate(imagePaths):
 3    # extract the person name from the image path
 4    print("[INFO] processing image {}/{}".format(i + 1,
 5        len(imagePaths)))
 6    name = imagePath.split(os.path.sep)[-2]
 7
 8    # load the input image and convert it from BGR (OpenCV ordering)
 9    # to dlib ordering (RGB)
10    image = cv2.imread(imagePath)
11    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

 1    # detect the (x, y)-coordinates of the bounding boxes
 2    # corresponding to each face in the input image
 3    boxes = face_recognition.face_locations(rgb,
 4        model=args["detection_method"])
 5
 6    # compute the facial embedding for the face
 7    encodings = face_recognition.face_encodings(rgb, boxes)
 8
 9    # loop over the encodings
10    for encoding in encodings:
11        # add each encoding + name to our set of known names and
12        # encodings
13        knownEncodings.append(encoding)
14        knownNames.append(name)

1# dump the facial encodings + names to disk
2print("[INFO] serializing encodings...")
3data = {"encodings": knownEncodings, "names": knownNames}
4f = open(args["encodings"], "wb")
5f.write(pickle.dumps(data))
6f.close()

 1$ python encode_faces.py --dataset dataset --encodings encodings.pickle
 2[INFO] quantifying faces...
 3[INFO] processing image 1/218
 4[INFO] processing image 2/218
 5[INFO] processing image 3/218
 6...
 7[INFO] processing image 216/218
 8[INFO] processing image 217/218
 9[INFO] processing image 218/218
10[INFO] serializing encodings...
11$ ls -lh encodings*
12-rw-r--r--@ 1 adrian  staff   234K May 29 13:03 encodings.pickle

 1# import the necessary packages
 2import face_recognition
 3import argparse
 4import pickle
 5import cv2
 6
 7# construct the argument parser and parse the arguments
 8ap = argparse.ArgumentParser()
 9ap.add_argument("-e", "--encodings", required=True,
10    help="path to serialized db of facial encodings")
11ap.add_argument("-i", "--image", required=True,
12    help="path to input image")
13ap.add_argument("-d", "--detection-method", type=str, default="cnn",
14    help="face detection model to use: either `hog` or `cnn`")
15args = vars(ap.parse_args())

 1# load the known faces and embeddings
 2print("[INFO] loading encodings...")
 3data = pickle.loads(open(args["encodings"], "rb").read())
 4
 5# load the input image and convert it from BGR to RGB
 6image = cv2.imread(args["image"])
 7rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
 8
 9# detect the (x, y)-coordinates of the bounding boxes corresponding
10# to each face in the input image, then compute the facial embeddings
11# for each face
12print("[INFO] recognizing faces...")
13boxes = face_recognition.face_locations(rgb,
14    model=args["detection_method"])
15encodings = face_recognition.face_encodings(rgb, boxes)
16
17# initialize the list of names for each face detected
18names = []

1# loop over the facial embeddings
2for encoding in encodings:
3    # attempt to match each face in the input image to our known
4    # encodings
5    matches = face_recognition.compare_faces(data["encodings"],
6        encoding)
7    name = "Unknown"

 1    # check to see if we have found a match
 2    if True in matches:
 3        # find the indexes of all matched faces then initialize a
 4        # dictionary to count the total number of times each face
 5        # was matched
 6        matchedIdxs = [i for (i, b) in enumerate(matches) if b]
 7        counts = {}
 8
 9        # loop over the matched indexes and maintain a count for
10        # each recognized face face
11        for i in matchedIdxs:
12            name = data["names"][i]
13            counts[name] = counts.get(name, 0) + 1
14
15        # determine the recognized face with the largest number of
16        # votes (note: in the event of an unlikely tie Python will
17        # select first entry in the dictionary)
18        name = max(counts, key=counts.get)
19
20    # update the list of names
21    names.append(name)

1(Pdb) matchedIdxs
2[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, 71, 72, 73, 74, 75]

1(Pdb) counts
2{'ian_malcolm': 40}

1(Pdb) counts
2{'alan_grant': 5}

 1# loop over the recognized faces
 2for ((top, right, bottom, left), name) in zip(boxes, names):
 3    # draw the predicted face name on the image
 4    cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
 5    y = top - 15 if top - 15 > 15 else top + 15
 6    cv2.putText(image, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
 7        0.75, (0, 255, 0), 2)
 8
 9# show the output image
10cv2.imshow("Image", image)
11cv2.waitKey(0)

1$ python recognize_faces_image.py --encodings encodings.pickle \
2    --image examples/example_01.png
3[INFO] loading encodings...
4[INFO] recognizing faces...

1$ python recognize_faces_image.py --encodings encodings.pickle \
2    --image examples/example_02.png
3[INFO] loading encodings...
4[INFO] recognizing faces...

 1# import the necessary packages
 2from imutils.video import VideoStream
 3import face_recognition
 4import argparse
 5import imutils
 6import pickle
 7import time
 8import cv2
 9
10# construct the argument parser and parse the arguments
11ap = argparse.ArgumentParser()
12ap.add_argument("-e", "--encodings", required=True,
13    help="path to serialized db of facial encodings")
14ap.add_argument("-o", "--output", type=str,
15    help="path to output video")
16ap.add_argument("-y", "--display", type=int, default=1,
17    help="whether or not to display output frame to screen")
18ap.add_argument("-d", "--detection-method", type=str, default="cnn",
19    help="face detection model to use: either `hog` or `cnn`")
20args = vars(ap.parse_args())

 1# load the known faces and embeddings
 2print("[INFO] loading encodings...")
 3data = pickle.loads(open(args["encodings"], "rb").read())
 4
 5# initialize the video stream and pointer to output video file, then
 6# allow the camera sensor to warm up
 7print("[INFO] starting video stream...")
 8vs = VideoStream(src=0).start()
 9writer = None
10time.sleep(2.0)

 1# loop over frames from the video file stream
 2while True:
 3    # grab the frame from the threaded video stream
 4    frame = vs.read()
 5
 6    # convert the input frame from BGR to RGB then resize it to have
 7    # a width of 750px (to speedup processing)
 8    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 9    rgb = imutils.resize(frame, width=750)
10    r = frame.shape[1] / float(rgb.shape[1])
11
12    # detect the (x, y)-coordinates of the bounding boxes
13    # corresponding to each face in the input frame, then compute
14    # the facial embeddings for each face
15    boxes = face_recognition.face_locations(rgb,
16        model=args["detection_method"])
17    encodings = face_recognition.face_encodings(rgb, boxes)
18    names = []

 1    # loop over the facial embeddings
 2    for encoding in encodings:
 3        # attempt to match each face in the input image to our known
 4        # encodings
 5        matches = face_recognition.compare_faces(data["encodings"],
 6            encoding)
 7        name = "Unknown"
 8
 9        # check to see if we have found a match
10        if True in matches:
11            # find the indexes of all matched faces then initialize a
12            # dictionary to count the total number of times each face
13            # was matched
14            matchedIdxs = [i for (i, b) in enumerate(matches) if b]
15            counts = {}
16
17            # loop over the matched indexes and maintain a count for
18            # each recognized face face
19            for i in matchedIdxs:
20                name = data["names"][i]
21                counts[name] = counts.get(name, 0) + 1
22
23            # determine the recognized face with the largest number
24            # of votes (note: in the event of an unlikely tie Python
25            # will select first entry in the dictionary)
26            name = max(counts, key=counts.get)
27
28        # update the list of names
29        names.append(name)

 1    # loop over the recognized faces
 2    for ((top, right, bottom, left), name) in zip(boxes, names):
 3        # rescale the face coordinates
 4        top = int(top * r)
 5        right = int(right * r)
 6        bottom = int(bottom * r)
 7        left = int(left * r)
 8
 9        # draw the predicted face name on the image
10        cv2.rectangle(frame, (left, top), (right, bottom),
11            (0, 255, 0), 2)
12        y = top - 15 if top - 15 > 15 else top + 15
13        cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
14            0.75, (0, 255, 0), 2)

 1    # if the video writer is None *AND* we are supposed to write
 2    # the output video to disk initialize the writer
 3    if writer is None and args["output"] is not None:
 4        fourcc = cv2.VideoWriter_fourcc(*"MJPG")
 5        writer = cv2.VideoWriter(args["output"], fourcc, 20,
 6            (frame.shape[1], frame.shape[0]), True)
 7
 8    # if the writer is not None, write the frame with recognized
 9    # faces t odisk
10    if writer is not None:
11        writer.write(frame)

1    # check to see if we are supposed to display the output frame to
2    # the screen
3    if args["display"] > 0:
4        cv2.imshow("Frame", frame)
5        key = cv2.waitKey(1) & 0xFF
6
7        # if the `q` key was pressed, break from the loop
8        if key == ord("q"):
9            break

1# do a bit of cleanup
2cv2.destroyAllWindows()
3vs.stop()
4
5# check to see if the video writer point needs to be released
6if writer is not None:
7    writer.release()

1$ python recognize_faces_video.py --encodings encodings.pickle \
2    --output output/webcam_face_recognition_output.avi --display 1
3[INFO] loading encodings...
4[INFO] starting video stream...

1$ python recognize_faces_video_file.py --encodings encodings.pickle \
2    --input videos/lunch_scene.mp4 --output output/lunch_scene_output.avi \
3    --display 0