主流注意力机制介绍以及如何添加到YOLOV5

已于 2022-10-18 17:35:02 修改
阅读量2.3k 收藏 66
点赞数 1
分类专栏： YOLOV5
于 2022-10-18 16:29:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41627642/article/details/127381209
版权

在这里插入图片描述
注意力机制分类图
在这里插入图片描述

1、SE🍀（通道维度）

论文名称：Squeeze-and-Excitation Networks

论文链接：https://arxiv.org/pdf/1709.01507.pdf

论文代码： https://github.com/hujie-frank/SENet
PyTorch代码地址：

SEnet（Squeeze-and-Excitation Network）考虑了特征通道之间的关系，在特征通道上加入了注意力机制。

SEnet通过学习的方式自动获取每个特征通道的重要程度，并且利用得到的重要程度来提升特征并抑制对当前任务不重要的特征。SEnet通过Squeeze模块和Exciation模块实现所述功能。
在这里插入图片描述
如图所示，首先作者通过squeeze操作，对空间维度进行压缩，直白的说就是对每个特征图做全局池化，平均成一个实数值。该实数从某种程度上来说具有全局感受野。作者提到该操作能够使得靠近数据输入的特征也可以具有全局感受野，这一点在很多的任务中是非常有用的。紧接着就是excitaton操作，由于经过squeeze操作后，网络输出了11C大小的特征图，作者利用权重w来学习C个通道直接的相关性。在实际应用时有的框架使用全连接，有的框架使用11的卷积实现，从参数计算角度我更加推荐使用11卷积，也就是下面代码中的fc2操作。该过程中作者先对C个通道降维再扩展回C通道。好处就是一方面降低了网络计算量，一方面增加了网络的非线性能力。最后一个操作时将exciation的输出看作是经过特征选择后的每个通道的重要性，通过乘法加权的方式乘到先前的特征上，从而实现提升重要特征，抑制不重要特征这个功能。

1、A Squeeze-and-Excitation block

在这里插入图片描述

1、Squeeze: Global Information Embedding

在这里插入图片描述

2、 Excitation: Adaptive Recalibration

在这里插入图片描述

3、ResNet中添加SE block的情况与代码解析。

这里写图片描述

import torch.nn as nn

class SENet(nn.Module):
    '''
    input:(batch_size, chs, h, w)
    output:(batch_size, chs, h, w)
    '''
    def __init__(self, chs, reduction=4):
        super(SENet, self).__init__()
        #Fsq
        self.average_pooling = nn.AdaptiveAvgPool2d(output_size=(1, 1))
        # (batch_size, chs, h, w) -> (batch, chs, 1, 1)
        #Fex
        self.fc = nn.Sequential(
            # First reduce dimension, then raise dimension.
            # Add nonlinear processing to fit the correlation between channels
            nn.Linear(chs, chs // reduction),
            nn.ReLU(inplace=True),
            nn.Linear(chs // reduction, chs)
        )
        self.activation = nn.Sigmoid()  # Get the weight of each channel

    def forward(self, x):
        tmp = x
        batch_size, chs, h, w = x.shape
        x = self.average_pooling(x).view(batch_size, chs)
        # (batch_size, chs, h, w) -> (batch, chs, 1, 1) -> (batch, chs)
        x = self.fc(x).view(batch_size, chs, 1, 1)
        # (batch, chs) -> (batch, chs, 1, 1)
        # x = torch.clamp(x, min=0, max=1)
        # if min =< elem <= max, new_elem = elem, if elem > max, new_elem = max, if elem < min, new_elem = min
        x = self.activation(x)
        return x * tmp  # x: (batch_size, chs, 1, 1), tmp: (batch_size, chs, h, w)

2、在主干网络里添加单独的注意力层

4、匹配YOLOV5的SE代码

class SELayer(nn.Module):
    def __init__(self, c1, c2, r=16):
        super(SELayer, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.l1 = nn.Linear(c1, c1 // r, bias=False)
        self.relu = nn.ReLU(inplace=True)
        self.l2 = nn.Linear(c1 // r, c1, bias=False)
        self.sig = nn.Sigmoid()
    def forward(self, x):
        print(x.size())
        b, c, _, _ = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.l1(y)
        y = self.relu(y)
        y = self.l2(y)
        y = self.sig(y)
        y = y.view(b, c, 1, 1)
5、在yolo.py中做改动，添加注意力模块名称

在这里插入图片描述

def parse_model(d, ch):  # model_dict, input_channels(3)
    logger.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
    anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)
 
    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
        m = eval(m) if isinstance(m, str) else m  # eval strings
        for j, a in enumerate(args):
            try:
                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
            except:
                pass
 
        n = max(round(n * gd), 1) if n > 1 else n  # depth gain
        #在此处添加名称
        if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
                 C3, C3TR, CoordAtt, SELayer, eca_layer, CBAM]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)
 
            args = [c1, c2, *args[1:]]
            #在此处添加名称
            if m in [BottleneckCSP, C3, C3TR,SELayer]:
                args.insert(2, n)  # number of repeats
                n = 1
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum([ch[x] for x in f])
        elif m is Detect:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        else:
            c2 = ch[f]
6、修改配置文件，添加到最后一层，(我这里拿yolov5s.yaml举例子),将注意力层加到你想加入的位置

yolov5s.yaml原来的配置文件

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 20  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

常用的一般是添加到backbone的最后一层,或者C3里面,这里是加在了最后一层。
在这里插入图片描述
#在末尾添加了SElayer注意力模块的配置文件。
在这里插入图片描述在这里插入图片描述

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone+SE
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1,1,SELayer,[1024]], #添加的SElayer
   [-1, 1, SPPF, [1024, 5]],  # 10
  ]

# YOLOv5+SE v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 14

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 18 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 15], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 21 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 11], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 24 (P5/32-large)

   [[18, 21, 24], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

3、在C3模块中加入注意力机制（C3模块和注意力融合）

第一步；要把注意力结构代码放到common.py文件中，以C3SE举例，将这段代码粘贴到common.py文件中

class SEBottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5, ratio=16):  # ch_in, ch_out, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2
        # self.se=SE(c1,c2,ratio)
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.l1 = nn.Linear(c1, c1 // ratio, bias=False)
        self.relu = nn.ReLU(inplace=True)
        self.l2 = nn.Linear(c1 // ratio, c1, bias=False)
        self.sig = nn.Sigmoid()

    def forward(self, x):
        x1 = self.cv2(self.cv1(x))
        b, c, _, _ = x.size()
        y = self.avgpool(x1).view(b, c)
        y = self.l1(y)
        y = self.relu(y)
        y = self.l2(y)
        y = self.sig(y)
        y = y.view(b, c, 1, 1)
        out = x1 * y.expand_as(x1)

        # out=self.se(x1)*x1
        return x + out if self.add else out


class C3SE(C3):
    # C3 module with SEBottleneck()
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(SEBottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

2.修改backbone主干网络中的4个C3模块改为C3SE，如下图所示

nc: 20  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3SE, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3SE, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3SE, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3SE, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

2、CBAM🍀（通道维度）

论文题目：《CBAM: Convolutional Block Attention Module》
论文地址：https://arxiv.org/pdf/1807.06521.pdf
CBAM(Convolutional Block Attention Module)结合了特征通道和特征空间两个维度的注意力机制。
在这里插入图片描述

CBAM通过学习的方式自动获取每个特征通道的重要程度，和SEnet类似。此外还通过类似的学习方式自动获取每个特征空间的重要程度。并且利用得到的重要程度来提升特征并抑制对当前任务不重要的特征。
在这里插入图片描述
CBAM提取特征通道注意力的方式基本和SEnet类似，如下ChannelAttention中的代码所示，其在SEnet的基础上增加了max_pool的特征提取方式，其余步骤是一样的。将通道注意力提取厚的特征作为空间注意力模块的输入。
在这里插入图片描述
CBAM提取特征空间注意力的方式：经过ChannelAttention后，最终将经过通道重要性选择后的特征图送入特征空间注意力模块，和通道注意力模块类似，空间注意力是以通道为单位进行最大和平均迟化，并将两者的结果进行concat，之后再一个卷积降成1wh的特征图空间权重，再将该权重和输入特征进行点积，从而实现空间注意力机制。

# CBAM
class ChannelAttention(nn.Module):
    def __init__(self, in_planes, ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)
        self.f1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
        self.relu = nn.ReLU()
        self.f2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        avg_out = self.f2(self.relu(self.f1(self.avg_pool(x))))
        max_out = self.f2(self.relu(self.f1(self.max_pool(x))))
        out = self.sigmoid(avg_out + max_out)
        return out
    
class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super(SpatialAttention, self).__init__()
        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
        padding = 3 if kernel_size == 7 else 1
        # (特征图的大小-算子的size+2*padding)/步长+1
        self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        # 1*h*w
        avg_out = torch.mean(x, dim=1, keepdim=True)
        max_out, _ = torch.max(x, dim=1, keepdim=True)
        x = torch.cat([avg_out, max_out], dim=1)
        #2*h*w
        x = self.conv(x)
        #1*h*w
        return self.sigmoid(x)
    
class CBAM(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, ratio=16, kernel_size=7):  # ch_in, ch_out, number, shortcut, groups, expansion
        super(CBAM, self).__init__()
        self.channel_attention = ChannelAttention(c1, ratio)
        self.spatial_attention = SpatialAttention(kernel_size)
    def forward(self, x):
        out = self.channel_attention(x) * x
        # c*h*w
        # c*h*w * 1*h*w
        out = self.spatial_attention(out) * out
        return out

3、ECA🍀

论文名称：ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks
论文地址：https://arxiv.org/abs/1910.03151
代码: https://github.com/BangguWu/ECANet
在这里插入图片描述

class ECA(nn.Module):
    """Constructs a ECA module.
    Args:
        channel: Number of channels of the input feature map
        k_size: Adaptive selection of kernel size
    """

    def __init__(self, c1,c2, k_size=3):
        super(ECA, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # feature descriptor on the global spatial information
        y = self.avg_pool(x)

        # print(y.shape,y.squeeze(-1).shape,y.squeeze(-1).transpose(-1, -2).shape)
        # Two different branches of ECA module
        # 50*C*1*1
        #50*C*1
        #50*1*C
        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)

        # Multi-scale information fusion
        y = self.sigmoid(y)

        return x * y.expand_as(x)

4、CA🍀

在这里插入图片描述

#CA
class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)
    def forward(self, x):
        return self.relu(x + 3) / 6
class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)
    def forward(self, x):
        return x * self.sigmoid(x)

class CoordAtt(nn.Module):
    def __init__(self, inp, oup, reduction=32):
        super(CoordAtt, self).__init__()
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))
        mip = max(8, inp // reduction)
        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(mip)
        self.act = h_swish()
        self.conv_h = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
    def forward(self, x):
        identity = x
        n, c, h, w = x.size()
        #c*1*W
        x_h = self.pool_h(x)
        #c*H*1
        #C*1*h
        x_w = self.pool_w(x).permute(0, 1, 3, 2)
        y = torch.cat([x_h, x_w], dim=2)
        #C*1*(h+w)
        y = self.conv1(y)
        y = self.bn1(y)
        y = self.act(y)
        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)
        a_h = self.conv_h(x_h).sigmoid()
        a_w = self.conv_w(x_w).sigmoid()
        out = identity * a_w * a_h
        return out

5、SOCA

在这里插入图片描述

6、A2-Net

在这里插入图片描述

7、 DANPositional

在这里插入图片描述

.8 DANChannel

在这里插入图片描述

1.2.9 RESNest

在这里插入图片描述

1.2.10 Harmonious

1.2.11 SpatialAttention

在这里插入图片描述

1.2.12 RANet

在这里插入图片描述

1.2.13 Co-excite

1.2.14 EfficientAttention

在这里插入图片描述

1.2.15 X-Linear

1.2.16 SlotAttention

在这里插入图片描述

1.2.17 Axial

1.2.18 RFA

1.2.19 Attention-BasedDropout

在这里插入图片描述

1.2.20 ReverseAttention

在这里插入图片描述

1.2.21 CrossAttention

在这里插入图片描述

1.2.22 Perceiver

1.2.23 Criss-CrossAttention

1.2.24 BoostedAttention

1.2.25 Prophet

1.2.26 S3TA

1.2.27 Self-CriticAttention

在这里插入图片描述

1.2.28 BayesianAttentionBeliefNetworks

1.2.29 Expectation-MaximizationAttention

1.2.30 GaussianAttention

在这里插入图片描述

qq_41627642
关注
  • 1
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
改进YOLOv5 | 在 C3 模块中添加【Triplet】【SpatialGroupEnhance】【NAM】【S2】注意力机制 | 附详细结构图
YOLOv8项目贡献者
05-17 2635
在 C3 模块中添加【Triplet】【SpatialGroupEnhance】【NAM】【S2】注意力机制 | 附详细结构图
基于改进YOLOv5的路面坑洼检测方法
04-27
在YOLOv5的主干网络中引入CBAM(Convolutional Block Attention Module)注意力机制，提高模型对关键特征的注意能力，将YOLOv5的损失函数改为EIoU(Efficient Intersection over Union)，提高模型对目标的检测精度。...
9种卷积注意力机制创新方法汇总，含2024最新
学姐带你玩AI的博客
12-27 5014
今天咱们来聊聊。相信各位在写论文的时候都苦恼过怎么更好地改模型，怎么更高效地提高模型的性能和泛化能力吧？我的建议是，不妨考虑考虑。卷积注意力机制是一种通过关注输入数据中的不同部分来改进模型性能的方法，结合了卷积网络和Transformer各自的优势，以同时获得更好的泛化能力和更大的模型容量。因此，通过将二者有效结合，卷积注意力机制就能帮助我们在准确性和效率之间实现更好的平衡。今天我就帮同学们整理了，帮助想发论文的同学更高效地改模型涨点，早点发出自己的顶会。另外，每种思路我都整理了。
365天深度学习训练营-第P8周：YOLOv5-C3模块实现
weixin_46559155的博客
12-05 2154
1.这个YOLOv5模型结构比之前学的模型都要难，目前看了几篇博客，也只能算是刚刚了解，还得继续看2.对比第三周构建简单的CNN来做天气预测，用YOLOv5做训练，accuracy上去了一些，但是并没有说达到95%以上这种精度，并且计算还很大，batch_size由设定的32改成了4才跑起来的，所以就这个问题而言，用YOLOv5，计算千万计的参数，但是得到的效果没有显著提升，所以模型的适用性到底怎么界定？
CVPR 2024 即插即用！ CA：新注意力机制，2024年最新Linux运维彻底组件化方案实践方法
2401_84164546的博客
04-09 1163
为了做好运维面试路上的助攻手，特整理了上百道。
深度学习小总结
Mr_jingjing的博客
02-18 206
卷积神经网络基础 互相关运算与卷积运算 卷积层得名于卷积运算，但卷积层中用到的并非卷积运算而是互相关运算。我们将核数组上下翻转、左右翻转，再与输入数组做互相关运算，这一过程就是卷积运算。由于卷积层的核数组是可学习的，所以使用互相关运算与使用卷积运算并无本质区别。 特征图与感受野 二维卷积层输出的二维数组可以看作是输入在空间维度（宽和高）上某一级的表征，也叫特征图（feature map）。影响元素...
yolov5-attention
04-12
该存储库代表Ultralytics对未来的对象检测方法的开源研究，并结合了在匿名客户数据集上数千小时的培训和发展过程中汲取的经验教训和最佳实践。 所有代码和模型都在积极开发中，如有更改或删除，恕不另行通知。 使用风险自负。 ** GPU速度使用批处理大小为32的V100 GPU测量超过5000张COCO val2017图像的平均每张图像的端到端时间，包括图像预处理，PyTorch FP16推理，后处理和NMS。 来自EfficientDet数据（批量大小为8）。 2021年1月5日： ：nn.SiLU（）激活，记录， 集成。 2020年8月13日： ：nn.Hardswish（）激活，数据自动下载，本机AMP。 2020年7月23日： ：改进了模型定义，培训和mAP。 2020年6月22日： 更新：新机头，减少了参数，提高了速度，并提高了mAP 。 2020年6月19日： 作为
零基础教程：Yolov5模型改进-添加13种注意力机制
pyscl01的博客
09-25 2707
零基础教程：Yolov5模型改进-添加注意力机制的详细步骤
Backbone中添加attention 之CBAM
hasque2019的博客
12-07 1084
attention踩坑
基于注意力机制和 fastnet 的改进 YOLOv5 在铁路和航路异物检测中的应用
sybh的博客
05-21 1104
随着交通系统的不断发展，关于交通基础设施(如铁路和航空)的安全问题变得越来越重要。铁路和航空安全面临的主要威胁之一是障碍物对轨道的入侵。常见的未经授权的铁路入侵包括行人、车辆、动物和落石。如果不能及时向当局通报这些入侵，可能会对铁路交通安全和运营连续性产生不利影响[1]。这一问题也存在于航空业。机场跑道上的外来碎片在飞机起降过程中对飞机构成威胁，严重时可能造成不可挽回的损害[2]。早期防范外来物的方法运输路线上的物体入侵主要依靠物理屏障和人工检查。
基于可变形卷积和注意力机制的滚动轴承故障诊断
02-06
基于可变形卷积和注意力机制的滚动轴承故障诊断 基于可变形卷积和注意力机制的滚动轴承故障诊断 轴承是旋转机械中的重要部件,轴承的故障可能导致严重的人员伤亡和经济损失,因此对轴承的故障诊断以及保障轴承的平稳...
chatbot.zip_attention_keras_likeacf_对话语料_注意力机制
07-14
框架为Keras（Tensorflow的高层包装），方案为主流的RNN（循环神经网络）的变种LSTM（长短期记忆网络）+seq2seq（序列到序列模型），外加算法Attention Mechanism（注意力机制），分词工具为jieba，UI为Tkinter，...
主流厂家OLT设备介绍.pptx
12-27
主流厂家OLT设备介绍
YOLO Air：YOLO科研改进论文推荐 | 改进组合上千种搭配，包括Backbone,Neck,Head,注意力机制,适用于YOLOv5、YOLOv7、YOLOX等算法
热门推荐
包括YOLOv5、YOLOv7、YOLOv8等模型改进
07-30 2万+
目标检测科研改进推荐 | 包括Backbone、Neck、Head、注意力机制、IoU损失函数、NMS、Loss计算方式、自注意力机制、数据增强部分、激活函数
grpcio-1.63.0-cp38-cp38-linux_armv7l.whl
最新发布
05-28
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
SQLyog-13.1.3-0.x86Community.exe
05-28
SQLyog-13.1.3-0.x86Community
VB自动出题题库系统设计(源代码+系统).rar
05-28
计算机专业毕业设计VB精品论文资源
c3tr模块解析 YOLOv5
05-11
c3tr模块是YOLOv5中的一个特殊模块，用于提高模型的特征表达能力和检测精度。 在YOLOv5的架构中，c3tr模块位于主干网络的倒数第二个stage中。这个stage的输出特征图大小为原图的1/16，包含了足够的空间信息和语义信息，但是对于一些小目标或者细节部分，特征表达能力还不够。 c3tr模块的设计就是为了解决这个问题。它的结构类似于一个卷积块，但是包含了一些特殊的操作： 1. Convolutional Block：包含了3个卷积层，用于提取特征信息。 2. Cross Stage Partial Connection：用于将前一层特征图的部分信息与当前层的特征图相加，增强特征表达能力。 3. SPP：Spatial Pyramid Pooling，用于提取不同尺度的特征信息，增强特征检测能力。 4. Concatenation：将不同尺度的特征信息进行拼接，得到最终的特征图。 通过以上操作，c3tr模块可以有效地提高模型的特征表达能力和检测精度，在YOLOv5中起到了重要的作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值