yolov3 darknet53网络及mobilenet改进附完整pytorch代码

偏执的太偏执、 2022-02-17 06:28 614阅读 0赞

### 一. 原理介绍 ###

**1.darknet53网络结构**

基本由1\*1与3\*3卷积构成，因为网络中有53个卷积层，所以叫做Darknet-53(不包含残差层里的2个卷积)。结构图直接引用一个博主总结的，简洁明了  [https://blog.csdn.net/qq\_37541097/article/details/81214953\#commentBox][https_blog.csdn.net_qq_37541097_article_details_81214953_commentBox]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 1][]

## ##

**2. mobilenet网络介绍**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 2][]

注意好好理解一下卷积nn,Conv2d()里的参数groups的作用；

mobilenet详解可参考这个  [https://blog.csdn.net/u011974639/article/details/79199306][https_blog.csdn.net_u011974639_article_details_79199306]

### 二. 代码实现 ###

**1.    darknet53.py**

import torch
    import torch.nn as nn
    import time
    
    class Conv2d(nn.Module):
        def __init__(self, inc, ouc, k, s, p):
            super(Conv2d, self).__init__()
            self.conv = nn.Sequential(
                nn.Conv2d(inc, ouc, k, s, p),
                nn.BatchNorm2d(ouc),
                nn.LeakyReLU()
            )
    
        def forward(self, x):
            return self.conv(x)
    
    
    class ConvSet(nn.Module):  # inc->ouc
        def __init__(self, inc, ouc):
            super(ConvSet, self).__init__()
            self.convset = nn.Sequential(
                Conv2d(inc, ouc, 1, 1, 0),
                Conv2d(ouc, ouc, 3, 1, 1),
                Conv2d(ouc, ouc * 2, 1, 1, 0),
                Conv2d(ouc * 2, ouc * 2, 3, 1, 1),
                Conv2d(ouc * 2, ouc, 1, 1, 0)
            )
    
        def forward(self, x):
            return self.convset(x)
    
    
    class Upsampling(nn.Module):
        def __init__(self):
            super(Upsampling, self).__init__()
    
        def forward(self, x):
            return nn.functional.interpolate(x, scale_factor=2, mode='nearest')
    
    
    class Downsampling(nn.Module):
        def __init__(self, inc, ouc):
            super(Downsampling, self).__init__()
            self.d = nn.Sequential(
                Conv2d(inc, ouc, 3, 2, 1)
            )
    
        def forward(self, x):
            return self.d(x)
    
    
    class Residual(nn.Module):  # inc->inc
        def __init__(self, inc):
            super(Residual, self).__init__()
            self.r = nn.Sequential(
                Conv2d(inc, inc // 2, 1, 1, 0),
                Conv2d(inc // 2, inc, 3, 1, 1)
            )
    
        def forward(self, x):
            return x + self.r(x)
    
    
    class MainNet(nn.Module):
        def __init__(self):
            super(MainNet, self).__init__()
    
            self.d52 = nn.Sequential(
                Conv2d(3, 32, 3, 1, 1),  # 416
                Conv2d(32, 64, 3, 2, 1),  # 208
    
                # 1x
                Conv2d(64, 32, 1, 1, 0),
                Conv2d(32, 64, 3, 1, 1),
                Residual(64),
    
                Downsampling(64, 128),  # 104
    
                # 2x
                Conv2d(128, 64, 1, 1, 0),
                Conv2d(64, 128, 3, 1, 1),
                Residual(128),
    
                Conv2d(128, 64, 1, 1, 0),
                Conv2d(64, 128, 3, 1, 1),
                Residual(128),
    
                Downsampling(128, 256),  # 52
    
                # 8x
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256),
    
                Conv2d(256, 128, 1, 1, 0),
                Conv2d(128, 256, 3, 1, 1),
                Residual(256)
            )
    
            self.d26 = nn.Sequential(
                Downsampling(256, 512),  # 26
    
                # 8x
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512),
    
                Conv2d(512, 256, 1, 1, 0),
                Conv2d(256, 512, 3, 1, 1),
                Residual(512)
            )
    
            self.d13 = nn.Sequential(
                Downsampling(512, 1024),  # 13
    
                # 4x
                Conv2d(1024, 512, 1, 1, 0),
                Conv2d(512, 1024, 3, 1, 1),
                Residual(1024),
    
                Conv2d(1024, 512, 1, 1, 0),
                Conv2d(512, 1024, 3, 1, 1),
                Residual(1024),
    
                Conv2d(1024, 512, 1, 1, 0),
                Conv2d(512, 1024, 3, 1, 1),
                Residual(1024),
    
                Conv2d(1024, 512, 1, 1, 0),
                Conv2d(512, 1024, 3, 1, 1),
                Residual(1024)
            )
            '---------------------------------------------------------'
    
            self.convset_13 = nn.Sequential(
                ConvSet(1024, 512)
            )
    
            self.detection_13 = nn.Sequential(
                Conv2d(512, 512, 3, 1, 1),
                nn.Conv2d(512, 18, 1, 1, 0)  # ?????????????????18
            )
    
            self.conv_13 = nn.Sequential(
                Conv2d(512, 256, 1, 1, 0)
            )
    
            self.up_to_26 = nn.Sequential(
                Upsampling()
            )
            '---------------------------------------------------------'
    
            self.convset_26 = nn.Sequential(
                ConvSet(768, 512)  # 经concat，通道相加512+256=768
            )
    
            self.detection_26 = nn.Sequential(
                Conv2d(512, 512, 3, 1, 1),
                nn.Conv2d(512, 18, 1, 1, 0)
            )
    
            self.conv_26 = nn.Sequential(
                Conv2d(512, 256, 1, 1, 0)
            )
    
            self.up_to_52 = nn.Sequential(
                Upsampling()
            )
            '---------------------------------------------------------'
    
            self.convset_52 = nn.Sequential(
                ConvSet(512, 512)  # 经concat，通道相加256+256=512
            )
    
            self.detection_52 = nn.Sequential(
                Conv2d(512, 512, 3, 1, 1),
                nn.Conv2d(512, 18, 1, 1, 0)
            )
    
        def forward(self, x):
            x_52 = self.d52(x)
            x_26 = self.d26(x_52)
            x_13 = self.d13(x_26)
    
            x_13_ = self.convset_13(x_13)
            out_13 = self.detection_13(x_13_)  # 13*13输出
    
            y_13_ = self.conv_13(x_13_)
            y_26 = self.up_to_26(y_13_)
            '----------------------------------------------------------'
    
            y_26_cat = torch.cat((y_26, x_26), dim=1)  # 26*26连接
            x_26_ = self.convset_26(y_26_cat)
            out_26 = self.detection_26(x_26_)
    
            y_26_ = self.conv_26(x_26_)
            y_52 = self.up_to_52(y_26_)
            '----------------------------------------------------------'
    
            y_52_cat = torch.cat((y_52, x_52), dim=1)
            x_52_ = self.convset_52(y_52_cat)
            out_52 = self.detection_52(x_52_)
    
            return out_13, out_26, out_52
    
    
    if __name__ == '__main__':
        trunk = MainNet()
        # print(sum(param.numel() for param in trunk.parameters()))
        trunk.eval()
        trunk.cuda().half()
        x = torch.cuda.HalfTensor(1, 3, 128, 128)
    
        y_13, y_26, y_52 = trunk(x)
        # print(y_13.shape)
        # print(y_26.shape)
        # print(y_52.shape)
    
        for _ in range(15):
            start_time = time.time()
            trunk(x)
            end_time = time.time()
            print(end_time - start_time)
            print("===================================")

用时如下，0.04s多：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 3][]

**2.  (改进版)mobilenetv1.py**

辅助理解   [https://blog.csdn.net/MOU\_IT/article/details/84955532][https_blog.csdn.net_MOU_IT_article_details_84955532]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 5][]

import torch
    import time
    
    
    class MobileLayer(torch.nn.Module):
    
        def __init__(self, in_channels, out_channels, stride=1):
            super(MobileLayer, self).__init__()
    
            self.in_channels = in_channels
            self.out_channels = out_channels
            self.stride = stride
    
            '1*1用的(1,1,0)—不变, 3*3用的(3,1,1)—不变和(3,2,1)—减半'
            self.sub_module = torch.nn.Sequential(
                torch.nn.Conv2d(in_channels, in_channels, 3, stride, 1, groups=in_channels, bias=False), #深度卷积
                torch.nn.BatchNorm2d(in_channels),
                torch.nn.LeakyReLU(0.1, True),
    
                torch.nn.Conv2d(in_channels, out_channels, 1, 1, 0, bias=False), #点卷积
                torch.nn.BatchNorm2d(out_channels),
                torch.nn.LeakyReLU(0.1, True)
            )
    
        def forward(self, x):
            if self.stride == 1 and self.in_channels == self.out_channels: #此处照顾了yolov3需要残差结构，故v1也加了残差
                return self.sub_module(x) + x
            else:
                return self.sub_module(x)
    
    class UpsampleLayer(torch.nn.Module):
    
        def __init__(self):
            super(UpsampleLayer, self).__init__()
    
        def forward(self, x):
            return torch.nn.functional.interpolate(x, scale_factor=2, mode='bilinear')
    
    class ConvolutionalSet(torch.nn.Module):
        def __init__(self, in_channels, out_channels):
            super(ConvolutionalSet, self).__init__()
    
            self.sub_module = torch.nn.Sequential(
                MobileLayer(in_channels, out_channels),
                MobileLayer(out_channels, out_channels),
            )
    
        def forward(self, x):
            return self.sub_module(x)
    
    class MainNet(torch.nn.Module):
    
        def __init__(self):
            super(MainNet, self).__init__()
    
            self.trunk_52 = torch.nn.Sequential(
                torch.nn.Conv2d(3, 32, 3, 1, 1),  # 416
                torch.nn.Conv2d(32, 64, 1, 2, 0),  # 208，下采样
    
                MobileLayer(64, 64), #每当self.stride == 1 and self.in_channels == self.out_channels，执行残差
    
                MobileLayer(64, 128, 2),  # 104, 下采样
    
                # MobileLayer(128, 128),
                # MobileLayer(128, 128),
                MobileLayer(128, 128),
    
                MobileLayer(128, 256, 2),  # 52，下采样
            )
    
            self.trunk_26 = torch.nn.Sequential(
                # MobileLayer(256, 256, 3),
                # MobileLayer(256, 256, 3),
                MobileLayer(256, 256),
    
                MobileLayer(256, 512, 2),  # 26，下采样
            )
    
            self.trunk_13 = torch.nn.Sequential(
                # MobileLayer(512, 512),
                # MobileLayer(512, 512),
                MobileLayer(512, 512),
    
                MobileLayer(512, 1024, 2),  # 13，下采样
            )
    
            self.convset_13 = torch.nn.Sequential(
                ConvolutionalSet(1024, 512)
            )
    
            self.detetion_13 = torch.nn.Sequential(
                # MobileLayer(512, 512, 3),
                torch.nn.Conv2d(512, 21, 3, 1, 1)
            )
    
            self.up_26 = torch.nn.Sequential(
                MobileLayer(512, 256),
                UpsampleLayer()
            )
    
            self.convset_26 = torch.nn.Sequential(
                ConvolutionalSet(768, 256)
            )
    
            self.detetion_26 = torch.nn.Sequential(
                torch.nn.Conv2d(256, 21, 3, 1, 1)
            )
    
            self.up_52 = torch.nn.Sequential(
                MobileLayer(256, 128),
                UpsampleLayer()
            )
    
            self.convset_52 = torch.nn.Sequential(
                ConvolutionalSet(384, 128)
            )
    
            self.detetion_52 = torch.nn.Sequential(
                MobileLayer(128, 128),
                torch.nn.Conv2d(128, 21, 3, 1, 1)
            )
    
        def forward(self, x):
            # start_time = time.time()
            h_52 = self.trunk_52(x)
            h_26 = self.trunk_26(h_52)
            h_13 = self.trunk_13(h_26)
    
            convset_out_13 = self.convset_13(h_13)
            detetion_out_13 = self.detetion_13(convset_out_13)
    
            # end_time = time.time()
            # print("........................",end_time - start_time)
    
            up_out_26 = self.up_26(convset_out_13)
            route_out_26 = torch.cat((up_out_26, h_26), dim=1)
            convset_out_26 = self.convset_26(route_out_26)
            detetion_out_26 = self.detetion_26(convset_out_26)
    
            up_out_52 = self.up_52(convset_out_26)
            route_out_52 = torch.cat((up_out_52, h_52), dim=1)
            convset_out_52 = self.convset_52(route_out_52)
            detetion_out_52 = self.detetion_52(convset_out_52)
    
            return detetion_out_13, detetion_out_26, detetion_out_52
    
    
    if __name__ == '__main__':
        trunk = MainNet()
        # print(sum(param.numel() for param in trunk.parameters()))
        trunk.eval()
        trunk.cuda().half()
        x = torch.cuda.HalfTensor(1, 3, 128, 128)
    
        y_13, y_26, y_52 = trunk(x)
        # print(y_13.shape)
        # print(y_26.shape)
        # print(y_52.shape)
    
        for _ in range(15):
            start_time = time.time()
            trunk(x)
            end_time = time.time()
            print(end_time - start_time)
            print("===================================")

用时如下，将近0.02s：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 6][]

[https_blog.csdn.net_qq_37541097_article_details_81214953_commentBox]: https://blog.csdn.net/qq_37541097/article/details/81214953#commentBox
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70]: /images/20220217/854a4d16c0da45b5976e99be6327a848.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 1]: /images/20220217/1e47553d4110461f9136a232fe02cbe6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 2]: /images/20220217/68e0589c71b04174a916cbff07275c88.png
[https_blog.csdn.net_u011974639_article_details_79199306]: https://blog.csdn.net/u011974639/article/details/79199306
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 3]: /images/20220217/04fd099bcf7b46cebe40061a8c523ca6.png
[https_blog.csdn.net_MOU_IT_article_details_84955532]: https://blog.csdn.net/MOU_IT/article/details/84955532
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 4]: /images/20220217/56b9bbd87633477190e95585ee9d4e24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 5]: /images/20220217/91b40acb194d4d0486adaab54def8498.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTM4NjY2_size_16_color_FFFFFF_t_70 6]: /images/20220217/ce0131329cbf4e6d99b4a31f59b2b6c9.png