人脸识别经典网络-MTCNN（含Python源码实现）

人脸检测-mtcnn

本文参加新星筹划人工智能赛道：https://bbs.csdn.net/topics/613989052

  
1. 人脸检测

1.1 人脸检测概述

人脸检测或者识别，都是根据人的脸部特性信息举行身份识别的一种生物识别术。用摄像机或摄像头采集含有人脸的图像或视频流，并自动在图像中检测和跟踪人脸，进而对检测到的人脸举行脸部识别的一系列相干技术，通常也叫做人像识别、面部识别。
1.2 人脸检测的难点

人脸识别被认为是生物特性识别领域乃至人工智能领域最困难的研究课题之一。人脸识别的难点是由于人脸作为生物特性的特点而导致的，难点重要包括以下部门：

• 相似性：从人脸的构造上来看，个体之间的人脸构造区别不大，乃至人脸器官的构造都很相似。这种相似性对于利用人脸举行定位是能偶提供很大的便利的，但同时对于个体的区分确实难的。
  
• 易变性：抛去构造仅仅关注外形的话，人脸的外形又黑白常多变的，面部表情多变，而在不同观察角度，人脸的视觉图像也相差很大，另外，人脸识别还受光照条件（例如白天和夜晚，室内和室外等）、人脸的很多遮盖物（例如口罩、墨镜、头发、胡须等）、年岁等多方面因素的影响。
  

在人脸识别中，第一类的变革是应该放大而作为区分个体的标准的，而第二类的变革应该消除，由于它们可以代表同一个个体。通常称第一类变革为类间变革（inter-class difference），而称第二类变革为类内变革（intra-class difference）。对于人脸，类内变革往往大于类间变革，从而使在受类内变革干扰的环境下利用类间变革区分个体变得异常困难。
1.3 人脸检测的应用场景

人脸识别重要用于身份识别。
由于视频监控正在快速遍及，众多的视频监控应用迫切需要一种远距离、用户非共同状态下的快速身份识别技术，以求远距离快速确认人员身份，实现智能预警。人脸识别技术无疑是最佳的选择，接纳快速人脸检测技术可以从监控视频图象中实时查找人脸，并与人脸数据库举行实时比对，从而实现快速身份识别。
人脸识别产品已广泛应用于金融、司法、部队、公安、边检、政府、航天、电力、工厂、教诲、医疗及众多企奇迹单元等领域。随着技术的进一步成熟和社会认同度的提高，人脸识别技术将应用在更多的领域。
1、企业、住宅安全和管理。如人脸识别门禁考勤系统，人脸识别防盗门等。
2、电子护照及身份证。
3、公安、司法和刑侦。如利用人脸识别系统和网络，在全国范围内搜捕逃犯。
4、自助服务。
5、信息安全。如手机、盘算机登录、电子政务和电子商务。
2. mtcnn

2.1 mtcnn概述

MTCNN，英文全称是Multi-task convolutional neural network，中文全称是多任务卷积神经网络，该神经网络将人脸区域检测与人脸关键点检测放在了一起。
从工程实践上，MTCNN是一种检测速率和准确率都很不错的算法，算法的推断流程有一定的启示作用。

2.2 mtcnn的网络结构

mtcnn从整体上划分分为P-Net、R-Net、和O-Net三层网络结构。各层的作用直观上感受如下图所示：

一次mtcnn对于局部信息的运作流程如下描述：

• 由原始图片和PNet生成预测的bounding boxes。
  
• 输入原始图片和PNet生成的bounding box，通过RNet，生成校正后的bounding box。
  
• 输入原始图片和RNet生成的bounding box，通过ONet，生成校正后的bounding box和人脸面部轮廓关键点。
  

当整个图片的局部信息都举行处理之后，就能得到所有的局部人脸信息，或有或无，举行校正处理后就可以得到最后的结果。

P-Net、R-Net、O-Net的网络结构如下图所示：

分析：
MTCNN重要包括三层网络，

• 第一层P-Net将颠末卷积，池化操纵后输出分类（对应像素点是否存在人脸）和回归（回归box)结果。
  
• 第二层网络将第一层输出的结果使用非极大克制（NMS）往复除高度重合的候选框，并将这些候选框放入R-Net中举行精致的操纵，拒绝大量错误框，再对回归框做校正，并使用NMS去除重合框，输出分支同样两个分类和回归。
  
• 最后将R-Net输出认为是人脸的候选框输入到O-Net中再一次举行精致操纵，拒绝掉错误的框，此时输出分支包罗三个分类：
  a. 是否有人脸：2个输出；
  b. 回归：回归得到的框的起始点（或中心点）的xy坐标和框的长宽，4个输出；
  c. 人脸特性点定位：5个人脸特性点的xy坐标，10个输出。
  

   三段网络都有NMS，但是所设阈值不同。
  2.3 图像金字塔

mtcnn的输入尺度是任意大小的，那么输入是如何处理的呢？
首先对图片举行Resize操纵，将原始图像缩放成不同的尺度，生成图像金字塔。然后将不同尺度的图像送入到这三个子网络中举行训练，目标是为了可以检测到不同大小的人脸，从而实现多尺度目标检测。
构建方式是通过不同的缩放系数factor分别对图片的h和w举行缩放，每次缩小为原来的factor大小。
   缩小后的长宽最小不可以小于12。
  

图片中的人脸的尺度有大有小，让识别算法不被目标尺度影响不停是个挑衅。
MTCNN使用了图像金字塔来办理目标多尺度问题，即把原图按照一定的比例(如0.709)，多次等比缩放得到多尺度的图片，很像个金字塔。
   为什么这里的缩放因子是0.709，由于缩放的时候若宽高都缩放                                                   1                               2                                            \frac{1}{2}                     21​，那么缩放后的面积就变为了原本面积的                                                   1                               4                                            \frac{1}{4}                     41​，假如考虑总面积缩放为原本的                                                   1                               2                                            \frac{1}{2}                     21​，那么就取                                                               2                                          2                                      ≈                            0.709                                  \frac{\sqrt{2}}{2}\approx 0.709                     22                     ​​≈0.709，这样就达到了将总面积缩放为原本的                                                   1                               2                                            \frac{1}{2}                     21​的目标。
  P-NET的模型是用单尺度(12*12)的图片训练出来的。推理的时候，缩小后的长宽最小不可以小于12。
对多个尺度的输入图像做训练，训练黑白常耗时的。因此通常只在推理阶段使用图像金字塔，提高算法的精度。

图像金字塔是有生成标准的，每次缩放的水平（factor）以及最小的兜底标准（minsize）都是需要合适的设置的，那么能够优化盘算效率的合适的最小人脸尺寸（minsize）和缩放因子（factor）具有什么样的依据？

• 第一阶段会多次缩放原图得到图片金字塔，目标是为了让缩放后图片中的人脸与P-NET训练时候的图片尺度(                                        12                            p                            x                            ×                            12                            p                            x                                  12px\times 12px                     12px×12px)靠近。
  
• 引申优化项：先把图像缩放到一定大小，再通过factor对这个大小举行缩放。可以淘汰盘算量。
  

   minsize的单元为px
  例：输入图片为                                   1200                         p                         x                         ×                         1200                         p                         x                              1200px\times 1200px                  1200px×1200px，设置缩放后的尺寸靠近训练图片的尺度(                                   12                         p                         x                         ×                         12                         p                         x                              12px\times 12px                  12px×12px)

图像金字塔也有其局限性

• 生成图像金字塔的过程比力慢。
  
• 每种尺度的图片都需要输入进模型，相称于执行了多次的模型推理流程。
  

2.4 P-Net

P-Net（Proposal Network）的网络结构
网络的输入为预处理中得到的图像金字塔，P-Net中筹划了一个全卷积网络（FCN）对输入的图像金字塔举行特性提取和边框回归。
   全卷积神经网络没有FC全毗连层，这就突破了输入维度的限制，那么其接受的输入尺寸是任意的。
  

在P-Net中，颠末了三次卷积和一次池化（MP：Max Pooling），输入                                   12                         ×                         12                         ×                         3                              12\times 12 \times 3                  12×12×3的尺寸变为了                                   1                         ×                         1                         ×                         32                              1\times 1\times 32                  1×1×32，                                   1                         ×                         1                         ×                         32                              1\times 1\times 32                  1×1×32的向量通过卷积得到了                                   1                         ×                         1                         ×                         2                              1\times 1\times 2                  1×1×2到了人脸的分类结果，相称于图像中的每个                                   12                         ×                         12                              12\times 12                  12×12的区域都会判断一下是否存在人脸，通道数为2，即得到两个值；第二个部门得到（bounding box regrssion）边框回归的结果，由于                                   12                         ×                         12                              12\times 12                  12×12的图像并不能保证，方形框能够完美的框住人脸，以是输出包罗的信息都是误差信息，通道数为4，有4个方面的信息，边框左上角的横坐标的相对偏移信息、边框左上角纵坐标的相对偏移信息、标定框宽度的误差、标定框高度的误差；第三个部门给出了人脸的5个关键点的位置，分别是左眼位置、右眼位置、鼻子位置、嘴巴左位置、嘴巴右位置，每个关键位置使用两个维度体现，故而输出是                                   1                         ×                         1                         ×                         10                              1\times 1\times 10                  1×1×10。
P-Net应用举例
一张                                   70                         ×                         70                              70\times 70                  70×70的图，颠末P网络全卷积后，输出为                                                        70                               −                               2                                      2                                  −                         2                         −                         2                         =                         30                              \frac{70-2}{2} -2 -2 =30                  270−2​−2−2=30，即一个5通道的                                   30                         ×                         30                              30\times 30                  30×30的特性图。这就意味着该图颠末p的一次滑窗操纵，得到                                   30                         ×                         30                         =                         900                              30\times 30=900                  30×30=900个建议框，而每个建议框对应1个置信度与4个偏移量。再经nms把置信度分数大于设定的阈值0.6对应的建议框保存下来，将其对应的边框偏移量经边框回归操纵，得到在原图中的坐标信息，即得到符合P-Net的这些建议框了。之后传给R-Net。
2.5 R-Net

R-Net（Refine Network），从网络图可以看到，该网络结构只是和P-Net网络结构多了一个全毗连层。图片在输入R-Net之前，都需要缩放到24x24x3。网络的输出与P-Net是相同的，R-Net的目标是为了去除大量的非人脸框。

2.6 O-Net

O-Net（Output Network），该层比R-Net层又多了一层卷积层，以是处理的结果会更加精致。输入的图像大小48x48x3，输出包括N个边界框的坐标信息，score以及关键点位置。

   从P-Net到R-Net，再到最后的O-Net，网络输入的图像越来越大，卷积层的通道数越来越多，网络的深度（层数）也越来越深，因此识别人脸的准确率应该也是越来越高的。
  3. 工程实践（基于Keras）

点击此处下载人脸数据集。该数据集有32,203张图片，共有93,703张脸被标记。

MTCNN网络定义，按照上述网络结构完成定义，代码按照P-Net、R-Net、O-Net举行模块化筹划，在mtcnn的网络构建过程中将其整合。mtcnn.py代码如下：

1. from keras.layers import Conv2D, Input,MaxPool2D, Reshape,Activation,Flatten, Dense, Permute
2. from keras.layers.advanced_activations import PReLU
3. from keras.models import Model, Sequential
4. import tensorflow as tf
5. import numpy as np
6. import utils
7. import cv2
8. #-----------------------------#
9. #   粗略获取人脸框
10. #   输出bbox位置和是否有人脸
11. #-----------------------------#
12. def create_Pnet(weight_path):
13.     input = Input(shape=[None, None, 3])
15.     x = Conv2D(10, (3, 3), strides=1, padding='valid', name='conv1')(input)
16.     x = PReLU(shared_axes=[1,2],name='PReLU1')(x)
17.     x = MaxPool2D(pool_size=2)(x)
19.     x = Conv2D(16, (3, 3), strides=1, padding='valid', name='conv2')(x)
20.     x = PReLU(shared_axes=[1,2],name='PReLU2')(x)
22.     x = Conv2D(32, (3, 3), strides=1, padding='valid', name='conv3')(x)
23.     x = PReLU(shared_axes=[1,2],name='PReLU3')(x)
25.     classifier = Conv2D(2, (1, 1), activation='softmax', name='conv4-1')(x)
26.     # 无激活函数，线性。
27.     bbox_regress = Conv2D(4, (1, 1), name='conv4-2')(x)
29.     model = Model([input], [classifier, bbox_regress])
30.     model.load_weights(weight_path, by_name=True)
31.     return model
33. #-----------------------------#
34. #   mtcnn的第二段
35. #   精修框
36. #-----------------------------#
37. def create_Rnet(weight_path):
38.     input = Input(shape=[24, 24, 3])
39.     # 24,24,3 -> 11,11,28
40.     x = Conv2D(28, (3, 3), strides=1, padding='valid', name='conv1')(input)
41.     x = PReLU(shared_axes=[1, 2], name='prelu1')(x)
42.     x = MaxPool2D(pool_size=3,strides=2, padding='same')(x)
44.     # 11,11,28 -> 4,4,48
45.     x = Conv2D(48, (3, 3), strides=1, padding='valid', name='conv2')(x)
46.     x = PReLU(shared_axes=[1, 2], name='prelu2')(x)
47.     x = MaxPool2D(pool_size=3, strides=2)(x)
49.     # 4,4,48 -> 3,3,64
50.     x = Conv2D(64, (2, 2), strides=1, padding='valid', name='conv3')(x)
51.     x = PReLU(shared_axes=[1, 2], name='prelu3')(x)
52.     # 3,3,64 -> 64,3,3
53.     x = Permute((3, 2, 1))(x)
54.     x = Flatten()(x)
55.     # 576 -> 128
56.     x = Dense(128, name='conv4')(x)
57.     x = PReLU( name='prelu4')(x)
58.     # 128 -> 2 128 -> 4
59.     classifier = Dense(2, activation='softmax', name='conv5-1')(x)
60.     bbox_regress = Dense(4, name='conv5-2')(x)
61.     model = Model([input], [classifier, bbox_regress])
62.     model.load_weights(weight_path, by_name=True)
63.     return model
65. #-----------------------------#
66. #   mtcnn的第三段
67. #   精修框并获得五个点
68. #-----------------------------#
69. def create_Onet(weight_path):
70.     input = Input(shape = [48,48,3])
71.     # 48,48,3 -> 23,23,32
72.     x = Conv2D(32, (3, 3), strides=1, padding='valid', name='conv1')(input)
73.     x = PReLU(shared_axes=[1,2],name='prelu1')(x)
74.     x = MaxPool2D(pool_size=3, strides=2, padding='same')(x)
75.     # 23,23,32 -> 10,10,64
76.     x = Conv2D(64, (3, 3), strides=1, padding='valid', name='conv2')(x)
77.     x = PReLU(shared_axes=[1,2],name='prelu2')(x)
78.     x = MaxPool2D(pool_size=3, strides=2)(x)
79.     # 8,8,64 -> 4,4,64
80.     x = Conv2D(64, (3, 3), strides=1, padding='valid', name='conv3')(x)
81.     x = PReLU(shared_axes=[1,2],name='prelu3')(x)
82.     x = MaxPool2D(pool_size=2)(x)
83.     # 4,4,64 -> 3,3,128
84.     x = Conv2D(128, (2, 2), strides=1, padding='valid', name='conv4')(x)
85.     x = PReLU(shared_axes=[1,2],name='prelu4')(x)
86.     # 3,3,128 -> 128,12,12
87.     x = Permute((3,2,1))(x)
89.     # 1152 -> 256
90.     x = Flatten()(x)
91.     x = Dense(256, name='conv5') (x)
92.     x = PReLU(name='prelu5')(x)
94.     # 鉴别
95.     # 256 -> 2 256 -> 4 256 -> 10
96.     classifier = Dense(2, activation='softmax',name='conv6-1')(x)
97.     bbox_regress = Dense(4,name='conv6-2')(x)
98.     landmark_regress = Dense(10,name='conv6-3')(x)
100.     model = Model([input], [classifier, bbox_regress, landmark_regress])
101.     model.load_weights(weight_path, by_name=True)
103.     return model
105. class mtcnn():
106.     def __init__(self):
107.         self.Pnet = create_Pnet('model_data/pnet.h5')
108.         self.Rnet = create_Rnet('model_data/rnet.h5')
109.         self.Onet = create_Onet('model_data/onet.h5')
111.     def detectFace(self, img, threshold):
112.         #-----------------------------#
113.         #   归一化，加快收敛速度
114.         #   把[0,255]映射到(-1,1)
115.         #-----------------------------#
116.         copy_img = (img.copy() - 127.5) / 127.5
117.         origin_h, origin_w, _ = copy_img.shape
118.         #-----------------------------#
119.         #   计算原始输入图像
120.         #   每一次缩放的比例
121.         #-----------------------------#
122.         scales = utils.calculateScales(img)
124.         out = []
125.         #-----------------------------#
126.         #   粗略计算人脸框
127.         #   pnet部分
128.         #-----------------------------#
129.         for scale in scales:
130.             hs = int(origin_h * scale)
131.             ws = int(origin_w * scale)
132.             scale_img = cv2.resize(copy_img, (ws, hs))
133.             inputs = scale_img.reshape(1, *scale_img.shape)
134.             # 图像金字塔中的每张图片分别传入Pnet得到output
135.             output = self.Pnet.predict(inputs)
136.             # 将所有output加入out
137.             out.append(output)
139.         image_num = len(scales)
140.         rectangles = []
141.         for i in range(image_num):
142.             # 有人脸的概率
143.             cls_prob = out[i][0][0][:,:,1]
144.             # 其对应的框的位置
145.             roi = out[i][1][0]
147.             # 取出每个缩放后图片的长宽
148.             out_h, out_w = cls_prob.shape
149.             out_side = max(out_h, out_w)
150.             print(cls_prob.shape)
151.             # 解码过程
152.             rectangle = utils.detect_face_12net(cls_prob, roi, out_side, 1 / scales[i], origin_w, origin_h, threshold[0])
153.             rectangles.extend(rectangle)
155.         # 进行非极大抑制
156.         rectangles = utils.NMS(rectangles, 0.7)
158.         if len(rectangles) == 0:
159.             return rectangles
161.         #-----------------------------#
162.         #   稍微精确计算人脸框
163.         #   Rnet部分
164.         #-----------------------------#
165.         predict_24_batch = []
166.         for rectangle in rectangles:
167.             crop_img = copy_img[int(rectangle[1]):int(rectangle[3]), int(rectangle[0]):int(rectangle[2])]
168.             scale_img = cv2.resize(crop_img, (24, 24))
169.             predict_24_batch.append(scale_img)
171.         predict_24_batch = np.array(predict_24_batch)
172.         out = self.Rnet.predict(predict_24_batch)
174.         cls_prob = out[0]
175.         cls_prob = np.array(cls_prob)
176.         roi_prob = out[1]
177.         roi_prob = np.array(roi_prob)
178.         rectangles = utils.filter_face_24net(cls_prob, roi_prob, rectangles, origin_w, origin_h, threshold[1])
180.         if len(rectangles) == 0:
181.             return rectangles
183.         #-----------------------------#
184.         #   计算人脸框
185.         #   onet部分
186.         #-----------------------------#
187.         predict_batch = []
188.         for rectangle in rectangles:
189.             crop_img = copy_img[int(rectangle[1]):int(rectangle[3]), int(rectangle[0]):int(rectangle[2])]
190.             scale_img = cv2.resize(crop_img, (48, 48))
191.             predict_batch.append(scale_img)
193.         predict_batch = np.array(predict_batch)
194.         output = self.Onet.predict(predict_batch)
195.         cls_prob = output[0]
196.         roi_prob = output[1]
197.         pts_prob = output[2]
199.         rectangles = utils.filter_face_48net(cls_prob, roi_prob, pts_prob, rectangles, origin_w, origin_h, threshold[2])
201.         return rectangles

复制代码

当有了mtcnn定义之后，可以利用其作为本身的模块来举行调用，推理，detect.py代码如下：

1. import cv2
2. import numpy as np
3. from mtcnn import mtcnn
5. img = cv2.imread('img/test1.jpg')
7. model = mtcnn()
8. threshold = [0.5,0.6,0.7]  # 三段网络的置信度阈值不同
9. rectangles = model.detectFace(img, threshold)
10. draw = img.copy()
12. for rectangle in rectangles:
13.     if rectangle is not None:
14.         W = -int(rectangle[0]) + int(rectangle[2])
15.         H = -int(rectangle[1]) + int(rectangle[3])
16.         paddingH = 0.01 * W
17.         paddingW = 0.02 * H
18.         crop_img = img[int(rectangle[1]+paddingH):int(rectangle[3]-paddingH), int(rectangle[0]-paddingW):int(rectangle[2]+paddingW)]
19.         if crop_img is None:
20.             continue
21.         if crop_img.shape[0] < 0 or crop_img.shape[1] < 0:
22.             continue
23.         cv2.rectangle(draw, (int(rectangle[0]), int(rectangle[1])), (int(rectangle[2]), int(rectangle[3])), (255, 0, 0), 1)
25.         for i in range(5, 15, 2):
26.             cv2.circle(draw, (int(rectangle[i + 0]), int(rectangle[i + 1])), 2, (0, 255, 0))
28. cv2.imwrite("img/out.jpg",draw)
30. cv2.imshow("test", draw)
31. c = cv2.waitKey(0)

复制代码

其中，用到的工具类助手如下，实现了非极大值克制已经网络的后处理等过程逻辑。

1. import sys
2. from operator import itemgetter
3. import numpy as np
4. import cv2
5. import matplotlib.pyplot as plt
6. #-----------------------------#
7. #   计算原始输入图像
8. #   每一次缩放的比例
9. #-----------------------------#
10. def calculateScales(img):
11.     copy_img = img.copy()
12.     pr_scale = 1.0
13.     h,w,_ = copy_img.shape
14.     # 引申优化项  = resize(h*500/min(h,w), w*500/min(h,w))
15.     if min(w,h)>500:
16.         pr_scale = 500.0/min(h,w)
17.         w = int(w*pr_scale)
18.         h = int(h*pr_scale)
19.     elif max(w,h)<500:
20.         pr_scale = 500.0/max(h,w)
21.         w = int(w*pr_scale)
22.         h = int(h*pr_scale)
24.     scales = []
25.     factor = 0.709
26.     factor_count = 0
27.     minl = min(h,w)
28.     while minl >= 12:
29.         scales.append(pr_scale*pow(factor, factor_count))
30.         minl *= factor
31.         factor_count += 1
32.     return scales
34. #-------------------------------------#
35. #   对pnet处理后的结果进行处理
36. #-------------------------------------#
37. def detect_face_12net(cls_prob,roi,out_side,scale,width,height,threshold):
38.     cls_prob = np.swapaxes(cls_prob, 0, 1)
39.     roi = np.swapaxes(roi, 0, 2)
41.     stride = 0
42.     # stride略等于2
43.     if out_side != 1:
44.         stride = float(2*out_side-1)/(out_side-1)
45.     (x,y) = np.where(cls_prob>=threshold)
47.     boundingbox = np.array([x,y]).T
48.     # 找到对应原图的位置
49.     bb1 = np.fix((stride * (boundingbox) + 0 ) * scale)
50.     bb2 = np.fix((stride * (boundingbox) + 11) * scale)
51.     # plt.scatter(bb1[:,0],bb1[:,1],linewidths=1)
52.     # plt.scatter(bb2[:,0],bb2[:,1],linewidths=1,c='r')
53.     # plt.show()
54.     boundingbox = np.concatenate((bb1,bb2),axis = 1)
55.    
56.     dx1 = roi[0][x,y]
57.     dx2 = roi[1][x,y]
58.     dx3 = roi[2][x,y]
59.     dx4 = roi[3][x,y]
60.     score = np.array([cls_prob[x,y]]).T
61.     offset = np.array([dx1,dx2,dx3,dx4]).T
63.     boundingbox = boundingbox + offset*12.0*scale
64.    
65.     rectangles = np.concatenate((boundingbox,score),axis=1)
66.     rectangles = rect2square(rectangles)
67.     pick = []
68.     for i in range(len(rectangles)):
69.         x1 = int(max(0     ,rectangles[i][0]))
70.         y1 = int(max(0     ,rectangles[i][1]))
71.         x2 = int(min(width ,rectangles[i][2]))
72.         y2 = int(min(height,rectangles[i][3]))
73.         sc = rectangles[i][4]
74.         if x2>x1 and y2>y1:
75.             pick.append([x1,y1,x2,y2,sc])
76.     return NMS(pick,0.3)
77. #-----------------------------#
78. #   将长方形调整为正方形
79. #-----------------------------#
80. def rect2square(rectangles):
81.     w = rectangles[:,2] - rectangles[:,0]
82.     h = rectangles[:,3] - rectangles[:,1]
83.     l = np.maximum(w,h).T
84.     rectangles[:,0] = rectangles[:,0] + w*0.5 - l*0.5
85.     rectangles[:,1] = rectangles[:,1] + h*0.5 - l*0.5
86.     rectangles[:,2:4] = rectangles[:,0:2] + np.repeat([l], 2, axis = 0).T
87.     return rectangles
88. #-------------------------------------#
89. #   非极大抑制
90. #-------------------------------------#
91. def NMS(rectangles,threshold):
92.     if len(rectangles)==0:
93.         return rectangles
94.     boxes = np.array(rectangles)
95.     x1 = boxes[:,0]
96.     y1 = boxes[:,1]
97.     x2 = boxes[:,2]
98.     y2 = boxes[:,3]
99.     s  = boxes[:,4]
100.     area = np.multiply(x2-x1+1, y2-y1+1)
101.     I = np.array(s.argsort())
102.     pick = []
103.     while len(I)>0:
104.         xx1 = np.maximum(x1[I[-1]], x1[I[0:-1]]) #I[-1] have hightest prob score, I[0:-1]->others
105.         yy1 = np.maximum(y1[I[-1]], y1[I[0:-1]])
106.         xx2 = np.minimum(x2[I[-1]], x2[I[0:-1]])
107.         yy2 = np.minimum(y2[I[-1]], y2[I[0:-1]])
108.         w = np.maximum(0.0, xx2 - xx1 + 1)
109.         h = np.maximum(0.0, yy2 - yy1 + 1)
110.         inter = w * h
111.         o = inter / (area[I[-1]] + area[I[0:-1]] - inter)
112.         pick.append(I[-1])
113.         I = I[np.where(o<=threshold)[0]]
114.     result_rectangle = boxes[pick].tolist()
115.     return result_rectangle
118. #-------------------------------------#
119. #   对Rnet处理后的结果进行处理
120. #-------------------------------------#
121. def filter_face_24net(cls_prob,roi,rectangles,width,height,threshold):
122.    
123.     prob = cls_prob[:,1]
124.     pick = np.where(prob>=threshold)
125.     rectangles = np.array(rectangles)
127.     x1  = rectangles[pick,0]
128.     y1  = rectangles[pick,1]
129.     x2  = rectangles[pick,2]
130.     y2  = rectangles[pick,3]
131.    
132.     sc  = np.array([prob[pick]]).T
134.     dx1 = roi[pick,0]
135.     dx2 = roi[pick,1]
136.     dx3 = roi[pick,2]
137.     dx4 = roi[pick,3]
139.     w   = x2-x1
140.     h   = y2-y1
142.     x1  = np.array([(x1+dx1*w)[0]]).T
143.     y1  = np.array([(y1+dx2*h)[0]]).T
144.     x2  = np.array([(x2+dx3*w)[0]]).T
145.     y2  = np.array([(y2+dx4*h)[0]]).T
147.     rectangles = np.concatenate((x1,y1,x2,y2,sc),axis=1)
148.     rectangles = rect2square(rectangles)
149.     pick = []
150.     for i in range(len(rectangles)):
151.         x1 = int(max(0     ,rectangles[i][0]))
152.         y1 = int(max(0     ,rectangles[i][1]))
153.         x2 = int(min(width ,rectangles[i][2]))
154.         y2 = int(min(height,rectangles[i][3]))
155.         sc = rectangles[i][4]
156.         if x2>x1 and y2>y1:
157.             pick.append([x1,y1,x2,y2,sc])
158.     return NMS(pick,0.3)
159. #-------------------------------------#
160. #   对onet处理后的结果进行处理
161. #-------------------------------------#
162. def filter_face_48net(cls_prob,roi,pts,rectangles,width,height,threshold):
163.    
164.     prob = cls_prob[:,1]
165.     pick = np.where(prob>=threshold)
166.     rectangles = np.array(rectangles)
168.     x1  = rectangles[pick,0]
169.     y1  = rectangles[pick,1]
170.     x2  = rectangles[pick,2]
171.     y2  = rectangles[pick,3]
173.     sc  = np.array([prob[pick]]).T
175.     dx1 = roi[pick,0]
176.     dx2 = roi[pick,1]
177.     dx3 = roi[pick,2]
178.     dx4 = roi[pick,3]
180.     w   = x2-x1
181.     h   = y2-y1
183.     pts0= np.array([(w*pts[pick,0]+x1)[0]]).T
184.     pts1= np.array([(h*pts[pick,5]+y1)[0]]).T
185.     pts2= np.array([(w*pts[pick,1]+x1)[0]]).T
186.     pts3= np.array([(h*pts[pick,6]+y1)[0]]).T
187.     pts4= np.array([(w*pts[pick,2]+x1)[0]]).T
188.     pts5= np.array([(h*pts[pick,7]+y1)[0]]).T
189.     pts6= np.array([(w*pts[pick,3]+x1)[0]]).T
190.     pts7= np.array([(h*pts[pick,8]+y1)[0]]).T
191.     pts8= np.array([(w*pts[pick,4]+x1)[0]]).T
192.     pts9= np.array([(h*pts[pick,9]+y1)[0]]).T
194.     x1  = np.array([(x1+dx1*w)[0]]).T
195.     y1  = np.array([(y1+dx2*h)[0]]).T
196.     x2  = np.array([(x2+dx3*w)[0]]).T
197.     y2  = np.array([(y2+dx4*h)[0]]).T
199.     rectangles=np.concatenate((x1,y1,x2,y2,sc,pts0,pts1,pts2,pts3,pts4,pts5,pts6,pts7,pts8,pts9),axis=1)
201.     pick = []
202.     for i in range(len(rectangles)):
203.         x1 = int(max(0     ,rectangles[i][0]))
204.         y1 = int(max(0     ,rectangles[i][1]))
205.         x2 = int(min(width ,rectangles[i][2]))
206.         y2 = int(min(height,rectangles[i][3]))
207.         if x2>x1 and y2>y1:
208.             pick.append([x1,y1,x2,y2,rectangles[i][4],
209.                  rectangles[i][5],rectangles[i][6],rectangles[i][7],rectangles[i][8],rectangles[i][9],rectangles[i][10],rectangles[i][11],rectangles[i][12],rectangles[i][13],rectangles[i][14]])
210.     return NMS(pick,0.3)

复制代码

test1.jpg如下所示：

推理结果out.jpg如下所示：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。