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.

3 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 4 matches
  1. [1] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 227 to 346 · score 0.91 · cosine annealing, AdamW, weight decay, PyTorch, clipping, class · block oscr:b:KK8GGXY8YFMAS-7 · Report a mismatch
  2. [2] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 227 to 346 · score 0.69 · AdamW, weight decay, neuron parameters, Optimization · block oscr:b:KK8GGXY8YFMAS-7 · Report a mismatch
  3. [3] § 4. Experiments › 4.1. Dataset and Setup ↔ sesnn.py, lines 202 to 206 · score 0.55 · Random horizontal flip, crop · block oscr:b:4D6CJ7P8ZDPWE-F · Report a mismatch
  4. [4] § 4. Experiments › 4.5. Ablation Study ↔ sesnn.py, lines 41 to 69 · score 0.54 · Excitation blocks, SE blocks, Squeeze, channel, spiking · block oscr:b:2V8078VKKTFHM-K · Report a mismatch

Paper

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

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/s41598-025-22430-3 [code]
BIASNN: a biologically inspired attention mechanism in spiking neural networks for image classification.
Journal: Scientific reports
In common: NumPy, computational, 6 references
[2] doi:10.3389/fnins.2024.1516868
Fourier or Wavelet bases as counterpart self-attention in spikformer for efficient visual classification.
Journal: Frontiers in neuroscience
In common: computational, 5 references
[3] doi:10.1038/s41467-025-63771-x [code]
Efficient and robust temporal processing with neural oscillations modulated spiking neural networks.
Journal: Nature communications
In common: PyTorch, NumPy, computational, 4 references
[4] doi:10.3389/fnins.2023.1167134 [code]
Spiking neural network with working memory can integrate and rectify spatiotemporal features.
Journal: Frontiers in neuroscience
In common: PyTorch, NumPy, 4 references
[5] doi:10.3389/fnins.2022.1079357 [code]
STSC-SNN: Spatio-Temporal Synaptic Connection with temporal convolution and attention for spiking neural networks.
Journal: Frontiers in neuroscience
In common: PyTorch, NumPy, 4 references
[6] doi:10.3389/fncom.2024.1508297
Spike-HAR++: an energy-efficient and lightweight parallel spiking transformer for event-based human action recognition.
Journal: Frontiers in computational neuroscience
In common: computational, 4 references
[7] doi:10.1038/s41467-025-62251-6 [code]
A multisynaptic spiking neuron for simultaneously encoding spatiotemporal dynamics.
Journal: Nature communications
In common: PyTorch, NumPy, 3 references
[8] doi:10.1038/s41598-025-34046-8 [code]
Enhancing time scalability of spiking neural networks with dynamic time constants.
Journal: Scientific reports
In common: PyTorch, NumPy, computational, 2 references
[9] doi:10.3390/brainsci13020319 [code]
Constrain Bias Addition to Train Low-Latency Spiking Neural Networks.
Journal: Brain sciences
In common: PyTorch, NumPy, computational, 2 references
[10] doi:10.1038/s41598-023-31110-z [code]
Multitask computation through dynamics in recurrent spiking neural networks.
Journal: Scientific reports
In common: PyTorch, NumPy, computational, 2 references

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.3390/biomimetics11050359.svg)](https://openscicode.org/badge/doi/10.3390/biomimetics11050359)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.3390/biomimetics11050359.svg
   :target: https://openscicode.org/badge/doi/10.3390/biomimetics11050359
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.3390/biomimetics11050359"><img src="https://openscicode.org/badge/doi/10.3390/biomimetics11050359.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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