SpikingJelly单层SNN跑MNIST：LIF训练与调参实战

MNIST大概是每个接触脉冲神经网络的人都会先踩一遍的地板砖。我第一次把单层全连接SNN搭起来跑MNIST，是在啃完一堆膜电位公式之后——理论看着都懂，真到写代码的时候，卡住的地方全是细枝末节：膜电位什么时候清零、输出层要不要再接一个脉冲神经元、损失函数为什么不是交叉熵、时间步T取多少合适、权重为什么建议关掉bias。这篇文章就把这次"最小可用实验"完整摊开：用SpikingJelly搭一个只有一层全连接加一层LIF神经元的脉冲神经网络，在MNIST上跑到九成以上的准确率，把每一步的动机、参数怎么算出来的、坑在哪里，全写清楚。适合刚学完SNN基本概念想动手验证的人，也适合做过普通CNN分类、想看看脉冲版本和人工神经网络到底差在哪的人。代码可以直接抄，参数可以直接用，实验结果和失败记录我都会附上。

1. 为什么先做单层全连接SNN：一次刻意的复杂度压缩

1.1 这个实验到底在验证什么

很多人学SNN的第一步就想去搭卷积脉冲网络、去做事件相机数据、去复现某个SOTA结构，结果卡在环境、卡在张量维度、卡在时间步展开，半个月过去连一个能收敛的模型都没有。我踩过这个坑，所以现在的顺序反过来：先用最简单的一层网络把整条链路跑通，确认"数据进得去、脉冲发得出、梯度传得回、准确率上得来"，再去加复杂度。

这个实验验证的东西其实只有四件事。第一，多时间步的膜电位状态管理是否正确，包括每个batch开始前有没有正确清零、时间维度上的状态是否按预期累积。第二，替代梯度是否真的把梯度送到了权重上，这一点最能通过"准确率有没有离开随机水平"来判断。第三，输入编码方式是否和这层神经元匹配，灰度值直接作为输入电流和泊松编码在单层结构上的表现差别很大。第四，超参数的量级是否合理，tau、阈值、学习率这几个数的相对关系一旦错位，损失曲线会给出非常明确的信号。

把这四件事拆开验证，比一次性搭一个大网络要省时间得多。单层结构的好处是它的行为可以用数学近似推出来，跑出来的结果和预期不符时，你能判断是代码错了还是认知错了，而不是面对一个黑盒发呆。

1.2 单层全连接的能力边界

必须提前说清楚：一层全连接加一层LIF，在MNIST上的天花板就在九成出头。这不是调参不到位的锅，是结构决定的。

从信息处理角度看，这层网络做的事情是：把784维输入经线性映射压到10维，然后用LIF神经元在时间维度上做"积分-阈值发放"，输出的脉冲计数除以时间步T，就近似于一个属于每一类的概率。整个过程是线性变换加上一个时间上的非线性累积，本质上还是一个线性分类器，只不过决策规则从"比较logit"变成了"比较发放率"。

MNIST里那些写得潦草的数字，需要局部笔画组合、需要空间位置关系，这些是卷积层擅长的东西，一层全连接学不到。所以看到准确率在91%到93%之间徘徊，不要怀疑人生，这个数就是这套结构该有的样子。我把它当作一个"参考基准线"：以后加卷积层、加残差、换成更复杂的编码方式，拿这个数做对照，改进到底有多少，一目了然。

反过来说，单层结构也有它的好处：参数量只有7840个，训练一轮在我那张入门级显卡上几十秒就能跑完，做参数扫描的时间成本极低。想搞清楚tau和T的关系、想看清楚发放率随训练变化的过程，这种小模型是最合适的实验台。

1.3 选SpikingJelly的三个现实理由

市面上做SNN的开源库不止一个，选SpikingJelly主要基于三个很实际的原因。

一是神经元模型的实现足够透明。它的LIFNode实现的离散化方程写得很清楚， decay_input 、 v_reset 、 detach_reset 这几个开关的含义在源码里能直接读到，不想要"魔法"。做实验最怕的就是某个参数有隐藏的默认行为，你在上层怎么调都不对，最后发现是底层把输入衰减了一次。

二是它同时提供单步模式和多步模式，而且两种模式的语义一致。单步模式写起来啰嗦但调试直观，多步模式一行搞定但报错信息没那么友好。先用单步跑通逻辑，再切多步验证数值一致，这个流程对新手特别友好。

三是替代梯度的实现比较全，ATan、Sigmoid、PiecewiseQuadratic这些都能直接换，方便做对比实验。替代梯度是SNN训练能否work的核心，能低成本地换着试，比自己去实现要省太多事。

需要说明的是，下面所有代码都基于PyTorch，思路不绑定具体库，看懂了换成别的实现也一样。

2. LIF神经元与SNN的训练原理拆解

2.1 膜电位演化方程与四个必须定死的参数

LIF神经元的物理直觉很像一个漏水的桶：上面有水龙头往里注水（输入电流），桶底有个小孔往外漏（泄漏），水满到某个刻度就整个倒掉一次（发放与重置）。写成离散形式，SpikingJelly里的实现是这样：

H[t] = V[t-1] + (X[t] - (V[t-1] - V_reset)) / tau
S[t] = (H[t] >= V_threshold)
V[t] = H[t] - S[t] * V_threshold    # 当 v_reset=None，软重置
V[t] = V_reset                       # 当 v_reset 指定了数值，硬重置

把第一行整理一下，在 decay_input=False 的情况下：

H[t] = V[t-1] * (1 - 1/tau) + V_reset/tau + X[t]

这个改写很关键，它告诉你 1 - 1/tau 就是每一步保留的历史膜电位比例。tau=2的时候每步只剩50%，等效记忆长度大概两三步；tau=100的时候每步保留99%，几乎不衰减，退化成一个不带泄漏的IF神经元。

四个必须定死的参数，我按重要性排：

tau（膜时间常数） 。它决定了神经元"记多久"。这个实验里我推荐从2.0开始，这是SpikingJelly的默认值，也是官方示例的取值。原因在2.4节会算。

v_threshold（发放阈值） 。决定多难才能发一次脉冲。配合输入归一化到[0,1]和权重初始化，取1.0是个稳妥的起点。

v_reset（重置电位） 。设成0.0是硬重置，发完脉冲膜电位归零；设成None是软重置，发完脉冲只减掉阈值，保留超出部分。软重置保留了一点"余量"，理论上信息损失更小，但硬重置的行为更容易分析和调试。新手建议先用硬重置。

decay_input（输入是否衰减） 。设成False时输入X[t]原样注入，不除以tau。做静态图像的分类，我建议保持False，因为图像信息只在最开始出现一次被重复喂入，如果输入再被tau衰减，弱信号很容易根本推不动膜电位。

这四个参数一起决定了网络的发放率分布，而发放率分布又直接决定训练能不能收敛，所以别把它们当成随便填的常数。

2.2 替代梯度：脉冲为什么能反传

脉冲发放本质上是个阶跃函数，导数在阈值处是无穷大，其他地方是零。这意味着标准反向传播在这里完全失效——梯度要么爆炸要么全零，权重根本没法更新。

替代梯度的思路很直白：前向传播时用真正的阶跃函数（该发就发，该不发就不发），反向传播时偷换成一个光滑的、形状接近阶跃的函数来算导数。前向和反向用了不同的函数，所以叫"替代"。

以ATan为例，它的反向替代函数形式大致是 alpha / (2 * (1 + (alpha*|x|)^2)) 这类形状，在零点附近有较大梯度，远离零点迅速衰减。这意味着只有膜电位接近阈值的那些神经元能获得有效的梯度信号，离阈值很远的基本学不到东西——这其实很符合直觉，一个离发放差很远的神经元，你很难说它"应该"往哪个方向调。

实操中有两个开关值得记住。 detach_reset=True 表示反向传播时不考虑重置过程的梯度，等于把重置当成一个常数操作。这个选择能显著降低梯度计算的复杂度和不稳定性，默认开启是有道理的，我在这个实验里也保持默认。另一个是替代函数的 alpha 或 spiking 参数，控制替代曲线在零点附近的陡峭程度，取值偏大时梯度更集中，偏小时更平滑，收敛更稳但学得慢。新手阶段建议别动，用默认值。

有个现象要提前打预防针：SNN的损失曲线通常比普通CNN抖得厉害。因为发放是离散事件，一个小扰动可能让某个神经元多发或少发一个脉冲，输出就跳一下。看到loss上下浮动不要急着认定是bug，看趋势就行。

2.3 编码方式：直接编码为什么在这个实验里更合适

SNN的输入必须是时间序列，而MNIST是静态灰度图，中间需要一个编码环节。常见的有两种。

泊松编码 ：把每个像素归一化到[0,1]，当作每一步发放脉冲的概率，每一步独立采样。优点是物理上更"像"真实的脉冲输入，稀疏性好；缺点是引入了随机噪声，同一个样本每次前向的输入都不一样，训练时loss抖动会明显增大，而且在单层结构上准确率往往不如直接编码。

直接编码 ：把归一化后的灰度值直接当作输入电流，在T个时间步里重复注入同一张图。它不产生真正的0/1输入，输入是模拟量，但第一层神经元的输出是真正的脉冲。这种做法在静态图像任务上性价比最高，实现简单、无随机性、可复现性好。

这个实验我选直接编码，理由很实在：单层网络的容量已经很小了，再叠加编码噪声，学到的信息会被进一步稀释；而且直接编码便于分析——同一张图重复T次，每步注入的电流完全相同，膜电位会稳定在一个周期性发放的状态，发放率就是输入强度的单调函数，行为可预测。

顺带说一个容易被忽略的点：输入必须归一化到[0,1]。如果直接把0到255的原始像素值喂进去，膜电位每步会被加上几十上百，第一步就全部超过阈值，所有神经元同步满速发放，输出恒定，梯度全废，准确率永远停在10%。这个坑我在第一次跑的时候踩过，排查了半天才发现是忘了除以255。

2.4 时间步T、精度和算力的三角关系

这里做点估算，把几个参数的相对关系说清楚。

假设输入某个像素归一化后是0.5，对应权重初始量级约0.02到0.05（PyTorch的kaiming初始化对784输入会给出这个量级），那么单步注入电流大约是0.01到0.025。看着很小，但网络会自己学，训练后权重会涨到能推动膜电位的量级。

关键在时间维度上的累积。因为同一张图被重复注入T次，膜电位在tau=2时的稳态值是单步输入的约tau倍（严格说是 X / (1/tau) 即 X * tau ）。如果训练后的有效输入强度刚好在阈值附近，神经元就会以接近50%的发放率周期发放。这个"输入强度 → 稳态膜电位 → 发放率"的映射，就是网络做分类的依据。

T取多大合适？我的经验是T=100对MNIST单层结构已经足够。理由：当tau=2时，膜电位对历史的有效记忆只有几步，理论上T=20就能让发放率稳定下来。但实际训练中，T大一些能让发放计数的统计更平滑，量化误差更小（发放率的分辨率是1/T）。T=20时，10个输出神经元的发放计数只能取0到20的整数，分类边界很粗；T=100时分辨率提高到1%，准确率能多出一两个点。

算力方面，单层全连接的乘加次数约等于 T × 784 × 10 = 784000 次每样本。对比一个普通的两层CNN，这个量小到可以忽略。真正的开销在反向传播：T=100意味着计算图要展开100层，显存里要保存每一步的膜电位和输入。单层结构下这部分开销是 T × batch × 10 个浮点数，batch=128时大约是100 × 128 × 10 × 4字节 ≈ 512KB，完全不是问题，但换成卷积结构后这个数会涨几百倍，那时候T的选择就变成显存和精度的直接权衡了。

所以我的建议：单层实验可以放心用T=100，等换到卷积结构时再回头考虑把T压到20到30，配合数据增强或者更大的batch来补精度。

3. 从零跑通：环境、数据与训练循环

3.1 环境准备与版本注意点

依赖很简单：PyTorch、torchvision、SpikingJelly，加一个tqdm看进度。版本上我踩过一次坑——SpikingJelly的API在不同版本之间有过调整，尤其是 activation_based 模块的内部结构。稳妥的做法是装一个较新的稳定版本，然后把导入路径写死成下面这样，跑不通就先去查对应版本的文档，别硬猜。

pip install torch torchvision
pip install spikingjelly
pip install tqdm

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from spikingjelly.activation_based import neuron, functional, surrogate, layer

数据这块，MNIST第一次运行会自动下载，记得把 root 指到一个有写权限的目录。如果机器不能联网，就提前把四个gz文件放进去，路径结构保持原样即可。

设备选择上有一点要注意：SNN的时间循环在CPU上跑会很慢，T=100、6万张图、每轮100个时间步的前向加反向，CPU大概要几十分钟一轮。有一张入门级显卡就够，显存占用很小。

3.2 网络定义：一行全连接加一层LIF

网络结构真的只有两行：

class SingleLayerSNN(nn.Module):
    def __init__(self, tau=2.0, v_threshold=1.0, v_reset=0.0):
        super().__init__()
        self.fc = nn.Linear(28 * 28, 10, bias=False)
        self.lif = neuron.LIFNode(
            tau=tau,
            decay_input=False,
            v_threshold=v_threshold,
            v_reset=v_reset,
            surrogate_function=surrogate.ATan(),
        )

    def forward(self, x):
        # x: [N, 784]，单步模式下一次喂一个时间步
        return self.lif(self.fc(x))

两个设计决定需要解释。

为什么不加bias 。偏置项相当于给每个输出神经元一个恒定的背景电流，无论输入是什么都在往膜电位里灌水。结果是即使输入全黑，神经元也会周期性发放，输出不再是"输入强度的函数"，稀疏性被破坏，训练早期的梯度信号也会被这个常数项主导。关掉bias之后，全零输入对应零发放，映射关系干净。这个细节在文献里经常被一笔带过，但它对训练稳定性的影响很直接。

为什么输出层就是LIF本身，后面不再接别的 。因为我们要的就是脉冲。输出10个神经元的脉冲计数，除以T得到0到1之间的发放率，取最大值对应的类别就是预测结果。如果后面再接一层线性层或者softmax，就把脉冲又变回模拟值了，等于放弃了这个结构最本质的东西。

还有一个隐藏要点： nn.Linear 在单步模式下可以直接用，因为它的输入维度是 [N, 784] ，形状正常。如果你后面要切多步模式，就必须换成 layer.Linear ，这点在3.4节说。

3.3 训练循环的骨架与状态重置

这是整个实验里最容易出错的地方。完整代码：

def train_one_epoch(net, loader, optimizer, device, T=100):
    net.train()
    total_loss, correct, total = 0.0, 0, 0
    for img, label in loader:
        img = img.to(device).flatten(1)   # [N, 784]
        label = label.to(device)
        optimizer.zero_grad()

        # 关键：每个 batch 前清空所有神经元的膜电位
        functional.reset_net(net)

        out_spikes = torch.zeros(img.shape[0], 10, device=device)
        for t in range(T):
            out_spikes = out_spikes + net(img)

        # 发放率与 one-hot 目标做均方误差
        firing_rate = out_spikes / T
        target = F.one_hot(label, 10).float()
        loss = F.mse_loss(firing_rate, target)

        loss.backward()
        optimizer.step()

        total_loss += loss.item() * img.shape[0]
        correct += (firing_rate.argmax(1) == label).sum().item()
        total += img.shape[0]
    return total_loss / total, correct / total

几个点逐条说。

functional.reset_net(net) 必须放在每个batch的最前面，且必须在 zero_grad 之后、前向之前。 它的作用是把所有脉冲神经元的膜电位 v 重置到初始值。如果不调用，上一个batch的膜电位会残留下来，成为下一个batch的初始状态。后果是：训练早期看起来还行（因为膜电位累积得不多），训练中后期膜电位越来越高，所有神经元一直处于过阈值状态，输出全是常数，准确率崩掉。我第一次跑就栽在这，表现是loss先降后剧烈震荡，最后准确率跳到10%附近。

损失函数用MSE而不是交叉熵。 输出是10个0到1之间的发放率，直接和one-hot目标比均方误差，语义是"让正确类别的发放率靠近1，错误类别靠近0"。交叉熵也能用，但需要先过softmax或者加个极小值防止log(0)——发放率完全为0的类别在训练早期很常见，一取对数就是-inf，梯度会直接爆。MSE在这个任务上收敛更稳，没什么好纠结的。

firing_rate.argmax(1) 求准确率。 注意是要在累积完之后算，不能每个时间步单独算再平均，那样会低估性能，因为单步的脉冲计数方差很大。

验证阶段必须切到 net.eval() 并且同样调用 reset_net 。 另外记得用 torch.no_grad() 包起来，不然显存会一路涨上去。

3.4 多步模式改写与速度对比

单步循环写起来清楚，但Python层的for循环跑100次，效率确实一般。SpikingJelly提供了多步模式，把时间维度变成一个显式的张量维度，让框架内部去处理。

改写方式是先把网络里的模块换成 layer 版本：

class SingleLayerSNNMultiStep(nn.Module):
    def __init__(self, tau=2.0):
        super().__init__()
        self.fc = layer.Linear(28 * 28, 10, bias=False)
        self.lif = neuron.LIFNode(
            tau=tau, decay_input=False,
            v_threshold=1.0, v_reset=0.0,
            surrogate_function=surrogate.ATan(),
        )

    def forward(self, x_seq):
        # x_seq: [T, N, 784]
        return self.lif(self.fc(x_seq))   # [T, N, 10]

训练循环相应改成：

functional.set_step_mode(net, 'm')

functional.reset_net(net)
x_seq = img.unsqueeze(0).repeat(T, 1, 1)      # [T, N, 784]
out_seq = net(x_seq)                          # [T, N, 10]
firing_rate = out_seq.sum(0) / T
loss = F.mse_loss(firing_rate, F.one_hot(label, 10).float())

repeat 会把同一张图在时间维度上复制T份，这正好对应直接编码的语义。如果你用泊松编码，这里就换成一个按时序采样的过程，不能直接repeat。

我实测下来，多步模式比单步循环快大概一倍多一点，具体取决于T和batch大小，T越大差距越明显。但多步模式的报错信息不够友好，形状对不上时经常只给一个维度不匹配的泛型错误，所以我的建议是：先用单步跑通，确认准确率到预期，再切多步做加速，切换后对比前几十个batch的loss曲线，确认数值一致（允许浮点误差级别的小差异），再正式训练。

有一个细节要注意： set_step_mode 对 nn.Linear 不生效，只有 layer.Linear 这类专用模块才认这个模式。混用会得到一个形状错误，而且不容易看出来原因。

3.5 我的实测结果与曲线解读

配置：Adam优化器，学习率1e-2，batch size 128，T=100，tau=2.0，v_threshold=1.0，硬重置，ATan替代梯度，训练10轮。在我这张入门级显卡上，一轮训练大概一分多钟。

结果大致是这样：第一轮结束测试准确率能到85%左右，第三轮接近90%，第五轮之后基本稳定在91%到93%的区间，后面几轮只是小幅波动。训练损失从第一轮的0.05左右降到0.01附近，验证损失在0.012左右走平。

几条曲线特征值得记一下。

训练损失下降非常快，前200个batch就完成了大部分下降。这是因为单层网络的参数少、优化空间简单，加上MSE的梯度尺度比较直接。

准确率曲线有明显的台阶感，不是平滑上升。这和发放的离散性有关：某些类别的发放率分布需要训练到一定程度才会跨过决策边界，跨过去的时候准确率会跳一下。

不同随机种子之间，最终准确率会有1到2个点的波动。这不是训练不稳定，是小模型在这个任务上的正常方差。做对比实验的时候，同一个配置至少跑三个种子取平均，单次结果没有参考价值。

如果你是第一次跑，而准确率停在88%左右上不去，先别急着改结构，去4.3节看看那几个提升手段，通常能补回来两个点。

4. 调参实录：单层网络的性能天花板在哪

4.1 超参数敏感度排序

我按"改动后准确率变化幅度"排了个序，这个顺序和你直觉里可能的不太一样。

第一位是 学习率 。1e-2到1e-3之间是个比较宽的好区间，1e-1会直接发散（loss变NaN或者准确率贴地），1e-4收敛太慢，10轮根本跑不完。单层网络对学习率的容忍度其实挺高的，只要别跨量级。

第二位是 时间步T 。T=20时准确率大概在88%到89%，T=50大概90%到91%，T=100能到91%到93%。再往上加到200，收益就很小了，因为发放率的分辨率提升有限，而训练时间翻倍。

第三位是 tau 。这个参数容易被低估。tau=2时表现最好，tau调到8以上开始明显变差，准确率掉到87%到89%。原因在2.4节算过：tau大了之后膜电位几乎不泄漏，累积过度，所有神经元都很容易饱和发放，输出区分度下降。这一点和很多人"tau越大记忆越长越好"的直觉相反。

第四位是 v_threshold 。它在0.5到2.0之间变化，影响不算剧烈，但和tau有耦合。阈值调低相当于所有神经元更容易发，整体发放率上去了，区分度反而下降。我试过0.5和1.0，差距大概0.5个点。

第五位是 替代函数类型 。ATan和Sigmoid在我这个配置下差别不到0.5个点，PiecewiseQuadratic略差一点。这个真的不用纠结，用默认的ATan就行。

4.2 一组可复现的参数扫描记录

下面这张表是我实际跑出来的一组记录，每个配置训练10轮，单次结果，仅供参考量级和趋势。不同硬件和随机种子会有波动，别把具体数字当金标准。

配置	T	lr	tau	v_threshold	测试准确率
基准	100	1e-2	2.0	1.0	92.1%
小时间步	20	1e-2	2.0	1.0	88.4%
中等时间步	50	1e-2	2.0	1.0	90.7%
大时间步	200	1e-2	2.0	1.0	92.6%
学习率偏小	100	1e-3	2.0	1.0	90.3%
学习率偏大	100	5e-2	2.0	1.0	89.6%
泄漏过快	100	1e-2	1.2	1.0	90.1%
泄漏过慢	100	1e-2	8.0	1.0	87.9%
阈值偏低	100	1e-2	2.0	0.5	91.5%
阈值偏高	100	1e-2	2.0	2.0	91.8%
软重置	100	1e-2	2.0	1.0	92.3%

从表里能读出几件事。T的收益在100之后基本饱和，200只多了0.5个点而训练时间翻倍，性价比很差。tau的窗口比较窄，1.2到8这个范围里，两端都不好，2附近是甜点。软重置比硬重置略好一点点，但在误差范围内，不值得为此增加理解成本。

4.3 提升准确率的四个实操手段

结构不变的前提下，还有几个手段能实打实地把准确率往上推。

第一个是输入归一化方式。 除了标准的除以255，可以试试对每个样本再做一次均值归一化，也就是减去整个batch的均值。这相当于把输入电流的直流分量去掉，让神经元更多响应相对差异而不是绝对亮度。我试过，能稳定多出0.3到0.8个点。但要注意，减均值之后输入有正有负，负电流会让膜电位往下走，理论上没问题，实测也稳定，只是初次接触可能会觉得别扭。

第二个是权重初始化。 默认的kaiming初始化对784输入会给出很小的初始权重，前几个batch膜电位涨得很慢，相当于浪费了训练步数。我换成手动初始化，标准差取0.05左右，收敛速度快了一些，最终准确率也有小提升。这个值没有理论支撑，是试出来的，换任务就得重新试。

第三个是学习率先大后小。 前5轮用1e-2，后5轮降到2e-3，准确率比全程恒定能高0.5个点左右。原因是训练后期需要更细的调整，而恒定的学习率会让发放率在目标附近来回跳。

第四个是T的配合调整。 如果你为了省时间把T压到20，那就要相应地把学习率调小一点，因为每个batch的有效梯度信号变弱了。T和学习率是耦合的，不能单独调一个。

反过来，有几件事我试过但没用：给网络加Dropout（脉冲本来就是稀疏的，再drop会让某些类别在整轮里完全没输出，反而伤准确率）、用更大的batch（128已经够，加到512准确率降了）、换更复杂的替代函数（差别在噪声范围内）。

还有一点得老实说：以上所有手段加起来，准确率上限也就在93%附近。想要再上去，唯一的路是改结构，加卷积层或者堆叠多层。这就是下一章的事。

5. 踩坑与排查：那些让准确率停在10%的问题

5.1 症状一：准确率长期贴在随机水平

这是最常见也最打击人的一类问题。训练十几轮，准确率一直在10%上下晃，loss几乎不降。

第一个要查的是 functional.reset_net(net) 有没有调用。没有它，膜电位会在整个训练过程中持续累积，到了几百个batch之后，所有神经元的初始膜电位都远超阈值，第一步前向就全部发放，输出变成常数，梯度全零。判断方法很简单：在训练循环里打印某个LIF节点的 v 的均值，正常情况下它应该每轮都从接近0开始，如果看到它一直在涨，就是这个原因。

第二个要查的是输入有没有归一化。前面说过，原始0到255的像素值进网络，第一步就把膜电位打到天上去了。判断方法是打印第一步之后 v 的均值，超过10基本可以确定是这个问题。

第三个要查的是替代梯度有没有接上。有一种错误写法是前向的时候用 torch.heaviside 或者 (v > threshold).float() 自己实现发放，反向的时候没有挂替代函数，这样梯度全是零，网络完全学不动。用框架提供的 neuron.LIFNode 不会有这个问题，但如果你自己手写神经元，一定要确认替代函数挂上了。

第四个要查的是标签和输出有没有错位。 F.one_hot(label, 10) 的维度是 [N, 10] ，输出的发放率也是 [N, 10] ，两者要能对上。曾经有一次我把 img.flatten(1) 忘了写，输入是 [N, 1, 28, 28] ， nn.Linear 报了个形状错误，但如果用了 view 之类的操作又恰好凑出了正确形状，就会导致数据完全错乱，表现也是准确率贴地。

5.2 症状二：训练损失正常但测试崩

训练集loss降到0.01，测试准确率只有20%，这种一般是过拟合，但小模型上过拟合来得这么猛，通常另有原因。

检查验证阶段有没有调用 reset_net 。很多人只在训练循环里加了，验证时忘了。结果是验证的第一个batch用的是训练最后一个batch残留的膜电位，后面每个batch继续累积，越到后面越离谱，最终准确率反映的完全不是模型能力。

检查有没有用 net.eval() 。这个模型里没有Dropout和BatchNorm，理论上切换eval模式不影响结果，但养成习惯没坏处。真要排查的话，可以在验证前后各打印一次膜电位分布，看是否有异常。

还有一个不太容易发现的原因：测试集的预处理和训练集不一致。比如训练时用了 ToTensor() （自动除以255），测试时忘了加同一个transform，输入量级差255倍，直接崩。

5.3 常见问题速查表

症状	最可能的原因	处理方式
准确率长期约10%	未调用 reset_net ，膜电位跨batch累积	每个batch前向之前调用一次
准确率长期约10%	输入未归一化到[0,1]	加 ToTensor() 或手动除以255
准确率长期约10%	自定义神经元未挂替代梯度	改用框架的 LIFNode
loss变成NaN	学习率过大，或交叉熵遇到log(0)	降学习率，或改用MSE
训练loss正常，测试极低	验证时忘记reset或预处理不一致	检查两处
输出全是0或全是最大发放	膜电位饱和，tau过大或权重初始化过大	降tau，检查初始化
准确率卡在88%上不去	T太小或学习率不合适	T提到100，lr调到1e-2
训练一轮要很久	单步循环开销大	换多步模式，或用更小的T
不同次运行结果差3个点	随机种子未固定	固定torch、numpy、cuda的种子
显存缓慢增长	验证阶段没加 no_grad	加上 torch.no_grad()

固定随机种子的写法，我一般这么干，放在所有训练之前：

import torch, numpy as np, random
def set_seed(s=42):
    random.seed(s)
    np.random.seed(s)
    torch.manual_seed(s)
    torch.cuda.manual_seed_all(s)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

注意最后两行会稍微降低运行速度，做对比实验的时候值得，正式训练可以关掉。

还有一条非常实用的排查经验： 把T临时设成1跑一遍 。如果T=1时准确率已经有30%左右，说明前向链路基本是通的，问题在时间维度的状态管理上；如果T=1时准确率还是10%，那问题一定在网络定义或者输入上。这个二分法能省掉大量猜测时间。

6. 这个基线能带到哪去：影响范围与扩展路径

6.1 把它当基准线的价值

一个只有7840个参数的模型，能有什么用？我的看法是，它的价值不在准确率，在它提供的那条对照曲线。

之后无论你换成双层全连接、换成卷积脉冲网络、换成带反馈的连接结构，都可以拿这个92%左右的数作为起点，看改进是不是真的存在。很多论文里报告的提升，如果不能在这个最简基线上复现出来，那大概率是训练技巧或者超参数搜索带来的，跟结构创新没什么关系。自己手里有个干净的基线，判断力会强很多。

另外这套代码还提供了一个"最小可调试单元"。SNN的训练出问题时，排查路径通常很长，从数据到编码到神经元到梯度到损失，每一环都可能出问题。把问题缩小到这个单层结构上，一次只动一个变量，定位速度会快很多。我在换成卷积结构之后遇到的几乎所有疑难杂症，都能在这个单层版本上复现出简化版，然后再回去修。

6.2 扩展到多层与卷积的迁移要点

往多层走的时候，有几个地方必须改，改了才不会翻车。

层与层之间要加非线性。 如果只是 Linear → Linear → LIF ，两个线性层之间没有非线性，等价于一个线性层，白加。正确的做法是每一层线性后面都接一个LIF， Linear → LIF → Linear → LIF ，脉冲本身提供了非线性。

中间层的维度不要一下子砍太狠。 从784直接降到10，跨度太大。多层版本一般是784 → 256 → 10，或者干脆用卷积。

卷积版本要换成 layer.Conv2d 。 如果用多步模式，必须用 layer 里的卷积， nn.Conv2d 不认时间维度。

池化要用脉冲友好的方式。 普通最大池化在脉冲上不好直接用，一般用平均值池化或者直接步长卷积降采样。

训练深度SNN时很容易遇到梯度消失或爆炸。 这时候可以试试加BatchNorm（SpikingJelly里有对应的时序BN），或者把替代函数的陡峭度调小一点，让梯度分布更平滑。

迁移的时候建议的路径是：先改结构但保持T=100不变，确认能收敛，再慢慢把T降下来换速度。反过来做（先降T再改结构）会让你分不清是结构问题还是时间步不够。

6.3 硬件与能耗视角下的实际意义

单层全连接SNN跑MNIST这个实验，从能耗角度看其实是有点"没意义"的：它的计算量太小，稀疏性带来的收益体现不出来，而且在通用GPU上，脉冲的0/1特性并不会自动转化成加速——GPU该做的乘加一次都没少。

它真正的意义在思路上。SNN的计算范式是"事件驱动 + 累积 + 阈值判断"，不做乘法，只做加法，而且大部分时间神经元是静默的。当网络规模上去、输入变成事件流（比如动态视觉传感器输出的稀疏事件）时，这种范式的优势才会显现：能量消耗正比于实际发生的脉冲数量，而不是固定的乘加次数。

所以把这个小实验做扎实，是为了理解后面那些大规模场景里的取舍：为什么要控制发放率、为什么稀疏性是设计目标而不是副作用、为什么时间步T在硬件上是直接对应延迟和能耗的。这些问题在MNIST上看着抽象，等真正部署到边缘设备上，就变成非常具体的工程约束了。

最后分享一个我自己养成的习惯：每跑完一个配置，把超参数、随机种子、最终准确率、训练耗时记到一个表里，不要靠记忆。SNN的随机性比普通网络大，跑十次能出七八个不同的数，没有记录的话，两天之后你就不记得哪个数对应哪个配置了。这份记录积累到二三十行的时候，你对这套结构的直觉就建立起来了，比看十篇教程都管用。