OSCR

Top-down feedback in deep neural networks leads to functional differences during audiovisual integration.

Code ↔ Paper

5 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 5 matches
  1. [1] § Methods › Model ↔ connectome_to_model/model/topdown_gru.py, lines 16–116 · score 0.73 · reset gate, update gate, hidden state, candidate, signal, channel
  2. [2] § Methods › Model ↔ connectome_to_model/model/topdown_gru.py, lines 16–116 · score 0.66 · ConvGRU, hidden state, Gated, cell, reset, signal
  3. [3] § Methods › Audiovisual task training › Training tasks ↔ scripts/multimodal_all_scenarios.py, lines 159–248 · score 0.63 · cross entropy loss, UAM, VS1, UUN, VS2, mismatched
  4. [4] § Methods › Audiovisual task training › Training tasks ↔ scripts/amb_audio_training.py, lines 155–226 · score 0.56 · cross entropy loss, UUN, mismatched, mix, shuffled, matching
  5. [5] § Methods › Stimuli generation and preprocessing › Ambiguous auditory stimuli ↔ connectome_to_model/utils/audio_dataset.py, lines 14–135 · score 0.54 · visual stimuli, 0–1, mel, FSDD, ambiguity, ambiguous

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 · 253 lines · 11 KB · MIT · 2 matches

  1. import os
  2. import torch
  3. from torch import nn
  4. import torch.nn.functional as F
  7. def _resolve_device_dtype(device, dtype):
  8. """Fall back to CUDA when available, otherwise CPU, so the cells run on either."""
  9. if dtype is None:
  10. dtype = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor
  11. if device is None:
  12. device = 'cuda' if torch.cuda.is_available() else 'cpu'
  13. return device, dtype
  16. class ConvGRUBasalTopDownCell(nn.Module):
  17. def __init__(self, input_size, input_dim, hidden_dim, kernel_size,
  18. basal_topdown_dim=0,
  19. apical_topdown_dim=0,
  20. bias=True,
  21. device=None,
  22. dtype=None):
  23. """
  24. Single ConvGRU block with topdown
  25. :param input_size: (int, int)
  26. Height and width of input tensor as (height, width).
  27. :param input_dim: int
  28. Number of channels of input tensor.
  29. :param hidden_dim: int
  30. Number of channels of hidden state.
  31. :param kernel_size: (int, int)
  32. Size of the convolutional kernel.
  33. :param apical_mechanism (str)
  34. 'multiplicative' or 'composite', how to combine top-down info within the block
  35. :param basal_topdown_dim (int)
  36. if there's no basal topdown input, use 0
  37. :param bias: bool
  38. Whether or not to add the bias.
  39. :param dtype: torch.cuda.FloatTensor or torch.FloatTensor
  40. Whether or not to use cuda.
  41. """
  42. super(ConvGRUBasalTopDownCell, self).__init__()
  43. self.height, self.width = input_size
  44. self.padding = kernel_size[0] // 2, kernel_size[1] // 2
  45. self.hidden_dim = hidden_dim
  46. self.bias = bias
  47. self.apical_topdown_dim = apical_topdown_dim
  48. self.basal_topdown_dim = basal_topdown_dim
  49. self.device, self.dtype = _resolve_device_dtype(device, dtype)
  51. # Basal compartment
  52. if basal_topdown_dim == 0:
  53. self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,
  54. out_channels=2*self.hidden_dim, # for update_gate,reset_gate + 2*topdown
  55. kernel_size=kernel_size,
  56. padding= (kernel_size[0] // 2, kernel_size[1] // 2),
  57. bias=self.bias)
  58. else:
  59. self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim + basal_topdown_dim,
  60. out_channels=2*self.hidden_dim, # for update_gate,reset_gate + 2*topdown
  61. kernel_size=kernel_size,
  62. padding= (kernel_size[0] // 2, kernel_size[1] // 2),
  63. bias=self.bias)
  65. # Apical compartment
  66. self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim+apical_topdown_dim,
  67. out_channels=self.hidden_dim, # for candidate neural memory
  68. kernel_size=kernel_size,
  69. padding=self.padding,
  70. bias=self.bias)
  72. def init_hidden(self, batch_size):
  73. return torch.zeros(batch_size, self.hidden_dim, self.height, self.width).type(self.dtype)
  75. def forward(self, input_tensor, h_cur, topdown):
  76. """
  77. :param self:
  78. :param input_tensor: (b, c, h, w)
  79. input is actually the target_model
  80. :param h_cur: (b, c_hidden, h, w)
  81. current hidden and cell states respectively
  82. :return: topdown: (b, c_topdown, h, w),
  83. topdown signal, either a direct clue or hidden of top layer
  84. """
  85. b, in_dim, h, w = input_tensor.shape
  86. mult_topdown_dim = in_dim + self.hidden_dim + 2*self.apical_topdown_dim
  87. if topdown is None:
  88. topdown = torch.zeros(b, mult_topdown_dim + self.basal_topdown_dim, h, w, device=input_tensor.device)
  90. # BASAL COMPARTMENT
  91. if self.basal_topdown_dim != 0:
  92. basal_topdown, topdown = torch.split(topdown, (self.basal_topdown_dim, topdown.shape[1]-self.basal_topdown_dim), dim=1)
  93. combined = torch.cat([input_tensor, h_cur, basal_topdown], dim=1)
  94. else:
  95. combined = torch.cat([input_tensor, h_cur], dim=1)
  97. combined_conv = self.conv_gates(combined)
  99. gamma, beta = torch.split(combined_conv, self.hidden_dim, dim=1)
  100. reset_gate = torch.sigmoid(gamma)
  101. update_gate = torch.sigmoid(beta)
  103. # APICAL COMPARTMENT
  104. if self.apical_topdown_dim != 0:
  105. add_topdown, mult_topdown = torch.split(topdown, (self.apical_topdown_dim, mult_topdown_dim - self.apical_topdown_dim), dim=1)
  106. combined = torch.cat([input_tensor, reset_gate*h_cur, add_topdown], dim=1) * (F.relu(mult_topdown) + 1)
  107. else:
  108. # multiplicative topdown
  109. combined = torch.cat([input_tensor, reset_gate*h_cur], dim=1) * (F.relu(topdown) + 1)
  111. cc_cnm = self.conv_can(combined)
  112. cnm = torch.tanh(cc_cnm)
  114. # MEMORY UPDATE
  115. h_next = (1 - update_gate) * h_cur + update_gate * cnm
  116. return h_next
  119. class ConvGRUTopDownCell(nn.Module):
  120. def __init__(self, input_size, input_dim, hidden_dim, kernel_size,
  121. topdown_type='multiplicative',
  122. bias=True,
  123. device=None,
  124. dtype=None):
  125. """
  126. Single ConvGRU block with topdown
  127. :param input_size: (int, int)
  128. Height and width of input tensor as (height, width).
  129. :param input_dim: int
  130. Number of channels of input tensor.
  131. :param hidden_dim: int
  132. Number of channels of hidden state.
  133. :param kernel_size: (int, int)
  134. Size of the convolutional kernel.
  135. :param topdown_type (str)
  136. 'multiplicative' or 'composite', how to combine top-down info within the block
  137. :param bias: bool
  138. Whether or not to add the bias.
  139. :param dtype: torch.cuda.FloatTensor or torch.FloatTensor
  140. Whether or not to use cuda.
  141. """
  142. super(ConvGRUTopDownCell, self).__init__()
  143. self.height, self.width = input_size
  144. self.padding = kernel_size[0] // 2, kernel_size[1] // 2
  145. self.hidden_dim = hidden_dim
  146. self.bias = bias
  147. self.device, self.dtype = _resolve_device_dtype(device, dtype)
  148. self.topdown_type = topdown_type
  150. if self.topdown_type == 'multiplicative':
  151. self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,
  152. out_channels=2*self.hidden_dim, # for update_gate,reset_gate + 2*topdown
  153. kernel_size=kernel_size,
  154. padding= (kernel_size[0] // 2, kernel_size[1] // 2),
  155. bias=self.bias)
  156. elif self.topdown_type == 'composite':
  157. self.conv_gates = nn.Conv2d(in_channels=(input_dim + hidden_dim)*2,
  158. out_channels=2*self.hidden_dim, # for update_gate,reset_gate + 2*topdown
  159. kernel_size=kernel_size,
  160. padding= (kernel_size[0] // 2, kernel_size[1] // 2),
  161. bias=self.bias)
  162. else:
  163. raise ValueError(f"Unknown topdown_type '{topdown_type}'; expected 'multiplicative' or 'composite'")
  165. self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,
  166. out_channels=self.hidden_dim, # for candidate neural memory
  167. kernel_size=kernel_size,
  168. padding=self.padding,
  169. bias=self.bias)
  171. def init_hidden(self, batch_size):
  172. return torch.zeros(batch_size, self.hidden_dim, self.height, self.width).type(self.dtype)
  174. def forward(self, input_tensor, h_cur, topdown):
  175. """
  176. :param self:
  177. :param input_tensor: (b, c, h, w)
  178. input is actually the target_model
  179. :param h_cur: (b, c_hidden, h, w)
  180. current hidden and cell states respectively
  181. :return: topdown: (b, c_topdown, h, w),
  182. topdown signal, either a direct clue or hidden of top layer
  183. """
  184. combined = torch.cat([input_tensor, h_cur], dim=1)
  185. if topdown is None:
  186. topdown = torch.zeros_like(combined)
  187. if self.topdown_type == 'composite':
  188. combined = torch.cat([input_tensor, h_cur, topdown], dim=1)
  190. combined_conv = self.conv_gates(combined)
  192. gamma, beta = torch.split(combined_conv, self.hidden_dim, dim=1)
  193. reset_gate = torch.sigmoid(gamma)
  194. update_gate = torch.sigmoid(beta)
  196. combined = torch.cat([input_tensor, reset_gate*h_cur], dim=1) * (F.relu(topdown) + 1)
  197. cc_cnm = self.conv_can(combined)
  198. cnm = torch.tanh(cc_cnm)
  200. h_next = (1 - update_gate) * h_cur + update_gate * cnm
  201. return h_next
  203. class ILC_upsampler(nn.Module):
  204. def __init__(self, in_channel, out_channel, stride, device='cuda'):
  205. """
  206. Projection layer for upsampling. Prevents checkerboard effect of a single ConvT
  208. :param in_channel (int)
  209. :param out_channel (int)
  210. :param stride (int)
  211. """
  212. super(ILC_upsampler, self).__init__()
  213. self.c1 = nn.Sequential(nn.ConvTranspose2d(in_channels=in_channel,
  214. out_channels=out_channel,
  215. kernel_size=(1,1),
  216. stride=stride, device=device
  217. ),
  218. nn.ReLU(),
  219. nn.ZeroPad2d((0,1,0,1))
  220. )
  221. self.c2 = nn.Sequential(nn.ConvTranspose2d(in_channels=in_channel,
  222. out_channels=out_channel,
  223. kernel_size=(1,1),
  224. stride=stride, device=device
  225. ),
  226. nn.ReLU(),
  227. nn.ZeroPad2d((1,0,1,0))
  228. )
  229. self.c3 = nn.Sequential(nn.ConvTranspose2d(in_channels=in_channel,
  230. out_channels=out_channel,
  231. kernel_size=(1,1),
  232. stride=stride, device=device
  233. ),
  234. nn.ReLU(),
  235. nn.ZeroPad2d((1,0,0,1))
  236. )
  237. self.c4 = nn.Sequential(nn.ConvTranspose2d(in_channels=in_channel,
  238. out_channels=out_channel,
  239. kernel_size=(1,1),
  240. stride=stride, device=device
  241. ),
  242. nn.ReLU(),
  243. nn.ZeroPad2d((0,1,1,0))
  244. )
  246. def forward(self, z):
  247. c1_out=self.c1(z)
  248. c2_out=self.c2(z)
  249. c3_out=self.c3(z)
  250. c4_out=self.c4(z)
  251. upsampled_z=c1_out+c2_out+c3_out+c4_out
  253. return upsampled_z

topdown_gru.py at commit 8346d1c, under MIT · at the source

Overview

Authors: Mashbayar Tugsbayar1,2, Mingze Li1,2, Eilif B Muller2,3,4, Blake Richards1,2
ORCID iDs: Mashbayar Tugsbayar, Mingze Li, Eilif B Muller, Blake Richards
  1. McGill University, Montréal, Canada
  2. Mila Quebec AI Institute, Montréal, Canada
  3. Department of Neurosciences, Faculty of Medicine, Université de Montréal, Montréal, Canada
  4. Centre de Recherche Azrieli du CHU Sainte-Justine, Montréal, Canada
Institutions: Mila - Quebec Artificial Intelligence Institute (Canada); McGill University (Canada); CHU Sainte-Justine Research Center (Canada); Université de Montréal (Canada)
Journal: eLife, volume 14, article RP105953
Dates: published online 26 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.105953 · PMID 42647275 · PMCID PMC13516690 · OpenAlex W4409283275
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism)
Methods: Spectral & time-frequency, Statistics, Machine learning, fMRI & imaging
Keywords: None
MeSH: Auditory Perception*, Neocortex*, Neural Networks, Computer*, Visual Perception*, Humans, Models, Neurological, Recurrent Neural Networks (* major topic)
Topic: Multisensory perception and integration (Experimental and Cognitive Psychology, Psychology), according to OpenAlex
Funding: Natural Sciences and Engineering Research Council of Canada (RGPAS-2020-00031, 566355-2022, RGPIN-2020-05105); McGill University (Healthy Brains Healthy Lives Graduate Fellowship)
Citations: not cited yet (Europe PMC); 83 references in the paper

Abstract

Artificial neural networks (ANNs) are an important tool for studying neural computation, but many features of the brain are not captured by standard ANN architectures. One notable missing feature in most ANN models is top-down feedback, that is projections from higher-order layers to lower-order layers in the network. Top-down feedback is ubiquitous in the brain, and it has a unique modulatory impact on activity in neocortical pyramidal neurons. However, we still do not understand its computational role. Here, we develop a deep neural network model that captures the core functional properties of top-down feedback in the neocortex, allowing us to construct hierarchical recurrent ANN models that more closely reflect the architecture of the brain. We use this to explore the impact of different hierarchical recurrent architectures on an audiovisual integration task. We find that certain hierarchies, namely those that mimic the architecture of the human brain, impart ANN models with a light visual bias similar to that seen in humans. This bias does not impair performance on the audiovisual tasks. The results further suggest that different configurations of top-down feedback make otherwise identically connected models functionally distinct from each other, and from traditional feedforward and laterally recurrent models. Altogether, our findings demonstrate that modulatory top-down feedback is a computationally relevant feature of biological brains, and that incorporating it into ANNs affects their behavior and constrains the solutions it is likely to discover.

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

Repositories

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

masht18/connectome-to-model

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 8346d1ce74d7bab27f5f297d443ab7195a5e35b8, 12 June 2026
Languages: Python (18), Jupyter (1)
Size: 26 files, 19 scripts
Software Heritage: archived
Found in: the references
Holds: README, environment (requirements.txt, setup.py), tests, documentation, 1 notebook
Not found: license file, CITATION.cff, continuous integration
Tools: PyTorch (18 files), NumPy (6 files), SciPy (6 files), pandas (4 files), Matplotlib (3 files), scikit-learn (3 files), Pillow (1 file), UMAP (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
20 files
At the source: archive.softwareheritage.org/swh:1:dir:169536ee084b00be2cfb64302aca8cf5fba61d63;origin=https://github.com/masht18/connectome-to-model;visit=swh:1:snp:14633c3a8fa73e27676fad7f0af63f0458d4c74d;anchor=swh:1:rev:8346d1ce74d7bab27f5f297d443ab7195a5e35b8

ABL-Lab/ambiguous-dataset

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 12b891d7dbf7ac4ccc98acc3ad52497451d9d546, 25 April 2024
Languages: Python (17), Shell (4), Jupyter (2)
Size: 41 files, 23 scripts
Software Heritage: not archived
Found in: “Code and data availability”
Holds: README, license file, environment (requirements.txt, setup.cfg, setup.py, tests/requirements.txt), tests, continuous integration, 2 notebooks
Not found: CITATION.cff, documentation
Tools: PyTorch (12 files), NumPy (10 files), Matplotlib (9 files), h5py (6 files), PyTorch Lightning (4 files), seaborn (4 files), scikit-learn (3 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
25 files
At the source: github.com/ABL-Lab/ambiguous-dataset

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;
  • 42 scripts, each with its path and the digest of its content;
  • 5 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.

Code and data availability

The toolbox used to convert graphs to top-down recurrent neural networks (Connectome-to-Model) is publicly available at https://github.com/masht18/connectome-to-model, copy archived at Tugsbayar et al., 2026. The task training scripts and graphs are also available at the same repository.

The structural connectivity and histological data used to build the human brainlike model rely on the open-source Microstructure-Informed Connectomics (MICA-MICs) dataset (doi: 10.1101/2021.08.04.454795 (https://doi.org/10.1101/2021.08.04.454795)) and the BigBrain quantitative 3D laminar atlas (doi: 10.1126/science.1235381 (https://doi.org/10.1126/science.1235381)).

The unambiguous audiovisual task stimuli are derived from the publicly available MNIST handwritten digit database and the FSDD. Ambiguous visual stimuli were sourced from Islah et al., 2023: (https://github.com/ABL-Lab/ambiguous-dataset).

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

Data availability

Code for running all the experiments, constructing the models, and preprocessing FSDD datasets can be found at the open source codebase of the paper: https://github.com/masht18/connectome-to-model (copy archived at Tugsbayar et al., 2026).

The following previously published datasets were used:

Islah N, Tugsbayar M, Gurbuz BT, Richards B, Muller EB, Etter G. 2025. Ambigious MNIST. GitHub. ABL-Lab/ambiguous-dataset

Jackson Z, Souza C, Flaks J, Pan Y, Nicolas H. 2018. Free Spoken Digit Dataset (FSDD) GitHub. Jakobovski/free-spoken-digit-dataset

Royer J, Rodriguez-Cruces R, Tavakol S, Lariviere S, Herholz P, Li Q, Wael R, Paquola C, Benkarim O, Park B, Lowe AJ, Margulies D, Smallwood J, Bernasconi A, Bernasconi N, Frauscher B, Bernhardt BC. 2023. MICA-MICs. CONP. mica-mics

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

Recorded: type, language, journal, volume, pages, dates, 4 authors, 1 keyword, 7 MeSH terms, 2 funders, 74 references.

Cite

This paper

Tugsbayar, M., Li, M., Muller, E. B., & Richards, B. (2026). Top-down feedback in deep neural networks leads to functional differences during audiovisual integration. eLife, 14, RP105953. https://doi.org/10.7554/elife.105953

BibTeX

@article{tugsbayar2026top,
author = {Tugsbayar, Mashbayar and Li, Mingze and Muller, Eilif B and Richards, Blake},
title = {{Top-down feedback in deep neural networks leads to functional differences during audiovisual integration}},
journal = {eLife},
year = {2026},
month = aug,
volume = {14},
pages = {RP105953},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.105953},
url = {https://doi.org/10.7554/elife.105953},
pmid = {42647275},
pmcid = {PMC13516690}
}

RIS

TY - JOUR
AU - Tugsbayar, Mashbayar
AU - Li, Mingze
AU - Muller, Eilif B
AU - Richards, Blake
TI - Top-down feedback in deep neural networks leads to functional differences during audiovisual integration
T2 - eLife
J2 - eLife
PY - 2026
DA - 2026/08/26
VL - 14
SP - RP105953
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.105953
UR - https://doi.org/10.7554/elife.105953
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.105953",
"type": "article-journal",
"title": "Top-down feedback in deep neural networks leads to functional differences during audiovisual integration",
"container-title": "eLife",
"author": [
{
"family": "Tugsbayar",
"given": "Mashbayar"
},
{
"family": "Li",
"given": "Mingze"
},
{
"family": "Muller",
"given": "Eilif B"
},
{
"family": "Richards",
"given": "Blake"
}
],
"container-title-short": "eLife",
"volume": "14",
"page": "RP105953",
"DOI": "10.7554/elife.105953",
"PMID": "42647275",
"PMCID": "PMC13516690",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.105953",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
26
]
]
}
}

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.7554/elife.105968 [code]
Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms.
Journal: eLife
In common: PyTorch Lightning, Pillow, PyTorch, 3 other tools, 5 references, author Blake Richards
[2] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: h5py, Pillow, PyTorch, 6 other tools, 7 references
[3] doi:10.1038/s41467-026-72146-9 [code]
Modeling attention and binding in the brain through bidirectional recurrent gating.
Journal: Nature communications
In common: Pillow, PyTorch, seaborn, 3 other tools, 7 references
[4] doi:10.1038/s42003-026-10169-0 [code]
Shared representations in brains and models reveal a two-route cortical organization during scene perception.
Journal: Communications biology
In common: h5py, Pillow, PyTorch, 6 other tools, 4 references
[5] doi:10.1371/journal.pcbi.1014164 [code]
'Backpropagation and the brain' realized in cortical error neuron microcircuits.
Journal: PLoS computational biology
In common: PyTorch, SciPy, Matplotlib, 1 other tool, 6 references
[6] doi:10.1038/s41467-026-76939-w [code]
HIPPIE: a generative model for electrophysiological analysis across species, technologies, and modalities.
Journal: Nature communications
In common: PyTorch Lightning, UMAP, h5py, 8 other tools
[7] doi:10.1162/imag.a.1207 [code]
Investigating the temporal dynamics and modeling of mid-level feature representations in humans.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PyTorch Lightning, Pillow, PyTorch, 6 other tools, 2 references
[8] doi:10.1038/s41467-026-74460-8 [code]
Spike-based alignment learning solves the weight transport problem.
Journal: Nature communications
In common: PyTorch, seaborn, scikit-learn, 4 other tools, 4 references
[9] doi:10.1371/journal.pbio.3003915 [code]
Noise-invariant representations of sound emerge along the canonical cortical hierarchy.
Journal: PLoS biology
In common: UMAP, h5py, Pillow, 7 other tools, 1 reference
[10] doi:10.1371/journal.pcbi.1014263 [code]
MIRAGE: Robust multi-modal architectures translate fMRI-to-image models from vision to mental imagery.
Journal: PLoS computational biology
In common: PyTorch Lightning, UMAP, h5py, 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.