OSCR

Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments.

Code ↔ Paper

21 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 21 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Author Response ↔ src/vak/metrics/boundary_detection/_boundary_detection.py, lines 9–149 · score 0.80 · IEEE International Conference, deep learning, Signal Processing, Speech, Computational, Acoustics
  2. [2] § Materials and Methods › Architecture of MooveTAF ↔ moove/models/CNN.py, the whole file · a weak match · score 0.72 · LeakyReLU, Conv2d, CNN, softmax, Dropout, flatten
  3. [3] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Classification network training ↔ moove/utils/training_utils.py, lines 495–550 · score 0.72 · cross entropy loss, class weighting, Adam, augmentation, imbalance, patience
  4. [4] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Segmentation network training ↔ moove/utils/training_utils.py, lines 495–550 · score 0.69 · cross entropy loss, class weighting, Adam, imbalance, patience, epochs
  5. [5] § Materials and Methods › Architecture of MooveTAF ↔ src/vak/nets/tweetynet.py, lines 53–173 · score 0.68 · ReLU, convolutional neural network, Sliding window, Dropout, CNN, layer
  6. [6] § Author Response ↔ src/vak/models/tweetynet.py, lines 19–77 · score 0.66 · cross entropy, classification models, neural networks, PyTorch, acc, tolerance
  7. [7] § Author Response ↔ src/vak/nets/tweetynet.py, lines 11–51 · score 0.63 · fully connected, spectrogram window, TweetyNet, CNN, maps, network
  8. [8] § Author Response ↔ src/vak/models/frame_classification_model.py, lines 21–87 · score 0.62 · frame classification models, neural network models, post processing, timebin, transformer, predictions
  9. [9] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Classification network training ↔ moove/app_state.py, lines 52–178 · score 0.60 · compression, augmentation, imbalance, noise, weighting, masking
  10. [10] § Author Response ↔ src/vak/metrics/boundary_detection/_boundary_detection.py, lines 9–149 · score 0.60 · information retrieval, mitigate, collar, PyTorch, tolerance, milliseconds
  11. [11] § Author Response ↔ src/vak/datapipes/frame_classification/train_datapipe.py, lines 63–170 · score 0.59 · audio samples, neural network models, frame classification, timebin, transformer, spectrogram
  12. [12] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Syllable spectrogram calculation ↔ src/vak/prep/spectrogram_dataset/spect.py, lines 28–106 · score 0.59 · Fourier transform, frequency cutoffs, FFT, spectrograms, window
  13. [13] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Syllable spectrogram calculation ↔ src/vak/config/spect_params.py, lines 31–82 · score 0.59 · Fourier transform, frequency cutoffs, FFT, spectrograms, window
  14. [14] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Segmentation network training ↔ src/vak/models/tweetynet.py, lines 19–77 · score 0.58 · cross entropy loss, Adam optimizer, class, frames, network, Segmented
  15. [15] § Materials and Methods › MooveGUI: data preprocessing, labeling, and network training › Energy-based segmentation ↔ moove/moovetaf.py, lines 481–527 · score 0.57 · bandpass filtering, raw audio, smoothing, threshold, bout
  16. [16] § Materials and Methods › Architecture of MooveTAF ↔ moove/moovetaf.py, lines 834–866 · score 0.57 · catch trial, target sequence, stimulus, MooveTAF, WN, playback
  17. [17] § Author Response ↔ src/vak/nets/tweetynet.py, lines 53–173 · score 0.54 · recurrent layers, TweetyNet, song, predicting, models, windows
  18. [18] § Author Response ↔ src/vak/nets/tweetynet.py, lines 11–51 · score 0.54 · bidirectional LSTM, neural network architectures
  19. [19] § Author Response ↔ src/vak/config/prep.py, lines 72–147 · score 0.54 · silent gaps, post processing, songbird, class, frame, syllable
  20. [20] § Author Response ↔ src/vak/datasets/cmacbench.py, lines 256–377 · score 0.51 · cross entropy loss, binary frame, window, classification
  21. [21] § Author Response ↔ src/vak/models/frame_classification_model.py, lines 21–87 · score 0.51 · Frame classification models, post processing, neural network, vocalized, offsets, sequences

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 · 187 lines · 7.1 KB · BSD-3-Clause · 4 matches

  1. """TweetyNet model"""
  3. from __future__ import annotations
  5. import torch
  6. from torch import nn
  8. from ..nn.modules import Conv2dTF
  11. class TweetyNet(nn.Module):
  12. """Neural network architecture
  13. that assign labels to time bins
  14. ("frames") in spectrogram windows.
  16. as described in
  17. https://elifesciences.org/articles/63853
  18. https://github.com/yardencsGitHub/tweetynet
  20. Cohen, Y., Nicholson, D. A., Sanchioni, A., Mallaber, E. K., Skidanova, V., & Gardner, T. J. (2022).
  21. Automated annotation of birdsong with a neural network that segments spectrograms. Elife, 11, e63853.
  23. Attributes
  24. ----------
  25. num_classes : int
  26. Number of classes.
  27. One of the two dimensions of the output.
  28. input_shape : tuple(int)
  29. With dimensions
  30. (channels, num. frequency bins, num. time bins in window).
  31. cnn : torch.nn.Sequential
  32. Convolutional layers of model.
  33. rnn_input_size : int
  34. Size of input to TweetyNet.rnn.
  35. Will be the product of the first two dimensions
  36. of the output of ``TweetyNet.cnn``,
  37. i.e. the number of output channels times
  38. the number of elements in the dimension
  39. that corresponds to frequency bins in the input.
  40. rnn : torch.nn.LSTM
  41. Bidirectional LSTM layer,
  42. that receives output of ``TweetyNet.cnn``.
  43. fc : torch.nn.Linear
  44. Finally fully-connected layer that maps
  45. the output of ``TweetyNet.rnn`` to a
  46. matrix of size (num. time bins in window, num. classes).
  48. Notes
  49. -----
  50. This is the network used by ``vak.models.TweetyNetModel``.
  51. """
  53. def __init__(
  54. self,
  55. num_classes,
  56. num_input_channels=1,
  57. num_freqbins=256,
  58. padding="SAME",
  59. conv1_filters=32,
  60. conv1_kernel_size=(5, 5),
  61. conv2_filters=64,
  62. conv2_kernel_size=(5, 5),
  63. pool1_size=(8, 1),
  64. pool1_stride=(8, 1),
  65. pool2_size=(8, 1),
  66. pool2_stride=(8, 1),
  67. hidden_size=None,
  68. rnn_dropout=0.0,
  69. num_layers=1,
  70. bidirectional=True,
  71. ):
  72. """initialize TweetyNet model
  74. Parameters
  75. ----------
  76. num_classes : int
  77. Number of classes to predict, e.g., number of syllable classes in an individual bird's song
  78. num_input_channels: int
  79. Number of channels in input. Typically one, for a spectrogram.
  80. Default is 1.
  81. num_freqbins: int
  82. Number of frequency bins in spectrograms that will be input to model.
  83. Default is 256.
  84. padding : str
  85. type of padding to use, one of {"VALID", "SAME"}. Default is "SAME".
  86. conv1_filters : int
  87. Number of filters in first convolutional layer. Default is 32.
  88. conv1_kernel_size : tuple
  89. Size of kernels, i.e. filters, in first convolutional layer. Default is (5, 5).
  90. conv2_filters : int
  91. Number of filters in second convolutional layer. Default is 64.
  92. conv2_kernel_size : tuple
  93. Size of kernels, i.e. filters, in second convolutional layer. Default is (5, 5).
  94. pool1_size : two element tuple of ints
  95. Size of sliding window for first max pooling layer. Default is (1, 8)
  96. pool1_stride : two element tuple of ints
  97. Step size for sliding window of first max pooling layer. Default is (1, 8)
  98. pool2_size : two element tuple of ints
  99. Size of sliding window for second max pooling layer. Default is (1, 8),
  100. pool2_stride : two element tuple of ints
  101. Step size for sliding window of second max pooling layer. Default is (1, 8)
  102. hidden_size : int
  103. number of features in the hidden state ``h``. Default is None,
  104. in which case ``hidden_size`` is set to the dimensionality of the
  105. output of the convolutional neural network. This default maintains
  106. the original behavior of the network.
  107. rnn_dropout : float
  108. If non-zero, introduces a Dropout layer on the outputs of each LSTM layer except the last layer,
  109. with dropout probability equal to dropout. Default: 0
  110. num_layers : int
  111. Number of recurrent layers. Default is 1.
  112. bidirectional : bool
  113. If True, make LSTM bidirectional. Default is True.
  114. """
  115. super().__init__()
  116. self.num_classes = num_classes
  117. self.num_input_channels = num_input_channels
  118. self.num_freqbins = num_freqbins
  120. self.cnn = nn.Sequential(
  121. Conv2dTF(
  122. in_channels=self.num_input_channels,
  123. out_channels=conv1_filters,
  124. kernel_size=conv1_kernel_size,
  125. padding=padding,
  126. ),
  127. nn.ReLU(inplace=True),
  128. nn.MaxPool2d(kernel_size=pool1_size, stride=pool1_stride),
  129. Conv2dTF(
  130. in_channels=conv1_filters,
  131. out_channels=conv2_filters,
  132. kernel_size=conv2_kernel_size,
  133. padding=padding,
  134. ),
  135. nn.ReLU(inplace=True),
  136. nn.MaxPool2d(kernel_size=pool2_size, stride=pool2_stride),
  137. )
  139. # determine number of features in output after stacking channels
  140. # we use the same number of features for hidden states
  141. # note self.num_hidden is also used to reshape output of cnn in self.forward method
  142. N_DUMMY_TIMEBINS = (
  143. 256 # some not-small number. This dimension doesn't matter here
  144. )
  145. batch_shape = (
  146. 1,
  147. self.num_input_channels,
  148. self.num_freqbins,
  149. N_DUMMY_TIMEBINS,
  150. )
  151. tmp_tensor = torch.rand(batch_shape)
  152. tmp_out = self.cnn(tmp_tensor)
  153. channels_out, freqbins_out = tmp_out.shape[1], tmp_out.shape[2]
  154. self.rnn_input_size = channels_out * freqbins_out
  156. if hidden_size is None:
  157. self.hidden_size = self.rnn_input_size
  158. else:
  159. self.hidden_size = hidden_size
  161. self.rnn = nn.LSTM(
  162. input_size=self.rnn_input_size,
  163. hidden_size=self.hidden_size,
  164. num_layers=num_layers,
  165. dropout=rnn_dropout,
  166. bidirectional=bidirectional,
  167. )
  169. # for self.fc, in_features = hidden_size * 2 because LSTM is bidirectional
  170. # so we get hidden forward + hidden backward as output
  171. self.fc = nn.Linear(
  172. in_features=self.hidden_size * 2, out_features=num_classes
  173. )
  175. def forward(self, x):
  176. features = self.cnn(x)
  177. # stack channels, to give tensor shape (batch, rnn_input_size, num time bins)
  178. features = features.view(features.shape[0], self.rnn_input_size, -1)
  179. # switch dimensions for feeding to rnn, to (num time bins, batch size, input size)
  180. features = features.permute(2, 0, 1)
  181. rnn_output, _ = self.rnn(features)
  182. # permute back to (batch, time bins, hidden size) to project features down onto number of classes
  183. rnn_output = rnn_output.permute(1, 0, 2)
  184. logits = self.fc(rnn_output)
  185. # permute yet again so that dimension order is (batch, classes, time steps)
  186. # because this is order that loss function expects
  187. return logits.permute(0, 2, 1)

tweetynet.py at commit 66b0f4b, under BSD-3-Clause · at the source

Overview

Authors: Nils Riekers1, Jacqueline Laura Göbl1, Franziska Heubach1, Lena Veit1
ORCID iDs: Nils Riekers, Lena Veit
  1. Neurobiology of Vocal Communication, Institute for Neurobiology, University of Tübingen, Tübingen 72076, Germany
Institutions: University of Tübingen (Germany)
Journal: eNeuro, volume 13, issue 7, pages ENEURO.0023-26.2026
Dates: received 26 January 2026; accepted 28 May 2026; published online 30 June 2026; in print July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1523/eneuro.0023-26.2026 · PMID 42315338 · PMCID PMC13326709 · OpenAlex W4417534590
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.64898/2025.12.19.695629
Status: code verified
Categories: other (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Smoothing, state filtering, decompositions, Machine learning, Statistics
Keywords: annotation, closed-loop, labeling, vocal sequence, vocalization, voice activity detection
MeSH: Finches*, Learning*, Neural Networks, Computer*, Vocalization, Animal*, Animals, Male (* major topic)
Topic: Animal Vocal Communication and Behavior (Developmental Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (536953998, 532521431); Eberhard Karls Universität Tübingen
Citations: not cited yet (Europe PMC); 68 references in the paper

Abstract

Songbirds are essential for studying neuronal mechanisms of learned vocalizations. Closed-loop interventions require online recognition of a specific target syllable while the bird is singing, for example, for manipulation of auditory feedback, song-triggered neuronal microstimulation or optogenetics. Existing tools for closed-loop interventions can recognize only single syllables through manually created templates, with limited flexibility to adapt to new experiments. We here present Moove (Marking Online using only the Onsets of Vocal Elements), a novel neural network approach to real-time syllable segmentation and classification of Bengalese finch songs. Moove's two-stage architecture detects syllable onsets and offsets and classifies syllables using acoustic information only from the first part of the syllable, enabling precise temporal contingency between behavior and feedback. We verify Moove's fast and accurate online annotation of all recorded syllables in five adult male Bengalese finches (Lonchura striata domestica). To validate Moove as a tool for learning experiments, we trained one adult male Bengalese finch with an established protocol: a specific target syllable is covered with noise, which masks auditory feedback and leads the bird to introduce specific modifications to syllable sequencing. The trained bird learned to avoid the targeted syllable sequence with comparable outcomes to previous reinforcement learning experiments. Our results show that Moove can correctly segment and classify Bengalese finch syllables in real time, with speed and reliability that allows effective operant conditioning experiments. Moove could be used for other closed-loop experiments on vocal signals, making it a crucial tool for future investigations of birdsong sequencing.

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 21 matches between paragraphs and lines of code.

veitlab/moove

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: e56daf7c3689332260a487a5684e2f80a58f2461, 22 May 2026
Languages: Python (39)
Size: 127 files, 39 scripts
Software Heritage: not archived
Found in: “Code accessibility”
Holds: README, license file, environment (pyproject.toml, uv.lock, conda.recipe/conda_build_config.yaml), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: NumPy (18 files), PyTorch (10 files), SciPy (9 files), Matplotlib (7 files), pandas (4 files), scikit-learn (2 files), Pillow (1 file), Plotly (1 file), seaborn (1 file), UMAP (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
41 files
At the source: github.com/veitlab/moove

vocalpy/vak

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 66b0f4b58a12eabe5fef8ab78d4cfb07e919e4e8, 13 March 2026
Languages: Python (292)
Size: 368 files, 292 scripts
Software Heritage: archived
Found in: the text, “Author Response”
Holds: README, license file, CITATION.cff, environment (pyproject.toml), tests, continuous integration, documentation
Tools: PyTorch (55 files), pandas (48 files), NumPy (46 files), PyTorch Lightning (13 files), SciPy (6 files), Numba (5 files), Matplotlib (4 files), UMAP (2 files), Keras (1 file), scikit-learn (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
294 files
At the source: github.com/vocalpy/vak/blob/main/src/vak/common/tensorboard.py

python-poetry/poetry

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 135631bbb93ed05834ea53a1367d7966880e2db5, 27 September 2026
Languages: Python (451), Shell (2), C (1)
Size: 1,022 files, 454 scripts
Software Heritage: archived
Found in: the text, “Author Response”
Holds: README, license file, CITATION.cff, environment (poetry.lock, pyproject.toml, tests/fixtures/build_constraints/pyproject.toml, tests/fixtures/build_constraints_empty/pyproject.toml, tests/fixtures/build_system_requires_not_available/pyproject.toml, tests/fixtures/deleted_directory_dependency/poetry.lock, tests/fixtures/deleted_directory_dependency/pyproject.toml, tests/fixtures/deleted_file_dependency/poetry.lock, tests/fixtures/deleted_file_dependency/pyproject.toml, tests/fixtures/excluded_subpackage/pyproject.toml, tests/fixtures/extended_project/pyproject.toml, tests/fixtures/extended_project_without_setup/pyproject.toml), tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
456 files
At the source: github.com/python-poetry/poetry/issues/10029

Code accessibility

The code/software described in the paper is freely available online at https://github.com/veitlab/moove and is available as Extended Data 1 (https://doi.org/10.1523/ENEURO.0023-26.2026.d1). The code is implemented in Python and was primarily developed and tested on a standard desktop PC with an Intel Core i5 CPU running Windows 11. It is compatible with common operating systems and off-the-shelf audio interfaces, and no specialized hardware is required.

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

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:

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

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 2, 28 September 2026

  • Funding: added Deutsche Forschungsgemeinschaft: 536953998, 532521431; Eberhard Karls Universität Tübingen

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 6 keywords, 6 MeSH terms, 59 references.

Cite

This paper

Riekers, N., Göbl, J. L., Heubach, F., & Veit, L. (2026). Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments. eNeuro, 13(7), ENEURO.0023-26.2026. https://doi.org/10.1523/eneuro.0023-26.2026

BibTeX

@article{riekers2026real,
author = {Riekers, Nils and Göbl, Jacqueline Laura and Heubach, Franziska and Veit, Lena},
title = {{Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments}},
journal = {eNeuro},
year = {2026},
month = jul,
volume = {13},
number = {7},
pages = {ENEURO.0023--26.2026},
publisher = {Society for Neuroscience},
issn = {2373-2822},
doi = {10.1523/eneuro.0023-26.2026},
url = {https://doi.org/10.1523/eneuro.0023-26.2026},
pmid = {42315338},
pmcid = {PMC13326709}
}

RIS

TY - JOUR
AU - Riekers, Nils
AU - Göbl, Jacqueline Laura
AU - Heubach, Franziska
AU - Veit, Lena
TI - Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments
T2 - eNeuro
J2 - eNeuro
PY - 2026
DA - 2026/07/01
VL - 13
IS - 7
SP - ENEURO.0023
EP - 26.2026
SN - 2373-2822
PB - Society for Neuroscience
DO - 10.1523/eneuro.0023-26.2026
UR - https://doi.org/10.1523/eneuro.0023-26.2026
LA - en
ER -

CSL-JSON

{
"id": "10.1523/eneuro.0023-26.2026",
"type": "article-journal",
"title": "Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments",
"container-title": "eNeuro",
"author": [
{
"family": "Riekers",
"given": "Nils"
},
{
"family": "Göbl",
"given": "Jacqueline Laura"
},
{
"family": "Heubach",
"given": "Franziska"
},
{
"family": "Veit",
"given": "Lena"
}
],
"container-title-short": "eNeuro",
"volume": "13",
"issue": "7",
"page": "ENEURO.0023-26.2026",
"DOI": "10.1523/eneuro.0023-26.2026",
"PMID": "42315338",
"PMCID": "PMC13326709",
"ISSN": "2373-2822",
"publisher": "Society for Neuroscience",
"URL": "https://doi.org/10.1523/eneuro.0023-26.2026",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

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/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: PyTorch Lightning, Keras, UMAP, 11 other tools
[2] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: Keras, UMAP, Numba, 9 other tools, 1 reference
[3] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: Keras, UMAP, Numba, 10 other tools
[4] 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: Keras, UMAP, Numba, 9 other tools
[5] doi:10.1038/s41592-026-03057-2 [code]
CREsted: modeling genomic and synthetic cell-type-specific enhancers across tissues and species.
Journal: Nature methods
In common: Keras, UMAP, Numba, 9 other tools
[6] doi:10.1038/s41467-026-75455-1 [code]
Shared latent representations of speech production for cross-patient speech decoding.
Journal: Nature communications
In common: PyTorch Lightning, Keras, TensorFlow, 8 other tools, cognitive
[7] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive <i>m/z</i> mapping and exploration.
Journal: Science advances
In common: Keras, UMAP, Numba, 8 other tools
[8] doi:10.1093/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: Keras, UMAP, Numba, 8 other tools
[9] doi:10.1038/s44320-026-00208-7 [code]
Interpretable deep generative ensemble learning for single-cell omics with Hydra.
Journal: Molecular systems biology
In common: Keras, UMAP, Numba, 8 other tools
[10] doi:10.1371/journal.pone.0346575 [code]
Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging.
Journal: PloS one
In common: UMAP, Numba, TensorFlow, 8 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.