PyTorch线性层实战：用CIFAR10数据集手把手教你实现图像分类（附完整代码）

PyTorch线性层实战：从CIFAR10图像分类项目深入理解全连接网络

如果你已经对PyTorch的张量操作和基础模块有了初步了解，可能会好奇：那些看起来简单的线性层，在实际项目中究竟扮演着怎样的角色？今天，我们就通过一个完整的图像分类项目，来彻底搞懂线性层的实战应用。CIFAR10数据集是个绝佳的起点——它足够复杂到需要真正的神经网络来处理，又不会庞大到让初学者望而却步。

很多教程会直接带你搭建复杂的卷积网络，但我觉得，从最基础的线性层开始构建一个分类器，反而能让你更清晰地理解数据是如何在神经网络中流动的。我们会从数据加载开始，一步步构建模型、编写训练循环，直到最终评估性能。在这个过程中，你会看到线性层如何将高维的图片数据“压缩”成10个类别的概率，也会遇到并解决几个新手常踩的坑。

1. 项目环境搭建与数据准备

在开始写代码之前，确保你的环境已经准备就绪。我推荐使用Python 3.8或更高版本，以及PyTorch 1.9以上。如果你还没有安装PyTorch，可以去官网根据你的CUDA版本选择对应的安装命令。对于这个项目，我们不需要GPU也能运行，但如果有的话训练速度会快很多。

# 创建虚拟环境（可选但推荐）
python -m venv pytorch_cifar10
source pytorch_cifar10/bin/activate  # Linux/Mac
# 或 pytorch_cifar10\Scripts\activate  # Windows

# 安装PyTorch和torchvision
pip install torch torchvision matplotlib tqdm

CIFAR10数据集包含60000张32x32像素的彩色图片，分为10个类别：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车。每类有6000张图片，其中50000张用于训练，10000张用于测试。torchvision已经内置了这个数据集，下载和使用都非常方便。

注意：第一次运行代码时会自动下载数据集，大约163MB。如果你在国内，下载速度可能较慢，可以考虑提前配置镜像源。

让我们先看看数据长什么样。下面的代码会加载数据集并显示一些样本：

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 定义数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 将PIL图像转换为Tensor，并归一化到[0,1]
    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)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

# 类别名称
classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

# 显示一些图片
def imshow(img):
    img = img / 2 + 0.5  # 反标准化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# 获取一批数据
dataiter = iter(trainloader)
images, labels = next(dataiter)

# 显示图片
imshow(torchvision.utils.make_grid(images))
print(' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))

运行这段代码，你会看到4张随机的小图片和它们的标签。注意观察图片的尺寸——32x32像素，3个颜色通道（RGB）。这意味着每张图片在数学上可以表示为一个形状为[3, 32, 32]的张量，或者展平后是[3072]的一维向量。这个3072（3×32×32）就是即将输入到我们线性层的特征数量。

2. 理解线性层的数学本质与PyTorch实现

线性层，也叫全连接层，是神经网络中最基础的组件之一。它的数学形式非常简单：y = xW^T + b。其中x是输入向量，W是权重矩阵，b是偏置向量。但在深入代码之前，我想先澄清几个容易混淆的概念。

线性层并不只是“一条直线”——虽然它的每个神经元确实执行线性变换，但多个线性层堆叠，配合非线性激活函数，就能拟合极其复杂的函数。这有点像用许多小线段来逼近曲线，线段越多，逼近得越好。

在PyTorch中，线性层由torch.nn.Linear类实现。它的构造函数有三个关键参数：

torch.nn.Linear(in_features, out_features, bias=True)

让我们拆解一下：

• in_features：每个输入样本的特征维度
• out_features：每个输出样本的特征维度
• bias：是否添加可学习的偏置项，默认为True

为了直观理解，我做了个对比表格：

现在来看一个具体的例子。假设我们有一批4张CIFAR10图片，形状是[4, 3, 32, 32]。要输入线性层，我们需要先把它展平：

import torch.nn as nn

# 创建一个线性层：3072个输入特征，10个输出特征
linear_layer = nn.Linear(3072, 10)

# 模拟一批数据：4张图片，每张3×32×32
batch_size = 4
dummy_input = torch.randn(batch_size, 3, 32, 32)  # 随机数据
print(f"原始输入形状: {dummy_input.shape}")  # torch.Size([4, 3, 32, 32])

# 展平操作
flattened = dummy_input.view(batch_size, -1)  # -1表示自动计算该维度大小
print(f"展平后形状: {flattened.shape}")  # torch.Size([4, 3072])

# 通过线性层
output = linear_layer(flattened)
print(f"线性层输出形状: {output.shape}")  # torch.Size([4, 10])

这里有几个关键点需要注意：

1. view() vs flatten()：两者都能展平张量，但view()要求数据在内存中是连续的，而flatten()总是返回一个拷贝。对于从DataLoader加载的数据，通常使用flatten(start_dim=1)，其中start_dim=1表示从第1维开始展平（保留batch维度）。

2. 批量处理：线性层天然支持批量处理。如果你输入形状为[batch_size, in_features]的张量，它会输出[batch_size, out_features]。这是PyTorch设计的一大优点。

3. 参数数量：这个线性层有多少参数？权重矩阵W的形状是[10, 3072]，偏置b的形状是[10]，所以总参数是10×3072 + 10 = 30730。对于32x32的小图片来说，这已经不少了！

提示：你可以用list(linear_layer.parameters())查看层的所有参数，或者用sum(p.numel() for p in linear_layer.parameters())计算总参数数量。

3. 构建基于线性层的图像分类模型

单靠一个线性层就想在CIFAR10上取得好成绩？几乎不可能。因为线性变换只能实现数据的线性分离，而图像分类问题通常是非线性的。我们需要堆叠多个线性层，并在它们之间加入非线性激活函数。

为什么需要非线性激活函数？ 如果没有非线性，多个线性层的组合仍然等价于一个线性层。数学上可以证明：f(x) = W2(W1x + b1) + b2 = (W2W1)x + (W2b1 + b2)，这还是一个线性变换。加入ReLU、Sigmoid或Tanh等非线性函数后，网络才能学习复杂的模式。

让我们设计一个简单的多层感知机（MLP）来处理CIFAR10：

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

class SimpleMLP(nn.Module):
    def __init__(self):
        super(SimpleMLP, self).__init__()
        # 第一层：3072 -> 512
        self.fc1 = nn.Linear(32 * 32 * 3, 512)
        # 第二层：512 -> 256  
        self.fc2 = nn.Linear(512, 256)
        # 第三层：256 -> 128
        self.fc3 = nn.Linear(256, 128)
        # 输出层：128 -> 10
        self.fc4 = nn.Linear(128, 10)
        
        # Dropout层防止过拟合
        self.dropout = nn.Dropout(0.3)
        
    def forward(self, x):
        # 展平输入：从[batch, 3, 32, 32]到[batch, 3072]
        x = x.view(-1, 32 * 32 * 3)
        
        # 第一层 + ReLU激活 + Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)