• yolov7添加GAMAttention注意力机制，同时添加CNeB，C3C2

    1、主要贡献
        主要是现有的一些trick的集合以及模块重参化和动态标签分配策略，最终在 5 FPS 到 160 FPS 范围内的速度和准确度都超过了所有已知的目标检测器。

        当前目标检测主要的优化方向：更快更强的网络架构；更有效的特征集成方法；更准确的检测方法；更精确的损失函数；更有效的标签分配方法；更有效的训练方法。

    2、主要思路
        按照论文，目前模型精度和推理性能比较均衡的是yolov7 模型(对应的开源git版本为0.1版)。根据源码+导出的onnx文件+“张大刀”等的网络图（修改了其中目前我认为的一些bug，增加一些细节）。重新绘制了yoloV7 0.1版本的非常详尽网络结构。注意：

        1）其中的特征图结果维度注释是按照箭头的流方向，不是固定的上下方向。

        2）输入输出仅仅是指当前模块的输入输出，整体需要根据流方向累乘计算最终的结果。

        3）该模型版本没有辅助训练头。

        整体上和YOLOV5是相似的，主要是网络结构的内部组件的更换（涉及一些新的sota的设计思想）、辅助训练头、标签分配思想等

    3、具体细节
        1）input
        整体复用YOLOV5的预处理方式和相关源码，唯一需要注意的是，官方主要是在640*640和1280*1280这样的相对较大的图片上进行的训练和测试。

        具体参考我的另一篇YOLOV5博客中的 “具体细节” -> ‘input’ 章节即可。目标检测算法——YOLOV5_TigerZ*的博客-CSDN博客_目标检测yolov5

        2）backbone
        主要是使用ELAN（该版本模型并没有使用论文里提到的最复杂的E-ELAN结构） 和 MP 结构。该版本模型的激活函数使用的是Silu。

        详细可以参考源码的 cfg/training/yolov7.yaml 文件 + models/yolo.py 文件 + 使用 export.py 导出onnx 结构使用 netron等软件来梳理。

        a.ELAN结构
        通过控制最短最长的梯度路径，更深的网络可以有效地学习和收敛。作者提出ELAN结构。基于ELAN设计的E-ELAN 用expand、shuffle、merge cardinality来实现在不破坏原有梯度路径的情况下不断增强网络学习能力的能力。（PS：该版本模型以及E6E网友反馈均未实现E-ELAN），论文中相关的图如下，其中的cross stage connection 其实就是1*1卷积：

    .MP 结构
        个人认为这是一个相对鸡贼的结构，之前下采样我们通常最开始使用maxpooling，之后大家又都选用stride = 2的3*3卷积。这里作者充分发挥：“小孩子才做选择，大人都要”的原则，同时使用了max pooling 和 stride=2的conv。  需要注意backbone中的MP前后通道数是不变的。

    neck & head
        检测头整体结构和YOLOV5类似，仍然是anchor based 结构，仍然没有使用YOLOX 和YOLOV6 的解耦头（分类和检测）思路，这一点目前不太理解，后续有精力可以魔改一下。主要是使用了：

        *SPPCSPC结构

        *ELAN-W（我自己命名非官方名字，因为基本上和ELAN类似，但是又不是论文中的E-ELAN）

        *MP 结构（和backbone参数不同）

        *比较流行的重参数化结构Rep结构

        以上参见本篇博客中的“主要思路”中的整体图，里面就有可视化的这些部件，可以非常直观的理解这些结构。详细可以参考源码的 cfg/training/yolov7.yaml 文件 + models/yolo.py 文件 + 使用 export.py 导出onnx 结构使用 netron等软件来梳理。

    loss function
        主要分带和不带辅助训练头两种，对应的训练脚本是train.py 和 train_aux.py。

        不带辅助训练头（分损失函数和匹配策略两部分讨论）。
        损失函数

        整体和YOLOV5 保持一致，分为坐标损失、目标置信度损失（GT就是训练阶段的普通iou）和分类损失三部分。其中目标置信度损失和分类损失采用BCEWithLogitsLoss（带log的二值交叉熵损失），坐标损失采用CIoU损失。详细参见utils/loss.py 里面的 ComputeLossOTA 函数 配合 配置文件里的各部分的权重设置。

        匹配策略

        主要是参考了YOLOV5 和YOLOV6使用的当下比较火的simOTA.

        S1.训练前，会基于训练集中gt框，通过k-means聚类算法，先验获得9个从小到大排列的anchor框。(可选)

        S2.将每个gt与9个anchor匹配：Yolov5为分别计算它与9种anchor的宽与宽的比值（较大的宽除以较小的宽，比值大于1，下面的高同样操作）、高与高的比值，在宽比值、高比值这2个比值中，取最大的一个比值，若这个比值小于设定的比值阈值，这个anchor的预测框就被称为正样本。一个gt可能与几个anchor均能匹配上（此时最大9个）。所以一个gt可能在不同的网络层上做预测训练，大大增加了正样本的数量，当然也会出现gt与所有anchor都匹配不上的情况，这样gt就会被当成背景，不参与训练，说明anchor框尺寸设计的不好。

        S3.扩充正样本。根据gt框的中心位置，将最近的2个邻域网格也作为预测网格，也即一个groundtruth框可以由3个网格来预测；可以发现粗略估计正样本数相比前yolo系列，增加了三倍（此时最大27个匹配）。图下图浅黄色区域，其中实线是YOLO的真实网格，虚线是将一个网格四等分，如这个例子中，GT的中心在右下虚线网格，则扩充右和下真实网格也作为正样本。

        S4.获取与当前gt有top10最大iou的prediction结果。将这top10 （5-15之间均可，并不敏感）iou进行sum，就为当前gt的k。k最小取1。

        S5.根据损失函数计算每个GT和候选anchor损失（前期会加大分类损失权重，后面减低分类损失权重，如1:5->1:3），并保留损失最小的前K个。

        S6.去掉同一个anchor被分配到多个GT的情况。

    1，common.py配置

    ./models/common.py文件增加以下模块

    1. class GAMAttention(nn.Module):
    2.        #https://paperswithcode.com/paper/global-attention-mechanism-retain-information
    3.     def __init__(self, c1, c2, group=True,rate=4):
    4.         super(GAMAttention, self).__init__()
    5.         
    6.         self.channel_attention = nn.Sequential(
    7.             nn.Linear(c1, int(c1 / rate)),
    8.             nn.ReLU(inplace=True),
    9.             nn.Linear(int(c1 / rate), c1)
    10.         )
    11.         self.spatial_attention = nn.Sequential(
    12.             nn.Conv2d(c1, c1//rate, kernel_size=7, padding=3,groups=rate)if group else nn.Conv2d(c1, int(c1 / rate), kernel_size=7, padding=3), 
    13.             nn.BatchNorm2d(int(c1 /rate)),
    14.             nn.ReLU(inplace=True),
    15.             nn.Conv2d(c1//rate, c2, kernel_size=7, padding=3,groups=rate) if group else nn.Conv2d(int(c1 / rate), c2, kernel_size=7, padding=3), 
    16.             nn.BatchNorm2d(c2)
    17.         )
    18.  
    19.     def forward(self, x):
    20.         b, c, h, w = x.shape
    21.         x_permute = x.permute(0, 2, 3, 1).view(b, -1, c)
    22.         x_att_permute = self.channel_attention(x_permute).view(b, h, w, c)
    23.         x_channel_att = x_att_permute.permute(0, 3, 1, 2)
    24.         x = x * x_channel_att
    25.  
    26.         x_spatial_att = self.spatial_attention(x).sigmoid()
    27.         x_spatial_att=channel_shuffle(x_spatial_att,4) #last shuffle 
    28.         out = x * x_spatial_att
    29.         return out  
    30.  
    31. def channel_shuffle(x, groups=2):
    32.         B, C, H, W = x.size()
    33.         out = x.view(B, groups, C // groups, H, W).permute(0, 2, 1, 3, 4).contiguous()
    34.         out=out.view(B, C, H, W) 
    35.         return out

    在yolo.py中添加：

     

    1. elif m is GAMAttention:
    2.     c1, c2 = ch[f], args[0]
    3.     if c2 != no:
    4.         c2 = make_divisible(c2 * gw, 8)
    5.     args = [c1, c2, *args[1:]]

    2，添加添加CNeB模块代码：

    在 common.py 文件中添加如下代码

    1. class LayerNorm_s(nn.Module):
    2.     
    3.     def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
    4.         super().__init__()
    5.         self.weight = nn.Parameter(torch.ones(normalized_shape))
    6.         self.bias = nn.Parameter(torch.zeros(normalized_shape))
    7.         self.eps = eps
    8.         self.data_format = data_format
    9.         if self.data_format not in ["channels_last", "channels_first"]:
    10.             raise NotImplementedError
    11.         self.normalized_shape = (normalized_shape,)
    12.  
    13.     def forward(self, x):
    14.         if self.data_format == "channels_last":
    15.             return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
    16.         elif self.data_format == "channels_first":
    17.             u = x.mean(1, keepdim=True)
    18.             s = (x - u).pow(2).mean(1, keepdim=True)
    19.             x = (x - u) / torch.sqrt(s + self.eps)
    20.             x = self.weight[:, None, None] * x + self.bias[:, None, None]
    21.             return x
    22.  
    23. class ConvNextBlock(nn.Module):
    24.     
    25.     def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6):
    26.         super().__init__()
    27.         self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim)  # depthwise conv
    28.         self.norm = LayerNorm_s(dim, eps=1e-6)
    29.         self.pwconv1 = nn.Linear(dim, 4 * dim)  
    30.         self.act = nn.GELU()
    31.         self.pwconv2 = nn.Linear(4 * dim, dim)
    32.         self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)),
    33.                                   requires_grad=True) if layer_scale_init_value > 0 else None
    34.         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
    35.  
    36.     def forward(self, x):
    37.         input = x
    38.         x = self.dwconv(x)
    39.         x = x.permute(0, 2, 3, 1)  # (N, C, H, W) -> (N, H, W, C)
    40.         x = self.norm(x)
    41.         x = self.pwconv1(x)
    42.         x = self.act(x)
    43.         x = self.pwconv2(x)
    44.         if self.gamma is not None:
    45.             x = self.gamma * x
    46.         x = x.permute(0, 3, 1, 2)  # (N, H, W, C) -> (N, C, H, W)
    47.  
    48.         x = input + self.drop_path(x)
    49.         return x
    50.  
    51. class DropPath(nn.Module):
    52.     """Drop paths (Stochastic Depth) per sample  (when applied in main path of residual blocks).
    53.     """
    54.  
    55.     def __init__(self, drop_prob=None):
    56.         super(DropPath, self).__init__()
    57.         self.drop_prob = drop_prob
    58.  
    59.     def forward(self, x):
    60.         return drop_path_f(x, self.drop_prob, self.training)
    61.  
    62. def drop_path_f(x, drop_prob: float = 0., training: bool = False):
    63.     if drop_prob == 0. or not training:
    64.         return x
    65.     keep_prob = 1 - drop_prob
    66.     shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
    67.     random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
    68.     random_tensor.floor_()  # binarize
    69.     output = x.div(keep_prob) * random_tensor
    70.     return output
    71.  
    72.  
    73. class CNeB(nn.Module):
    74.     # CSP ConvNextBlock with 3 convolutions by iscyy/yoloair
    75.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
    76.         super().__init__()
    77.         c_ = int(c2 * e)  # hidden channels
    78.         self.cv1 = Conv(c1, c_, 1, 1)
    79.         self.cv2 = Conv(c1, c_, 1, 1)
    80.         self.cv3 = Conv(2 * c_, c2, 1)
    81.         self.m = nn.Sequential(*(ConvNextBlock(c_) for _ in range(n)))
    82.     def forward(self, x):
    83.         return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))

    在 models/yolo.py文件夹下找到parse_model函数

    在 for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):下方添加以下代码

    1. elif m is CNeB:
    2.     c1, c2 = ch[f], args[0]
    3.     if c2 != no:
    4.         c2 = make_divisible(c2 * gw, 8)
    5.  
    6.     args = [c1, c2, *args[1:]]
    7.     if m is CNeB:
    8.         args.insert(2, n)
    9.         n = 1

    3，添加C3C2模块：

    在common.py中添加：

    1. class C3C2(nn.Module):
    2.     # CSP Bottleneck with 3 convolutions
    3.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
    4.         super().__init__()
    5.         c_ = int(c2 * e)  # hidden channels
    6.         self.conv = nn.Conv2d(c1, c_, 1, 1, autopad(1, None), groups=g, bias=False)
    7.         self.bn = nn.BatchNorm2d(c_)
    8.         self.act = nn.SiLU()
    9.         self.cv1 = Conv(2 * c_, c2, 1, act=nn.Mish())
    10.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
    11.  
    12.     def forward(self, x):
    13.         y = self.conv(x)
    14.         return self.cv1(torch.cat((self.m(self.act(self.bn(y))), y), dim=1))

    在yolo.py中添加：

    4，更改配置文件

    1. # YOLOv7 🚀, GPL-3.0 license
    2. # parameters
    3. nc: 4  # number of classes
    4. depth_multiple: 0.33  # model depth multiple
    5. width_multiple: 1.0  # layer channel multiple
    6.  
    7. # anchors
    8. anchors:
    9.   - [12,16, 19,36, 40,28]  # P3/8
    10.   - [36,75, 76,55, 72,146]  # P4/16
    11.   - [142,110, 192,243, 459,401]  # P5/32
    12.  
    13. # yolov7 backbone by yoloair
    14. backbone:
    15.   # [from, number, module, args]
    16.   [[-1, 1, Conv, [32, 3, 1]],  # 0
    17.    [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2
    18.    [-1, 1, Conv, [64, 3, 1]],
    19.    [-1, 1, Conv, [128, 3, 2]],  # 3-P2/4
    20.    [-1, 1, CNeB, [128]],
    21.    [-1, 1, Conv, [256, 3, 2]],
    22.    [-1, 1, MP, []],
    23.    [-1, 1, Conv, [128, 1, 1]],
    24.    [-3, 1, Conv, [128, 1, 1]],
    25.    [-1, 1, Conv, [128, 3, 2]],
    26.    [[-1, -3], 1, Concat, [1]],  # 16-P3/8
    27.    [-1, 1, Conv, [128, 1, 1]],
    28.    [-2, 1, Conv, [128, 1, 1]],
    29.    [-1, 1, Conv, [128, 3, 1]],
    30.    [-1, 1, Conv, [128, 3, 1]],
    31.    [-1, 1, Conv, [128, 3, 1]],
    32.    [-1, 1, Conv, [128, 3, 1]],
    33.    [[-1, -3, -5, -6], 1, Concat, [1]],
    34.    [-1, 1, Conv, [512, 1, 1]],
    35.    [-1, 1, MP, []],
    36.    [-1, 1, Conv, [256, 1, 1]],
    37.    [-3, 1, Conv, [256, 1, 1]],
    38.    [-1, 1, Conv, [256, 3, 2]],
    39.    [[-1, -3], 1, Concat, [1]],
    40.    [-1, 1, Conv, [256, 1, 1]],
    41.    [-2, 1, Conv, [256, 1, 1]],
    42.    [-1, 1, Conv, [256, 3, 1]],
    43.    [-1, 1, Conv, [256, 3, 1]],
    44.    [-1, 1, Conv, [256, 3, 1]],
    45.    [-1, 1, Conv, [256, 3, 1]],
    46.    [[-1, -3, -5, -6], 1, Concat, [1]],
    47.    [-1, 1, Conv, [1024, 1, 1]],
    48.    [-1, 1, MP, []],
    49.    [-1, 1, Conv, [512, 1, 1]],
    50.    [-3, 1, Conv, [512, 1, 1]],
    51.    [-1, 1, Conv, [512, 3, 2]],
    52.    [[-1, -3], 1, Concat, [1]],
    53.    [-1, 1, CNeB, [1024]],
    54.    [-1, 1, Conv, [256, 3, 1]],
    55.   ]
    56.  
    57. # yolov7 head by yoloair
    58. head:
    59.   [[-1, 1, SPPCSPC, [512]],
    60.    [-1, 1, Conv, [256, 1, 1]],
    61.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    62.    [31, 1, Conv, [256, 1, 1]],
    63.    [[-1, -2], 1, Concat, [1]],
    64.    [-1, 1, C3C2, [128]],
    65.    [-1, 1, Conv, [128, 1, 1]],
    66.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    67.    [18, 1, Conv, [128, 1, 1]],
    68.    [[-1, -2], 1, Concat, [1]],
    69.    [-1, 1, C3C2, [128]],
    70.    [-1, 1, MP, []],
    71.    [-1, 1, Conv, [128, 1, 1]],
    72.    [-3, 1, GAMAttention, [128]],
    73.    [-1, 1, Conv, [128, 3, 2]],
    74.    [[-1, -3, 44], 1, Concat, [1]],
    75.    [-1, 1, C3C2, [256]],
    76.    [-1, 1, MP, []],
    77.    [-1, 1, Conv, [256, 1, 1]],
    78.    [-3, 1, Conv, [256, 1, 1]],
    79.    [-1, 1, Conv, [256, 3, 2]],
    80.    [[-1, -3, 39], 1, Concat, [1]],
    81.    [-1, 3, C3C2, [512]],
    82.  
    83. # 检测头 -----------------------------
    84.    [49, 1, RepConv, [256, 3, 1]],
    85.    [55, 1, RepConv, [512, 3, 1]],
    86.    [61, 1, RepConv, [1024, 3, 1]],
    87.  
    88.    [[62,63,64], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
    89.   ]

    如果是mish的错误就是pytorch版本不对（重新建一个环境）：

    pip install torch==1.12.0+cu113 torchvision==0.13.0+cu113 --extra-index-url https://download.pytorch.org/whl/cu113 

  • 相关阅读:
    04-循环神经网络基础和自然语言处理介绍
    实现Kickstart + NFS + DHCP + PXE的全自动远程无人职守安装
    Android 第三十六章 DatePickerDialog
    911. 在线选举
    罗丹明聚乙二醇叠氮，Rhodamine-PEG-N3，N3-PEG-Rhodamine，罗丹明PEG叠氮，叠氮PEG罗丹明，叠氮聚乙二醇罗丹明
    导数+偏导数+方向梯度+梯度下降法(python)
    【第2期赠书活动】〖Python 数据库开发实战 - Redis篇⑤〗- Redis 的常用配置参数
    mybatisPlus条件构造器常用方法
    php fpdf使用记录
    【计算机思维】01.计算机思维框架
  • 原文地址：https://blog.csdn.net/qq_53545309/article/details/132258772