OSCR

The development of FEDUPP: feeding experimentation device users processing package to assess learning and cognitive flexibility.

Code ↔ Paper

2 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 2 matches
  1. [1] § Methods › CNN-based model ↔ scripts/meal_classifiers.py, lines 63–98 · score 0.68 · ReLU, feature map, convolutional, kernel, CNN, classes
  2. [2] § Results › Comparison of FEDUPP metrics with win-stay/lose-shift ↔ scripts/direction_transition.py, lines 1623–1667 · score 0.58 · way ANOVA, Win Stay, Lose shift, interaction, CASK

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 · 250 lines · 9.8 KB · MIT · 1 match

  1. """
  2. This script defines and implements neural network models (RNN and CNN) for classifying
  3. meal-related time-series data. It includes classes for datasets, the classifiers
  4. themselves, and functions for training, evaluation, and prediction.
  5. """
  6. import numpy as np
  7. from sklearn.metrics import f1_score
  8. import torch
  9. import torch.nn as nn
  10. import torch.optim as optim
  11. from torch.utils.data import DataLoader, Dataset
  13. # Detect best available device including MPS for Mac
  14. device = torch.device('cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu')
  16. class TimeSeriesDataset(Dataset):
  17. """A custom PyTorch Dataset for time-series data."""
  18. def __init__(self, X, y):
  19. """
  20. Args:
  21. X (torch.Tensor): The input features, with shape (num_samples, seq_len).
  22. y (torch.Tensor): The corresponding labels, with shape (num_samples,).
  23. """
  24. self.X = X # Tensor of shape (num_samples, seq_len)
  25. self.y = y # Tensor of shape (num_samples,)
  27. def __len__(self):
  28. """Returns the total number of samples."""
  29. return len(self.y)
  31. def __getitem__(self, idx):
  32. """Returns a single sample and its label."""
  33. return self.X[idx], self.y[idx]
  36. class RNNClassifier(nn.Module):
  37. """A Recurrent Neural Network (RNN) classifier using LSTM layers."""
  38. def __init__(self, input_size=1, hidden_size=16, num_layers=1, num_classes=2):
  39. """
  40. Args:
  41. input_size (int): The number of features in the input.
  42. hidden_size (int): The number of features in the hidden state.
  43. num_layers (int): The number of recurrent layers.
  44. num_classes (int): The number of output classes.
  45. """
  46. super(RNNClassifier, self).__init__()
  47. self.hidden_size = hidden_size
  48. self.num_layers = num_layers
  49. self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
  50. self.fc = nn.Linear(hidden_size, num_classes)
  52. def forward(self, x):
  53. # x: [batch_size, seq_len]
  54. x = x.unsqueeze(-1) # Now x is [batch_size, seq_len, 1]
  55. h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size, device=x.device)
  56. c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size, device=x.device)
  57. out, _ = self.lstm(x, (h0, c0))
  58. out = out[:, -1, :]
  59. out = self.fc(out)
  60. return out
  63. class CNNClassifier(nn.Module):
  64. """A 1D Convolutional Neural Network (CNN) for time-series classification."""
  65. def __init__(self, num_classes=2, maxlen=4):
  66. """
  67. Args:
  68. num_classes (int): The number of output classes.
  69. maxlen (int): The maximum length of the input sequences.
  70. """
  71. super(CNNClassifier, self).__init__()
  72. self.conv1 = nn.Conv1d(in_channels=1, out_channels=16, kernel_size=2)
  73. self.relu = nn.ReLU()
  74. self.conv2 = nn.Conv1d(in_channels=16, out_channels=32, kernel_size=2)
  75. self.pool = nn.MaxPool1d(kernel_size=2)
  76. self.maxlen = maxlen
  77. # Calculate the size of the feature map after convolution and pooling
  78. self.feature_size = self._get_feature_size()
  79. self.fc = nn.Linear(self.feature_size, num_classes)
  81. def _get_feature_size(self):
  82. # Replace 'maxlen' with your actual maximum sequence length
  83. dummy_input = torch.zeros(1, 1, self.maxlen) # Shape: [batch_size, channels, seq_len]
  84. x = self.relu(self.conv1(dummy_input))
  85. x = self.relu(self.conv2(x))
  86. x = self.pool(x)
  87. feature_size = x.view(1, -1).size(1)
  88. return feature_size
  90. def forward(self, x):
  91. # x shape: [batch_size, seq_len]
  92. x = x.unsqueeze(1) # Shape: [batch_size, channels=1, seq_len]
  93. x = self.relu(self.conv1(x))
  94. x = self.relu(self.conv2(x))
  95. x = self.pool(x)
  96. x = x.view(x.size(0), -1) # Flatten the tensor
  97. x = self.fc(x)
  98. return x
  101. def train(model:nn.Module, lr:float, num_epochs:int, train_loader:DataLoader,
  102. X_test_tensor:torch.tensor, y_test_tensor:torch.tensor):
  103. """
  104. Trains a given neural network model.
  106. Args:
  107. model (nn.Module): The model to be trained.
  108. lr (float): The learning rate for the optimizer.
  109. num_epochs (int): The number of training epochs.
  110. train_loader (DataLoader): The DataLoader for the training data.
  111. X_test_tensor (torch.Tensor): The test features.
  112. y_test_tensor (torch.Tensor): The test labels.
  114. Returns:
  115. nn.Module: The trained model.
  116. """
  118. criterion = nn.CrossEntropyLoss()
  119. optimizer = optim.Adam(model.parameters(), lr=lr)
  120. print(f"Model Parameters: {sum(p.numel() for p in model.parameters())}")
  122. for epoch in range(num_epochs):
  123. model.train()
  124. total_loss = 0
  125. correct_train = 0
  126. total_train = 0
  128. for X_batch, y_batch in train_loader:
  129. X_batch, y_batch = X_batch.to(device), y_batch.to(device)
  130. optimizer.zero_grad()
  131. outputs = model(X_batch)
  132. loss = criterion(outputs, y_batch)
  133. loss.backward()
  134. optimizer.step()
  136. total_loss += loss.item() * X_batch.size(0)
  137. _, predicted = torch.max(outputs.data, 1)
  138. total_train += y_batch.size(0)
  139. predicted, y_batch = predicted.cpu().numpy(), y_batch.cpu().numpy()
  140. correct_train += (predicted == y_batch).sum().item()
  142. avg_loss = total_loss / total_train
  143. train_accuracy = correct_train / total_train
  145. model.eval()
  146. with torch.no_grad():
  147. outputs_test = model(X_test_tensor)
  148. _, predicted_test = torch.max(outputs_test.data, 1)
  149. correct_test = (predicted_test.cpu() == y_test_tensor).sum().item()
  150. test_accuracy = correct_test / y_test_tensor.size(0)
  152. if (epoch+1) % 10 == 0 or epoch == num_epochs-1:
  153. print(f'Ep {epoch+1}, Loss: {avg_loss:.4f}, Train Acc: {train_accuracy:.4f}, Test Acc: {test_accuracy:.4f}')
  155. return model
  158. def evaluate_meals_by_groups(model:nn.Module, ctrl_input:torch.Tensor, ctrl_y:torch.Tensor,
  159. exp_input:torch.Tensor, exp_y:torch.Tensor):
  160. """
  161. Evaluates the model's performance on control and experimental groups.
  163. Args:
  164. model (nn.Module): The trained model.
  165. ctrl_input (torch.Tensor): Input data for the control group.
  166. ctrl_y (torch.Tensor): Labels for the control group.
  167. exp_input (torch.Tensor): Input data for the experimental group.
  168. exp_y (torch.Tensor): Labels for the experimental group.
  169. """
  170. model.eval()
  171. with torch.no_grad():
  172. outputs_ctrl = model(ctrl_input)
  173. _, predicted_ctrl = torch.max(outputs_ctrl.data, 1)
  174. correct_test = (predicted_ctrl.cpu().numpy() == ctrl_y).sum().item()
  175. ctrl_accuracy = correct_test / len(ctrl_y)
  177. outputs_exp = model(exp_input)
  178. _, predicted_exp = torch.max(outputs_exp.data, 1)
  179. correct_test = (predicted_exp.cpu().numpy() == exp_y).sum().item()
  180. exp_accuracy = correct_test / len(exp_y)
  182. print(f'Control Accuracy: {ctrl_accuracy:.3f}, Exp Accuracy: {exp_accuracy:.3f}')
  184. predicted_ctrl, predicted_exp = predicted_ctrl.cpu().numpy(), predicted_exp.cpu().numpy()
  185. ctrl_good, ctrl_total = np.sum(predicted_ctrl), np.size(predicted_ctrl)
  186. exp_good, exp_total = np.sum(predicted_exp), np.size(predicted_exp)
  188. # calculate F1 score
  189. f1_ctrl = f1_score(ctrl_y, predicted_ctrl)
  190. f1_exp = f1_score(exp_y, predicted_exp)
  191. print(f'Control Group: {ctrl_total-ctrl_good}/{ctrl_total} good meals with proportion of {1-ctrl_good/ctrl_total}; F1 Score: {f1_ctrl:.3f}')
  192. print(f'Experiment Group: {exp_total-exp_good}/{exp_total} good meals with proportion of {1-exp_good/exp_total}; F1 Score: {f1_exp:.3f}')
  195. def evaluate_meals_on_new_data(model:nn.Module, ctrl_input:torch.Tensor, exp_input:torch.Tensor):
  196. """
  197. Evaluates the model on new, unlabeled data from control and experimental groups.
  199. Args:
  200. model (nn.Module): The trained model.
  201. ctrl_input (torch.Tensor): New input data for the control group.
  202. exp_input (torch.Tensor): New input data for the experimental group.
  203. """
  204. ctrl_input, exp_input = ctrl_input.to(device), exp_input.to(device)
  205. model.eval()
  206. with torch.no_grad():
  207. outputs_ctrl = model(ctrl_input)
  208. _, predicted_ctrl = torch.max(outputs_ctrl.data, 1)
  210. outputs_exp = model(exp_input)
  211. _, predicted_exp = torch.max(outputs_exp.data, 1)
  213. predicted_ctrl, predicted_exp = predicted_ctrl.cpu().numpy(), predicted_exp.cpu().numpy()
  214. ctrl_good, ctrl_total = np.sum(predicted_ctrl), np.size(predicted_ctrl)
  215. exp_good, exp_total = np.sum(predicted_exp), np.size(predicted_exp)
  217. print(f'Control Group: {ctrl_total-ctrl_good}/{ctrl_total} good meals with proportion of {1-ctrl_good/ctrl_total}')
  218. print(f'Experiment Group: {exp_total-exp_good}/{exp_total} good meals with proportion of {1-exp_good/exp_total}')
  221. def predict(model:nn.Module, input):
  222. """
  223. Makes predictions on new data using the trained model.
  225. Args:
  226. model (nn.Module): The trained model.
  227. input (array-like or torch.Tensor): The input data for prediction.
  229. Returns:
  230. np.ndarray: The predicted class labels.
  231. """
  232. if not isinstance(input, torch.Tensor):
  233. input = torch.tensor(input, dtype=torch.float32)
  234. else:
  235. input = input.float()
  237. # Ensure input is on the same device as the model
  238. try:
  239. model_device = next(model.parameters()).device
  240. except StopIteration:
  241. model_device = device
  243. input = input.to(model_device)
  245. model.eval()
  246. with torch.no_grad():
  247. outputs_ctrl = model(input)
  248. _, predicted_ctrl = torch.max(outputs_ctrl.data, 1)
  250. return predicted_ctrl.cpu().numpy()

meal_classifiers.py at commit 783c7f7, under MIT · at the source

Overview

Authors: Mingyang Yao1,2, Avraham M. Libster2, Shane Desfor2,3, Freiya Malhotra2, Nathalia Castorena2, Patricia Montilla-Perez2, Francesca Telese2
ORCID iDs: Mingyang Yao, Avraham M. Libster, Shane Desfor
  1. Department of Mathematics, School of Physical Sciences, University of California,San Diego, CA USA
  2. Department of Psychiatry, School of Medicine, University of California,San Diego, CA USA
  3. School of Biological Sciences, University of California,San Diego, CA USA
Institutions: University of California San Diego (United States)
Journal: Translational psychiatry, volume 16, issue 1, article 348
Dates: received 19 August 2025; accepted 30 April 2026; published online 16 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41398-026-04091-6 · PMID 42140909 · PMCID PMC13346605 · OpenAlex W4413346959
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.08.14.670424
Status: code verified
Categories: mouse (organism), cognitive (subfield)
Methods: Statistics, Machine learning, Evoked potentials, Connectivity
Keywords: Neuroscience, Psychology
MeSH: Cognitive Flexibility*, Feeding Behavior*, Learning*, Reversal Learning*, Animals, Hippocampus, Male, Mice, Mice, Inbred C57BL (* major topic)
Topic: Mobile Learning in Education (Information Systems, Computer Science), according to OpenAlex
Funding: UC | UC San Diego | Kavli Institute for Brain and Mind, University of California, San Diego (KIBM, UCSD) (2021-1754); National Institute of General Medical Sciences (2T32GM133351); U.S. Department of Health & Human Services | NIH | National Institute on Drug Abuse (NIDA) (F31DA063338); National Institute of Diabetes and Digestive and Kidney Diseases (5P30DK063491); Pilot Award from the UCSD-UCLA Diabetes Research Center to F.T. NIGMS T32 Training Grant (2T32GM133351) to S.D
Citations: not cited yet (Europe PMC); 49 references in the paper

Abstract

Cognitive flexibility, the ability to adapt behavior in response to changing contingencies, is a key component of adaptive decision-making and is impaired in multiple neuropsychiatric disorders. Traditional rodent assays of cognitive flexibility are conducted in experimenter-controlled sessions in restrictive environments, limiting ecological validity and temporal resolution. Here, we developed a fully automated, home-cage paradigm using the Feeding Experimentation Device 3 (FED3) and a companion open-source analysis pipeline, the Feeding Experimentation Device Users Processing Package (FEDUPP), to assess learning and cognitive flexibility with minimal experimenter intervention. The paradigm combines a single-day fixed-ratio 1 (FR1) task with a multi-day, reversal learning task in which active port assignment switches every 25 pellets collected. FEDUPP implements multi-scale learning metrics, including overall accuracy, an 80% accuracy milestone, and a machine learning-based classification of meal accuracy to capture motivated, goal-directed feeding. In wild-type mice, the paradigm detected rapid FR1 acquisition and progressive within-block adaptation during reversal. Application to mice with dorsal hippocampal knockdown of the scaffolding protein CASK revealed faster FR1 acquisition and higher accuracy. In addition, a faster onset of the first accurate meal after reversal suggests an improvement in updating goal-directed feeding behavior. These findings demonstrate that FEDUPP enables high-resolution, continuous assessment of learning and cognitive flexibility in ethologically relevant settings, and that meal-based accuracy provides a sensitive metric for detecting subtle changes in flexibility not captured by traditional measures.

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

ftlabucsd/FEDUPP

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 783c7f7d665a4a2def670cf69b0c92c2f6d9f041, 19 May 2026
Languages: Python (9), Jupyter (2)
Size: 1,176 files, 11 scripts
Software Heritage: not archived
Found in: the text, “Analysis programming tools”
Holds: README, license file, environment (requirements.txt), documentation, 2 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (10 files), pandas (7 files), Matplotlib (6 files), PyTorch (3 files), scikit-learn (3 files), SciPy (3 files), seaborn (3 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
13 files
At the source: github.com/ftlabucsd/FEDUPP

Zenodo 20277475

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: DataCite
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (10 files), pandas (7 files), Matplotlib (6 files), PyTorch (3 files), scikit-learn (3 files), SciPy (3 files), seaborn (3 files)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
13 files
At the source: doi.org/10.5281/zenodo.20277475

ftlabucsd/FED3-data

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 783c7f7d665a4a2def670cf69b0c92c2f6d9f041, 19 May 2026
Languages: Python (9), Jupyter (2)
Size: 1,176 files, 11 scripts
Software Heritage: not archived
Found in: DataCite
Holds: README, license file, environment (requirements.txt), documentation, 2 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (10 files), pandas (7 files), Matplotlib (6 files), PyTorch (3 files), scikit-learn (3 files), SciPy (3 files), seaborn (3 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
13 files
At the source: github.com/ftlabucsd/FED3-data

Zenodo 20277476

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: DataCite
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (10 files), pandas (7 files), Matplotlib (6 files), PyTorch (3 files), scikit-learn (3 files), SciPy (3 files), seaborn (3 files)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
13 files
At the source: doi.org/10.5281/zenodo.20277476

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:

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

FED3 behavioral data is available on https://github.com/ftlabucsd/FEDUPP.

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, 7 authors, 2 keywords, 9 MeSH terms, 5 funders, 49 references.

Cite

This paper

Yao, M., Libster, A. M., Desfor, S., Malhotra, F., Castorena, N., Montilla-Perez, P., & Telese, F. (2026). The development of FEDUPP: feeding experimentation device users processing package to assess learning and cognitive flexibility. Translational psychiatry, 16(1), 348. https://doi.org/10.1038/s41398-026-04091-6

BibTeX

@article{yao2026development,
author = {Yao, Mingyang and Libster, Avraham M. and Desfor, Shane and Malhotra, Freiya and Castorena, Nathalia and Montilla-Perez, Patricia and Telese, Francesca},
title = {{The development of FEDUPP: feeding experimentation device users processing package to assess learning and cognitive flexibility}},
journal = {Translational psychiatry},
year = {2026},
month = may,
volume = {16},
number = {1},
pages = {348},
publisher = {Nature Publishing Group},
issn = {2158-3188},
doi = {10.1038/s41398-026-04091-6},
url = {https://doi.org/10.1038/s41398-026-04091-6},
pmid = {42140909},
pmcid = {PMC13346605}
}

RIS

TY - JOUR
AU - Yao, Mingyang
AU - Libster, Avraham M.
AU - Desfor, Shane
AU - Malhotra, Freiya
AU - Castorena, Nathalia
AU - Montilla-Perez, Patricia
AU - Telese, Francesca
TI - The development of FEDUPP: feeding experimentation device users processing package to assess learning and cognitive flexibility
T2 - Translational psychiatry
J2 - Transl Psychiatry
PY - 2026
DA - 2026/05/16
VL - 16
IS - 1
SP - 348
SN - 2158-3188
PB - Nature Publishing Group
DO - 10.1038/s41398-026-04091-6
UR - https://doi.org/10.1038/s41398-026-04091-6
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41398-026-04091-6",
"type": "article-journal",
"title": "The development of FEDUPP: feeding experimentation device users processing package to assess learning and cognitive flexibility",
"container-title": "Translational psychiatry",
"author": [
{
"family": "Yao",
"given": "Mingyang"
},
{
"family": "Libster",
"given": "Avraham M."
},
{
"family": "Desfor",
"given": "Shane"
},
{
"family": "Malhotra",
"given": "Freiya"
},
{
"family": "Castorena",
"given": "Nathalia"
},
{
"family": "Montilla-Perez",
"given": "Patricia"
},
{
"family": "Telese",
"given": "Francesca"
}
],
"container-title-short": "Transl Psychiatry",
"volume": "16",
"issue": "1",
"page": "348",
"DOI": "10.1038/s41398-026-04091-6",
"PMID": "42140909",
"PMCID": "PMC13346605",
"ISSN": "2158-3188",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41398-026-04091-6",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
16
]
]
}
}

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.1073/pnas.2536535123 [code]
Orbitofrontal noradrenaline supports adaptive learning-rate adjustment in probabilistic reversal learning.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: pandas, SciPy, Matplotlib, 1 other tool, cognitive, 3 references
[2] doi:10.1038/s41593-026-02362-5 [code]
Replay of procedural memory is independent of the hippocampus.
Journal: Nature neuroscience
In common: seaborn, scikit-learn, pandas, 3 other tools, cognitive, mouse, 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: PyTorch, seaborn, scikit-learn, 4 other tools, 1 reference
[4] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, mouse, 1 reference
[5] doi:10.1371/journal.pcbi.1014585 [code]
Decoding behavior with minimal and interpretable agent models.
Journal: PLoS computational biology
In common: PyTorch, pandas, SciPy, 2 other tools, cognitive, mouse, 1 reference
[6] doi:10.1002/hbm.70605 [code]
BrainEnrich: Revealing Biological Insights for Imaging-Derived Phenotypes Through Transcriptomic Enrichment.
Journal: Human brain mapping
In common: seaborn, scikit-learn, pandas, 3 other tools, 1 reference
[7] doi:10.7554/elife.108673 [code]
Adaptive behavior is guided by integrated representations of controlled and non-controlled information.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, 1 reference
[8] doi:10.1038/s41467-026-74347-8 [code]
Compositionality of social gaze in the prefrontal-amygdala circuits.
Journal: Nature communications
In common: seaborn, scikit-learn, pandas, 3 other tools, 1 reference
[9] doi:10.1038/s41531-026-01354-3 [code]
Neuromodulation-induced normalization of cortical metastable dynamics signatures in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: seaborn, scikit-learn, pandas, 3 other tools, 1 reference
[10] doi:10.1038/s41467-026-71568-9 [code]
Convergent and selective representations of pain, appetitive processes, aversive processes, and cognitive control in the insula.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, cognitive, 1 reference

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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