数学建模社区-数学中国
标题:
轻量级神经网络算法-SqueezeNet
[打印本页]
作者:
杨利霞
时间:
2022-9-5 16:42
标题:
轻量级神经网络算法-SqueezeNet
, f }1 d8 q$ F. @) x# |
轻量级神经网络算法-SqueezeNet
' s" J: m) `8 [
4. 轻量级神经网络算法目录
( u; U2 S S7 z6 N: @$ q D3 S. Q
轻量级神经网络算法
+ W! V2 Q* ^7 I2 C9 B
4.1 各轻量级神经网络算法总结对比
& A$ D, X+ l* d P `
4.2 SqueezeNet
L C' \" s3 l2 O- A
4.3 DenseNet
& \3 ^4 Q5 W" L8 u3 a
4.4 Xception
) ^( y% g0 s- g( K8 ~# @: ^2 j
4.5 MobileNet v1
; c* ]& q! j2 m4 ?0 Y4 [7 M. t
4.6 IGCV
; P# x' g4 L% M% P
4.7 NASNet
. p8 m y. B* C, Q% r1 x
4.8 CondenseNet
- n; ]' T/ R! t
4.9 PNASNet
% v7 j M# Q, i
4.10 SENet
$ n0 N& D8 N' T# b0 i
4.11 ShuffleNet v1
0 `7 D4 B! I, S1 E
4.12 MobileNet v2
5 \ h3 Y; ^. |
4.13 AmoebaNet
0 [8 A5 o* s1 d! H! `8 y9 ~
4.14 IGCV2
$ a5 l: b1 q' r
4.15 IGCV3
. o) V" X6 w; \# d2 p8 I; Z
4.16 ShuffleNet v2
3 p. g+ Z* B# g2 b; T- a4 D
4.17 MnasNet
* ~. Q) I; R) l0 I/ W( g
4.18 MobileNet v3
: K8 h% e0 }. w
深度学习知识点总结
, G% \( w# c5 B! g( g, E3 L
4 X% u! I! i# O5 Y8 {" [
专栏链接:
& b8 |( Y: `2 s! o* U' T
https://blog.csdn.net/qq_39707285/article/details/124005405
% C' B0 K# J9 d& a2 t' G
本专栏主要总结深度学习中的知识点,从各大数据集比赛开始,介绍历年冠军算法;同时总结深度学习中重要的知识点,包括损失函数、优化器、各种经典算法、各种算法的优化策略Bag of Freebies (BoF)等。
+ ]" w' h( f8 p# M
6 B# y7 j m7 u( x. S G$ c) g
本章目录
Q2 A! c( K/ C: O2 C3 C" o
4. 轻量级神经网络算法目录
3 q( f4 _( O* X/ u, c- x. M
4.2 SqueezeNet
, @3 N0 T7 r' K
4.2.1 问题分析
' C1 |, m) \: e5 F" U( N/ ^
4.2.2 SqueezeNet的三大策略
, m$ e( H$ \5 U8 W; }7 z
4.2.3 Fire模块
0 g# a% y. E- m
4.2.4 SqueezeNet整理结构
' ]6 q9 C; @# ~9 S# c
4.2.5 代码实现SqueezeNet
' A' M* e3 ^ f! n2 V
4.2.6 其他实现细节
. Z& S0 i8 y' b+ }+ e
4.2.7 总结
+ M# o1 q. e( S# e# \5 I( V$ @0 j
4.2 SqueezeNet
' j) |0 Y) d- ]% c& M& t+ r
4.2.1 问题分析
0 U8 w- Q+ N4 D' g4 C, [- O. w5 [
最近在卷积神经网络上的研究主要关注提高准确率。在给定相应的准确率之后,通常有多个CNN结构可以达到该准确率要求。在同等准确率的情况下,较小的CNN结构至少有三个优点:
, q+ \+ y7 ^2 f+ `6 P% R
3 A3 {, p1 ?- ^' z
在分布式训练期间,较小的CNN需要较少的跨服务器通信
. ?" s* o2 H' [/ m3 x# _2 u% ]8 v
在自动驾驶汽车等应用场景下,较小的CNN需要较少的带宽将新模型从云端导入
( b4 B' K& q7 ~ l% E3 e5 i" c
较小的CNN更适合部署在FPGA和其他内存有限的硬件上
+ Q1 u5 i' C6 o& \
为了达到所有这些优点,本文提出了较小的CNN结构,称之为SqueezeNet。SqueezeNet在ImageNet上实现了AlexNet同级别的准确率,但参数减少了50倍。另外使用模型压缩技术,能够将SqueezeNet压缩到小于0.5MB(比AlexNet小近510倍)。
( V/ `( N! y. S4 K0 e1 G
% C/ ~; x# s5 e g; K1 [
4.2.2 SqueezeNet的三大策略
2 c# ~; n C2 ^( z
策略1:用1x1卷积代替3x3卷积
& ?+ S3 M; d; ^2 |* T& c- c/ v
1x1卷积核的参数比3x3少9倍,所以网络中部分卷积核改为使用为1x1卷积。
1 z5 F' X8 q- ~/ x4 Y0 W
8 q$ P2 x4 u8 ]( N5 y* y
策略2:减少输入到3*3卷积核的通道数量
z, }4 A5 v" Z
对于一个完全由3×3卷积核组成的卷积层来说,总参数量=输入通道数×卷积核数量×(3×3),所以仅仅替换3×3卷积核为1×1,还不能完全达到减少参数的目的,还需要减少输入到3×3卷积核的通道数。本文提出squeeze layer,来减少输入到3×3卷积核的通道数。
2 {$ o' T" K" K
% N. d' @* j! U" h
策略3:在网络后期再进行下采样,使卷积层具有较大的激活图
5 S& f1 m8 P' U# T; d9 N
这里的激活图(activate maps)指的是输出的特征图。在卷积网络中,每个卷积层产生空间分辨率至少为1×1(经常大于1×1)的输出激活图,激活图的宽和高主要是由1)输入的数据(例如256×256的图片) 2)CNN结构中下采样层方法 决定的。下采样通常是stride>1的卷积层或者池化层,如果在早期layer中有较大的stride,则后面大部分的layers中将是小的激活图,如果在早期layer中stride为1,在网络后期layer中stride>1,则大部分的layer将有一个大的激活图。本文的观点是,大的激活图能够产生更高的分类准确率,所以在网络设计中,stride>1往往设置在后期的layer中。
- A# w+ M+ o) f6 q
$ y# I! z( g8 u" V
策略1和策略2在试图保持准确性的同时,明智地减少CNN中的参数数量,策略3是在有限的参数预算上最大化准确率。
# o5 f) S6 N# Q y* |; e1 c
& W: }1 Z9 e4 P1 l! n* ?& n
4.2.3 Fire模块
; I: |, \- v) i6 y% Q# e
为实现这3大策略,提出了Fire模块,Fire模块中主要包含squeeze层和expand层。squeeze卷积如图橙色椭圆内所示,只使用1×1卷积(策略1优化点),然后进入到expand卷积,expand卷积包括1×1(策略1优化点)和3×3卷积,squeeze和expand整体构成Fire模块,该模块有三个超参数s1x1,e1x1,e3x3,其中s1x1是squeeze层卷积核的数量,e1x1是expand层中1×1卷积核的数量,e3x3是expand层中3×3卷积核的数量,另外设置s1x1<(e1x1+e3x3)(策略2优化点),这样就能限制输入到3×3卷积核通道数,实现策略2的想法。
- J9 l1 l$ \8 x( Z) U
' B' M( L1 N# @' z$ X
/ l2 e# X$ R% K& w
4.2.4 SqueezeNet整理结构
5 j; j" s7 B( o6 m7 Q3 B! u
SqueezeNet整体网络结构图如下所示,其中maxpool(stride=2)分别设置在conv1/fire4/fire8/conv10之后,这些相对较晚的pool安排符合策略3的想法。
! z; i% Z8 n* ?: K
: P4 B/ T* p8 n: V+ n1 N# N
2 M. @ O) ~. C, c H9 J: M
4.2.5 代码实现SqueezeNet
5 T' T' F% J Q& f6 u* }1 E
Fire模块的代码如下:
% ^7 ~- Z* U7 X$ W3 T/ |5 y
Q$ w% M* E; v$ {3 i' i
class Fire(nn.Module):
* C" k; j' ~' f4 @: ?3 S2 ?: G
7 P, u) R: @: W: g9 \ x3 l: k: {+ |
def __init__(
$ s) v) c. r% [. \
self,
; p7 d, o$ l% o7 [8 p' w
inplanes: int,
' E; d! }" Z c- v$ m, k
squeeze_planes: int,
) J; v: A) l! u: H' z
expand1x1_planes: int,
; W$ H1 f! d e( k) ?6 `" D7 n. l% P' b
expand3x3_planes: int
! V9 r0 w0 n/ x( b N- M4 U% X6 u
) -> None:
+ A6 x! Q4 `( H: q3 |
super(Fire, self).__init__()
2 t) \" g- h/ N6 {' ~; H+ J) c
self.inplanes = inplanes
+ B+ f" ]: ?* u0 n7 ?
self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)
! b5 @' e5 O- \( z7 z5 P7 j$ j
self.squeeze_activation = nn.ReLU(inplace=True)
) b5 E$ o) z: D: m: ~$ x
self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes,
, h) S: [2 h# |
kernel_size=1)
7 ] C7 C* Y7 C2 J1 d
self.expand1x1_activation = nn.ReLU(inplace=True)
2 m y* S, j! @9 E3 P! j8 B9 w9 w
self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes,
6 h1 k- i8 C: Y. F# Y8 A
kernel_size=3, padding=1)
1 L6 F5 i% V: v* [. |" Q$ L
self.expand3x3_activation = nn.ReLU(inplace=True)
: V0 e9 U; ~7 H8 i' l& X
/ @3 X, Y) |4 {& }* Q: D. K+ k
def forward(self, x: torch.Tensor) -> torch.Tensor:
8 [* \4 X" }. K4 d- W( T+ y) O9 x
x = self.squeeze_activation(self.squeeze(x))
/ O9 P' ?3 Q n% ^5 ^, |2 Y0 d
return torch.cat([
2 W5 K1 m% h! @, @* i
self.expand1x1_activation(self.expand1x1(x)),
- b! X7 {! y9 L4 b5 ?& N+ e* ~
self.expand3x3_activation(self.expand3x3(x))
+ p$ W* o+ K6 i) o& F& t! a {- _
], 1)
% J& L' T5 Y- q1 g
& k. L- p5 G- r j4 V% L
1
5 h; s3 O6 e' U2 K4 {1 e
2
+ j% }5 k( Y1 n: C* K4 @: H0 M
3
9 U; s# \, ]8 n' \ g) r+ \+ I
4
. P% I+ l* @$ _! G
5
0 ] E% M* ?2 o2 S' |/ s( t% V
6
( m# _$ L' |: S# J* U
7
5 u) i) f5 |5 z: p
8
$ h0 X, l$ d. G @, O b
9
: y2 C X, h8 t4 M" R0 Y8 M+ x* X
10
1 _1 r- T. Y4 D* Q) u9 Y9 Z4 p1 `
11
0 i; N/ b3 k# O% W1 A
12
7 _; C1 W0 J* S+ U5 }
13
7 d( A. I$ p$ L) U8 @8 E* b4 O: V+ n8 C
14
$ m$ m/ w) S! X* D8 V- X( j! F
15
2 b! I. J" j' j' ]+ a
16
O% U- u7 U$ j$ v
17
' n( O) |2 R0 I$ D: Y
18
1 P; M' T b- R; f0 Z0 Z7 x
19
. s/ d0 V& G" p
20
2 x' |: o7 [- w* p8 X. K' u, P
21
( R4 j3 A# r6 H! N
22
" h: Y0 F' o0 R9 o- d
23
5 w1 q+ f6 j6 r4 @( t
24
0 v# ?. @! Y3 x/ Q/ m) ?2 l3 [
25
4 \+ y+ h) U$ U% I4 l
26
/ C2 g3 R# w% Z
SqueezeNet主要有两个结构,SqueezeNet1_0和SqueezeNet1_1,SqueezeNet1_0即官方版本(图2左侧),SqueezeNet1_1与SqueezeNet1_0相比在没有减少准确率的情况下,节省近2.4倍的参数量和计算量。
! {% P: P% P3 C; |7 i
4 b6 E' S+ X, H# U7 x0 q+ A
SqueezeNet1_0的网络结构如下:
) ^+ k1 D2 \9 Y4 ^
7 S1 `9 B7 |( v* _. v
self.features = nn.Sequential(
1 [$ |( w& B; P* t
nn.Conv2d(3, 96, kernel_size=7, stride=2),
- x; X5 B+ d5 w# ^0 b" D: y, f
nn.ReLU(inplace=True),
$ o. d* M7 W) t4 N
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
' @$ a0 |; J' h! v o. V
Fire(96, 16, 64, 64),
5 }, a3 u6 i! M d
Fire(128, 16, 64, 64),
& C. Q, u- I7 ]2 K* @7 v) \- x
Fire(128, 32, 128, 128),
% z. O2 W. k9 d; h; a0 ~
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
9 t. m Q' D z$ D/ s
Fire(256, 32, 128, 128),
2 J8 T: ^4 h: Z2 S) D/ U, C
Fire(256, 48, 192, 192),
4 ~5 H4 S5 O0 J P5 H0 m
Fire(384, 48, 192, 192),
% ]; }3 }' h, L' w' n0 Y; ?
Fire(384, 64, 256, 256),
& D2 q$ h- _3 L
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
2 l& C, } O' v g, N6 }/ c' H
Fire(512, 64, 256, 256),
0 \3 W' I/ o! V/ D8 O
)
9 ~( F+ B `- {$ y/ e2 Z% w& Y ]! w7 {
final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
% w8 @, K) U$ |" G+ t& m
self.classifier = nn.Sequential(
+ ]! Q+ w# u( [- }( }
nn.Dropout(p=0.5),
; \& W; L8 O4 B, w$ U+ Z
final_conv,
. @! I+ G8 V- l. I
nn.ReLU(inplace=True),
& M' r( t0 ~/ k' d( N
nn.AdaptiveAvgPool2d((1, 1))
7 a5 ]5 t' k! Q/ N8 u7 y* r' H
)
: x2 y% y; A" n& m* e6 F: P
6 {1 p9 J$ o7 A7 h9 {
2 @& b2 j+ B9 C+ | X: ?
1
. G+ f0 s U% i4 ^; |
2
# K& z3 V9 R/ J% Y# X
3
2 M; I3 T1 O7 G1 K3 C" t2 g; ~3 t( u# N
4
) f, R. \8 Y Q
5
4 R0 O! ]! X+ ] y
6
]% d8 b4 i z5 g
7
: h7 J6 x; {9 p5 r1 j3 l: A8 S; N" }5 w3 E
8
{0 A3 v' Y% C8 ~2 V/ H/ q6 l
9
. a6 e P0 \) T4 {) I5 U* X% k
10
) Q$ F, l, w# U: U
11
) h( h; K! s, q6 Y( `0 g
12
( J! O( H: Z# O) p' i, I
13
6 U8 d3 }: l5 m% E6 w
14
2 w6 R; J ^& S2 r
15
+ Y5 F4 U2 }9 v _' Q" I9 U
16
! D3 o3 K6 Z1 g/ q! F
17
! P s% ~$ C7 d+ G
18
! w1 ]+ s6 S) T+ k5 @; q6 ^# ~
19
' K0 U5 M: {/ N5 g6 M! `
20
5 ^7 L% V2 t7 b& F; `: j
21
3 d7 T' y0 t5 S
22
* Z; |0 }! h- x" c$ {3 P9 ^
23
$ ?2 o; j/ w @6 k/ ]/ r
SqueezeNet1_1的网络结构如下:
+ i) _. p" N+ P5 @) ^2 V: I
/ w7 `& K: ~( G$ w1 s
self.features = nn.Sequential(
. A' e1 G4 y7 L2 x. A; h/ C
nn.Conv2d(3, 64, kernel_size=3, stride=2),
- E0 C3 b2 ^% ], o+ i
nn.ReLU(inplace=True),
" b4 l# B- ]1 |" U) S* B$ b. K
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
5 O- }, V8 G* k, H" A/ Z
Fire(64, 16, 64, 64),
% \+ q: {( U! Z/ R* B8 E
Fire(128, 16, 64, 64),
7 e$ Y' g5 x$ _7 Z
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
- k. X! Z) ^) {
Fire(128, 32, 128, 128),
* Q* u i. J! A5 d6 R) D
Fire(256, 32, 128, 128),
& _- r4 T6 A1 l% n) T7 a! p
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
7 R5 ^+ [ }, ^
Fire(256, 48, 192, 192),
- p2 S* W/ S( n7 v3 V4 R
Fire(384, 48, 192, 192),
9 i! B: {$ z" Y# X& e+ r8 R1 ~ x
Fire(384, 64, 256, 256),
6 f* A# H) o% v# G8 D$ M1 J" @7 h
Fire(512, 64, 256, 256),
& b5 t, w" K+ W2 ~; `2 Y. f9 M
)
% D" r: D R/ W% y8 ] p) D
final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
1 X5 x, T& R* U/ s: n
self.classifier = nn.Sequential(
. r! t- T- ?3 i: R8 C F
nn.Dropout(p=0.5),
: F3 W+ |& w* }
final_conv,
9 J3 `$ |' m/ ~( w/ p4 \
nn.ReLU(inplace=True),
! N. ]- X2 e& [
nn.AdaptiveAvgPool2d((1, 1))
! z) y( H3 s3 g _
)
. G; q! D6 _/ z! g
2 N: M4 @& Q& N& z |: M5 d
1
& O0 l' C7 o$ A4 g9 A' ]
2
6 X2 {" O- o5 v" u
3
% c a0 ]; _ |; \
4
" S, Y/ A* H! ~; _
5
/ k* W2 X' }% z% s
6
5 y7 A4 Z' u, s2 @: \: J5 H
7
" x! S) Q6 C# S6 q
8
$ s/ n& H# D# M* y# v- C8 \6 U2 g
9
: p( w$ d( U' y4 L! c" _5 t9 v0 p7 ?
10
4 T' n1 G3 t: J7 I9 b& | P# p
11
4 f) I+ V Q5 R% W# z x$ }
12
9 `" }" I& f5 U% G
13
7 a& |) R! W N( |% W6 B* m
14
* ~: p9 |& m7 l* \$ f0 G* o
15
& s# q7 S3 N7 d% t! i J
16
7 \% x% k m; o# u/ L* J
17
) g2 R4 y( f, D* o6 B
18
8 f. d0 g9 p/ m0 w3 R P9 [
19
- V6 B; M' S1 ~! _! h ^
20
) f# c4 S4 ^7 o) y0 y% y
21
3 y) ?; t! C( }4 D+ L
22
4 R" ^2 B: H- b7 J$ Z( s% u
SqueezeNet各层详细参数量及其输入输出如下表所示。
& J+ N1 E4 j, T* K( G3 e; U
. j8 W! o: H) M" O
% z4 f9 o( M3 Y4 L9 B8 }& Y
4.2.6 其他实现细节
# \- v6 e5 G/ o% n
1×1和3×3卷积的输出宽和高不同,所以3×3卷积设置1个为0的padding
! s% W5 }& d0 a3 a" w( j9 Y* ^% F* |( Z
squeeze和expand层中使用ReLU
8 x8 R4 i! B; N1 g8 |3 ^ ^
在fire9之后的layer中使用ratio为50%的Dropout
7 i7 O9 ^4 |# X3 M8 Q+ j
参考NiN算法想法,SqueezeNet中不含全连接层
/ z) i/ B' {" S1 y
训练时,前期学习率设置为0.04,然后线性减少
8 Q5 E7 _$ {" M( C+ @ E5 D( }
4.2.7 总结
& w9 Q3 f' N% y: r! i
本文最主要就是三点:
" r/ T3 `6 w' Q& u2 {3 h' I% m! i
2 _' J- { w4 H5 H' [- p3 F' F2 T, t
用1×1卷积代替部分3×3卷积,输出两种卷积级联的结果
( d t- h. y9 k8 O. x6 G7 [& x
减少输入到3×3卷积的特征图的通道数,减少参数量
: P* Y8 _! f. p7 n
不过早的使用pool,在网络结构后期再使用pool,这样能提高分类准确率
$ B; M4 k, i) g! q& s X
————————————————
( S3 N4 L9 d- p; K. j
版权声明:本文为CSDN博主「Mr.小梅」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
3 c$ ~) V# p( A" s. F
原文链接:https://blog.csdn.net/qq_39707285/article/details/126498100
: F0 y6 ~9 E" ] |+ v, L, R4 q+ U
: @! K: [1 z+ R- }- m+ S$ U. P
1 d6 i6 {2 E7 h$ x
欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)
Powered by Discuz! X2.5