轻量级人脸属性Slim-CNN

╰半夏微凉° 2022-10-07 10:46 164阅读 0赞

文章链接：https://arxiv.org/abs/1907.02157

作者提出了一种micro-architecture 名字叫Slim Module的轻量网络结构，网络结构中使用了depthwise separable convolutions（什么是depthwise separable convolutions，可以只看总结）这种结构，实验数据集是CelebA datasets，获得了91.24%的精度，但是参数与可执行方法相比较（comparable performing methods）少了25倍。

作者的方法

作者提出来的micro-architecture包括以下特点：

1）多分支（如：Inception and ResNets），网络结构中多分支意味着网络中有多条路径可以传递判别性信息（discrimination features）；

2）卷积核小（如：VGG-Net and GoogleNet，卷积核大小【1\*1,3\*3,5\*5】），提升网络结构的性能，减少训练参数；

3）skip-connections（跳层连接）

提出的slim module：

然后整体的网络结构细节：

和结构框架：

作者使用了sigmoid cross-entropy loss函数：

根据作者提供的信息，我还没将网络结构搭建出来；

实验1：作者在CelebA上进行几种人脸属性分类方法的横向比较实验：

通过表三，作者想说明，虽然自己的方法不是最好的，但是与平均精度排名第一的论文【4】的方法相比较，所占空间最小7.9M，参数量最少0.6M，而且精度还没有差太多。

实验2：作者将slim-net与其他几种深度学习的微结构（micro-architecture)进行了比较,实验结果：

（实验细节需要自行移步到论文的4.3.2节）

实验3：作者对slim-module中的3\*3卷积核的depthwise separable convolutional层的卷积核进行了探究性的实验，  
原文链接：https://blog.csdn.net/qq\_22764813/article/details/97803221

有预训练 pytorch：

[https://github.com/gtamba/pytorch-slim-cnn][https_github.com_gtamba_pytorch-slim-cnn]

torch网络结构：

[https://github.com/Joyako/Slim-CNN/blob/master/SlimCNN/slim\_cnn.py][https_github.com_Joyako_Slim-CNN_blob_master_SlimCNN_slim_cnn.py]

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class ConvBNReLU(nn.Sequential):
        def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1):
            padding = (kernel_size - 1) // 2
            super(ConvBNReLU, self).__init__(
                nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=False),
                nn.BatchNorm2d(out_planes),
                nn.ReLU(inplace=True)
            )
    
    
    class DWSeparableConv(nn.Module):
        """Depth-Wise Separable Convolution"""
        def __init__(self, inp, oup):
            super().__init__()
            self.dwc = ConvBNReLU(inp, inp, kernel_size=3, groups=inp)
            self.pwc = ConvBNReLU(inp, oup, kernel_size=1)
    
        def forward(self, x):
            x = self.dwc(x)
            x = self.pwc(x)
    
            return x
    
    
    class SSEBlock(nn.Module):
        """Separable Squeeze-Expand Block"""
        def __init__(self, inp, oup):
            super().__init__()
            out_channel = oup * 4
            self.pwc1 = ConvBNReLU(inp, oup, kernel_size=1)
            self.pwc2 = ConvBNReLU(oup, out_channel, kernel_size=1)
            self.dwc = DWSeparableConv(oup, out_channel)
    
        def forward(self, x):
            x = self.pwc1(x)
            out1 = self.pwc2(x)
            out2 = self.dwc(x)
    
            return torch.cat((out1, out2), 1)
    
    
    class SlimModule(nn.Module):
        def __init__(self, inp, oup):
            super().__init__()
            hidden_dim = oup * 4
            out_channel = oup * 3
            self.sse1 = SSEBlock(inp, oup)
            self.sse2 = SSEBlock(hidden_dim * 2, oup)
            self.dwc = DWSeparableConv(hidden_dim * 2, out_channel)
            self.conv = ConvBNReLU(inp, hidden_dim * 2, kernel_size=1)
    
        def forward(self, x):
            out = self.sse1(x)
            out += self.conv(x)
            out = self.sse2(out)
            out = self.dwc(out)
    
            return out
    
    
    class SlimNet(nn.Module):
        def __init__(self, num_classes):
            super().__init__()
            self.conv = ConvBNReLU(3, 96, kernel_size=7, stride=2)
            self.max_pool0 = nn.MaxPool2d(kernel_size=3, stride=2)
    
            # 4 stacked Slim Module
            self.module1 = SlimModule(96, 16)
            self.module2 = SlimModule(48, 32)
            self.module3 = SlimModule(96, 48)
            self.module4 = SlimModule(144, 64)
    
            self.max_pool1 = nn.MaxPool2d(kernel_size=3, stride=2)
            self.max_pool2 = nn.MaxPool2d(kernel_size=3, stride=2)
            self.max_pool3 = nn.MaxPool2d(kernel_size=3, stride=2)
            self.max_pool4 = nn.MaxPool2d(kernel_size=3, stride=2)
    
            self.gap = nn.AdaptiveAvgPool2d((1, 1))
            self.fc = nn.Linear(192, num_classes)
    
        def forward(self, x):
            x = self.max_pool0(self.conv(x))
            x = self.max_pool1(self.module1(x))
            x = self.max_pool2(self.module2(x))
            x = self.max_pool3(self.module3(x))
            x = self.max_pool4(self.module4(x))
    
            # global average pooling
            x = self.gap(x)
            x = torch.flatten(x, 1)
            x = self.fc(x)
            x = F.sigmoid(x)
    
            return x
    
    from torchstat import stat
    net =SlimNet(4)
    stat(net, (3, 178, 218))

[https_github.com_gtamba_pytorch-slim-cnn]: https://github.com/gtamba/pytorch-slim-cnn
[https_github.com_Joyako_Slim-CNN_blob_master_SlimCNN_slim_cnn.py]: https://github.com/Joyako/Slim-CNN/blob/master/SlimCNN/slim_cnn.py