OSCR

A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition.

Code ↔ Paper

1 match 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 1 match
  1. [1] § Methods › Learning based on neural circuits evolution › Synaptic plasticity ↔ examples/Structure_Evolution/Adaptive_lsm/BrainCog-Version/tools/EnuGlobalNetwork.py, lines 210–242 · score 0.65 · post synaptic neuron, pre synaptic neuron, synapse, STDP, network, Spike

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 · 280 lines · 17 KB · Apache-2.0 · 1 match

  1. import pickle
  2. import time
  4. import numpy as np
  5. import torch
  6. import matplotlib.pyplot as plt
  7. import seaborn as sns
  8. from matplotlib import gridspec
  10. from AbstractLayerBMM import AbstractLayerBMM
  11. from EvolvableNeuralUnitStacked import EvolvableNeuralUnitStacked
  12. from Tools import get_data_path
  14. sns.set_style("darkgrid")
  17. class EnuGlobalNetwork(AbstractLayerBMM):
  18. """Network of ENUs implementation in PyTorch, where each synapse and neuron is modeled as an ENU. """
  20. def __init__(self, n_offspring, n_pseudo_env, n_input_neurons, n_hidden_neurons, n_output_neurons, n_syn_per_neuron):
  21. # offspring
  22. self.n_offspring = n_offspring
  23. self.n_pseudo_env = n_pseudo_env
  24. # input channels
  25. n_input_channels = 16
  26. self.n_input_channels = n_input_channels
  27. n_dynamic_param = 32
  28. # total neurons
  29. n_neurons = n_output_neurons + n_hidden_neurons
  30. self.n_neurons = n_neurons
  31. super().__init__(n_offspring, n_neurons, n_input_neurons, n_output_neurons)
  32. torch.random.manual_seed(0)
  33. #NOTE: batch dimension holds output of each neuron/synapse, allowing fast GPU MM
  34. #NOTE neurons far less than synapses, so can be relatively bigger rnn for little cost
  35. n_input_channels_neuron = 16
  36. n_input_neuron, n_output_neuron = n_input_channels_neuron, n_input_channels
  37. self.neurons = EvolvableNeuralUnitStacked(n_offspring, batch_size=self.n_neurons, n_input=n_input_neuron, n_dynamic_param=n_dynamic_param, n_output=n_output_neuron)
  38. #self.n_syn = next_power_of_2(int(n_neurons * (rel_connectivity*n_neurons)))
  39. self.n_syn_per_neuron = n_syn_per_neuron
  40. self.n_syn = n_neurons * n_syn_per_neuron
  41. n_input_syn, n_output_syn = n_input_channels * 2, n_input_channels_neuron # * 2 for neuron feedback (which same channel as n_channel input)
  42. self.synapses = EvolvableNeuralUnitStacked(n_offspring, batch_size=self.n_syn, n_input=n_input_syn, n_dynamic_param=n_dynamic_param, n_output=n_output_syn)
  43. # just randomly connect synapses to neurons
  44. self.synapse_connections = torch.randint(n_input_neurons + n_neurons, size=(n_neurons, n_syn_per_neuron), device='cuda', dtype=torch.long)
  45. # fixed predefined connection patterns
  46. if n_input_neurons==2 and n_output_neurons==2 and n_hidden_neurons==2:
  47. print("Fixed connection Network 2-2-2")
  48. self.synapse_connections = torch.tensor([[0, 1],
  49. [0, 1],
  50. [2, 3],
  51. [2, 3]], device='cuda', dtype=torch.long)
  52. elif n_input_neurons == 4 and n_output_neurons == 3 and n_hidden_neurons == 3 and n_syn_per_neuron==3:
  53. print("Fixed connection Network 4-3-3 (3syn)")
  54. self.synapse_connections = torch.tensor([[0, 1, 3],# hidden connections #4
  55. [0, 2, 3], #5
  56. [1, 2, 3],# 6
  57. [4, 5, 6], # output connections #7
  58. [4, 5, 6],#8
  59. [4, 5, 6]#9
  60. ], device='cuda', dtype=torch.long)
  61. elif n_input_neurons==5 and n_hidden_neurons==0 and n_output_neurons==4:
  62. print("Fixed connection Network 5-0-4 (5syn)")
  63. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  64. self.synapse_connections = torch.tensor([[0, 1, 2, 3, 4],# output connections
  65. [0, 1, 2, 3, 4],
  66. [0, 1, 2, 3, 4],
  67. [0, 1, 2, 3, 4]
  68. ], device='cuda', dtype=torch.long)
  69. elif n_input_neurons==1 and n_hidden_neurons==0 and n_output_neurons==2:
  70. print("Fixed connection Network 1-0-2 (1syn)")
  71. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  72. self.synapse_connections = torch.tensor([[0],# output connections
  73. [0]
  74. ], device='cuda', dtype=torch.long)
  75. elif n_input_neurons==4 and n_hidden_neurons==0 and n_output_neurons==3 and n_syn_per_neuron==4:
  76. print("Sparse connection Network 4-0-3 (4syn)")
  77. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  78. self.synapse_connections = torch.tensor([[0, 1, 2, 3],# output connections #4
  79. [0, 1, 2, 3], #5
  80. [0, 1, 2, 3],# 6
  81. ], device='cuda', dtype=torch.long)
  82. elif n_input_neurons == 4 and n_hidden_neurons == 3 and n_output_neurons == 3 and n_syn_per_neuron == 4:
  83. print("Sparse connection Network 4-3-3 (3syn)")
  84. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  85. self.synapse_connections = torch.tensor([[0, 1, 3], # hidden connections #4
  86. [0, 2, 3], # 5
  87. [1, 2, 3], # 6
  88. [4, 5, 3], # output connections #7
  89. [4, 6, 3], # 8
  90. [5, 6, 3] # 9
  91. ], device='cuda', dtype=torch.long)
  92. elif n_input_neurons==4 and n_hidden_neurons==3 and n_output_neurons==3 and n_syn_per_neuron==8:
  93. print("Sparse connection Network 4-3-3 (8syn)")
  94. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  95. self.synapse_connections = torch.tensor([[0, 1, 5, 6, 7, 8, 3, 4],# hidden connections #4
  96. [0, 2, 4, 6, 7, 9, 3, 5], #5
  97. [1, 2, 4, 5, 8, 9, 3, 6],# 6
  98. [4, 5, 8, 9, 0, 1, 3, 7], # output connections #7
  99. [4, 6, 7, 9, 0, 2, 3, 8],#8
  100. [5, 6, 7, 8, 1, 2, 3, 9]#9
  101. ], device='cuda', dtype=torch.long)
  102. elif n_input_neurons==4 and n_hidden_neurons==4 and n_output_neurons==4 and n_syn_per_neuron==8:
  103. print("Fixed connection Network 4-4-4 (8syn)")
  104. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  105. self.synapse_connections = torch.tensor([[0, 1, 2, 3, 4, 5, 6, 7],# hidden connections
  106. [0, 1, 2, 3, 4, 5, 6, 7],
  107. [0, 1, 2, 3, 4, 5, 6, 7],
  108. [0, 1, 2, 3, 4, 5, 6, 7],
  109. [4, 5, 6, 7, 8, 9, 10, 11], # output connections
  110. [4, 5, 6, 7, 8, 9, 10, 11],
  111. [4, 5, 6, 7, 8, 9, 10, 11],
  112. [4, 5, 6, 7, 8, 9, 10, 11],
  113. ], device='cuda', dtype=torch.long)
  114. elif n_input_neurons==5 and n_hidden_neurons==5 and n_output_neurons==4:
  115. print("Fixed connection Network 5-5-4 (5syn)")
  116. # neuron i connected to neuron j and k, neuron 0..input_neurons is index
  117. self.synapse_connections = torch.tensor([[0, 1, 2, 3, 4],# hidden connections
  118. [0, 1, 2, 3, 4],
  119. [0, 1, 2, 3, 4],
  120. [0, 1, 2, 3, 4],
  121. [0, 1, 2, 3, 4],
  122. [5, 6, 7, 8, 9], # output connections
  123. [5, 6, 7, 8, 9],
  124. [5, 6, 7, 8, 9],
  125. [5, 6, 7, 8, 9],
  126. ], device='cuda', dtype=torch.long)
  127. elif n_input_neurons==1 and n_hidden_neurons==0 and n_output_neurons==1:
  128. print("Fixed connection Single")
  129. self.synapse_connections = torch.tensor([[0]], device='cuda', dtype=torch.long)
  130. else:
  131. print("Random connections")
  132. # each synapse is connected also to its post-synaptic neuron, to allow STDP type learning to emerge
  133. self.synapse_connections_post = torch.arange(n_neurons, device='cuda', dtype=torch.long).reshape(n_neurons, -1).repeat(1, n_syn_per_neuron)
  134. # define compartments
  135. self.compartments = [self.neurons, self.synapses]
  136. self.trainable_layers = self.neurons.trainable_layers + self.synapses.trainable_layers
  137. self.track_data = False
  140. def dump_model(self, e, exp_name):
  141. """Dump model to restore"""
  142. with open(get_data_path(e, exp_name, "Model"), 'wb') as f:
  143. parameters = {}
  144. parameters["neuron"] = [layer.base_parameters.cpu().numpy() for layer in self.neurons.trainable_layers]
  145. parameters["synapse"] = [layer.base_parameters.cpu().numpy() for layer in self.synapses.trainable_layers]
  146. pickle.dump(parameters, f)
  148. def restore_model(self, e, exp_name):
  149. """Restore model"""
  150. with open(get_data_path(e, exp_name, "Model"), 'rb') as f:
  151. parameters = pickle.load(f)
  152. #TODO: refactor to dump/restore at ENU level and just call those functions
  153. assert len(self.neurons.trainable_layers) == len(parameters["neuron"])
  154. for i in range(len(parameters["neuron"])):
  155. self.neurons.trainable_layers[i].base_parameters = torch.from_numpy(parameters["neuron"][i].astype(np.float32)).cuda()
  156. assert len(self.synapses.trainable_layers) == len(parameters["synapse"])
  157. for i in range(len(parameters["synapse"])):
  158. self.synapses.trainable_layers[i].base_parameters = torch.from_numpy(parameters["synapse"][i].astype(np.float32)).cuda()
  160. @staticmethod
  161. def plot_weights(e, exp_name):
  162. """Visualize weights of ENU gates"""
  163. sns.set_style("dark")
  164. def calc_average(start, stop):
  165. weights_average = None
  166. for e in range(start, stop, 1000):
  167. with open(get_data_path(e, exp_name, "Model"), 'rb') as f:
  168. parameters = pickle.load(f)
  169. weights = []
  170. for i in range(len(parameters["neuron"])):
  171. weights += [parameters["neuron"][i].astype(np.float32)]
  172. if weights_average is None:
  173. weights_average = weights
  174. else:
  175. for i in range(len(weights_average)):
  176. weights_average[i] += weights[i]
  177. return weights_average
  178. weights_mean1 = calc_average(20000, 30000)
  179. fig, ax = plt.subplots(1, 2, sharex='col', sharey='row')
  180. for i in range(len(weights_mean1)):
  181. ax[i].imshow(weights_mean1[i], cmap="gray")
  182. weights_mean2 = calc_average(30000, 40000)
  183. fig, ax = plt.subplots(1, 2, sharex='col', sharey='row')
  184. for i in range(len(weights_mean2)):
  185. ax[i].imshow(weights_mean2[i], cmap="gray")
  186. fig, ax = plt.subplots(1, 2, sharex='col', sharey='row')
  187. for i in range(len(weights_mean2)):
  188. ax[i].imshow((weights_mean2[i] - weights_mean1[i])**5, cmap="gray")
  189. plt.show()
  192. def dump_network_activity(self, e, exp_name):
  193. """Dump raw data for visualization"""
  194. with open(get_data_path(e, exp_name, "GlobalNetwork"), 'wb') as f:
  195. pickle.dump(self.vis_data, f)
  197. def print(self):
  198. print("--Neurons--")
  199. self.neurons.print()
  200. print("--Synapses--")
  201. self.synapses.print()
  203. def reset(self):
  204. self.vis_data = []
  205. if self.track_data:
  206. print("Tracking network activity")
  207. for compartment in self.compartments:
  208. compartment.reset()
  210. def forward(self, X):
  211. """Main computation forward pass"""
  212. # transfer to GPU
  213. X_raw_gpu = torch.from_numpy(X.astype(np.float32)).cuda()
  214. X_gpu = torch.zeros((X.shape[0], X.shape[1], self.n_input_channels), device='cuda', dtype=torch.float32)
  215. X_gpu[:, :, :X_raw_gpu.shape[2]] = X_raw_gpu
  216. # first compute synapses, set input to previous output of connected neuron
  217. # concat our input spiking pattern directly to input to our synapses (the neurons)
  218. # NOTE: this concats in batch dimension, meaning it feeds into input neurons directly spiking pattern, while rest receive input from network
  219. input_to_synapses = torch.cat([X_gpu, self.neurons.out_mem], dim=1)
  220. # connect each synapse randomly to multiple inputs
  221. input_to_synapses_connected = input_to_synapses[:, self.synapse_connections.flatten(), :]
  222. # need feedback connection from neuron to synapse, to allow stdp type rules to emerge (else it has to do it through feedback connections, but less guarentee on connections and cannot distinguise type)
  223. # one synapse has 1 pre-synaptic neuron and 1 post-synaptic neuron, connectection defined in synapse_connections, synapse_connections[i, :] gives all input synapses of that neuron
  224. # so feedback to all it's input synapses through broadcasting backwards
  225. post_neuron_backprop_connected = self.neurons.out_mem[:, self.synapse_connections_post.flatten(), :]
  226. input_to_synapses_connected = torch.cat([input_to_synapses_connected, post_neuron_backprop_connected], dim=-1)
  227. # compute synapse
  228. self.synapses.forward(input_to_synapses_connected)
  229. # then integrate(sum) all outputs of a neurons input synapses, can just reshape into valid shape, since we already randomly connected when computing synapses
  230. # NOTE: each neuron then requires same number of synapses, then reshape by modifying batch dim (which contains syn outputs)
  231. integration = torch.sum(self.synapses.out.reshape((self.n_offspring, self.n_neurons, -1, self.synapses.shape[-1])), dim=2)
  232. # scale by number of synapses
  233. integration /= self.n_syn_per_neuron
  234. self.out_integration = integration
  235. # finally set neuron input to summated connected synapses output
  236. input_to_neurons = integration
  237. out = self.neurons.forward(input_to_neurons)
  238. # output is last neuron output, NOTE: just first channel is returned, since we reshape neurons to channels
  239. self.out = out[:, -self.n_output:, 0].reshape(self.n_offspring, self.n_output)
  240. if self.track_data:
  241. self._track_vis_data(X, input_to_synapses_connected, input_to_neurons)
  242. return self.out
  244. def _track_vis_data(self, X, input_to_synapses_connected, input_to_neurons):
  245. offspring_idx = 0
  246. self.vis_data += [(X[offspring_idx], input_to_neurons[offspring_idx].cpu().numpy(), self.neurons.out[offspring_idx].cpu().numpy(),
  247. input_to_synapses_connected[offspring_idx].cpu().numpy(), self.synapses.out[offspring_idx].cpu().numpy())]
  249. @staticmethod
  250. def plot_network_activity(e, exp_name):
  251. with open(get_data_path(e, exp_name, "GlobalNetwork"), 'rb') as f:
  252. vis_data = pickle.load(f)
  253. X, input_to_neurons, neurons_out, input_to_synapses, synapses_out = map(np.array, zip(*vis_data))
  254. def plot_enu_activity(input, output, title):
  255. n_cells = output.shape[1]
  256. n_cells = np.minimum(10, output.shape[1])
  257. fig, grid = plt.subplots(2, n_cells, sharex='col', sharey='row')
  258. if n_cells==1:
  259. grid[0].plot(input[:, 0, :])
  260. grid[1].plot(output[:, 0, :])
  261. else:
  262. for i in range(n_cells):
  263. grid[0, i].plot(input[:, i, :])
  264. grid[1, i].plot(output[:, i, :])
  265. plt.xlabel("t")
  266. plt.title(title)
  267. #plt.ylabel("")
  268. plt.legend()
  269. plt.figure()
  270. plt.plot(X[:, :, 0])
  271. plot_enu_activity(input_to_neurons, neurons_out, "ENU neuron activity")
  272. plot_enu_activity(input_to_synapses, synapses_out, "ENU synapse activity")
  274. plt.figure()
  275. spike_points = np.where(neurons_out[:, :, 0] > 0)
  276. plt.scatter(spike_points[0], spike_points[1], marker='|')
  278. plt.show()

EnuGlobalNetwork.py at commit f9b879f, under Apache-2.0 · at the source

Overview

Authors: Qian Liang1, Yi Zeng1,2,3,4, Menghaoran Tang3
ORCID iDs: Qian Liang
  1. Brain-inspired Cognitive AI Lab, Institute of Automation, Chinese Academy of Sciences,Beijing, China
  2. 2049 AI Lab, Beijing Institute of AI Safety and Governance, Beijing, China
  3. School of Artificial Intelligence, University of Chinese Academy of Sciences,Beijing, China
  4. Center for Long-term AI, Beijing, China
Institutions: Institute of Automation (China); University of Chinese Academy of Sciences (China)
Journal: Scientific reports, volume 16, issue 1, article 12956
Dates: received 5 February 2025; accepted 4 March 2026; published online 10 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-43529-1 · PMID 41807549 · PMCID PMC13096507 · OpenAlex W7134954717
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), human (organism), cognitive (subfield)
Methods: Single-unit activity, calcium imaging
Keywords: Brain-inspired spiking neural network, Mode perception, Symbolic music learning, Music memory, Music generation, Cognitive neuroscience, Learning and memory, Neural circuits, Psychology, Machine learning, Computational models
MeSH: Auditory Perception*, Learning*, Music*, Nerve Net*, Neural Networks, Computer*, Brain, Humans, Models, Neurological, Neurosciences (* major topic)
Topic: Neuroscience and Music Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Strategic Priority Research Program of the Chinese Academy of Sciences (Grant No.XDB1010302); National Natural Science Foundation of China (Grant No. 62576341)
Citations: not cited yet (Europe PMC); 61 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

lqnankai/Music-Dataset

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: b463e083e1242b54fa2a28203aa548258bd638c9, 27 February 2025
Size: 3 files
Software Heritage: not archived
Found in: the text, “Datasets”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
2 files
At the source: github.com/lqnankai/Music-Dataset

braincog-x/brain-cog

License: Apache-2.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: f9b879f75da2247a9f0c31864a947f0e5d2f3dab, 6 November 2025
Languages: Python (542), Shell (1)
Size: 721 files, 543 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file, environment (requirements.txt, setup.py, examples/decision_making/RL/requirements.txt, examples/Social_Cognition/ToCM/requirements.txt), tests, documentation
Not found: CITATION.cff, continuous integration
Tools: NumPy (283 files), PyTorch (260 files), Matplotlib (75 files), pandas (28 files), SciPy (23 files), Pillow (14 files), seaborn (9 files), scikit-learn (8 files), imageio (6 files), NetworkX (6 files), OpenCV (4 files), TensorFlow (3 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
545 files
At the source: github.com/BrainCog-X/Brain-Cog/tree/main/examples/Knowledge_Representation_and_Reasoning/musicMemory/task

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 543 scripts, each with its path and the digest of its content;
  • 1 match 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.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-43529-1.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 11 keywords, 9 MeSH terms, 2 funders, 37 references.

Cite

This paper

Liang, Q., Zeng, Y., & Tang, M. (2026). A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition. Scientific reports, 16(1), 12956. https://doi.org/10.1038/s41598-026-43529-1

BibTeX

@article{liang2026spiking,
author = {Liang, Qian and Zeng, Yi and Tang, Menghaoran},
title = {{A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition}},
journal = {Scientific reports},
year = {2026},
month = mar,
volume = {16},
number = {1},
pages = {12956},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-43529-1},
url = {https://doi.org/10.1038/s41598-026-43529-1},
pmid = {41807549},
pmcid = {PMC13096507}
}

RIS

TY - JOUR
AU - Liang, Qian
AU - Zeng, Yi
AU - Tang, Menghaoran
TI - A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/03/10
VL - 16
IS - 1
SP - 12956
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-43529-1
UR - https://doi.org/10.1038/s41598-026-43529-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-43529-1",
"type": "article-journal",
"title": "A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition",
"container-title": "Scientific reports",
"author": [
{
"family": "Liang",
"given": "Qian"
},
{
"family": "Zeng",
"given": "Yi"
},
{
"family": "Tang",
"given": "Menghaoran"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "12956",
"DOI": "10.1038/s41598-026-43529-1",
"PMID": "41807549",
"PMCID": "PMC13096507",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-43529-1",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
10
]
]
}
}

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-74358-5 [code]
Brain-inspired spatial intelligence for embodied agents.
Journal: Nature communications
In common: imageio, TensorFlow, NetworkX, 9 other tools, cognitive, 1 reference
[2] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: imageio, TensorFlow, NetworkX, 9 other tools
[3] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: imageio, TensorFlow, NetworkX, 8 other tools
[4] doi:10.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: imageio, TensorFlow, OpenCV, 8 other tools
[5] doi:10.1038/s41593-026-02388-9 [code]
Hippocampal CA3 connectomics reveals a gradient of mossy fiber inputs and selective feedforward inhibition onto pyramidal cells.
Journal: Nature neuroscience
In common: imageio, NetworkX, OpenCV, 8 other tools
[6] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: TensorFlow, NetworkX, OpenCV, 8 other tools
[7] doi:10.1016/j.isci.2026.115488 [code]
An integrated <i>i</i> <i>n vitro</i> platform and biophysical modeling approach for studying synaptic transmission in isolated neuronal pairs.
Journal: iScience
In common: NetworkX, OpenCV, Pillow, 7 other tools, 1 reference
[8] doi:10.1186/s12880-026-02481-2 [code]
Deep learning-based neuroanatomical profiling reveals population-specific brain changes in multiple sclerosis: a large-scale Middle Eastern study.
Journal: BMC medical imaging
In common: imageio, TensorFlow, OpenCV, 7 other tools
[9] doi:10.1038/s41467-026-74357-6 [code]
Hippocampo-neocortical interaction as compressive retrieval-augmented generation.
Journal: Nature communications
In common: NetworkX, Pillow, PyTorch, 6 other tools, computational modeling (no new data), 1 reference
[10] doi:10.1016/j.isci.2026.116168 [code]
See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion.
Journal: iScience
In common: imageio, TensorFlow, OpenCV, 7 other tools

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.