基于 PyTorch 搭建 DarkNet53 模型架构与训练实战

基于 PyTorch 搭建 DarkNet53 模型架构与训练实战

DarkNet 架构与原理

DarkNet 是由 Joseph Redmon 创建的开源神经网络框架，以 C 和 CUDA 实现，支持 CPU 和 GPU 计算。在深度学习领域，提到'Darknet'通常指 YOLO 系列目标检测算法所使用的骨干网络结构。

本文重点介绍 DarkNet53，它是 YOLOv3 之后采用的主干特征提取网络。该模型包含 53 个卷积层，摒弃了传统的池化层下采样，转而使用步幅为 2 的卷积操作。这种设计在减少参数量的同时更好地保留了图像细节，配合 3×3 和 1×1 卷积核以及 LeakyReLU 激活函数，有效提升了非线性表达能力。

对于传入图像，DarkNet 通过多层卷积提取特征，随后传递给全连接层进行分类或回归。其较大的感受野使其能捕捉不同尺度的图像特征，结合检测头部即可实现对多目标的精准定位。

目标检测应用背景

随着深度学习技术的普及，目标检测已成为计算机视觉的核心研究方向之一，广泛应用于无人驾驶、安防监控等场景。DarkNet 作为高效的特征提取器，在此类任务中表现优异。

PyTorch 代码实践

以下示例演示如何使用 PyTorch 框架加载数据、定义 DarkNet53 模型并进行训练，同时展示网络结构统计。

数据准备

假设已准备好包含图片路径的 CSV 文件：

import pandas as pd

# 读取 CSV 文件
data = pd.read_csv("my_csv")

模型定义

我们自定义了 BN_Conv2d、SE 模块及 Dark_block 残差单元，构建完整的 DarkNet 网络。

import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary

class SE(nn.Module):
    def __init__(self, in_chnls, ratio):
        super(SE, self).__init__()
        self.squeeze = nn.AdaptiveAvgPool2d((1, 1))
        self.compress = nn.Conv2d(in_chnls, in_chnls // ratio, 1, 1, 0)
        .excitation = nn.Conv2d(in_chnls // ratio, in_chnls, , , )

     ():
        out = .squeeze(x)
        out = .compress(out)
        out = F.relu(out)
        out = .excitation(out)
         x * F.sigmoid(out)
    

 (nn.Module):
     ():
        (BN_Conv2d, ).__init__()
        layers = [nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride,
                            padding=padding, dilation=dilation, groups=groups, bias=bias),
                  nn.BatchNorm2d(out_channels)]
         activation   :
            layers.append(activation)
        .seq = nn.Sequential(*layers)

     ():
         .seq(x)
    

 (nn.Module):
     ():
        (BN_Conv2d_Leaky, ).__init__()
        .seq = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride,
                      padding=padding, dilation=dilation, groups=groups, bias=bias),
            nn.BatchNorm2d(out_channels)
        )

     ():
         F.leaky_relu(.seq(x))
    

 (nn.Module):
    
     ():
        (Dark_block, ).__init__()
        .is_se = is_se
         inner_channels  :
            inner_channels = channels // 
        .conv1 = BN_Conv2d_Leaky(channels, inner_channels, , , )
        .conv2 = nn.Conv2d(inner_channels, channels, , , )
        .bn = nn.BatchNorm2d(channels)
         .is_se:
            .se = SE(channels, )

     ():
        out = .conv1(x)
        out = .conv2(out)
        out = .bn(out)
         .is_se:
            coefficient = .se(out)
            out *= coefficient
        out += x
         F.leaky_relu(out)
    

 (nn.Module):
     ():
        (DarkNet, ).__init__()
        .is_se = is_se
        filters = [, , , , ]

        .conv1 = BN_Conv2d(, , , , )
        .redu1 = BN_Conv2d(, , , , )
        .conv2 = .__make_layers(filters[], layers[])
        .redu2 = BN_Conv2d(filters[], filters[], , , )
        .conv3 = .__make_layers(filters[], layers[])
        .redu3 = BN_Conv2d(filters[], filters[], , , )
        .conv4 = .__make_layers(filters[], layers[])
        .redu4 = BN_Conv2d(filters[], filters[], , , )
        .conv5 = .__make_layers(filters[], layers[])
        .redu5 = BN_Conv2d(filters[], filters[], , , )
        .conv6 = .__make_layers(filters[], layers[])
        .global_pool = nn.AdaptiveAvgPool2d((, ))
        .fc = nn.Linear(filters[], num_classes)

     ():
        layers = []
         _  (num_layers):
            layers.append(Dark_block(num_filter, .is_se))
         nn.Sequential(*layers)

     ():
        out = .conv1(x)
        out = .redu1(out)
        out = .conv2(out)
        out = .redu2(out)
        out = .conv3(out)
        out = .redu3(out)
        out = .conv4(out)
        out = .redu4(out)
        out = .conv5(out)
        out = .redu5(out)
        out = .conv6(out)
        out = .global_pool(out)
        out = out.view(out.size(), -)
        out = .fc(out)
         out


 ():
     DarkNet([, , , , ], num_classes)


 ():
    net = darknet_53()
    summary(net, (, , ))

test()