OSCR

Mass spectrometry imaging-based explainable machine learning reveals the biochemical landscapes of the mouse brain.

Code ↔ Paper

4 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 4 matches
  1. [1] § Materials and methods › Modeling › Model-based selection of m/z markers for each brain region ↔ notebooks/linear.ipynb, lines 28–124 · score 0.78 · noise feature, permuted features, linear model, thresholds, selection, subsampling
  2. [2] § Materials and methods › Modeling › Model-based selection of m/z markers for each brain region ↔ msi_atlas/mapping.py, lines 19–83 · score 0.69 · permuted features, linear model, thresholds, selection, subsampling, noise
  3. [3] § Materials and methods › Visualizations › Virtual Pathology Stain (VPS) ↔ notebooks/linear.ipynb, lines 376–450 · score 0.68 · grayscale, 0–1, RGB, stain, pixels, IHC
  4. [4] § Materials and methods › Modeling › Machine learning-based classification of pixel categories ↔ msi_atlas/atlas_linear_model.py, lines 17–147 · score 0.52 · sampled weights, Pyro, uncertainty, linear, predictive, model

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 · 494 lines · 17 KB · MIT · 2 matches

  1. # %%
  2. from msi_visual.normalization import total_ion_count, spatial_total_ion_count
  3. from msi_atlas.annotations import get_dataset
  4. import numpy as np
  5. from argparse import Namespace
  6. from pathlib import Path
  7. import joblib
  8. array = np.array
  9. import os
  13. path = r"/home/jacob/Desktop/atlas_verification"
  14. extraction_args = eval(
  15. open(
  16. Path(path) /
  17. "args.txt").read())
  18. extraction_mzs = extraction_args.mzs
  20. paths = [(Path(path) / "0.npy", 1),
  21. (Path(path) / "2.npy", 0),
  22. (Path(path) / "1.npy", 2),
  23. (Path(path) / "3.npy", 3)]
  24. paths = [(str(path[0]), path[1]) for path in paths]
  25. X, y, slide_labels, label_encoder = get_dataset(r"NRL4485-s2_reannotation_23-12-24_PAHJ.json",
  26. paths, subsample=1, normalization=total_ion_count)
  28. # %%
  29. from msi_atlas.atlas_linear_model import AtlasLinearModel
  30. import torch
  32. def permute_features(X, noise_dim, random_state=None):
  33. """
  34. Creates noise features by randomly selecting columns from X and permuting their values.
  35. """
  36. rng = np.random.default_rng(random_state)
  37. n_samples, n_features = X.shape
  38. noise_indices = rng.choice(n_features, size=noise_dim, replace=True)
  39. noise = np.zeros((n_samples, noise_dim))
  41. for i, col_idx in enumerate(noise_indices):
  42. noise[:, i] = rng.permutation(X[:, col_idx])
  44. return noise
  46. def feature_stability_with_noise(X, y,
  47. num_runs=30,
  48. reg_strengths=[1e-2, 1e-3],
  49. noise_dim=20,
  50. subsample_ratio=0.8,
  51. weight_threshold=1e-4,
  52. random_state=None):
  53. """
  54. Estimates feature stability using subsampling and permuted real features for FDR control.
  56. Returns:
  57. - selected_features: boolean mask for real features
  58. - stability: array of shape (n_features + noise_dim,) with selection frequencies
  59. - noise_threshold: max stability among permuted (noise) features
  60. """
  61. rng = np.random.default_rng(random_state)
  62. n_samples, n_features = X.shape
  63. total_features = n_features + noise_dim
  64. stability = np.zeros((y.max()+1, total_features))
  67. all_weights = []
  68. balanced_accs = []
  69. accs = []
  70. for _ in range(num_runs):
  71. idx = rng.choice(n_samples, int(subsample_ratio * n_samples), replace=False)
  72. X_sub, y_sub = X[idx], y[idx]
  73. X_test, y_test = X[~idx], y[~idx]
  77. noise = permute_features(X_sub, noise_dim, random_state=rng)
  78. X_aug = np.hstack([X_sub, noise])
  79. X_test_aug = np.hstack([X_test, noise])
  82. for reg in reg_strengths:
  83. model = AtlasLinearModel(lr=0.1, C=y.max()+1)
  84. model.fit(X_aug, y_sub, early_stop_acc=0.8)
  86. # Get balanced test accuracy
  87. y_pred = model.predict(torch.tensor(X_test_aug, dtype=torch.float32).cuda())
  89. # Get overall test accuracy
  90. acc = (y_pred == y_test).mean()
  92. class_accuracies = []
  93. for c in np.unique(y_test):
  94. mask = y_test == c
  95. if mask.sum() > 0: # Only calculate if class exists in test set
  96. class_acc = (y_pred[mask] == y_test[mask]).mean()
  97. class_accuracies.append(class_acc)
  98. balanced_acc = np.mean(class_accuracies)
  99. balanced_accs.append(balanced_acc)
  100. accs.append(acc)
  103. weights = model.coef_ # shape: (total_features,)
  104. weights = weights.detach().cpu().numpy()
  105. all_weights.append(weights)
  106. max_noise_weight = np.max(weights[:, -noise_dim:], axis=-1)
  107. weight_threshold = max_noise_weight * 1.1
  108. selected = (weights > weight_threshold[:, None]).astype(float)
  109. stability += selected
  113. stability /= (num_runs * len(reg_strengths))
  114. print("Accuracy: ", np.mean(accs))
  115. print("Balanced Accuracy: ", np.mean(balanced_accs))
  116. return stability, all_weights
  118. y = np.array(y)
  119. stability, all_weights_specific = feature_stability_with_noise(X, y, 200, subsample_ratio=0.5, reg_strengths=[0], noise_dim=50)
  120. import joblib
  122. # # Save stability and weights
  123. # joblib.dump(stability, 'stability.joblib')
  124. # joblib.dump(all_weights_specific, 'all_weights_specific.joblib')
  127. # %%
  128. from collections import defaultdict
  129. shared_counter = defaultdict(int)
  130. categories = defaultdict(list)
  131. mzs_per_category = defaultdict(list)
  132. weight = {}
  133. for category_index in range(stability.shape[0]):
  134. for i in range(stability.shape[1]):
  135. if stability[category_index, i] > 0.95:
  136. shared_counter[extraction_mzs[i]] += 1
  137. categories[extraction_mzs[i]].append(category_index)
  138. weight[extraction_mzs[i]] = float(np.array(all_weights_specific)[:, category_index, i].mean())
  139. mzs_per_category[category_index].append((extraction_mzs[i], weight[extraction_mzs[i]]))
  141. category_index = 102
  142. shared_mzs = []
  143. specific_mzs = []
  144. specific_indices = []
  145. shared_indices = []
  148. for i in range(stability.shape[1] -50):
  149. weight[extraction_mzs[i]] = float(np.array(all_weights_specific)[:, category_index, i].mean())
  150. if stability[category_index, i] > 0.95:
  151. specific_indices.append(i)
  152. specific_mzs.append(extraction_mzs[i])
  153. weight[extraction_mzs[i]] = float(np.array(all_weights_specific)[:, category_index, i].mean())
  154. elif stability[category_index, i] > 0.5:
  155. shared_indices.append(i)
  156. shared_mzs.append(extraction_mzs[i])
  158. print(specific_mzs)
  160. mzs_per_category_with_model = {}
  161. for category in mzs_per_category:
  162. mzs_per_category_with_model[category] = [x[0] for x in sorted(mzs_per_category[category], key=lambda x: x[1], reverse=True)]
  164. # %%
  165. import pandas as pd
  166. from collections import defaultdict
  168. model_mzs_and_stabilities = {"category": []}
  169. for i in range(200):
  170. model_mzs_and_stabilities[f"mz_{i}"] = []
  171. model_mzs_and_stabilities[f"stability_{i}"] = []
  173. frequencies = stability[:, :-50]
  175. mzs_per_category_with_model_80 = defaultdict(list)
  176. mzs_per_category_with_model_100 = defaultdict(list)
  178. for category_index in range(frequencies.shape[0]):
  179. sorted_indices = np.argsort(frequencies[category_index])[::-1]
  180. mzs = [extraction_mzs[i] for i in sorted_indices]
  181. category_stabilities = frequencies[category_index, sorted_indices]
  182. model_mzs_and_stabilities["category"].append(label_encoder.classes_[category_index])
  184. for i, (mz, f) in enumerate(zip(mzs[:200], category_stabilities[:200])):
  185. model_mzs_and_stabilities[f"mz_{i}"].append(mz)
  186. model_mzs_and_stabilities[f"stability_{i}"].append(f)
  188. if f > 0.8:
  189. mzs_per_category_with_model_80[label_encoder.classes_[category_index]].append(mz)
  190. if f == 1.0:
  191. mzs_per_category_with_model_100[label_encoder.classes_[category_index]].append(mz)
  194. model_mzs_and_stabilities = pd.DataFrame(model_mzs_and_stabilities)
  195. model_mzs_and_stabilities.to_csv("model_mzs_and_stabilities.csv", index=False)
  199. # %%
  200. print([str(a) for a in list(label_encoder.inverse_transform(categories[1179.73081311]))])
  201. print([str(a) for a in list(label_encoder.inverse_transform(categories[1207.75938587]))])
  202. print([str(a) for a in list(label_encoder.inverse_transform(categories[808.12340284]))])
  204. label_encoder.transform(["BG_ARTEFACT_ARTEFACT"])
  206. sorted_counter = sorted(shared_counter.items(), key=lambda x: x[1], reverse=True)
  207. print(sorted_counter)
  211. # %%
  212. mzs = joblib.load("/home/jacob/Desktop/auc_mzs.joblib")
  213. auc_mzs_per_category = {}
  214. for category, category_name in enumerate(label_encoder.classes_):
  215. auc_mzs_per_category[category] = mzs["unique"][category_name] + mzs["common"][category_name]
  216. auc_mzs_per_category[category] = [x[0] for x in sorted(auc_mzs_per_category[category], key=lambda x: x[1], reverse=True)]
  217. #auc_mzs_per_category[102]
  219. # %%
  220. import pandas as pd
  222. # Create empty DataFrame with 50 columns
  223. df = pd.DataFrame(index=label_encoder.classes_, columns=range(250))
  225. # Fill DataFrame with m/z values for each category
  226. for category in auc_mzs_per_category:
  227. category_name = label_encoder.classes_[category]
  228. mzs = [x for x in auc_mzs_per_category[category][:250]] # Get top 50 m/z values
  229. # Pad with NaN if less than 50 m/z values
  230. mzs.extend([float('nan')] * (250 - len(mzs)))
  231. df.loc[category_name] = mzs
  233. # Save to CSV
  234. df.to_csv('MZ_AUC.csv')
  236. # Create empty DataFrame with 50 columns
  237. df = pd.DataFrame(index=label_encoder.classes_, columns=range(250))
  239. # Fill DataFrame with m/z values for each category
  240. for category in mzs_per_category:
  241. category_name = label_encoder.classes_[category]
  242. mzs = mzs_per_category_with_model[category][:250] # Get top 50 m/z values
  243. # Pad with NaN if less than 50 m/z values
  244. mzs.extend([float('nan')] * (250 - len(mzs)))
  245. df.loc[category_name] = mzs
  247. # Save to CSV
  248. df.to_csv('MZ_MODEL_TIC.csv')
  252. # %%
  253. from venn import venn
  254. from matplotlib import pyplot as plt
  255. %matplotlib inline
  257. parent_categories = list(set([name.split("_")[0].replace("#", '') for name in label_encoder.classes_]))
  258. mzs_per_parent = defaultdict(list)
  260. for category in mzs_per_category_with_model_80:
  261. parent = category.split("_")[0].replace("#", '')
  262. mzs = mzs_per_category_with_model_80[category]
  263. mzs = [mz for mz in mzs if mz not in auc_mzs_per_category[0]]
  264. mzs_per_parent[parent].extend(mzs)
  268. # Convert lists to sets for each parent category
  269. mz_sets = {parent: set(mzs) for parent, mzs in mzs_per_parent.items() if parent in ['BST', 'CNU', 'CTX', 'WM']}
  271. venn(mz_sets)
  274. plt.rcParams.update({'font.size': 10}) # Increase font size for all text elements
  275. plt.title("Venn diagram for m/z values identified by the model", y=-0.1)
  278. # %%
  279. from venn import venn
  280. from matplotlib import pyplot as plt
  281. %matplotlib inline
  283. parent_categories = list(set([name.split("_")[0].replace("#", '') for name in label_encoder.classes_]))
  284. mzs_per_parent = defaultdict(list)
  286. for category in auc_mzs_per_category:
  287. parent = label_encoder.classes_[category].split("_")[0].replace("#", '')
  288. mzs = auc_mzs_per_category[category]
  289. mzs = [mz for mz in mzs if mz not in auc_mzs_per_category[0]]
  290. mzs_per_parent[parent].extend(mzs)
  294. # Convert lists to sets for each parent category
  295. mz_sets = {parent: set(mzs) for parent, mzs in mzs_per_parent.items() if parent in ['BST', 'CNU', 'CTX', 'WM']}
  297. venn(mz_sets)
  298. plt.title("Venn diagram for m/z values identified by mPAUC")
  301. # %%
  302. # Count occurrences of each m/z value across all parent categories
  303. mz_counts = defaultdict(list)
  304. for parent, mzs in mzs_per_parent.items():
  305. if parent == 'BG':
  306. continue
  307. for mz in set(mzs):
  308. mz_counts[mz].append(parent)
  310. # Sort by number of occurrences (most frequent first)
  311. sorted_mzs = sorted(mz_counts.items(), key=lambda x: len(x[1]), reverse=True)
  313. print("Most common m/z values and their parent categories:")
  314. for mz, parents in sorted_mzs[:150]: # Show top 20
  315. print(f"m/z {mz:.5f} {', '.join(parents)}")
  318. # %%
  319. joblib.dump({"stability": stability, "all_weights_specific": all_weights_specific, "label_encoder": label_encoder}, "spatial_tic_model.joblib")
  321. # %%
  322. # Count category frequencies for m/z values in category 102
  323. category_counts = defaultdict(int)
  325. for mz in auc_mzs_per_category[102]:
  326. found = False
  327. # Find all categories this m/z appears in
  328. for cat_idx, mzs in auc_mzs_per_category.items():
  329. if mz in mzs and cat_idx != 102: # Exclude self-comparison
  330. cat_name = label_encoder.classes_[cat_idx].replace("_ARTEFACT", "")
  331. category_counts[cat_name] += 1
  332. found = True
  333. if not found:
  334. category_counts["unique"] += 1
  336. # Get top 10 categories by frequency
  337. top_10_categories = dict(sorted(category_counts.items(), key=lambda x: x[1], reverse=True)[:10])
  339. # Create pie chart
  340. plt.figure(figsize=(20, 20), dpi=200)
  341. plt.rcParams.update({'font.size': 30}) # Increase font size for all text elements
  342. plt.pie(top_10_categories.values(), labels=top_10_categories.keys(), autopct='%5.1f%%')
  345. plt.title(f"Frequencies of m/z's shared with other categories for {label_encoder.classes_[102].replace('_ARTEFACT', '')}", y=-0.1)
  346. plt.axis('equal')
  347. plt.show()
  350. # %%
  351. # Count category frequencies for m/z values in category 102
  352. category_counts = defaultdict(int)
  354. for mz in mzs_per_category_with_model_80[label_encoder.classes_[102]]:
  355. found = False
  356. # Find all categories this m/z appears in
  357. for cat_name, mzs in mzs_per_category_with_model_80.items():
  358. if mz in mzs and cat_name != label_encoder.classes_[102]: # Exclude self-comparison
  359. cat_name = cat_name.replace("_ARTEFACT", "")
  360. category_counts[cat_name] += 1
  361. found = True
  362. if not found:
  363. category_counts["unique"] += 1
  365. # Get top 10 categories by frequency
  366. top_10_categories = dict(sorted(category_counts.items(), key=lambda x: x[1], reverse=True)[:10])
  368. # Create pie chart
  369. plt.figure(figsize=(10, 10))
  370. plt.pie(top_10_categories.values(), labels=top_10_categories.keys(), autopct='%1.1f%%', textprops={'fontsize': 14})
  371. plt.title(f"Frequencies of m/z's shared with other categories for {label_encoder.classes_[102].replace('_ARTEFACT', '')} (Top 10)\nTIC model mapping")
  372. plt.axis('equal')
  373. plt.show()
  376. # %%
  377. import cv2
  378. from PIL import Image
  380. def get_ihc_image(img, mzs, category, intensity=None):
  381. indices = [extraction_mzs.index(float(mz)) for mz in mzs]
  382. mask = img.max(axis=-1)
  383. img = img / np.max(img, axis=(0, 1))
  384. ion = img[:, :, indices].mean(axis=-1)
  385. if intensity is None:
  386. ion = ion / ion.max()
  387. else:
  388. ion = ion / intensity
  391. ion = ion / np.percentile(ion, 99.7)
  392. ion[ion > 1] = 1
  395. # Apply non-linear stretching to emphasize larger values
  396. # Using power function with exponent < 1 to compress lower values and stretch higher ones
  397. ion = np.power(ion, 2) # Adjust exponent as needed (smaller = more stretching)
  398. ion = np.uint8((ion / ion.max()) * 255) # Rescale back to 0-255 range
  399. #ion = np.uint8(ion* 255) # Rescale back to 0-255 range
  401. #display(Image.fromarray(ion))
  404. # Convert grayscale to RGB IHC-like coloring
  405. # Create RGB image with brown for high values and light pink for low values
  406. rgb = np.zeros((ion.shape[0], ion.shape[1], 3), dtype=np.uint8)
  408. # Brown color (RGB: 139, 69, 19) for high values
  409. # Light pink (RGB: 255, 228, 225) for low values
  410. rgb[:,:,0] = np.uint8(255 - ion * 0.45) # R channel
  411. rgb[:,:,1] = np.uint8(228 - ion * 0.62) # G channel
  412. rgb[:,:,2] = np.uint8(225 - ion * 0.81) # B channel
  415. # Create a colormap from white to brown
  416. white = np.array([255, 255, 255])
  417. brown = np.array([139, 69, 19])
  419. # Create normalized intensity values between 0 and 1
  420. norm_ion = ion.astype(float) / 255
  422. # For each pixel, interpolate between white and brown based on intensity
  423. for i in range(3): # RGB channels
  424. rgb[:,:,i] = np.uint8(white[i] + (brown[i] - white[i]) * norm_ion)
  426. rgb[mask == 0] = 0
  429. # This creates a brownish-purple tone typical of IHC staining
  430. ion = rgb
  431. # Add text overlay with category name
  432. font = cv2.FONT_HERSHEY_SIMPLEX
  433. font_scale = 0.8
  434. font_color = (255, 50, 60) # White text
  435. font_thickness = 2
  436. text_size = cv2.getTextSize(category, font, font_scale, font_thickness)[0] * 2
  438. # Position text at top center
  439. ##text_x = (ion.shape[1]) // 2
  440. text_x = 10
  441. text_y = text_size[1] + 10 # Add some padding from top
  443. # Rotate image 90 degrees counterclockwise
  444. ion = cv2.rotate(ion, cv2.ROTATE_90_COUNTERCLOCKWISE)
  446. ion_no_text = ion.copy()
  447. # Add text to image
  448. category = category.replace("_ARTEFACT", "")
  449. cv2.putText(ion, category, (text_x, text_y), font, font_scale, font_color, font_thickness)
  450. return ion, ion_no_text
  452. # %%
  453. import json
  454. categories_per_mz = defaultdict(list)
  455. for mz in mzs_per_category_with_model[102]:
  457. for cat_idx, mzs in mzs_per_category_with_model.items():
  458. if mz in mzs and cat_idx != 102: # Exclude self-comparison
  459. cat_name = label_encoder.classes_[cat_idx].replace("_ARTEFACT", "")
  460. categories_per_mz[mz].append(cat_name)
  463. # Create folder for this m/z value if it doesn't exist
  464. mz_folder = f"mz_{mz:.4f}"
  465. for path in paths:
  466. img = total_ion_count(np.load(path[0]))
  467. _, ion_no_text = get_ihc_image(img, [mz], '')
  468. Image.fromarray(ion_no_text).save(f"{mz_folder}_{path[1]}.png")
  469. # Save categories per m/z as JSON
  470. with open(f"categories.json", "w") as f:
  471. json.dump(categories_per_mz, f, indent=4)
  474. # %%
  475. import pandas as pd
  476. csv = pd.read_csv("MZ_MODEL_TIC.csv")
  478. # %%
  479. cnu_mzs = mzs_per_parent['CNU']
  481. cnu_mzs = [x for x in cnu_mzs if x not in mzs_per_parent['BST']]
  482. cnu_mzs = [x for x in cnu_mzs if x not in mzs_per_parent['CTX']]
  483. cnu_mzs = [x for x in cnu_mzs if x not in mzs_per_parent['WM']]
  484. cnu_mzs = [x for x in cnu_mzs if x not in mzs_per_parent['BG']]
  486. print(cnu_mzs)
  493. # %%

linear.ipynb at commit de9d453, under MIT · at the source

Overview

Authors: Jacob Gildenblat1, Jorunn Stamnas2, Jens Pahnke1,3,4,5,6,7
ORCID iDs: Jacob Gildenblat, Jorunn Stamnas, Jens Pahnke
  1. Pahnke Lab, www.pahnkelab.eu
  2. Proteomics Core Facility, Department of Immunology, Department of Clinical Medicine (KlinMed), Medical Faculty, University of Oslo (UiO) and Division of Laboratory Medicine (KLM), Oslo University Hospital (OUS), Oslo, Norway
  3. Translational Neurodegeneration Research and Neuropathology Lab, Department of Clinical Medicine, Medical Faculty, University of Oslo, Oslo, Norway
  4. Section of Neuropathology Research, Department of Pathology, Division of Laboratory Medicine, Oslo University Hospital, Oslo, Norway
  5. Institute of Nutritional Medicine, University of Lübeck and University Medical Center Schleswig-Holstein, Lübeck, Germany
  6. Department of Neuromedicine and Neuroscience, The Faculty of Medicine and Life Sciences, University of Latvia, Rīga, Latvia
  7. Department of Neurobiology, School of Neurobiology, Biochemistry and Biophysics, The Georg S. Wise Faculty of Life Sciences, University of Tel Aviv, Ramat Aviv, Israel
Institutions: Oslo University Hospital (Norway); University of Oslo (Norway); University of Latvia (Latvia); University of Lübeck (Germany)
Journal: Free neuropathology, volume 7, article 9
Dates: received 3 March 2026; accepted 17 April 2026; published online 28 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.17879/freeneuropathology-2026-9413 · PMID 42078793 · PMCID PMC13129809 · OpenAlex W7157246238
Open access: green, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), other (modality), mouse (organism), Alzheimer's / dementia (population), methods / tools (subfield)
Methods: Connectivity, Smoothing, state filtering, decompositions, Machine learning, Statistics
Keywords: Mass spectrometry imaging, Brain atlas, Dimensionality reduction, Machine learning, Data visualization, Explainable machine learning, Lipidomics, Explainability, Alzheimer's disease, MSI-VISUAL, MSI-ATLAS, ABCA7, Index lipids, GM3
Topic: Metabolomics and Mass Spectrometry Studies (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Citations: not cited yet (Europe PMC); 45 references in the paper

Abstract

Recent computational advances in mass spectrometry imaging (MSI) now enable unprecedented insight into organ-wide molecular composition and functional architecture. Here, we present the first high-resolution molecular-computational atlas of specific mouse brain lipids and metabolites, acquired using a NEDC matrix and negative-mode MSI, covering 123 anatomically defined regions and 191 polygonal annotations derived solely from MSI data, without auxiliary imaging. To overcome annotation ambiguity and MSI complexity, we introduced the Computational Brain Lipid Atlas (CBLA), a graph-based visual-explainability framework that generates Virtual Landscape Visualizations (VLVs) of specific lipid distributions across brain substructures. The CBLA integrates dimensionality reduction and ensembles of supervised models to (i) refine annotations, (ii) elucidate interregional relationships, (iii) interpret model behavior, and (iv) formulate biologically testable hypotheses. The CBLA revealed novel lipid distribution patterns, functional integrations, anatomical connections – the brain's telephone cables, and region-specific disease signatures – index lipids, including disease networks in the basal ganglia. It further identified index lipids that trace extrapyramidal nuclei and their cortical-brainstem connections, highlighting network-level molecular organization. A new algorithm decomposes annotated regions into precise mass-to-charge (m/z) features and resolves high-resolution m/z values from MSI data, m/z producing a comprehensive high-resolution brain map. It can be applied to any MS measurements, including metabolites, lipids, and peptides. This resource underpins downstream studies, as exemplified here by characterizing the molecular lipid composition of Aβ plaques in APP and ABCA7 transgenic mice, their spatial arrangement, and their connections with surrounding tissue. For the first time, our data suggest that GM3 ganglioside accumulation in cortical amyloid plaques may originate from hippocampal structures, consistent with longstanding evidence of disrupted hippocampo-cortical connectivity; a similar origin may also apply to plaque-associated Aβ signals in the cortex. More broadly, several selected m/z signals showed putative anatomical origins in specific brain subregions. Together, these findings establish MSI-ATLAS as a general framework for mapping brain organization and disease-related molecular networks directly from MSI data.

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

jacobgil/msi-atlas

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: de9d453840f91e8383052ada42322e99547bd95e, 23 May 2025
Languages: Python (4), Jupyter (1)
Size: 9 files, 5 scripts
Software Heritage: not archived
Found in: “Availability of code”
Holds: README, license file, 1 notebook
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (5 files), PyTorch (4 files), Matplotlib (3 files), OpenCV (3 files), scikit-learn (3 files), NetworkX (2 files), Pillow (2 files), Pyro (2 files), pandas (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
7 files
At the source: github.com/jacobgil/msi-atlas

Availability of code

Code is available as an open-source package on GitHub. https://github.com/jacobgil/msi-atlas

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;
  • 5 scripts, each with its path and the digest of its content;
  • 4 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.

Availability of data and material

The datasets generated and analyzed during the current study are available in the ProteomeXchange PRIDE repository under accession number PXD056609.

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, 3 authors, 14 keywords, 43 references.

Cite

This paper

Gildenblat, J., Stamnas, J., & Pahnke, J. (2026). Mass spectrometry imaging-based explainable machine learning reveals the biochemical landscapes of the mouse brain. Free neuropathology, 7, 9. https://doi.org/10.17879/freeneuropathology-2026-9413

BibTeX

@article{gildenblat2026mass,
author = {Gildenblat, Jacob and Stamnas, Jorunn and Pahnke, Jens},
title = {{Mass spectrometry imaging-based explainable machine learning reveals the biochemical landscapes of the mouse brain}},
journal = {Free neuropathology},
year = {2026},
month = apr,
volume = {7},
pages = {9},
publisher = {Free Neuropathology General Assembly},
issn = {2699-4445},
doi = {10.17879/freeneuropathology-2026-9413},
url = {https://doi.org/10.17879/freeneuropathology-2026-9413},
pmid = {42078793},
pmcid = {PMC13129809}
}

RIS

TY - JOUR
AU - Gildenblat, Jacob
AU - Stamnas, Jorunn
AU - Pahnke, Jens
TI - Mass spectrometry imaging-based explainable machine learning reveals the biochemical landscapes of the mouse brain
T2 - Free neuropathology
J2 - Free Neuropathol
PY - 2026
DA - 2026/04/28
VL - 7
SP - 9
SN - 2699-4445
PB - Free Neuropathology General Assembly
DO - 10.17879/freeneuropathology-2026-9413
UR - https://doi.org/10.17879/freeneuropathology-2026-9413
LA - en
ER -

CSL-JSON

{
"id": "10.17879/freeneuropathology-2026-9413",
"type": "article-journal",
"title": "Mass spectrometry imaging-based explainable machine learning reveals the biochemical landscapes of the mouse brain",
"container-title": "Free neuropathology",
"author": [
{
"family": "Gildenblat",
"given": "Jacob"
},
{
"family": "Stamnas",
"given": "Jorunn"
},
{
"family": "Pahnke",
"given": "Jens"
}
],
"container-title-short": "Free Neuropathol",
"volume": "7",
"page": "9",
"DOI": "10.17879/freeneuropathology-2026-9413",
"PMID": "42078793",
"PMCID": "PMC13129809",
"ISSN": "2699-4445",
"publisher": "Free Neuropathology General Assembly",
"URL": "https://doi.org/10.17879/freeneuropathology-2026-9413",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
28
]
]
}
}

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.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: NetworkX, OpenCV, Pillow, 5 other tools, other, methods / tools, genetics / omics, 1 other category, 13 references, 2 authors
[2] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: Pyro, OpenCV, Pillow, 5 other tools, methods / tools
[3] doi:10.1038/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: NetworkX, OpenCV, Pillow, 5 other tools, methods / tools, mouse
[4] doi:10.1038/s41598-026-61605-4 [code]
Learning precise segmentation of neurofibrillary tangles from rapid manual point annotations.
Journal: Scientific reports
In common: OpenCV, Pillow, PyTorch, 4 other tools, methods / tools, Alzheimer's / dementia, 1 reference
[5] doi:10.1038/s42003-026-10259-z [code]
Spatial transcriptomic profiling of developing mouse hearts reveals a spatially patterned signaling environment.
Journal: Communications biology
In common: Pyro, OpenCV, PyTorch, 4 other tools, genetics / omics, mouse
[6] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: NetworkX, OpenCV, Pillow, 5 other tools, genetics / omics, mouse
[7] doi:10.1093/bioinformatics/btag652 [code]
mmVelo: a deep generative model for estimating cell state-dependent dynamics across multiple modalities.
Journal: Bioinformatics (Oxford, England)
In common: Pyro, Pillow, PyTorch, 4 other tools, genetics / omics, mouse
[8] 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: NetworkX, OpenCV, Pillow, 5 other tools, methods / tools
[9] doi:10.1038/s41398-026-03965-z [code]
Disentangling individual heterogeneity reveals robust network and molecular signatures of major depressive disorder with suicidal ideation.
Journal: Translational psychiatry
In common: NetworkX, OpenCV, Pillow, 5 other tools, genetics / omics
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: NetworkX, OpenCV, Pillow, 5 other tools, mouse

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.