文章五《卷积神经网络（CNN）与图像处理》-CSDN博客

本文链接：https://blog.csdn.net/c123728529/article/details/147671693

文章5：卷积神经网络（CNN）与图像处理——让AI学会"看图说话"

引言：你的AI宠物如何认出猫狗？

想象你的手机突然有了"眼睛"，不仅能识别照片里的猫狗，还能告诉你它们的品种！这就是卷积神经网络（CNN）的魔法。今天，我们将用PyTorch打造一个"视觉AI"，并带它去看懂世界。

一、CNN的视觉超能力：从像素到特征的奇幻之旅

1.1 卷积层：图像的"微距镜头"

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
（想象这是卷积核在图像上滑动的动图）

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)  # 输入3通道，输出16个特征图
        self.pool = nn.MaxPool2d(2, 2)  # 池化层压缩空间维度
        
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 卷积→激活→池化
        return x

关键参数解释：

kernel_size=3：3x3的"视觉小滑块"
padding=1：防止边缘信息丢失的"补丁"
stride=1：每次移动1像素的"扫描步长"

1.2 池化层：图像的"压缩大师"

# 最大池化：保留最关键特征
x = torch.tensor([[[[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]]]])
print(F.max_pool2d(x, 2))  # 输出[[[[5, 9]]]]

1.3 全连接层：特征的"决策法庭"

self.fc = nn.Sequential(
    nn.Linear(16 * 8 * 8, 64),  # 将空间特征展平
    nn.ReLU(),
    nn.Linear(64, 10)  # 10类分类
)

二、实战CIFAR-10：让AI学会"儿童画"识别

2.1 数据集探秘：10个"婴儿级"分类

import torchvision
transform = torchvision.transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 标准化到[-1,1]
])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, 
                                       download=True, transform=transform)

2.2 搭建CNN模型：三层结构设计

class CIFARNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.fc_layers = nn.Sequential(
            nn.Linear(64*8*8, 512),
            nn.ReLU(),
            nn.Dropout(0.5),  # 防止过拟合
            nn.Linear(512, 10)
        )

三、数据增强与过拟合：训练AI的"防作弊"策略

3.1 数据增强：让AI见多识广

augmentations = transforms.Compose([
    transforms.RandomHorizontalFlip(),  # 随机翻转
    transforms.RandomRotation(15),      # 随机旋转
    transforms.ColorJitter(brightness=0.2),  # 调整亮度
    transforms.RandomCrop(32, padding=4)  # 随机裁剪
])

3.2 过拟合解决：给模型"减压"

# 在训练时：
model.train()
for data, target in trainloader:
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()

# 在验证时：
model.eval()
with torch.no_grad():
    # 计算验证集准确率

四、可视化卷积层：看AI如何"看"世界

4.1 特征图可视化：AI的"视觉日记"

# 提取中间层输出
def visualize_filters(layer_num, input_image):
    with torch.no_grad():
        outputs = []
        hook = model.conv_layers[layer_num].register_forward_hook(lambda m, i, o: outputs.append(o))
        _ = model(input_image)
        hook.remove()
        return outputs[0]

# 绘制特征图
features = visualize_filters(0, test_image)
plt.figure(figsize=(10,5))
for i in range(8):
    plt.subplot(2,4,i+1)
    plt.imshow(features[0][i].detach().numpy(), cmap='viridis')
    plt.axis('off')
plt.suptitle("第一层卷积的'视觉偏好'")

五、迁移学习实战：用ResNet玩转猫狗分类

5.1 预训练模型：站在巨人肩膀上

import torchvision.models as models
model = models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False  # 冻结底层参数

# 替换最后的全连接层
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)  # 2分类（猫/狗）

5.2 猫狗分类：从0到1的完整流程

# 数据准备（假设已下载猫狗数据集）
train_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.RandomCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor()
])

trainset = datasets.ImageFolder(root='dogs_cats/train', transform=train_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

# 训练循环
for epoch in range(10):
    train_loss = 0.0
    for images, labels in trainloader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

六、进阶技巧：让模型更聪明的"黑科技"

6.1 混合精度训练：给GPU"减负"

from torch.cuda import amp

scaler = amp.GradScaler()
for images, labels in trainloader:
    with amp.autocast():
        outputs = model(images)
        loss = criterion(outputs, labels)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

6.2 模型蒸馏：让AI互相学习

# 使用教师模型指导学生模型
teacher_logits = teacher_model(images)
student_loss = criterion(student_output, labels) + 0.1 * F.kl_div(
    F.log_softmax(student_output / T, dim=1),
    F.softmax(teacher_logits / T, dim=1),
    reduction='batchmean'
) * (T**2)