OSCR

A Data-Driven Closed-Loop Control Approach to Drive Neural State Transitions for Mechanistic Insight.

Code ↔ Paper

11 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 11 matches
  1. [1] § Results › Spatial Separation Between Resting and Sad Mood Induction ↔ analyses/spatial_separation/classification_utils.py, lines 57–118 · score 0.72 · linear discriminant, Gaussian Mixture, cross validation, LDA, classification, SVMs
  2. [2] § Methods › DSR Model and Control › Statistical Analysis › State Separation ↔ analyses/spatial_separation.ipynb, lines 82–136 · score 0.63 · cubic feature, polynomial feature, sad mood, nonlinear, classifiers, validate
  3. [3] § Methods › DSR Model and Control › DSR Model Evaluation ↔ src/evaluation.py, lines 129–146 · score 0.61 · Hellinger distance, power spectrum, smoothed, trajectory
  4. [4] § Methods › DSR Model and Control › Statistical Analysis › State Separation ↔ analyses/spatial_separation/classification_utils.py, lines 168–249 · score 0.56 · Logistic regression, expansions, classifiers, polynomial, validate, linear
  5. [5] § Results ↔ analyses/analysis_simulation.ipynb, lines 82–151 · score 0.56 · negative log likelihood, Neural activity, generated trajectories, simulated, GMMs, models
  6. [6] § Methods › DSR Model and Control › Model Training ↔ src/rnn/main.py, lines 13–64 · score 0.55 · teacher forcing, gradient, BPTT, decaying, linear, latent
  7. [7] § Results › Asymmetric Neural Controllability in rMDD: Reduced Energy Costs and Residual Bias Toward Sad Mood States ↔ analyses/analysis_utils.py, lines 1–47 · score 0.54 · PIns, AIns, DLPFC, HPC, PHG, rMDD
  8. [8] § Methods › DSR Model and Control › Statistical Analysis › State Separation ↔ analyses/spatial_separation.ipynb, lines 295–364 · score 0.52 · sliced Wasserstein distance, discrepancy, MMD, GMMs
  9. [9] § Results › DSR Models Learn the Underlying Dynamics ↔ src/evaluation.py, lines 129–146 · score 0.52 · Hellinger distance, power spectra, trajectories
  10. [10] § Methods › DSR Model and Control › DSR Model Evaluation ↔ analyses/analysis_rnn.ipynb, lines 155–221 · score 0.51 · spectral densities, smoothed, power, transform, reconstruction
  11. [11] § Results › DSR Models Learn the Underlying Dynamics ↔ analyses/analysis_rnn.ipynb, lines 102–153 · score 0.51 · power spectra, functional connectivity, Lyapunov, cross, correlation, models

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 · 268 lines · 12 KB · MIT · 2 matches

  1. import numpy as np
  2. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  3. from sklearn.metrics import accuracy_score
  4. from sklearn.svm import SVC
  5. from sklearn.model_selection import GridSearchCV, StratifiedKFold
  6. from sklearn.pipeline import Pipeline
  7. from sklearn.preprocessing import StandardScaler, PolynomialFeatures
  8. from sklearn.linear_model import LogisticRegression
  9. from sklearn.mixture import GaussianMixture
  12. def random_split(data, classes, train_test_split=0.75):
  13. np.random.seed(42)
  14. permutation = np.random.permutation(len(data))
  15. data = data[permutation]
  16. classes = classes[permutation]
  18. split = int(len(data) * train_test_split)
  19. train_data, test_data = data[:split], data[split:]
  20. train_classes, test_classes = classes[:split], classes[split:]
  22. return train_data, train_classes, test_data, test_classes
  24. def chron_block_split(data, classes, train_test_split=0.75, n_blocks_per_class=5):
  25. np.random.seed(42)
  26. unique_classes = np.unique(classes)
  27. train_data, test_data, train_classes, test_classes = [], [], [], []
  28. for cls in unique_classes:
  29. cls_data = data[classes == cls]
  30. n_samples = len(cls_data)
  31. block_size = n_samples // n_blocks_per_class
  32. blocks = [cls_data[i:i + block_size] for i in range(0, n_samples, block_size)]
  33. np.random.shuffle(blocks)
  34. split_idx = int(len(blocks) * train_test_split)
  35. train_blocks = blocks[:split_idx]
  36. test_blocks = blocks[split_idx:]
  37. train_data.append(np.concatenate(train_blocks))
  38. test_data.append(np.concatenate(test_blocks))
  39. train_classes.append(np.full(len(train_data[-1]), cls))
  40. test_classes.append(np.full(len(test_data[-1]), cls))
  42. return np.concatenate(train_data), np.concatenate(train_classes), np.concatenate(test_data), np.concatenate(test_classes)
  44. def chron_split(data, classes, train_test_split=0.75):
  45. unique_classes = np.unique(classes)
  46. train_data, test_data, train_classes, test_classes = [], [], [], []
  47. for cls in unique_classes:
  48. cls_data = data[classes == cls]
  49. split_idx = int(len(cls_data) * train_test_split)
  50. train_data.append(cls_data[:split_idx])
  51. test_data.append(cls_data[split_idx:])
  52. train_classes.append(np.full(split_idx, cls))
  53. test_classes.append(np.full(len(cls_data) - split_idx, cls))
  55. return np.concatenate(train_data), np.concatenate(train_classes), np.concatenate(test_data), np.concatenate(test_classes)
  57. def perform_cross_validation(data: np.array, classes: np.array, classifier: str, train_test_split=0.75, use_chron_split=False, n_poly_features=None) -> (object, float, np.array, np.array, np.array, np.array):
  58. if not use_chron_split:
  59. train_data, train_classes, test_data, test_classes = random_split(data, classes, train_test_split)
  60. else:
  61. train_data, train_classes, test_data, test_classes = chron_split(data, classes, train_test_split)
  63. match classifier:
  64. case "lda":
  65. pipeline = Pipeline(
  66. [('scaler', StandardScaler()), ('lda', LinearDiscriminantAnalysis())])
  67. param_grid = {'lda__solver': ['lsqr', 'eigen'], 'lda__shrinkage': [
  68. None, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]}
  69. grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy')
  71. grid_search.fit(train_data, train_classes)
  72. best_params = grid_search.best_params_
  73. best_clf = grid_search.best_estimator_
  74. validation_score = grid_search.cv_results_[
  75. "mean_test_score"][grid_search.best_index_]
  77. test_score = accuracy_score(test_classes, best_clf.predict(test_data))
  79. case "svm":
  80. pipeline = Pipeline([('scaler', StandardScaler()), ('svm', SVC(random_state=42))])
  81. param_grid = [
  82. {'svm__C': [0.01, 0.1, 1, 10, 100], 'svm__kernel': [
  83. 'poly'], 'svm__degree': [2, 3, 4, 5]},
  84. {'svm__C': [0.01, 0.1, 1, 10, 100], 'svm__kernel': ['rbf']},
  85. ]
  86. grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy')
  88. grid_search.fit(train_data, train_classes)
  89. best_params = grid_search.best_params_
  90. best_clf = grid_search.best_estimator_
  91. validation_score = grid_search.cv_results_[
  92. "mean_test_score"][grid_search.best_index_]
  94. test_score = accuracy_score(test_classes, best_clf.predict(test_data))
  96. case "gmm":
  97. param_grid = {
  98. "n_components": [6],#2, 4, 8
  99. "covariance_type": ["full",]# "diag"
  100. }
  101. skf = StratifiedKFold(n_splits=5)
  102. best_params = None
  103. validation_score = -np.inf
  105. def fit_gmms(x, y, n_components, covariance_type):
  106. gmm0 = GaussianMixture(
  107. n_components=n_components,
  108. covariance_type=covariance_type,
  109. random_state=42
  110. )
  111. gmm1 = GaussianMixture(
  112. n_components=n_components,
  113. covariance_type=covariance_type,
  114. random_state=42
  115. )
  116. gmm0.fit(x[y == 0])
  117. gmm1.fit(x[y == 1])
  118. return gmm0, gmm1
  120. def predict_gmms(gmm0, gmm1, x):
  121. score0 = gmm0.score_samples(x)
  122. score1 = gmm1.score_samples(x)
  123. return (score1 > score0).astype(int)
  125. for n_components in param_grid["n_components"]:
  126. for covariance_type in param_grid["covariance_type"]:
  127. fold_scores = []
  128. for train_idx, val_idx in skf.split(train_data, train_classes):
  129. x_train, x_val = train_data[train_idx], train_data[val_idx]
  130. y_train, y_val = train_classes[train_idx], train_classes[val_idx]
  131. scaler = StandardScaler()
  132. x_train = scaler.fit_transform(x_train)
  133. x_val = scaler.transform(x_val)
  134. gmm0, gmm1 = fit_gmms(
  135. x_train, y_train, n_components, covariance_type)
  136. preds = predict_gmms(gmm0, gmm1, x_val)
  137. fold_scores.append(accuracy_score(y_val, preds))
  139. mean_score = float(np.mean(fold_scores))
  140. if mean_score > validation_score:
  141. validation_score = mean_score
  142. best_params = {
  143. "n_components": n_components,
  144. "covariance_type": covariance_type
  145. }
  147. scaler = StandardScaler()
  148. train_data_scaled = scaler.fit_transform(train_data)
  149. test_data_scaled = scaler.transform(test_data)
  151. gmm0, gmm1 = fit_gmms(
  152. train_data_scaled,
  153. train_classes,
  154. best_params["n_components"],
  155. best_params["covariance_type"]
  156. )
  158. test_preds = predict_gmms(gmm0, gmm1, test_data_scaled)
  159. test_score = accuracy_score(test_classes, test_preds)
  160. best_clf = (scaler, gmm0, gmm1)
  162. case "poly_logreg":
  163. # Create polynomial features of degree 3
  164. poly = PolynomialFeatures(degree=3, include_bias=False)
  165. train_data_poly_full = poly.fit_transform(train_data)
  166. test_data_poly_full = poly.transform(test_data)
  168. # Select subset of features if n_poly_features is specified
  169. if n_poly_features is not None:
  170. n_original = train_data.shape[1]
  171. # First n_original features are linear terms, rest are polynomial
  172. if n_poly_features <= n_original:
  173. # Only use some linear terms
  174. feature_indices = list(range(n_poly_features))
  175. else:
  176. # Use all linear terms + some polynomial terms
  177. n_poly_to_add = n_poly_features - n_original
  178. feature_indices = list(range(n_original)) + list(range(n_original, n_original + n_poly_to_add))
  180. train_data_poly = train_data_poly_full[:, feature_indices]
  181. test_data_poly = test_data_poly_full[:, feature_indices]
  182. else:
  183. train_data_poly = train_data_poly_full
  184. test_data_poly = test_data_poly_full
  186. # Scale again after polynomial expansion
  187. scaler = StandardScaler()
  188. train_data_poly_scaled = scaler.fit_transform(train_data_poly)
  189. test_data_poly_scaled = scaler.transform(test_data_poly)
  191. # Use simpler parameter grid with L2 regularization
  192. param_grid = {
  193. 'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
  194. 'penalty': ['l2'],
  195. 'solver': ['lbfgs']
  196. }
  198. best_params = None
  199. validation_score = -np.inf
  201. # Manual cross-validation
  202. skf = StratifiedKFold(n_splits=5, shuffle=False)
  204. for C in param_grid['C']:
  205. fold_scores = []
  206. for train_idx, val_idx in skf.split(train_data_poly_scaled, train_classes):
  207. X_train_fold = train_data_poly_scaled[train_idx]
  208. X_val_fold = train_data_poly_scaled[val_idx]
  209. y_train_fold = train_classes[train_idx]
  210. y_val_fold = train_classes[val_idx]
  212. clf = LogisticRegression(
  213. C=C,
  214. penalty='l2',
  215. solver='lbfgs',
  216. max_iter=2000,
  217. random_state=42
  218. )
  219. clf.fit(X_train_fold, y_train_fold)
  220. fold_scores.append(accuracy_score(y_val_fold, clf.predict(X_val_fold)))
  222. mean_score = np.mean(fold_scores)
  223. if mean_score > validation_score:
  224. validation_score = mean_score
  225. best_params = {
  226. 'C': C,
  227. 'n_poly_features': n_poly_features if n_poly_features else train_data_poly.shape[1],
  228. 'penalty': 'l2',
  229. 'solver': 'lbfgs'
  230. }
  232. # Train final model with best parameters
  233. best_clf = LogisticRegression(
  234. C=best_params['C'],
  235. penalty='l2',
  236. solver='lbfgs',
  237. max_iter=2000,
  238. random_state=42
  239. )
  240. best_clf.fit(train_data_poly_scaled, train_classes)
  242. # Store the pipeline components for later use
  243. best_clf = (poly, scaler, best_clf, feature_indices if n_poly_features else None)
  245. test_score = accuracy_score(test_classes, best_clf[2].predict(test_data_poly_scaled))
  247. discriminative_scores, most_discriminative_units = get_discriminative_scores(
  248. train_data, train_classes)
  249. return best_clf, best_params, validation_score, test_score, discriminative_scores, most_discriminative_units
  252. def get_discriminative_scores(data, classes):
  253. means = np.array([data[classes == i].mean(axis=0)
  254. for i in np.unique(classes)])
  255. vars = np.array([data[classes == i].var(axis=0)
  256. for i in np.unique(classes)])
  257. pairwise_mean_diff = np.abs(
  258. means[:, np.newaxis, :] - means[np.newaxis, :, :])
  259. pairwise_var_diff = np.sqrt(
  260. vars[:, np.newaxis, :] + vars[np.newaxis, :, :])
  261. discriminative_scores = pairwise_mean_diff / pairwise_var_diff
  262. discriminative_scores = discriminative_scores / \
  263. (np.sum(np.abs(discriminative_scores), axis=2, keepdims=True) + 1e-10)
  264. most_discriminative_units = np.flip(np.unravel_index(np.argsort(
  265. discriminative_scores, axis=None), discriminative_scores.shape)[-1])
  266. most_discriminative_units = most_discriminative_units[np.sort(
  267. np.unique(most_discriminative_units, return_index=True)[1])]
  268. return discriminative_scores, most_discriminative_units

classification_utils.py at commit 5925379, under MIT · at the source

Overview

Authors: Niklas Emonds1,2, Evelyn Herberg2, Martin Fungisai Gerchen3,4,5, Marc Pritsch1,2, Joshua Rocha3,5, Vera Zamoscik3,6, Peter Kirsch3,4,5, Roland Herzog2, Georgia Koppe1,2,7
ORCID iDs: Niklas Emonds, Peter Kirsch
  1. Hector Institute for AI in Psychiatry & Department of Psychiatry and Psychotherapy, Central Institute of Mental Health (CIMH), Medical Faculty Mannheim, Heidelberg University, Heidelberg, Germany
  2. Interdisciplinary Center for Scientific Computing, Heidelberg University, Heidelberg, Germany
  3. Department of Clinical Psychology, CIMH, Medical Faculty Mannheim, Heidelberg University, Mannheim, Germany
  4. Department of Psychology, University of Heidelberg, Heidelberg, Germany
  5. German Center for Mental Health, DZPG, Partner Site Mannheim‐Heidelberg‐Ulm, Mannheim, Germany
  6. Department of Psychology, School of Social Sciences, University of Mannheim, Mannheim, Germany
  7. Hertie Institute for AI in Brain Health, University of Tübingen, Tübingen, Germany
Institutions: Heidelberg University (Germany); Central Institute of Mental Health (Germany); Medizinische Fakultät Mannheim; Deutsches Zentrum für Psychische Gesundheit (Germany); University of Mannheim (Germany); University of Tübingen (Germany)
Journal: Human brain mapping, volume 47, issue 11, article e70600
Dates: received 8 November 2025; accepted 30 June 2026; published online 15 July 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/hbm.70600 · PMID 42454569 · PMCID PMC13370802 · OpenAlex W4412624695
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.07.21.665992
Status: code verified
Categories: human (organism), depression (population), computational (subfield)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity, fMRI & imaging
Keywords: affective state transitions, brain network controllability, closed‐loop neuromodulation, dynamical systems reconstruction, major depressive disorder, optimal control
MeSH: Affect*, Brain Mapping*, Major Depressive Disorder*, Adult, Female, Humans, Magnetic Resonance Imaging, Male, Nonlinear Dynamics, Young Adult (* major topic)
Topic: Neural Networks and Applications (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Wellcome Trust (Z334349/Z/25/Z); Federal Ministry of Research, Technology and Space (neuroAI initiative) (01GQ2509B); German Research Foundation within the Research Unit FOR 5159 : (subproject11); Hector II foundation; Excellence Strategy of the German Federal and State Governments
Citations: cited by 1 paper (Europe PMC); 65 references in the paper

Abstract

Altered affective state dynamics are a characteristic feature of depression and can persist beyond symptomatic remission. Individuals with remitted major depressive disorder (rMDD) often show heightened reactivity to negative mood states and reduced efficiency in recovering from them, consistent with changes in affective dynamics after remission. These patterns may reflect alterations in the brain's capacity to flexibly shift between neural states that support distinct affective modes. Characterizing the dynamical mechanisms that govern transitions into and out of experimentally induced affective states is therefore essential for understanding vulnerability to recurrence and informing mechanistic interventions. We developed a data‐driven framework combining dynamical system reconstruction (DSR) with model‐based control to infer optimal control policies for transitions between resting and sad mood brain states using functional magnetic resonance imaging (fMRI) data. Nonlinear DSR models trained on individuals with rMDD and healthy controls (HC) yielded region‐specific, state‐dependent control strategies. Small regions (e.g., sgACC, NAcc) showed higher controllability, requiring less energy for state transitions. Notably, rMDD participants required less control energy than HC to shift both into and, to a more spatially restricted extent, out of sad mood states. Despite reaching the resting state target with similar proximity, however, they remained closer to the sad mood distribution when returning to rest, reflecting a residual bias toward the sad mood distribution. Elevated coupling in rMDD, especially toward the DLPFC, was linked to lower control energy, suggesting that stronger network coupling facilitates transitions. These findings indicate rMDD dynamics that ease entry into sad mood states but impede full disengagement. More broadly, they demonstrate how closed‐loop control applied to data‐driven dynamical models can provide mechanistic insight into brain state transitions and inform future hypotheses about cognitive vulnerability or compensatory processes.

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

Repository

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

humml-lab/fmri-control

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 59253796ecb10a3adce29d48a7045e073f950335, 16 July 2026
Languages: Python (23), Jupyter (7)
Size: 465 files, 30 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, license file, environment (environment.yml), 7 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (19 files), PyTorch (14 files), Matplotlib (9 files), scikit-learn (7 files), SciPy (5 files), statsmodels (2 files), UMAP (2 files), NiBabel (1 file), Nilearn (1 file), pandas (1 file), Plotly (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
32 files
At the source: github.com/humml-lab/fmri-control

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 30 scripts, each with its path and the digest of its content;
  • 11 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability Statement

All code and fully preprocessed data used for the analyses is openly available at https://github.com/humml‐lab/fmri‐control (https://github.com/humml-lab/fmri-control).

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, issue, pages, dates, 9 authors, 6 keywords, 10 MeSH terms, 5 funders, 56 references.

Cite

This paper

Emonds, N., Herberg, E., Gerchen, M. F., Pritsch, M., Rocha, J., Zamoscik, V., Kirsch, P., Herzog, R., & Koppe, G. (2026). A Data-Driven Closed-Loop Control Approach to Drive Neural State Transitions for Mechanistic Insight. Human brain mapping, 47(11), e70600. https://doi.org/10.1002/hbm.70600

BibTeX

@article{emonds2026data,
author = {Emonds, Niklas and Herberg, Evelyn and Gerchen, Martin Fungisai and Pritsch, Marc and Rocha, Joshua and Zamoscik, Vera and Kirsch, Peter and Herzog, Roland and Koppe, Georgia},
title = {{A Data-Driven Closed-Loop Control Approach to Drive Neural State Transitions for Mechanistic Insight}},
journal = {Human brain mapping},
year = {2026},
month = aug,
volume = {47},
number = {11},
pages = {e70600},
publisher = {Wiley},
issn = {1065-9471},
doi = {10.1002/hbm.70600},
url = {https://doi.org/10.1002/hbm.70600},
pmid = {42454569},
pmcid = {PMC13370802}
}

RIS

TY - JOUR
AU - Emonds, Niklas
AU - Herberg, Evelyn
AU - Gerchen, Martin Fungisai
AU - Pritsch, Marc
AU - Rocha, Joshua
AU - Zamoscik, Vera
AU - Kirsch, Peter
AU - Herzog, Roland
AU - Koppe, Georgia
TI - A Data-Driven Closed-Loop Control Approach to Drive Neural State Transitions for Mechanistic Insight
T2 - Human brain mapping
J2 - Hum Brain Mapp
PY - 2026
DA - 2026/08/01
VL - 47
IS - 11
SP - e70600
SN - 1065-9471
PB - Wiley
DO - 10.1002/hbm.70600
UR - https://doi.org/10.1002/hbm.70600
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hbm.70600",
"type": "article-journal",
"title": "A Data-Driven Closed-Loop Control Approach to Drive Neural State Transitions for Mechanistic Insight",
"container-title": "Human brain mapping",
"author": [
{
"family": "Emonds",
"given": "Niklas"
},
{
"family": "Herberg",
"given": "Evelyn"
},
{
"family": "Gerchen",
"given": "Martin Fungisai"
},
{
"family": "Pritsch",
"given": "Marc"
},
{
"family": "Rocha",
"given": "Joshua"
},
{
"family": "Zamoscik",
"given": "Vera"
},
{
"family": "Kirsch",
"given": "Peter"
},
{
"family": "Herzog",
"given": "Roland"
},
{
"family": "Koppe",
"given": "Georgia"
}
],
"container-title-short": "Hum Brain Mapp",
"volume": "47",
"issue": "11",
"page": "e70600",
"DOI": "10.1002/hbm.70600",
"PMID": "42454569",
"PMCID": "PMC13370802",
"ISSN": "1065-9471",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hbm.70600",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
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/s41467-026-71961-4 [code]
Spatiotemporal asymmetries on brain energy landscape uncover system entrapment related to depression severity.
Journal: Nature communications
In common: Nilearn, statsmodels, NiBabel, 5 other tools, computational, depression, 6 references
[2] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: Nilearn, NiBabel, PyTorch, 5 other tools, depression, 5 references
[3] doi:10.1162/imag.a.1282 [code]
Metabolic syndrome severity and the energetic cost of brain network transitions: A normative modeling study of accelerated brain aging.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, statsmodels, NiBabel, 5 other tools, computational, 3 references
[4] doi:10.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: UMAP, Nilearn, Plotly, 8 other tools
[5] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, Plotly, statsmodels, 6 other tools, computational, 1 reference
[6] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: Nilearn, statsmodels, NiBabel, 5 other tools, computational, 1 reference
[7] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: UMAP, Plotly, statsmodels, 6 other tools, depression
[8] doi:10.1162/imag.a.1276 [code]
High-resolution whole-brain magnetic resonance spectroscopic imaging in youth at risk for psychosis.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: UMAP, Nilearn, Plotly, 6 other tools
[9] doi:10.1038/s42003-026-10011-7 [code]
Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures.
Journal: Communications biology
In common: Nilearn, NiBabel, PyTorch, 5 other tools, depression, 1 reference
[10] doi:10.1371/journal.pcbi.1013463 [code]
A multi-frequency whole-brain neural mass model with homeostatic feedback inhibition.
Journal: PLoS computational biology
In common: Nilearn, NiBabel, scikit-learn, 3 other tools, computational, 2 references

Contribute

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

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

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.