三铜钱做二分类的时候，很多人觉得多分类不过是把输出层的1个神经元改成10个而已。说实话，我以前也这么想，直到有一次朋友拿着自己调好的多分类结果来找我：测试集准确率高了，但看真实数据分布，模型几乎把所有样本都判成了最常见的两类，其他类别干脆“摆烂”。多分类和多标签不一样、和二分类更不是同一件事，真正的坑藏在数据处理、损失函数、评估方式和推理细节里。
这篇文章我准备用PyTorch把一个典型的图像多分类项目完整走一遍，以Fashion-MNIST为例，从DataLoader开始，到CNN模型、训练循环、混淆矩阵评估、单张图片推理，每个环节都给出能直接跑的代码，同时把我自己踩过的坑和判断标准一并写出来。适合的人群是那种已经跑过一些二分类或回归demo，但对“完整的多分类项目代码”还没有形成整体认知的初学者；也欢迎想快速搭一个baseline的老手来对照查漏。
1. 多分类不是二分类的简单放大：动手前先把两个关键点想透
1.1 输出层的神经元数量只是表象，本质是分类边界的竞争关系
二分类输出层可以用1个神经元加Sigmoid，输出一个0到1之间的置信度，大于0.5算正类，小于0.5算负类。这背后其实是一个二选一的决策：模型只需要判断“是”还是“不是”，两者天然互补。
多分类面对的是K个互斥类别，样本只能属于其中一类。有人确实会把二分类写法直接改一改，输出层设成10个神经元，然后用argmax取最大分数当作预测。这么说吧，训练也许能跑，但最后输出的那10个数值没有一个统一的语义，可解释性很差。
核心要点是Softmax。多分类经过Softmax之后，10个输出值被归一化成10个概率，加起来等于1。这意味着模型不是单独给每个类打0到1的分数，而是让所有类别互相竞争，一个类别的概率升高，其他类别的概率必然下降。这个“竞争”逻辑才是多分类和二分类本质上的区别。
与之形成对比的是多标签分类。一张图里可能同时有猫又有狗，这时候每个类别之间不互斥，通常会在输出层用Sigmoid而不是Softmax，每个输出独立判断是否超过0.5。刚起步的人很容易把多分类和多标签混在一个项目里讨论，代码结构完全不一样，先分清场景再动手。
1.2 Softmax和CrossEntropy为什么成对出现，PyTorch里又为什么不用手动加
Softmax的公式写成文本大概是p_i = exp(z_i) / Σ_j exp(z_j)，其中z_i是网络最后一层输出的第i类分数，也叫logit。exp会把分数差异放大，大的更大、小的更小，最后变成一个“概率分布”。
交叉熵损失则衡量模型输出的概率分布和真实标签之间的差距。配合one-hot标签理解时，除了真实类别那一项，其余全是0，所以公式可以简化成loss = -log(p_y)，p_y是模型给真实类别的概率。真实类别的概率越接近1，loss越低，这就是训练优化的方向。
PyTorch里的nn.CrossEntropyLoss()有一个新手最容易忽略的细节：它内部已经包含了LogSoftmax + NLLLoss，所以你喂给它的应该是模型最后一层的原始输出logits，千万不要在模型外面再手动加一层nn.Softmax。很多人第一次用的时候会把softmax(logits)送进损失函数，结果loss曲线怪异，甚至半天不收敛。原因不完全是重复Softmax，而是数值稳定性的问题，直接改一下输入通道就对了。
1.3 用Fashion-MNIST当实验对象，为什么比MNIST更有参考价值
本文所有代码使用Fashion-MNIST。它是灰度图像，单通道，每张28×28像素，包含10个服饰类别：T恤/上衣、裤子、套头衫、裙子、外套、凉鞋、衬衫、运动鞋、包、短靴。比起手写数字MNIST，它对CNN来说不至于太简单，但训练成本又很低，没有GPU也能吃得消，是验证多分类代码逻辑最好的中间地带。
还有一个重要原因：Fashion-MNIST的类别本身存在视觉重叠。比如T恤和衬衫、套头衫和外套，只看局部特征确实难分；运动鞋、凉鞋、短靴也都是脚上穿的，轮廓相似。这样训练出来的模型在混淆矩阵里会呈现明显的错分模式，方便把多分类评估讲清楚。如果拿MNIST来演示，数字之间的边界比较清晰，混淆矩阵很难看出门道，反而不利于学习。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 数据装载与预处理：先让每个张量的形状烂熟于心
2.1 一份可以直接用的DataLoader配置
图像多分类项目第一步通常不是写模型，而是把数据装进DataLoader。这一步如果张量形状不对，后面每一步都会疯狂报错。Fashion-MNIST的原始数据是PIL图片，形状是28×28，通过transforms.ToTensor()会转成单通道张量，形状是(1, 28, 28)，像素值从0到255归一化到0到1之间，然后DataLoader加上batch维度，模型实际拿到的形状是(N, 1, 28, 28)。
下面这份代码基本可以直接用：
python复制import torch
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.2860,), (0.3530,)),
])
full_train_set = datasets.FashionMNIST(
root='./data', train=True, download=True, transform=transform
)
test_set = datasets.FashionMNIST(
root='./data', train=False, download=True, transform=transform
)
train_set, val_set = random_split(full_train_set, [50000, 10000])
train_loader = DataLoader(train_set, batch_size=128, shuffle=True, num_workers=2)
val_loader = DataLoader(val_set, batch_size=256, shuffle=False, num_workers=2)
test_loader = DataLoader(test_set, batch_size=256, shuffle=False, num_workers=2)
这段代码里有几个容易被忽略的点。Normalize((0.2860,), (0.3530,))是Fashion-MNIST数据集的常见通道均值和标准差，目的是让输入分布尽量接近均值为0、方差为1的标准正态分布。为什么要这样处理？简单说，输入数值范围太大或分布偏移明显时，梯度更新会不稳定，网络训练速度也会受影响。如果不想查这些统计值，用Normalize((0.5,), (0.5,))也能跑，只是效果可能差一点点。
验证集是从原始训练集里切出10000张。很多初学者直接拿官方测试集当验证集用，调一个超参就在测试集上看一次效果，最后真实评估的指标就会虚高，因为测试集已经“泄露”到调参过程中了。正确做法是把训练数据拆成训练集和验证集，模型选型和超参调整只看验证集，测试集留到最后做一次最终评估。
2.2 采样、shuffle和Windows下的DataLoader细节
train_loader在每一轮epoch里都会重新打乱样本顺序。这对随机梯度下降很关键。如果不打乱，模型在连续几次迭代中看到的都是同一批类别的样本，梯度方向会偏向局部，收敛速度慢且不稳定。验证集和测试集不需要shuffle，因为推理阶段样本顺序不改变结果，shuffle反而会影响复现和混淆矩阵的阅读。
random_split本身就是随机划分，要注意的一点是它依赖全局随机状态。如果你想保证每次运行划分结果一致，必须在执行random_split之前设置好随机种子，否则第二次运行可能被划进训练集和验证集的样本就变了。这个问题等到第7节我会专门讲。
Windows系统下用PyTorch的DataLoader还要注意两个坑：一是脚本如果直接写在模块顶层，num_workers大于0时可能会报BrokenPipeError或DataLoader worker错误，最好把所有训练逻辑放进if __name__ == '__main__':里；二是部分老版本PyTorch在Windows上对多进程支持不稳定，如果实在调不通，先把num_workers设成0，代码能跑通再考虑提速。
很多自然图像数据集每张尺寸不一样，不像Fashion-MNIST天生固定28×28。处理这类数据需要在transform里统一做Resize或RandomResizedCrop，否则一个batch里的图片无法堆叠成同一个四维张量，DataLoader组合batch时直接报错。这里不展开讲，但思路是一样的：模型输入张量的形状必须全程可控。
3. 模型搭建：从“图片像素”到“类别得分”的完整通路
3.1 先跑通一个干净的CNN，不要上来就堆大模型
多分类项目里最常见的误区是一上来就搬ResNet、EfficientNet，然后在一个小规模数据集上疯狂调参。我的建议是先跑通一个结构简单的CNN，把数据、训练、评估全链路打通，形成baseline之后，再根据瓶颈决定要不要上更强的模型。
以一个简单有效的小CNN为例：
python复制import torch.nn as nn
class FashionCNN(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.conv_block1 = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
)
self.conv_block2 = nn.Sequential(
nn.Conv2d(32, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
)
self.classifier = nn.Sequential(
nn.Flatten(),
nn.Linear(64 * 7 * 7, 128),
nn.ReLU(inplace=True),
nn.Dropout(0.3),
nn.Linear(128, num_classes),
)
def forward(self, x):
x = self.conv_block1(x)
x = self.conv_block2(x)
x = self.classifier(x)
return x
这个网络结构大致是“卷积块1 → 卷积块2 → 展平 → 全连接 → 分类输出”。输入28×28单通道经过第一个卷积块，padding=1保证卷积不改变空间尺寸，然后MaxPool把28变成14；第二个卷积块同样保持14不变，MaxPool再把它压到7。最后进入全连接层之前，特征图是64×7×7，nn.Flatten()会按每个样本展平成64×7×7=3136维向量。
3.2 BatchNorm、Dropout和ReLU各管什么事，位置为什么有讲究
很多人抄模型时认识每一个模块，但不知道为什么要放在那个位置。第一个卷积层后面先接BatchNorm再接ReLU，BatchNorm的作用是规范化当前batch的特征分布，让网络在训练过程中对权重初始化不再那么敏感。ReLU是激活函数，给网络引入非线性；没有激活函数的多层卷积堆叠起来本质还是线性变换，表达能力非常有限。
Dropout放在全连接层之间，是一种正则化手段。训练时随机让一部分神经元失活，等于强迫网络不要把全部注意力放在某几个神经元上，降低过拟合风险；推理时Dropout不生效，相当于所有神经元一起参与计算。这里有个非常经典的坑：训练完模型做预测时忘了切model.eval()，如果网络里有Dropout，预测结果每次都不一样。后面推理部分我会再强调一遍。
64 * 7 * 7这个数字容易写错。它依赖前面卷积、池化之后的特征图尺寸。如果你修改了输入分辨率或网络层数，这里的数字就要对应变化，而nn.Linear要求输入维度必须和上一层的输出完全吻合，对不上的时候程序会在构建时或运行时直接报维度错误。一个通用的解决方案是把self.classifier的第一个线性层输入维度写成上一层的实际尺寸，而不是靠猜。
3.3 最后一层输出的logits到底是什么，为什么不能直接当概率用
模型最后一层nn.Linear(128, num_classes)输出的是10个原始分数，也就是常说的logits。别看它数值有大有小，它不是一个概率分布，因为分数没有上下界、而且没有归一化。
预测时可以在这10个logits上直接取argmax(dim=1)，拿到分数最大的索引作为预测类别。但如果你想看置信度，就必须先过nn.Softmax(dim=1)或者torch.softmax。训练阶段不用手动Softmax的原因前面说过，损失函数内部已经处理了；但在推理阶段需要概率的时候，一定不能忘记加。
FashionCNN这个结构算是一种“三明治”思路：前面用卷积层自动提取局部视觉特征，后面用全连接层做分类。它能够演示多分类项目里最重要的几个组成部分：输入通道数、特征图变化、展平操作、分类层输出维度。先把这条通路刻在脑子里，之后换成其他网络模型，只是中间的特征提取器更复杂了，输入输出链路本质不变。
4. 训练循环与损失曲线：代码能跑只是起点，会看信号才是关键
4.1 训练代码骨架：一个epoch里每个步骤的顺序不能乱
训练循环看起来就是几十行代码，但很多初学者在一开始就把顺序弄错。标准的单epoch流程是：取一个batch → 前向传播算logits → 计算loss → 梯度清零 → 反向传播 → 优化器更新。
python复制import torch
import torch.nn as nn
import torch.optim as optim
def train_one_epoch(model, loader, optimizer, criterion, device):
model.train()
total_loss = 0.0
total_correct = 0
total_num = 0
for images, labels in loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item() * images.size(0)
total_correct += (outputs.argmax(dim=1) == labels).sum().item()
total_num += images.size(0)
avg_loss = total_loss / total_num
accuracy = total_correct / total_num
return avg_loss, accuracy
很多新手容易在两个地方翻车。第一个是忘记在每轮迭代前调用optimizer.zero_grad()。PyTorch的梯度是自动累积的，不清零的话，下一轮迭代的梯度会和上一轮叠加，导致loss曲线震荡甚至爆炸。第二个是混淆了optimizer.step()和loss.backward()的顺序，必须先反向传播算出梯度，再让优化器去更新参数，顺序颠倒会得到完全错误的训练结果。
这里我还要特别提醒一点：loss.item()返回的只是loss的标量值，不会保留计算图，用它对整个epoch做平均是正确做法。如果你直接保存loss本身而不是.item()，它会一直持有计算图引用，显存占用会随着迭代次数快速增长。
4.2 验证集的作用和“用哪个模型做测试”的选择
训练循环中需要每隔一个epoch在验证集上做一次评估。评估时要写一个独立的函数，并明确调用model.eval()，告诉PyTorch当前处于推理模式。和train模式的区别在于，BatchNorm会使用当前batch的统计量还是使用训练阶段累计的统计量，Dropout是否生效，这些都会影响结果。
python复制@torch.no_grad()
def evaluate(model, loader, criterion, device):
model.eval()
total_loss = 0.0
total_correct = 0
total_num = 0
for images, labels in loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
total_loss += loss.item() * images.size(0)
total_correct += (outputs.argmax(dim=1) == labels).sum().item()
total_num += images.size(0)
avg_loss = total_loss / total_num
accuracy = total_correct / total_num
return avg_loss, accuracy
@torch.no_grad()是一个很方便的装饰器，意味着这个函数内部不会构建计算图，既能加快运算速度，也能避免显存膨胀。验证和测试阶段没有反向传播需求，所以必须加。
训练主循环里要做的不仅是打印每个epoch的指标，更要学会保存“验证集上表现最好的那个模型”，而不是直接拿最后一个epoch的权重去测试。原因是训练后期模型可能已经开始过拟合，最后一个epoch的验证集指标未必最优。常见的保存策略是：
python复制epochs = 20
best_val_acc = 0.0
model = FashionCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(epochs):
train_loss, train_acc = train_one_epoch(model, train_loader, optimizer, criterion, device)
val_loss, val_acc = evaluate(model, val_loader, criterion, device)
print(f"Epoch {epoch+1:02d} | train_loss {train_loss:.4f} | train_acc {train_acc:.4f} | val_acc {val_acc:.4f}")
if val_acc > best_val_acc:
best_val_acc = val_acc
torch.save(model.state_dict(), "best_model.pth")
4.3 损失曲线出现“跌不下去”或“剧烈震荡”时，先查什么
模型训练过程中，我最常被问到的问题是：为什么我的loss到了某个数值后就不再下降了？这里有一套相对固定的排查顺序。
先看是否是学习率过大或过小。学习率太大会导致loss震荡甚至NaN，学习率太小会导致loss下降速度非常缓慢，看起来像卡住了。一般来说，用Adam优化器时，初始学习率可以设在1e-3附近；SGD的合理学习率会更低一些，比如1e-2需要配合合适的momentum。如果发现loss曲线长期不动，可以把学习率调低一个数量级或调高一个数量级分别测试。
再观察训练集准确率和验证集准确率的差距。如果train_acc很高但val_acc上不去，说明过拟合，可以考虑加Dropout、加数据增强，或者降低模型容量。如果train_acc也不高，那问题更多出在特征学习层面，需要看看模型结构是否太简单、输入归一化是否正确、数据是否存在标签错误。
还有一种比较隐蔽的情况：loss偶尔出现NaN。打开训练日志看是刚开始就NaN还是训练若干轮之后NaN。刚开始就NaN常见原因是输入数据里有NaN、学习率过大或模型初始化异常；训练中间突然NaN则经常是学习率过大导致梯度爆炸。不要把精力花在反复调整网络上，先把这些最基础的训练信号排干净，再动模型结构。
5. 测试集评估：准确率之外的“照妖镜”才是多分类的真正考场
5.1 在测试集上生成预测结果和标签：三步拿到混淆矩阵
训练完并选定最优模型文件后，就该在测试集上做一次诚实的评估了。评估时先加载保存好的权重，注意load_state_dict不会覆盖设备信息，如果训练时用的GPU、现在在CPU上测试，需要使用torch.load('best_model.pth', map_location=device)。
测试集评估代码需要一个关键动作：把模型在某个batch里输出的logits转成类别索引。前面说过操作是用outputs.argmax(dim=1)。这里的dim=1指的是沿着类别维度取最大值索引，不要粗心写成dim=0，dim=0是在batch维度上取最大值，含义完全不同。
python复制model.load_state_dict(torch.load("best_model.pth", map_location=device))
model.to(device)
model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for images, labels in test_loader:
images = images.to(device)
outputs = model(images)
preds = outputs.argmax(dim=1)
all_preds.extend(preds.cpu