softmax神经网络入门：从反向传播到分类任务实战

要说清楚一件事，就得先把背景交代明白。“python-基于softmax方法的简单神经网络（程序）”这个标题，乍看像是一个课程作业，但实际上它背后一整套思路，是理解深度学习中分类问题的基础。用softmax做输出层，配合一个隐藏层，就是最典型的“浅层网络”结构。这套代码虽然短，但它把神经网络的核心环节——前向传播、反向传播、梯度更新——全走了一遍。很多初学者直接上手框架写模型，调个接口就完事，反而不知道网络内部到底在算什么。这个项目最大的价值，就是帮你把“黑盒”拆开，看清楚每个矩阵乘法、每个梯度对应的是什么含义。

我遇到过不少想入门机器学习的朋友，一上来就陷在数学推导里出不来，或者反过来，只顾着跑通代码、调参，对原理完全没概念。这个基于softmax的简单神经网络，刚好卡在两者中间：代码量不大，但足够承载核心概念；数学要求不高，但足以支撑你理解更复杂的模型。这篇文章我会从设计思路、数学原理、完整代码实现到踩坑经验，把整个项目拆开揉碎，结合我自己的实操经历来讲，希望能帮你把这个经典小项目吃透。

1. 项目拆解与整体设计思路

1.1 这个网络到底在解决什么问题

先回到最根本的问题上。softmax这个名字听起来很唬人，但它解决的事情非常简单：把一组任意实数，变成一组加起来等于1的概率。比如网络最后一层输出了三个数：2.0、1.0、0.1，它们大小不一，甚至可能是负数，没法直接当作分类结果。softmax会计算一个指数变换，再归一化，得到类似0.62、0.29、0.09这样的概率分布。哪个类别的概率最大，就预测哪一类。

这个能力是分类任务的核心诉求。你要判断一张图片是猫、狗还是鸟，本质上就是比较“这张图片属于猫的概率、属于狗的概率、属于鸟的概率”谁更大。所以，几乎所有现代图像分类模型，最后一层都挂着一个softmax（或者它的变体），把网络输出的得分转化成概率。

这个项目解决的，就是用最简的方式实现这个过程。它接受一批带有标签的训练数据，通过若干轮迭代，让网络学会输入到类别的映射。训练完以后，你给它一个从没见过的输入，它能输出一组靠谱的概率，并且准确判对类别。别小看这件事，它涵盖了一个完整分类器的全部要素：数据表示、模型结构、损失函数、梯度下降优化、推理预测。

有些读者可能会问，既然是“简单神经网络”，为什么不直接用单层的softmax回归？我做这个项目的时候也在思考这个问题。单层softmax回归，其实就是没有隐藏层的“神经网络”，它只能学到输入特征到类别输出之间的线性关系。对于手写数字之类的任务，效果还算能看，但稍微复杂一点的数据，线性边界就不够用了。加上一个隐藏层，网络就具备了拟合非线性关系的能力。这个提升跟“线性回归升级成多项式回归”是同一个逻辑，区别在于，神经网络用激活函数自动学特征组合，不需要你手写特征工程。这就是“简单神经网络”比“单纯softmax回归”更值得写的原因。

1.2 为什么选softmax作为核心方法

选择softmax，是因为它和交叉熵损失函数搭配得非常好。很多初学者不理解，为什么非要用指数函数，不能直接归一化吗？比如把输出值减去最小值，再除以范围，也能压缩到0到1之间啊。理论上可以，但在梯度下降的训练过程中，这种简单的归一化会导致梯度计算极其不稳定。

我举一个直白的例子。假设网络输出是[100, 101, 102]，这条三个数差别很小，但数值都很大。如果直接套归一化，结果大致是[0, 0.5, 1]，信息几乎被抹平了。而softmax先做指数运算，e的100次方和e的102次方，差距会被急剧放大，归一化后得到一个更“锐利”的概率分布。这个放大效应，让网络在输出值差异不大的时候，也能够产生足够强的梯度信号，推动参数更新。这就是softmax在分类任务里“好用”的本质原因。

再者，softmax的数学形式跟交叉熵配合之后，反向传播的梯度会有一个非常简洁的表达式。这个我在后面推导时会详细展开，这里先记一句话：softmax和交叉熵组合，让输出层的梯度计算从复杂的链式法则变成了一个极其简单的减法。这个性质，让编程实现变得异常清爽，也让代码调试容易不少。从工程角度看，选softmax是非常务实的决策。

1.3 网络结构设计：几层、多少神经元

我设计的网络结构是这样的：输入层、一个隐藏层、一个softmax输出层。用处理手写数字图像举例，如果图片是28x28像素，那么输入层的神经元数量就是784个，每个神经元对应一个像素的灰度值。隐藏层我选了64个神经元，数量不多，保证这个项目在普通电脑上几秒钟就能完成训练。输出层的神经元数量等于类别数，如果是10个数字，那就是10个神经元，每个神经元对应一个数字类别。

关于隐藏层的神经元数量，这里有个经验之谈：不是越多越好。神经元多了，模型的表达能力会增强，但同时也更容易过拟合——也就是训练集上表现很好，验证集上一塌糊涂。64个神经元在大部分简单分类任务上是比较稳的起点。如果你想实验，可以试试32、64、128三档，观察准确率和训练时间的变化，这比照抄别人的配置更能帮助你建立直觉。

隐藏层的激活函数，我选的是ReLU。对比一下，早期神经网络常用sigmoid，但它有一个很致命的问题：输入绝对值稍微大一点，梯度就趋近于0，参数几乎不动。这在深层网络里会引发所谓的“梯度消失”，训练根本推不动。ReLU的梯度在正区间恒等于1，负区间等于0，既省计算量，又不会让信息在层间传递时逐渐衰减。我在实操中也确实发现，把sigmoid换成ReLU之后，同样训练轮数下，准确率明显提升。这是现代神经网络能训练起来的功臣之一，没有它，很多结构都会卡死。

2. 核心数学原理与关键推导

2.1 softmax的公式与数值稳定性

softmax的计算公式写出来非常简洁：

对于第i个输出节点，它的softmax值是：

[ p_i = \frac{e^{z_i}}{\sum_{j=1}^{C} e^{z_j}} ]

其中z是网络最后一层的原始得分（也叫logits），C是类别总数。这个公式做的事情，就是先把每个得分取指数，再除以所有指数之和。指数函数有一个特点，它在输入比较大的时候，输出会非常快地增长。e的10次方约等于22026，e的12次方约等于162754。这个放大效应保证了“得分最高的类别，对应概率也最高”，同时也能拉开差距。

但是，指数函数也带来一个实际工程问题——数值溢出。假设你的网络输出里有z等于1000，那么e的1000次方会直接溢出成无穷大，后面所有计算都变成nan。怎么解决？有一个标准技巧：把每个z都减去这一批数据里的最大值，再做softmax。因为减同一个常数不改变softmax的结果（数学上可以证明，分子分母同时除以e的最大值），但能保证指数函数的输入不超过0，彻底避免溢出。

我在实现代码时，专门把softmax函数单独拎出来写，并且在里面就处理数值稳定性，而不是调用它的地方去处理。这样不管是训练还是推理，只要调用这一个函数，就必然安全。

2.2 交叉熵损失函数：衡量“模型有多错”

有了概率分布，就要有一个可优化的目标函数，告诉网络“现在的预测有多差”。这个损失函数就是交叉熵。对于单个样本，它的公式是：

[ L = -\sum_{k=1}^{C} y_k \log(p_k) ]

这里的y是真实标签的one-hot编码：如果真实类别是t，那么y_t等于1，其他位置都是0。带进去以后，整条求和只剩下一项，损失就是-log(真实类别对应的预测概率)。这个设计非常巧妙：如果模型对真实类别给出的概率是1，损失就是0；如果概率是0.1，损失就是2.3左右；概率越小，损失越大，而且是以对数级别增长。用对数还有一个好处，损失不会像线性惩罚那样“温和”，它会对特别错误的预测产生极强的惩罚信号，逼着网络快速修正。

为什么是交叉熵而不是均方误差？这是我初学阶段很困惑的点。均方误差(MSE)看起来也能衡量预测和真实标签的差距，用在回归任务上很合适，但用在分类上就水土不服了。原因在于，MSE配合softmax会产生一个包含sigmoid导数因子的梯度，而这个导数在概率接近0或1的时候会变得非常小，造成梯度消失。交叉熵配合softmax，相当于把这两个函数的导数互相“抵消”了一部分，得到一个干净又稳定的梯度。这也是神经网络分类任务默认用交叉熵的根本原因。

2.3 反向传播：梯度是怎么算出来的

反向传播是整个神经网络最核心，也是初学者最容易绕晕的部分。我尽量用最通俗的方式讲明白。

神经网络的训练，其实就是一个不断调整参数，让损失函数降低的过程。调整方向的依据是“损失对每个参数w的偏导数”，也就是梯度。梯度的绝对值大，说明这个参数对损失的影响也大，应该多调；绝对值接近0，说明影响小，少调或不调。反向传播就是高效计算所有这些梯度的算法。

因为网络是层层堆叠的，输出层的损失可以直接求出对最后一层参数的梯度，而隐藏层的梯度需要依赖输出层的梯度往前传。这就是“反向”这个字的来源。具体到代码里，你会看到梯度是先算输出层，再算隐藏层，一层一层往回传播。

推导细节如下。假设当前批次有m个样本，用矩阵化运算，先得到样本的真实one-hot标签矩阵y_onehot，形状是(m, C)。前向传播算出的预测概率矩阵probs，形状也是(m, C)。对于输出层，softmax加交叉熵的梯度，最终会化简成一个极其简洁的式子：

[ dz2 = probs - y_onehot ]

这个式子说明一个问题：输出层误差，就是预测概率和真实标签之间的“差额”。预测得越离谱，差额越大，梯度越强；预测得越准，差额越接近0，参数也就趋于稳定。这一步没有任何复杂的指数运算或除法，堪称优雅。

得到dz2以后，通过链式法则，可以继续求隐藏层到输出层的权重梯度。用矩阵乘法表示：

[ dW2 = a1^T \cdot dz2 ] [ db2 = \sum_{batch} dz2 ]

其中a1是隐藏层的激活输出。接下来继续往前提，计算隐藏层的误差dz1。这一步要借道权重W2：

[ da1 = dz2 \cdot W2^T ]

然后乘以ReLU的导数。ReLU的导数很简单：输入大于0为1，小于等于0为0。所以：

[ dz1 = da1 \cdot (z1 > 0) ]

最后求输入层到隐藏层的权重梯度：

[ dW1 = X^T \cdot dz1 ] [ db1 = \sum_{batch} dz1 ]

全部梯度求完之后，用梯度下降规则更新参数：

[ W = W - learning_rate \cdot dW ]

这句更新规则，是所有神经网络的共同底层逻辑。不管以后你接触的是卷积网络、循环网络还是Transformer，本质上都在反复做同一件事：前向算预测，反向算梯度，梯度下降来更新。把这个简单项目吃透，对你理解其他任何模型的源码都有巨大帮助。

3. 完整代码实现与逐段解析

3.1 初始化参数：好的开始是成功的一半

神经网络的权重初始化，直接决定训练能不能跑通。我的做法是：权重用随机正态分布乘以一个较小的标量，偏置初始化为0。

import numpy as np class SimpleNeuralNetwork: def __init__(self, input_size, hidden_size, num_classes, learning_rate=0.01): # 输入层到隐藏层的权重和偏置 self.W1 = np.random.randn(input_size, hidden_size) * 0.01 self.b1 = np.zeros(hidden_size) # 隐藏层到输出层的权重和偏置 self.W2 = np.random.randn(hidden_size, num_classes) * 0.01 self.b2 = np.zeros(num_classes) self.lr = learning_rate

为什么权重不能初始化为0？如果所有参数都是0，那么隐藏层所有神经元的输入输出完全相同，反向传播时所有梯度的数值也完全相同。这样的结果就是，不管隐藏层设置多少个神经元，它们在训练过程中始终保持一致，等效于只有一个神经元，模型的表达能力被完全锁死。这个现象叫“对称性问题”。随机初始化的作用就是打破对称，让每个神经元开始学习不同的特征。

为什么乘以0.01而不是直接使用标准正态分布？这个标量控制的是初始权重的量级。输入数据通常是0到1之间的像素值，输入层到隐藏层的加权和很容易随着神经元数量增加而变大，如果权重分布的标准差过大，加权和早就超出ReLU的有效输入区间，甚至造成数值爆炸。0.01是一个比较保守的倍数，保证每层的输出幅度不会一开始就失控。当然，如果你使用更精细的初始化方法，比如Xavier或者He初始化，效果通常会更好，但在这么浅的网络里，简单的0.01已经够用了。

3.2 前向传播：数据在网络中如何流动

前向传播就是一句话：输入数据经过层层矩阵运算和激活函数，最后变成预测概率。

def softmax(self, z): # 数值稳定性处理：减去最大值 shifted = z - np.max(z, axis=1, keepdims=True) exp_scores = np.exp(shifted) return exp_scores / np.sum(exp_scores, axis=1, keepdims=True) def forward(self, X): # 第一层：线性变换 + ReLU激活 self.z1 = np.dot(X, self.W1) + self.b1 self.a1 = np.maximum(0, self.z1) # ReLU激活 # 第二层：线性变换 + softmax self.z2 = np.dot(self.a1, self.W2) + self.b2 self.probs = self.softmax(self.z2) return self.probs

这段代码最值得留意的两个细节：

第一个，是softmax里的数值稳定性处理。减掉最大值之后再算指数，跟直接用原始值算指数，数学上结果完全一样。但如果不减，一旦出现某个z过大，指数计算会溢出成inf，后续所有运算全部变nan。我在第一次实现的时候没注意这一点，结果训练到一半损失突然变成了nan，找了半天才发现是这个原因。这个坑，基本每个手写神经网络的人都会踩一次。

第二个，是前向传播中所有中间结果都用self保存在对象上。为什么要保存？因为反向传播需要用到这些中间值来计算梯度。比如计算dW2需要a1，计算dz1需要z1。如果不在前向的时候把它们存下来，反向的时候还得重新算一遍，又慢又费事。本质上，你维护的是一个“计算图”的临时节点。当你后面学到用框架时会发现，框架做的也就是自动帮你保存这些中间缓存。

3.3 反向传播与参数更新：梯度计算的工程落地

反向传播代码看起来公式很多，实际上就是按照我前面推导的矩阵运算步骤，一步步写下来。

def backward(self, X, y): m = X.shape[0] # one-hot编码：把类标签变成概率形式的向量 y_onehot = np.zeros_like(self.probs) y_onehot[np.arange(m), y] = 1 # ---------- 输出层梯度 ---------- dz2 = self.probs - y_onehot # softmax + 交叉熵的梯度简化式 dW2 = np.dot(self.a1.T, dz2) / m db2 = np.sum(dz2, axis=0) / m # ---------- 隐藏层梯度 ---------- da1 = np.dot(dz2, self.W2.T) dz1 = da1 * (self.z1 > 0) # ReLU导数 dW1 = np.dot(X.T, dz1) / m db1 = np.sum(dz1, axis=0) / m # ---------- 参数更新 ---------- self.W2 -= self.lr * dW2 self.b2 -= self.lr * db2 self.W1 -= self.lr * dW1 self.b1 -= self.lr * db1

这里有一个非常细节的工程问题：每个梯度都除以了样本数m。为什么？因为这里的梯度是整批样本的累加结果。比如说，损失定义如果是整批样本损失的平均值，那么梯度也应该取平均。除以m之后，梯度的大小就不会跟batch size挂钩。这样，即使你调整batch size，学习率的设置也不会受到太大影响。这个小习惯，在你之后用过mini-batch训练时会特别重要。

还有个细节：dz2 = probs - y_onehot 这行，就是前面说的“softmax加交叉熵的梯度等价于预测减标签”的代码体现。你反推一下就会发现，少了这个化简，你还需要单独计算softmax的雅可比矩阵，再乘以交叉熵的导数，那代码会复杂很多。我在学习阶段试过完全展开的方式去写，代码体积翻一倍不说，还容易出错。所以，理解数学推导，真的能帮你写出更简洁、更不容易出bug的代码。

3.4 完整的训练流程与预测函数

有了前向和反向，剩下就是组织训练循环。这里我加入了一个简单的准确率统计，方便实时观察训练效果。

def train(self, X, y, epochs): for epoch in range(epochs): probs = self.forward(X) loss = self.compute_loss(probs, y) self.backward(X, y) if epoch % 10 == 0: acc = self.predict(X) == y acc = np.mean(acc) print(f"Epoch {epoch:3d} | Loss: {loss:.6f} | Accuracy: {acc:.4f}") def compute_loss(self, probs, y): m = y.shape[0] # 用np.arange选真实类别的预测概率，取负对数平均 log_probs = -np.log(probs[np.arange(m), y] + 1e-9) return np.sum(log_probs) / m def predict(self, X): probs = self.forward(X) return np.argmax(probs, axis=1)

compute_loss里我加了一个1e-9的小常数，目的是防止probs出现0值，导致log(0)得负无穷。虽然softmax的输出在理论上永远是正数，但在数值精度有限的计算机上，极端情况真的可能得到0。这种防御性编程是实践经验，建议保留。

完整跑起来的流程大概是：先准备训练数据，把像素矩阵展平成二维，标签格式设成一维数组，每个元素是0到9的整数；然后创建网络，调用训练函数，最后评估准确率。

3.5 手写数字识别的完整示例

我用自己的方式完整跑通了一份，生成的代码可以直接拿来实验。训练目标采用常见的手写数字数据集，每个样本是28x28的灰度图：

# 加载数据（以常见开源数据集为例） def load_data(): # 这里假设你已经有了 (X_train, y_train), (X_test, y_test) # 数据形状： # X_train: (60000, 784) 的二维数组，像素值范围 [0, 1] # y_train: (60000,) 的一维数组，取值 0-9 pass X_train, y_train, X_test, y_test = load_data() # 初始化网络：输入784 -> 隐藏64 -> 输出10 model = SimpleNeuralNetwork(input_size=784, hidden_size=64, num_classes=10, learning_rate=0.1) # 训练200个epoch model.train(X_train, y_train, epochs=200) # 在测试集上评估 test_acc = np.mean(model.predict(X_test) == y_test) print(f"Test Accuracy: {test_acc:.4f}")

如果数据加载正常、学习率设置合理，200个epoch之后，测试集准确率通常能够达到95%左右。这个数字放在今天当然不算惊艳，但你要知道，这里没有任何卷积结构，也没有任何复杂的正则化技巧，仅仅是一个64神经元的单隐藏层网络，就能把高维像素数据学到接近可用的水平。这也是为什么我用这个项目做教学案例的原因：它的性价比极高，能让你快速建立起对神经网络能力的认知。

如果你没接触过手写数字数据集，想快速验证代码正确性，可以用sklearn里自带的手写数字数据集，或者直接生成随机的模拟数据来调试。等代码流程确认没问题了，再换成完整的数据集跑。

4. 训练细节与调参要点

4.1 数据预处理能决定成败

很多人跑神经网络，第一反应是调整模型结构，却忽略了一个更基本的问题：数据预处理。我踩过一次很惨的坑，直接把原始图像像素值喂给网络，完全不归一化灰度值，结果是训练损失一直在高位震荡，准确率始终徘徊在60%左右。原因很简单：28x28的像素如果取0到255的原始值，加权和会轻易算出一个很大的数，再经过ReLU之后，输出值量级差异巨大，梯度也就变得非常不稳定。

正确的方法是把像素值除255，压缩到0到1之间。更进一步，可以做标准化：计算整个训练集的均值和标准差，然后每个像素减去均值再除以标准差。对于这个浅层网络来说，简单的除以255其实够用了。但如果你以后做更复杂的任务，标准化的作用会更加明显。

数据预处理的另一个常被忽略的步骤，是确保标签的数据类型正确。标签数组如果你用float来存储，后面跟one-hot编码对接时容易出现类型错误。最好在刚加载完数据就直接统一转换成int类型，一劳永逸。

4.2 学习率：神经网络最核心的超参数

学习率决定的是“每一步参数调整的幅度”。这个超参数对整个训练过程的影响，怎么强调都不为过。在我的项目里，learning_rate=0.1可以比较快地收敛，大概50个epoch就达到一个不错的准确率。你可以把学习率改成1.0试试，会发现损失直接冲上nan；改成0.001则会发现训练速度慢得让人抓狂，200个epoch后准确率还很低。

这里有一个经验法则：如果你发现损失在前期不降反升，或者剧烈震荡，那大概率是学习率设大了，先把它除以10再试。如果你发现损失下降得极慢，像蜗牛爬一样，那是学习率太小，把它乘以3到10倍再试。这个“指数搜索”的方法，比每次猜一个值去跑要高效得多。

还有一个细节：要不要用学习率衰减？在这个浅层网络里，不需要。数据量不大，训练轮次不多，固定学习率就能很好收敛。但如果你把这个结构扩展到更大的数据集，学习率衰减、或用Adam这种自适应优化器，会带来更平滑的收敛曲线。

4.3 梯度检查：验证反向传播写对没写对

写反向传播，最大的恐慌就是“代码跑起来了，但结果完全不对”。这时候就需要一个定心丸——数值梯度检查。它的原理是直接用导数的定义去近似计算梯度：

[ \frac{\partial L}{\partial w} \approx \frac{L(w + \epsilon) - L(w - \epsilon)}{2\epsilon} ]

epsilon取1e-7。你随机挑几个参数，把数值近似梯度和反向传播算出来的梯度做对比，如果相对误差小于1e-5，基本可以断定反向传播写对了。

我在调试这个项目时，曾经以为自己的反向传播天衣无缝，结果一跑梯度检查，发现输出层权重梯度误差高达0.1。追查下来，原来是忘记除以m。这个教训让我养成了一个习惯：工程实现阶段的数学推导，一定要用数值梯度检查来确认，而不是靠肉眼检查代码。这个习惯，可以说帮我省下过无数晚上。

数值梯度检查在完整的代码里可以这样集成：

def gradient_check(model, X, y, eps=1e-7): # 对某个参数做扰动，计算近似梯度 original = model.W2[0, 0] model.W2[0, 0] = original + eps loss_plus = model.compute_loss(model.forward(X), y) model.W2[0, 0] = original - eps loss_minus = model.compute_loss(model.forward(X), y) model.W2[0, 0] = original numeric_grad = (loss_plus - loss_minus) / (2 * eps) # 跟反向传播算出来的梯度对比 model.backward(X, y) analytic_grad = model.dW2[0, 0] # 需要把dW2存成对象属性 print("Numeric:", numeric_grad, "Analytic:", analytic_grad)

注意，梯度检查要在小数据上做，比如只取10个样本，否则数值近似的计算量会很大，而且训练之前的权重还没更新时检查效果最准。检查通过之后，再放大数据量开跑。

4.4 训练指标的观测策略

训练时，我习惯每一到十个epoch输出一次loss和accuracy。loss衡量的是模型整体的“错的程度”，accuracy衡量的是“对的个数占比”。理想情况下，两者同步变化。但有些情况下会看到一个奇异现象：loss在下降，accuracy却不涨，或者在小幅波动。这是正常的，因为loss和accuracy并不完全等价。比如，模型把预测概率从0.2提高到0.45，loss会下降，但只要0.45不是该样本的最大概率，准确率就不变。

所以不要只看准确率，要结合loss一起来判断模型是否在学习。还有一点要注意，如果你的训练集上准确率接近100%，但测试集上准确率不高，那就是典型的过拟合信号。在我这个浅层网络上，过拟合不太严重，但你可以手动实验：把训练数据减少到1000个样本，训练相同的epoch数，很容易观察过拟合现象。这也是理解数据量和模型容量关系的好办法。

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

5.1 训练中损失输出为nan

这是新手阶段最容易遇到的情况。原因基本围绕着“数值溢出”展开。我整理几种可能的方向供大家排查。

第一，softmax溢出。如果你的代码里没有做“减去最大值”的数值稳定化处理，当一个批次里出现一个特别大的logits值，损失计算会直接变成log(0)，也就是负无穷，或者e的大数次方变成inf。解决方法就是把softmax稳定化代码加上，大概率直接解决。

第二，学习率过大。就算softmax稳定化了，如果学习率设置成10这种飞起的数值，参数一下被更新到一个极端位置，下一轮前向传播照样会爆出大数，从而导致nan。解决方法是调低学习率，按10倍级别缩小。

第三，数据没有归一化。原始数据值域过大，造成第一层加权和经常溢出。把数据缩放到0到1之间几乎能根治这个问题。我在实际排查中，按照“softmax稳定性 -> 学习率 -> 数据归一化”这三个顺序排查，屡试不爽。

5.2 准确率长期不提升

还有一种情况是：损失在下降，但准确率卡在某个值附近，比如分类10类任务卡在10%左右，这个准确率恰好等于随机乱猜的水平。遇到这种情况，几乎可以断定是网络的“梯度流动”出了问题。

最常见的原因是激活函数选择错误。如果你用的是sigmoid而不是ReLU，那么经过多轮迭代之后，sigmoid的导数会不断把梯度削减，最终导致参数几乎不更新。另一个常见原因是隐藏层神经元数量太少，比如只有4个、8个，模型的表达能力不够，学不出有效的决策边界。还有一个隐蔽原因，是标签和损失函数之间不匹配。比如，你用了交叉熵，但标签是one-hot形式，然后又用了一个需要单整数标签的损失函数，这种类型错位会导致梯度异常。

排查方法其实不复杂：在训练10个epoch之后，可以随机挑几个样本看看网络输出的logits分布。如果所有输出都非常接近，说明模型还没分化出对各类别的判断力；如果某些输出值明显偏大，说明模型在“努力”了，只是还没收敛到位。

5.3 预测结果全变成同一个类别

这通常是模型“偷懒”的极端表现——它学会了把一切输入都预测成训练集中样本最多的那个类别。确切地说，这是类别不均衡和模型容量不足共同作用的结果。如果你训练的类别分布严重不均衡，比如90%的样本是类别0，那么一个坏模型只要无条件输出类别0，就能拿到90%的准确率。神经网络在梯度下降过程中很容易发现这个“捷径”，快速收敛到一个平庸但损失不高的解。

解决思路有两类。一类是数据层面的：对少数类样本做重采样，或者对多数类样本降采样，让类别分布不那么失衡。另一类是模型层面的：给少数类的损失加上更高的权重，让模型更重视这些“容易犯错”的样本。对于这个简单项目来说，先检查一下类别数量分布是不是均匀，通常就能发现问题所在。

5.4 为什么我的准确率低于别人

很多人在跑同样结构的网络时，发现自己的准确率总比教程里的低两三个百分点，就开始怀疑人生。这里我可以明确地说，造成这种微小差距的因素有很多：数据集的切分方式不同（有人用固定的训练测试划分，有人随机划分）、参数初始化的随机性、训练时的batch shuffle策略、甚至浮点数运算的微小差异。

一个很实用的建议是：跑三次，取平均值。因为随机初始化的不同，网络可能收敛到不同的局部最优，但优秀的模型结构会让这些“最优”之间的差距不大。如果你每次跑出来的准确率都在一个很小的范围内波动，那说明你的实现是没问题的，不用太纠结具体数值。如果你跟别人的差距特别大，比如差了五个百分点，那就要去怀疑是不是数据预处理或者某个梯度步骤写错了。

6. 这个项目还可以往哪些方向扩展

这个简单神经网络的代码虽然短，但它是一个很好的“改装平台”。我经常跟朋友说，想在机器学习上练手，与其一上来就啃复杂框架，不如在这个基础网络结构上做三次“扩展实验”。

第一个扩展方向，是增加隐藏层的数量，做一个真正的“深度”网络。把网络改成两个隐藏层、三个隐藏层，然后观察训练收敛速度和最终准确率的变化。你很快会发现一个反直觉的现象：层数增加，不一定训练更快。深了之后，优化难度和过拟合风险都在上升，需要更多的调参技巧。

第二个扩展方向，是引入正则化。加一个L2权重衰减项，或者加一个dropout层。你会发现，在小规模数据集上，正则化甚至可能降低训练集准确率，但在测试集上的泛化能力提升了。这个“训练集上差一点，测试集上强一点”的体验，能帮你直观理解机器学习的泛化本质。

第三个扩展方向，是把固定学习率换成简单的学习率衰减，或者换成mini-batch梯度下降。观察不同优化策略对损失曲线的影响，尤其是损失曲线从“震荡”变为“平滑”的过程。这会帮你理解为什么现代的深度学习框架默认用自适应优化器。

说到底，这个“基于softmax方法的简单神经网络”，好比一辆手动挡教练车。它能让你看到每个齿轮怎么咬合、每脚油门怎么起作用。等你看明白了，再切换到自动挡（也就是深度学习框架），你至少不会对底层原理一无所知。我一直认为，用框架前先用numpy手写一个神经网络，是了解深度学习最好的入门方式，没有之一。

最后分享一个小技巧：写这种项目时，记得把训练过程的损失曲线画出来。不用复杂的工具，matplotlib里几行代码就能画一条折线图。看损失曲线下降的形态，比看最终准确率数字，更能帮助你理解模型训练的动态过程。我每次调试模型，第一件事都是看曲线形状是否健康——下降平滑，说明一切正常；断崖式下跌，说明梯度爆炸；一条平线，说明模型根本在“摆烂”。这个习惯，后来陪着我走过了很多个模型调试的夜晚。