2. 多分类任务的三个核心设计问题

先说结论：DNN跑多分类，真正需要想清楚的只有三件事——输出层的神经元数量、输出层的激活函数、损失函数的选择。这三件事定下来，模型框架基本就定死了，后面做的都是调参和优化。

2.1 输出层神经元数量：类别数，不是特征的维度

很多初学者会在这犯迷糊。输入层神经元数量由特征维度决定，这没错；但输出层神经元数量完全由类别数量决定。比如要识别手写数字0到9，那就是10个类别，输出层设10个神经元。

每个神经元对应一个类别，输出值的大小代表模型认为样本属于该类别的“倾向程度”。这不是我拍脑袋定的，而是神经网络做分类的基本范式——用多个输出单元分别拟合不同类别的判别函数，最后取最大值的那个神经元作为预测结果。

2.2 激活函数：二分类用Sigmoid，多分类必须用Softmax

这是新手踩坑最多的地方。二分类任务经常用Sigmoid，输出一个0到1之间的值，大于阈值判为正类。但多分类如果还按这个思路来，每个输出神经元单独算Sigmoid，就会出现一个严重的问题：各个神经元的输出互不约束，可能输出结果是[0.8, 0.6, 0.7]，三个类别都“挺像”，但没法直接说哪个概率最高，总和也不是1。

Softmax干的事就是把这组原始输出值“归一化”成真正的概率分布。它有个很直白的特性：先对每个输出值做指数运算（放大差距），再除以所有指数值的总和。这样得到的结果满足两个条件：

• 每个值在0到1之间
• 所有值的总和等于1

打个比方：一班同学考试成绩出来后，你想知道谁“相对最好”。Softmax不看绝对分，而是看各自分数的指数在所有同学指数总和中的占比——分数最高的那个同学，占比会非常突出。这就是为什么Softmax特别适合做多分类的概率输出，它把“原始得分”变成了“竞争性概率”。

2.3 损失函数：交叉熵，而不是均方误差

多分类任务的标准损失函数是交叉熵（Cross-Entropy Loss）。这个问题我在不少项目里见过有人用均方误差（MSE）来训练分类模型，结果收敛速度慢、准确率也上不去，还以为是网络结构出了问题。

原因其实在原理层面。MSE假设误差服从高斯分布，适合回归任务；而分类任务的真实标签是离散的类别索引，本质是一个概率分布（某个类别概率为1，其他为0）。交叉熵衡量的是模型预测分布与真实分布之间的差异，差异越小，模型越接近真实分布。

还有一个更实际的优势：交叉熵配合Softmax，梯度更新更稳定。如果使用MSE加Softmax，在预测结果接近真实值时梯度会趋近于0（因为Sigmoid/Softmax函数在饱和区导数很小），导致训练停滞。而交叉熵的梯度形式会抵消掉Softmax导数中的饱和项，让误差信号能持续反向传播下去。这个数学性质很重要，直接决定了你能不能把模型训起来。

所以在实操中，PyTorch的CrossEntropyLoss和TensorFlow的categorical_crossentropy内部都已经帮我们把Softmax和交叉熵融合在一起了，不需要在模型里单独再写一层Softmax再做损失计算——这一点后面代码部分会详细展开。

2. 从零搭建一个DNN多分类模型

这一部分我直接给出一份可运行的完整代码，用的是PyTorch框架。为什么选PyTorch？因为它的动态图机制在调试网络结构时非常方便，print一个张量的形状就能立刻发现问题，对新手极其友好。框架选型不是关键，但调试体验确实影响效率，这点在后面的实操中你会感受到。

2.1 环境准备与依赖安装

先用最简单的命令把环境配好。我用的是Python 3.9以上的版本，配合PyTorch 2.x：

pip install torch torchvision matplotlib numpy scikit-learn

torchvision在这份代码里不是必须的，但后续如果要做数据增强或加载现成数据集，它很方便，顺手一起装。matplotlib用来可视化训练曲线，scikit-learn用来生成数据集和做评估指标计算。

2.2 数据准备：用make_classification生成多分类数据

为了把注意力集中在DNN本身而不是数据处理上，我用make_classification生成一份模拟数据。它允许我直接指定样本数、特征数、类别数和聚类程度，非常适合做网络结构验证。

from sklearn.datasets import make_classification from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler import torch from torch.utils.data import DataLoader, TensorDataset # 生成多分类数据集：5个类别，1200个样本，每个样本20维特征 X, y = make_classification( n_samples=1200, n_features=20, n_informative=15, n_redundant=5, n_classes=5, n_clusters_per_class=1, random_state=42 ) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=42, stratify=y ) # 标准化：对每个特征减均值除以标准差 scaler = StandardScaler() X_train = scaler.fit_transform(X_train) X_test = scaler.transform(X_test) # 转换为PyTorch张量 X_train_t = torch.tensor(X_train, dtype=torch.float32) y_train_t = torch.tensor(y_train, dtype=torch.long) X_test_t = torch.tensor(X_test, dtype=torch.float32) y_test_t = torch.tensor(y_test, dtype=torch.long) # 构建DataLoader train_dataset = TensorDataset(X_train_t, y_train_t) test_dataset = TensorDataset(X_test_t, y_test_t) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

有几处细节单独说一下。

**标准化这一步不能省。**全连接网络对输入特征的尺度非常敏感。如果一个特征取值范围是0到10000，另一个是0到1，前者在反向传播中产生的梯度会大很多，迫使网络权重主要朝着拟合这个特征的方向调整，其他特征的信息就被压制了。标准化后所有特征都在同一量纲下，每个特征对损失的贡献才公平。

stratify=y这个参数也值得注意，它保证划分后的训练集和测试集中各类别比例与原数据集一致。多分类任务中类别不平衡会严重干扰训练，分层抽样是最基本的预防手段。

2.3 构建DNN模型

下面定义一个三层全连接网络，输入层20个神经元，两个隐藏层分别为64和32个神经元，输出层5个神经元对应5个类别：

import torch.nn as nn class MulticlassDNN(nn.Module): def __init__(self, input_dim=20, num_classes=5): super(MulticlassDNN, self).__init__() self.fc1 = nn.Linear(input_dim, 64) self.fc2 = nn.Linear(64, 32) self.fc3 = nn.Linear(32, num_classes) self.relu = nn.ReLU() self.dropout = nn.Dropout(0.3) def forward(self, x): x = self.relu(self.fc1(x)) x = self.dropout(x) x = self.relu(self.fc2(x)) x = self.dropout(x) x = self.fc3(x) # 注意：输出层不加激活函数 return x

结构很简单，但有三个关键设计决策需要解释清楚。

**隐藏层为什么用ReLU而不是Sigmoid？**这是现代神经网络的标配选择。Sigmoid函数在输入绝对值较大时梯度趋近于0，多层叠加后梯度连乘会指数级缩小，导致浅层权重几乎无法更新，这就是“梯度消失”。ReLU在正区间梯度恒为1，不会压缩梯度信号；在负区间直接输出0，给网络引入稀疏性，反而有助于缓解过拟合。

**Dropout放在哪个位置？**我习惯把它放在每个隐藏层激活函数之后、下一层之前。Dropout的原理是训练时以一定概率随机“丢弃”神经元，迫使网络不依赖单个节点的输出，从而增强泛化能力。用0.3的丢弃率对于这个规模的网络来说是合理选择，率太高会使模型欠拟合，太低又起不到正则化效果。测试阶段Dropout自动关闭，所有神经元都参与推理。

**输出层为什么没有激活函数？**这是PyTorch用户最需要记住的约定之一。我们的模型返回的是“原始logits”，真正的Softmax概率转换被放到了损失函数内部。这样设计不是因为忘写了，而是CrossEntropyLoss内部已经包含Softmax操作，如果模型里再加一层Softmax，等于做了两次转换，既浪费计算还会在数值上产生不必要的误差。

2.4 训练循环：优化器和损失函数的选择

训练代码写好后，我会配合可视化一起讲，因为训练过程只有看着曲线变化才能理解每个超参数的作用：

import torch.optim as optim import matplotlib.pyplot as plt model = MulticlassDNN() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) train_losses = [] test_accuracies = [] num_epochs = 100 for epoch in range(num_epochs): model.train() running_loss = 0.0 for batch_X, batch_y in train_loader: optimizer.zero_grad() outputs = model(batch_X) loss = criterion(outputs, batch_y) loss.backward() optimizer.step() running_loss += loss.item() * batch_X.size(0) epoch_loss = running_loss / len(train_loader.dataset) train_losses.append(epoch_loss) # 每个epoch结束后在测试集上评估 model.eval() correct = 0 total = 0 with torch.no_grad(): for batch_X, batch_y in test_loader: outputs = model(batch_X) _, predicted = torch.max(outputs, 1) total += batch_y.size(0) correct += (predicted == batch_y).sum().item() epoch_acc = correct / total test_accuracies.append(epoch_acc) if (epoch + 1) % 10 == 0: print(f"Epoch {epoch+1:3d} | Loss: {epoch_loss:.4f} | Test Acc: {epoch_acc:.4f}")

优化器选Adam而不是SGD，原因很实际：Adam自带自适应学习率，对学习率的初始值不敏感，对于大多数中等规模任务可以“开箱即用”地收敛。SGD虽然理论上能找到更平坦的极小值，泛化性有时更好，但需要仔细调整学习率和动量参数，调参成本高。我在这个Demo里先用Adam把模型训起来，如果后续要追求极限精度再切换到SGD配合学习率衰减，这是更稳妥的工作流。

还有一个细节：每次迭代必须调用optimizer.zero_grad()。PyTorch的梯度是累积的，如果不清零，上一次迭代的梯度会叠加到本次，导致参数更新方向被污染。这个错误我在早期写代码时踩过，排查了很久才意识到是梯度累积的问题。

训练结束后把损失曲线和准确率曲线画出来：

plt.figure(figsize=(12, 4)) plt.subplot(1, 2, 1) plt.plot(train_losses) plt.title("Training Loss") plt.xlabel("Epoch") plt.ylabel("Loss") plt.subplot(1, 2, 2) plt.plot(test_accuracies) plt.title("Test Accuracy") plt.xlabel("Epoch") plt.ylabel("Accuracy") plt.show()

用这份配置跑100个epoch，在测试集上一般能拿到0.95以上的准确率。如果你的结果差很多，不用怀疑模型结构，先检查数据标准化和损失函数配置。

2.5 评估：光看准确率远远不够

准确率是多分类最直观的指标，但不是唯一的。类别不均衡时准确率会骗人。假设95%的样本属于A类，模型把所有样本都预测成A类，准确率也有95%，但这是个废物模型。

多分类任务至少要看三个东西：混淆矩阵、每类精确率/召回率、以及宏观平均F1分数。用scikit-learn几行代码就能算出来：

from sklearn.metrics import classification_report, confusion_matrix import numpy as np # 收集全部预测结果 all_preds = [] all_labels = [] model.eval() with torch.no_grad(): for batch_X, batch_y in test_loader: outputs = model(batch_X) _, predicted = torch.max(outputs, 1) all_preds.extend(predicted.numpy()) all_labels.extend(batch_y.numpy()) print(classification_report(all_labels, all_preds)) print("Confusion Matrix:") print(confusion_matrix(all_labels, all_preds))

classification_report输出的每一行是一个类别的精确率（Precision）、召回率（Recall）和F1分数。**宏平均（macro avg）把所有类别的指标平等看待，比微平均（micro avg）更能反映模型在小类别上的表现。**如果宏平均远低于微平均，说明模型把多数类的优势带到了总体指标里，少数类被忽略了。

3. 核心细节拆解：Softmax、交叉熵与反向传播的协作方式

很多教程把Softmax和交叉熵当成两个独立概念讲，但在实际代码里它们是一个整体。理解这个整体，你才能看懂为什么CrossEntropyLoss直接吃logits，而不是吃Softmax之后的概率。

3.1 Softmax的数学形式与梯度传播

Softmax把任意实数向量转换成概率分布。对于类别k，Softmax的公式是：

P(y=k|x) = exp(z_k) / Σ_j exp(z_j)

其中z_k是输出层第k个神经元的logit值。这里有两个值得注意的工程细节。

第一个是数值稳定性问题。如果某个logit值很大（比如10），exp(10)约等于22026，如果5个神经元都有较大输出，分母可能达到几万甚至更大，在极端情况下exp(1000)直接溢出成无穷大。PyTorch的CrossEntropyLoss内部会自动做数值稳定化处理——通常是先减去最大值再算Softmax：

exp(z_k - max_z) / Σ_j exp(z_j - max_z)

数学上这个变换不改变结果，因为分子分母同时除以了exp(max_z)，但数值上避免了溢出。这是框架帮我们处理好的细节，如果你自己手写Softmax，一定要做这个减法。

第二个是Softmax的饱和区梯度问题。对Softmax求导后发现，当某个类别概率接近1时，对应神经元的梯度接近0。单纯用Softmax加MSE，模型越接近收敛越学不动——这就是前面说的“梯度停滞”。而交叉熵的巧妙之处在于，它的梯度公式将Softmax的导数简化成了(P(y=k|x) - 1)这种形式，预测越错梯度越大，预测越对梯度越接近0，训练过程自然顺畅。

这解释了为什么在实际框架中你不需要显式地把“Softmax”和“CrossEntropy”分开写：PyTorch的CrossEntropyLoss和TensorFlow的SparseCategoricalCrossentropy在内部已把两者合并为数值稳定且梯度可完美传播的复合函数。

3.2 模型输出应该是什么格式

这也是一个高频问题，在网上看到代码风格各不相同。先说结论：多数主流框架，损失函数吃的是原始logits，不吃概率值。

PyTorch的CrossEntropyLoss要求输入是形状为(batch_size, num_classes)的logits张量，标签是形状为(batch_size,)的长整型索引（即每个样本的类别编号，比如0、1、2、3、4）。注意标签不能是One-Hot编码的向量，而是类别索引。

TensorFlow这边情况稍复杂一点，有两个相似的损失函数：

• SparseCategoricalCrossentropy：接收整数标签，对应PyTorch的CrossEntropyLoss
• CategoricalCrossentropy：接收One-Hot标签

如果你模型最后一层已经通过Softmax层做了概率转换，那么在loss中要显式指定from_logits=False；如果模型直接输出logits，则用from_logits=True。我在多个项目里的习惯是模型输出logits，损失函数设from_logits=True，好处是数值稳定性更好，因为在loss内部做Softmax时的减最大值操作可以正确生效。如果先在外面做Softmax再喂给loss，数值上可能多了一层精度损耗。

3.3 从预测概率到类别标签

推理阶段，我们一般通过torch.max取概率最大的类别索引：

_, predicted = torch.max(outputs, 1)

torch.max返回两个值：最大值和其索引。predicted的形状是(batch_size,)，里面是每个样本预测的类别编号。这个操作只做比较，不参与反向传播，所以可以在no_grad环境下运行。

需要补充一点：如果你想要更详细的置信度信息，可以先用torch.softmax(outputs, dim=1)拿到每个类别的概率值，再根据业务需要决定是否设置置信度阈值。比如某些医疗诊断场景，模型对某个样本预测为A类的概率只有0.45，这时候不应该直接当成确定结果输出，而是要标记为“低置信度，需要人工复核”。多分类任务落到实际场景中，不只是选一个类别标签，更重要的是把概率值传给下游决策。

3. 网络结构优化与参数调优记录

模型能跑通只是第一步。下面分享一些我在实际调参过程中总结出有效性的操作。这部分内容偏经验向，但每条都有明确的实验依据。

3.1 隐藏层神经元数量的选择逻辑

对于这份5类、20维特征的数据集，64-32的结构已经足够了。如果特征数量上升到几百甚至上千，隐藏层宽度可以适当增加，但不是越宽越好。

我见过有人把隐藏层设成512-256-128，想着“越大越强”，结果在中等规模数据集上训练速度慢、严重过拟合，测试准确率反而低于更小的模型。神经网络的容量要与数据量匹配，参数越多，需要的训练样本也越多，否则模型只会记住训练集噪声。

一个可用的经验法则是：第一隐藏层神经元数量在输入维度到输入维度4倍之间，后续层逐渐减半。不要一上来就堆几百个神经元，先小后大，用验证集的损失曲线判断容量是否不足——训练损失高、验证损失也高，说明欠拟合，此时增加容量；训练损失低、验证损失高，说明过拟合，此时增加Dropout或减小容量。

3.2 学习率：最大超参数，没有之一

在我调参的经验排序中，学习率对最终效果的影响远超其他超参数。lr设太大，损失会震荡甚至发散；lr设太小，收敛极慢，训练几百轮还在原地踏步。

用Adam时，lr=0.001是稳妥的默认值，适合大多数场景。但有个细节值得留意：lr适当时，训练损失曲线应该是平滑下降的。如果看到损失曲线剧烈抖动，先别急着改网络结构，把lr调小一个量级再试。

更进一步，可以考虑学习率调度。常见的策略是ReduceLROnPlateau：当验证损失多轮不再下降时，把学习率乘以0.1。这是一种“先大步探索、后小步精调”的思路，我在训练后期经常能靠它再提升1到2个百分点的准确率：

scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='min', factor=0.5, patience=10 ) # 在每个epoch结束后： scheduler.step(epoch_loss)

patience=10表示容忍10个epoch内验证损失不改善，之后才降低学习率。这个参数防止了训练过程的正常波动被误判为收敛，过早降低学习率。

3.3 正则化三板斧：Dropout、Weight Decay、早停

深度神经网络的过拟合风险不能被无视。虽然只有3层网络，面对1200条数据仍然可能在训练后期开始“背题”。我常用的三种正则化手段，各有所长：

• Dropout：随机屏蔽神经元，让网络“冗余化”，对中等规模网络效果立竿见影
• Weight Decay（权重衰减）：在损失函数中加上权重的L2范数，防止单个权重值过大，Adam优化器中直接设置weight_decay=1e-4即可
• 早停（Early Stopping）：监控验证损失，连续N轮没有改善就停止训练，保留最优模型权重

早停是防止过拟合最省心的手段，不需要调任何模型结构参数。我通常把验证损失最优时的模型权重保存下来，最后用这份权重做测试集评估，而不是用最后一个epoch的权重：

best_acc = 0.0 best_model_state = None for epoch in range(num_epochs): # ...训练逻辑... if epoch_acc > best_acc: best_acc = epoch_acc best_model_state = model.state_dict().copy() # 训练结束后 model.load_state_dict(best_model_state)

3.4 从数据侧看多分类

调参调到头，如果准确率还差口气，我会回头审视数据。多分类任务中数据侧最常遇到的问题是类别交织严重——某些样本的特征分布与另一个类别的样本高度重叠，模型在特征空间里根本分不出边界。

用make_classification生成数据时可以设置class_sep参数控制类别分离程度。实际项目中的数据不会说“我的重叠程度是0.8”，但可以通过数据可视化来感受。比如用PCA把特征降到2维再散点图，能直观看到类别分布是否交织严重。如果重叠严重，单纯调网络结构收效甚微，这时应该考虑：

• 增加特征或做特征工程，引入更多判别信息
• 增加数据量，让边界区域有更多训练样本
• 改用更复杂的模型（但DNN已经是强特征提取器，换CNN等结构属于另一条路线）

**分类本质上是数据问题，不只是模型问题。**很多团队在数据侧稍微下功夫，效果提升比调整网络结构来得快得多。

4. 实战常见问题与排查技巧

这一部分我整理了在多分类DNN实战中最高频出现的问题，按照出现的概率从高到低排列，每一条我都亲自踩过或者帮别人排查过。

4.1 损失变成NaN（非数值）

训练过程中loss突然变成NaN，这是最让人头疼的问题之一。排查顺序如下：

• 学习率过大：最常见原因。把lr从0.001降到0.0001试一次。
• 数据包含NaN值：检查输入数据是否有缺失值或异常值。标准化前先过滤，np.isnan(X).any()可以快速检测。
• 梯度爆炸：多层网络深了容易出现，可以用梯度裁剪解决：

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

梯度裁剪刀把梯度的L2范数限制在1.0以内，超出部分等比缩放。它不改变梯度方向，只约束更新幅度，在训练稳定性上非常有效。

4.2 训练损失下降但测试准确率纹丝不动

这个情况我遇到好几次，特征在于训练损失一路向下，说明模型表达能力没问题，但泛化能力差。通常是过拟合了。

解决方案按优先级排序：

1. 增加Dropout比例：从0.3调到0.5
2. 给优化器加weight_decay=1e-4
3. 增加训练数据量或做数据增强
4. 减小模型容量（减少隐藏层神经元数）

4.3 准确率卡在某个值上不去

如果你的数据集本身的区分度有限，准确率会有个天花板。先画出混淆矩阵，看哪个类别之间互相混淆最多。比如3类和4类经常混在一起，说明这两类在特征空间中的边界很模糊，可以检查数据标注是否有误，或者考虑是否要合并类别。

另外还有个常见原因——类别不均衡。某类别样本数远少于其他类别，模型对这些样本的召回率会很低。解决方案包括：

• 对少数类过采样（imbalanced-learn库里有现成工具）
• 对多数类下采样
• 在损失函数中为少数类设置更高的权重，比如PyTorch的CrossEntropyLoss(weight=class_weights)

类别权重在实操中非常有用。它不是篡改数据分布，而是引导模型更关注少数类样本。但要注意权重不要设得太大，否则模型会被少数类带偏，压低整体准确率。

4.4 训练速度过慢

3层全连接网络训练速度应该以秒为单位才合理。如果你觉得慢得离谱，先检查是不是在CPU上硬跑。这个规模的数据和模型，CPU几百毫秒一个epoch不是问题，但如果特征维度很大、数据量到了几十万，GPU能快几十倍。

其次检查batch_size是否太小。batch=64较均衡，太小（比如1）会导致梯度更新频繁、震荡大且慢；太大则每个epoch更新的次数少，收敛慢且占用内存多。

4.5 预测结果全是同一个类别

这种症状基本可以确定是模型没学会特征，只学会了把样本全分到多数类。检查下面三件事：

• 标签是否传错：PyTorch的CrossEntropyLoss要求标签是torch.long类型，如果把浮点标签传进去，可能产生难以察觉的错误
• 最后一层是否误加了Softmax：如果模型输出层加了Softmax后再交给CrossEntropyLoss，相当于做了两次Softmax，概率分布被过度平滑，模型输出信息量降低
• 学习率是否过小或过大：极端情况会让模型困在局部极小值或者震荡发散

5. 超参数速查表与项目扩展方向

最后给出一张我在多分类DNN项目上的默认配置速查表，这份配置经过多次实验验证，可以直接作为项目的起点。

5.1 默认配置速查表

5.2 从Demo到实际项目的演进方向

这篇博文的Demo只是一个最小可行框架，实际业务中的多分类任务往往需要向下面几个方向扩展。

**类别数量扩展。**从5类扩展到上百类时，Softmax分母的计算量会线性增加，但更关键的问题是类别之间的层次关系。比如商品分类，可能先分“电子产品”再分“手机”，这类任务可以用层次分类或者多个DNN串行完成，而不是让一个模型直接输出几百个类别。

**数据规模扩展。**当样本量从1千涨到100万，DNN的训练瓶颈会从模型结构转向数据读取和分布式训练。这时候需要引入数据并行、流水线并行等手段，DNN模型本身的结构可能不变，但训练工程复杂度会大幅提升。

**模型解释性需求。**多分类DNN的“黑箱”特性在某些场景（比如风控、医疗）是很大的问题。做这类项目，可以考虑在模型之外配合SHAP等解释工具，分析每个特征对不同类别预测的贡献度。这有助于发现模型是否依赖了不该依赖的特征。

**多标签场景。**如果样本同时归属于多个类别（比如一张图片同时包含猫和狗），那就不再是“多分类”而是“多标签分类”。做法是输出层每个神经元都单独用Sigmoid激活，损失函数换成BCEWithLogitsLoss。这是从多分类到多标签的一个自然扩展，掌握好DNN多分类之后，再上手多标签会非常快。

我在实际项目中最大的体会是：**多分类任务中，80%的收益来自数据和损失函数的正确设计，网络结构本身对结果的影响没有想象中那么大。**把输入数据整理干净、把类别平衡处理到位、把损失函数选对，剩下的结构调优都是在“锦上添花”。这也意味着，遇到效果不佳的情况，不要急着换更深更宽的网络，先用排查清单把基础问题扫一遍。

另外再分享一个很实用的习惯：每次调参后把结果记录在一个表格里，标明超参数配置、训练损失、测试准确率、训练耗时。不要凭感觉判断“好像改了lr之后效果好一些”，用数据说话。调参的本质就是在高维空间里搜索最优解，没有记录就等于随机游走。这个习惯让我在后续很多个项目的起步阶段能直接用历史最优配置，省下了大量试错时间。