OSCR

Brain functional network connectivity interpolation characterizes the neuropsychiatric continuum and heterogeneity.

Code ↔ Paper

10 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 10 matches
  1. [1] § Methods › Data › Datasets ↔ data/utils.py, lines 24–57 · score 0.94 · Negative Syndrome Scale, invalid diagnostic, verbal learning, cognitive scores, working memory, CMINDS
  2. [2] § Methods › Data › Datasets ↔ visualization/plot_cognitive_score.ipynb, lines 88–206 · score 0.82 · composite scores, verbal learning, cognitive scores, working memory, PANSS, vigilance
  3. [3] § Results › sFNC interpolation captures the psychosis continuum and heterogeneity ↔ data/utils.py, lines 24–57 · score 0.76 · verbal learning, FBIRN subjects, cognitive scores, working memory, CMINDS, PANSS
  4. [4] § Methods › Data › Datasets ↔ data/utils.py, lines 60–89 · score 0.74 · Autism Diagnostic Observation, ADOS scores, Schedule, age, ABIDE, ASD
  5. [5] § Results › sFNC interpolation captures the psychosis continuum and heterogeneity ↔ visualization/plot_cognitive_score.ipynb, lines 88–206 · score 0.73 · composite scores, verbal learning, cognitive scores, working memory, PANSS, gender
  6. [6] § Methods › Variational autoencoders ↔ interpolation/interp_dfnc_asd.ipynb, lines 328–410 · score 0.66 · learning rate scheduler, PyTorch, Adam, epochs, optimizer, loss
  7. [7] § Methods › Variational autoencoders ↔ interpolation/interp_dfnc_sz.ipynb, lines 291–373 · score 0.66 · learning rate scheduler, PyTorch, Adam, epochs, optimizer, loss
  8. [8] § Results › sFNC interpolation captures the psychosis continuum and heterogeneity ↔ visualization/plot_cognitive_score.ipynb, lines 217–226 · score 0.57 · cognitive scores, composite scores, S23, speed, diagnostic, sFNC
  9. [9] § Methods › Variational autoencoders ↔ models/ivae.py, lines 133–205 · score 0.57 · decoder parameterized, encoder parameterized, log
  10. [10] § Results › sFNC interpolation captures the psychosis continuum and heterogeneity ↔ visualization/plot_mse.ipynb, lines 49–78 · score 0.50 · squared errors, MSE, S13, sFNC, patients, FBIRN

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 · 306 lines · 12 KB · Apache-2.0 · 3 matches

  1. import glob
  2. import mat73
  3. import numpy as np
  4. import scipy.io as sio
  5. import scipy.stats as stats
  8. def to_one_hot(x, m=None):
  9. if type(x) is not list:
  10. x = [x]
  11. if m is None:
  12. ml = []
  13. for xi in x:
  14. ml += [xi.max() + 1]
  15. m = max(ml)
  16. dtp = x[0].dtype
  17. xoh = []
  18. for i, xi in enumerate(x):
  19. xoh += [np.zeros((xi.size, int(m)), dtype=dtp)]
  20. xoh[i][np.arange(xi.size), xi.astype(int)] = 1
  21. return xoh
  24. def load_sz_score(filename):
  25. """
  26. Load FBIRN subject measures
  28. :param filepath: filepath to the dataset
  29. :return valid_score: valid subject measures
  30. :return invalid_sub_ind: invalid subject indices
  31. """
  32. data_dict = mat73.loadmat(filename)
  33. keys = ['diagnosis(1:sz; 2:hc)','PANSS(positive)','PANSS(negative)',\
  34. 'SpeedOfProcessing','AttentionVigilance','WorkingMemory','VerbalLearning',\
  35. 'VisualLearning','ReasoningProblemSolving','CMINDS_composite', \
  36. 'age', 'gender(1:male; 2:female)', 'Site'] # PANSS: The Positive and Negative Syndrome Scale
  37. ind = [data_dict['FILE_ID'].index(i) for i in keys]
  38. score = data_dict['analysis_SCORE'][:,ind] # FBIRN:311x10
  40. n_sub = score.shape[0]
  41. for i in range(n_sub):
  42. if score[i,0]==2 and score[i,1]==-9999: #for positive PANSS, if CTR has -9999, assign minimal possible score 7
  43. score[i,1] = 7
  44. if score[i,0]==2 and score[i,2]==-9999: #for negative PANSS, if CTR has -9999, assign minimal possible score 7
  45. score[i,2] = 7
  47. # remove subjects with nan or -9999 entry
  48. invalid_score_ind = np.argwhere((np.isnan(score)) | (score==-9999))
  49. invalid_sub_ind = np.unique(invalid_score_ind[:,0])
  51. invalid_cognitive_score_ind = np.argwhere((np.isnan(score[:,3:])) | (score[:,3:]==-9999)) # remove subjects with cognitive score nan or -9999
  52. invalid_diagnosis_score_ind = np.argwhere((np.isnan(score[:,:3])) | (score[:,:3]==-9999)) # remove subjects with diagnosis score nan or SZ -9999
  53. invalid_score_ind = np.hstack([invalid_cognitive_score_ind[:,0], invalid_diagnosis_score_ind[:,0]])
  54. invalid_sub_ind = np.unique(invalid_score_ind)
  55. score_valid = np.delete(score, invalid_sub_ind, 0)
  57. return score_valid, invalid_sub_ind
  60. def load_asd_score(filename):
  61. """
  62. Load ABIDE subject measures
  64. :param filepath: filepath to the dataset
  65. :return valid_score: valid subject measures
  66. :return site_valid: valid site labels
  67. :return invalid_sub_ind: invalid subject indices
  68. """
  69. data_dict = mat73.loadmat(filename)
  70. keys = ['DX_GROUP', 'ADOS_TOTAL', 'AGE_AT_SCAN', 'SEX'] # DX: 1 ASD, 2 CTR; ADOS: Autism Diagnostic Observation Schedule
  71. ind = [data_dict['FILE_ID'].index(i) for i in keys]
  73. site_ind = data_dict['FILE_ID'].index('SITE_ID')
  74. score_str_list = data_dict['analysis_SCORE_str']
  75. site_list = [score_str[site_ind] for score_str in score_str_list]
  77. score = data_dict['analysis_SCORE'][:,ind] # ABIDE1:869
  79. # set CTR ADOS score to 0
  80. missing_ados_ind = np.where( (score[:,0]==2) & (np.isnan(score[:,1])) )[0]
  81. score[missing_ados_ind, 1] = 0
  83. invalid_score_ind = np.argwhere(np.isnan(score))
  84. invalid_sub_ind = np.unique(invalid_score_ind[:,0])
  86. score_valid = np.delete(score, invalid_sub_ind, 0)
  87. site_valid = np.delete(site_list, invalid_sub_ind)
  89. return score_valid, site_valid, invalid_sub_ind
  92. def load_sfnc(filename, nan_sub_ind=None):
  93. """
  94. Load sFNC data
  96. :param filepath: filepath to the dataset
  97. :param nan_sub_ind: invalid subject indices
  98. :return sfnc_triu: sFNC upper triangle data
  99. :return sfnc_raw: raw sFNC data
  100. """
  101. if 'ABIDE' in filename:
  102. data_dict = sio.loadmat(filename)
  103. else:
  104. data_dict = mat73.loadmat(filename)
  105. sfnc = data_dict['sFNC']
  106. sfnc_matrix_valid = np.delete(sfnc, nan_sub_ind, 0)
  108. # reshape sFNC
  109. sfnc_vector_valid = []
  110. for i in range(sfnc_matrix_valid.shape[0]):
  111. tmp = sfnc_matrix_valid[i]
  112. # only use the lower triangular part of the FNC (diagonal is all ones) and upper and lower triangular are mirrored
  113. tmp = tmp[np.triu_indices(53, 1)]
  114. sfnc_vector_valid.append(tmp)
  116. sfnc_vector_valid = np.array(sfnc_vector_valid)
  117. return sfnc_vector_valid, sfnc_matrix_valid
  120. def load_dfnc(filepath, nan_sub_ind=None, dataset='FBIRN'):
  121. """
  122. Load dFNC data
  124. :param filepath: filepath to the dataset
  125. :param nan_sub_ind: invalid subject indices
  126. :return dfnc_tensor_valid: dFNC data
  127. """
  128. filelist = glob.glob(filepath)
  129. filelist.sort()
  130. dfnc_list = []
  131. if dataset.lower() == 'fbirn':
  132. for f in filelist:
  133. data_dict = sio.loadmat(f)
  134. dfnc = data_dict['FNCdyn']
  135. dfnc_list.append(dfnc)
  136. elif dataset.lower() == 'abide':
  137. for f in filelist:
  138. data_dict = mat73.loadmat(f)
  139. dfnc = data_dict['FNCdyn']
  140. dfnc_list.append(dfnc)
  141. dfnc_tensor = np.array(dfnc_list)
  142. dfnc_tensor_valid = np.delete(dfnc_tensor, nan_sub_ind, 0)
  143. return dfnc_tensor_valid
  146. def vector2matrix(vector):
  147. """
  148. Convert a 1378x1 FNC vector to a 53x53 FNC matrix
  150. :param vector: 1378x1 FNC vector
  151. :return matrix: 53x53 FNC matrix
  152. """
  153. matrix = np.zeros((53, 53))
  154. matrix[np.triu_indices(53, 1)] = vector
  155. matrix[np.tril_indices(53, -1)] = matrix.T[np.tril_indices(53, -1)]
  156. matrix[np.diag_indices(53)] = 1
  157. return matrix
  160. def compute_sub_per_state(kmeans_label, n_pt, n_state=5, n_window=137):
  161. """
  162. Compute the number of subjects per state
  164. :param kmeans_label: kmeans label
  165. :param n_pt: number of patients
  166. :param n_state: number of states
  167. :param n_window: number of windows
  168. :return num_sub_per_state: number of subjects per state
  169. :return ratio_sub_per_state: ratio of subjects per state
  170. """
  171. num_sub_per_state = np.zeros((2,n_state)) # 1st row: patient; 2nd row: control
  172. for i, j in enumerate(range(0,len(kmeans_label),n_window)):
  173. if i < n_pt:
  174. for k in range(5):
  175. if np.any(kmeans_label[j:j+n_window] == k):
  176. num_sub_per_state[0,k] += 1
  177. else:
  178. for k in range(5):
  179. if np.any(kmeans_label[j:j+n_window] == k):
  180. num_sub_per_state[1,k] += 1
  181. ratio_sub_per_state = num_sub_per_state / np.sum(num_sub_per_state, axis=0)
  182. return num_sub_per_state, ratio_sub_per_state
  185. def compute_fnc_per_state(kmeans_label, n_pt, n_state=5, n_window=137):
  186. """
  187. Compute the number of FNCs per state
  189. :param kmeans_label: kmeans label
  190. :param n_pt: number of patients
  191. :param n_state: number of states
  192. :param n_window: number of windows
  193. :return num_fnc_per_state: number of FNCs per state
  194. :return ratio_fnc_per_state: ratio of FNCs per state
  195. """
  196. num_fnc_per_state = np.zeros((2,n_state)) # 1st row: patient; 2nd row: control
  197. for i in range(len(kmeans_label)):
  198. if i < n_pt * n_window:
  199. num_fnc_per_state[0,kmeans_label[i]] += 1
  200. else:
  201. num_fnc_per_state[1,kmeans_label[i]] += 1
  202. ratio_fnc_per_state = num_fnc_per_state / np.sum(num_fnc_per_state, axis=0)
  203. return num_fnc_per_state, ratio_fnc_per_state
  206. def compute_dwell_state(kmeans_label_2d, sorted_state_ind, n_pt, n_hc, n_state=5):
  207. """
  208. Compute the occupancy rate per state
  210. :param kmeans_label_2d: kmeans label
  211. :param sorted_state_ind: sorted state indices
  212. :param n_pt: number of patients
  213. :param n_hc: number of controls
  214. :param n_state: number of states
  215. :return dwell_state_mean_pt: mean of occupancy rate for patients
  216. :return dwell_state_ste_pt: standard error of occupancy rate for patients
  217. :return dwell_state_mean_hc: mean of occupancy rate for controls
  218. :return dwell_state_ste_hc: standard error of occupancy rate for controls
  219. :return dwell_state_pvalue: p-value of t-test between patients and controls
  220. """
  221. n = kmeans_label_2d.shape[0]
  222. dwell_state = np.zeros((n, n_state))
  223. for i in range(n):
  224. for k in range(n_state):
  225. dwell_state[i,k]=len(np.where(kmeans_label_2d[i,:]==k)[0])
  226. dwell_state_sorted = dwell_state[:, sorted_state_ind]
  227. dwell_state_mean_pt = np.mean(dwell_state_sorted[:n_pt, :], axis=0)
  228. dwell_state_std_pt = np.std(dwell_state_sorted[:n_pt, :], axis=0)
  229. dwell_state_ste_pt = dwell_state_std_pt/np.sqrt(n_pt)
  230. dwell_state_mean_hc = np.mean(dwell_state_sorted[n_pt:, :], axis=0)
  231. dwell_state_std_hc = np.std(dwell_state_sorted[n_pt:, :], axis=0)
  232. dwell_state_ste_hc = dwell_state_std_hc/np.sqrt(n_hc)
  233. dwell_state_pvalue = np.zeros(n_state)
  234. for i in range(n_state):
  235. dwell_state_pt = dwell_state_sorted[:n_pt, i]
  236. dwell_state_hc = dwell_state_sorted[n_pt:, i]
  237. _, dwell_state_pvalue[i] = stats.ttest_ind(a=dwell_state_pt, b=dwell_state_hc)
  238. return dwell_state_mean_pt, dwell_state_ste_pt, dwell_state_mean_hc, dwell_state_ste_hc, dwell_state_pvalue
  241. def compute_transition_matrix(kmeans_label_2d, sorted_state_ind, n_pt, n_state=5, n_window=137):
  242. """
  243. Compute the transition matrix
  245. :param kmeans_label_2d: kmeans label
  246. :param sorted_state_ind: sorted state indices
  247. :param n_pt: number of patients
  248. :param n_state: number of states
  249. :param n_window: number of windows
  250. :return transition_matrix_pt: transition matrix for patients
  251. :return transition_matrix_hc: transition matrix for controls
  252. :return transition_matrix: transition matrix
  253. :return transition_matrix_pvalue: p-value of t-test between patients and controls
  254. """
  255. n = kmeans_label_2d.shape[0]
  256. mapping = {}
  257. for k in range(n_state):
  258. mapping[k] = np.where(sorted_state_ind==k)[0][0]
  259. transition_matrix = np.zeros((n, n_state, n_state))
  260. for i in range(n):
  261. for t in range(n_window-1):
  262. state_t1 = mapping[kmeans_label_2d[i,t]]
  263. state_t2 = mapping[kmeans_label_2d[i,t+1]]
  264. if state_t1 != state_t2:
  265. transition_matrix[i, state_t1, state_t2] += 1
  266. transition_matrix_pt = np.mean(transition_matrix[:n_pt,:,:], axis=0)/n_window
  267. transition_matrix_hc = np.mean(transition_matrix[n_pt:,:,:], axis=0)/n_window
  269. transition_matrix_pvalue = np.zeros((n_state, n_state))
  270. for i in range(n_state):
  271. for j in range(n_state):
  272. _, transition_matrix_pvalue[i,j] = stats.ttest_ind(a=transition_matrix[:n_pt,i,j], b=transition_matrix[n_pt:,i,j])
  274. return transition_matrix_pt, transition_matrix_hc, transition_matrix, transition_matrix_pvalue
  277. def find_unique_ind(sorted_state_ind, corr, ratio_fnc_per_state, n_state=5):
  278. """
  279. Find unique sorted state indices
  281. :param sorted_state_ind: sorted state indices
  282. :param corr: correlation matrix
  283. :param ratio_fnc_per_state: ratio of FNCs per state
  284. :param n_state: number of states
  285. :return unique_sorted_state_ind: unique sorted state indices
  286. """
  287. duplicated_dict = {}
  288. unique_ind = np.unique(sorted_state_ind)
  289. if len(sorted_state_ind)==len(unique_ind)+1:
  290. unique_sorted_state_ind = np.copy(sorted_state_ind)
  291. for i in unique_ind:
  292. ind = np.where(sorted_state_ind == i)[0]
  293. if len(ind) > 1:
  294. duplicated_dict[i] = ind
  295. missing_ind = list(set(np.arange(n_state)) - set(sorted_state_ind))
  296. duplicated_ind = list(duplicated_dict.keys())
  297. for i in duplicated_ind:
  298. duplicated_ind_loc = duplicated_dict[i]
  299. for j in missing_ind:
  300. ind = np.argmax(corr[0, duplicated_ind_loc, j])
  301. unique_sorted_state_ind[duplicated_ind_loc[ind]] = j
  302. elif len(sorted_state_ind)==len(unique_ind):
  303. unique_sorted_state_ind = sorted_state_ind
  304. else:
  305. unique_sorted_state_ind = np.argsort(ratio_fnc_per_state[1,:])
  306. return unique_sorted_state_ind

utils.py at commit 573f1e0, under Apache-2.0 · at the source

Overview

Authors: Xinhui Li1,2, Eloy Geenjaar1,2, Zening Fu1, Godfrey D. Pearlson3, Vince D. Calhoun1,2
ORCID iDs: Xinhui Li, Eloy Geenjaar, Zening Fu, Godfrey D. Pearlson, Vince D. Calhoun
  1. Tri-institutional Center for Translational Research in Neuroimaging and Data Science, Georgia State University, Georgia Institute of Technology, Emory University, Atlanta, GA, United States
  2. School of Electrical and Computer Engineering, Georgia Institute of Technology, Atlanta, GA, United States
  3. Department of Psychiatry, School of Medicine, Yale University, New Haven, CT, United States
Institutions: Georgia Institute of Technology (United States); Emory University (United States); Georgia State University (United States); Center for Translational Research in Neuroimaging and Data Science (United States); Yale University (United States)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1220
Dates: received 6 November 2024; accepted 19 March 2026; published online 27 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1220 · PMID 42065117 · PMCID PMC13125074 · OpenAlex W4404430660
Open access: diamond, a free copy (OpenAlex)
Preprint: doi:10.1101/2024.11.13.623318
Status: code verified
Categories: human (organism), autism (population), schizophrenia / psychosis (population), systems (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Evoked potentials, fMRI & imaging
Keywords: functional network connectivity, psychosis continuum, psychosis heterogeneity, variational autoencoder, schizophrenia, autism spectrum disorder
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Foundation for the National Institutes of Health (R01MH118695, R01EB006841); National Science Foundation (2112455); Georgia Tech/Emory NIH/NIBIB Training Program in Computational Neural-engineering (T32EB025816)
Citations: cited by 1 paper (Europe PMC); 107 references in the paper

Abstract

Psychiatric and neurodevelopmental disorders such as schizophrenia (SZ) and autism spectrum disorder (ASD) are challenging to characterize in part due to their heterogeneous presentation in individuals, with symptoms now believed to exist on a continuum. Conventional diagnostic and neuroimaging analytical approaches rely on subjective assessment or group differences, but typically ignore progression between groups or heterogeneity within a group. To estimate the neuropsychiatric continuum and heterogeneity, we proposed a functional network connectivity (FNC) interpolation framework based on a variational autoencoder (VAE) using static FNC (sFNC) and dynamic FNC (dFNC) data from controls and patients with SZ or ASD. We demonstrated that VAEs significantly outperformed a linear baseline and a semi-supervised counterpart. For both sFNC and dFNC interpolation, the generated results effectively captured representative and generalizable properties in the original data. The interpolated continua from controls to patients in both SZ and ASD revealed group-wise gradients characterized by reduced positive correlations within the auditory, sensorimotor, and visual networks, as well as between the subcortical and cerebellar domains. In contrast, anti-correlations weakened between the subcortical domain and the sensory domains, and between the cerebellar domain and the sensory domains. Finally, we showed examples of how to generate continuous FNC data following group- or state-based trajectories in the VAE latent space. The proposed framework offers added advantages over traditional methods, including data-driven discovery of hidden relationships, visualization of individual differences, imputation of missing values along a continuous spectrum, and estimation of the stage where an individual falls within the continuum.

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

XinhuiLi/interpolation

License: Apache-2.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 573f1e0714e70a23861b290b550bfce5f6e905f1, 8 April 2026
Languages: Jupyter (19), Python (7)
Size: 32 files, 26 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file, environment (requirements.txt), 19 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (22 files), Matplotlib (18 files), seaborn (12 files), PyTorch (11 files), SciPy (10 files), pandas (5 files), scikit-learn (3 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
26 files
At the source: github.com/XinhuiLi/interpolation.git

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;
  • 24 scripts, each with its path and the digest of its content;
  • 10 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 and Code Availability

The FBIRN dataset can be accessed at https://www.nitrc.org/projects/fbirn/. The ABIDE I dataset can be accessed at https://fcon_1000.projects.nitrc.org/indi/abide/. The NeuroMark network templates are available at http://trendscenter.org/software. The analysis and visualization code is publicly available at https://github.com/XinhuiLi/interpolation.git.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 5 authors, 6 keywords, 3 funders, 94 references.

Cite

This paper

Li, X., Geenjaar, E., Fu, Z., Pearlson, G. D., & Calhoun, V. D. (2026). Brain functional network connectivity interpolation characterizes the neuropsychiatric continuum and heterogeneity. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1220. https://doi.org/10.1162/imag.a.1220

BibTeX

@article{li2026brain,
author = {Li, Xinhui and Geenjaar, Eloy and Fu, Zening and Pearlson, Godfrey D. and Calhoun, Vince D.},
title = {{Brain functional network connectivity interpolation characterizes the neuropsychiatric continuum and heterogeneity}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = apr,
volume = {4},
pages = {IMAG.a.1220},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1220},
url = {https://doi.org/10.1162/imag.a.1220},
pmid = {42065117},
pmcid = {PMC13125074}
}

RIS

TY - JOUR
AU - Li, Xinhui
AU - Geenjaar, Eloy
AU - Fu, Zening
AU - Pearlson, Godfrey D.
AU - Calhoun, Vince D.
TI - Brain functional network connectivity interpolation characterizes the neuropsychiatric continuum and heterogeneity
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/04/27
VL - 4
SP - IMAG.a.1220
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1220
UR - https://doi.org/10.1162/imag.a.1220
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1220",
"type": "article-journal",
"title": "Brain functional network connectivity interpolation characterizes the neuropsychiatric continuum and heterogeneity",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Li",
"given": "Xinhui"
},
{
"family": "Geenjaar",
"given": "Eloy"
},
{
"family": "Fu",
"given": "Zening"
},
{
"family": "Pearlson",
"given": "Godfrey D."
},
{
"family": "Calhoun",
"given": "Vince D."
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1220",
"DOI": "10.1162/imag.a.1220",
"PMID": "42065117",
"PMCID": "PMC13125074",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1220",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
27
]
]
}
}

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.1266 [code]
Multimodal subspace independent vector analysis effectively captures latent relationships between brain structure and function.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: seaborn, scikit-learn, pandas, 3 other tools, schizophrenia / psychosis, 2 references, 2 authors
[2] doi:10.1038/s41398-026-04278-x [code]
Aberrant recovery of timescale-aligned amplitude balance links to symptoms and cognition in schizophrenia.
Journal: Translational psychiatry
In common: schizophrenia / psychosis, 6 references, author Vince Calhoun
[3] doi:10.1038/s41467-026-75585-6 [code]
Brain network dynamics reflect psychiatric illness status and transdiagnostic symptom profiles across health and disease.
Journal: Nature communications
In common: seaborn, scikit-learn, pandas, 3 other tools, schizophrenia / psychosis, 6 references
[4] doi:10.64898/2026.08.13.26360304 [code]
Lifespan brain structural variation reveals shared organization across mental health conditions
Journal: medRxiv (preprint)
In common: seaborn, scikit-learn, pandas, 3 other tools, 1 reference, author Vince Calhoun
[5] doi:10.1186/s40708-026-00312-2 [code]
Synergistic and redundant information dynamics exhibit dissociable alterations across schizophrenia and neurodevelopmental conditions.
Journal: Brain informatics
In common: seaborn, scikit-learn, pandas, 2 other tools, schizophrenia / psychosis, autism, 3 references
[6] doi:10.1038/s42003-026-10094-2 [code]
E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD.
Journal: Communications biology
In common: PyTorch, seaborn, scikit-learn, 4 other tools, autism, 2 references
[7] doi:10.1002/hbm.70496 [code]
Transdiagnostic Profiles of BOLD Signal Variability in Autism and Schizophrenia Spectrum Disorders: Associations With Cognition and Functioning.
Journal: Human brain mapping
In common: seaborn, scikit-learn, pandas, 3 other tools, schizophrenia / psychosis, autism, 2 references
[8] doi:10.1002/hbm.70599 [code]
Group Joint ICA (gjICA): A Method for Multimodal Fusion of Concurrent EEG and fMRI Data.
Journal: Human brain mapping
In common: NumPy, 3 references, author Vince Calhoun
[9] doi:10.7554/elife.108109 [code]
Multimodal MRI marker of cognition explains the association between cognition and mental health in the UK Biobank.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, 3 references
[10] doi:10.1016/j.bpsgos.2026.100787 [code]
Dynamic Functional Synchronization Profiles in Autism Differ by Spatial Scale and Along Hierarchical Cortical Gradients.
Journal: Biological psychiatry global open science
In common: pandas, SciPy, Matplotlib, 1 other tool, autism, systems, 3 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.