1. 卷积神经网络入门指南

第一次接触卷积神经网络（CNN）时，我被它的名字吓到了——又是"卷积"又是"神经网络"，听起来就很高深。但当我真正动手实现一个简单的CNN后，发现它其实就像搭积木一样有趣。CNN是专门为处理图像这类网格数据设计的神经网络，它的核心思想是通过局部感受野和权值共享来高效提取图像特征。

传统神经网络处理图像时有个致命问题：如果把一张1000×1000像素的图片展平输入全连接网络，第一层就需要10^6个权重参数，这计算量简直爆炸。而CNN通过三个关键设计解决了这个问题：局部连接、权值共享和下采样。举个例子，当识别猫的图片时，CNN不需要看完整张图，只需要检测到胡须、耳朵等局部特征就能做出判断。

CNN的基本结构通常包含三种主要层：

• 卷积层：负责提取局部特征
• 池化层：降低特征图维度
• 全连接层：最终分类决策

我建议初学者从经典的LeNet-5网络开始，这是Yann LeCun在1998年提出的用于手写数字识别的CNN架构。虽然只有7层，但它已经包含了现代CNN的所有关键组件。下面是一个简化版的LeNet实现：

import torch
import torch.nn as nn

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)  # 输入1通道，输出6通道，5x5卷积核
        self.pool = nn.MaxPool2d(2, 2)   # 2x2最大池化
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16*4*4, 120)  # 全连接层
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)      # 输出10类
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 16*4*4)  # 展平
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

2. 卷积层深度解析

卷积层是CNN的核心组件，它的工作原理其实很直观。想象你用手电筒在黑暗的房间里慢慢扫过一幅画，每次只能照亮画的一小部分——这就是卷积核的工作方式。在代码中，我们使用一个小的权重矩阵（通常3×3或5×5）在输入图像上滑动，计算局部区域的加权和。

卷积操作有几个关键参数需要理解：

• 卷积核大小（kernel_size）：决定感受野大小
• 步长（stride）：控制滑动步长，影响输出尺寸
• 填充（padding）：处理边界像素
• 输出通道数：决定提取多少种特征

输出尺寸的计算公式为：

输出高度 = (输入高度 + 2×填充 - 卷积核大小)/步长 + 1
输出宽度 = (输入宽度 + 2×填充 - 卷积核大小)/步长 + 1

举个例子，对于224×224的输入图像，使用3×3卷积核，padding=1，stride=1时，输出尺寸保持224×224不变。如果stride=2，输出则变为112×112。

现代CNN通常使用小卷积核（3×3）的堆叠来代替大卷积核，这样既能增加网络深度，又减少了参数量。VGG网络就大量使用了这种设计：

# VGG风格的卷积块示例
conv_block = nn.Sequential(
    nn.Conv2d(64, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2)
)

在实际项目中，我经常使用可视化工具观察卷积层提取的特征。比如用PyTorch的hook机制可以轻松获取中间层输出：

def visualize_features(model, layer, input_image):
    features = None
    
    def hook_fn(module, inp, out):
        nonlocal features
        features = out.detach()
    
    handle = layer.register_forward_hook(hook_fn)
    model(input_image)
    handle.remove()
    return features

3. 激活函数与池化层

卷积操作本质上是线性变换，为了引入非线性，我们需要激活函数。ReLU（Rectified Linear Unit）是目前最常用的激活函数，它简单高效：

ReLU(x) = max(0, x)

ReLU有几个显著优点：

1. 计算简单，加速训练
2. 缓解梯度消失问题
3. 诱导稀疏激活，相当于隐式的特征选择

不过ReLU也有"神经元死亡"问题——一旦输入为负，梯度就永远为0。针对这个问题，后来出现了LeakyReLU、PReLU等变体。但在实践中，普通ReLU在大多数情况下表现已经足够好。

池化层的作用是降低空间维度，提高计算效率并增强平移不变性。最大池化（Max Pooling）是最常用的池化方式，它取局部区域的最大值作为输出。比如2×2最大池化会将4个像素缩减为1个，尺寸减半。

池化层的超参数包括：

• 池化窗口大小（通常2×2）
• 步长（通常等于窗口大小）

# PyTorch中的池化层示例
pool = nn.MaxPool2d(kernel_size=2, stride=2)

有趣的是，现代网络设计中池化层的使用在减少。像ResNet等网络更多地使用带步长的卷积来替代池化，这样网络可以学习最适合的下采样方式。

4. 从零构建完整CNN模型

现在我们把所有组件组合起来，构建一个完整的CNN模型用于CIFAR-10图像分类。CIFAR-10包含10类32×32的彩色图片，是个很好的入门数据集。

我们的网络结构如下：

1. 卷积层1：32个3×3卷积核，ReLU激活
2. 最大池化：2×2
3. 卷积层2：64个3×3卷积核，ReLU激活
4. 最大池化：2×2
5. 全连接层1：128个神经元，ReLU激活
6. 输出层：10个神经元（对应10类）

import torch.optim as optim

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64*8*8, 128)
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64*8*8)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 训练流程
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(trainloader):.3f}')

训练过程中有几个实用技巧：

1. 使用学习率调度器动态调整学习率
2. 添加Batch Normalization加速收敛
3. 使用数据增强提高泛化能力

完整的训练脚本还应该包含验证集评估，防止过拟合。一个好的CNN模型在CIFAR-10上可以达到80%以上的准确率。