Download ShuffleNet-CIFAR10/Classification-normal/scripts/model.py from code-philia/mtpnet_image_models: direct link, hf CLI and curl.
- Browser
- Download file 8.54 kB
-
https://huggingface.co/datasets/code-philia/mtpnet_image_models/resolve/main/ShuffleNet-CIFAR10/Classification-normal/scripts/model.py
- Command line
-
hf download hf://datasets/code-philia/mtpnet_image_models/ShuffleNet-CIFAR10/Classification-normal/scripts/model.py
-
curl -L -o model.py https://huggingface.co/datasets/code-philia/mtpnet_image_models/resolve/main/ShuffleNet-CIFAR10/Classification-normal/scripts/model.py
8.54 kB
| ''' | |
| ShuffleNet in PyTorch. | |
| ShuffleNet是一个专门为移动设备设计的高效卷积神经网络。其主要创新点在于使用了两个新操作: | |
| 1. 逐点组卷积(pointwise group convolution) | |
| 2. 通道重排(channel shuffle) | |
| 这两个操作大大降低了计算复杂度,同时保持了良好的准确率。 | |
| 主要特点: | |
| 1. 使用组卷积减少参数量和计算量 | |
| 2. 使用通道重排操作使不同组之间的信息可以流通 | |
| 3. 使用深度可分离卷积进一步降低计算复杂度 | |
| 4. 设计了多个计算复杂度版本以适应不同的设备 | |
| Reference: | |
| [1] Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, Jian Sun | |
| ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices. CVPR 2018. | |
| ''' | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| class ShuffleBlock(nn.Module): | |
| """通道重排模块 | |
| 通过重新排列通道的顺序来实现不同组之间的信息交流。 | |
| Args: | |
| groups (int): 分组数量 | |
| """ | |
| def __init__(self, groups): | |
| 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 Bottleneck(nn.Module): | |
| """ShuffleNet的基本模块 | |
| 结构: | |
| x -> 1x1 GConv -> BN -> Shuffle -> 3x3 DWConv -> BN -> 1x1 GConv -> BN -> (+) -> ReLU | |
| |---------------------| | |
| Args: | |
| in_channels (int): 输入通道数 | |
| out_channels (int): 输出通道数 | |
| stride (int): 步长,用于下采样 | |
| groups (int): 组卷积的分组数 | |
| """ | |
| def __init__(self, in_channels, out_channels, stride, groups): | |
| super(Bottleneck, self).__init__() | |
| self.stride = stride | |
| # 确定中间通道数和分组数 | |
| mid_channels = out_channels // 4 | |
| g = 1 if in_channels == 24 else groups | |
| # 第一个1x1组卷积 | |
| self.conv1 = nn.Conv2d(in_channels, mid_channels, | |
| kernel_size=1, groups=g, bias=False) | |
| self.bn1 = nn.BatchNorm2d(mid_channels) | |
| self.shuffle1 = ShuffleBlock(groups=g) | |
| # 3x3深度可分离卷积 | |
| self.conv2 = nn.Conv2d(mid_channels, mid_channels, | |
| kernel_size=3, stride=stride, padding=1, | |
| groups=mid_channels, bias=False) | |
| self.bn2 = nn.BatchNorm2d(mid_channels) | |
| # 第二个1x1组卷积 | |
| self.conv3 = nn.Conv2d(mid_channels, out_channels, | |
| kernel_size=1, groups=groups, bias=False) | |
| self.bn3 = nn.BatchNorm2d(out_channels) | |
| # 残差连接 | |
| self.shortcut = nn.Sequential() | |
| if stride == 2: | |
| self.shortcut = nn.Sequential( | |
| nn.AvgPool2d(3, stride=2, padding=1) | |
| ) | |
| def forward(self, x): | |
| # 主分支 | |
| out = F.relu(self.bn1(self.conv1(x))) | |
| out = self.shuffle1(out) | |
| out = F.relu(self.bn2(self.conv2(out))) | |
| out = self.bn3(self.conv3(out)) | |
| # 残差连接 | |
| res = self.shortcut(x) | |
| # 如果是下采样层,拼接残差;否则相加 | |
| out = F.relu(torch.cat([out, res], 1)) if self.stride == 2 else F.relu(out + res) | |
| return out | |
| class ShuffleNet(nn.Module): | |
| """ShuffleNet模型 | |
| 网络结构: | |
| 1. 一个卷积层进行特征提取 | |
| 2. 三个阶段,每个阶段包含多个带重排的残差块 | |
| 3. 平均池化和全连接层进行分类 | |
| Args: | |
| cfg (dict): 配置字典,包含: | |
| - out_channels (list): 每个阶段的输出通道数 | |
| - num_blocks (list): 每个阶段的块数 | |
| - groups (int): 组卷积的分组数 | |
| """ | |
| def __init__(self, cfg): | |
| super(ShuffleNet, self).__init__() | |
| out_channels = cfg['out_channels'] | |
| num_blocks = cfg['num_blocks'] | |
| groups = cfg['groups'] | |
| # 第一层卷积 | |
| self.conv1 = nn.Conv2d(3, 24, kernel_size=1, bias=False) | |
| self.bn1 = nn.BatchNorm2d(24) | |
| self.in_channels = 24 | |
| # 三个阶段 | |
| self.layer1 = self._make_layer(out_channels[0], num_blocks[0], groups) | |
| self.layer2 = self._make_layer(out_channels[1], num_blocks[1], groups) | |
| self.layer3 = self._make_layer(out_channels[2], num_blocks[2], groups) | |
| # 分类层 | |
| self.avg_pool = nn.AdaptiveAvgPool2d(1) | |
| self.classifier = nn.Linear(out_channels[2], 10) | |
| # 初始化权重 | |
| self._initialize_weights() | |
| def _make_layer(self, out_channels, num_blocks, groups): | |
| """构建ShuffleNet的一个阶段 | |
| Args: | |
| out_channels (int): 输出通道数 | |
| num_blocks (int): 块的数量 | |
| groups (int): 分组数 | |
| Returns: | |
| nn.Sequential: 一个阶段的层序列 | |
| """ | |
| layers = [] | |
| for i in range(num_blocks): | |
| stride = 2 if i == 0 else 1 | |
| cat_channels = self.in_channels if i == 0 else 0 | |
| layers.append( | |
| Bottleneck( | |
| self.in_channels, | |
| out_channels - cat_channels, | |
| stride=stride, | |
| groups=groups | |
| ) | |
| ) | |
| 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 = self.avg_pool(out) | |
| out = out.view(out.size(0), -1) | |
| out = self.classifier(out) | |
| return out | |
| def feature(self, x): | |
| """提取特征""" | |
| out = F.relu(self.bn1(self.conv1(x))) | |
| out = self.layer1(out) | |
| out = self.layer2(out) | |
| out = self.layer3(out) | |
| out = self.avg_pool(out) | |
| return out | |
| def prediction(self, x): | |
| """分类""" | |
| x = x.view(x.size(0), -1) | |
| out = self.classifier(x) | |
| 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) | |
| def ShuffleNetG2(num_classes=10): | |
| """返回groups=2的ShuffleNet模型""" | |
| cfg = { | |
| 'out_channels': [200,400,800], | |
| 'num_blocks': [4,8,4], | |
| 'groups': 2 | |
| } | |
| return ShuffleNet(cfg) | |
| def ShuffleNetG3(): | |
| """返回groups=3的ShuffleNet模型""" | |
| cfg = { | |
| 'out_channels': [240,480,960], | |
| 'num_blocks': [4,8,4], | |
| 'groups': 3 | |
| } | |
| return ShuffleNet(cfg) | |
| def test(): | |
| """测试函数""" | |
| # 创建模型 | |
| net = ShuffleNetG2() | |
| 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() |