基于Python、Keras和OpenCV的实时人脸活体检测_keras人脸识别

你在互联网上找到的大多数人脸识别算法和研究论文都遭受照片攻击。这些方法在检测和识别来自网络摄像头的图像、视频和视频流中的人脸方面非常有效。然而，他们无法区分现实生活中的面孔和照片上的面孔。这种无法识别人脸的现象是由于这些算法在二维帧上工作。

现在让我们想象一下我们想要实现一个人脸识别开门器。该系统可以很好地区分已知面孔和未知面孔，以便只有授权人员才能访问。尽管如此，一个心怀不轨的人只要出示授权人的照片。这个3D探测器，类似于苹果的FaceID，应运而生了。但如果我们没有3D探测器呢？

本文的目标是实现一种基于眨眼检测的人脸活体检测算法，以抵抗照片攻击。该算法通过网络摄像头实时工作，只有当人的名字闪烁时才会显示出来。通俗地说，程序运行如下：

1. 在网络摄像头生成的每个帧中检测人脸。
2. 对于每个检测到的脸，检测眼睛。
3. 对于每个检测到的眼睛，检测眼睛是否睁开或关闭。
4. 如果在某个时候检测到眼睛是睁开的，然后是闭着的，然后是睁开的，我们就断定此人已经眨了眼睛，并且程序显示了他的名字（如果是人脸识别开门器，我们将授权此人进入）。

对于人脸的检测和识别，你需要安装face_recognition库，它提供了非常有用的深度学习方法来查找和识别图像中的人脸。特别是，face_locations、face_encodings和compare_faces函数是最有用的3个函数。人脸定位方法可以用两种方法来检测人脸：方向梯度直方图（HoG）和卷积神经网络（CNN）。由于时间限制，选择了HoG方法。

face_encodings函数是一个预先训练的卷积神经网络，能够将图像编码成128个特征向量。这个嵌入向量应该表示足够的信息来区分两个不同的人。最后，compare_faces计算两个嵌入向量之间的距离。它将允许算法识别从摄像头帧中提取的人脸，并将其嵌入向量与我们数据集中所有编码的人脸进行比较。最近的向量应该对应于同一个人。

1. 已知人脸数据集编码

在我的例子中，算法能够识别我和奥巴马。我为每个人挑选了大约10张照片。下面是处理和编码已知人脸数据库的代码。

def process_and_encode(images):
    known_encodings = []
    known_names = []
    print("[LOG] Encoding dataset ...")

    for image_path in tqdm(images):
        # 加载图片
        image = cv2.imread(image_path)
        # 将其从BGR转换为RGB
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
     
        # 检测图像中的脸并获取其位置（方框坐标）
        boxes = face_recognition.face_locations(image, model='hog')

        # 将人脸编码为128维嵌入向量
        encoding = face_recognition.face_encodings(image, boxes)

        # 人物名称是图像来源文件夹的名称
        name = image_path.split(os.path.sep)[-2]

        if len(encoding) > 0 : 
            known_encodings.append(encoding[0])
            known_names.append(name)

    return {"encodings": known_encodings, "names": known_names}
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

现在我们知道了每个想识别的人的编码，我们可以尝试通过网络摄像头识别人脸。然而，在转到这一部分之前，我们需要区分一张人脸照片和一张活人的脸。

2. 人脸活体检测

作为提醒，我们的目标是在某个点上检测出一个睁闭的睁眼模式。我训练了一个卷积神经网络来分类眼睛是闭着的还是睁着的。所选择的模型是LeNet-5，它已经在Closed Eyes In The Wild (CEW)数据集上进行了训练。它由大约4800张24x24大小的眼睛图像组成。

Closed Eyes In The Wild (CEW)数据集地址：

• http://parnec.nuaa.edu.cn/xtan/data/ClosedEyeDatabases.html

from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import AveragePooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.preprocessing.image import ImageDataGenerator

IMG_SIZE = 24
def train(train_generator, val_generator):
	STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size
	STEP_SIZE_VALID=val_generator.n//val_generator.batch_size
	
	model = Sequential()

	model.add(Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=(IMG_SIZE,IMG_SIZE,1)))
	model.add(AveragePooling2D())

	model.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
	model.add(AveragePooling2D())

	model.add(Flatten())

	model.add(Dense(units=120, activation='relu'))

	model.add(Dense(units=84, activation='relu'))

	model.add(Dense(units=1, activation = 'sigmoid'))


	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
  
  	print('[LOG] Training CNN')
  
	model.fit_generator(generator=train_generator,
	                    steps_per_epoch=STEP_SIZE_TRAIN,
	                    validation_data=val_generator,
	                    validation_steps=STEP_SIZE_VALID,
	                    epochs=20
	)
  return model
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

在评估模型时，我达到了94%的准确率。

每次我们检测到一只眼睛，我们就用我们的模型来预测它的状态，并跟踪每个人的眼睛状态。因此，检测眨眼变得非常容易，它试图在眼睛状态历史中找到一个闭眼-睁眼-闭眼模式。

def isBlinking(history, maxFrames):
    """ @history: A string containing the history of eyes status 
         where a '1' means that the eyes were closed and '0' open.
        @maxFrames: The maximal number of successive frames where an eye is closed """
    for i in range(maxFrames):
        pattern = '1' + '0'*(i+1) + '1'
        if pattern in history:
            return True
    return False
1
2
3
4
5
6
7
8
9

3. 活体的人脸识别

我们几乎拥有建立“真实”人脸识别算法的所有要素。我们只需要一种实时检测人脸和眼睛的方法。我使用openCV预先训练的Haar级联分类器来完成这些任务。有关Haar cascade人脸和眼睛检测的更多信息，我强烈建议你阅读openCV的这篇强大的文章。

• https://docs.opencv.org/3.4.3/d7/d8b/tutorial_py_face_detection.html

def detect_and_display(model, video_capture, face_detector, open_eyes_detector, left_eye_detector, right_eye_detector, data, eyes_detected):
        frame = video_capture.read()
        # 调整框架大小
        frame = cv2.resize(frame, (0, 0), fx=0.6, fy=0.6)

        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        
        # 检测人脸
        faces = face_detector.detectMultiScale(
            gray,
            scaleFactor=1.2,
            minNeighbors=5,
            minSize=(50, 50),
            flags=cv2.CASCADE_SCALE_IMAGE
        )

        # 对于每个检测到的脸
        for (x,y,w,h) in faces:
            # 将人脸编码为128维嵌入向量
            encoding = face_recognition.face_encodings(rgb, [(y, x+w, y+h, x)])[0]

            # 将向量与所有已知的人脸编码进行比较
            matches = face_recognition.compare_faces(data["encodings"], encoding)

            # 目前我们不知道该人的名字
            name = "Unknown"

            # 如果至少有一次匹配:
            if True in matches:
                matchedIdxs = [i for (i, b) in enumerate(matches) if b]
                counts = {}
                for i in matchedIdxs:
                    name = data["names"][i]
                    counts[name] = counts.get(name, 0) + 1

                # 匹配次数最多的已知编码对应于检测到的人脸名称
                name = max(counts, key=counts.get)

            face = frame[y:y+h,x:x+w]
            gray_face = gray[y:y+h,x:x+w]

            eyes = []
            
            # 眼睛检测
            # 首先检查眼睛是否睁开（考虑到眼镜）
            open_eyes_glasses = open_eyes_detector.detectMultiScale(
                gray_face,
                scaleFactor=1.1,
                minNeighbors=5,
                minSize=(30, 30),
                flags = cv2.CASCADE_SCALE_IMAGE
            )
            # 如果open_eyes_glasses检测到眼睛，则眼睛睁开 
            if len(open_eyes_glasses) == 2:
                eyes_detected[name]+='1'
                for (ex,ey,ew,eh) in open_eyes_glasses:
                    cv2.rectangle(face,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
            
            # 否则尝试使用left和right_eye_detector检测眼睛
            # 以检测到睁开和闭合的眼睛                
            else:
                # 将脸分成左右两边
                left_face = frame[y:y+h, x+int(w/2):x+w]
                left_face_gray = gray[y:y+h, x+int(w/2):x+w]

                right_face = frame[y:y+h, x:x+int(w/2)]
                right_face_gray = gray[y:y+h, x:x+int(w/2)]

                # 检测左眼
                left_eye = left_eye_detector.detectMultiScale(
                    left_face_gray,
                    scaleFactor=1.1,
                    minNeighbors=5,
                    minSize=(30, 30),
                    flags = cv2.CASCADE_SCALE_IMAGE
                )

                # 检测右眼
                right_eye = right_eye_detector.detectMultiScale(
                    right_face_gray,
                    scaleFactor=1.1,
                    minNeighbors=5,
                    minSize=(30, 30),
                    flags = cv2.CASCADE_SCALE_IMAGE
                )

                eye_status = '1' # we suppose the eyes are open

                # 检查每只眼睛是否闭合。
                # 如果有人闭着眼睛，我们得出结论是闭着眼睛
                for (ex,ey,ew,eh) in right_eye:
                    color = (0,255,0)
                    pred = predict(right_face[ey:ey+eh,ex:ex+ew],model)
                    if pred == 'closed':
                        eye_status='0'
                        color = (0,0,255)
                    cv2.rectangle(right_face,(ex,ey),(ex+ew,ey+eh),color,2)
                for (ex,ey,ew,eh) in left_eye:
                    color = (0,255,0)
                    pred = predict(left_face[ey:ey+eh,ex:ex+ew],model)
                    if pred == 'closed':
                        eye_status='0'
                        color = (0,0,255)
                    cv2.rectangle(left_face,(ex,ey),(ex+ew,ey+eh),color,2)
                eyes_detected[name] += eye_status

            # 每次，我们都会检查该人是否眨眼
            # 如果是，我们显示其名字
            if isBlinking(eyes_detected[name],3):
                cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
                # 显示名字
                y = y - 15 if y - 15 > 15 else y + 15
                cv2.putText(frame, name, (x, y), cv2.FONT_HERSHEY_SIMPLEX,0.75, (0, 255, 0), 2)

        return frame
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
116

上面的功能是用于检测和识别真实人脸的代码。它接受以下参数：

• model：我们的睁眼/闭眼分类器
• video_capture：流视频
• face_detector：Haar级联的人脸分类器。我使用了haarcascade_frontalface_alt.xml
• open_eyes_detector：Haar级联睁眼分类器。我使用了haarcascade_eye_tree_eyeglasses.xml
• left_eye_detector：Haar级联的左眼分类器。我使用了haarcascade_lefteye_2splits.xml，它可以检测睁眼或闭眼。
• right_eye_detector：Haar级联的右眼分类器。我使用了haarcascade_righteye_2splits.xml，它可以检测睁眼或闭眼。
• data：已知编码和已知名称的字典
• eyes_detected：包含每个名称的眼睛状态历史记录的字典。

在第2-4行，我们从网络摄像头流中获取一个帧，然后调整其大小以加快计算速度。

在第10行，我们从帧中检测人脸，然后在第21行，我们将其编码为128-d矢量。

在第23-38行，我们将这个向量与已知的人脸编码进行比较，并通过计算匹配的次数来确定此人的姓名。选择匹配次数最多的一个。

从第45行开始，我们试着探测眼睛进入人脸框。

首先，我们尝试用睁眼检测器来检测睁眼。如果探测器探测成功，则在第54行，将“1”添加到眼睛状态历史记录中，这意味着眼睛是睁开的，因为睁开的眼睛探测器无法检测到闭着的眼睛。否则，如果第一个分类器失败（可能是因为眼睛是闭着的，或者仅仅是因为它不能识别眼睛），则使用左眼和右眼检测器。人脸被分为左右两侧，以便对各个探测器进行分类。

从第92行开始，提取眼睛部分，训练后的模型预测眼睛是否闭合。如果检测到一只眼睛闭着，则两眼都将被预测为闭着，并将“0”添加到眼睛状态历史记录中。否则就可以断定眼睛是睁开的。

最后，在第110行，is blinking()函数用于检测眨眼，如果该人眨眼，则显示姓名。整个代码都可以在我的github帐户上找到。

• 我的github帐户

  • https://github.com/Guarouba/face_rec

使用眨眼检测功能阻止照片攻击的演示视频:
https://youtu.be/arQN6w0fZw8

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。