从零实现bp神经网络与卷积神经网络分类MNIST数据集实验：原理对比与性能优化

1次阅读

没有评论

共计 2728 个字符，预计需要花费 7 分钟才能阅读完成。

MNIST 手写数字数据集包含 60,000 张训练图像和 10,000 张测试图像，每张为 28×28 像素的灰度图。作为计算机视觉领域的 ”Hello World”，其技术价值体现在：

低维度输入（784 个特征）适合验证模型基础能力
类别数量适中（10 类数字）便于快速验证算法有效性
数据质量统一且标注准确，省去数据清洗成本

全连接网络将 28×28 图像展平为 784 维向量，通过多个隐层进行非线性变换。参数量计算公式为：

$$\text{Params} = (784×H_1) + (H_1×H_2) + … + (H_n×10)$$

其中 $H_i$ 表示第 i 个隐层的神经元数量。三层网络（784-256-128-10）的参数量达到：

$$784×256 + 256×128 + 128×10 = 235,520$$

卷积层通过 3×3 或 5×5 的卷积核提取局部特征，参数量显著降低。典型 CNN 架构参数量计算示例：

卷积层：$C_{out}×(C_{in}×K×K + 1)$
$C_{in}=1$, $C_{out}=32$, $K=5$ → $32×(1×5×5 + 1)=832$
全连接层：$N_{in}×N_{out} + N_{out}$
池化后 7×7×32→10 → $7×7×32×10 + 10=15,690$

总参数量仅 16,522，约为 BP 网络的 7%。

import torch
from torchvision import datasets, transforms

# 标准化到 [-1,1] 区间
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载数据集
train_set = datasets.MNIST('data', download=True, train=True, transform=transform)
test_set = datasets.MNIST('data', train=False, transform=transform)

# 创建数据加载器
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=1000)

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

class BPNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)  # 输入层到隐层 1
        self.fc2 = nn.Linear(256, 128)  # 隐层 1 到隐层 2
        self.fc3 = nn.Linear(128, 10)   # 隐层 2 到输出层

    def forward(self, x):
        x = x.view(-1, 784)  # 展平图像
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return self.fc3(x)

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 5)  # 输入通道, 输出通道, 卷积核
        self.pool = nn.MaxPool2d(2, 2)    # 2×2 最大池化
        self.fc1 = nn.Linear(32 * 12 * 12, 64)
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 32 * 12 * 12)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.cross_entropy(output, target)
        loss.backward()
        optimizer.step()

# 测试函数
def test(model, device, test_loader):
    model.eval()
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            pred = output.argmax(dim=1)
            correct += pred.eq(target).sum().item()
    return correct / len(test_loader.dataset)