Brain cognition gaps reveal associations with dopamine and factors related to brain health through artificial intelligence prediction of functional connectome.
5 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 6 matches
- [1] § Materials and methods › Deep neural network model › Enhanced residual block ↔ train_densenet_fc_age.py, lines 235 to 315 · score 0.78 · squared error, Keras, loss, momentum, TensorFlow, MSE · block
oscr:b:1V4WBN2S0YQW0-5· Report a mismatch - [2] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 200 to 209 · score 0.60 · BatchNormalization, enhanced residual block, transition, layer, ReLU · block
oscr:b:TKD9FEJDWV0VQ-F· Report a mismatch - [3] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 212 to 232 · score 0.57 · Batch normalization, dense block, DenseNet, linear, layer, ReLU · block
oscr:b:98FK5WZ89S0H9-K· Report a mismatch - [4] § Materials and methods › Deep neural network model ↔ train_densenet_fc_age.py, lines 1 to 50 · score 0.54 · DenseNet, attention block, HFAB, ERB, training · block
oscr:b:JCJ0M2VBG07EY-B· Report a mismatch - [5] § Results › AI-driven predictive modeling of cognition scores from the functional connectome ↔ train_densenet_fc_age.py, lines 235 to 315 · score 0.53 · absolute error, square error, MAE, MSE, scores, trained · block
oscr:b:1V4WBN2S0YQW0-5· Report a mismatch - [6] § Materials and methods › Deep neural network model › Enhanced residual block ↔ train_densenet_fc_age.py, lines 179 to 187 · score 0.51 · ReLU, residual block, ERB, maps · block
oscr:b:6H31TQZKCA1P6-1· Report a mismatch
Paper
Loaded from Europe PMC by your browser; OSCR does not store it: 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
- #!/usr/bin/env python
- """
- train_densenet_fc_age.py
- Train a DenseNet-style CNN with attention blocks (HFAB/ERB) to predict a
- continuous target (e.g. age, episodic-memory score) from square functional
- connectivity (FC) matrices stored as .mat files.
- 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
- Example
- -------
- python train_densenet_fc_age.py \
- --data-dir /path/to/FC_Movie \
- --labels-csv /path/to/WM_AGE.csv \
- --subject-id-col SubjectID \
- --target-col AGE \
- --runs-per-subject 3 \
- --output-dir ./runs/densenet_age_run1
- Requirements: see requirements.txt (TensorFlow >= 2.10, scikit-learn, scipy,
- pandas, numpy).
- """
- from __future__ import annotations
- import argparse
- import json
- import logging
- import re
- import sys
- from dataclasses import dataclass
- from pathlib import Path
- from typing import Optional
- import numpy as np
- import pandas as pd
- import scipy.io
- import tensorflow as tf
- from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
- from sklearn.model_selection import GroupShuffleSplit
- from tensorflow.keras import Model
- from tensorflow.keras.layers import Conv2D, Dropout, Flatten, Input, MaxPool2D
- from tensorflow.keras.layers import BatchNormalization, ReLU, concatenate, multiply, add
- logging.basicConfig(
- level=logging.INFO,
- format="%(asctime)s [%(levelname)s] %(message)s",
- datefmt="%Y-%m-%d %H:%M:%S",
- )
- log = logging.getLogger("densenet_fc")
- # Data loading
- @dataclass
- class Sample:
- filepath: Path
- subject_id: str
- target: float
- def extract_subject_id(filepath: Path) -> str:
- """
- Parse a subject identifier out of a .mat filename / path.
- *** ADAPT THIS TO YOUR ACTUAL NAMING CONVENTION. ***
- The default assumes filenames contain a token like 'sub-0012' or
- 'subject012'. This is the single most important function to check before
- trusting any results: silent subject/label mismatches are the easiest
- way to get numbers that look plausible but are meaningless.
- """
- match = re.search(r"(sub(?:ject)?-?\d+)", filepath.stem, flags=re.IGNORECASE)
- if not match:
- raise ValueError(
- f"Could not extract a subject ID from '{filepath.name}'. "
- "Update extract_subject_id() to match your file naming scheme."
- )
- return match.group(1).lower()
- def build_sample_index(
- data_dir: Path,
- labels_csv: Path,
- subject_id_col: str,
- target_col: str,
- ) -> list[Sample]:
- """
- Build an explicit, verifiable list of (filepath, subject_id, target)
- triples by joining .mat files to the labels CSV on subject ID.
- """
- df = pd.read_csv(labels_csv)
- if subject_id_col not in df.columns or target_col not in df.columns:
- raise ValueError(
- f"labels CSV must contain columns '{subject_id_col}' and "
- f"'{target_col}'. Found columns: {list(df.columns)}"
- )
- df[subject_id_col] = df[subject_id_col].astype(str).str.lower()
- label_lookup = dict(zip(df[subject_id_col], df[target_col].astype(float)))
- mat_files = sorted(data_dir.glob("**/*.mat"))
- if not mat_files:
- raise FileNotFoundError(f"No .mat files found under {data_dir}")
- samples: list[Sample] = []
- skipped = 0
- for fp in mat_files:
- try:
- sid = extract_subject_id(fp)
- except ValueError as exc:
- log.warning("Skipping file: %s", exc)
- skipped += 1
- continue
- if sid not in label_lookup:
- log.warning("No label found for subject '%s' (file: %s) -- skipping.", sid, fp.name)
- skipped += 1
- continue
- samples.append(Sample(filepath=fp, subject_id=sid, target=label_lookup[sid]))
- if skipped:
- log.warning("%d of %d files were skipped due to missing/unmatched labels.", skipped, len(mat_files))
- log.info("Matched %d FC-map files to labels across %d unique subjects.",
- len(samples), len({s.subject_id for s in samples}))
- if not samples:
- raise RuntimeError("No samples matched between .mat files and labels CSV. Check extract_subject_id().")
- return samples
- def load_matrices(samples: list[Sample], mat_key: str, matrix_size: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
- """Load all FC matrices into a single float32 array, plus targets and group (subject) IDs."""
- n = len(samples)
- data = np.zeros((n, matrix_size, matrix_size), dtype="float32")
- targets = np.zeros(n, dtype="float32")
- groups = np.empty(n, dtype=object)
- for i, s in enumerate(samples):
- mat = scipy.io.loadmat(s.filepath)
- if mat_key not in mat:
- raise KeyError(
- f"Expected key '{mat_key}' not found in {s.filepath.name}. "
- f"Available keys: {[k for k in mat if not k.startswith('__')]}"
- )
- arr = mat[mat_key]
- if arr.shape != (matrix_size, matrix_size):
- raise ValueError(
- f"{s.filepath.name}: expected shape ({matrix_size}, {matrix_size}), got {arr.shape}"
- )
- data[i] = arr
- targets[i] = s.target
- groups[i] = s.subject_id
- data = np.expand_dims(data, axis=-1) # (N, H, W, 1)
- return data, targets, groups
- def group_train_val_split(
- data: np.ndarray, targets: np.ndarray, groups: np.ndarray, val_fraction: float, seed: int
- ):
- """Subject-grouped split so repeat runs from one subject never straddle train/val."""
- splitter = GroupShuffleSplit(n_splits=1, test_size=val_fraction, random_state=seed)
- train_idx, val_idx = next(splitter.split(data, targets, groups))
- log.info(
- "Train/val split: %d train samples (%d subjects), %d val samples (%d subjects).",
- len(train_idx), len(set(groups[train_idx])),
- len(val_idx), len(set(groups[val_idx])),
- )
- return (data[train_idx], targets[train_idx]), (data[val_idx], targets[val_idx])
- # Model
- def enhanced_residual_block(x, n_filters: int):
- """ERB: 1x1 -> 3x3 -> 1x1 convs with two residual additions."""
- conv11 = Conv2D(n_filters, 1, kernel_initializer="he_uniform", padding="same", activation="relu")(x)
- y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(conv11)
- y = add([conv11, y])
- y = Conv2D(n_filters, 1, kernel_initializer="he_uniform", padding="same", activation="relu")(y)
- y = add([conv11, y])
- return y
- def high_freq_attention_block(x, n_filters: int):
- """HFAB: a conv branch gated by a sigmoid attention map derived from an ERB."""
- branch = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(x)
- y = ReLU()(branch)
- y = enhanced_residual_block(y, n_filters)
- y = ReLU()(y)
- y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", padding="same", activation="relu")(y)
- y = tf.keras.activations.sigmoid(y)
- return multiply([y, branch])
- def dense_block(x, n_filters: int, n_layers: int, dropout: float):
- for _ in range(n_layers):
- y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
- y = Conv2D(n_filters, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(y)
- if dropout > 0:
- y = Dropout(dropout)(y)
- x = concatenate([y, x])
- return x
- def transition_layer(x, n_filters: int, dropout: float):
- n_channels = x.shape[-1] // 2
- x = Conv2D(n_channels, 3, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
- x = BatchNormalization()(x)
- x = MaxPool2D(pool_size=5, strides=1, padding="same")(x)
- x = enhanced_residual_block(x, n_filters)
- x = high_freq_attention_block(x, n_filters)
- if dropout > 0:
- x = Dropout(dropout)(x)
- return x
- def build_densenet(
- input_shape: tuple[int, int, int],
- n_outputs: int = 1,
- n_filters: int = 16,
- block_depths: tuple[int, ...] = (2, 6, 6, 2),
- dropout: float = 0.2,
- ) -> Model:
- inputs = Input(input_shape)
- x = BatchNormalization()(inputs)
- x = Conv2D(n_filters, 3, strides=1, kernel_initializer="he_uniform", activation="relu", padding="same")(x)
- for n_layers in block_depths:
- x = high_freq_attention_block(x, n_filters)
- x = dense_block(x, n_filters, n_layers, dropout)
- x = transition_layer(x, n_filters, dropout)
- x = Flatten()(x)
- if dropout > 0:
- x = Dropout(dropout)(x)
- outputs = tf.keras.layers.Dense(n_outputs, activation="linear")(x)
- return Model(inputs, outputs, name="densenet_fc_regressor")
- # Training / evaluation
- def train(args: argparse.Namespace) -> None:
- tf.random.set_seed(args.seed)
- np.random.seed(args.seed)
- output_dir = Path(args.output_dir)
- output_dir.mkdir(parents=True, exist_ok=True)
- with open(output_dir / "run_config.json", "w") as f:
- json.dump(vars(args), f, indent=2, default=str)
- samples = build_sample_index(
- data_dir=Path(args.data_dir),
- labels_csv=Path(args.labels_csv),
- subject_id_col=args.subject_id_col,
- target_col=args.target_col,
- )
- data, targets, groups = load_matrices(samples, mat_key=args.mat_key, matrix_size=args.matrix_size)
- log.info("Loaded data array: %s, target range [%.3f, %.3f]", data.shape, targets.min(), targets.max())
- (train_x, train_y), (val_x, val_y) = group_train_val_split(
- data, targets, groups, val_fraction=args.val_fraction, seed=args.seed
- )
- # Standardize target using train-set statistics only (avoids leakage).
- target_mean, target_std = train_y.mean(), train_y.std() + 1e-8
- train_y_norm = (train_y - target_mean) / target_std
- val_y_norm = (val_y - target_mean) / target_std
- model = build_densenet(
- input_shape=(args.matrix_size, args.matrix_size, 1),
- n_outputs=1,
- n_filters=args.n_filters,
- dropout=args.dropout,
- )
- model.summary(print_fn=log.info)
- optimizer = tf.keras.optimizers.Adam(learning_rate=args.learning_rate) if args.optimizer == "adam" \
- else tf.keras.optimizers.SGD(learning_rate=args.learning_rate, momentum=0.9)
- model.compile(optimizer=optimizer, loss="mean_absolute_error", metrics=["mse"])
- callbacks = [
- tf.keras.callbacks.ModelCheckpoint(
- filepath=str(output_dir / "best_model.keras"),
- monitor="val_loss", save_best_only=True, verbose=1,
- ),
- tf.keras.callbacks.EarlyStopping(
- monitor="val_loss", patience=args.early_stopping_patience,
- restore_best_weights=True, verbose=1,
- ),
- tf.keras.callbacks.ReduceLROnPlateau(
- monitor="val_loss", factor=0.5, patience=max(5, args.early_stopping_patience // 2), verbose=1,
- ),
- tf.keras.callbacks.CSVLogger(str(output_dir / "training_history.csv")),
- ]
- history = model.fit(
- train_x, train_y_norm,
- validation_data=(val_x, val_y_norm),
- batch_size=args.batch_size,
- epochs=args.epochs,
- callbacks=callbacks,
- verbose=2,
- )
- # Final held-out evaluation, in original target units.
- val_pred_norm = model.predict(val_x, batch_size=args.batch_size).ravel()
- val_pred = val_pred_norm * target_std + target_mean
- mae = mean_absolute_error(val_y, val_pred)
- rmse = mean_squared_error(val_y, val_pred, squared=False)
- r2 = r2_score(val_y, val_pred)
- log.info("Held-out validation -- MAE: %.4f, RMSE: %.4f, R^2: %.4f", mae, rmse, r2)
- metrics = {"val_mae": mae, "val_rmse": rmse, "val_r2": r2,
- "target_mean": float(target_mean), "target_std": float(target_std)}
- with open(output_dir / "final_metrics.json", "w") as f:
- json.dump(metrics, f, indent=2)
- model.save(output_dir / "final_model.keras")
- log.info("Saved final model and metrics to %s", output_dir)
- # CLI
- def parse_args(argv: Optional[list[str]] = None) -> argparse.Namespace:
- p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
- p.add_argument("--data-dir", required=True, type=str, help="Directory containing .mat FC-map files (searched recursively).")
- p.add_argument("--labels-csv", required=True, type=str, help="CSV file with subject IDs and target values.")
- p.add_argument("--subject-id-col", default="SubjectID", type=str, help="Column name for subject ID in labels CSV.")
- p.add_argument("--target-col", default="AGE", type=str, help="Column name for the regression target in labels CSV.")
- p.add_argument("--mat-key", default="IMG_temp", type=str, help="Key inside each .mat file holding the FC matrix.")
- p.add_argument("--matrix-size", default=273, type=int, help="Side length of the (square) FC matrix.")
- p.add_argument("--output-dir", default="./run_output", type=str, help="Where to write model checkpoints, logs, metrics.")
- p.add_argument("--val-fraction", default=0.2, type=float, help="Fraction of subjects held out for validation.")
- p.add_argument("--n-filters", default=16, type=int, help="Base channel width for the network.")
- p.add_argument("--dropout", default=0.2, type=float, help="Dropout rate used throughout the network.")
- p.add_argument("--batch-size", default=16, type=int)
- p.add_argument("--epochs", default=400, type=int)
- p.add_argument("--learning-rate", default=1e-3, type=float)
- p.add_argument("--optimizer", default="adam", choices=["adam", "sgd"])
- p.add_argument("--early-stopping-patience", default=25, type=int)
- p.add_argument("--seed", default=0, type=int)
- return p.parse_args(argv)
- def main() -> None:
- args = parse_args()
- log.info("Starting run with config: %s", vars(args))
- train(args)
- if __name__ == "__main__":
- sys.exit(main())
train_densenet_fc_age.py at commit 40d54fc, under CC-BY-4.0 · at the source
Overview
- Department of Electrical Engineering and Computer Science, University of Stavanger, Stavanger, Norway
- Department of Diagnostic Imaging, Akershus University Hospital, Lørenskog, Norway
- Institute of Clinical Medicine, University of Oslo, Oslo, Norway
- Wallenberg Centre for Molecular Medicine (WCMM), Umeå University, Umeå, Sweden
- Department of Medical and Translational Biology, Umeå University, Umeå, Sweden
- Aging Research Center, Karolinska Institute and Stockholm University, Solna, Sweden
- Department of Diagnostics and Intervention, Diagnostic Radiology, Umeå University, Umeå, Sweden
- Umeå Center for Functional Brain Imaging (UFBI), Umeå University, Umeå, Sweden
- Department of Psychology, Florida State University, Tallahassee, United States
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
40d54fc2665482db688562207d989d924d7ecdc7, 27 August 2026Availability: 1 check, the latest on 26 September 2026: the link answers
- 26 September 2026: the link answers
3 files
- train_densenet_fc_age.py
, Python, 347 lines, 6 matches - LICENSE, License, 18 lines
- README.md, Text, 29 lines
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://
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://
BibTeX
@article{esmaeili2026bra
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/
url = {https://
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/
VL - 14
SP - RP104053
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.7554/
"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":
"volume": "14",
"page": "RP104053",
"DOI": "10.7554/
"PMID": "42684829",
"PMCID": "PMC13537765",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://
"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.7554/elife.97658 [code]
- Two long-axis dimensions of hippocampal-cortical integration support memory function across the adult lifespan.Journal: eLifeIn common: pandas, SciPy, NumPy, cognitive, 10 references, 4 authors
- [2] doi:10.1016/j.nbas.2023.100079 [code]
- Dopamine D1-signaling modulates maintenance of functional network segregation in aging.Journal: Aging brainIn common: cognitive, 21 references, author Robin Pedersen
- [3] doi:10.1523/jneurosci.0621-23.2024 [code]
- Dopamine D1-Receptor Organization Contributes to Functional Brain Architecture.Journal: The Journal of neuroscience : the official journal of the Society for NeuroscienceIn common: 10 references, 3 authors
- [4] doi:10.1162/imag_a_00462 [code]
- Dedifferentiation of caudate functional organization is linked to reduced D1 dopamine receptor availability and poorer memory function in aging.Journal: Imaging neuroscience (Cambridge, Mass.)In common: 19 references
- [5] 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
- [6] doi:10.1162/imag.a.1074 [code]
- Multiple brain activation patterns underlying successful visual short-term memory across the adult lifespan.Journal: Imaging neuroscience (Cambridge, Mass.)In common: cognitive, 11 references, author Alireza Salami
- [7] doi:10.1002/hbm.26535 [code]
- How do tasks impact the reliability of fMRI functional connectivity?Journal: Human brain mappingIn common: pandas, SciPy, NumPy, 12 references
- [8] doi:10.1162/imag_a_00233 [code]
- Multilayer meta-matching: Translating phenotypic prediction models from multiple datasets to small data.Journal: Imaging neuroscience (Cambridge, Mass.)In common: scikit-learn, SciPy, NumPy, 12 references
- [9] doi:10.21203/rs.3.rs-9326213/v1 [code]
- Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brainJournal: Research Square (preprint)In common: scikit-learn, pandas, SciPy, 1 other tool, cognitive, 10 references
- [10] doi:10.64898/2026.03.09.710558 [code]
- Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brainJournal: bioRxiv (preprint)In common: scikit-learn, pandas, SciPy, 1 other tool, cognitive, 10 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.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 1 repository of the authors' code, each at its verified commit and with its license, 1 script, and 6 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:7570102d994f323a…
Add the badge to the code's README
If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.
Markdown
<!-- oscr-badge:start -->
[](https://openscicode.org/badge/doi/10.7554/elife.104053)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.7554/elife.104053.svg
:target: https://openscicode.org/badge/doi/10.7554/elife.104053
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.7554/elife.104053"><img src="https://openscicode.org/badge/doi/10.7554/elife.104053.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".
If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.
Report a mismatch between the code and the paper · Report a code error (signed in)
Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.
Report a reproduction failure (signed in)
Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.
Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.
