使用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--filelimit10 --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

# import the necessary packages

from imutilsimport paths

import face_recognition

import argparse

import pickle

import cv2

import os

# construct the argument parser and parse the arguments

ap= argparse.ArgumentParser()

ap.add_argument("-i","--dataset", required=True,

    help="path to input directory of faces + images")

ap.add_argument("-e","--encodings", required=True,

    help="path to serialized db of facial encodings")

ap.add_argument("-d","--detection-method",type=str, default="cnn",

    help="face detection model to use: either `hog` or `cnn`")

args= vars(ap.parse_args())

# grab the paths to the input images in our dataset

print("[INFO] quantifying faces...")

imagePaths= list(paths.list_images(args["dataset"]))

# initialize the list of known encodings and known names

knownEncodings= []

knownNames= []

# loop over the image paths

for (i, imagePath)in enumerate(imagePaths):

    # extract the person name from the image path

    print("[INFO] processing image {}/{}".format(i+ 1,

        len(imagePaths)))

    name= imagePath.split(os.path.sep)[-2]

    # load the input image and convert it from BGR (OpenCV ordering)

    # to dlib ordering (RGB)

    image= cv2.imread(imagePath)

    rgb= cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# detect the (x, y)-coordinates of the bounding boxes

# corresponding to each face in the input image

boxes= face_recognition.face_locations(rgb,

    model=args["detection_method"])

# compute the facial embedding for the face

encodings= face_recognition.face_encodings(rgb, boxes)

# loop over the encodings

for encodingin encodings:

    # add each encoding + name to our set of known names and

    # encodings

    knownEncodings.append(encoding)

    knownNames.append(name)

# dump the facial encodings + names to disk

print("[INFO] serializing encodings...")

data= {"encodings": knownEncodings,"names": knownNames}

f= open(args["encodings"],"wb")

f.write(pickle.dumps(data))

f.close()

$ python encode_faces.py--dataset dataset--encodings encodings.pickle

[INFO] quantifying faces...

[INFO] processing image1/218

[INFO] processing image2/218

[INFO] processing image3/218

...

[INFO] processing image216/218

[INFO] processing image217/218

[INFO] processing image218/218

[INFO] serializing encodings...

$ ls-lh encodings*

-rw-r--r--@1 adrian  staff  234K May29 13:03 encodings.pickle

# import the necessary packages

import face_recognition

import argparse

import pickle

import cv2

# construct the argument parser and parse the arguments

ap= argparse.ArgumentParser()

ap.add_argument("-e","--encodings", required=True,

    help="path to serialized db of facial encodings")

ap.add_argument("-i","--image", required=True,

    help="path to input image")

ap.add_argument("-d","--detection-method",type=str, default="cnn",

    help="face detection model to use: either `hog` or `cnn`")

args= vars(ap.parse_args())

# load the known faces and embeddings

print("[INFO] loading encodings...")

data= pickle.loads(open(args["encodings"],"rb").read())

# load the input image and convert it from BGR to RGB

image= cv2.imread(args["image"])

rgb= cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# detect the (x, y)-coordinates of the bounding boxes corresponding

# to each face in the input image, then compute the facial embeddings

# for each face

print("[INFO] recognizing faces...")

boxes= face_recognition.face_locations(rgb,

    model=args["detection_method"])

encodings= face_recognition.face_encodings(rgb, boxes)

# initialize the list of names for each face detected

names= []

# loop over the facial embeddings

for encodingin encodings:

    # attempt to match each face in the input image to our known

    # encodings

    matches= face_recognition.compare_faces(data["encodings"],

        encoding)

    name= "Unknown"

# check to see if we have found a match

if True in matches:

    # find the indexes of all matched faces then initialize a

    # dictionary to count the total number of times each face

    # was matched

    matchedIdxs= [ifor (i, b)in enumerate(matches)if b]

    counts= {}

    # loop over the matched indexes and maintain a count for

    # each recognized face face

    for iin matchedIdxs:

        name= data["names"][i]

        counts[name]= counts.get(name,0)+ 1

    # determine the recognized face with the largest number of

    # votes (note: in the event of an unlikely tie Python will

    # select first entry in the dictionary)

    name= max(counts, key=counts.get)

# update the list of names

names.append(name)

(Pdb) matchedIdxs

[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]

(Pdb) counts

{'ian_malcolm':40}

(Pdb) counts

{'alan_grant':5}

# loop over the recognized faces

for ((top, right, bottom, left), name)in zip(boxes, names):

    # draw the predicted face name on the image

    cv2.rectangle(image, (left, top), (right, bottom), (0,255,0),2)

    y= top- 15 if top- 15 >15 else top+ 15

    cv2.putText(image, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,

        0.75, (0,255,0),2)

# show the output image

cv2.imshow("Image", image)

cv2.waitKey(0)

$ python recognize_faces_image.py--encodings encodings.pickle \

    --image examples/example_01.png

[INFO] loading encodings...

[INFO] recognizing faces...

$ python recognize_faces_image.py--encodings encodings.pickle \

    --image examples/example_02.png

[INFO] loading encodings...

[INFO] recognizing faces...

# import the necessary packages

from imutils.videoimport VideoStream

import face_recognition

import argparse

import imutils

import pickle

import time

import cv2

# construct the argument parser and parse the arguments

ap= argparse.ArgumentParser()

ap.add_argument("-e","--encodings", required=True,

    help="path to serialized db of facial encodings")

ap.add_argument("-o","--output",type=str,

    help="path to output video")

ap.add_argument("-y","--display",type=int, default=1,

    help="whether or not to display output frame to screen")

ap.add_argument("-d","--detection-method",type=str, default="cnn",

    help="face detection model to use: either `hog` or `cnn`")

args= vars(ap.parse_args())

# load the known faces and embeddings

print("[INFO] loading encodings...")

data= pickle.loads(open(args["encodings"],"rb").read())

# initialize the video stream and pointer to output video file, then

# allow the camera sensor to warm up

print("[INFO] starting video stream...")

vs= VideoStream(src=0).start()

writer= None

time.sleep(2.0)

# loop over frames from the video file stream

while True:

    # grab the frame from the threaded video stream

    frame= vs.read()

    # convert the input frame from BGR to RGB then resize it to have

    # a width of 750px (to speedup processing)

    rgb= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    rgb= imutils.resize(frame, width=750)

    r= frame.shape[1]/ float(rgb.shape[1])

    # detect the (x, y)-coordinates of the bounding boxes

    # corresponding to each face in the input frame, then compute

    # the facial embeddings for each face

    boxes= face_recognition.face_locations(rgb,

        model=args["detection_method"])

    encodings= face_recognition.face_encodings(rgb, boxes)

    names= []

# loop over the facial embeddings

for encodingin encodings:

    # attempt to match each face in the input image to our known

    # encodings

    matches= face_recognition.compare_faces(data["encodings"],

        encoding)

    name= "Unknown"

    # check to see if we have found a match

    if True in matches:

        # find the indexes of all matched faces then initialize a

        # dictionary to count the total number of times each face

        # was matched

        matchedIdxs= [ifor (i, b)in enumerate(matches)if b]

        counts= {}

        # loop over the matched indexes and maintain a count for

        # each recognized face face

        for iin matchedIdxs:

            name= data["names"][i]

            counts[name]= counts.get(name,0)+ 1

        # determine the recognized face with the largest number

        # of votes (note: in the event of an unlikely tie Python

        # will select first entry in the dictionary)

        name= max(counts, key=counts.get)

    # update the list of names

    names.append(name)

# loop over the recognized faces

for ((top, right, bottom, left), name)in zip(boxes, names):

    # rescale the face coordinates

    top= int(top* r)

    right= int(right* r)

    bottom= int(bottom* r)

    left= int(left* r)

    # draw the predicted face name on the image

    cv2.rectangle(frame, (left, top), (right, bottom),

        (0,255,0),2)

    y= top- 15 if top- 15 >15 else top+ 15

    cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,

        0.75, (0,255,0),2)

# if the video writer is None *AND* we are supposed to write

# the output video to disk initialize the writer

if writeris None and args["output"]is not None:

    fourcc= cv2.VideoWriter_fourcc(*"MJPG")

    writer= cv2.VideoWriter(args["output"], fourcc,20,

        (frame.shape[1], frame.shape[0]),True)

# if the writer is not None, write the frame with recognized

# faces t odisk

if writeris not None:

    writer.write(frame)

# check to see if we are supposed to display the output frame to

# the screen

if args["display"] >0:

    cv2.imshow("Frame", frame)

    key= cv2.waitKey(1) &0xFF

    # if the `q` key was pressed, break from the loop

    if key== ord("q"):

        break

# do a bit of cleanup

cv2.destroyAllWindows()

vs.stop()

# check to see if the video writer point needs to be released

if writeris not None:

    writer.release()

$ python recognize_faces_video.py--encodings encodings.pickle \

    --output output/webcam_face_recognition_output.avi--display1

[INFO] loading encodings...

[INFO] starting video stream...

$ python recognize_faces_video_file.py--encodings encodings.pickle \

    --input videos/lunch_scene.mp4--output output/lunch_scene_output.avi \

    --display0