图像分类：从 AlexNet 到 EfficientNet

import torch
import torchvision.transforms as T
from torchvision.datasets import ImageNet

# 加载 ImageNet 数据集（需自行下载）
transform = T.Compose([
    T.Resize(256),
    T.CenterCrop(224),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406],
                std=[0.229, 0.224, 0.225])
])
train_set = ImageNet(
    root="/data/imagenet",
    split="train",
    transform=transform
)

# 快速查看 ImageNet 类别信息
from torchvision.datasets import ImageNet

# ImageNet 有 1000 个 ILSVRC 分类类别
imagenet = ImageNet(root="/data/imagenet", split="val")
print(f"图片数量: {len(imagenet)}")
print(f"类别数量: {len(imagenet.classes)}")
print(f"前5个类别: {imagenet.classes[:5]}")
# 输出: ['tench', 'goldfish', 'great_white_shark', ...]

import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2),
            nn.Conv2d(64, 192, 5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2),
            nn.Conv2d(192, 384, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

# 为什么 ReLU 比 sigmoid 好？
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-3, 3, 100)
relu = torch.relu(x)
sigmoid = torch.sigmoid(x)

plt.plot(x.numpy(), relu.numpy(), label='ReLU')
plt.plot(x.numpy(), sigmoid.numpy(), label='Sigmoid')
plt.axhline(y=0, color='gray', linestyle='--')
plt.axvline(x=0, color='gray', linestyle='--')
plt.legend()
plt.title('Activation Functions')
plt.grid(True)
plt.show()
# ReLU 在正区间梯度恒为 1，避免梯度消失

import torch.nn as nn

def make_layers(cfg, batch_norm=True):
    """VGG 风格卷积层构建函数"""
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(2, 2)]
        else:
            conv = nn.Conv2d(in_channels, v, 3, padding=1)
            if batch_norm:
                layers += [conv, nn.BatchNorm2d(v), nn.ReLU(True)]
            else:
                layers += [conv, nn.ReLU(True)]
            in_channels = v
    return nn.Sequential(*layers)

# VGG-16 配置: 'M' = MaxPool
cfg_16 = [64, 64, 'M', 128, 128, 'M',
          256, 256, 256, 'M', 512, 512, 512, 'M',
          512, 512, 512, 'M']
features = make_layers(cfg_16)

# 感受野计算：3 层 3x3 vs 1 层 7x7
def calc_receptive_field(layers):
    """计算网络的感受野大小"""
    rf = 1  # 初始感受野
    for kernel, stride in layers:
        rf = rf + (kernel - 1) * stride
    return rf

# 单层 7x7 卷积
rf_7x7 = calc_receptive_field([(7, 1)])
print(f"7x7 感受野: {rf_7x7}")  # 7

# 三层 3x3 卷积 (stride=1)
rf_3x3 = calc_receptive_field([(3, 1), (3, 1), (3, 1)])
print(f"3x3 x3 感受野: {rf_3x3}")  # 7

# 结论: 感受野相同，但 3 层 3x3 参数更少、有更多 ReLU 非线性

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

class InceptionBlock(nn.Module):
    """Inception 模块：多尺度并行卷积"""
    def __init__(self, in_ch, c1, c2r, c2, c3r, c3, c4):
        super().__init__()
        # 1x1 分支
        self.b1 = nn.Conv2d(in_ch, c1, 1)
        # 1x1 降维 + 3x3 卷积分支
        self.b2 = nn.Sequential(
            nn.Conv2d(in_ch, c2r, 1),
            nn.ReLU(),
            nn.Conv2d(c2r, c2, 3, padding=1)
        )
        # 1x1 降维 + 5x5 卷积分支
        self.b3 = nn.Sequential(
            nn.Conv2d(in_ch, c3r, 1),
            nn.ReLU(),
            nn.Conv2d(c3r, c3, 5, padding=2)
        )
        # 3x3 池化 + 1x1 分支
        self.b4 = nn.Sequential(
            nn.MaxPool2d(3, 1, 1),
            nn.Conv2d(in_ch, c4, 1)
        )

    def forward(self, x):
        return torch.cat([
            F.relu(self.b1(x)),
            F.relu(self.b2(x)),
            F.relu(self.b3(x)),
            F.relu(self.b4(x))
        ], dim=1)

# 1x1 卷积的降维效果
def calc_flops_with_bottleneck(in_ch, mid_ch, out_ch, size=28):
    """对比使用和不使用 1x1 瓶颈层的计算量"""
    # 直接使用 3x3 卷积
    direct_flops = in_ch * out_ch * 9 * size * size
    # 使用 1x1 降维 + 3x3 + 1x1 升维
    bottleneck_flops = (
        in_ch * mid_ch * 1 * size * size +      # 1x1 降维
        mid_ch * mid_ch * 9 * size * size +      # 3x3 卷积
        mid_ch * out_ch * 1 * size * size        # 1x1 升维
    )
    ratio = direct_flops / bottleneck_flops
    print(f"直接 3x3: {direct_flops/1e6:.1f}M FLOPs")
    print(f"瓶颈方案: {bottleneck_flops/1e6:.1f}M FLOPs")
    print(f"加速比: {ratio:.1f}x")

calc_flops_with_bottleneck(256, 64, 256)
# 输出: 瓶颈方案比直接方案快约 2.8 倍

import torch.nn as nn

class BasicBlock(nn.Module):
    """ResNet 基础残差块（用于 ResNet-18/34）"""
    expansion = 1

    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3,
                                stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3,
                                padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_ch)
        # 下采样时用 1x1 卷积匹配维度
        self.shortcut = nn.Sequential()
        if stride != 1 or in_ch != out_ch:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 1, stride=stride, bias=False),
                nn.BatchNorm2d(out_ch)
            )

    def forward(self, x):
        out = nn.functional.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)  # 残差连接：核心！
        out = nn.functional.relu(out)
        return out

# 可视化残差连接 vs 普通网络的信息流
import torch

class PlainBlock(nn.Module):
    """普通堆叠：信息逐层衰减"""
    def __init__(self, dim):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(dim, dim), nn.ReLU(),
            nn.Linear(dim, dim), nn.ReLU(),
            nn.Linear(dim, dim), nn.ReLU(),
        )
    def forward(self, x):
        return self.layers(x)

class ResBlock(nn.Module):
    """残差块：信息无损传播"""
    def __init__(self, dim):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(dim, dim), nn.ReLU(),
            nn.Linear(dim, dim), nn.ReLU(),
        )
    def forward(self, x):
        return x + self.layers(x)  # 残差连接

x = torch.randn(1, 64)
plain = PlainBlock(64)
res = ResBlock(64)
# 残差块的梯度可以直接流过 shortcut，
# 避免了深层网络的梯度消失

import torch.nn as nn
from torchvision.models import efficientnet_b0

class MBConv(nn.Module):
    """Mobile Inverted Bottleneck Conv - EfficientNet 核心构建块"""
    def __init__(self, in_ch, out_ch, kernel, stride, expand_ratio):
        super().__init__()
        hidden_ch = in_ch * expand_ratio
        layers = []

        # 1. 扩展层：用 1x1 增加通道数
        if expand_ratio != 1:
            layers.extend([
                nn.Conv2d(in_ch, hidden_ch, 1, bias=False),
                nn.BatchNorm2d(hidden_ch),
                nn.SiLU()  # Swish 激活
            ])

        # 2. 深度可分离卷积
        layers.extend([
            nn.Conv2d(hidden_ch, hidden_ch, kernel,
                       stride=stride, padding=kernel//2,
                       groups=hidden_ch, bias=False),
            nn.BatchNorm2d(hidden_ch),
            nn.SiLU()
        ])

        # 3. 投影层：用 1x1 压缩通道数
        layers.extend([
            nn.Conv2d(hidden_ch, out_ch, 1, bias=False),
            nn.BatchNorm2d(out_ch)
        ])

        self.block = nn.Sequential(*layers)
        self.skip = (stride == 1 and in_ch == out_ch)

    def forward(self, x):
        if self.skip:
            return x + self.block(x)  # 残差连接
        return self.block(x)

# EfficientNet 复合缩放公式
import math

def compound_scaling(phi, alpha=1.2, beta=1.1, gamma=1.15):
    """
    复合缩放: d = alpha^phi, w = beta^phi, r = gamma^phi
    alpha, beta, gamma 由 NAS 搜索得到，满足 alpha*beta^2*gamma^2 ≈ 2
    """
    depth = alpha ** phi
    width = beta ** phi
    resolution = gamma ** phi
    return depth, width, resolution

print("EfficientNet 各版本缩放参数:")
print(f"{'版本':<10} {'phi':<6} {'深度倍率':<10} {'宽度倍率':<10} {'分辨率':<8}")
for b in range(8):
    d, w, r = compound_scaling(b)
    print(f"B{b:<9} {b:<6} {d:<10.2f} {w:<10.2f} {r*224:<8.0f}")
# B0: phi=0 → 基础模型 (224x224)
# B7: phi=7 → 最大模型 (~600x600)

import torch
from torchvision import models, transforms
from PIL import Image

# 1. 加载预训练模型
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
model.eval()  # 切换到评估模式（重要！）

# 2. 图片预处理（必须与训练时一致）
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

# 3. 推理
img = Image.open("cat.jpg")
x = preprocess(img).unsqueeze(0)  # 添加 batch 维度

with torch.no_grad():
    output = model(x)
    probs = torch.softmax(output, dim=1)
    top5 = torch.topk(probs, 5)

for prob, idx in zip(top5.values[0], top5.indices[0]):
    print(f"类别 {idx.item()}: {prob.item()*100:.2f}%")

# 迁移学习：冻结特征提取层，微调分类头
import torch.nn as nn
from torchvision import models

# 加载预训练 ResNet-50
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)

# 冻结所有特征提取层
for param in model.parameters():
    param.requires_grad = False

# 替换分类头（ImageNet 是 1000 类，我们只需要 10 类）
num_features = model.fc.in_features
model.fc = nn.Sequential(
    nn.Dropout(0.3),
    nn.Linear(num_features, 256),
    nn.ReLU(),
    nn.Linear(256, 10)  # 自定义类别数
)

# 只训练分类头的参数
optimizer = torch.optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-3
)
print(f"可训练参数: {sum(p.numel() for p in model.parameters() if p.requires_grad)}")
# 输出: ~150K (只有分类头), 对比全量 25M