脉冲编码(address-event representation)

可视化演示

演示地址事件表示(AER)异步握手编码、多源脉冲仲裁与时序保序，以及DVS事件驱动传感器的稀疏事件流输出。

AER基本概念：一张快递单的世界

假设你管理着神经之城唯一的邮政系统。每天，几百万神经元居民会突然兴奋——“我要寄快递！”你不可能派人守在每户门口蹲点，也不该每天把整座城所有人的动静录成胶片循环播放。神经之城用的是一套“快递单系统”：谁要寄件，就在单子上写下门牌号（发件地址）与寄件时刻（时间戳），单子投进传送带即可。收件端看到单子，便知道“3号街的李四在t=3.2微秒时兴奋了一下”。

在神经形态芯片里，这套“快递单”叫AER事件。每个事件是一个二元组：

$$\displaystyle e_i = (a_i, t_i)$$

其中 \(a_i\) 是发放脉冲的神经元在芯片中的唯一地址——可以是一维编号，也可以是二维坐标展平后的编码；\(t_i\) 是该脉冲发生的时间戳。所谓脉冲编码（Address-Event Representation），本质就是只编码“谁在何时发放了脉冲”，不携带波形、幅度等冗余信息——神经脉冲的波形千篇一律，真正承载信息的是发放地址与发放时刻。

AER高效的根本原因，在于利用了大脑的稀疏性：任何瞬间，一块组织中活跃的神经元占比通常只有约1%~5%。既然绝大多数居民根本没寄件，“事件驱动、有就传、没有就安静”的方案，天然比“每帧全量广播”更省带宽、更省功耗。需要强调的是，AER不是神经网络训练算法，而是芯片与芯片、核与核之间的通信协议——它回答的问题从来不是“这条脉冲意味着什么”，而是“这条脉冲如何低成本、保真地送达”。

理解了“快递单”的哲学，就能明白为什么AER能成为Loihi、TrueNorth等类脑芯片的标准通信方式：它把整个城市的喧嚣，压缩成几张轻飘飘的纸片，却完整保留了因果信息。

1. 事件标识 \(e_i\)：表示神经形态系统中第 \(i\) 个脉冲事件，每个事件是通信的最小基本单位。

$$\displaystyle e_i$$

2. 地址分量 \(a_i\)：发放该脉冲的神经元在芯片中的唯一编号，用来指明“谁”发出了这个事件。

$$\displaystyle a_i$$

3. 时间戳分量 \(t_i\)：该脉冲发生的时刻，由硬件计数器统一记录，用来指明“何时”发出。

$$\displaystyle t_i$$

---

异步通信原理：预约制传送带

传送带建好了，但居民怎么把快递单交上去？神经之城的规矩是“预约制”：寄件人先按一下传送带入口的铃（Request），调度员确认入口空闲后回一个“可以放”的手势（Acknowledge），寄件人这才把单子放上带。整个过程没有固定的班车时刻表——任何时刻都可能有人按铃，传送带随时在跑。

这正是AER异步通信的核心：请求-应答握手协议。发送方将请求信号Req拉高，接收方准备好后拉高应答信号Ack，发送方看到Ack后撤销Req，一轮事件传输完成。每个事件都经历这样的四相握手，吞吐可达数百M事件/秒。因为没有全局时钟，芯片不需要庞大的时钟树同步，这在超大规模芯片上省下大量功耗与面积。

共享总线是AER降低布线成本的关键。\(N\) 个神经元两两直连需要 \(O(N^2)\) 条线路，而共享总线只需 \(\log_2 N\) 根地址线加几根握手线。例如一个16K神经元的核，两两直连需要超过一亿条连线，而AER总线只需约14根地址线加Req/Ack。但总线容量有限，事件流量必须满足约束：

$$\displaystyle \sum_{k=1}^{M} C_k \cdot f_k \leq B_{\mathrm{bus}}$$

式中 \(C_k\) 是第 \(k\) 个神经元每个事件平均占用总线的时间片数，\(f_k\) 是其发放频率，\(M\) 是神经元总数。一旦总流量超过带宽，事件就会排队积压，甚至溢出丢失。

“预约+共享传送带”的设计，让一座百万人口的神经之城不需要铺百万条专线，只需一条高效快车道——这就是异步协议对布线成本的解放。

1. 总事件流量：遍历所有神经元，将每个源的事件率乘上其占用时间片后累加，得到所有源对总线的总流量需求。

$$\displaystyle \sum_{k=1}^{M} C_k \cdot f_k$$

2. 带宽约束不等式：总流量必须小于等于总线服务能力 \(B_{\mathrm{bus}}\)，否则事件会排队积压甚至丢失，通信实时性无法保证。

$$\displaystyle \leq B_{\mathrm{bus}}$$

---

硬件实现部件：分拣中心的四道工序

有了规则，还得有物理设施。神经之城的快递单要经过四道工序：收集（居民把单子投进管道）、贴标（给单子印上地址码）、过闸（调度员放行）、暂存（高峰期单子在仓里排队等候）。

对应到硅片上，AER发送端硬件主要由四部分组成。事件检测电路监视神经元的膜电位，一旦超过发放阈值便产生脉冲事件；地址编码器把神经元的空间坐标映射为二进制地址码；仲裁器电路在多个同时请求的事件中裁决谁先使用总线；FIFO缓冲在总线繁忙时暂存事件，防止溢出丢失。其中地址编码是最典型的“贴标”操作，一个位于二维阵列 \((x_i, y_i)\) 的神经元，用线性化公式编码为唯一地址：

$$\displaystyle a_i = x_i \times N_y + y_i$$

其中 \(N_y\) 是阵列高度（行数）。接收端可由此反解出神经元的真实坐标，把“3号传送带第7格”还原为“神经地图上的第3层第7列”。

事件检测电路本质是比较器加数字转换：当膜电位跨过阈值，锁存器记录时刻并触发握手。地址编码器则是一棵优先级编码树，能把128×128阵列中16K个坐标压缩成14位二进制码。FIFO深度是工程权衡——太浅则高峰丢事件，太深则增大延迟与面积，通常取“总线最坏等待时间×峰值事件率”来估算容量。

正是这些“管道、贴标机、闸口、暂存仓”各司其职，快递单才能在传送带上飞驰而不出错——硬件实现的本质，就是把AER协议翻译成高速可靠的电路语言。

1. 行坐标与列坐标：神经元在二维阵列中的位置用 \((x_i, y_i)\) 表示，\(x_i\) 是行号，\(y_i\) 是列号。

$$\displaystyle x_i, \quad y_i$$

2. 行偏移量：每行有 \(N_y\) 个神经元，行号乘以 \(N_y\) 得到该行的起始地址。

$$\displaystyle x_i \times N_y$$

3. 一维地址合成：行起始地址加上列号得到唯一地址，接收端可由此逆推二维坐标。

$$\displaystyle a_i = x_i \times N_y + y_i$$

---

仲裁机制：调度员的艺术

现在到了最微妙的环节。清晨高峰，几十个居民同时把快递单塞进闸口，调度员必须在瞬间决定谁先上带。如果永远让1号街优先，9号街的急性子就要暴动；如果挨个轮流，又可能让刚需加急的单子等太久。

仲裁器就是这位调度员。最简单的轮询仲裁维护一个旋转指针，每次从上一优先级加一的位置开始查找请求者，让所有源获得均等服务机会，实现简单、无饥饿。但它不看事件紧急程度——高速事件源与低速源待遇相同，突发流量下延迟会波动。优先级仲裁则允许为特定源设置更高优先级，保证关键路径（如报警信号）的低延迟，但低优先级源可能长期得不到服务，即“饿死”。

无论哪种策略，仲裁器都必须保证同一时刻总线上只有一个事件——这是冲突避免的底线。带宽分配的本质是给请求者“分时间片”，让高优先级源等效带宽更高，同时为低优先级源设置服务上限以避免完全饿死。平均仲裁延迟可写为：

$$\displaystyle \bar{d}_{\mathrm{arb}} = \frac{M}{2W} \times \frac{1}{1 - \rho}$$

其中 \(M\) 是等待仲裁的事件数，\(W\) 是总线服务率（时间片/秒），\(\rho = \sum f_j / W\) 是总线利用率。直观地说，等待的事件越多、总线越繁忙，仲裁延迟就越大；当利用率接近1时，延迟将急剧恶化。

一位好调度员，既不能堵死关键件，也不该饿着偏远街区。AER的仲裁设计，正是在公平、优先级、延迟之间反复权衡的调度艺术。

1. 平均队列延误项：\(M / (2W)\) 表示在服务率 \(W\) 下，队列中 \(M\) 个事件平均等待的基础时间。

$$\displaystyle \frac{M}{2W}$$

2. 利用率修正因子：\(1 / (1-\rho)\) 反映总线越拥堵延迟越被放大，当利用率趋近1时延迟趋于无穷。

$$\displaystyle \frac{1}{1 - \rho}$$

3. 平均仲裁延迟：两部分的乘积就是事件在仲裁阶段的平均等待时间，是评估调度质量的核心指标。

$$\displaystyle \bar{d}_{\mathrm{arb}}$$

---

时序保序：快递单的先后顺序

快递单终于到对岸了。收件城市打开一叠单子，最怕什么？顺序乱了。如果“5分钟前的脉冲”和“1秒前的脉冲”被当作同一时刻处理，对岸重建出的神经活动就是一场灾难——就像收到一堆乱序的拼图，永远拼不出原画面。

时间戳是每个AER事件的灵魂。它由发送端片上全局计数器统一标记，记录脉冲发放的硬件时刻。接收端利用时间戳把乱序到达的事件按时间重排，重建出与原始脉冲序列时间结构等价的输出，这个过程叫时间戳重建。但重建依赖一个前提：事件携带的时间戳与真实发放顺序一致，即因果顺序不颠倒。

保障时序，就要控制事件从产生到送达的端到端延迟，它由三部分组成：

$$\displaystyle \Delta t = t_{\mathrm{recv}} - t_{\mathrm{send}} = d_{\mathrm{queue}} + d_{\mathrm{arb}} + d_{\mathrm{bus}}$$

其中 \(d_{\mathrm{queue}}\) 是FIFO排队延迟，\(d_{\mathrm{arb}}\) 是仲裁等待延迟，\(d_{\mathrm{bus}}\) 是总线传输延迟。高优先级插队会让先到者反而晚达，破坏时间戳单调性。因此，很多AER路由器采用“按时间戳排序的优先队列”，或在网络层丢弃乱序事件。值得强调的是：延迟的一致比延迟的大小更重要——所有事件经历相近延迟，则相对时间关系保真；延迟差异大，即使平均延迟低，相对时序也已失真。

所以神经之城在收件端还要设一个“排序台”：宁可让所有包裹多等半秒，也绝不让先寄出的包裹后到。

1. 端到端延迟定义：\(t_{\mathrm{send}}\) 是脉冲产生的硬件时刻，\(t_{\mathrm{recv}}\) 是接收端读出事件的时刻，两者之差即总延迟。

$$\displaystyle t_{\mathrm{recv}} - t_{\mathrm{send}}$$

2. 排队延迟 \(d_{\mathrm{queue}}\)：事件在FIFO缓冲中等候的总时长，与队列深度和上游到达率相关。

$$\displaystyle d_{\mathrm{queue}}$$

3. 仲裁与传输延迟：仲裁等待与总线传输耗时之和，构成端到端延迟的另外两个分量。

$$\displaystyle d_{\mathrm{arb}} + d_{\mathrm{bus}}$$

---

多芯片扩展：从城镇到都市群

一座城装不下一亿个神经元了。市长决定：建一群城市，城市间用高等级公路连接。居民寄快递，先寄到本城枢纽，再由长途车跨城转运——这就是AER从单芯片走向多芯片系统的方式。

多芯片系统用AER路由器把多个芯片连成网络。路由器接收上游芯片的事件包，解析地址，按路由表决定转发到哪个下游端口。典型拓扑是树形或网格，Loihi、达尔文等芯片都采用分级路由：核内总线、核间片上网络（NoC）、芯片间高速串行接口，从而把总神经元规模从单芯片的数千扩展到数亿。系统总带宽需求是所有芯片事件率之和：

$$\displaystyle B_{\mathrm{total}} = \sum_{m=1}^{M} \sum_{k=1}^{N_m} f_{m,k}$$

其中 \(M\) 是芯片数，\(N_m\) 是第 \(m\) 个芯片的神经元数，\(f_{m,k}\) 是第 \(m\) 个芯片第 \(k\) 个神经元的事件率。这个公式说明：多芯片系统的瓶颈从来不是单芯片峰值，而是所有芯片“同时兴奋”时的总事件流。

扩展带来两大挑战：布线拥塞与共享瓶颈。根节点和上游链路是天然拥塞点，因此可扩展AER使用多路并行总线、压缩编码（地址增量压缩、时间戳差分压缩）与虚拟通道提升有效带宽。压缩的本质是挖掘事件流中的冗余——相邻事件地址往往相近，时间戳增量小，只传差值即可省近一半带宽。树形拓扑在根节点部署高带宽交叉开关，星形互联则用中心路由做全局仲裁。实际中，Loihi 2用片上网络集成128个神经形态核，并通过AER背板连接多芯片。

从一条传送带的小镇，到高速路网连接的都市群，AER的异步稀疏通信哲学始终如一：无论规模多大，快递单依然是那张轻飘飘的纸片，系统要做的只是把城池规划得足够聪明。

1. 单芯片事件率：对第 \(m\) 个芯片的所有神经元事件率求和，得到该芯片的输出总事件率。

$$\displaystyle \sum_{k=1}^{N_m} f_{m,k}$$

2. 系统总带宽需求：对所有芯片求和，得到多芯片系统需要满足的总事件吞吐，即所有活跃神经元事件率之和。

$$\displaystyle \sum_{m=1}^{M}\sum_{k=1}^{N_m} f_{m,k} = B_{\mathrm{total}}$$

---

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""AER(address-event representation)协议最小模拟多神经元异步发放脉冲 -> 仲裁器按时间戳有序调度 -> 共享总线限速传输 -> 接收端重建""" import randomimport heapqfrom dataclasses import dataclass, field  @dataclass(order=True)class Event:    """一个AER事件: 时间戳 + 神经元地址"""    timestamp: float    address: int = field(compare=False)  class Neuron:    """泊松发放的神经元, 每次发放产生一个AER事件"""     def __init__(self, addr, rate):        self.addr = addr          # 神经元地址(编号)        self.rate = rate          # 平均发放率 (次/秒)        self.next_t = random.expovariate(rate)     def tick(self, now):        """推进到now时刻, 若该发放则返回事件, 否则返回None"""        if now >= self.next_t:            self.next_t = now + random.expovariate(self.rate)            return Event(self.next_t, self.addr)        return None  class AERBus:    """共享总线 + 仲裁器: 按时间戳优先调度, 带宽受限"""     def __init__(self, bandwidth):        self.bandwidth = bandwidth  # 每秒最多传输的事件数        self.pending = []           # 等待仲裁的队列(最小堆)        self.delivered = []         # 已送达事件        self._credit = 0.0          # 时间片余量     def submit(self, ev):        heapq.heappush(self.pending, ev)  # 入队即仲裁排序     def transmit(self, dt):        """经过dt秒, 传输带宽允许的事件数"""        self._credit += self.bandwidth * dt        slots = int(self._credit)        self._credit -= slots        for _ in range(slots):            if not self.pending:                break            ev = heapq.heappop(self.pending)            self.delivered.append(ev)  def main():    random.seed(42)    neurons = [        Neuron(addr=0, rate=20.0),        Neuron(addr=1, rate=25.0),        Neuron(addr=2, rate=30.0),        Neuron(addr=3, rate=35.0),    ]    bus = AERBus(bandwidth=80.0)  # 总发放率约110, 故意设低以观察积压     total = 0    t = 0.0    dt = 0.001  # 仿真步长 1ms    while t < 1.0:        for n in neurons:            ev = n.tick(t)            if ev is not None:                bus.submit(ev)                total += 1        bus.transmit(dt)        t += dt     delivered = bus.delivered    ordered = all(        delivered[i].timestamp <= delivered[i + 1].timestamp        for i in range(len(delivered) - 1)    )    print(f"生成事件: {total}")    print(f"送达事件: {len(delivered)}  积压/丢失: {total - len(delivered)}")    print(f"时序保序: {ordered}")    print("前5个送达事件 (时间戳, 地址):")    for ev in delivered[:5]:        print(f"  t={ev.timestamp:.4f}s  addr={ev.address}")  if __name__ == "__main__":    main()

1. if now >= self.next_t:判断当前仿真时刻是否已到达该神经元的发放时刻，触发事件生成。
2. return Event(self.next_t, self.addr)生成一个AER事件，只记录“地址+时间戳”这两个核心信息。
3. heapq.heappush(self.pending, ev)事件进入仲裁队列，最小堆自动按时间戳排序，实现时序保序的仲裁。
4. slots = int(self._credit)将带宽换算为本仿真步可传输的事件数，模拟有限总线容量。
5. ev = heapq.heappop(self.pending)弹出时间戳最小的事件上总线，验证“先产生先送达”的因果顺序。

常见误区

面试题