基于Python的机器学习系列（31）：PyTorch - 卷积神经网络（CNN）

本文链接：https://blog.youkuaiyun.com/ljd939952281/article/details/141691671

在本篇文章中，我们将探索卷积神经网络（CNN），一种在图像分类任务中表现出色的深度学习模型。CNN利用卷积层、池化层和其他层来提取图像中的特征，从而有效地处理图像数据。

1. 卷积层

卷积层是CNN的核心，它通过卷积操作从输入图像中提取特征。假设我们有一张14x14像素的图像，每个像素的值范围从0到255。我们将这些值归一化到0到1之间。卷积层通过滑动窗口的方式应用卷积核，从而捕捉图像的局部特征。

例如，对于一张手写数字“1”的图像，我们的输入形状可能是 (1, 14, 14)，其中1代表图像的颜色通道（例如灰度图像），14x14代表图像的高度和宽度。如果是RGB图像，输入形状则是 (3, 14, 14)。

2. 池化层

池化层用于减少卷积操作后得到的特征图的尺寸，从而减少计算量和防止过拟合。最常用的池化方法是最大池化（Max Pooling）和平均池化（Average Pooling）。池化操作通过在特征图上应用窗口，取窗口内的最大值或平均值，从而减少特征图的尺寸。

3. 批量归一化层（BatchNorm）

批量归一化层用于加速训练过程并稳定学习过程。它通过将每层的输出标准化，使其具有零均值和单位方差，从而提高模型的收敛速度和稳定性。

4. Dropout层

Dropout层是一种正则化技术，通过在训练过程中随机丢弃一部分神经元，防止过拟合。它使得网络在每次训练迭代中只使用一部分神经元，从而增强了模型的泛化能力。

代码示例

下面是一个完整的CNN实现示例，我们将使用PyTorch构建一个简单的卷积神经网络来处理MNIST数据集。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import make_grid
import matplotlib.pyplot as plt

# 设置设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用的设备: {device}")

# 超参数设置
batch_size = 100
learning_rate = 0.001
num_epochs = 5

# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载数据集
train_dataset = datasets.MNIST(root='data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='data', train=False, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(128 * 3 * 3, 500)
        self.fc2 = nn.Linear(500, 10)
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 128 * 3 * 3)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 初始化模型、损失函数和优化器
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * images.size(0)

    epoch_loss = running_loss / len(train_loader.dataset)
    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}")

# 测试模型
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Accuracy: {100 * correct / total:.2f}%")