當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

【魔改YOLOv5-6.x（上）】结合轻量化网络Shufflenetv2、Mobilenetv3和Ghostnet

發布時間：2024/1/18 编程问答 36 豆豆

生活随笔收集整理的這篇文章主要介紹了【魔改YOLOv5-6.x（上）】结合轻量化网络Shufflenetv2、Mobilenetv3和Ghostnet 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

文章目錄

- 前言
- 一、Shufflenetv2
- - 論文簡介
  - 模型概述
  - 加入YOLOv5
- 二、Mobilenetv3
- - 論文簡介
  - 模型概述
  - - 深度可分離卷積
    - 逆殘差結構
    - SE通道注意力
    - h-swish激活函數
  - 加入YOLOv5
- 三、Ghostnet
- - 論文簡介
  - 模型概述
  - 加入YOLOv5
- References

前言

本文使用的YOLOv5版本為v6.1，對YOLOv5-6.x網絡結構還不熟悉的同學們，可以移步至：【YOLOv5-6.x】網絡模型&源碼解析

另外，本文所使用的實驗環境為1個GTX 1080 GPU，數據集為VOC2007，超參數為hyp.scratch-low.yaml，訓練200個epoch，其他參數均為源碼中默認設置的數值。

YOLOv5中修改網絡結構的一般步驟：

models/common.py：在common.py文件中，加入要修改的模塊代碼
models/yolo.py：在yolo.py文件內的parse_model函數里添加新模塊的名稱
models/new_model.yaml：在models文件夾下新建模塊對應的.yaml文件

一、Shufflenetv2

[Cite]Ma, Ningning, et al. “Shufflenet v2: Practical guidelines for efficient cnn architecture design.” Proceedings of the European conference on computer vision (ECCV). 2018.

論文地址

論文代碼

論文簡介

曠視輕量化卷積神經網絡Shufflenetv2，通過大量實驗提出四條輕量化網絡設計準則，對輸入輸出通道、分組卷積組數、網絡碎片化程度、逐元素操作對不同硬件上的速度和內存訪問量MAC(Memory Access Cost)的影響進行了詳細分析：

準則一：輸入輸出通道數相同時，內存訪問量MAC最小
- Mobilenetv2就不滿足，采用了擬殘差結構，輸入輸出通道數不相等
準則二：分組數過大的分組卷積會增加MAC
- Shufflenetv1就不滿足，采用了分組卷積（GConv）
準則三：碎片化操作（多通路，把網絡搞的很寬）對并行加速不友好
- Inception系列的網絡
準則四：逐元素操作（Element-wise，例如ReLU、Shortcut-add等）帶來的內存和耗時不可忽略
- Shufflenetv1就不滿足，采用了add操作

針對以上四條準則，作者提出了Shufflenetv2模型，通過Channel Split替代分組卷積，滿足四條設計準則，達到了速度和精度的最優權衡。

模型概述

Shufflenetv2有兩個結構：basic unit和unit from spatial down sampling(2×)

basic unit：輸入輸出通道數不變，大小也不變
unit from spatial down sample ：輸出通道數擴大一倍，大小縮小一倍（降采樣）

Shufflenetv2整體哲學要緊緊向論文中提出的輕量化四大準則靠攏，基本除了準則四之外，都有效的避免了。

為了解決GConv(Group Convolution)導致的不同group之間沒有信息交流，只在同一個group內進行特征提取的問題，Shufflenetv2設計了Channel Shuffle操作進行通道重排，跨group信息交流

class ShuffleBlock(nn.Module):def __init__(self, groups=2):super(ShuffleBlock, self).__init__()self.groups = groupsdef forward(self, x):'''Channel shuffle: [N,C,H,W] -> [N,g,C/g,H,W] -> [N,C/g,g,H,W] -> [N,C,H,W]'''N, C, H, W = x.size()g = self.groupsreturn x.view(N, g, C//g, H, W).permute(0, 2, 1, 3, 4).reshape(N, C, H, W)

加入YOLOv5

common.py文件修改：直接在最下面加入如下代碼

# ---------------------------- ShuffleBlock start -------------------------------# 通道重排，跨group信息交流 def channel_shuffle(x, groups):batchsize, num_channels, height, width = x.data.size()channels_per_group = num_channels // groups# reshapex = x.view(batchsize, groups,channels_per_group, height, width)x = torch.transpose(x, 1, 2).contiguous()# flattenx = x.view(batchsize, -1, height, width)return xclass conv_bn_relu_maxpool(nn.Module):def __init__(self, c1, c2): # ch_in, ch_outsuper(conv_bn_relu_maxpool, self).__init__()self.conv = nn.Sequential(nn.Conv2d(c1, c2, kernel_size=3, stride=2, padding=1, bias=False),nn.BatchNorm2d(c2),nn.ReLU(inplace=True),)self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)def forward(self, x):return self.maxpool(self.conv(x))class Shuffle_Block(nn.Module):def __init__(self, inp, oup, stride):super(Shuffle_Block, self).__init__()if not (1 <= stride <= 3):raise ValueError('illegal stride value')self.stride = stridebranch_features = oup // 2assert (self.stride != 1) or (inp == branch_features << 1)if self.stride > 1:self.branch1 = nn.Sequential(self.depthwise_conv(inp, inp, kernel_size=3, stride=self.stride, padding=1),nn.BatchNorm2d(inp),nn.Conv2d(inp, branch_features, kernel_size=1, stride=1, padding=0, bias=False),nn.BatchNorm2d(branch_features),nn.ReLU(inplace=True),)self.branch2 = nn.Sequential(nn.Conv2d(inp if (self.stride > 1) else branch_features,branch_features, kernel_size=1, stride=1, padding=0, bias=False),nn.BatchNorm2d(branch_features),nn.ReLU(inplace=True),self.depthwise_conv(branch_features, branch_features, kernel_size=3, stride=self.stride, padding=1),nn.BatchNorm2d(branch_features),nn.Conv2d(branch_features, branch_features, kernel_size=1, stride=1, padding=0, bias=False),nn.BatchNorm2d(branch_features),nn.ReLU(inplace=True),)@staticmethoddef depthwise_conv(i, o, kernel_size, stride=1, padding=0, bias=False):return nn.Conv2d(i, o, kernel_size, stride, padding, bias=bias, groups=i)def forward(self, x):if self.stride == 1:x1, x2 = x.chunk(2, dim=1) # 按照維度1進行splitout = torch.cat((x1, self.branch2(x2)), dim=1)else:out = torch.cat((self.branch1(x), self.branch2(x)), dim=1)out = channel_shuffle(out, 2)return out# ---------------------------- ShuffleBlock end --------------------------------

yolo.py文件修改：在yolo.py的parse_model函數中，加入conv_bn_relu_maxpool, Shuffle_Block兩個模塊（如下圖紅框所示）
新建yaml文件：在model文件下新建yolov5-shufflenetv2.yaml文件，復制以下代碼即可

二、Mobilenetv3

[Cite]Howard, Andrew, et al. “Searching for mobilenetv3.” Proceedings of the IEEE/CVF International Conference on Computer Vision. 2019.

論文地址

論文代碼

論文簡介

MobileNetV3，是谷歌在2019年3月21日提出的輕量化網絡架構，在前兩個版本的基礎上，加入神經網絡架構搜索（NAS）和h-swish激活函數，并引入SE通道注意力機制，性能和速度都表現優異，受到學術界和工業界的追捧。

主要特點：

論文推出兩個版本：Large 和 Small，分別適用于不同的場景

網絡的架構基于NAS實現的MnasNet（效果比MobileNetV2好），由NAS搜索獲取參數

引入MobileNetV1的深度可分離卷積

引入MobileNetV2的具有線性瓶頸的倒殘差結構

引入基于squeeze and excitation結構的輕量級注意力模型(SE)

使用了一種新的激活函數h-swish(x)

網絡結構搜索中，結合兩種技術：資源受限的NAS（platform-aware NAS）與NetAdapt

修改了MobileNetV2網絡端部最后階段

模型概述

深度可分離卷積

Mobilenetv1提出了深度可分離卷積，就是將普通卷積拆分成為一個深度卷積(Depthwise Convolutional Filters)和一個逐點卷積(Pointwise Convolution)：

Depthwise Convolutional Filters：將卷積核拆分成為單通道形式，在不改變輸入特征圖像深度的情況下，對每一通道進行卷積操作，這樣就得到了和輸入特征圖通道數一致的輸出特征圖，這樣就會有一個問題，通道數太少，特征圖的維度太少，能獲取到足夠的有效信息嗎？
Pointwise Convolution：逐點卷積就是1×1卷積，主要作用就是對特征圖進行升維和降維，在深度卷積的過程中，假設得到了8×8×3的輸出特征圖，我們用256個1×1×3的卷積核對輸入特征圖進行卷積操作，輸出的特征圖和標準的卷積操作一樣都是8×8×256了

逆殘差結構

深度卷積本身沒有改變通道的能力，來的是多少通道輸出就是多少通道，如果來的通道很少的話，DW深度卷積只能在低維度上工作，這樣效果并不會很好，所以我們要“擴張”通道。

既然我們已經知道PW逐點卷積也就是1×1卷積可以用來升維和降維，那就可以在DW深度卷積之前使用PW卷積進行升維（升維倍數為t，t=6），再在一個更高維的空間中進行卷積操作來提取特征，這樣不管輸入通道數是多少，經過第一個PW逐點卷積升維之后，深度卷積都是在相對的更高6倍維度上進行工作。

Inverted residuals：為了像Resnet一樣復用特征，引入了shortcut結構，采用了 1×1 -> 3 ×3 -> 1 × 1 的模式，但是不同點是：

ResNet 先降維 (0.25倍)、卷積、再升維
Mobilenetv2 則是先升維 (6倍)、卷積、再降維

SE通道注意力

SE通道注意力出自論文：《Squeeze-and-excitation networks.》，主要是探討了卷積神經網絡中信息特征的構造問題，而作者提出了一種稱為“Squeeze-Excitation(SE)”的組件：

SE組件的作用是：可以通過顯示地建模通道之間的相互依存關系來增強通道級的特征響應（說白了就是學習一組權重，將這組權重賦予到每一個通道來進一步改善特征表示），使得重要特征得到加強，非重要特征得到弱化
具體來說，就是通過學習的方式來自動獲取到每個特征通道的重要程度，然后依照這個重要程度去提升有用的特征并抑制對當前任務用處不大的特征

class SELayer(nn.Module):def __init__(self, channel, reduction=4):super(SELayer, self).__init__()# Squeeze操作self.avg_pool = nn.AdaptiveAvgPool2d(1)# Excitation操作(FC+ReLU+FC+Sigmoid)self.fc = nn.Sequential(nn.Linear(channel, channel // reduction),nn.ReLU(inplace=True),nn.Linear(channel // reduction, channel),h_sigmoid())def forward(self, x):b, c, _, _ = x.size()y = self.avg_pool(x)y = y.view(b, c)y = self.fc(y).view(b, c, 1, 1) # 學習到的每一channel的權重return x * y

h-swish激活函數

近似操作模擬swish和relu，公式如下：

$h\_swish(x)=x*\frac{ReLU6(x+3)}{6}$ 、 $h\_sigmoid(x)=\frac{ReLU6(x+3)}{6}$

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) / 6class 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)

加入YOLOv5

common.py文件修改：直接在最下面加入如下代碼

# ---------------------------- MobileBlock start ------------------------------- 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) / 6class 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 SELayer(nn.Module):def __init__(self, channel, reduction=4):super(SELayer, self).__init__()# Squeeze操作self.avg_pool = nn.AdaptiveAvgPool2d(1)# Excitation操作(FC+ReLU+FC+Sigmoid)self.fc = nn.Sequential(nn.Linear(channel, channel // reduction),nn.ReLU(inplace=True),nn.Linear(channel // reduction, channel),h_sigmoid())def forward(self, x):b, c, _, _ = x.size()y = self.avg_pool(x)y = y.view(b, c)y = self.fc(y).view(b, c, 1, 1) # 學習到的每一channel的權重return x * yclass conv_bn_hswish(nn.Module):"""This equals todef conv_3x3_bn(inp, oup, stride):return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False),nn.BatchNorm2d(oup),h_swish())"""def __init__(self, c1, c2, stride):super(conv_bn_hswish, self).__init__()self.conv = nn.Conv2d(c1, c2, 3, stride, 1, bias=False)self.bn = nn.BatchNorm2d(c2)self.act = h_swish()def forward(self, x):return self.act(self.bn(self.conv(x)))def fuseforward(self, x):return self.act(self.conv(x))class MobileNet_Block(nn.Module):def __init__(self, inp, oup, hidden_dim, kernel_size, stride, use_se, use_hs):super(MobileNet_Block, self).__init__()assert stride in [1, 2]self.identity = stride == 1 and inp == oup# 輸入通道數=擴張通道數則不進行通道擴張if inp == hidden_dim:self.conv = nn.Sequential(# dwnn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim,bias=False),nn.BatchNorm2d(hidden_dim),h_swish() if use_hs else nn.ReLU(inplace=True),# Squeeze-and-ExciteSELayer(hidden_dim) if use_se else nn.Sequential(),# pw-linearnn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),nn.BatchNorm2d(oup),)else:# 否則先進行通道擴張self.conv = nn.Sequential(# pwnn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),nn.BatchNorm2d(hidden_dim),h_swish() if use_hs else nn.ReLU(inplace=True),# dwnn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim,bias=False),nn.BatchNorm2d(hidden_dim),# Squeeze-and-ExciteSELayer(hidden_dim) if use_se else nn.Sequential(),h_swish() if use_hs else nn.ReLU(inplace=True),# pw-linearnn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),nn.BatchNorm2d(oup),)def forward(self, x):y = self.conv(x)if self.identity:return x + yelse:return y# ---------------------------- MobileBlock end ---------------------------------

yolo.py文件修改：在yolo.py的parse_model函數中，加入h_sigmoid, h_swish, SELayer, conv_bn_hswish, MobileNet_Block五個模塊
新建yaml文件：在model文件下新建yolov5-mobilenetv3-small.yaml文件，復制以下代碼即可

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license# Parameters nc: 20 # number of classes depth_multiple: 1.0 # model depth multiple width_multiple: 1.0 # 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:# MobileNetV3-small 11層# [from, number, module, args]# MobileNet_Block: [out_ch, hidden_ch, kernel_size, stride, use_se, use_hs]# hidden_ch表示在Inverted residuals中的擴張通道數# use_se 表示是否使用 SELayer, use_hs 表示使用 h_swish 還是 ReLU[[-1, 1, conv_bn_hswish, [16, 2]], # 0-p1/2[-1, 1, MobileNet_Block, [16, 16, 3, 2, 1, 0]], # 1-p2/4[-1, 1, MobileNet_Block, [24, 72, 3, 2, 0, 0]], # 2-p3/8[-1, 1, MobileNet_Block, [24, 88, 3, 1, 0, 0]], # 3-p3/8[-1, 1, MobileNet_Block, [40, 96, 5, 2, 1, 1]], # 4-p4/16[-1, 1, MobileNet_Block, [40, 240, 5, 1, 1, 1]], # 5-p4/16[-1, 1, MobileNet_Block, [40, 240, 5, 1, 1, 1]], # 6-p4/16[-1, 1, MobileNet_Block, [48, 120, 5, 1, 1, 1]], # 7-p4/16[-1, 1, MobileNet_Block, [48, 144, 5, 1, 1, 1]], # 8-p4/16[-1, 1, MobileNet_Block, [96, 288, 5, 2, 1, 1]], # 9-p5/32[-1, 1, MobileNet_Block, [96, 576, 5, 1, 1, 1]], # 10-p5/32[-1, 1, MobileNet_Block, [96, 576, 5, 1, 1, 1]], # 11-p5/32]# YOLOv5 v6.0 head head:[[-1, 1, Conv, [256, 1, 1]],[-1, 1, nn.Upsample, [None, 2, 'nearest']],[[-1, 8], 1, Concat, [1]], # cat backbone P4[-1, 1, C3, [256, False]], # 15[-1, 1, Conv, [128, 1, 1]],[-1, 1, nn.Upsample, [None, 2, 'nearest']],[[-1, 3], 1, Concat, [1]], # cat backbone P3[-1, 1, C3, [128, False]], # 19 (P3/8-small)[-1, 1, Conv, [128, 3, 2]],[[-1, 16], 1, Concat, [1]], # cat head P4[-1, 1, C3, [256, False]], # 22 (P4/16-medium)[-1, 1, Conv, [256, 3, 2]],[[-1, 12], 1, Concat, [1]], # cat head P5[-1, 1, C3, [512, False]], # 25 (P5/32-large)[[19, 22, 25], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)]

三、Ghostnet

Han, Kai, et al. “Ghostnet: More features from cheap operations.” Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2020.

論文地址

論文代碼

論文簡介

Ghostnet出自華為諾亞方舟實驗室，作者發現在傳統的深度學習網絡中存在著大量冗余，但是對模型的精度至關重要的特征圖。這些特征圖是由卷積操作得到，又輸入到下一個卷積層進行運算，這個過程包含大量的網絡參數，消耗了大量的計算資源。

作者考慮到這些feature map層中的冗余信息可能是一個成功模型的重要組成部分，正是因為這些冗余信息才能保證輸入數據的全面理解，所以作者在設計輕量化模型的時候并沒有試圖去除這些冗余feature map，而是嘗試使用更低成本的計算量來獲取這些冗余feature map。
?

模型概述

Ghost卷積部分將傳統卷積操作分為兩部分：

第一步，使用少量卷積核進行卷積操作（比如正常用64個，這里就用32個，從而減少一半計算量）
第二步，使用3×3或5×5的卷積核進行逐通道卷積操作（Cheap operations）

最終將第一部分作為一份恒等映射（Identity），與第二步的結果進行Concat操作

GhostBottleneck部分有兩種結構：

stride=1，不進行下采樣時，直接進行兩個Ghost卷積操作
stride=2，進行下采樣時，多出來一個步長為2的深度卷積操作

加入YOLOv5

在最新版本的YOLOv5-6.1源碼中，作者已經加入了Ghost模塊，并在models/hub/文件夾下，給出了yolov5s-ghost.yaml文件，因此直接使用即可。

class GhostConv(nn.Module):# Ghost Convolution https://github.com/huawei-noah/ghostnetdef __init__(self, c1, c2, k=1, s=1, g=1, act=True): # ch_in, ch_out, kernel, stride, groupssuper().__init__()c_ = c2 // 2 # hidden channelsself.cv1 = Conv(c1, c_, k, s, None, g, act) # 先進行一半卷積減少計算量self.cv2 = Conv(c_, c_, 5, 1, None, c_, act) # 再進行逐特征圖卷積def forward(self, x):y = self.cv1(x)return torch.cat([y, self.cv2(y)], 1) # 最后將兩部分進行concatclass GhostBottleneck(nn.Module):# Ghost Bottleneck https://github.com/huawei-noah/ghostnetdef __init__(self, c1, c2, k=3, s=1): # ch_in, ch_out, kernel, stridesuper().__init__()c_ = c2 // 2self.conv = nn.Sequential(GhostConv(c1, c_, 1, 1), # pw# dw 當stride=2時才開啟DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),GhostConv(c_, c2, 1, 1, act=False)) # pw-linearself.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False),Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity()def forward(self, x):return self.conv(x) + self.shortcut(x) # Add(Element-Wise操作)class C3Ghost(C3):# C3 module with GhostBottleneck()def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):super().__init__(c1, c2, n, shortcut, g, e) # 引入C3(父類)的屬性c_ = int(c2 * e) # hidden channelsself.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n)))

References

【精讀AI論文】曠視輕量化網絡ShuffleNet V2-算法精講

輕量級神經網絡“巡禮”（一）—— ShuffleNetV2

輕量級神經網絡“巡禮”（二）—— MobileNet，從V1到V3

Yolov5更換backbone，與模型壓縮（剪枝，量化，蒸餾）

目標檢測 YOLOv5 自定義網絡結構

總結

以上是生活随笔為你收集整理的【魔改YOLOv5-6.x（上）】结合轻量化网络Shufflenetv2、Mobilenetv3和Ghostnet的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：文件格式转换软件有哪些？值得推荐的几款软
下一篇：打造轻量级自动化测试框架WebZ