OSCR

Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome.

Code ↔ Paper

6 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 6 matches
  1. [1] § Materials and methods › Deep neural network model › Enhanced residual block ↔ train_densenet_fc_age.py, lines 235–315 · score 0.78 · squared error, Keras, loss, momentum, TensorFlow, MSE
  2. [2] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 200–209 · score 0.60 · BatchNormalization, enhanced residual block, transition, layer, ReLU
  3. [3] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 212–232 · score 0.57 · Batch normalization, dense block, DenseNet, linear, layer, ReLU
  4. [4] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 1–50 · score 0.54 · DenseNet, attention block, HFAB, ERB, training
  5. [5] § Results › AI-driven predictive modeling of cognition scores from the functional connectome ↔ train_densenet_fc_age.py, lines 235–315 · score 0.53 · absolute error, square error, MAE, MSE, scores, trained
  6. [6] § Materials and methods › Deep neural network model › Enhanced residual block ↔ train_densenet_fc_age.py, lines 179–187 · score 0.51 · ReLU, residual block, ERB, maps

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 · 347 lines · 14 KB · CC-BY-4.0 · 6 matches

  1. #!/usr/bin/env python
  2. """
  3. train_densenet_fc_age.py
  5. Train a DenseNet-style CNN with attention blocks (HFAB/ERB) to predict a
  6. continuous target (e.g. age, episodic-memory score) from square functional
  7. connectivity (FC) matrices stored as .mat files.
  8. M. Esmaeili et al. (2026), Brain-Cognitive Gaps in relation to Dopamine and Health-related Factors: Insights from AI-Driven Functional Connectome Predictions, eLife Sciences Publications, Ltd, 2025. https://doi.org/10.7554/eLife.104053.1
  10. Example
  11. -------
  12. python train_densenet_fc_age.py \
  13. --data-dir /path/to/FC_Movie \
  14. --labels-csv /path/to/WM_AGE.csv \
  15. --subject-id-col SubjectID \
  16. --target-col AGE \
  17. --runs-per-subject 3 \
  18. --output-dir ./runs/densenet_age_run1
  20. Requirements: see requirements.txt (TensorFlow >= 2.10, scikit-learn, scipy,
  21. pandas, numpy).
  22. """
  24. from __future__ import annotations
  26. import argparse
  27. import json
  28. import logging
  29. import re
  30. import sys
  31. from dataclasses import dataclass
  32. from pathlib import Path
  33. from typing import Optional
  35. import numpy as np
  36. import pandas as pd
  37. import scipy.io
  38. import tensorflow as tf
  39. from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
  40. from sklearn.model_selection import GroupShuffleSplit
  41. from tensorflow.keras import Model
  42. from tensorflow.keras.layers import Conv2D, Dropout, Flatten, Input, MaxPool2D
  43. from tensorflow.keras.layers import BatchNormalization, ReLU, concatenate, multiply, add
  45. logging.basicConfig(
  46. level=logging.INFO,
  47. format="%(asctime)s [%(levelname)s] %(message)s",
  48. datefmt="%Y-%m-%d %H:%M:%S",
  49. )
  50. log = logging.getLogger("densenet_fc")
  53. # Data loading
  54. @dataclass
  55. class Sample:
  56. filepath: Path
  57. subject_id: str
  58. target: float
  61. def extract_subject_id(filepath: Path) -> str:
  62. """
  63. Parse a subject identifier out of a .mat filename / path.
  65. *** ADAPT THIS TO YOUR ACTUAL NAMING CONVENTION. ***
  66. The default assumes filenames contain a token like 'sub-0012' or
  67. 'subject012'. This is the single most important function to check before
  68. trusting any results: silent subject/label mismatches are the easiest
  69. way to get numbers that look plausible but are meaningless.
  70. """
  71. match = re.search(r"(sub(?:ject)?-?\d+)", filepath.stem, flags=re.IGNORECASE)
  72. if not match:
  73. raise ValueError(
  74. f"Could not extract a subject ID from '{filepath.name}'. "
  75. "Update extract_subject_id() to match your file naming scheme."
  76. )
  77. return match.group(1).lower()
  80. def build_sample_index(
  81. data_dir: Path,
  82. labels_csv: Path,
  83. subject_id_col: str,
  84. target_col: str,
  85. ) -> list[Sample]:
  86. """
  87. Build an explicit, verifiable list of (filepath, subject_id, target)
  88. triples by joining .mat files to the labels CSV on subject ID.
  89. """
  90. df = pd.read_csv(labels_csv)
  91. if subject_id_col not in df.columns or target_col not in df.columns:
  92. raise ValueError(
  93. f"labels CSV must contain columns '{subject_id_col}' and "
  94. f"'{target_col}'. Found columns: {list(df.columns)}"
  95. )
  96. df[subject_id_col] = df[subject_id_col].astype(str).str.lower()
  97. label_lookup = dict(zip(df[subject_id_col], df[target_col].astype(float)))
  99. mat_files = sorted(data_dir.glob("**/*.mat"))
  100. if not mat_files:
  101. raise FileNotFoundError(f"No .mat files found under {data_dir}")
  103. samples: list[Sample] = []
  104. skipped = 0
  105. for fp in mat_files:
  106. try:
  107. sid = extract_subject_id(fp)
  108. except ValueError as exc:
  109. log.warning("Skipping file: %s", exc)
  110. skipped += 1
  111. continue
  112. if sid not in label_lookup:
  113. log.warning("No label found for subject '%s' (file: %s) -- skipping.", sid, fp.name)
  114. skipped += 1
  115. continue
  116. samples.append(Sample(filepath=fp, subject_id=sid, target=label_lookup[sid]))
  118. if skipped:
  119. log.warning("%d of %d files were skipped due to missing/unmatched labels.", skipped, len(mat_files))
  120. log.info("Matched %d FC-map files to labels across %d unique subjects.",
  121. len(samples), len({s.subject_id for s in samples}))
  122. if not samples:
  123. raise RuntimeError("No samples matched between .mat files and labels CSV. Check extract_subject_id().")
  124. return samples
  127. def load_matrices(samples: list[Sample], mat_key: str, matrix_size: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
  128. """Load all FC matrices into a single float32 array, plus targets and group (subject) IDs."""
  129. n = len(samples)
  130. data = np.zeros((n, matrix_size, matrix_size), dtype="float32")
  131. targets = np.zeros(n, dtype="float32")
  132. groups = np.empty(n, dtype=object)
  134. for i, s in enumerate(samples):
  135. mat = scipy.io.loadmat(s.filepath)
  136. if mat_key not in mat:
  137. raise KeyError(
  138. f"Expected key '{mat_key}' not found in {s.filepath.name}. "
  139. f"Available keys: {[k for k in mat if not k.startswith('__')]}"
  140. )
  141. arr = mat[mat_key]
  142. if arr.shape != (matrix_size, matrix_size):
  143. raise ValueError(
  144. f"{s.filepath.name}: expected shape ({matrix_size}, {matrix_size}), got {arr.shape}"
  145. )
  146. data[i] = arr
  147. targets[i] = s.target
  148. groups[i] = s.subject_id
  150. data = np.expand_dims(data, axis=-1) # (N, H, W, 1)
  151. return data, targets, groups
  154. def group_train_val_split(
  155. data: np.ndarray, targets: np.ndarray, groups: np.ndarray, val_fraction: float, seed: int
  156. ):
  157. """Subject-grouped split so repeat runs from one subject never straddle train/val."""
  158. splitter = GroupShuffleSplit(n_splits=1, test_size=val_fraction, random_state=seed)
  159. train_idx, val_idx = next(splitter.split(data, targets, groups))
  160. log.info(
  161. "Train/val split: %d train samples (%d subjects), %d val samples (%d subjects).",
  162. len(train_idx), len(set(groups[train_idx])),
  163. len(val_idx), len(set(groups[val_idx])),
  164. )
  165. return (data[train_idx], targets[train_idx]), (data[val_idx], targets[val_idx])
  168. # Model
  169. def enhanced_residual_block(x, n_filters: int):
  170. """ERB: 1x1 -> 3x3 -> 1x1 convs with two residual additions."""
  171. conv11 = Conv2D(n_filters, 1, kernel_initializer="he_uniform", padding="same", activation="relu")(x)
  172. y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(conv11)
  173. y = add([conv11, y])
  174. y = Conv2D(n_filters, 1, kernel_initializer="he_uniform", padding="same", activation="relu")(y)
  175. y = add([conv11, y])
  176. return y
  179. def high_freq_attention_block(x, n_filters: int):
  180. """HFAB: a conv branch gated by a sigmoid attention map derived from an ERB."""
  181. branch = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(x)
  182. y = ReLU()(branch)
  183. y = enhanced_residual_block(y, n_filters)
  184. y = ReLU()(y)
  185. y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(y)
  186. y = tf.keras.activations.sigmoid(y)
  187. return multiply([y, branch])
  190. def dense_block(x, n_filters: int, n_layers: int, dropout: float):
  191. for _ in range(n_layers):
  192. y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
  193. y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(y)
  194. if dropout > 0:
  195. y = Dropout(dropout)(y)
  196. x = concatenate([y, x])
  197. return x
  200. def transition_layer(x, n_filters: int, dropout: float):
  201. n_channels = x.shape[-1] // 2
  202. x = Conv2D(n_channels, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
  203. x = BatchNormalization()(x)
  204. x = MaxPool2D(pool_size=5, strides=1, padding="same")(x)
  205. x = enhanced_residual_block(x, n_filters)
  206. x = high_freq_attention_block(x, n_filters)
  207. if dropout > 0:
  208. x = Dropout(dropout)(x)
  209. return x
  212. def build_densenet(
  213. input_shape: tuple[int, int, int],
  214. n_outputs: int = 1,
  215. n_filters: int = 16,
  216. block_depths: tuple[int, ...] = (2, 6, 6, 2),
  217. dropout: float = 0.2,
  218. ) -> Model:
  219. inputs = Input(input_shape)
  220. x = BatchNormalization()(inputs)
  221. x = Conv2D(n_filters, 3, strides=1, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
  223. for n_layers in block_depths:
  224. x = high_freq_attention_block(x, n_filters)
  225. x = dense_block(x, n_filters, n_layers, dropout)
  226. x = transition_layer(x, n_filters, dropout)
  228. x = Flatten()(x)
  229. if dropout > 0:
  230. x = Dropout(dropout)(x)
  231. outputs = tf.keras.layers.Dense(n_outputs, activation="linear")(x)
  232. return Model(inputs, outputs, name="densenet_fc_regressor")
  235. # Training / evaluation
  236. def train(args: argparse.Namespace) -> None:
  237. tf.random.set_seed(args.seed)
  238. np.random.seed(args.seed)
  240. output_dir = Path(args.output_dir)
  241. output_dir.mkdir(parents=True, exist_ok=True)
  242. with open(output_dir / "run_config.json", "w") as f:
  243. json.dump(vars(args), f, indent=2, default=str)
  245. samples = build_sample_index(
  246. data_dir=Path(args.data_dir),
  247. labels_csv=Path(args.labels_csv),
  248. subject_id_col=args.subject_id_col,
  249. target_col=args.target_col,
  250. )
  252. data, targets, groups = load_matrices(samples, mat_key=args.mat_key, matrix_size=args.matrix_size)
  253. log.info("Loaded data array: %s, target range [%.3f, %.3f]", data.shape, targets.min(), targets.max())
  255. (train_x, train_y), (val_x, val_y) = group_train_val_split(
  256. data, targets, groups, val_fraction=args.val_fraction, seed=args.seed
  257. )
  259. # Standardize target using train-set statistics only (avoids leakage).
  260. target_mean, target_std = train_y.mean(), train_y.std() + 1e-8
  261. train_y_norm = (train_y - target_mean) / target_std
  262. val_y_norm = (val_y - target_mean) / target_std
  264. model = build_densenet(
  265. input_shape=(args.matrix_size, args.matrix_size, 1),
  266. n_outputs=1,
  267. n_filters=args.n_filters,
  268. dropout=args.dropout,
  269. )
  270. model.summary(print_fn=log.info)
  272. optimizer = tf.keras.optimizers.Adam(learning_rate=args.learning_rate) if args.optimizer == "adam" \
  273. else tf.keras.optimizers.SGD(learning_rate=args.learning_rate, momentum=0.9)
  274. model.compile(optimizer=optimizer, loss="mean_absolute_error", metrics=["mse"])
  276. callbacks = [
  277. tf.keras.callbacks.ModelCheckpoint(
  278. filepath=str(output_dir / "best_model.keras"),
  279. monitor="val_loss", save_best_only=True, verbose=1,
  280. ),
  281. tf.keras.callbacks.EarlyStopping(
  282. monitor="val_loss", patience=args.early_stopping_patience,
  283. restore_best_weights=True, verbose=1,
  284. ),
  285. tf.keras.callbacks.ReduceLROnPlateau(
  286. monitor="val_loss", factor=0.5, patience=max(5, args.early_stopping_patience // 2), verbose=1,
  287. ),
  288. tf.keras.callbacks.CSVLogger(str(output_dir / "training_history.csv")),
  289. ]
  291. history = model.fit(
  292. train_x, train_y_norm,
  293. validation_data=(val_x, val_y_norm),
  294. batch_size=args.batch_size,
  295. epochs=args.epochs,
  296. callbacks=callbacks,
  297. verbose=2,
  298. )
  300. # Final held-out evaluation, in original target units.
  301. val_pred_norm = model.predict(val_x, batch_size=args.batch_size).ravel()
  302. val_pred = val_pred_norm * target_std + target_mean
  304. mae = mean_absolute_error(val_y, val_pred)
  305. rmse = mean_squared_error(val_y, val_pred, squared=False)
  306. r2 = r2_score(val_y, val_pred)
  307. log.info("Held-out validation -- MAE: %.4f, RMSE: %.4f, R^2: %.4f", mae, rmse, r2)
  309. metrics = {"val_mae": mae, "val_rmse": rmse, "val_r2": r2,
  310. "target_mean": float(target_mean), "target_std": float(target_std)}
  311. with open(output_dir / "final_metrics.json", "w") as f:
  312. json.dump(metrics, f, indent=2)
  314. model.save(output_dir / "final_model.keras")
  315. log.info("Saved final model and metrics to %s", output_dir)
  318. # CLI
  319. def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
  320. p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
  321. p.add_argument("--data-dir", required=True, type=str, help="Directory containing .mat FC-map files (searched recursively).")
  322. p.add_argument("--labels-csv", required=True, type=str, help="CSV file with subject IDs and target values.")
  323. p.add_argument("--subject-id-col", default="SubjectID", type=str, help="Column name for subject ID in labels CSV.")
  324. p.add_argument("--target-col", default="AGE", type=str, help="Column name for the regression target in labels CSV.")
  325. p.add_argument("--mat-key", default="IMG_temp", type=str, help="Key inside each .mat file holding the FC matrix.")
  326. p.add_argument("--matrix-size", default=273, type=int, help="Side length of the (square) FC matrix.")
  327. p.add_argument("--output-dir", default="./run_output", type=str, help="Where to write model checkpoints, logs, metrics.")
  328. p.add_argument("--val-fraction", default=0.2, type=float, help="Fraction of subjects held out for validation.")
  329. p.add_argument("--n-filters", default=16, type=int, help="Base channel width for the network.")
  330. p.add_argument("--dropout", default=0.2, type=float, help="Dropout rate used throughout the network.")
  331. p.add_argument("--batch-size", default=16, type=int)
  332. p.add_argument("--epochs", default=400, type=int)
  333. p.add_argument("--learning-rate", default=1e-3, type=float)
  334. p.add_argument("--optimizer", default="adam", choices=["adam", "sgd"])
  335. p.add_argument("--early-stopping-patience", default=25, type=int)
  336. p.add_argument("--seed", default=0, type=int)
  337. return p.parse_args(argv)
  340. def main() -> None:
  341. args = parse_args()
  342. log.info("Starting run with config: %s", vars(args))
  343. train(args)
  346. if __name__ == "__main__":
  347. sys.exit(main())

train_densenet_fc_age.py at commit 40d54fc, under CC-BY-4.0 · at the source

Overview

Authors: Morteza Esmaeili1,2, Erin Beate Bjørkeli2,3, Robin Pedersen4,5,6, Farshad Falahati4,5,6, Jarkko Johansson4,7, Kristin Nordin6, Nina Karalija7,8, Lars Bäckman6, Lars Nyberg5,7,8, Alireza Salami4,5,6,8,9
ORCID iDs: Morteza Esmaeili, Robin Pedersen, Farshad Falahati, Jarkko Johansson, Kristin Nordin, Lars Nyberg, Alireza Salami
  1. Department of Electrical Engineering and Computer Science, University of Stavanger, Stavanger, Norway
  2. Department of Diagnostic Imaging, Akershus University Hospital, Lørenskog, Norway
  3. Institute of Clinical Medicine, University of Oslo, Oslo, Norway
  4. Wallenberg Centre for Molecular Medicine (WCMM), Umeå University, Umeå, Sweden
  5. Department of Medical and Translational Biology, Umeå University, Umeå, Sweden
  6. Aging Research Center, Karolinska Institute and Stockholm University, Solna, Sweden
  7. Department of Diagnostics and Intervention, Diagnostic Radiology, Umeå University, Umeå, Sweden
  8. Umeå Center for Functional Brain Imaging (UFBI), Umeå University, Umeå, Sweden
  9. Department of Psychology, Florida State University, Tallahassee, United States
Institutions: Akershus University Hospital (Norway); University of Stavanger (Norway); University of Oslo (Norway); Stockholm University (Sweden); Karolinska Institutet (Sweden); Umeå University (Sweden); Florida State University (United States)
Journal: eLife, volume 14, article RP104053
Dates: published online 2 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.104053 · PMID 42684829 · PMCID PMC13537765 · OpenAlex W4407578756
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: PET / SPECT (modality), human (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: Human
MeSH: Artificial Intelligence*, Brain*, Cognition*, Connectome*, Dopamine*, Adult, Female, Humans, Intelligence, Male, Memory, Episodic, Memory, Short-Term, Positron-Emission Tomography, Young Adult (* major topic)
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Karolinska Institutet (StratNeuro grant); Helse Sør-Øst RHF (2021023, 2018047); Wallenberg Centre for Molecular and Translational Medicine (P20-0515); Swedish Research Council (2021-02558)
Citations: not cited yet (Europe PMC); 149 references in the paper

Abstract

A key question in human neuroscience is to understand how individual differences in brain function relate to cognitive differences. However, the optimal condition of brain function to study between-person differences in cognition remains unclear. While many studies have developed objective biomarkers to accurately predict intelligence and general cognition, consensus on domain-specific markers has not yet emerged. Brain age has been proposed as a potential candidate, but recent research suggests that brain age offers minimal additional information on cognitive decline beyond what chronological age provides, prompting a shift toward approaches focused directly on cognitive prediction. Using a deep learning approach, we evaluated the predictive power of the functional connectome during various states (resting state, movie-watching, and n-back) on episodic memory and working memory performance. Our findings show that connectomes during tasks, especially during movie-watching, predict individual differences across cognitive domains, while resting state connectomes predict episodic memory meaningfully. Furthermore, individuals with a negative brain cognition gap (where brain predictions underestimate actual performance) exhibited lower physical activity and higher cardiovascular risk compared to those with a positive gap. This shows that knowledge of the brain cognition gap provides insights into factors contributing to cognitive resilience. Further, lower PET-derived measures of dopamine binding were linked to a greater brain cognition gap, mediated by regional functional variability. Together, our findings highlight the importance of brain state in connectome-based cognitive prediction and introduce the brain cognition gap as a potentially informative, dopamine-modulated marker of vulnerability to compromise brain function.

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

MorEsm/AI-based-Prediction-of-Cognitive-Function

License: CC-BY-4.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 40d54fc2665482db688562207d989d924d7ecdc7, 27 August 2026
Languages: Python (1)
Size: 3 files, 1 script
Software Heritage: not archived
Found in: “Data availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Keras (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), SciPy (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
3 files
At the source: github.com/MorEsm/AI-based-Prediction-of-Cognitive-Function

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;
  • 1 script, each with its path and the digest of its content;
  • 6 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

The scripts used for developing the model are available at https://github.com/MorEsm/AI-based-Prediction-of-Cognitive-Function (copy archived at Esmaeili, 2026).

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, 10 authors, 1 keyword, 14 MeSH terms, 4 funders, 141 references.

Cite

This paper

Esmaeili, M., Bjørkeli, E. B., Pedersen, R., Falahati, F., Johansson, J., Nordin, K., Karalija, N., Bäckman, L., Nyberg, L., & Salami, A. (2026). Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome. eLife, 14, RP104053. https://doi.org/10.7554/elife.104053

BibTeX

@article{esmaeili2026brain,
author = {Esmaeili, Morteza and Bjørkeli, Erin Beate and Pedersen, Robin and Falahati, Farshad and Johansson, Jarkko and Nordin, Kristin and Karalija, Nina and Bäckman, Lars and Nyberg, Lars and Salami, Alireza},
title = {{Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome}},
journal = {eLife},
year = {2026},
month = sep,
volume = {14},
pages = {RP104053},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.104053},
url = {https://doi.org/10.7554/elife.104053},
pmid = {42684829},
pmcid = {PMC13537765}
}

RIS

TY - JOUR
AU - Esmaeili, Morteza
AU - Bjørkeli, Erin Beate
AU - Pedersen, Robin
AU - Falahati, Farshad
AU - Johansson, Jarkko
AU - Nordin, Kristin
AU - Karalija, Nina
AU - Bäckman, Lars
AU - Nyberg, Lars
AU - Salami, Alireza
TI - Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome
T2 - eLife
J2 - eLife
PY - 2026
DA - 2026/09/02
VL - 14
SP - RP104053
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.104053
UR - https://doi.org/10.7554/elife.104053
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.104053",
"type": "article-journal",
"title": "Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome",
"container-title": "eLife",
"author": [
{
"family": "Esmaeili",
"given": "Morteza"
},
{
"family": "Bjørkeli",
"given": "Erin Beate"
},
{
"family": "Pedersen",
"given": "Robin"
},
{
"family": "Falahati",
"given": "Farshad"
},
{
"family": "Johansson",
"given": "Jarkko"
},
{
"family": "Nordin",
"given": "Kristin"
},
{
"family": "Karalija",
"given": "Nina"
},
{
"family": "Bäckman",
"given": "Lars"
},
{
"family": "Nyberg",
"given": "Lars"
},
{
"family": "Salami",
"given": "Alireza"
}
],
"container-title-short": "eLife",
"volume": "14",
"page": "RP104053",
"DOI": "10.7554/elife.104053",
"PMID": "42684829",
"PMCID": "PMC13537765",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.104053",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
2
]
]
}
}

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.1162/imag.a.1302 [code]
Five-year associations among dopamine D2-like receptor loss, cognitive decline, education, and self-reported leisure activities in healthy older adults.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PET / SPECT, 13 references
[2] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: scikit-learn, pandas, SciPy, 1 other tool, cognitive, 10 references
[3] doi:10.1038/s41467-026-74953-6 [code]
In-scanner thoughts contribute to resting-state functional connectivity.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 1 other tool, 10 references
[4] doi:10.1523/eneuro.0370-25.2026 [code]
Pretraining for Large-Scale Functional Connectome Fingerprinting Supports Generalization and Transfer Learning in Functional Neuroimaging.
Journal: eNeuro
In common: scikit-learn, pandas, NumPy, 10 references
[5] doi:10.1038/s41467-026-73941-0 [code]
Using connectome-based predictive models to reveal the systems standardized tests and clinical symptoms are reflecting.
Journal: Nature communications
In common: 10 references
[6] doi:10.1038/s41467-026-75661-x [code]
A neural signature of sleep deprivation in the human brain.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 1 other tool, cognitive, 8 references
[7] doi:10.1038/s41467-026-75745-8 [code]
A language network in the individualized functional connectomes of 1199 human brains doing arbitrary tasks.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 1 other tool, cognitive, 6 references
[8] doi:10.1038/s44220-026-00623-7 [code]
Optimizing functional connectivity scanning conditions for predicting autistic traits.
Journal: Nature. Mental health
In common: 8 references
[9] doi:10.1038/s41562-026-02447-y [code]
Feature selection leads to divergent neurobiological interpretations of brain-based machine learning biomarkers.
Journal: Nature human behaviour
In common: 7 references
[10] doi:10.1162/imag.a.1287 [code]
Is the whole more than the sum of its parts? Considering global and local features of the connectome improves prediction of individuals and phenotypes.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: 7 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.