OSCR

Pursuit of biomarkers of brain diseases: beyond cohort comparisons.

Code ↔ Paper

2 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 2 matches
  1. [1] § The case of brain activity-based biomarkers › Brain Swap ↔ AI_model.ipynb, lines 1–114 · score 0.56 · readout layer, RNN2, trained, RNN1, loss, RNNs
  2. [2] § The case of brain activity-based biomarkers › Brain Swap ↔ AI_model.ipynb, lines 1–114 · score 0.52 · hidden state, Adam, RNN2, layer, RNN1, loss

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

Jupyter notebook · 299 lines · 9.8 KB · GPL-3.0 · 2 matches

  1. # %%
  2. import torch
  3. import torch.nn as nn
  4. import torch.optim as optim
  5. import numpy as np
  6. import matplotlib.pyplot as plt
  8. # Set random seeds for reproducibility
  9. seed_num = 42
  10. torch.manual_seed(seed_num)
  11. np.random.seed(seed_num)
  13. # Parameters
  14. input_size = 10
  15. hidden_size = 50
  16. output_size = 1
  17. seq_length = 20
  18. batch_size = 32
  19. n_epochs = 100
  20. learning_rate = 0.01
  22. # Generate synthetic data
  23. def generate_data(batch_size, seq_length, input_size):
  24. X = torch.randn(batch_size, seq_length, input_size)
  25. # Simple task: predict the sum of the last 5 inputs
  26. y = torch.sum(X[:, -5:, :], dim=(1, 2)).unsqueeze(1)
  27. return X, y
  29. # Define the RNN model
  30. class RNNModel(nn.Module):
  31. def __init__(self, input_size, hidden_size, output_size):
  32. super(RNNModel, self).__init__()
  33. self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
  34. self.readout = nn.Linear(hidden_size, output_size)
  36. def forward(self, x):
  37. rnn_out, _ = self.rnn(x)
  38. # Take the last hidden state
  39. last_hidden = rnn_out[:, -1, :]
  40. output = self.readout(last_hidden)
  41. return output
  43. # Create two identical RNN models
  44. rnn1 = RNNModel(input_size, hidden_size, output_size)
  45. rnn2 = RNNModel(input_size, hidden_size, output_size)
  47. # Make rnn2's RNN identical to rnn1's RNN initially
  48. rnn2.rnn.load_state_dict(rnn1.rnn.state_dict())
  49. #rnn2.bias.load_state_dict(rnn1.bias.state_dict())
  51. # Verify they have the same parameters initially
  52. print("Initial parameter comparison:")
  53. for (name1, param1), (name2, param2) in zip(rnn1.named_parameters(), rnn2.named_parameters()):
  54. print(f"{name1} and {name2} equal: {torch.allclose(param1, param2)}")
  56. # Training setup
  57. criterion = nn.MSELoss()
  58. optimizer1 = optim.Adam(rnn1.parameters(), lr=learning_rate)
  59. optimizer2 = optim.Adam(rnn2.parameters(), lr=learning_rate)
  61. # Training loop
  62. for epoch in range(n_epochs):
  63. X, y = generate_data(batch_size, seq_length, input_size)
  65. # Train RNN1
  66. optimizer1.zero_grad()
  67. output1 = rnn1(X)
  68. loss1 = criterion(output1, y)
  69. loss1.backward()
  70. optimizer1.step()
  72. # Train RNN2
  73. optimizer2.zero_grad()
  74. output2 = rnn2(X)
  75. loss2 = criterion(output2, y)
  76. loss2.backward()
  77. optimizer2.step()
  79. if epoch % 10 == 0:
  80. print(f"Epoch {epoch}, Loss1: {loss1.item():.4f}, Loss2: {loss2.item():.4f}")
  82. # After training, compare the readout layers
  83. print("\nAfter training parameter comparison:")
  84. for (name1, param1), (name2, param2) in zip(rnn1.named_parameters(), rnn2.named_parameters()):
  85. print(f"{name1} and {name2} equal: {torch.allclose(param1, param2, atol=1e-4)}")
  87. # Test the models
  88. X_test, y_test = generate_data(batch_size, seq_length, input_size)
  89. with torch.no_grad():
  90. output1 = rnn1(X_test)
  91. output2 = rnn2(X_test)
  92. print(f"\nTest MSE RNN1: {criterion(output1, y_test).item():.4f}")
  93. print(f"Test MSE RNN2: {criterion(output2, y_test).item():.4f}")
  95. # Now drive the second readout with the first RNN's activity
  96. with torch.no_grad():
  97. rnn1_activity, _ = rnn1.rnn(X_test)
  98. rnn1_last_hidden = rnn1_activity[:, -1, :]
  99. output2_driven = rnn2.readout(rnn1_last_hidden)
  101. print(f"\nTest MSE when driving rnn2's readout with rnn1's activity: {criterion(output2_driven, y_test).item():.4f}")
  103. # Plot results
  104. plt.figure(figsize=(6, 3))
  105. plt.plot(y_test.numpy(), label='True')
  106. plt.plot(output1.numpy(), 'o', label='Model 1')
  107. plt.plot(output2.numpy(), 'o', label='Model 2')
  108. plt.plot(output2_driven.numpy(), 'x', label='Model 3')
  109. plt.legend(ncol=4,loc='upper left')
  110. plt.ylim((-15,24))
  111. #plt.title("Comparison of Outputs")
  112. plt.xlabel("Input ID")
  113. plt.ylabel("Output")
  114. plt.show()
  116. # %%
  117. import torch
  118. import torch.nn as nn
  119. import torch.optim as optim
  120. import numpy as np
  121. import matplotlib.pyplot as plt
  123. # Set random seeds for reproducibility
  124. seed_num = 0
  125. torch.manual_seed(seed_num)
  126. np.random.seed(seed_num)
  128. # Parameters
  129. input_size = 3 # Reduced for easier visualization
  130. seq_length = 20 # Reduced for easier visualization
  131. batch_size = 32
  132. n_epochs = 100
  133. learning_rate = 0.01
  135. # Generate synthetic data
  136. def generate_data(batch_size, seq_length, input_size):
  137. X = torch.randn(batch_size, seq_length, input_size)
  138. # Simple task: predict the sum of the last 5 inputs
  139. y = torch.sum(X[:, -5:, :], dim=(1, 2)).unsqueeze(1)
  140. return X, y
  142. # 1. Let's generate some sample data just for visualization
  143. X_vis, y_vis = generate_data(batch_size=3, seq_length=seq_length, input_size=input_size)
  145. # 2. Create a plot
  146. fig, axes = plt.subplots(3, 1, figsize=(3, 6))
  148. # Color map for the input features
  149. colors = ['black', 'black', 'black']
  150. matplot_colors = ["C{}".format(i) for i in range(20)]
  152. for i in range(3):
  153. ax = axes[i]
  154. # Plot each feature of the i-th sequence in the batch
  155. for feat in range(input_size):
  156. ax.plot(X_vis[i, :, feat].numpy(),
  157. color=colors[i],
  158. linestyle='-',
  159. marker='o',
  160. markersize=4,
  161. label=f'Feature {feat+1}' if i == 0 else ""
  162. )
  164. # Highlight the last 5 timesteps, which are used for the target sum
  165. ax.axvspan(seq_length-5, seq_length-1, alpha=0.3, label='Used for Target' if i == 0 else "")
  167. # Add the target value as text on the plot
  168. ax.text(0.40, 0.85, f'Output {i*32} = {y_vis[i].item():.2f}', transform=ax.transAxes,
  169. bbox=dict(boxstyle='round', facecolor=matplot_colors[0], alpha=0.3))
  171. ax.set_xlabel('Timestep')
  172. ax.set_title(f'Input {i*32}')
  173. ax.grid(True, linestyle='--', alpha=0.6)
  174. ax.set_xticks(np.arange(0, seq_length, 2))
  175. ax.set_xlim(0, 19)
  177. plt.tight_layout(rect=[0, 0.05, 1, 0.95]) # Adjust layout to make room for suptitle and legend
  178. plt.show()
  180. # %%
  181. import numpy as np
  182. import matplotlib.pyplot as plt
  183. from scipy.stats import multivariate_normal
  184. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  186. def create_rotated_covariance(major_var, minor_var, angle_deg):
  187. """
  188. Create a covariance matrix with specified rotation and axis variances.
  190. Parameters:
  191. major_var: variance along the major axis (long direction)
  192. minor_var: variance along the minor axis (short direction)
  193. angle_deg: rotation angle in degrees (0° = aligned with x-axis)
  194. """
  195. # Convert angle to radians
  196. angle_rad = np.deg2rad(angle_deg)
  198. # Create rotation matrix
  199. cos_angle = np.cos(angle_rad)
  200. sin_angle = np.sin(angle_rad)
  201. R = np.array([[cos_angle, -sin_angle],
  202. [sin_angle, cos_angle]])
  204. # Create eigenvalue matrix (diagonal)
  205. Lambda = np.array([[major_var, 0],
  206. [0, minor_var]])
  208. # Compute covariance matrix: Σ = R Λ Rᵀ
  209. covariance = R @ Lambda @ R.T
  211. return covariance
  213. # Set parameters
  214. angle = -45 # Keep rotation constant at 45°
  215. major_var_1, minor_var_1 = 3.0, 0.1 # First Gaussian: long and thin
  216. major_var_2, minor_var_2 = 2., 0.2 # Second Gaussian: also long and thin, but different
  218. # Create covariance matrices with same rotation but different shapes
  219. cov1 = create_rotated_covariance(major_var_1, minor_var_1, angle)
  220. cov2 = create_rotated_covariance(major_var_2, minor_var_2, angle)
  222. # Set random seed for reproducibility
  223. np.random.seed(42)
  225. # Create the figure with subplots
  226. plt.figure(figsize=(6, 5))
  228. # Generate data
  229. n_samples = 1000
  231. # Create two correlated 2D distributions
  232. mean1 = [1.2, 1]
  233. #cov1 = [[2, -1.6], [-0.4, .5]] # Positive correlation
  235. mean2 = [2, 2]
  236. #cov2 = [[1, -0.8], [-0.8, 1]] # Negative correlation
  238. # Generate samples
  239. samples1 = np.random.multivariate_normal(mean1, cov1, n_samples)
  240. samples2 = np.random.multivariate_normal(mean2, cov2, n_samples)
  242. # Prepare data for LDA
  243. X = np.vstack((samples1, samples2)) # Combine all features
  244. y = np.hstack((np.zeros(n_samples), np.ones(n_samples))) # Create labels: Class1=0, Class2=1
  246. # Fit Linear Discriminant Analysis (LDA)
  247. lda = LinearDiscriminantAnalysis()
  248. lda.fit(X, y)
  250. # Main 2D scatter plot
  251. ax_scatter = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
  252. ax_scatter.scatter(samples1[:, 0], samples1[:, 1], alpha=0.6, label='Group 1', s=10)
  253. ax_scatter.scatter(samples2[:, 0], samples2[:, 1], alpha=0.6, label='Group 2', s=10)
  254. ax_scatter.set_xlabel('Feature 1')
  255. ax_scatter.set_ylabel('Feature 2')
  256. #ax_scatter.set_title('2D View: Easy Separation')
  257. ax_scatter.legend()
  258. ax_scatter.grid(True, alpha=0.1)
  260. # --- Plot the LDA separatrix ---
  261. # Create a mesh grid covering the plot area
  262. x_min, x_max = ax_scatter.get_xlim()
  263. y_min, y_max = ax_scatter.get_ylim()
  264. xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
  265. np.linspace(y_min, y_max, 100))
  267. # Predict class probabilities for each grid point
  268. Z = lda.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
  269. Z = Z.reshape(xx.shape)
  271. # Plot the decision boundary (separatrix) at P(class=1) = 0.5
  272. contour = ax_scatter.contour(xx, yy, Z, levels=[0.5], colors='red', linewidths=3, linestyles='dashed')
  273. ax_scatter.clabel(contour, inline=True, fontsize=0)
  274. #, fmt='P(Class2)=0.5'
  276. # X marginal (top)
  277. ax_x_marginal = plt.subplot2grid((3, 3), (0, 0), colspan=2)
  278. ax_x_marginal.hist(samples1[:, 0], bins=30, alpha=0.5, density=True, label='Class 1')
  279. ax_x_marginal.hist(samples2[:, 0], bins=30, alpha=0.5, density=True, label='Class 2')
  280. ax_x_marginal.set_title('Feature 1')
  281. ax_x_marginal.set_ylabel('Density')
  282. #ax_x_marginal.legend()
  283. #ax_x_marginal.grid(True, alpha=0.3)
  285. # Y marginal (right)
  286. ax_y_marginal = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
  287. ax_y_marginal.hist(samples1[:, 1], bins=30, orientation='horizontal', alpha=0.5, density=True, label='Class 1')
  288. ax_y_marginal.hist(samples2[:, 1], bins=30, orientation='horizontal', alpha=0.5, density=True, label='Class 2')
  289. ax_y_marginal.set_title('Feature 2')
  290. ax_y_marginal.set_xlabel('Density')
  291. #ax_y_marginal.legend()
  292. #ax_y_marginal.grid(True, alpha=0.3)
  294. # Add some empty space for better layout
  295. #ax_empty = plt.subplot2grid((4, 4), (0, 2), rowspan=1)
  296. #ax_empty.axis('off')
  298. plt.tight_layout()
  299. plt.show()

AI_model.ipynb at commit d159a15, under GPL-3.0 · at the source

Overview

Authors: Pascal Helson1,2,3, Arvind Kumar1,2
  1. School of Electrical Engineering and Computer Science and Digital Futures, KTH Royal Institute of Technology Stockholm,Stockholm, Sweden
  2. Science For Life Laboratory,Solna, Sweden
  3. UMR 5293, IMN, University of Bordeaux, CNRS,Bordeaux, France
Institutions: Digital Futures (Sweden); Science for Life Laboratory (Sweden); Université de Bordeaux (France)
Journal: NPJ digital medicine, volume 9, issue 1, article 361
Dates: received 11 September 2025; accepted 29 March 2026; published online 10 April 2026
Type: Review · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41746-026-02614-5 · PMID 41963496 · PMCID PMC13156286 · OpenAlex W4414597599
Open access: gold, a free copy (OpenAlex)
Preprint: arxiv:2509.10547
Status: code verified
Categories: human (organism), clinical / translational (subfield)
Methods: Single-unit activity, calcium imaging, Machine learning
Keywords: Biomarkers, Computational biology and bioinformatics, Neurology, Neuroscience
Topic: S100 Proteins and Annexins (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Digital Futures
Citations: not cited yet (Europe PMC); 51 references in the paper

Abstract

Despite the diversity and volume of brain data acquired and advanced AI-based algorithms to analyze them, brain features are rarely used in clinics for diagnosis and prognosis. Here we argue that the field continues to rely on cohort comparisons to seek biomarkers, despite the well-established degeneracy of brain features. Using a thought experiment (Brain Swap), we show that more data and more powerful algorithms will not be sufficient to identify biomarkers of brain diseases. We argue that instead of comparing patient versus healthy controls using single data type, we should use multimodal (e.g. brain activity, neurotransmitters, neuromodulators, brain imaging) and longitudinal brain data to guide the grouping before defining multidimensional biomarkers for brain diseases.

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

paschels/brain_disease_biomarker

License: GPL-3.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: d159a15239d4e885edfc89c3a8e6783416a42411, 24 November 2025
Languages: Jupyter (1)
Size: 4 files, 1 script
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, 1 notebook
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (1 file), NumPy (1 file), PyTorch (1 file), scikit-learn (1 file), SciPy (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
3 files
At the source: github.com/paschels/brain_disease_biomarker

Code availability

We used Pytorch for our code, which you can find at https://github.com/paschels/brain_disease_biomarker.

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

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

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 4 keywords, 1 funder, 46 references.

Cite

This paper

Helson, P., & Kumar, A. (2026). Pursuit of biomarkers of brain diseases: beyond cohort comparisons. NPJ digital medicine, 9(1), 361. https://doi.org/10.1038/s41746-026-02614-5

BibTeX

@article{helson2026pursuit,
author = {Helson, Pascal and Kumar, Arvind},
title = {{Pursuit of biomarkers of brain diseases: beyond cohort comparisons}},
journal = {NPJ digital medicine},
year = {2026},
month = apr,
volume = {9},
number = {1},
pages = {361},
publisher = {Nature Publishing Group},
issn = {2398-6352},
doi = {10.1038/s41746-026-02614-5},
url = {https://doi.org/10.1038/s41746-026-02614-5},
pmid = {41963496},
pmcid = {PMC13156286}
}

RIS

TY - JOUR
AU - Helson, Pascal
AU - Kumar, Arvind
TI - Pursuit of biomarkers of brain diseases: beyond cohort comparisons
T2 - NPJ digital medicine
J2 - NPJ Digit Med
PY - 2026
DA - 2026/04/10
VL - 9
IS - 1
SP - 361
SN - 2398-6352
PB - Nature Publishing Group
DO - 10.1038/s41746-026-02614-5
UR - https://doi.org/10.1038/s41746-026-02614-5
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41746-026-02614-5",
"type": "article-journal",
"title": "Pursuit of biomarkers of brain diseases: beyond cohort comparisons",
"container-title": "NPJ digital medicine",
"author": [
{
"family": "Helson",
"given": "Pascal"
},
{
"family": "Kumar",
"given": "Arvind"
}
],
"container-title-short": "NPJ Digit Med",
"volume": "9",
"issue": "1",
"page": "361",
"DOI": "10.1038/s41746-026-02614-5",
"PMID": "41963496",
"PMCID": "PMC13156286",
"ISSN": "2398-6352",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41746-026-02614-5",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
10
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-71918-7 [code]
Developmental disinhibition gates language lateralization in childhood.
Journal: Nature communications
In common: PyTorch, scikit-learn, SciPy, 2 other tools, 3 references
[2] doi:10.1186/s12916-026-04903-y [code]
Structural connectome architecture and biological vulnerability shape cortical atrophy in cocaine use disorder.
Journal: BMC medicine
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, 3 references
[3] doi:10.1038/s41593-026-02205-3 [code]
Competitive interactions shape mammalian brain network dynamics and computation.
Journal: Nature neuroscience
In common: PyTorch, scikit-learn, SciPy, 2 other tools, 2 references
[4] doi:10.1371/journal.pone.0344600 [code]
Robust disease prognosis via diagnostic knowledge preservation: A sequential learning approach.
Journal: PloS one
In common: PyTorch, scikit-learn, SciPy, 2 other tools, clinical / translational, 1 reference
[5] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: PyTorch, scikit-learn, SciPy, 2 other tools, clinical / translational, 1 reference
[6] doi:10.1093/braincomms/fcag253 [code]
Disease detection and classification in temporal lobe epilepsy: step-wise versus simultaneous AI decision models in a multisite neuroimaging study.
Journal: Brain communications
In common: PyTorch, scikit-learn, SciPy, 2 other tools, clinical / translational, 1 reference
[7] doi:10.1038/s41467-026-71961-4 [code]
Spatiotemporal asymmetries on brain energy landscape uncover system entrapment related to depression severity.
Journal: Nature communications
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, 2 references
[8] doi:10.1038/s43856-026-01606-6 [code]
Validation of remote multimodal AI screening for Parkinson disease across diverse settings.
Journal: Communications medicine
In common: PyTorch, scikit-learn, SciPy, 2 other tools, clinical / translational, 1 reference
[9] doi:10.1038/s41398-026-04101-7 [code]
Using deep learning to identify brain networks mediating cognitive and motor impairments in alcohol use disorder.
Journal: Translational psychiatry
In common: PyTorch, scikit-learn, SciPy, 2 other tools, 1 reference
[10] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, 2 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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