YOLOv10 即插即用改进模块

YOLOv12即插即用--LSKblockAttention 本文介绍了如何在中应用,以增强。作为一种能够的网络,在任务中展现出了卓越的能力,并在多个数据集上刷新了记录。其核心思想是通过大核可分离卷积(LSK)来增强模型的,特别适用于检测那些尺度变化大、特征微弱的目标。在本研究中,我们对进行了深入优化,将模块巧妙地融入,以进一步提升小目标的检测性能。该优化策略不仅增强了模型对弱小目标的捕捉能力,还有效降低了漏检率,使检测结果更加稳定可靠。实验表明,这种改进方法能够有效提升红外遥感小目标的检测精度,尤其适用于。本研究为。 阅读详情

目录

1. 注意力机制类 (1-25)


1. 注意力机制类 (1-25)

Python

# ============ 模块1: CBAM注意力机制 ============
class CBAM(nn.Module):
    """通道+空间双重注意力"""
    def __init__(self, channels, reduction=16):
        super().__init__()
        # 通道注意力
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)
        self.mlp = nn.Sequential(
            nn.Conv2d(channels, channels//reduction, 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(channels//reduction, channels, 1)
        )
        # 空间注意力
        self.conv_spatial = nn.Conv2d(2, 1, 7, padding=3)
        
    def forward(self, x):
        # 通道注意力
        avg_out = self.mlp(self.avg_pool(x))
        max_out = self.mlp(self.max_pool(x))
        x = x * torch.sigmoid(avg_out + max_out)
        # 空间注意力
        avg_spatial = torch.mean(x, dim=1, keepdim=True)
        max_spatial, _ = torch.max(x, dim=1, keepdim=True)
        spatial = torch.cat([avg_spatial, max_spatial], dim=1)
        x = x * torch.sigmoid(self.conv_spatial(spatial))
        return x

# 改进思路: 结合通道和空间维度,自适应增强重要特征,抑制背景噪声


# ============ 模块2: ECA注意力机制 ============
class ECA(nn.Module):
    """高效通道注意力,避免降维"""
    def __init__(self, channels, gamma=2, b=1):
        super().__init__()
        kernel_size = int(abs((math.log(channels, 2) + b) / gamma))
        kernel_size = kernel_size if kernel_size % 2 else kernel_size + 1
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size, padding=kernel_size//2, bias=False)
        
    def forward(self, x):
        y = self.avg_pool(x)
        y = self.conv(y.squeeze(-1).transpose(-1, -2))
        y = y.transpose(-1, -2).unsqueeze(-1)
        return x * torch.sigmoid(y)

# 改进思路: 1D卷积替代全连接,避免通道降维带来的信息损失,参数更少更高效


# ============ 模块3: SimAM注意力机制 ============
class SimAM(nn.Module):
    """无参数三维注意力"""
    def __init__(self, e_lambda=1e-4):
        super().__init__()
        self.activation = nn.Sigmoid()
        self.e_lambda = e_lambda
        
    def forward(self, x):
        b, c, h, w = x.size()
        n = w * h - 1
        x_minus_mu_square = (x - x.mean(dim=[2, 3], keepdim=True)).pow(2)
        y = x_minus_mu_square / (4 * (x_minus_mu_square.sum(dim=[2, 3], keepdim=True) / n + self.e_lambda)) + 0.5
        return x * self.activation(y)

# 改进思路: 基于神经科学的三维权重,无需额外参数,计算能量函数突出重要神经元


# ============ 模块4: Coordinate Attention ============
class CoordAtt(nn.Module):
    """坐标注意力,编码位置信息"""
    def __init__(self, inp, reduction=32):
        super().__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 = nn.Hardswish()
        self.conv_h = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        
    def forward(self, x):
        identity = x
        n, c, h, w = x.size()
        x_h = self.pool_h(x)
        x_w = self.pool_w(x).permute(0, 1, 3, 2)
        y = torch.cat([x_h, x_w], dim=2)
        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()
        return identity * a_w * a_h

# 改进思路: 将通道注意力分解为两个1D特征编码,捕获精确的位置信息


# ============ 模块5: Global Context Block ============
class GCBlock(nn.Module):
    """全局上下文建模"""
    def __init__(self, inplanes, ratio=16):
        super().__init__()
        self.inplanes = inplanes
        self.inter_channels = inplanes // ratio
        self.conv_mask = nn.Conv2d(inplanes, 1, kernel_size=1)
        self.transform = nn.Sequential(
            nn.Conv2d(inplanes, self.inter_channels, 1),
            nn.LayerNorm([self.inter_channels, 1, 1]),
            nn.ReLU(inplace=True),
            nn.Conv2d(self.inter_channels, inplanes, 1)
        )
        
    def forward(self, x):
        # 全局注意力池化
        context_mask = self.conv_mask(x)
        context_mask = context_mask.view(x.size(0), 1, -1)
        context_mask = F.softmax(context_mask, dim=2)
        context_mask = context_mask.view(x.size(0), 1, x.size(2), x.size(3))
        
        # 全局上下文特征
        context = torch.matmul(x.view(x.size(0), x.size(1), -1), 
                              context_mask.view(x.size(0), 1, -1).permute(0, 2, 1))
        context = context.unsqueeze(-1)
        return x + self.transform(context)

# 改进思路: 结合Non-local和SE-Net,轻量级全局上下文建模,增强长距离依赖


# ============ 模块6: Double Attention ============
class DoubleAttention(nn.Module):
    """双重注意力:特征聚集和分配"""
    def __init__(self, in_channels, c_m, c_n):
        super().__init__()
        self.c_m = c_m
        self.c_n = c_n
        self.convA = nn.Conv2d(in_channels, c_m, 1)
        self.convB = nn.Conv2d(in_channels, c_n, 1)
        self.convV = nn.Conv2d(in_channels, c_n, 1)
        
    def forward(self, x):
        b, c, h, w = x.size()
        A = self.convA(x).view(b, self.c_m, -1)
        B = self.convB(x).view(b, self.c_n, -1)
        V = self.convV(x).view(b, self.c_n, -1)
        tmp = torch.bmm(B, V.permute(0, 2, 1)) / (h * w)
        tmp = F.softmax(tmp, dim=-1)
        Z = torch.bmm(A, tmp)
        return Z.view(b, self.c_m, h, w)

# 改进思路: 先聚集关键特征再分配到各位置,两步注意力机制提高特征表达


# ============ 模块7: A2Net Double Attention ============
class A2Attn(nn.Module):
    """A2-Net双重注意力"""
    def __init__(self, in_ch, c_m=128, c_n=128, reconstruct=True):
        super().__init__()
        self.c_m = c_m
        self.c_n = c_n
        self.reconstruct = reconstruct
        self.convA = nn.Conv2d(in_ch, c_m, 1)
        self.convB = nn.Conv2d(in_ch, c_n, 1)
        self.convV = nn.Conv2d(in_ch, c_n, 1)
        if reconstruct:
            self.conv_reconstruct = nn.Conv2d(c_m, in_ch, kernel_size=1)
            
    def forward(self, x):
        b, c, h, w = x.shape
        A = self.convA(x)
        B = self.convB(x)
        V = self.convV(x)
        tmpA = A.view(b, self.c_m, -1)
        attention_maps = F.softmax(B.view(b, self.c_n, -1), dim=-1)
        attention_vectors = F.softmax(V.view(b, self.c_n, -1), dim=1)
        global_descriptors = torch.bmm(tmpA, attention_maps.permute(0, 2, 1))
        tmpZ = torch.bmm(global_descriptors, attention_vectors)
        tmpZ = tmpZ.view(b, self.c_m, h, w)
        if self.reconstruct:
            tmpZ = self.conv_reconstruct(tmpZ)
        return tmpZ

# 改进思路: 收集-分配机制,首先收集所有位置信息,然后自适应分配到各位置


# ============ 模块8: Self-Calibrated Attention ============
class SCConv(nn.Module):
    """自校准卷积"""
    def __init__(self, inplanes, planes, stride=1, padding=1, dilation=1, groups=1):
        super().__init__()
        self.conv_k = nn.Conv2d(inplanes, planes, kernel_size=3, 
                                stride=stride, padding=padding, 
                                dilation=dilation, groups=groups, bias=False)
        self.conv_scale = nn.Conv2d(inplanes//2, inplanes//2, kernel_size=3, 
                                    stride=stride, padding=padding, 
                                    dilation=dilation, groups=groups, bias=False)
        self.conv_up = nn.Conv2d(inplanes//2, inplanes, kernel_size=3, 
                                 stride=1, padding=1, bias=False)
        self.bn = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        
    def forward(self, x):
        b, c, h, w = x.size()
        x1, x2 = torch.split(x, c//2, dim=1)
        x2 = self.conv_scale(x2)
        x2 = F.interpolate(x2, scale_factor=0.5, mode='bilinear', align_corners=False)
        x2 = self.conv_up(x2)
        x2 = F.interpolate(x2, size=(h, w), mode='bilinear', align_corners=False)
        x = torch.cat([x1, x2], dim=1)
        return self.relu(self.bn(self.conv_k(x)))

# 改进思路: 多尺度自校准,通过下采样-上采样建立长距离空间关联


# ============ 模块9: Triplet Attention ============
class TripletAttention(nn.Module):
    """三元组注意力,跨维度交互"""
    def __init__(self, no_spatial=False):
        super().__init__()
        self.cw = AttentionGate()
        self.hc = AttentionGate()
        self.no_spatial = no_spatial
        if not no_spatial:
            self.hw = AttentionGate()
            
    def forward(self, x):
        x_perm1 = x.permute(0, 2, 1, 3).contiguous()
        x_out1 = self.cw(x_perm1)
        x_out11 = x_out1.permute(0, 2, 1, 3).contiguous()
        x_perm2 = x.permute(0, 3, 2, 1).contiguous()
        x_out2 = self.hc(x_perm2)
        x_out21 = x_out2.permute(0, 3, 2, 1).contiguous()
        if not self.no_spatial:
            x_out = self.hw(x)
            x_out = 1/3 * (x_out + x_out11 + x_out21)
        else:
            x_out = 1/2 * (x_out11 + x_out21)
        return x_out

class AttentionGate(nn.Module):
    def __init__(self):
        super().__init__()
        kernel_size = 7
        self.compress = ZPool()
        self.conv = BasicConv(2, 1, kernel_size, stride=1, padding=(kernel_size-1)//2, relu=False)
        
    def forward(self, x):
        x_compress = self.compress(x)
        x_out = self.conv(x_compress)
        scale = torch.sigmoid_(x_out)
        return x * scale

class ZPool(nn.Module):
    def forward(self, x):
        return torch.cat((torch.max(x, 1)[0].unsqueeze(1), torch.mean(x, 1).unsqueeze(1)), dim=1)

class BasicConv(nn.Module):
    def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, relu=True):
        super().__init__()
        self.out_channels = out_planes
        self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, 
                             stride=stride, padding=padding, bias=False)
        self.bn = nn.BatchNorm2d(out_planes)
        self.relu = nn.ReLU() if relu else None
        
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        if self.relu is not None:
            x = self.relu(x)
        return x

# 改进思路: 通过permute操作在三个维度对(CW,HC,HW)分别计算注意力,捕获跨维度交互


# ============ 模块10: Shuffle Attention ============
class ShuffleAttention(nn.Module):
    """混洗注意力"""
    def __init__(self, channel=512, reduction=16, G=8):
        super().__init__()
        self.G = G
        self.channel = channel
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.gn = nn.GroupNorm(channel // (2 * G), channel // (2 * G))
        self.cweight = nn.Parameter(torch.zeros(1, channel // (2 * G), 1, 1))
        self.cbias = nn.Parameter(torch.ones(1, channel // (2 * G), 1, 1))
        self.sweight = nn.Parameter(torch.zeros(1, channel // (2 * G), 1, 1))
        self.sbias = nn.Parameter(torch.ones(1, channel // (2 * G), 1, 1))
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        b, c, h, w = x.size()
        x = x.view(b * self.G, -1, h, w)
        x_0, x_1 = x.chunk(2, dim=1)
        
        # 通道注意力
        xn = self.avg_pool(x_0)
        xn = self.cweight * xn + self.cbias
        xn = x_0 * self.sigmoid(xn)
        
        # 空间注意力
        xs = self.gn(x_1)
        xs = self.sweight * xs + self.sbias
        xs = x_1 * self.sigmoid(xs)
        
        out = torch.cat([xn, xs], dim=1)
        out = out.view(b, -1, h, w)
        
        # 通道混洗
        out = self.channel_shuffle(out, 2)
        return out
        
    def channel_shuffle(self, x, groups):
        b, c, h, w = x.size()
        x = x.view(b, groups, c // groups, h, w)
        x = x.permute(0, 2, 1, 3, 4).contiguous()
        x = x.view(b, c, h, w)
        return x

# 改进思路: 将通道分组后分别进行通道和空间注意力,通过混洗促进组间信息交流


# ============ 模块11: Residual Attention ============
class ResidualAttention(nn.Module):
    """残差注意力模块"""
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.attention = AttentionModule(out_channels)
        
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride),
                nn.BatchNorm2d(out_channels)
            )
        else:
            self.shortcut = nn.Identity()
            
    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = self.attention(out)
        out += self.shortcut(x)
        return self.relu(out)

class AttentionModule(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.mask = nn.Sequential(
            nn.Conv2d(channels, channels//4, 1),
            nn.BatchNorm2d(channels//4),
            nn.ReLU(inplace=True),
            nn.Conv2d(channels//4, channels, 1),
            nn.BatchNorm2d(channels),
            nn.Sigmoid()
        )
        
    def forward(self, x):
        return x * self.mask(x)

# 改进思路: 软注意力掩码与残差连接结合,逐步细化特征,避免信息损失


# ============ 模块12: Squeeze-and-Excitation改进版 ============
class SEWeightModule(nn.Module):
    """SE模块权重生成"""
    def __init__(self, channels, reduction=16):
        super().__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc1 = nn.Conv2d(channels, channels//reduction, kernel_size=1, padding=0)
        self.relu = nn.ReLU(inplace=True)
        self.fc2 = nn.Conv2d(channels//reduction, channels, kernel_size=1, padding=0)
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        out = self.avg_pool(x)
        out = self.fc1(out)
        out = self.relu(out)
        out = self.fc2(out)
        weight = self.sigmoid(out)
        return weight

class SENet(nn.Module):
    def __init__(self, channels, reduction=16):
        super().__init__()
        self.weight = SEWeightModule(channels, reduction)
        
    def forward(self, x):
        weight = self.weight(x)
        return x * weight

# 改进思路: 经典通道注意力,显式建模通道间相互依赖关系,自适应重标定通道特征
即插即用篇 | 手把手教你 YOLOv10 添加注意力机制 | 20+ 种全打通! 阅读详情

相关推荐

YOLOV10 改进 | 模块即插即用 直接可用,持续更新

YOLOv10去除NMS后端到端延迟显著降低。YOLOv10相比YOLOv8速度提升。YOLOv10相比YOLOv9速度提升。

u012133341的博客 835

YOLO即插即用模块---MEGANet

将 EGA 模块添加到目标分类网络中,例如在 Faster R-CNN 的 RoI Pooling 层之后添加 EGA 模块,增强目标区域特征,提高分类准确率。: 将 EGA 模块添加到特征提取网络中,例如在 ResNet 或 EfficientNet 的某些层之间插入 EGA 模块,增强特征图中目标边界信息。: 将 EGA 模块添加到目标框回归网络中,例如在 RetinaNet 或 YOLO 的回归层之前添加 EGA 模块,引导模型更精确地回归目标边界。: 利用编码器提取的特征生成分割结果。

llz19670的博客 3987

YOLOv10改进策略【卷积层】| NeurIPS-2022 ParNet 即插即用模块 含二次创新

本文记录的是利用中的基础模块优化的目标检测网络模型。 是一个即插即用模块,能够在不增加深度的情况下增加感受野,更好地处理图像中的不同尺度特征,有助于网络对输入数据更全面地理解和学习,从而提升网络的特征提取能力和分类性能。NON-DEEP NETWORKS模块是ParNet网络架构中的重要组成部分,其设计出发点、原理、结构和优势如下:的实现代码如下: 四、创新模块 4.1 改进点1⭐ 模块改进方法:直接加入(第五节讲解添加步骤)。添加后如下:模块改进方法:基于的(第五节讲解添加步骤)。第二种改进方法是对中的

Limiiiing的博客 870

YOLO即插即用模块---CAA

论文地址:2403.06258。

llz19670的博客 1009

YoloV10改进:Block改进|使用ContextAggregation模块改善C2f模块|即插即用

给定一张图像。

m0_47867638的博客 1123

YoloV10改进策略:下采样与上采样改进|下采样模块和DUpsampling上采样模块|即插即用

在深度学习与计算机视觉领域,YoloV10作为实时目标检测算法的代表,以其卓越的性能和效率赢得了广泛认可。然而,为了不断追求更高的精度与更快的推理速度,我们在YoloV10的基础上进行了创新性改进,重点引入了先进的下采样模块和DUpsampling上采样模块。这些改进不仅显著提升了YoloV10的性能,还为其在复杂场景下的应用提供了更强大的支持。下采样模块的革新该模块结合了卷积层和最大池化层来生成具有较低维度的扩展特征图,同时考虑了计算成本的优化。以下是该下采样模块的详细总结:卷积层和最大池化层:特征图拼接

m0_47867638的博客 1356

YOLO即插即用模块---ASSA

AST模型通过自适应稀疏自注意力和特征细化前馈网络,有效地解决了基于 AST模型通过自适应稀疏自注意力和特征细化前馈网络,有效地解决了基于 AST模型通过自适应稀疏自注意力和特征细化前馈网络,有效地解决了基于Transformer的图像恢复方法中存在的计算量大、冗余信息多和噪声交互等问题,并在多个图像恢复任务中取得了优异的性能。: 在SPAD数据集上,AST-B模型在PSNR指标上比现有的最佳的CNN模型和Transformer模型。: 该模块采用增强和简化方案来。

llz19670的博客 2442

YoloV10改进:Neck层改进|使用ContextAggregation模块改善Neck的输出特征|即插即用

通过百度网盘分享的文件:YoloV10改进:Neck层改进使用ContextAggregati...链接:

m0_47867638的博客 351

YoloV10改进策略:Block改进|RFE模块,提高小物体的识别精度|即插即用|代码+修改过程

本文介绍了一种基于YOLOv5的人脸检测方法,命名为YOLO-FaceV2。该方法旨在解决人脸检测中的尺度变化、简单与困难样本不平衡以及人脸遮挡等问题。通过引入一系列创新模块和损失函数,YOLO-FaceV2在WiderFace数据集上取得了优异的表现,特别是在小物体、遮挡和困难样本的检测上。

m0_47867638的博客 396

YoloV10改进策略:Block改进|细节增强注意力模块(DEAB)|即插即用

DEA-Net的提出背景:单幅图像去雾是一项具有挑战性的任务,旨在从观测到的雾图中恢复出潜在的清晰图像。传统方法存在局限性,而基于深度学习的方法通过增加卷积的深度或宽度来提高性能,但卷积神经网络(CNN)结构的学习能力仍有待充分探索。DEA-Net的核心目标:提出一种包含细节增强卷积(DEConv)和内容引导注意力(CGA)的细节增强注意力模块(DEAB),以增强特征学习,从而提升去雾性能。

m0_47867638的博客 796

YoloV10的改进策略:下采样改进|集成GCViT的Downsampler模块实现性能显著提升|即插即用

随着深度学习在计算机视觉领域的广泛应用,目标检测任务成为了研究热点之一。YoloV8作为实时目标检测领域的领先模型,凭借其高效性与准确性赢得了广泛的关注。然而,为了进一步提升YoloV8的性能,特别是在特征提取与下采样过程中的信息保留能力,我们引入了来自GCViT(Global Context Vision Transformers)模型中的Downsampler模块。本文将详细阐述这一改进方法,并探讨其带来的显著优势。

m0_47867638的博客 737

YoloV10改进策略:Neck改进|SEAM与MultiSEAM模块,提高小目标和遮挡目标的检测精度|即插即用|附加代码+改进方法

本文参考了“YOLO-FaceV2:A Scale and Occlusion Aware Face Detector”的研究内容,该论文提出了一种基于YOLOv5的人脸检测方法,即YOLO-FaceV2,以解决人脸尺度变化、简单与困难样本不平衡以及人脸遮挡等问题。受到该论文的启发,本文将SEAM模块(遮挡感知注意力网络)及其扩展形式MultiSEAM模块引入到YoloV10中,旨在提升物体遮挡检测精度以及小目标的检测性能。

m0_47867638的博客 1292

YOLOv10改进,YOLOv10添加引入即插即用的空间和通道协同注意力模块SCSA,2024,二次创新C2f结构

SCSA通过结合空间注意力(SMSA)和通道注意力(PCSA)来提升模型在多语义特征学习中的表现。其核心目标是减小多语义特征之间的差异,增强特征之间的相关性,从而提高视觉任务(如图像分类、目标检测等)的性能。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 653

YOLOv10改进策略【注意力机制篇】| NAM 即插即用模块,重新优化通道和空间注意力(含二次创新)

本文记录的是基于NAM模块的YOLOv10目标检测改进方法研究。 许多先前的研究专注于通过注意力操作捕获显著特征,但缺乏对权重贡献因素的考虑,而这些因素能够进一步抑制不重要的通道或像素。而本文利用改进,通过权重的贡献因素来改进注意力机制,提高模型精度。NAM: Normalization-based Attention Module注意力模块的设计的原理和优势如下:​Bin​−μB​​+β,其中μB\mu_{B}μB​和σB\sigma_{B}σB​分别是小批量BBB的均值和标准差;γ\gammaγ和β\b

Limiiiing的博客 1324

YoloV10改进策略:BackBone改进|注意力改进|HCANet全局与局部的注意力模块CAFM|二次创新|即插即用

在CAFM模型的基础上进行二次创新,我成功地开发了一个性能显著提升的改进版模型。这一创新不仅优化了特征提取和融合的方式,还极大地提高了模型的泛化能力和准确性。为了验证其有效性,我们将这一改进应用于流行的目标检测算法YoloV10,并取得了显著的精度提升。这一改进具有即插即用的特性,易于理解和实现,为相关领域的研究人员提供了新的思路和方法。CAFM结构图如下:修改后的结构图:对CAFM模块做了适当的修改,加入了DropPath和激活函数,又加入了残差链接,方便其集成到YoloV10中。

m0_47867638的博客 942

即插即用篇 | YOLOv10 引入 YOLO12 最新模块,无痛涨点 | 让你的基于v10改进直接变成基于v12改进 !

让你的基于v10改进直接变成基于v12改进 !

Coding... 830

YOLOv10改进策略【注意力机制篇】| EMA 即插即用模块,提高远距离建模依赖(含二次创新)

本文记录的是基于EMA模块的YOLOv10目标检测改进方法研究。EMA认为跨维度交互有助于通道或空间注意力预测,并且解决了现有注意力机制在提取深度视觉表示时可能带来的问题。YOLOv10。

Limiiiing的博客 1821

YoloV10改进策略:卷积篇|ACConv2d模块在YoloV10中的创新应用与显著性能提升|简单易用|即插即用

通过百度网盘分享的文件:YoloV10改进策略:卷积篇ACConv2d模块在YoloV10中的.

m0_47867638的博客 883
上一篇: 100个YOLOv8改进模块 |即插即用
下一篇: YOLOv9 即插即用改进模块清单(30个最新模块)
VectorShift
博客等级 码龄1年 1842粉丝 1109原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VectorShift

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值