改进yolov8|FasterNet更换主干网络，跑得飞快！！

各位哥哥姐姐弟弟妹妹各人好，我是干饭王刘姐，主业干饭，主业2.0计算机研究生在读。
和我一起来改进yolov8变身计算机大牛吧！
本文中的论文笔记都是刘姐亲身整理，原创整理哦~
  一、FasterNet简介

论文地址

   https://export.arxiv.org/pdf/2303.03667v1.pdf
  代码地址

   https://github.com/JierunChen/FasterNet
  论文内容（原创整理）

前述

• 提出了一种新的部门卷积（PConv），更有效地提取空间特征，同时减少冗余计算和内存访问。
  
• MobileNets，ShuffleNets 和GhostNet 等利用 dependency卷积（DWConv）和/或组卷积（GConv）来提取空间特征。然而，在努力减少FLOP的过程中，操作员常常遭受增长的存储器访问的副作用。MicroNet 进一步分解和稀疏化网络，将其FLOP推到极低的程度。
  
• 延迟Latency = FLOPs/FLOPS, FLOPS是每秒浮点运算的缩写，作为有效计算速率的度量。
  
• 本文旨在通过开辟一种简朴而快速有效的运算符来消除这种差异，该运算符可以在降低FLOPs的环境下保持高FLOPS。
  
• 从本质上讲，PConv具有比通例Conv更低的FLOPS，而具有比DWConv/GConv更高的FLOPS。换句话说，PConv更好地利用了设备上的计算能力。
  
• 基于DWConv
  

贡献

• 指出了实现更高FLOPS的重要性，而不但仅是为了更快的神经网络而减少FLOPS。·
  
• 引入了一个简朴而快速有效的算子PConv，它很有可能取代现有的首选项DWConv。·
  
• 推出FasterNet，它可以在GPU，CPU和ARM处置惩罚器等各种设备上顺利运行，速率普遍很快。·
  
• 对各种任务举行了广泛的实验，并验证了PConv和FasterNet的高速和有效性。
  

具体

• 它只是在一部门输入通道上应用通例Conv举行空间特征提取，其余通道保持不变。
  
• PConv的FLOPs为：hwkkcp*cp。
  
• 内存访问量：hw2cp+kkcpcp。
  
• PConv后接PWConv（逐点卷积）
  
• FasterNet，这是一种新的神经网络家族，运行速率快，对许多视觉任务非常有效。
  
  
  
  
  
  
  

显著效果

时间进步巨大50%+，GFLOPs减少60%+
改进过程

FasterNet核心代码（添加到ultralytics/nn/modules/block.py）：

1. # --------------------------FasterNet----------------------------
2. from timm.models.layers import DropPath
5. class Partial_conv3(nn.Module):
6.     def __init__(self, dim, n_div, forward):
7.         super().__init__()
8.         self.dim_conv3 = dim // n_div
9.         self.dim_untouched = dim - self.dim_conv3
10.         self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False)
12.         if forward == 'slicing':
13.             self.forward = self.forward_slicing
14.         elif forward == 'split_cat':
15.             self.forward = self.forward_split_cat
16.         else:
17.             raise NotImplementedError
19.     def forward_slicing(self, x):
20.         # only for inference
21.         x = x.clone()  # !!! Keep the original input intact for the residual connection later
22.         x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :])
24.         return x
26.     def forward_split_cat(self, x):
27.         # for training/inference
28.         x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)
29.         x1 = self.partial_conv3(x1)
30.         x = torch.cat((x1, x2), 1)
31.         return x
34. class MLPBlock(nn.Module):
35.     def __init__(self,
36.                  dim,
37.                  n_div,
38.                  mlp_ratio,
39.                  drop_path,
40.                  layer_scale_init_value,
41.                  act_layer,
42.                  norm_layer,
43.                  pconv_fw_type
44.                  ):
46.         super().__init__()
47.         self.dim = dim
48.         self.mlp_ratio = mlp_ratio
49.         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
50.         self.n_div = n_div
52.         mlp_hidden_dim = int(dim * mlp_ratio)
53.         mlp_layer = [
54.             nn.Conv2d(dim, mlp_hidden_dim, 1, bias=False),
55.             norm_layer(mlp_hidden_dim),
56.             act_layer(),
57.             nn.Conv2d(mlp_hidden_dim, dim, 1, bias=False)
58.         ]
59.         self.mlp = nn.Sequential(*mlp_layer)
60.         self.spatial_mixing = Partial_conv3(
61.             dim,
62.             n_div,
63.             pconv_fw_type
64.         )
65.         if layer_scale_init_value > 0:
66.             self.layer_scale = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
67.             self.forward = self.forward_layer_scale
68.         else:
69.             self.forward = self.forward
71.     def forward(self, x):
72.         shortcut = x
73.         x = self.spatial_mixing(x)
74.         x = shortcut + self.drop_path(self.mlp(x))
75.         return x
77.     def forward_layer_scale(self, x):
78.         shortcut = x
79.         x = self.spatial_mixing(x)
80.         x = shortcut + self.drop_path(
81.             self.layer_scale.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
82.         return x
85. class BasicStage(nn.Module):
86.     def __init__(self,
87.                  dim,
88.                  depth=1,
89.                  n_div=4,
90.                  mlp_ratio=2,
91.                  layer_scale_init_value=0,
92.                  norm_layer=nn.BatchNorm2d,
93.                  act_layer=nn.ReLU,
94.                  pconv_fw_type='split_cat'
95.                  ):
96.         super().__init__()
97.         dpr = [x.item()
98.                for x in torch.linspace(0, 0.0, sum([1, 2, 8, 2]))]
99.         blocks_list = [
100.             MLPBlock(
101.                 dim=dim,
102.                 n_div=n_div,
103.                 mlp_ratio=mlp_ratio,
104.                 drop_path=dpr[i],
105.                 layer_scale_init_value=layer_scale_init_value,
106.                 norm_layer=norm_layer,
107.                 act_layer=act_layer,
108.                 pconv_fw_type=pconv_fw_type
109.             )
110.             for i in range(depth)
111.         ]
113.         self.blocks = nn.Sequential(*blocks_list)
115.     def forward(self, x):
116.         x = self.blocks(x)
117.         return x
120. class PatchEmbed_FasterNet(nn.Module):
122.     def __init__(self, in_chans, embed_dim, patch_size, patch_stride, norm_layer=nn.BatchNorm2d):
123.         super().__init__()
124.         self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_stride, bias=False)
125.         if norm_layer is not None:
126.             self.norm = norm_layer(embed_dim)
127.         else:
128.             self.norm = nn.Identity()
130.     def forward(self, x):
131.         x = self.norm(self.proj(x))
132.         return x
134.     def fuseforward(self, x):
135.         x = self.proj(x)
136.         return x
139. class PatchMerging_FasterNet(nn.Module):
141.     def __init__(self, dim, out_dim, k, patch_stride2, norm_layer=nn.BatchNorm2d):
142.         super().__init__()
143.         self.reduction = nn.Conv2d(dim, out_dim, kernel_size=k, stride=patch_stride2, bias=False)
144.         if norm_layer is not None:
145.             self.norm = norm_layer(out_dim)
146.         else:
147.             self.norm = nn.Identity()
149.     def forward(self, x):
150.         x = self.norm(self.reduction(x))
151.         return x
153.     def fuseforward(self, x):
154.         x = self.reduction(x)
155.         return x

复制代码

并在ultralytics/nn/modules/block.py中最上方“all”中引用‘BasicStage’, ‘PatchEmbed_FasterNet’, ‘PatchMerging_FasterNet’

在ultralytics/nn/modules/init.py中

1. from .block import (....,BasicStage,PatchEmbed_FasterNet,PatchMerging_FasterNet)

复制代码

在 ultralytics/nn/tasks.py 上方

1. from ultralytics.nn.modules import (....BasicStage, PatchEmbed_FasterNet, PatchMerging_FasterNet)

复制代码

在parse_model解析函数中添加如下代码：

1. if m in (... BasicStage, PatchEmbed_FasterNet, PatchMerging_FasterNet):

复制代码

和

1.         elif m in [BasicStage]:
2.                 args.pop(1)

复制代码

在 ultralytics/nn/tasks.py 中的self.model.modules()后面添加

1.                 if type(m) is PatchEmbed_FasterNet:
2.                     m.proj = fuse_conv_and_bn(m.proj, m.norm)
3.                     delattr(m, 'norm')  # remove BN
4.                     m.forward = m.fuseforward
5.                 if type(m) is PatchMerging_FasterNet:
6.                     m.reduction = fuse_conv_and_bn(m.reduction, m.norm)
7.                     delattr(m, 'norm')  # remove BN
8.                     m.forward = m.fuseforward

复制代码

在ultralytics/cfg/models/v8文件夹下新建yolov8-FasterNet.yaml文件

[code]# Ultralytics YOLO