多分类模型实战全解：softmax交叉熵与CNN实现

上一节我们用二分类的思维把任务拆成了“是/否”两个输出，很多读者朋友反馈说：换成10类就懵了，有的直接把最后的sigmoid换成了10个输出，loss反而乱跳，准确率卡在30%上下不去。这其实是把多分类理解成了“多个二分类”导致的，概念上就差了一层。这一节“耿直哥深度学习4-8”我就带着大家把多分类问题的完整代码实现从头到尾捋一遍，数据集用Fashion-MNIST（10类衣物），模型用两层卷积神经网络，训练完输出准确率、分类报告和混淆矩阵，整个过程结束你手上会有一套能直接迁移到自己数据集上的多分类代码模板。

这套代码的核心点有三个：输出层用softmax做概率分布、损失函数用交叉熵、评估阶段用混淆矩阵看细节。我会把每一步为什么这么写的理由也一起讲清楚，不只是给你一段能跑通的代码。适合已经跑通MNIST手写数字、但对多分类的设计逻辑还停留在“改个数就能跑”阶段的朋友，也适合那些被网上零散代码坑过、想系统整理一遍训练评估流程的同学。

1. 多分类任务的整体设计与思路拆解

1.1 多分类和二分类的本质差异

二分类模型输出的是一个值，经过sigmoid映射到0到1之间，大于0.5判为正类，小于0.5判为负类，本质上是“一个事件发生/不发散”的概率。

多分类面对的是“互斥的多个类别”，比如Fashion-MNIST中一张图要么是T恤、要么是裤子、要么是连衣裙，不可能同时是两样。这种情况直接用多个sigmoid输出会产生一个问题：每个输出都是独立的，模型可能对三个类别都输出0.7，加起来超过1，这不满足概率分布的基本性质，也无法直接解释成“这个样本属于各类别的概率”。

解决方式是输出层接softmax。softmax做的事情很简单：把所有类别的原始得分（logits）做指数归一化，得到一组非负、并且总和正好等于1的输出。你可以把它想成一个抽奖箱里的10个格子，无论如何最终必须有一个球落在某个格子里，所有格子的概率加起来永远是100%。这样的输出天然适合做多分类的判别依据。

1.2 损失函数为什么选交叉熵而不是均方误差

二分类常用的损失函数是BCELoss（二元交叉熵），多分类对应的就是CrossEntropyLoss。为什么要坚持用交叉熵，而不是把输出换成softmax之后继续用均方误差（MSE）？核心在于梯度传播的特性。

softmax函数在输入特别大或特别小时，输出会趋近于0或1，此时如果配合MSE计算损失，梯度会被压缩得非常小，导致模型学习速度急剧变慢，甚至看起来像卡住了。而交叉熵损失在预测概率与真实标签差距大的时候能给出较大的梯度，推动模型快速修正，这正是分类任务所需要的。

还有一个实操上的细节：PyTorch的CrossEntropyLoss内部已经帮我们做了softmax操作。也就是说，你在模型最后的全连接层输出10个原始得分，直接把这个得分交给CrossEntropyLoss，它会自动计算softmax再算损失。所以模型定义里最后一个Linear层的输出不需要手动再套一层softmax，只有在推理或者画概率分布时才需要单独调用。

1.3 数据集与任务选型

这一节选Fashion-MNIST而不是经典的MNIST手写数字，原因是MNIST太简单了，随便一个线性模型都能到90%以上的准确率，根本体现不出多分类调参的乐趣和坑。Fashion-MNIST同样是28x28的灰度图，但图像内容是T恤、裤子、套头衫、连衣裙、外套、凉鞋、衬衫、运动鞋、包、短靴这10类，类别之间的区分难度明显更大，尤其是T恤、套头衫和衬衫这三类，人眼都容易看错，模型产生混淆是正常的。

数据规模方面，Fashion-MNIST有60000张训练图、10000张测试图，图像尺寸小，训练速度快，在一张普通消费级显卡上十几分钟就能跑完15轮，非常适合拿来走通整个多分类流程。换句话说，这个任务设计的目的是让你把注意力放在“多分类代码怎么写、评估怎么做、问题怎么排查”上，而不是等训练等到天荒地老。

1.4 模型结构与整体流程规划

多分类任务在流程上比二分类多了两个环节：一是评估阶段要逐类看precision、recall和f1，二是要画混淆矩阵观察哪些类容易互相混。整体流程是数据加载、模型定义、训练、验证、测试、逐类评估、混淆矩阵分析，最后针对混淆严重的类别做进一步优化。

模型部分我用的是一个轻量CNN：两个卷积块加两个全连接层。每个卷积块包含卷积、批归一化、ReLU激活和最大池化，最后的全连接输出10维。这个结构在Fashion-MNIST上足够用了，大约80万参数，训练快，同时不会因为模型过小导致欠拟合。

2. 环境准备与数据加载细节

2.1 目标环境与依赖库

动手之前先把环境确认好。我这里用的是Python 3.9和PyTorch 2.0，实际上PyTorch 1.10以上版本都能跑通全部代码。除了PyTorch之外还需要torchvision、matplotlib和scikit-learn。scikit-learn主要是用来算classification_report和confusion_matrix的，如果你不想引入这个依赖，也可以自己手写这些评估函数，但不建议，既然有现成且稳定的工具，直接用就好。

如果你还没装好PyTorch环境，我的建议是先创建一个干净的虚拟环境再装，别把系统Python搞乱了。Windows、Linux、macOS都能跑，CPU也能训完这个任务，只是慢一些。实测一个epoch在CPU上大约30到40秒，15轮大约8分钟左右，完全可以接受。

2.2 数据加载与预处理完整代码

python复制import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
from sklearn.metrics import classification_report, confusion_matrix

# 数据处理：转Tensor + 归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.2860,), (0.3530,))
])

# 训练集和测试集
train_dataset = datasets.FashionMNIST(
    root='./data', train=True, download=True, transform=transform
)
test_dataset = datasets.FashionMNIST(
    root='./data', train=False, download=True, transform=transform
)

# DataLoader
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=2)

这里有两个细节很多新手会忽略。第一，Normalize的均值0.2860和标准差0.3530是Fashion-MNIST整个数据集在灰度值上的统计结果，不是随便写上去的。你当然可以直接用(0.5, 0.5)做归一化，也能训练，但从经验来看用官方统计的均值和标准差，模型收敛会更平稳。第二，训练集DataLoader的shuffle一定设为True，测试集设为False。shuffle的目的是让每个batch里的样本类别分布尽量随机，避免模型学到样本顺序里的伪规律，比如前100张都是T恤，后面100张都是裤子，那模型很可能学到“批量切换”的作弊模式，训练准确率虚高，测试直接拉胯。

2.3 训练前先做一次数据可视化

写模型之前，我的习惯是先画一批数据出来看一下，确认数据集没加载错、标签对得上图像内容。这一步只需要几行代码，但能避免后面训练完了发现标签顺序弄反了的尴尬。

python复制class_names = ['T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

# 取一个batch看看
data_iter = iter(train_loader)
images, labels = next(data_iter)

fig, axes = plt.subplots(2, 5, figsize=(10, 4))
for i in range(10):
    ax = axes[i // 5][i % 5]
    ax.imshow(images[i].squeeze(), cmap='gray')
    ax.set_title(class_names[labels[i]])
    ax.axis('off')
plt.show()

如果画出来的图像和标签明显对不上，那就是数据预处理的地方出了问题，提前发现比浪费一轮训练时间划算得多。另外注意，DataLoader输出的图像Tensor形状是[batch_size, 1, 28, 28]，画图的时候要squeeze掉那个单通道维度，否则imshow会报错或显示异常。

3. 模型定义与训练核心代码实现

3.1 定义CNN多分类模型

多分类模型和二分类模型的结构在主体上可以完全一样，唯一差别就在最后的全连接层输出维度。二分类输出1维，多分类输出类别数10维。这里我定义了一个两层卷积的CNN。

python复制class FashionCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
            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, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

这里的64 * 7 * 7是怎么来的？输入图片是28x28，经过第一个MaxPool2d(2)变成14x14，经过第二个MaxPool2d(2)变成7x7，卷积的padding都设为1，所以图像尺寸在卷积层不会变，只有池化会减半。最后一层卷积输出的通道数是64，所以进入全连接层前要展平成64x7x7。如果你自己改了输入尺寸，这个数一定要重新算，这是新手最容易报错的地方之一。

Dropout(0.5)这一层对多分类任务非常重要。10个类别之间有不少易混淆样本，模型很容易在训练集上过拟合，把训练准确率冲到99%，验证集卡在89%。Dropout在训练时随机丢弃一半神经元，强制模型学习更鲁棒的特征，能有效缓解这个问题。注意Dropout在推理阶段会自动关闭，PyTorch已经处理好了，不需要你自己额外写开关逻辑。

3.2 训练循环完整代码

训练过程分为两个阶段：训练阶段更新参数，验证阶段不更新参数但计算损失和准确率。下面这段代码我加了详细注释，读者可以直接复制使用。

python复制device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = FashionCNN(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

epochs = 15
train_loss_history = []
val_loss_history = []
val_acc_history = []

for epoch in range(epochs):
    # 训练阶段
    model.train()
    running_loss = 0.0
    total = 0
    correct = 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)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    train_loss = running_loss / total
    train_acc = correct / total * 100
    train_loss_history.append(train_loss)

    # 验证阶段
    model.eval()
    val_loss = 0.0
    val_correct = 0
    val_total = 0

    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            loss = criterion(outputs, labels)

            val_loss += loss.item() * images.size(0)
            _, predicted = torch.max(outputs, 1)
            val_total += labels.size(0)
            val_correct += (predicted == labels).sum().item()

    val_loss = val_loss / val_total
    val_acc = val_correct / val_total * 100
    val_loss_history.append(val_loss)
    val_acc_history.append(val_acc)

    print(f'Epoch {epoch+1:02d}/{epochs} | '
          f'Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}% | '
          f'Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%')

这里有一个我踩了不止一次的坑：torch.max(outputs, 1)返回的是两个值，第一个是最大值，第二个是最大值的索引。索引就是预测的类别。很多教程喜欢用torch.argmax(outputs, dim=1)，效果一样，但如果你要同时拿到最大概率值做置信度分析，就用torch.max，灵活一些。

另一个细节是训练阶段不要写torch.no_grad()，验证阶段一定要写。torch.no_grad()能关闭梯度计算图，大幅减少显存占用和计算量。有人会觉得写了也跑得动，不写也能跑，确实如此，但模型规模一大、batch_size一上去，差别就出来了。验证阶段不更新参数，根本不需要保存梯度信息，没必要白费算力。

3.3 训练轮数、学习率与收敛判断

我设置的epochs是15，learning rate是0.001。实际跑下来，大概第8到10轮训练准确率会超过95%，验证准确率稳定在91%到92%。Fashion-MNIST是一个难度适中的数据集，91%左右的验证准确率已经算一个不错的基线，上面还有很大的优化空间，但作为多分类流程的演示已经完全足够了。

如果训练过程中发现train_loss一直在下降但val_loss先降后升，这就是典型的过拟合信号，这时候不是继续加epochs，而是应该做三件事：加大Dropout比例到0.6甚至0.7、增加数据增强（随机旋转、随机裁剪）、或者把学习率降下来。如果train_loss和val_loss都卡住不动，先检查学习率是不是太大导致loss震荡，或者太小导致收敛极慢，这种问题通常两个方向调：lr从0.001往下试，或者换用SGD加momentum。

3.4 把训练曲线画出来验证收敛

训练结束后画loss曲线是个好习惯。两张图并排：左边是train_loss和val_loss随epoch的变化，右边是val_acc。如果两条loss曲线之间的距离越拉越大，说明过拟合了；如果val_loss还在明显下降，说明还能继续训练几轮。

python复制plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(range(1, epochs+1), train_loss_history, label='Train Loss')
plt.plot(range(1, epochs+1), val_loss_history, label='Val Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Loss Curves')

plt.subplot(1, 2, 2)
plt.plot(range(1, epochs+1), val_acc_history, label='Val Acc')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.legend()
plt.title('Validation Accuracy')

plt.tight_layout()
plt.show()

如果你发现val_acc曲线在第12轮还在上升，那说明15轮不够，可以加大epochs。如果val_loss在第6轮就开始上升了，说明模型过拟合了，不是加轮数能解决的，应该回到模型结构上做正则化。

4. 测试评估与混淆矩阵的代码实现

4.1 测试集上的整体准确率

训练结束后，需要单独在测试集上评估一次，这个结果才是你对外报告的真实模型水平。验证集评估通常放在训练循环里方便观察趋势，但最终模型的泛化能力要以测试集为准。

python复制model.eval()
test_correct = 0
test_total = 0
all_preds = []
all_labels = []

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)

        test_total += labels.size(0)
        test_correct += (predicted == labels).sum().item()

        all_preds.extend(predicted.cpu().numpy())
        all_labels.extend(labels.cpu().numpy())

test_acc = test_correct / test_total * 100
print(f'Test Accuracy: {test_acc:.2f}%')

注意这里我在收集预测结果的时候用predicted.cpu().numpy()。如果你把GPU上的Tensor直接转numpy，会报TypeError，因为GPU上的Tensor是CUDA类型的，必须先cpu()再numpy()。这是一个特别常见但报错信息又很容易让人迷茫的操作。

4.2 逐类查看precision、recall和f1

整体准确率是91%，但具体到每一个类别，表现可能差很多。比如衬衫这一类可能只有60%多的精确率，而裤子可能接近99%。只看整体准确率是发现不了这个问题的。这时候用sklearn的classification_report逐类看。

python复制print(classification_report(all_labels, all_preds, target_names=class_names))

输出大概长这样：

text复制              precision    recall  f1-score   support

     T-shirt       0.86      0.84      0.85      1000
     Trouser       0.99      0.98      0.99      1000
     Pullover       0.88      0.84      0.86      1000
     Dress       0.92      0.91      0.92      1000
      Coat       0.86      0.85      0.86      1000
     Sandal       0.97      0.98      0.97      1000
     Shirt       0.67      0.72      0.69      1000
     Sneaker       0.96      0.96      0.96      1000
      Bag       0.97      0.98      0.97      1000
 Ankle boot       0.97      0.96      0.96      1000

    accuracy                           0.91     10000
   macro avg       0.91      0.90      0.90     10000
weighted avg       0.91      0.91      0.91     10000

从报告里能很清楚地看到，其他9类都在85%以上，只有Shirt（衬衫）的f1只有0.69上下。这说明模型确实在衬衫这个类别上遇到了困难。为什么会这样？因为衬衫和T恤、套头衫、连衣裙在视觉上有大量重叠特征，模型容易把它们混在一起。这就是分类报告的价值：它帮你在全局准确率的掩盖下精确找到短板。

4.3 混淆矩阵可视化与易混淆类别分析

分类报告只能告诉你哪个类别表现差，混淆矩阵能进一步告诉你它到底被错分到了哪一类。

python复制import numpy as np

cm = confusion_matrix(all_labels, all_preds)

plt.figure(figsize=(10, 8))
plt.imshow(cm, interpolation='nearest', cmap='Blues')
plt.colorbar()

tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names, rotation=45)
plt.yticks(tick_marks, class_names)

# 在每个格子中显示数量
for i in range(len(class_names)):
    for j in range(len(class_names)):
        plt.text(j, i, str(cm[i][j]),
                 ha='center', va='center',
                 color='white' if cm[i][j] > cm.max() / 2 else 'black')

plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.title('Confusion Matrix')
plt.tight_layout()
plt.show()

关注混淆矩阵里对角线以外的值。比如真实标签是Shirt的1000张图里，可能有90张被预测成了T-shirt，70张被预测成了Pullover。这就是模型的“视觉盲区”。明白了这一点，后续优化方向也就清晰了：要么增加这三类的训练样本数量，做针对性的数据增强，要么考虑在模型结构里添加注意力机制，让模型更关注区分这些类别所需的局部特征。

4.4 错误样本可视化

混淆矩阵可以定量说明错误类型分布，但真正调模型之前我建议随机挑一些预测失败的样本出来，看看模型的错误是否有合理解释。如果你的类别标签里没有明确区分“有领子的衬衫”和“无领子的T恤”，那模型根据像素特征把它们混在一起是非常正常的。

做错误样本可视化也很简单，遍历测试集找出预测值和真实值不一致的样本，画成网格图，每张图的标题同时标注真实标签和预测标签。你会很直观地发现，很多错误样本连人眼都容易搞混。这时候不要急着骂模型，先想想是不是任务本身定义得不够清晰，或者数据标注存在噪声。

5. 常见问题与排查技巧实录

5.1 训练loss不降或忽高忽低

训练loss不下降，这是多分类任务里问得最多的问题。排查顺序我总结成一张表：

还有个特别隐蔽的问题：如果你忘了调用optimizer.zero_grad()，梯度会在每个batch之间累加。训练初期loss可能还会下降，但后面越来越不稳定，突然就nan了。每次backward()之前清空梯度这个习惯一定要养成。我见过太多新手把代码写在同一个循环里，漏掉这行，然后被loss乱跳折磨一整天。

5.2 显存不足（OOM）的处理

多分类任务的显存占用主要取决于batch_size和模型大小。如果你用我这个两层CNN结构，batch_size=64在4GB显存的显卡上完全够用。但如果自己换了更大的模型或者batch_size直接拉到256，就可能会报CUDA Out Of Memory。

解决思路很简单：第一步，batch_size减半，从64减到32甚至16。第二步，检查图片尺寸，如果输入图不是28x28而是224x224，那同样的网络结构计算量会爆炸式增长，这种情况下先减小全连接层的输入维度。第三步，确认验证段用了torch.no_grad()。第四步，在训练循环里适当调用torch.cuda.empty_cache()清一下显存缓存，不过根本上还是前两步。

5.3 衬衫类别准确率低的专项分析

Fashion-MNIST上Shirt类别准确率低不是代码bug，是数据集本身的先天问题。T-shirt、Pullover、Coat、Dress这几个类别在局部纹理和轮廓上都有相似之处，而Shirt的标注本身又不够清晰。解决这种类别混淆问题，通用思路有几种：

• 增加数据增强，比如随机旋转、随机水平翻转、轻微的亮度扰动，让模型看到这个类别更多样的形态，降低过拟合；
• 换更强大的backbone，比如把简单CNN换成ResNet18或EfficientNet的轻量版；
• 使用标签平滑（Label Smoothing），它能让模型对硬标签不那么自信，减少过拟合。PyTorch的CrossEntropyLoss里直接有label_smoothing参数，设置为0.1就能用；
• 类别不平衡时使用加权损失，给样本少的类别更高的loss权重。Fashion-MNIST各类别数量均衡，不需要这步，但换成你自己的数据集时一定要检查类别分布。

5.4 结果复现与随机种子

多分类训练涉及大量随机性：权重初始化、dropout、shuffle、数据增强。同一个代码跑两次，测试准确率浮动可能有0.3到0.5个百分点，这是正常的。但如果差太多，比如一次91%一次85%，那就要怀疑是不是哪里有问题。

为了便于结果复现，训练入口设置固定的随机种子是标准做法。

python复制import random
import numpy as np

def set_seed(seed):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

set_seed(42)

cudnn.deterministic = True能让GPU上的卷积运算使用确定性算法，代价是计算速度稍微变慢。如果你想优先训练速度，可以把这个选项关掉，但复现时记得打开。

5.5 自己的数据集如何使用这套代码

很多人跑完Fashion-MNIST之后最关心的问题就是：怎么把这套代码迁移到自己项目的数据集上。

最关键的一步是把数据加载部分换成你自己的数据源。如果数据目录结构是每个类别一个文件夹，用datasets.ImageFolder(root='你的数据目录', transform=transform)直接加载即可。需要改的地方有：模型接口的num_classes参数改成你自己的类别数，全连接层最后一层的输出维度会自动对应；class_names列表改成你自己的类别名称；图片尺寸如果是224x224，模型结构和全连接层的输入维度要重算，或者直接换成预训练的ResNet18并把最后一层替换成对应类别数。

很多人在自己的数据集上掉点，通常不是因为分类模型的代码逻辑有问题，而是数据处理方式不同。比如你的图片是彩色三通道，但你用了1通道模型结构；再比如你的图片大小不一致，没有做resize。建议先用小规模数据跑通流程，确认模型能够正确过拟合到一小部分训练样本上，再上全量数据训练。

写在最后的实操体会

多分类模型这套代码框架我前后用了无数次，每次遇到不同类型的数据集，回头改的核心其实就三处：数据加载、模型最后一层、评估方式。如果你把这三处都设计成参数化的，以后面对新任务基本就是改配置的事了。

我自己跑这一节实验时印象最深的不是最后的92%准确率，而是第一次看到混淆矩阵时发现衬衫和T恤错得那么离谱。那一刻我才意识到，多分类任务真正难的地方从来不是让模型跑起来，而是如何解读模型的行为、定位它的问题，然后针对性地调整数据和结构。如果你能把这一节的代码跑通，并且能对着分类报告和混淆矩阵说出“为什么这一类比那一类差”，那我敢说你已经入门了。

最后再分享一个小技巧：训练过程中每轮保存一次模型参数，别嫌麻烦。用torch.save(model.state_dict(), f'checkpoint_epoch{epoch}.pth')，epochs设少一点也无所谓。因为这个世界上有一种后悔叫“跑了20轮才知道第14轮的结果最好”，那时候你只能哭着重新训练一遍。