人脸检测之Retina FaceNet-婴美网

数字版权

retinaface 与普通的目标检测算法类似，在图片上预先设定好一些先验框，这些先验框会分布在整个图片上，网络内部结构会对这些先验框进行判断看是否包含人脸，同时也会调整位置进行调整并且给每一个先验框的一个置信度。

retinaface 人脸检测算法

甜点

最近一直了解人脸检测的算法，所以也尝试学多人脸检测框架。所以这里将拿出来和大家分享一下

在 retinaface 的先验框不但要获得人脸位置，还需要获得每一个人脸的五个关键点位置

接下来我们对 retinaface 执行过程其实就是在图片上预先设定好先验框，网络的预测结果会判断先验框内部是否包含人脸并且对先验框进行调整获得预测框和五个人脸关键点。

主干特征提取网络

mobilenet 和 resnet
在主干网络(例如 mobilenetv1) 不断进行特征提取，在特征提取过程就是压缩长宽到深度(通道扩张)上过程(下采样)

mobilenet

mobilenet 网络是由 google 团队在年提出的，专注移动端和嵌入式设备中轻量级 cnn 网络，在大大减少模型参数与运算量下，对于精度只是小幅度下降而已。

加强特征提取网络 fpn 和 shh

fpn 构建就是生成特征图进行融合，通过上采样然后和上一层的有效特征层进行

ssh 的思想非常简单，使用了 3 个并行结构，利用 3 x 3 卷积的堆叠代替 5 x 5 与 7 x 7 卷积的效果，

retina head

在主干网络输出的相当输出了不同大小网格，用于检测不同大小目标，先验框默认数量为 2，这些先验框用于检测目标，然后通过调整得到目标边界框。

face classification 用于检测先验框中是否存在人脸。也就是判断先验框内部是否包含目标，利用一个 1 x 1 的卷积，将 ssh 的通道数调整成 num_anchors x 2 ，用于代表每个先验框内部包含人脸的概率，这里觉得有必要解释一下 2，通常不就是用一个概率来表示先验框存在人脸的概率，而在这里用了两个值来表示人脸是否存在先验框内的概率。其实在两个值中，如果第一个值比较大，就表示有人脸，那么如果第二值比较大，表示没有人脸存在
face box regression 用于调整先验框的中心和宽高，用四个参数对先验框进行调整。此时可以利用 1 x 1 的卷积，将 ssh 的通道数调整成 num_anchors x 4 用于表示每个先验框的调整参数
facial landmark regression 对先验框进行调整获得人脸关键点，每一个人脸关键点需要两个调整参数，一共有五个人脸关键点。此时利用 1 x 1 的卷积，将 ssh 通道调整成为 num_anchor(num_anchors x 5 x 2) 表示每个先验框的每一个人脸关键点的调整，5 就是人脸上 5 个关键点，这里 2 表示对人脸中心点进行调整的参数。

fpn

class fpn(nn.module): 
    def __init__(self,in_channels_list,out_channels): 
        super(fpn,self).__init__() 
        leaky = 0 
        if (out_channels <= 64): 
            leaky = 0.1 
         
        # 利用 1x1 卷积对获得的3有效特征层进行通道数的调整，输出通道数都为 64 
        self.output1 = conv_bn1x1(in_channels_list[0], out_channels, stride = 1, leaky = leaky) 
        self.output2 = conv_bn1x1(in_channels_list[1], out_channels, stride = 1, leaky = leaky) 
        self.output3 = conv_bn1x1(in_channels_list[2], out_channels, stride = 1, leaky = leaky) 
 
        self.merge1 = conv_bn(out_channels, out_channels, leaky = leaky) 
        self.merge2 = conv_bn(out_channels, out_channels, leaky = leaky) 
 
    def forward(self, input): 
        # names = list(input.keys()) 
        input = list(input.values()) 
 
        #  
        output1 = self.output1(input[0]) 
        output2 = self.output2(input[1]) 
        output3 = self.output3(input[2]) 
 
        # 对于最小特征层进行上采样来获得 up3 
        up3 = f.interpolate(output3, size=[output2.size(2), output2.size(3)], mode="nearest") 
        # 然后将最小特征层经过上采用获得结果和中间有效特征层进行相加 
        output2 = output2 + up3 
        # 进行 64 通道卷积进行特征整合 
        output2 = self.merge2(output2) 
 
        # 这个步骤和上面类似 
        up2 = f.interpolate(output2, size=[output1.size(2), output1.size(3)], mode="nearest") 
        output1 = output1 + up2 
        output1 = self.merge1(output1) 
 
        out = [output1, output2, output3] 
        return out

ssh

class ssh(nn.module): 
    def __init__(self, in_channel, out_channel): 
        super(ssh, self).__init__() 
        assert out_channel % 4 == 0 
        leaky = 0 
        if (out_channel <= 64): 
            leaky = 0.1 
        self.conv3x3 = conv_bn_no_relu(in_channel, out_channel//2, stride=1) 
 
        # 用 2 个 3 x 3 的卷积来代替 5 x 5 的卷积 
        self.conv5x5_1 = conv_bn(in_channel, out_channel//4, stride=1, leaky = leaky) 
        self.conv5x5_2 = conv_bn_no_relu(out_channel//4, out_channel//4, stride=1) 
        # 使用 3 个 3 x 3 的卷积来代替 7 x 7 的卷积 
        self.conv7x7_2 = conv_bn(out_channel//4, out_channel//4, stride=1, leaky = leaky) 
        self.conv7x7_3 = conv_bn_no_relu(out_channel//4, out_channel//4, stride=1) 
 
    def forward(self, input): 
        conv3x3 = self.conv3x3(input) 
 
        conv5x5_1 = self.conv5x5_1(input) 
        conv5x5 = self.conv5x5_2(conv5x5_1) 
 
        conv7x7_2 = self.conv7x7_2(conv5x5_1) 
        conv7x7 = self.conv7x7_3(conv7x7_2) 
 
        # 堆叠 
        out = torch.cat([conv3x3, conv5x5, conv7x7], dim=1) 
        out = f.relu(out) 
        return out