'''
ShuffleNetV2 in PyTorch.
ShuffleNetV2是ShuffleNet的改进版本,通过实验总结出了四个高效网络设计的实用准则:
1. 输入输出通道数相等时计算量最小
2. 过度使用组卷积会增加MAC(内存访问代价)
3. 网络碎片化会降低并行度
4. Element-wise操作不可忽视
主要改进:
1. 通道分离(Channel Split)替代组卷积
2. 重新设计了基本单元,使输入输出通道数相等
3. 每个阶段使用不同的通道数配置
4. 简化了下采样模块的设计
Reference:
[1] Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, Jian Sun
ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design. ECCV 2018.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class ShuffleBlock(nn.Module):
"""通道重排模块
通过重新排列通道的顺序来实现不同特征的信息交流。
Args:
groups (int): 分组数量,默认为2
"""
def __init__(self, groups=2):
super(ShuffleBlock, self).__init__()
self.groups = groups
def forward(self, x):
"""通道重排的前向传播
步骤:
1. [N,C,H,W] -> [N,g,C/g,H,W] # 重塑为g组
2. [N,g,C/g,H,W] -> [N,C/g,g,H,W] # 转置g维度
3. [N,C/g,g,H,W] -> [N,C,H,W] # 重塑回原始形状
Args:
x: 输入张量,[N,C,H,W]
Returns:
out: 通道重排后的张量,[N,C,H,W]
"""
N, C, H, W = x.size()
g = self.groups
return x.view(N, g, C//g, H, W).permute(0, 2, 1, 3, 4).reshape(N, C, H, W)
class SplitBlock(nn.Module):
"""通道分离模块
将输入特征图按比例分成两部分。
Args:
ratio (float): 分离比例,默认为0.5
"""
def __init__(self, ratio):
super(SplitBlock, self).__init__()
self.ratio = ratio
def forward(self, x):
"""通道分离的前向传播
Args:
x: 输入张量,[N,C,H,W]
Returns:
tuple: 分离后的两个张量,[N,C1,H,W]和[N,C2,H,W]
"""
c = int(x.size(1) * self.ratio)
return x[:, :c, :, :], x[:, c:, :, :]
class BasicBlock(nn.Module):
"""ShuffleNetV2的基本模块
结构:
x -------|-----------------|
| | |
| 1x1 Conv |
| 3x3 DWConv |
| 1x1 Conv |
| |
|------------------Concat
|
Channel Shuffle
Args:
in_channels (int): 输入通道数
split_ratio (float): 通道分离比例,默认为0.5
"""
def __init__(self, in_channels, split_ratio=0.5):
super(BasicBlock, self).__init__()
self.split = SplitBlock(split_ratio)
in_channels = int(in_channels * split_ratio)
# 主分支
self.conv1 = nn.Conv2d(in_channels, in_channels,
kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(in_channels)
self.conv2 = nn.Conv2d(in_channels, in_channels,
kernel_size=3, stride=1, padding=1,
groups=in_channels, bias=False)
self.bn2 = nn.BatchNorm2d(in_channels)
self.conv3 = nn.Conv2d(in_channels, in_channels,
kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm2d(in_channels)
self.shuffle = ShuffleBlock()
def forward(self, x):
# 通道分离
x1, x2 = self.split(x)
# 主分支
out = F.relu(self.bn1(self.conv1(x2)))
out = self.bn2(self.conv2(out))
out = F.relu(self.bn3(self.conv3(out)))
# 拼接并重排
out = torch.cat([x1, out], 1)
out = self.shuffle(out)
return out
class DownBlock(nn.Module):
"""下采样模块
结构:
3x3 DWConv(s=2) 1x1 Conv
x -----> 1x1 Conv 3x3 DWConv(s=2)
1x1 Conv
|
Concat
|
Channel Shuffle
Args:
in_channels (int): 输入通道数
out_channels (int): 输出通道数
"""
def __init__(self, in_channels, out_channels):
super(DownBlock, self).__init__()
mid_channels = out_channels // 2
# 左分支
self.branch1 = nn.Sequential(
# 3x3深度可分离卷积,步长为2
nn.Conv2d(in_channels, in_channels,
kernel_size=3, stride=2, padding=1,
groups=in_channels, bias=False),
nn.BatchNorm2d(in_channels),
# 1x1卷积
nn.Conv2d(in_channels, mid_channels,
kernel_size=1, bias=False),
nn.BatchNorm2d(mid_channels)
)
# 右分支
self.branch2 = nn.Sequential(
# 1x1卷积
nn.Conv2d(in_channels, mid_channels,
kernel_size=1, bias=False),
nn.BatchNorm2d(mid_channels),
# 3x3深度可分离卷积,步长为2
nn.Conv2d(mid_channels, mid_channels,
kernel_size=3, stride=2, padding=1,
groups=mid_channels, bias=False),
nn.BatchNorm2d(mid_channels),
# 1x1卷积
nn.Conv2d(mid_channels, mid_channels,
kernel_size=1, bias=False),
nn.BatchNorm2d(mid_channels)
)
self.shuffle = ShuffleBlock()
def forward(self, x):
# 左分支
out1 = self.branch1(x)
# 右分支
out2 = self.branch2(x)
# 拼接并重排
out = torch.cat([out1, out2], 1)
out = self.shuffle(out)
return out
class ShuffleNetV2(nn.Module):
"""ShuffleNetV2模型
网络结构:
1. 一个卷积层进行特征提取
2. 三个阶段,每个阶段包含多个基本块和一个下采样块
3. 最后一个卷积层
4. 平均池化和全连接层进行分类
Args:
net_size (float): 网络大小系数,可选0.5/1.0/1.5/2.0
"""
def __init__(self, net_size):
super(ShuffleNetV2, self).__init__()
out_channels = configs[net_size]['out_channels']
num_blocks = configs[net_size]['num_blocks']
# 第一层卷积
self.conv1 = nn.Conv2d(3, 24, kernel_size=3,
stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(24)
self.in_channels = 24
# 三个阶段
self.layer1 = self._make_layer(out_channels[0], num_blocks[0])
self.layer2 = self._make_layer(out_channels[1], num_blocks[1])
self.layer3 = self._make_layer(out_channels[2], num_blocks[2])
# 最后的1x1卷积
self.conv2 = nn.Conv2d(out_channels[2], out_channels[3],
kernel_size=1, stride=1, padding=0, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels[3])
# 分类层
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.classifier = nn.Linear(out_channels[3], 10)
# 初始化权重
self._initialize_weights()
def _make_layer(self, out_channels, num_blocks):
"""构建一个阶段
Args:
out_channels (int): 输出通道数
num_blocks (int): 基本块的数量
Returns:
nn.Sequential: 一个阶段的层序列
"""
layers = [DownBlock(self.in_channels, out_channels)]
for i in range(num_blocks):
layers.append(BasicBlock(out_channels))
self.in_channels = out_channels
return nn.Sequential(*layers)
def forward(self, x):
"""前向传播
Args:
x: 输入张量,[N,3,32,32]
Returns:
out: 输出张量,[N,num_classes]
"""
# 特征提取
out = F.relu(self.bn1(self.conv1(x)))
# 三个阶段
out = self.layer1(out)
out = self.layer2(out)
out = self.layer3(out)
# 最后的特征提取
out = F.relu(self.bn2(self.conv2(out)))
# 分类
out = self.avg_pool(out)
out = out.view(out.size(0), -1)
out = self.classifier(out)
return out
def _initialize_weights(self):
"""初始化模型权重
采用kaiming初始化方法:
- 卷积层权重采用kaiming_normal_初始化
- BN层参数采用常数初始化
- 线性层采用正态分布初始化
"""
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
# 不同大小的网络配置
configs = {
0.5: {
'out_channels': (48, 96, 192, 1024),
'num_blocks': (3, 7, 3)
},
1.0: {
'out_channels': (116, 232, 464, 1024),
'num_blocks': (3, 7, 3)
},
1.5: {
'out_channels': (176, 352, 704, 1024),
'num_blocks': (3, 7, 3)
},
2.0: {
'out_channels': (224, 488, 976, 2048),
'num_blocks': (3, 7, 3)
}
}
def test():
"""测试函数"""
# 创建模型
net = ShuffleNetV2(net_size=0.5)
print('Model Structure:')
print(net)
# 测试前向传播
x = torch.randn(1,3,32,32)
y = net(x)
print('\nInput Shape:', x.shape)
print('Output Shape:', y.shape)
# 打印模型信息
from torchinfo import summary
device = 'cuda' if torch.cuda.is_available() else 'cpu'
net = net.to(device)
summary(net, (1,3,32,32))
if __name__ == '__main__':
test()