前言
作为当前先进的深度学习目标检测算法YOLOv8，已经集合了大量的trick，但是还是有提高和改进的空间，针对具体应用场景下的检测难点，可以不同的改进方法。此后的系列文章，将重点对YOLOv8的如何改进进行详细的介绍，目的是为了给那些搞科研的同学需要创新点或者搞工程项目的朋友需要达到更好的效果提供自己的微薄帮助和参考。由于出到YOLOv8，YOLOv7、YOLOv5算法2020年至今已经涌现出大量改进论文，这个不论对于搞科研的同学或者已经工作的朋友来说，研究的价值和新颖度都不太够了，为与时俱进，以后改进算法以YOLOv7为基础，此前YOLOv5改进方法在YOLOv7同样适用，所以继续YOLOv5系列改进的序号。另外改进方法在YOLOv5等其他算法同样可以适用进行改进。希望能够对大家有帮助。
一、解决问题
将稀疏性引入注意力机制引入到YOLO系列算法中，提高检测效果。
二、基本原理
摘要：作为视觉转换器的核心构建块，atten-tion是捕捉长期依赖性的强大工具。然而，这种能力是有代价的：它会带来巨大的计算负担和沉重的内存占用，因为跨所有空间位置的成对令牌交互都是计算的。一系列工作试图通过将手工制作和内容不可知的稀疏性引入注意力来缓解这个问题，例如将注意力操作限制在局部窗口、轴向条纹或扩展窗口内。与这些方法相反，我们提出了一种新的动态稀疏注意力，通过双层路由实现更灵活的计算分配和内容感知。具体而言，对于查询，首先在粗略区域级别过滤掉不相关的键值对，然后在保留的候选区域（即路由区域）的并集中应用细粒度的令牌对令牌关注。我们提供了所提出的双层路由注意的一个简单而有效的实现，它利用稀疏性来节省计算和内存，同时只涉及GPU友好的密集矩阵乘法。基于提出的双层路由注意，提出了一种新的通用视觉变换器，命名为BiFormer。由于BiFormer以查询自适应的方式处理一小部分相关令牌，而不会分散对其他无关令牌的注意力，因此它具有良好的性能和较高的计算效率，尤其是在密集的预测任务中。在图像分类、物体检测和语义分割等几个计算机视觉任务中的经验结果验证了我们设计的有效性。
为了缓解MHSA的可扩展性问题，一些工作[14，29，41，46，48]提出了不同的稀疏注意机制，其中每个查询只关注少数键值对，而不是所有键值对。然而，这些已有的工作要么使用手工制作的静态模式，要么在所有查询中共享键值对的采样子集，如图1所示。在这项工作中，我们探索了一种动态的、可查询的稀疏注意力机制。我们的关键思想是在粗略的区域级别中过滤掉最不相关的键值对，这样只剩下一小部分路由区域。然后，我们将细粒度令牌应用于这些路由区域的并集中的令牌注意力。为了简化符号，我们讨论了单头自注意和单输入的情况，尽管我们在实践中使用了多头自注意[42]和分批输入。整个算法在算法1中使用Pytorch类[32]伪码进行求和。
三、添加方法
BiFormer相关代码如下：具体改进方法，关注后私信
class BiFormer(nn.Module):
def __init__(self, depth=[3, 4, 8, 3], in_chans=3, num_classes=1000, embed_dim=[64, 128, 320, 512],
head_dim=64, qk_scale=None, representation_size=None,
drop_path_rate=0., drop_rate=0.,
use_checkpoint_stages=[],
########
n_win=7,
kv_downsample_mode='ada_avgpool',
kv_per_wins=[2, 2, -1, -1],
topks=[8, 8, -1, -1],
side_dwconv=5,
layer_scale_init_value=-1,
qk_dims=[None, None, None, None],
param_routing=False, diff_routing=False, soft_routing=False,
pre_norm=True,
pe=None,
pe_stages=[0],
before_attn_dwconv=3,
auto_pad=False,
#-----------------------
kv_downsample_kernels=[4, 2, 1, 1],
kv_downsample_ratios=[4, 2, 1, 1], # -> kv_per_win = [2, 2, 2, 1]
mlp_ratios=[4, 4, 4, 4],
param_attention='qkvo',
mlp_dwconv=False):
"""
Args:
depth (list): depth of each stage
img_size (int, tuple): input image size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (list): embedding dimension of each stage
head_dim (int): head dimension
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
qk_scale (float): override default qk scale of head_dim ** -0.5 if set
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
norm_layer (nn.Module): normalization layer
conv_stem (bool): whether use overlapped patch stem
"""
super().__init__()
self.num_classes = num_classes
self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
############ downsample layers (patch embeddings) ######################
self.downsample_layers = nn.ModuleList()
# NOTE: uniformer uses two 3*3 conv, while in many other transformers this is one 7*7 conv
stem = nn.Sequential(
nn.Conv2d(in_chans, embed_dim[0] // 2, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
nn.BatchNorm2d(embed_dim[0] // 2),
nn.GELU(),
nn.Conv2d(embed_dim[0] // 2, embed_dim[0], kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
nn.BatchNorm2d(embed_dim[0]),
)
if (pe is not None) and 0 in pe_stages:
stem.append(get_pe_layer(emb_dim=embed_dim[0], name=pe))
if use_checkpoint_stages:
stem = checkpoint_wrapper(stem)
self.downsample_layers.append(stem)
for i in range(3):
downsample_layer = nn.Sequential(
nn.Conv2d(embed_dim[i], embed_dim[i+1], kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
nn.BatchNorm2d(embed_dim[i+1])
)
if (pe is not None) and i+1 in pe_stages:
downsample_layer.append(get_pe_layer(emb_dim=embed_dim[i+1], name=pe))
if use_checkpoint_stages:
downsample_layer = checkpoint_wrapper(downsample_layer)
self.downsample_layers.append(downsample_layer)
##########################################################################
self.stages = nn.ModuleList() # 4 feature resolution stages, each consisting of multiple residual blocks
nheads= [dim // head_dim for dim in qk_dims]
dp_rates=[x.item() for x in torch.linspace(0, drop_path_rate, sum(depth))]
cur = 0
for i in range(4):
stage = nn.Sequential(
*[Block(dim=embed_dim[i], drop_path=dp_rates[cur + j],
layer_scale_init_value=layer_scale_init_value,
topk=topks[i],
num_heads=nheads[i],
n_win=n_win,
qk_dim=qk_dims[i],
qk_scale=qk_scale,
kv_per_win=kv_per_wins[i],
kv_downsample_ratio=kv_downsample_ratios[i],
kv_downsample_kernel=kv_downsample_kernels[i],
kv_downsample_mode=kv_downsample_mode,
param_attention=param_attention,
param_routing=param_routing,
diff_routing=diff_routing,
soft_routing=soft_routing,
mlp_ratio=mlp_ratios[i],
mlp_dwconv=mlp_dwconv,
side_dwconv=side_dwconv,
before_attn_dwconv=before_attn_dwconv,
pre_norm=pre_norm,
auto_pad=auto_pad) for j in range(depth[i])],
)
if i in use_checkpoint_stages:
stage = checkpoint_wrapper(stage)
self.stages.append(stage)
cur += depth[i]
##########################################################################
self.norm = nn.BatchNorm2d(embed_dim[-1])
# Representation layer
if representation_size:
self.num_features = representation_size
self.pre_logits = nn.Sequential(OrderedDict([
('fc', nn.Linear(embed_dim, representation_size)),
('act', nn.Tanh())
]))
else:
self.pre_logits = nn.Identity()
# Classifier head
self.head = nn.Linear(embed_dim[-1], num_classes) if num_classes > 0 else nn.Identity()
self.apply(self._init_weights)
def _init_weights(self, m):
if isinstance(m, nn.Linear):
trunc_normal_(m.weight, std=.02)
if isinstance(m, nn.Linear) and m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.LayerNorm):
nn.init.constant_(m.bias, 0)
nn.init.constant_(m.weight, 1.0)
@torch.jit.ignore
def no_weight_decay(self):
return {'pos_embed', 'cls_token'}
def get_classifier(self):
return self.head
def reset_classifier(self, num_classes, global_pool=''):
self.num_classes = num_classes
self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
def forward_features(self, x):
for i in range(4):
x = self.downsample_layers[i](x) # res = (56, 28, 14, 7), wins = (64, 16, 4, 1)
x = self.stages[i](x)
x = self.norm(x)
x = self.pre_logits(x)
return x
def forward(self, x):
x = self.forward_features(x)
x = x.flatten(2).mean(-1)
x = self.head(x)
return 四、总结
预告一下：下一篇内容将继续分享深度学习算法相关改进方法。有兴趣的朋友可以关注一下我，有问题可以留言或者私聊我哦
PS：该方法不仅仅是适用改进YOLOv5，也可以改进其他的YOLO网络以及目标检测网络，比如YOLOv7、v6、v4、v3，Faster rcnn ，ssd等。
最后，有需要的请关注私信我吧。关注免费领取深度学习算法学习资料！