神经网络—EfficientNet（pytorch）

EfficientNet-B0 的实现

辽逸

3550人浏览 · 2024-08-30 13:18:31

辽逸 · 2024-08-30 13:18:31 发布

EfficientNet 是一种高效的卷积神经网络（CNN），由 Google 的研究团队在 2019 年提出。EfficientNet 的设计目标是提高网络的性能，同时减少计算资源的消耗。该网络在 ImageNet 数据集上的表现极为优异，能够在准确率和计算效率之间实现良好的平衡。

1. 核心创新

复合缩放（Compound Scaling）: EfficientNet 引入了一种新的缩放策略，称为复合缩放。这种方法同时对网络的宽度、深度和分辨率进行均衡缩放。与传统方法只对某一方面进行缩放不同，复合缩放可以更有效地利用计算资源，提高网络的整体性能。
EfficientNet-B0 基础架构: EfficientNet-B0 是系列中的基础模型，设计上采用了优化的卷积神经网络架构，利用了深度可分离卷积（Depthwise Separable Convolutions）和 SE 模块（Squeeze-and-Excitation）等技术。SE 模块通过自适应地调整通道的权重，提高了特征提取的效率。
深度可分离卷积: 类似于 Inception 网络中的深度可分离卷积，EfficientNet 也采用了这种方法，以减少计算量和参数量，从而提高计算效率。
Squeeze-and-Excitation 模块: SE 模块通过学习通道间的关系，自适应地调整各通道的权重，增强了网络对重要特征的关注能力，从而提高了网络的性能。

2. EfficientNet-B0 架构

EfficientNet-B0 是 EfficientNet 系列中的基础模型。其网络结构主要由以下几部分组成：

输入层: 输入图像的尺寸为 224x224 像素。
初始卷积层: 使用一个 3x3 的卷积核，步幅为 2，将输入图像的尺寸缩小到 112x112 像素，并应用 Batch Normalization 和 Swish 激活函数。
深度可分离卷积块: EfficientNet-B0 使用了多个深度可分离卷积块（Depthwise Separable Convolutions），每个块包含一个深度卷积和一个逐点卷积。深度卷积负责空间特征的提取，逐点卷积负责通道特征的融合。这种设计减少了计算复杂度和参数数量。
Squeeze-and-Excitation 模块: 在每个卷积块后使用 SE 模块，以增强通道间的特征表达能力。SE 模块包括一个全局平均池化层、一个全连接层和一个 Sigmoid 激活函数，用于自适应调整通道的权重。
网络块: EfficientNet-B0 包含多个 MBConv（Mobile Inverted Bottleneck Convolution）块。MBConv 是一种高效的卷积块，结合了深度可分离卷积和 SE 模块。每个 MBConv 块由三个卷积层组成：一个 1x1 卷积进行扩展、一个 3x3 深度卷积进行空间特征提取、一个 1x1 卷积进行降维。
全局平均池化层: 在最后的卷积层后，使用全局平均池化层将特征图的空间维度缩小到一个标量，以得到图像的全局特征。
全连接层: 全局平均池化后的特征被输入到一个全连接层，用于进行分类任务。这个全连接层输出的维度对应于类别数量。

3. 复合缩放策略

EfficientNet 的复合缩放策略通过以下三个维度对网络进行缩放：

网络宽度: 增加卷积层的通道数。
网络深度: 增加网络层数，即增加 MBConv 块的数量。
输入分辨率: 增加输入图像的尺寸，进而提高特征图的分辨率。

这些缩放方式综合考虑了计算资源和模型性能，避免了过度的计算开销。

4. 从 EfficientNet-B0 到 EfficientNet-B7

从 EfficientNet-B0 到 EfficientNet-B7，模型在基础架构的设计上进行扩展：

EfficientNet-B1: 比 B0 更宽，更多的 MBConv 块。
EfficientNet-B2 到 B7: 按照复合缩放策略，逐步增加网络的宽度、深度和输入分辨率，进一步提高模型性能。每个版本都在前一个版本的基础上进行优化，确保性能与效率的最佳平衡。

总的来说，EfficientNet 的设计充分利用了复合缩放策略，结合深度可分离卷积和 SE 模块，创建了一个高效且性能卓越的神经网络架构。

EfficientNet-B0 实现：

import torch
import torch.nn as nn
import torch.nn.functional as F

# Squeeze-and-Excitation模块
class SqueezeAndExcitation(nn.Module):
    def __init__(self, in_channels, reduction=4):
        super(SqueezeAndExcitation, self).__init__()
        self.fc1 = nn.Linear(in_channels, in_channels // reduction, bias=False)
        self.fc2 = nn.Linear(in_channels // reduction, in_channels, bias=False)
        self.relu = nn.ReLU(inplace=True)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        b, c, _, _ = x.size()
        y = F.adaptive_avg_pool2d(x, (1, 1)).view(b, c)
        y = self.fc1(y)
        y = self.relu(y)
        y = self.fc2(y)
        y = self.sigmoid(y).view(b, c, 1, 1)
        return x * y

# 深度可分离卷积块
class DepthwiseSeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, expansion=6):
        super(DepthwiseSeparableConv, self).__init__()
        self.expand = nn.Sequential(
            nn.Conv2d(in_channels, in_channels * expansion, kernel_size=1, bias=False),
            nn.BatchNorm2d(in_channels * expansion),
            nn.ReLU(inplace=True)
        )
        self.depthwise = nn.Sequential(
            nn.Conv2d(in_channels * expansion, in_channels * expansion, kernel_size=3, stride=stride, padding=1, groups=in_channels * expansion, bias=False),
            nn.BatchNorm2d(in_channels * expansion),
            nn.ReLU(inplace=True)
        )
        self.se = SqueezeAndExcitation(in_channels * expansion)
        self.pointwise = nn.Sequential(
            nn.Conv2d(in_channels * expansion, out_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        self.skip = stride == 1 and in_channels == out_channels

    def forward(self, x):
        if self.skip:
            return self.pointwise(self.se(self.depthwise(self.expand(x)))) + x
        else:
            return self.pointwise(self.se(self.depthwise(self.expand(x))))

# EfficientNet-B0
class EfficientNetB0(nn.Module):
    def __init__(self, num_classes=1000):
        super(EfficientNetB0, self).__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True)
        )
        self.blocks = nn.Sequential(
            DepthwiseSeparableConv(32, 16, stride=1, expansion=1),
            DepthwiseSeparableConv(16, 24, stride=2, expansion=6),
            DepthwiseSeparableConv(24, 40, stride=2, expansion=6),
            DepthwiseSeparableConv(40, 80, stride=2, expansion=6),
            DepthwiseSeparableConv(80, 112, stride=1, expansion=6),
            DepthwiseSeparableConv(112, 192, stride=2, expansion=6),
            DepthwiseSeparableConv(192, 320, stride=1, expansion=6)
        )
        self.head = nn.Sequential(
            nn.Conv2d(320, 1280, kernel_size=1, bias=False),
            nn.BatchNorm2d(1280),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d(1)
        )
        self.fc = nn.Linear(1280, num_classes)

    def forward(self, x):
        x = self.stem(x)
        x = self.blocks(x)
        x = self.head(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# Example usage
if __name__ == "__main__":
    model = EfficientNetB0(num_classes=1000)
    x = torch.randn(1, 3, 224, 224)
    output = model(x)
    print(output.size())