教程:异构多受体 E/I RSNN¶
本教程构建一个带四类受体通道的 E/I 循环脉冲网络:E→E、E→I、I→E 和 I→I。连接使用一张语义边表,受体通道通过 Synapse(receptor=...) 表达;HeterSynapsePSC 为每个通道维护独立的 Alpha PSC,再把通道电流汇总到目标神经元。
这里不把 n_neuron * n_receptor 的物理展开矩阵当作模型定义。那只是 SparseConnection 为后端执行生成的布局。这样检查点、权重和边查询仍然使用神经元级的 pre、post 和 receptor。
完整示例¶
import torch
from torch import nn
import pandas as pd
from btorch.models import environ, functional
from btorch.models.connection import SparseConnection, Synapse
from btorch.models.constrain import constrain_net
from btorch.models.neurons import GLIF3
from btorch.models.rnn import RecurrentNN
from btorch.models.synapse import AlphaPSC, HeterSynapsePSC
class HeterogeneousEIRSNN(nn.Module):
"""E/I RSNN with semantic receptor-labelled recurrent edges."""
def __init__(self, n_input, n_exc, n_inh, n_output, device):
super().__init__()
self.n_exc = n_exc
self.n_inh = n_inh
self.n_neuron = n_exc + n_inh
neuron_type = torch.cat(
[
torch.zeros(n_exc, dtype=torch.long),
torch.ones(n_inh, dtype=torch.long),
]
)
source = torch.arange(self.n_neuron).repeat_interleave(self.n_neuron)
target = torch.arange(self.n_neuron).repeat(self.n_neuron)
keep = source != target
pre = source[keep].to(device)
post = target[keep].to(device)
pre_type = neuron_type[pre.cpu()].to(device)
post_type = neuron_type[post.cpu()].to(device)
# Receptor order: E->E, E->I, I->E, I->I.
receptor = pre_type * 2 + post_type
generator = torch.Generator(device=device).manual_seed(0)
magnitude = 0.04 + 0.02 * torch.rand(
pre.numel(), generator=generator, device=device
)
initial_weight = torch.where(pre_type == 0, magnitude, -magnitude)
receptor_index = pd.DataFrame(
{
"receptor_index": [0, 1, 2, 3],
"pre_receptor_type": ["E", "E", "I", "I"],
"post_receptor_type": ["E", "I", "E", "I"],
}
)
self.connection = SparseConnection.from_edges(
pre,
post,
n_pre=self.n_neuron,
n_post=self.n_neuron,
values=initial_weight,
synapse=Synapse(
receptor=receptor,
n_receptor=4,
dale=True,
),
device=device,
)
self.receptor_index = receptor_index
tau_by_receptor = torch.tensor(
[5.0, 8.0, 6.0, 10.0],
device=device,
).repeat(self.n_neuron)
psc = HeterSynapsePSC(
n_neuron=self.n_neuron,
n_receptor=4,
receptor_type_index=receptor_index,
linear=self.connection,
base_psc=AlphaPSC,
tau_syn=tau_by_receptor,
step_mode="s",
)
neuron = GLIF3(
n_neuron=self.n_neuron,
v_threshold=-45.0,
v_reset=-60.0,
c_m=2.0,
tau=20.0,
k=[1.0 / 80.0],
asc_amps=[-0.2],
tau_ref=2.0,
step_mode="s",
backend="torch",
device=device,
)
self.brain = RecurrentNN(
neuron=neuron,
synapse=psc,
step_mode="m",
update_state_names=("neuron.v", "synapse.psc"),
)
self.input = nn.Linear(n_input, self.n_neuron, bias=False, device=device)
self.output = nn.Linear(self.n_neuron, n_output, device=device)
def forward(self, x):
spikes, states = self.brain(self.input(x))
logits = self.output(spikes.mean(dim=0))
return logits, spikes, states
torch.manual_seed(0)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
batch_size, time_steps = 6, 24
model = HeterogeneousEIRSNN(
n_input=12,
n_exc=6,
n_inh=4,
n_output=3,
device=device,
).to(device)
model = model.to(device=device, dtype=torch.float32)
functional.init_net_state(
model,
batch_size=batch_size,
device=device,
dtype=torch.float32,
)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()
inputs = torch.randn(time_steps, batch_size, 12, device=device)
targets = torch.randint(0, 3, (batch_size,), device=device)
environ.set(dt=1.0)
model.train()
for _ in range(3):
functional.reset_net(model, batch_size=batch_size)
optimizer.zero_grad()
with environ.context(dt=1.0):
logits, spikes, states = model(inputs)
loss = criterion(logits, targets)
loss.backward()
optimizer.step()
constrain_net(model)
assert logits.shape == (batch_size, 3)
assert spikes.shape == (time_steps, batch_size, 10)
assert states["neuron.v"].shape == spikes.shape
assert model.connection.n_receptor == 4
edge_weight = model.connection.weight()
assert bool((edge_weight[model.connection.pre < model.n_exc] >= 0).all())
assert bool((edge_weight[model.connection.pre >= model.n_exc] <= 0).all())
print(f"loss={loss.item():.4f}, edges={model.connection.nnz}")
受体索引表¶
receptor_index 是模型旁边的语义元数据,不会被编码进物理矩阵。四个通道的索引约定为:
receptor_index |
源类型 | 目标类型 | tau_syn |
|---|---|---|---|
| 0 | E | E | 5.0 |
| 1 | E | I | 8.0 |
| 2 | I | E | 6.0 |
| 3 | I | I | 10.0 |
边上的 receptor 是 [n_edge] 的整数张量。HeterSynapsePSC 的输出先按 post * n_receptor + receptor 排列,再沿最后一个受体轴求和,所以 RecurrentNN 仍然看到 [batch, n_neuron] 的总突触电流。
Dale 约束¶
教程把所有从 E 神经元发出的边初始化为正,把所有从 I 神经元发出的边初始化为负,并设置 Synapse(dale=True)。EdgeWeight 保存每条边的参考符号;每次优化器更新后调用 constrain_net(model),确保符号不会改变。
如果需要不同的权重共享策略,可以把 ConstrainedWeight 传给 Synapse(weight=...)。受体和延迟仍然是边属性,不需要创建 HeterogeneousLinear 或其他专用线性层。
读取通道电流¶
前向之后,可以读取未汇总的通道 PSC:
psc = model.brain.synapse
ee_current = psc.get_psc(receptor_type=("E", "E"))
ie_current = psc.get_psc(receptor_type=("I", "E"))
assert ee_current.shape == ie_current.shape == (batch_size, model.n_neuron)
也可以检查当前语义边和权重:
edges = model.connection.edge_table()
assert {"pre", "post", "receptor", "weight"}.issubset(edges)
current_weight = model.connection.weight()
加入异构延迟¶
延迟与受体使用同一套语义边模型。为每条边增加 delay,并设置 n_delay:
SparseConnection 会声明 n_delay,HeterSynapsePSC 自动创建 SpikeHistory,将延迟历史送入连接。输入仍然是未展开的 [batch, n_neuron] 脉冲;历史和扁平索引由 PSC 与连接内部管理。
与物理展开数据互操作¶
如果数据来自旧的 make_hetersynapse_conn,可以使用:
conn = SparseConnection.from_hetersynapse(
expanded_matrix,
receptor_type_index=receptor_index,
n_delay=3,
)
这只是适配入口。新建模型时,优先使用本教程中的 from_edges 与 Synapse(receptor=..., delay=...),因为它们保留了神经元级拓扑和边属性。
下一步¶
要比较稀疏连接的 planner、task queue 和 CUDA Graph,请参阅稀疏连接指南。