OSCR

Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures.

Code ↔ Paper

22 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 22 matches · 2 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Experimental settings ↔ visualization.py, lines 24–108 · score 0.91 · Gradient clipping, AdamW, hidden layers, weight decay, model architecture, accumulation
  2. [2] § Methods › Experimental settings ↔ main.py, lines 47–95 · score 0.83 · Gradient clipping, AdamW, weight decay, accumulation, norm, SGDR
  3. [3] § Methods › Statistics and reproducibility › Statistical analysis ↔ loss_writer.py, lines 79–136 · score 0.81 · balanced accuracy, F1 score, binary classification, NMSE, R2, sensitivity
  4. [4] § Methods › Frequency-resolved decomposition based on scale-free principles › Step 1: Ultralow-frequency boundary identification using Lorentzian fitting ↔ data_preprocess_and_load/datasets.py, lines 37–78 · score 0.67 · curve_fit, power spectrum, Lorentzian, Ultralow
  5. [5] § Methods › Communicability-based pretraining strategy › Implementation details and dataset ↔ data_preprocess_and_load/datasets.py, lines 239–320 · score 0.65 · UK Biobank, downstream tasks, sequence length, fine tuning, Pretraining, band
  6. [6] § Results › Experimental setup and downstream tasks › MBBN demonstrates superior performance across diverse neuroimaging tasks ↔ data_preprocess_and_load/datasets.py, lines 239–320 · score 0.64 · fluid intelligence, downstream tasks, HCP MMP1, phenotypes, Schaefer, UKB
  7. [7] § Methods › Communicability-based pretraining strategy › Masking strategy and pretraining loss ↔ model.py, lines 296–379 · score 0.63 · MBBN pretraining, temporal masking, spatial masking, windows, zeros, head
  8. [8] § Methods › Statistics and reproducibility › Statistical analysis ↔ metrics.py, the whole file · a weak match · score 0.63 · F1 score, NMSE, R2, sensitivity, metrics, MAE
  9. [9] § Methods › Preprocessing ↔ data_preprocess_and_load/datasets.py, lines 325–424 · score 0.62 · Adolescent Brain Cognitive, sequence length, ABCD, Preprocessing
  10. [10] § Methods › Communicability-based pretraining strategy › Masking strategy and pretraining loss ↔ main.py, lines 97–164 · score 0.61 · MBBN pretraining, temporal masking, spatial masking, windows, nodes, head
  11. [11] § Methods › Statistics and reproducibility › Data splitting and sample sizes › Reproducibility ↔ environment.sh, the whole file · a weak match · score 0.61 · nibabel, conda, nitime, scikit, PyTorch, Python
  12. [12] § Methods › Communicability-based pretraining strategy › Masking strategy and pretraining loss ↔ model.py, lines 296–379 · score 0.58 · Temporal masking, Spatial masking, windows, zero, ROIs, Pretraining
  13. [13] § Methods › Preprocessing ↔ data_preprocess_and_load/ROI_EXTRACT_UKB.py, lines 32–40 · score 0.58 · MNI space, HCP MMP1, ROI, preprocessing
  14. [14] § Methods › Frequency-resolved decomposition based on scale-free principles › Validation of frequency-specific scaling properties ↔ data_preprocess_and_load/datasets.py, lines 37–78 · score 0.57 · spline multifractal, knee frequencies, spectrum, Lorentzian, power, fit
  15. [15] § Results › Experimental setup and downstream tasks › MBBN demonstrates superior performance across diverse neuroimaging tasks ↔ main.py, lines 7–45 · score 0.55 · vanilla BERT, model architectures, fine tuning, scratch, baseline, seed
  16. [16] § Methods › Model design › Model architecture ↔ visualization.py, lines 24–108 · score 0.55 · sequence length, spatial loss, head, UKB, ABIDE, architecture
  17. [17] § Methods › Dataset description and subject selection criteria ↔ data_preprocess_and_load/datasets.py, lines 325–424 · score 0.54 · Adolescent Brain Cognitive, MRI, ROI, preprocessing, ABCD
  18. [18] § Methods › Frequency-resolved decomposition based on scale-free principles › Validation of frequency-specific scaling properties ↔ data_preprocess_and_load/datasets.py, lines 133–234 · score 0.54 · knee frequencies, 1.5 s, bounded, TR, ABIDE, fMRI
  19. [19] § Methods › Communicability-based pretraining strategy › Masking strategy and pretraining loss ↔ main.py, lines 97–164 · score 0.54 · Temporal masking, Spatial masking, windows, nodes, Pretraining, loss
  20. [20] § Methods › Statistics and reproducibility › Data splitting and sample sizes › Reproducibility ↔ utils.py, lines 112–122 · score 0.52 · random module, reproducibility, Python, PyTorch, CUDA, seeds
  21. [21] § Methods › Statistics and reproducibility › Data splitting and sample sizes ↔ data_preprocess_and_load/datasets.py, lines 81–110 · score 0.52 · zero variance ROIs, split
  22. [22] § Methods › Model design › Model architecture ↔ main.py, lines 47–95 · score 0.51 · sequence length, spatial loss, UKB, ABIDE, ABCD, MBBN

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 · 424 lines · 16 KB · MIT · 8 matches

  1. import numpy as np
  2. import pandas as pd
  3. import os
  4. import torch
  5. from torch.utils.data import Dataset
  6. import torch.nn.functional as F
  7. import scipy
  8. from scipy import stats
  9. from scipy.optimize import curve_fit
  10. from iminuit import Minuit
  11. from numba import njit
  12. import warnings
  14. warnings.filterwarnings("ignore")
  16. from nitime.timeseries import TimeSeries
  17. from nitime.analysis import SpectralAnalyzer, FilterAnalyzer
  20. @njit
  21. def lorentzian_function(x, s0, f1):
  22. """Lorentzian power spectral density model (Eq. 2 in paper)."""
  23. return (s0 * f1**2) / (x**2 + f1**2)
  26. @njit
  27. def spline_multifractal(x, beta_low, beta_high, A, f2, smoothness):
  28. """Spline multifractal model with cubic-spline transition (Eq. 3-4 in paper)."""
  29. log_x = np.log(x)
  30. log_f2 = np.log(f2)
  31. w = np.where(log_x < log_f2 - smoothness, 0,
  32. np.where(log_x > log_f2 + smoothness, 1,
  33. 0.5 * (1 - np.cos(np.pi * (log_x - log_f2 + smoothness) / (2 * smoothness)))))
  34. return A * x**(beta_low * (1 - w) + beta_high * w)
  37. def _find_knee_frequencies(y, TR, seq_len, intermediate_vec,
  38. lz_p0, lz_bounds):
  39. """Identify f1 (ultralow/low) and f2 (low/high) knee frequencies.
  41. Step 1: Lorentzian fit on the full PSD → f1
  42. Step 2: Spline multifractal fit on PSD above f1 → f2
  44. Returns (f1, f2) in Hz.
  45. """
  46. # Average over ROIs to get a single representative power spectrum
  47. sample_whole = y.mean(axis=0)
  49. T = TimeSeries(sample_whole, sampling_interval=TR)
  50. S = SpectralAnalyzer(T)
  51. xdata = np.array(S.spectrum_fourier[0][1:])
  52. ydata = np.abs(S.spectrum_fourier[1][1:])
  54. # Step 1 — Lorentzian: find f1
  55. popt, _ = curve_fit(lorentzian_function, xdata, ydata,
  56. p0=lz_p0, bounds=lz_bounds, maxfev=50000)
  57. f1 = popt[-1]
  58. knee = round(f1 / (1 / (seq_len * TR)))
  59. if knee <= 0:
  60. knee = 1
  62. # Step 2 — Spline multifractal: find f2
  63. def least_squares(beta_low, beta_high, A, f2, smoothness):
  64. y_pred = spline_multifractal(xdata[knee:], beta_low, beta_high,
  65. A, f2, smoothness)
  66. return np.sum((y_pred - ydata[knee:])**2)
  68. m = Minuit(least_squares, beta_low=-1.2, beta_high=-0.5,
  69. A=10, f2=0.08, smoothness=0.25)
  70. m.limits['beta_low'] = (-5, -0.01)
  71. m.limits['beta_high'] = (-5, -0.01)
  72. m.limits['f2'] = (f1 + 0.0001, 0.15)
  73. m.limits['A'] = (1, 30)
  74. m.limits['smoothness'] = (0.001, 1)
  75. m.migrad()
  76. f2 = m.values['f2']
  78. return f1, f2
  81. def _filter_three_bands(y, TR, f1, f2, filtering_type):
  82. """Split timeseries y [ROI × time] into ultralow, low, and high bands.
  84. Uses f2 as the high-pass cutoff and f1 as the low-pass cutoff.
  85. FIR is used for ultralow/low; Boxcar for high (as in Table 7).
  86. """
  87. # High frequency (above f2)
  88. T1 = TimeSeries(y, sampling_interval=TR)
  89. FA1 = FilterAnalyzer(T1, lb=f2)
  90. if filtering_type == 'FIR':
  91. high = FA1.fir.data
  92. # Guard against zero-variance ROIs after FIR filtering
  93. std = np.std(high, axis=1, keepdims=True)
  94. high = (high - high.mean(axis=1, keepdims=True)) / (std + 1e-10)
  95. ultralow_low = FA1.data - FA1.fir.data
  96. else: # Boxcar
  97. high = stats.zscore(FA1.filtered_boxcar.data, axis=1)
  98. ultralow_low = FA1.data - FA1.filtered_boxcar.data
  100. # Low and ultralow frequencies (split at f1)
  101. T2 = TimeSeries(ultralow_low, sampling_interval=TR)
  102. FA2 = FilterAnalyzer(T2, lb=f1)
  103. if filtering_type == 'FIR':
  104. low = stats.zscore(FA2.fir.data, axis=1)
  105. ultralow = stats.zscore(FA2.data - FA2.fir.data, axis=1)
  106. else: # Boxcar
  107. low = stats.zscore(FA2.filtered_boxcar.data, axis=1)
  108. ultralow = stats.zscore(FA2.data - FA2.filtered_boxcar.data, axis=1)
  110. return ultralow, low, high
  113. class BaseDataset(Dataset):
  114. def __init__(self):
  115. super().__init__()
  117. def register_args(self, **kwargs):
  118. self.index_l = []
  119. self.target = kwargs.get('target')
  120. self.fine_tune_task = kwargs.get('fine_tune_task')
  121. self.dataset_name = kwargs.get('dataset_name')
  122. self.intermediate_vec = kwargs.get('intermediate_vec')
  123. self.filtering_type = kwargs.get('filtering_type')
  124. self.sequence_length = kwargs.get('sequence_length')
  125. self.pretrained_model_weights_path = kwargs.get('pretrained_model_weights_path')
  126. self.finetune = kwargs.get('finetune')
  127. self.transfer_learning = bool(self.pretrained_model_weights_path) or self.finetune
  128. self.finetune_test = kwargs.get('finetune_test')
  131. # ─── ABIDE ────────────────────────────────────────────────────────────────────
  133. class ABIDE_fMRI_timeseries(BaseDataset):
  134. """ABIDE-I/II dataset. Target: ASD (binary classification)."""
  136. # TR values per acquisition site (in seconds)
  137. _SITE_TR = {
  138. 'CALTECH': 2.0, 'CMU': 2.0, 'KKI': 2.5, 'LEUVEN': 1.66,
  139. 'MAX_MUN': 3.0, 'NYU': 2.0, 'OHSU': 2.5, 'OLIN': 1.5,
  140. 'PITT': 1.5, 'SBL': 2.2, 'SDSU': 2.0, 'STANFORD': 2.0,
  141. 'TRINITY': 2.0, 'UCLA': 3.0, 'UM': 2.0, 'USM': 2.0, 'YALE': 2.0,
  142. }
  144. def __init__(self, **kwargs):
  145. self.register_args(**kwargs)
  146. self.data_dir = kwargs.get('abide_path')
  147. self.meta_data = pd.read_csv(
  148. os.path.join(kwargs.get('base_path'), 'data', 'metadata',
  149. 'ABIDE1+2_meta.csv'))
  150. self.site_meta_data = pd.read_csv(
  151. os.path.join(kwargs.get('base_path'), 'data', 'metadata',
  152. 'ABIDE1_pheno_and_sites.csv'))
  154. # Build file list
  155. data_list = []
  156. for sub in os.listdir(self.data_dir):
  157. if self.intermediate_vec == 400:
  158. data_list.append(os.path.join(
  159. self.data_dir, sub,
  160. 'schaefer_400Parcels_17Networks_' + sub + '.npy'))
  161. elif sub.startswith('00'): # ABIDE-I subjects
  162. data_list.append(os.path.join(
  163. self.data_dir, sub, 'hcp_mmp1_360_' + sub + '.npy'))
  165. if self.intermediate_vec == 360:
  166. unified_name_list = [i[2:] for i in os.listdir(self.data_dir)
  167. if i.startswith('00')]
  168. else:
  169. unified_name_list = [i[2:] if i.startswith('00') else i
  170. for i in os.listdir(self.data_dir)]
  172. non_na = self.meta_data.dropna(axis=0)
  173. valid_sub = (set(str(i) for i in non_na['SUB_ID'])
  174. & set(unified_name_list))
  176. for filename in data_list:
  177. sub = filename.split('/')[-2]
  178. if sub.startswith('00'): # ABIDE-I
  179. subid = sub[2:]
  180. site_row = self.site_meta_data[
  181. self.site_meta_data['SUB_ID'] == int(subid)]['SITE_ID']
  182. site = site_row.values[0] if len(site_row) else 'ABIDE2'
  183. else:
  184. subid = sub
  185. site = 'ABIDE2'
  187. if subid in valid_sub:
  188. if self.target == 'sex':
  189. target_val = non_na.loc[
  190. non_na['SUB_ID'] == int(subid), 'SEX'].values[0]
  191. else: # ASD
  192. target_val = non_na.loc[
  193. non_na['SUB_ID'] == int(subid), 'DX_GROUP'].values[0]
  194. target = torch.tensor(1.0 if target_val == 2 else 0.0)
  195. self.index_l.append((subid, sub, filename, target, site))
  197. def __len__(self):
  198. return len(self.index_l)
  200. def __getitem__(self, index):
  201. subj, subj_name, path_to_fMRIs, target, site = self.index_l[index]
  203. y = np.load(path_to_fMRIs)[:self.sequence_length].T # [ROI, seq_len]
  205. # Padding to pretrained sequence length (464) for finetuning
  206. pad = 464 - self.sequence_length
  208. # Site-specific TR
  209. TR = next((v for k, v in self._SITE_TR.items() if k in site), 3.0)
  211. f1, f2 = _find_knee_frequencies(
  212. y, TR, self.sequence_length, self.intermediate_vec,
  213. lz_p0=[900, 0.05],
  214. lz_bounds=([0, 0.01], [1200, 0.1]))
  216. ultralow, low, high = _filter_three_bands(
  217. y, TR, f1, f2, self.filtering_type)
  219. # Always pad to match pretraining length (464)
  220. high = F.pad(torch.from_numpy(high),
  221. (pad // 2, pad // 2), 'constant', 0).T.float()
  222. low = F.pad(torch.from_numpy(low),
  223. (pad // 2, pad // 2), 'constant', 0).T.float()
  224. ultralow = F.pad(torch.from_numpy(ultralow),
  225. (pad // 2, pad // 2), 'constant', 0).T.float()
  227. return {
  228. 'fmri_highfreq_sequence': high,
  229. 'fmri_lowfreq_sequence': low,
  230. 'fmri_ultralowfreq_sequence': ultralow,
  231. 'subject': subj,
  232. 'subject_name': subj_name,
  233. self.target: target,
  234. }
  237. # ─── UKB ──────────────────────────────────────────────────────────────────────
  239. class UKB_fMRI_timeseries(BaseDataset):
  240. """UK Biobank dataset. Used for pretraining (target='reconstruction')
  241. and downstream tasks (sex, depression, fluid intelligence)."""
  243. TR = 0.735 # seconds
  245. def __init__(self, **kwargs):
  246. self.register_args(**kwargs)
  247. self.data_dir = kwargs.get('ukb_path')
  248. self.meta_data = pd.read_csv(
  249. os.path.join(kwargs.get('base_path'), 'data', 'metadata',
  250. 'UKB_phenotype_gps_fluidint.csv'))
  252. valid_sub = list(map(int, os.listdir(self.data_dir)))
  254. if self.target != 'reconstruction':
  255. non_na = self.meta_data[['eid', self.target]].dropna(axis=0)
  256. subjects = list(set(non_na['eid']) & set(valid_sub))
  257. else:
  258. subjects = valid_sub
  260. if self.fine_tune_task == 'regression':
  261. cont_mean = non_na[self.target].mean()
  262. cont_std = non_na[self.target].std()
  263. self.mean = cont_mean
  264. self.std = cont_std
  266. for i, subject in enumerate(subjects):
  267. if self.fine_tune_task == 'regression':
  268. target = torch.tensor(
  269. (self.meta_data.loc[self.meta_data['eid'] == subject,
  270. self.target].values[0]
  271. - cont_mean) / cont_std).float()
  272. elif self.fine_tune_task == 'binary_classification':
  273. target = torch.tensor(
  274. self.meta_data.loc[self.meta_data['eid'] == subject,
  275. self.target].values[0])
  276. else: # reconstruction
  277. target = torch.tensor(0)
  279. if self.intermediate_vec == 360:
  280. j = str(subject) + '_20227_2_0'
  281. k = str(subject) + '_20227_3_0'
  282. path_j = os.path.join(self.data_dir, j, 'hcp_mmp1_360_' + j + '.npy')
  283. path_k = os.path.join(self.data_dir, k, 'hcp_mmp1_360_' + k + '.npy')
  284. path_to_fMRIs = path_j if os.path.exists(path_j) else path_k
  285. elif self.intermediate_vec == 400:
  286. path_to_fMRIs = os.path.join(
  287. self.data_dir, str(subject),
  288. 'schaefer_400Parcels_17Networks_' + str(subject) + '.npy')
  290. self.index_l.append((i, subject, path_to_fMRIs, target))
  292. def __len__(self):
  293. return len(self.index_l)
  295. def __getitem__(self, index):
  296. subj, subj_name, path_to_fMRIs, target = self.index_l[index]
  298. # Skip first 20 dummy scans
  299. y = np.load(path_to_fMRIs)[20:20 + self.sequence_length].T
  301. f1, f2 = _find_knee_frequencies(
  302. y, self.TR, self.sequence_length, self.intermediate_vec,
  303. lz_p0=[900, 0.05],
  304. lz_bounds=([0, 0.01], [1200, 0.1]))
  306. ultralow, low, high = _filter_three_bands(
  307. y, self.TR, f1, f2, self.filtering_type)
  309. high = torch.from_numpy(high).T.float()
  310. low = torch.from_numpy(low).T.float()
  311. ultralow = torch.from_numpy(ultralow).T.float()
  313. return {
  314. 'fmri_highfreq_sequence': high,
  315. 'fmri_lowfreq_sequence': low,
  316. 'fmri_ultralowfreq_sequence': ultralow,
  317. 'subject': subj,
  318. 'subject_name': subj_name,
  319. self.target: target,
  320. }
  323. # ─── ABCD ─────────────────────────────────────────────────────────────────────
  325. class ABCD_fMRI_timeseries(BaseDataset):
  326. """Adolescent Brain Cognitive Development (ABCD) dataset.
  327. Targets: sex, ADHD_label, depression, fluid_intelligence, reconstruction."""
  329. TR = 0.8 # seconds
  331. def __init__(self, **kwargs):
  332. self.register_args(**kwargs)
  333. self.data_dir = kwargs.get('abcd_path')
  335. if self.target == 'depression':
  336. self.meta_data = pd.read_csv(
  337. os.path.join(kwargs.get('base_path'), 'data', 'metadata',
  338. 'ABCD_5_1_KSADS_raw_MDD_ANX_CorP_pp_pres_ALL.csv'))
  339. self.meta_data['subjectkey'] = [
  340. i.split('-')[1] for i in self.meta_data['subjectkey']]
  341. self.target = 'MDD_pp'
  342. else:
  343. self.meta_data = pd.read_csv(
  344. os.path.join(kwargs.get('base_path'), 'data', 'metadata',
  345. 'ABCD_matched.csv'))
  347. valid_sub = [i.split('-')[1] for i in os.listdir(self.data_dir)]
  349. if self.target != 'reconstruction':
  350. non_na = self.meta_data[['subjectkey', self.target]].dropna(axis=0)
  351. subjects = list(set(non_na['subjectkey']) & set(valid_sub))
  352. else:
  353. subjects = valid_sub
  355. if self.fine_tune_task == 'regression':
  356. cont_mean = non_na[self.target].mean()
  357. cont_std = non_na[self.target].std()
  358. self.mean = cont_mean
  359. self.std = cont_std
  361. for i, subject in enumerate(subjects):
  362. if self.intermediate_vec == 360:
  363. path_to_fMRIs = os.path.join(
  364. self.data_dir, 'sub-' + subject,
  365. 'hcp_mmp1_sub-' + subject + '.npy')
  366. elif self.intermediate_vec == 400:
  367. path_to_fMRIs = os.path.join(
  368. self.data_dir, 'sub-' + subject,
  369. 'schaefer_sub-' + subject + '.npy')
  371. if self.fine_tune_task == 'regression':
  372. target = torch.tensor(
  373. (self.meta_data.loc[
  374. self.meta_data['subjectkey'] == subject,
  375. self.target].values[0] - cont_mean) / cont_std).float()
  376. elif self.fine_tune_task == 'binary_classification':
  377. target = torch.tensor(
  378. self.meta_data.loc[
  379. self.meta_data['subjectkey'] == subject,
  380. self.target].values[0])
  381. else: # reconstruction
  382. target = torch.tensor(0)
  384. self.index_l.append((i, subject, path_to_fMRIs, target))
  386. def __len__(self):
  387. return len(self.index_l)
  389. def __getitem__(self, index):
  390. subj, subj_name, path_to_fMRIs, target = self.index_l[index]
  392. y = np.load(path_to_fMRIs)[:self.sequence_length].T # [ROI, seq_len]
  394. if self.transfer_learning or self.finetune_test:
  395. pad = 464 - self.sequence_length
  397. f1, f2 = _find_knee_frequencies(
  398. y, self.TR, self.sequence_length, self.intermediate_vec,
  399. lz_p0=[1, 0.05],
  400. lz_bounds=([0, 0.01], [15, 0.1]))
  402. ultralow, low, high = _filter_three_bands(
  403. y, self.TR, f1, f2, self.filtering_type)
  405. if self.transfer_learning or self.finetune_test:
  406. high = F.pad(torch.from_numpy(high),
  407. (pad // 2, pad // 2), 'constant', 0).T.float()
  408. low = F.pad(torch.from_numpy(low),
  409. (pad // 2, pad // 2), 'constant', 0).T.float()
  410. ultralow = F.pad(torch.from_numpy(ultralow),
  411. (pad // 2, pad // 2), 'constant', 0).T.float()
  412. else:
  413. high = torch.from_numpy(high).T.float()
  414. low = torch.from_numpy(low).T.float()
  415. ultralow = torch.from_numpy(ultralow).T.float()
  417. return {
  418. 'fmri_highfreq_sequence': high,
  419. 'fmri_lowfreq_sequence': low,
  420. 'fmri_ultralowfreq_sequence': ultralow,
  421. 'subject': subj,
  422. 'subject_name': subj_name,
  423. self.target: target,
  424. }

datasets.py at commit eed038c, under MIT · at the source

Overview

Authors: Sangyoon Bae1, Junbeom Kwon2, Shinjae Yoo3, Jiook Cha1,4,5
  1. Interdisciplinary Program in Artificial Intelligence, Seoul National University, Seoul, South Korea
  2. Department of Psychology, University of Texas at Austin, Austin, TX USA
  3. Computational Science Initiative, Brookhaven National Laboratory, Shirley, NY USA
  4. Department of Psychology, Seoul National University, Seoul, South Korea
  5. Department of Brain and Cognitive Sciences, Seoul National University, Seoul, South Korea
Institutions: Seoul National University (South Korea); The University of Texas at Austin (United States); Brookhaven National Laboratory (United States)
Journal: Communications biology, volume 9, issue 1, article 963
Dates: received 24 June 2025; accepted 26 March 2026; published online 8 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s42003-026-10011-7 · PMID 42103872 · PMCID PMC13369815 · OpenAlex W7160558314
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), depression (population), autism (population), ADHD (population), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Machine learning, Graphs, fMRI & imaging, Physiology & signal measures
Keywords: Learning algorithms, Computational models
MeSH: Attention Deficit Disorder with Hyperactivity*, Autism Spectrum Disorder*, Brain*, Learning*, Adolescent, Brain Mapping, Cognition, Humans, Magnetic Resonance Imaging, Major Depressive Disorder, Nerve Net (* major topic)
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Korea Health Industry Development Institute (KHIDI) (HR22C1605); Korea Basic Science Institute (KBSI) (RS-2024-00435727); National Research Foundation of Korea (NRF-2021S1A3A2A02090597, NRF-2021M3E5D2A01022515); U.S. Department of Energy (m4750-2024)
Citations: not cited yet (Europe PMC); 76 references in the paper

Abstract

Understanding how the brain’s nonlinear dynamics give rise to cognition remains a central challenge in neuroscience. Conventional neuroimaging methods assume linearity and stationarity, failing to capture frequency-specific neural computations. We introduce Multi-Band Brain Net (MBBN), a transformer-based framework that models frequency-specific spatiotemporal brain dynamics from fMRI. MBBN integrates biologically grounded frequency decomposition with multi-band self-attention, enabling discovery of frequency-dependent network interactions. Trained on 49,673 individuals across three large-scale cohorts (UK Biobank, Adolescent Brain Cognitive Development Study (ABCD), Autism Brain Imaging Data Exchange (ABIDE)), MBBN achieves state-of-the-art performance in predicting psychiatric and cognitive outcomes—including major depressive disorder (MDD), attention-deficit/hyperactivity disorder (ADHD), and autism spectrum disorder (ASD)—with AUROC improvements of up to 41.36% alongside strong cognitive intelligence prediction. Frequency-resolved analyses reveal disorder-specific signatures: in ADHD, high-frequency fronto-sensorimotor connectivity is attenuated and opercular somatosensory nodes emerge as dynamic hubs; in ASD, orbitofrontal-somatosensory circuits show focal high-frequency disruption alongside enhanced ultra-low-frequency coupling between the temporo-parietal junction and prefrontal cortex. By combining biologically informed frequency decomposition with transformer architecture, MBBN delivers interpretable biomarkers and improved prediction of psychiatric and cognitive traits.

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

Transconnectome/MBBN

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: eed038cfd162c02461098bae067d0b77de555bec, 9 April 2026
Languages: Python (15), Shell (2), Jupyter (1)
Size: 33 files, 18 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (environment.yaml, requirements.txt), documentation, 1 notebook
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (15 files), PyTorch (11 files), NiBabel (5 files), pandas (5 files), Nilearn (4 files), scikit-learn (3 files), SciPy (3 files), Matplotlib (2 files), Numba (2 files), scikit-image (2 files), Hugging Face Transformers (2 files), LMFIT (1 file), NetworkX (1 file), Pillow (1 file), PyWavelets (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
20 files
At the source: github.com/Transconnectome/MBBN

Code availability

The code is available on Github (https://github.com/Transconnectome/MBBN).

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

Tracing map

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

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 18 scripts, each with its path and the digest of its content;
  • 22 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 UKB, ABCD, and ABIDE datasets are publicly available to researchers.

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

Data Availability Statement

The MBBN codebase and environment setup instructions are available in the project repository. Pre-computed data splits are stored in the splits/directory. fMRI data were preprocessed and parcellated according to the HCP-MMP1 (360 parcels) or Schaefer (400 parcels) atlases before model input.

The UKB, ABCD, and ABIDE datasets are publicly available to researchers.

The code is available on Github (https://github.com/Transconnectome/MBBN).

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, 4 authors, 2 keywords, 11 MeSH terms, 4 funders, 60 references.

Cite

This paper

Bae, S., Kwon, J., Yoo, S., & Cha, J. (2026). Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures. Communications biology, 9(1), 963. https://doi.org/10.1038/s42003-026-10011-7

BibTeX

@article{bae2026learning,
author = {Bae, Sangyoon and Kwon, Junbeom and Yoo, Shinjae and Cha, Jiook},
title = {{Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures}},
journal = {Communications biology},
year = {2026},
month = may,
volume = {9},
number = {1},
pages = {963},
publisher = {Nature Publishing Group},
issn = {2399-3642},
doi = {10.1038/s42003-026-10011-7},
url = {https://doi.org/10.1038/s42003-026-10011-7},
pmid = {42103872},
pmcid = {PMC13369815}
}

RIS

TY - JOUR
AU - Bae, Sangyoon
AU - Kwon, Junbeom
AU - Yoo, Shinjae
AU - Cha, Jiook
TI - Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures
T2 - Communications biology
J2 - Commun Biol
PY - 2026
DA - 2026/05/08
VL - 9
IS - 1
SP - 963
SN - 2399-3642
PB - Nature Publishing Group
DO - 10.1038/s42003-026-10011-7
UR - https://doi.org/10.1038/s42003-026-10011-7
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s42003-026-10011-7",
"type": "article-journal",
"title": "Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures",
"container-title": "Communications biology",
"author": [
{
"family": "Bae",
"given": "Sangyoon"
},
{
"family": "Kwon",
"given": "Junbeom"
},
{
"family": "Yoo",
"given": "Shinjae"
},
{
"family": "Cha",
"given": "Jiook"
}
],
"container-title-short": "Commun Biol",
"volume": "9",
"issue": "1",
"page": "963",
"DOI": "10.1038/s42003-026-10011-7",
"PMID": "42103872",
"PMCID": "PMC13369815",
"ISSN": "2399-3642",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s42003-026-10011-7",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
8
]
]
}
}

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.1002/hbm.70469 [code]
VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.
Journal: Human brain mapping
In common: Hugging Face Transformers, Nilearn, NetworkX, 8 other tools, autism, 2 references
[2] doi:10.3390/brainsci16050455 [code]
Spec-RWKV: A Spectrum-Guided Multi-Scale Recurrent Modeling Framework for Multi-Center Resting-State fMRI-Assisted Diagnosis.
Journal: Brain sciences
In common: PyWavelets, Nilearn, PyTorch, 4 other tools, ADHD, autism, 4 references
[3] doi:10.1162/imag.a.1275 [code]
Glucose metabolism echoes long-range temporal correlations in the human brain.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, scikit-learn, pandas, 3 other tools, 7 references
[4] doi:10.1117/1.nph.13.2.025001 [code]
Surface-based image reconstruction optimization for high-density functional near-infrared spectroscopy.
Journal: Neurophotonics
In common: PyWavelets, Nilearn, NetworkX, 8 other tools
[5] doi:10.1038/s41467-026-76011-7 [code]
Human cortex organizes dynamic co-fluctuations along the sensorimotor-association axis.
Journal: Nature communications
In common: scikit-image, Pillow, NiBabel, 4 other tools, 5 references
[6] doi:10.1162/imag.a.1252 [code]
Does the brain's E:I balance really shape long-range temporal correlations? Lessons learned from 3T MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PyWavelets, NiBabel, scikit-learn, 4 other tools, 4 references
[7] 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: Numba, Nilearn, Pillow, 7 other tools, cognitive, 2 references
[8] doi:10.64898/2026.03.09.710558 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: bioRxiv (preprint)
In common: Numba, Nilearn, Pillow, 7 other tools, cognitive, 2 references
[9] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Hugging Face Transformers, Nilearn, scikit-image, 8 other tools, cognitive
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Hugging Face Transformers, Numba, NetworkX, 8 other tools

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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