OSCR

SE-SNN: Squeeze-and-Excitation-Enhanced Spiking Neural Networks with Learnable Neuron Dynamics for Event-Based Vision.

Code ↔ Paper

4 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 4 matches
  1. [1] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 227–346 · score 0.91 · cosine annealing, AdamW, weight decay, PyTorch, clipping, class
  2. [2] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 227–346 · score 0.69 · AdamW, weight decay, neuron parameters, Optimization
  3. [3] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 202–206 · score 0.55 · Random horizontal flip, crop
  4. [4] § 4. Experiments › 4.5. Ablation Study ↔ sesnn.py, lines 41–69 · score 0.54 · Excitation blocks, SE blocks, Squeeze, channel, spiking

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 349 lines · 13 KB · no license · 4 matches

  1. import torch
  2. import torch.nn as nn
  3. from spikingjelly.activation_based import neuron, functional, layer, surrogate
  4. from spikingjelly.datasets.cifar10_dvs import CIFAR10DVS
  5. from torch.utils.data import DataLoader, random_split, Dataset
  6. from torchvision import transforms
  7. import torch.optim as optim
  8. from torch.optim.lr_scheduler import CosineAnnealingLR, LinearLR, SequentialLR
  9. from torch.amp import GradScaler, autocast
  10. import os
  11. import gc
  12. import numpy as np
  13. import copy
  15. # ----------------------------
  16. # 🔧 配置：高性能模式
  17. # ----------------------------
  18. device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  19. batch_size = 16
  20. epochs = 300
  21. base_lr = 4e-4
  22. T = 16
  23. root_dir = './data/CIFAR10DVS'
  25. # 早停参数
  26. patience = 20
  27. min_delta = 0.0
  29. print(f"🚀 Device: {device} | VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
  30. print(f"⚙️ Config: Batch={batch_size}, T={T}, LR={base_lr}, Strategy=SE-Net+Mixup+Warmup")
  32. # ----------------------------
  33. # 🧠 1. 可学习 PLIF + SE Block (已修复)
  34. # ----------------------------
  35. class RobustPLIF(neuron.LIFNode):
  36. def __init__(self, tau=10.0, v_threshold=0.5, *args, **kwargs):
  37. super().__init__(tau=tau, v_threshold=v_threshold, surrogate_function=surrogate.ATan(alpha=2.0), detach_reset=True, *args, **kwargs)
  38. self.tau = nn.Parameter(torch.as_tensor(float(self.tau), dtype=torch.float))
  39. self.v_threshold = nn.Parameter(torch.as_tensor(float(self.v_threshold), dtype=torch.float))
  41. class SEBlock(nn.Module):
  42. """Squeeze-and-Excitation Block for SNN (Fixed)"""
  43. def __init__(self, channels, reduction=16):
  44. super().__init__()
  45. self.avg_pool = layer.AdaptiveAvgPool2d(1)
  46. # 注意：这里使用 nn.Sequential 包含普通的 Linear 和 Sigmoid
  47. # 因为 SE 生成的是权重系数 (0-1 浮点数)，不需要发放脉冲
  48. self.fc = nn.Sequential(
  49. layer.Linear(channels, channels // reduction, bias=False),
  50. # 中间层加一个 ReLU 或 Sigmoid 都可以，这里用 ReLU 保持非负，或者用 LIF 也可以但没必要
  51. # 为了简单有效，中间层用 ReLU (普通神经网络激活) 或者 恒等映射
  52. # 但 layer 模块里主要是 SNN 层。我们直接用 nn.ReLU 配合普通 Linear?
  53. # SpikingJelly 的 layer.Linear 输出是膜电位，可以直接接 nn.ReLU
  54. nn.ReLU(inplace=True),
  55. layer.Linear(channels // reduction, channels, bias=False),
  56. nn.Sigmoid() # 【修复】使用 torch.nn.Sigmoid 生成 0-1 之间的权重
  57. )
  59. def forward(self, x):
  60. # x shape: (N, C, H, W) - 单时间步的膜电位
  61. b, c, h, w = x.shape
  63. y = self.avg_pool(x) # (N, C, 1, 1)
  64. y = layer.Flatten()(y) # (N, C)
  65. y = self.fc(y) # (N, C) - 输出是 0-1 的浮点数
  66. y = y.view(b, c, 1, 1)
  68. # 将权重乘回原特征图 (逐元素相乘)
  69. return x * y
  71. # ----------------------------
  72. # 🏗️ 2. SE-ResNet 架构
  73. # ----------------------------
  74. class SEResidualBlock(nn.Module):
  75. def __init__(self, in_channels, out_channels, stride=1, dropout=0.1, use_se=True):
  76. super().__init__()
  77. self.conv1 = layer.Conv2d(in_channels, out_channels, 3, stride=stride, padding=1, bias=False)
  78. self.bn1 = layer.BatchNorm2d(out_channels)
  79. self.lif1 = RobustPLIF(tau=10.0, v_threshold=0.4)
  80. self.dropout1 = layer.Dropout(dropout) if dropout > 0 else None
  82. self.conv2 = layer.Conv2d(out_channels, out_channels, 3, stride=1, padding=1, bias=False)
  83. self.bn2 = layer.BatchNorm2d(out_channels)
  84. self.lif2 = RobustPLIF(tau=10.0, v_threshold=0.4)
  86. self.use_se = use_se
  87. if self.use_se:
  88. self.se = SEBlock(out_channels)
  90. self.downsample = None
  91. if stride != 1 or in_channels != out_channels:
  92. self.downsample = nn.Sequential(
  93. layer.Conv2d(in_channels, out_channels, 1, stride=stride, bias=False),
  94. layer.BatchNorm2d(out_channels)
  95. )
  97. def forward(self, x):
  98. identity = x
  99. out = self.conv1(x)
  100. out = self.bn1(out)
  101. out = self.lif1(out)
  102. if self.dropout1: out = self.dropout1(out)
  104. out = self.conv2(out)
  105. out = self.bn2(out)
  107. if self.use_se:
  108. out = self.se(out)
  110. if self.downsample is not None:
  111. identity = self.downsample(x)
  112. out = out + identity
  113. out = self.lif2(out)
  114. return out
  116. class SESNN(nn.Module):
  117. def __init__(self, num_classes=10, T=16):
  118. super().__init__()
  119. self.T = T
  120. base_channels = 64
  122. self.init_conv = nn.Sequential(
  123. layer.Conv2d(2, base_channels, 3, padding=1, bias=False),
  124. layer.BatchNorm2d(base_channels),
  125. RobustPLIF(tau=10.0, v_threshold=0.4),
  126. layer.MaxPool2d(2, 2)
  127. )
  129. self.layer1 = self._make_layer(base_channels, base_channels, 2, stride=1, dropout=0.1)
  130. self.layer2 = self._make_layer(base_channels, base_channels*2, 2, stride=2, dropout=0.2)
  131. self.layer3 = self._make_layer(base_channels*2, base_channels*4, 2, stride=2, dropout=0.3)
  132. self.layer4 = self._make_layer(base_channels*4, base_channels*8, 2, stride=2, dropout=0.3)
  134. self.avgpool = layer.AdaptiveAvgPool2d((4, 4))
  136. self.fc = nn.Sequential(
  137. layer.Flatten(),
  138. layer.Dropout(0.5),
  139. layer.Linear(base_channels*8 * 4 * 4, 1024),
  140. RobustPLIF(tau=5.0, v_threshold=0.5),
  141. layer.Dropout(0.5),
  142. layer.Linear(1024, num_classes)
  143. )
  145. def _make_layer(self, in_channels, out_channels, num_blocks, stride, dropout=0.0):
  146. layers = []
  147. layers.append(SEResidualBlock(in_channels, out_channels, stride, dropout))
  148. for _ in range(1, num_blocks):
  149. layers.append(SEResidualBlock(out_channels, out_channels, 1, dropout))
  150. return nn.Sequential(*layers)
  152. def forward(self, x):
  153. N, T_in, C, H, W = x.shape
  154. output_list = []
  155. for t in range(T_in):
  156. x_t = x[:, t, :, :, :]
  157. x_t = self.init_conv(x_t)
  158. x_t = self.layer1(x_t)
  159. x_t = self.layer2(x_t)
  160. x_t = self.layer3(x_t)
  161. x_t = self.layer4(x_t)
  162. x_t = self.avgpool(x_t)
  163. output_list.append(x_t)
  165. # 改进的时间整合：取最大值
  166. x = torch.stack(output_list, dim=1).max(dim=1)[0]
  167. x = self.fc(x)
  168. return x
  170. # ----------------------------
  171. # 🔄 数据加载 (Mixup + 改进归一化)
  172. # ----------------------------
  173. def mixup_data(x, y, alpha=0.2):
  174. if alpha > 0:
  175. lam = np.random.beta(alpha, alpha)
  176. else:
  177. lam = 1
  178. batch_size = x.size(0)
  179. index = torch.randperm(batch_size).to(x.device)
  180. mixed_x = lam * x + (1 - lam) * x[index, :]
  181. y_a, y_b = y, y[index]
  182. return mixed_x, y_a, y_b, lam
  184. class NormDataset(Dataset):
  185. def __init__(self, dataset, transform):
  186. self.dataset = dataset
  187. self.transform = transform
  189. def __len__(self):
  190. return len(self.dataset)
  192. def __getitem__(self, i):
  193. ev, tgt = self.dataset[i]
  194. if isinstance(ev, np.ndarray):
  195. ev = torch.from_numpy(ev).float()
  196. ev = self.transform(ev)
  197. if ev.max() > 0:
  198. ev = ev / (ev.max() + 1e-5)
  199. ev = torch.clamp(ev, 0, 1)
  200. return ev, tgt
  202. def get_train_transform():
  203. return transforms.Compose([
  204. transforms.RandomHorizontalFlip(p=0.5),
  205. transforms.RandomCrop(size=128, padding=4),
  206. ])
  208. def get_test_transform():
  209. return transforms.Compose([])
  211. def get_loaders():
  212. train_transform = get_train_transform()
  213. test_transform = get_test_transform()
  215. full_dataset = CIFAR10DVS(root_dir, data_type='frame', frames_number=T, split_by='time')
  216. train_ds = NormDataset(full_dataset, train_transform)
  218. train_size = int(0.9 * len(train_ds))
  219. test_size = len(train_ds) - train_size
  220. train_subset, test_subset = random_split(train_ds, [train_size, test_size], generator=torch.Generator().manual_seed(42))
  222. train_loader = DataLoader(train_subset, batch_size=batch_size, shuffle=True, num_workers=0, pin_memory=True, drop_last=True)
  223. test_loader = DataLoader(test_subset, batch_size=batch_size, shuffle=False, num_workers=0, pin_memory=True)
  225. return train_loader, test_loader
  227. # ----------------------------
  228. # 🚀 主训练流程
  229. # ----------------------------
  230. def main():
  231. train_loader, test_loader = get_loaders()
  232. model = SESNN(num_classes=10, T=T).to(device)
  234. ema_model = copy.deepcopy(model)
  235. ema_decay = 0.995
  237. param_count = sum(p.numel() for p in model.parameters())
  238. print(f"📊 Model Params: {param_count:,}")
  240. neuron_params = []
  241. normal_params = []
  242. for name, param in model.named_parameters():
  243. if 'tau' in name or 'v_threshold' in name:
  244. neuron_params.append(param)
  245. else:
  246. normal_params.append(param)
  248. optimizer = optim.AdamW([
  249. {'params': normal_params, 'lr': base_lr},
  250. {'params': neuron_params, 'lr': base_lr * 0.5}
  251. ], weight_decay=5e-4, betas=(0.9, 0.999))
  253. warmup_epochs = 10
  254. scheduler_warmup = LinearLR(optimizer, start_factor=0.1, end_factor=1.0, total_iters=warmup_epochs)
  255. scheduler_cosine = CosineAnnealingLR(optimizer, T_max=epochs - warmup_epochs, eta_min=1e-7)
  256. scheduler = SequentialLR(optimizer, schedulers=[scheduler_warmup, scheduler_cosine], milestones=[warmup_epochs])
  258. scaler = GradScaler('cuda')
  259. criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
  261. best_acc = 0.0
  262. best_state = None
  263. wait = 0
  265. def update_ema(model, ema_model, decay):
  266. with torch.no_grad():
  267. for (name_ms, ms), (name_mes, mes) in zip(model.state_dict().items(), ema_model.state_dict().items()):
  268. if ms.dtype.is_floating_point:
  269. mes.mul_(decay)
  270. mes.add_(ms, alpha=1.0 - decay)
  271. else:
  272. mes.copy_(ms)
  274. for epoch in range(epochs):
  275. model.train()
  276. train_correct, train_total = 0, 0
  278. for data, target in train_loader:
  279. data, target = data.to(device), target.to(device)
  280. mixed_data, y_a, y_b, lam = mixup_data(data, target, alpha=0.2)
  282. functional.reset_net(model)
  283. optimizer.zero_grad()
  285. with autocast('cuda'):
  286. output = model(mixed_data)
  287. loss = lam * criterion(output, y_a) + (1 - lam) * criterion(output, y_b)
  289. scaler.scale(loss).backward()
  290. scaler.unscale_(optimizer)
  291. torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
  293. scaler.step(optimizer)
  294. scaler.update()
  296. update_ema(model, ema_model, ema_decay)
  298. with torch.no_grad():
  299. for name, param in model.named_parameters():
  300. if 'tau' in name: param.clamp_(1.0, 20.0)
  301. elif 'v_threshold' in name: param.clamp_(0.2, 0.8)
  302. for name, param in ema_model.named_parameters():
  303. if 'tau' in name: param.clamp_(1.0, 20.0)
  304. elif 'v_threshold' in name: param.clamp_(0.2, 0.8)
  306. _, pred = output.max(1)
  307. train_correct += pred.eq(target).sum().item()
  308. train_total += target.size(0)
  310. scheduler.step()
  312. ema_model.eval()
  313. test_correct, test_total = 0, 0
  314. with torch.no_grad():
  315. for data, target in test_loader:
  316. data, target = data.to(device), target.to(device)
  317. functional.reset_net(ema_model)
  318. output = ema_model(data)
  319. _, pred = output.max(1)
  320. test_correct += pred.eq(target).sum().item()
  321. test_total += target.size(0)
  323. train_acc = 100.0 * train_correct / train_total
  324. test_acc = 100.0 * test_correct / test_total
  326. if test_acc > best_acc + min_delta:
  327. best_acc = test_acc
  328. best_state = copy.deepcopy(ema_model.state_dict())
  329. wait = 0
  330. print(f"💾 New Best (EMA)! Test Acc: {best_acc:.2f}%")
  331. torch.save(best_state, "best_se_snn_fixed.pth")
  332. else:
  333. wait += 1
  334. if wait >= patience:
  335. print(f"⏹️ Early Stopping triggered at Epoch {epoch+1}. Best Acc: {best_acc:.2f}%")
  336. break
  338. print(f"Epoch {epoch+1}/{epochs} | Train: {train_acc:.2f}% | Test(EMA): {test_acc:.2f}% | Wait: {wait}/{patience}")
  340. if epoch % 10 == 0:
  341. gc.collect()
  342. torch.cuda.empty_cache()
  344. if best_state is not None:
  345. ema_model.load_state_dict(best_state)
  346. print(f"✅ Training finished. Loaded best model with Acc: {best_acc:.2f}%")
  348. if __name__ == "__main__":
  349. main()

sesnn.py at commit 2577e77, no license · at the source

Overview

Authors: Chuang Liu1, Yang Chen1
  1. School of Intelligent Science and Information Engineering, Shenyang University, Shenyang 110044, China
Institutions: Shenyang University (China)
Journal: Biomimetics (Basel, Switzerland), volume 11, issue 5, article 359
Dates: received 26 March 2026; accepted 19 May 2026; published online 21 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/biomimetics11050359 · PMID 42187426 · PMCID PMC13204279 · OpenAlex W7162023598
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational (subfield)
Methods: Machine learning, Single-unit activity, calcium imaging, Smoothing, state filtering, decompositions
Keywords: spiking neural networks, neuromorphic computing, squeeze-and-excitation, learnable neuron dynamics, event-based vision, CIFAR10-DVS
Topic: Advanced Memory and Neural Computing (Electrical and Electronic Engineering, Engineering), according to OpenAlex
Funding: China Postdoctoral Science Foundation (2021M693858); Educational Department of Liaoning Province (LJ212411035009); Technological Innovation Program for Young People of Shenyang City (RC210400)
Citations: not cited yet (Europe PMC); 44 references in the paper

Abstract

Spiking neural networks (SNNs) have emerged as a promising paradigm for energy-efficient neuromorphic computing, particularly when processing asynchronous event streams from dynamic vision sensors (DVSs). However, SNNs often suffer from limited representational capacity and suboptimal feature recalibration compared to their artificial counterparts. To address these challenges, we propose SE-SNN, a novel architecture that integrates Squeeze-and-Excitation (SE) blocks into deep residual SNNs, enabling channel-wise attention without spike generation. Furthermore, we introduce a Robust Parametric Leaky Integrate-and-Fire (RobustPLIF) neuron model with learnable membrane time constant (τ) and firing threshold (vth), allowing adaptive temporal dynamics in each layer. Our model is trained on the CIFAR10-DVS dataset.The experimental results demonstrate that SE-SNN achieves an accuracy of 78.8 % on CIFAR10-DVS with 16 time steps, outperforming baseline SNNs while maintaining biological plausibility and hardware efficiency. Ablation studies confirm the individual contributions of the SE blocks and learnable neuron parameters to the performance gains.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 4 matches between paragraphs and lines of code.

chuang-liu-cn/code

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 2577e77fc0c9eaacda9e9fda29ad554e06ab1836, 26 March 2026
Languages: MATLAB (27), Python (1)
Size: 65 files, 28 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (1 file), NumPy (1 file), PyTorch (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
29 files
At the source: github.com/chuang-liu-cn/code

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 28 scripts, each with its path and the digest of its content;
  • 4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability Statement

Restrictions apply to the availability of these data. Data were obtained from third party and are available [from the authors/at https://github.com/chuang-liu-cn/code] with the permission of third party.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 6 keywords, 3 funders, 40 references.

Cite

This paper

Liu, C., & Chen, Y. (2026). SE-SNN: Squeeze-and-Excitation-Enhanced Spiking Neural Networks with Learnable Neuron Dynamics for Event-Based Vision. Biomimetics (Basel, Switzerland), 11(5), 359. https://doi.org/10.3390/biomimetics11050359

BibTeX

@article{liu2026se,
author = {Liu, Chuang and Chen, Yang},
title = {{SE-SNN: Squeeze-and-Excitation-Enhanced Spiking Neural Networks with Learnable Neuron Dynamics for Event-Based Vision}},
journal = {Biomimetics (Basel, Switzerland)},
year = {2026},
month = may,
volume = {11},
number = {5},
pages = {359},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {2313-7673},
doi = {10.3390/biomimetics11050359},
url = {https://doi.org/10.3390/biomimetics11050359},
pmid = {42187426},
pmcid = {PMC13204279}
}

RIS

TY - JOUR
AU - Liu, Chuang
AU - Chen, Yang
TI - SE-SNN: Squeeze-and-Excitation-Enhanced Spiking Neural Networks with Learnable Neuron Dynamics for Event-Based Vision
T2 - Biomimetics (Basel, Switzerland)
J2 - Biomimetics (Basel)
PY - 2026
DA - 2026/05/21
VL - 11
IS - 5
SP - 359
SN - 2313-7673
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/biomimetics11050359
UR - https://doi.org/10.3390/biomimetics11050359
LA - en
ER -

CSL-JSON

{
"id": "10.3390/biomimetics11050359",
"type": "article-journal",
"title": "SE-SNN: Squeeze-and-Excitation-Enhanced Spiking Neural Networks with Learnable Neuron Dynamics for Event-Based Vision",
"container-title": "Biomimetics (Basel, Switzerland)",
"author": [
{
"family": "Liu",
"given": "Chuang"
},
{
"family": "Chen",
"given": "Yang"
}
],
"container-title-short": "Biomimetics (Basel)",
"volume": "11",
"issue": "5",
"page": "359",
"DOI": "10.3390/biomimetics11050359",
"PMID": "42187426",
"PMCID": "PMC13204279",
"ISSN": "2313-7673",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/biomimetics11050359",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
21
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-74243-1 [code]
Spiking neural network decoders of finger forces from high-density intramuscular microelectrode arrays.
Journal: Nature communications
In common: PyTorch, NumPy, computational, 1 reference
[2] doi:10.1038/s41467-026-76878-6 [code]
Temporal coding enables hyperacuity in event-based vision.
Journal: Nature communications
In common: PyTorch, NumPy, 1 reference
[3] doi:10.1186/s13634-026-01330-2 [code]
Leednet: a lightweight network for event detection in EEG signals.
Journal: Journal on advances in signal processing
In common: PyTorch, NumPy, 1 reference
[4] doi:10.1007/s00285-026-02415-0 [code]
Spiking neural models for decision-making tasks with learning.
Journal: Journal of mathematical biology
In common: PyTorch, NumPy, 1 reference
[5] doi:10.1038/s42256-026-01254-4 [code]
Neural sampling from cognitive maps enables goal-directed imagination and planning.
Journal: Nature machine intelligence
In common: PyTorch, NumPy, 1 reference
[6] doi:10.1038/s41586-026-10528-1 [code]
A critical initialization for biological neural networks.
Journal: Nature
In common: PyTorch, NumPy, 1 reference
[7] doi:10.3390/biomimetics11070481 [code]
Task-State fMRI-Derived Whole-Brain Functional Topology-Constrained Spiking Neural Network with an Embedded Auditory Core Circuit for Speech Recognition.
Journal: Biomimetics (Basel, Switzerland)
In common: 2 references
[8] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: NumPy, computational, 1 reference
[9] doi:10.3389/fnins.2026.1605209 [code]
Spiking neural networks provide accurate and time-efficient models for whisker stimulus classification of the awake mouse.
Journal: Frontiers in neuroscience
In common: NumPy, computational, 1 reference
[10] doi:10.1038/s41467-026-71503-y [code]
Rapid formation of non-spatial hippocampal representations consistent with behavioral timescale synaptic plasticity is modulated by entorhinal input.
Journal: Nature communications
In common: Statistics and Machine Learning Toolbox, 1 reference

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.