YOLO目标检测3

news2025/1/28 1:28:37

一. 参考资料

《YOLO目标检测》 by 杨建华博士

本篇文章的主要内容来自于这本书，只是作为学习记录进行分享。

二. 搭建YOLOv1的网络

2.1 YOLOv1的网络结构

作者带我们构建的YOLOv1网络是一个全卷积结构，其中不包含任何全连接层，这一点可以避免YOLOv1中存在的因全连接层而导致的参数过多的问题。尽管YOLO网络是在YOLOv2工作才开始转变为全卷积结构，但我们已经了解了全连接层的弊端，因此没有必要再循规蹈矩地照搬YOLOv1的原始网络结构，这也符合我们设计YOLOv1的初衷。

2.1.1 主干网络

使用当下流行的ResNet网络代替YOLOv1的GoogLeNet风格的主干网络。相较于原本的主干网络，ResNet使用了诸如批归一化(batch normalization，BN)、残差连接(residual connection)等操作，有助于稳定训练更大更深的网络。

前面已经讲过，将图像分类网络用作目标检测网络的主干网络时，通常是不需要最后的平均池化层和分类层的，因此，这里去除ResNet-18网络中的最后的平均池化层和全连接层，

这里使用的ResNet-18网络的最大降采样倍数为32，在这个网络中，默认输入图像尺寸为 $416 \times 416$ ，最后的输出图像为 $14 \times 14$ ，要比传统的YOLOv1更精细些。

根据书中提供的代码，实现ResNet主干网络的关键部分的代码为：

# YOLO_Tutorial/models/yolov1/yolov1_backbone.py
# --------------------------------------------------------
...
class ResNet(nn.Module):
    def __init__(self, block, layers, zero_init_residual=False):
        super(ResNet, self).__init__()
        self.inplanes=64
        self.conv1=nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1=nn.BatchNorm2d(64)
        self.relu=nn.ReLU(inplace=True)
        self.maxpool=nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1=self._make_layer(block, 64, layers[0])
        self.layer2=self._make_layer(block, 128, layers[1], stride=2)
        self.layer3=self._make_layer(block, 256, layers[2], stride=2)
        self.layer4=self._make_layer(block, 512, layers[3], stride=2)
　
    def forward(self, x):
        c1=self.conv1(x)     # [B, C, H/2, W/2]
        c1=self.bn1(c1)      # [B, C, H/2, W/2]
        c1=self.relu(c1)     # [B, C, H/2, W/2]
        c2=self.maxpool(c1)  # [B, C, H/4, W/4]
　
        c2=self.layer1(c2)   # [B, C, H/4, W/4]
        c3=self.layer2(c2)   # [B, C, H/8, W/8]
        c4=self.layer3(c3)   # [B, C, H/16, W/16]
        c5=self.layer4(c4)   # [B, C, H/32, W/32]
　
        return c5

2.1.2 颈部网络

出于参数和性能的综合考虑，作者使用性价比较高的空间金字塔池化(SPP)模块，遵循主流的YOLO框架的做法，对SPP模块进行适当的改进。

改进的SPP模块的网络结构设计参考了YOLOv5开源项目中的实现方法，让一层5×5的最大池化层等效于先前讲过的5×5、9×9和13×13这三条并行的最大池化层分支，从而降低计算开销，这也和之前所讲的空间金字塔的特性相同，通过逐层卷积能够从小到大找到不同尺寸的目标，再将不同的卷积结果叠起来进行最终的输出。

# YOLO_Tutorial/models/yolov1/yolov1_neck.py
# --------------------------------------------------------
...
class SPPF(nn.Module):
    def __init__(self, in_dim, out_dim, expand_ratio=0.5, pooling_size=5,
                 act_type='lrelu', norm_type='BN'):
        super().__init__()
        inter_dim=int(in_dim * expand_ratio)
        self.out_dim=out_dim
        self.cv1=Conv(in_dim, inter_dim, k=1, act_type=act_type, norm_type=
          norm_type)
        self.cv2=Conv(inter_dim * 4, out_dim, k=1, act_type=act_type, norm_type=
          norm_type)
        self.m=nn.MaxPool2d(kernel_size=pooling_size, stride=1, padding=pooling_
          size // 2)
　
    def forward(self, x):
        x=self.cv1(x)
        y1=self.m(x)
        y2=self.m(y1)
        return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))

在代码4-2中，输入的特征图会先被一层 $1 \times 1$ 卷积处理，其通道数会被压缩一半，随后再由一层 $5 \times 5$ 最大池化层连续处理三次，依据感受野的原理，该处理方式等价于分别使用 $5 \times 5$ 、 $9 \times 9$ 和 $13 \times 13$ 最大池化层并行地处理特征图。最后，将所有处理后的特征图沿通道拼接，再由另一层 $1 \times 1$ 卷积做一次输出的映射，将其通道映射至指定数目的输出通道。

2.1.3 检测头

在YOLOv1中，检测头部分用的是全连接层，全连接层具有参数过多，过于占用内存空间的缺点，这里，我们抛弃全连接层，改用卷积网络。由于当前主流的检测头是解耦检测头，因此，我们也采用解耦检测头作为YOLOv1的检测头，由类别分支和回归分支组成，类别分支进行类别和置信度预测，回归分支进行位置参数预测，如图4-4所示。

检测头的结构十分简单，共输出两种不同的特征：类别特征 $\mathbf{F}_{cls} \in \mathbb{R}^{13 \times 13 \times 512}$ 和位置特征 $\mathbf{F}_{reg} \in \mathbb{R}^{13 \times 13 \times 512}$ ，没有复杂结构，代码编写简单，作者实现了相关代码，如以下代码所示：

# YOLO_Tutorial/models/yolov1/yolov1_head.py
# --------------------------------------------------------
...
class DecoupledHead(nn.Module):
    def __init__(self, cfg, in_dim, out_dim, num_classes=80):
        super().__init__()
        print('==============================')
        print('Head: Decoupled Head')
        self.in_dim=in_dim
        self.num_cls_head=cfg['num_cls_head']
        self.num_reg_head=cfg['num_reg_head']
        self.act_type=cfg['head_act']
        self.norm_type=cfg['head_norm']
　
        # cls head
        cls_feats=[]
        self.cls_out_dim=max(out_dim, num_classes)
        for i in range(cfg['num_cls_head']):
            if i==0:
                cls_feats.append(
                    Conv(in_dim, self.cls_out_dim, k=3, p=1, s=1,
                        act_type=self.act_type,
                        norm_type=self.norm_type,
                        depthwise=cfg['head_depthwise'])
                        )
            else:
                cls_feats.append(
                    Conv(self.cls_out_dim, self.cls_out_dim, k=3, p=1, s=1,
                        act_type=self.act_type,
                        norm_type=self.norm_type,
                        depthwise=cfg['head_depthwise'])
                        )
        # reg head
        reg_feats=[]
        self.reg_out_dim=max(out_dim, 64)
        for i in range(cfg['num_reg_head']):
            if i==0:
                reg_feats.append(
                    Conv(in_dim, self.reg_out_dim, k=3, p=1, s=1,
                        act_type=self.act_type,
                        norm_type=self.norm_type,
                        depthwise=cfg['head_depthwise'])
                        )
            else:
                reg_feats.append(
                    Conv(self.reg_out_dim, self.reg_out_dim, k=3, p=1, s=1,
                        act_type=self.act_type,
                        norm_type=self.norm_type,
                        depthwise=cfg['head_depthwise'])
                        )
　
        self.cls_feats=nn.Sequential(*cls_feats)
        self.reg_feats=nn.Sequential(*reg_feats)
　
    def forward(self, x):
        cls_feats=self.cls_feats(x)
        reg_feats=self.reg_feats(x)
　
        return cls_feats, reg_feats

2.1.4 预测层

在官方的YOLOv1中，每个网格预测两个边界框，而这两个边界框的学习完全依赖自身预测的边界框位置的准确性，YOLOv1本身并没有对这两个边界框做任何约束。可以认为，这两个边界框是“平权”的，谁学得好谁学得差完全是随机的，二者之间没有显式的互斥关系，且每个网格处最终只会输出置信度最大的边界框，那么可以将这两个“平权”的边界框修改为一个边界框，即每个网格处只需要输出一个边界框。于是，我们的YOLOv1网络最终输出的张量为 $\mathbf{Y} \in \mathbb{R}^{13 \times 13 \times (1+N_c+4)}$ ，其中通道维度上的1表示边界框的置信度， $N_c$ 表示类别的总数，4表示边界框的4个位置参数。这里不再有表示每个网格的边界框数量的 $B$ 。