OSCR

Spatial analysis of paraneoplastic cerebellar degeneration in ovarian cancer with anti-Yo syndrome and SCA1.

Code ↔ Paper

12 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 12 matches
  1. [1] § Methods › Analysis ↔ notebooks/3d_thickness_analysis.ipynb, lines 604–650 · score 0.93 · Lobule III, Lobule VIIIA, Lobule IX, Lobule VIIB, Lobule VIIIB, Lobule Crus
  2. [2] § Methods › Analysis ↔ notebooks/network_analysis.ipynb, lines 397–441 · score 0.92 · Lobule III, Lobule VIIIA, Lobule IX, Lobule VIIB, Lobule VIIIB, Lobule Crus
  3. [3] § Methods › Analysis ↔ notebooks/group_classification.ipynb, lines 409–515 · score 0.88 · Random Forest classifier, class weights, residualized feature, age residualized, CV, stratified
  4. [4] § Methods › Analysis ↔ notebooks/network_analysis.ipynb, lines 915–957 · score 0.79 · absolute thresholds, proportional thresholding, NetworkX, strongest, network metric, density
  5. [5] § Methods › Analysis ↔ notebooks/group_differences.ipynb, lines 358–428 · score 0.76 · bootstrap cluster stability, silhouette scores, Adjusted Rand, ARI, patient
  6. [6] § Results › Classification of patient groups ↔ notebooks/group_classification.ipynb, lines 409–515 · score 0.74 · random forest classifier, age residualized features, class weights, Permutation, shuffles, fit
  7. [7] § Results › Graph-based metrics ↔ notebooks/network_analysis.ipynb, lines 865–913 · score 0.73 · correlation thresholds, global efficiency, network metric, node strength, global clustering, density
  8. [8] § Results › Graph-based metrics ↔ notebooks/network_analysis.ipynb, lines 915–957 · score 0.71 · proportional thresholding, global efficiency, node strength, Global clustering, absolute, edge
  9. [9] § Results › Cortical thickness analysis ↔ notebooks/group_differences.ipynb, lines 358–428 · score 0.58 · silhouette score, Adjusted Rand, Cluster stability, patients, PCD
  10. [10] § Results › Classification of patient groups ↔ notebooks/group_classification.ipynb, lines 125–173 · score 0.57 · random forest classifier, ROC curves, folds, AUCs, residualized
  11. [11] § Methods › Analysis ↔ notebooks/network_analysis.ipynb, lines 518–579 · score 0.57 · Node strength, clustering coefficient, shortest, efficiency, edge, weights
  12. [12] § Methods › Analysis ↔ notebooks/network_analysis.ipynb, lines 518–579 · score 0.54 · NetworkX, graph metrics, Connectivity

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 · 1,059 lines · 34 KB · no license · 6 matches

  1. # %%
  2. import nibabel as nib
  3. import os
  4. import numpy as np
  5. import pandas as pd
  6. from sklearn.linear_model import LinearRegression
  7. from statsmodels.api import OLS, add_constant
  8. from statsmodels.stats.multitest import multipletests
  9. import matplotlib.pyplot as plt
  10. from matplotlib.colors import ListedColormap
  11. from nilearn.plotting import plot_stat_map
  12. from nilearn.image import load_img
  13. import scipy.stats as stats
  14. from nilearn import plotting, datasets
  15. from nilearn.plotting import plot_anat, plot_stat_map, view_img
  16. from scipy.ndimage import center_of_mass
  17. from nilearn.image import resample_to_img
  18. from scipy import stats
  19. from netplotbrain import plot as netplot
  21. plt.rcParams.update({
  22. 'font.size': 12,
  23. 'axes.titlesize': 14,
  24. 'axes.labelsize': 12,
  25. 'xtick.labelsize': 10,
  26. 'ytick.labelsize': 10,
  27. 'legend.fontsize': 10,
  28. 'figure.dpi': 100,
  29. 'savefig.dpi': 900,
  30. 'font.family': 'sans-serif',
  31. 'font.sans-serif': ['Arial', 'DejaVu Sans'],
  32. 'pdf.fonttype': 42,
  33. })
  35. # %%
  36. def compute_barycenters(mask_path, exclude_regions, target_affine):
  37. """
  38. Compute barycenters for regions in a given NIfTI mask, aligned to the target atlas space.
  39. """
  40. mask_img = nib.load(mask_path)
  41. mask_data = mask_img.get_fdata()
  42. unique_regions = np.unique(mask_data)[1:] # Exclude background (0)
  44. coords = []
  45. included_regions = []
  46. for region in unique_regions:
  47. if region not in exclude_regions:
  48. region_mask = (mask_data == region)
  49. barycenter = center_of_mass(region_mask)
  50. coords.append(barycenter)
  51. included_regions.append(region)
  53. # Transform barycenters to target atlas space
  54. coords = np.array(coords)
  55. transformed_coords = nib.affines.apply_affine(target_affine, coords)
  56. return transformed_coords, included_regions
  58. def extract_region_thickness(data_path, subject_files, mask_path, included_regions):
  59. """
  60. Extract region-wise cortical thickness data using a custom mask.
  61. """
  62. mask_img = nib.load(mask_path)
  63. mask_data = mask_img.get_fdata()
  65. region_thickness = []
  66. for path in subject_files:
  67. subject_img = nib.load(data_path + path)
  68. resampled_img = resample_to_img(subject_img, mask_img, interpolation="nearest")
  69. resampled_data = resampled_img.get_fdata()
  71. subject_region_means = [
  72. np.median(resampled_data[mask_data == region]) for region in included_regions
  73. ]
  74. region_thickness.append(subject_region_means)
  76. return np.array(region_thickness)
  79. def compute_structural_covariance(data):
  80. """
  81. Compute structural covariance as pairwise correlations between nodes.
  82. """
  83. n_regions = data.shape[1]
  84. corr_matrix = np.zeros((n_regions, n_regions))
  85. for i in range(n_regions):
  86. for j in range(i, n_regions):
  87. if np.std(data[:, i]) == 0 or np.std(data[:, j]) == 0:
  88. corr_matrix[i, j] = corr_matrix[j, i] = 0 # Avoid divide by zero
  89. else:
  90. corr_matrix[i, j] = corr_matrix[j, i] = np.corrcoef(data[:, i], data[:, j])[0, 1]
  91. return corr_matrix
  94. def plot_network_on_brain(coords, adj_matrix, title, filename, template=None):
  95. """
  96. Plot the network on the brain using NetPlotBrain.
  97. """
  98. edges = []
  99. for i in range(adj_matrix.shape[0]):
  100. for j in range(i + 1, adj_matrix.shape[1]):
  101. if adj_matrix[i, j] != 0:
  102. edges.append({"i": i, "j": j, "weight": adj_matrix[i, j]})
  104. edges_df = pd.DataFrame(edges)
  105. nodes_df = pd.DataFrame(coords, columns=["x", "y", "z"])
  107. netplot(
  108. template="MNI152NLin2009cAsym",
  109. nodes=nodes_df,
  110. edges=edges_df,
  111. node_size=5,
  112. edge_color="weight",
  113. edge_cmap="coolwarm",
  114. margin=0.05,
  115. #view="preset-6",
  116. view = 'LRSP',
  117. savename=filename,
  118. )
  121. # %%
  122. # Paths to thickness data for two groups
  123. group1_paths = [
  124. "IXI158.nii", "IXI204.nii", "IXI237.nii", "IXI251.nii", "IXI288.nii",
  125. "IXI383.nii", "IXI384.nii", "IXI399.nii", "IXI420.nii", "IXI433.nii",
  126. "IXI462.nii", "IXI464.nii", "IXI476.nii", "IXI491.nii", "IXI498.nii",
  127. "IXI518.nii", "IXI538.nii"
  128. ]
  129. group2_paths = [
  130. "Patient1.nii", "Patient2.nii", "Patient3.nii", "Patient4.nii",
  131. "Patient5.nii", "Patient6.nii", "Patient8.nii", "Patient9.nii",
  132. "Patient10.nii", "Patient11.nii", "Patient12.nii"
  133. ]
  134. group3_paths = ["SCA013.nii", "SCA029.nii", "SCA033.nii", "SCA039.nii",
  135. "SCA068.nii", "SCA069.nii", "SCA076.nii", "SCA077.nii",
  136. "SCA083.nii", "SCA084.nii", "SCA087.nii", "SCA090.nii",
  137. "SCA093.nii", "SCA094.nii", "SCA095.nii", "SCA096.nii",
  138. "SCA097.nii"
  139. ]
  140. data_path="../data/normal_yo_SCA/"
  142. # %%
  143. # Load mask and compute barycenters
  144. mask_path = "../data/mni_structures_job1687583.nii"
  145. mask_img = nib.load(mask_path)
  146. atlas = datasets.fetch_atlas_schaefer_2018()
  147. target_affine = mask_img.affine
  148. #target_affine = nib.load(atlas["maps"]).affine # Get affine from atlas
  149. exclude_regions = [13, 113] # Exclude regions
  150. coords, included_regions = compute_barycenters(mask_path, exclude_regions, target_affine)
  152. # %%
  153. # Extract region-wise cortical thickness
  154. group1_data = extract_region_thickness(data_path, group1_paths, mask_path, included_regions)
  155. group2_data = extract_region_thickness(data_path, group2_paths, mask_path, included_regions)
  156. group3_data = extract_region_thickness(data_path, group3_paths, mask_path, included_regions)
  159. # %%
  160. np.save('../data/group1_data.npy', group1_data)
  161. np.save('../data/group2_data.npy', group2_data)
  162. np.save('../data/group3_data.npy', group3_data)
  164. # Load the array
  165. group1_data = np.load('../data/group1_data.npy')
  166. group2_data = np.load('../data/group2_data.npy')
  167. group3_data = np.load('../data/group3_data.npy')
  169. # %%
  170. # Compute structural covariance matrices
  171. corr_matrix_group1 = compute_structural_covariance(group1_data)
  172. corr_matrix_group2 = compute_structural_covariance(group2_data)
  173. corr_matrix_group3 = compute_structural_covariance(group3_data)
  175. # %%
  176. threshold = 0.0
  177. adj_matrix_group1 = np.where(np.abs(corr_matrix_group1) > threshold, corr_matrix_group1, 0)
  178. adj_matrix_group2 = np.where(np.abs(corr_matrix_group2) > threshold, corr_matrix_group2, 0)
  179. adj_matrix_group3 = np.where(np.abs(corr_matrix_group3) > threshold, corr_matrix_group3, 0)
  181. # %%
  182. # Compute difference matrix
  183. diff_matrix = adj_matrix_group2 - adj_matrix_group1
  184. diff_matrix_13 = adj_matrix_group3 - adj_matrix_group1
  185. diff_matrix_23 = adj_matrix_group2 - adj_matrix_group3
  187. # %%
  188. from scipy.stats import ttest_ind
  190. # %%
  191. # Perform pairwise t-tests with FDR correction
  192. n_nodes = group1_data.shape[1]
  193. p_values = []
  194. indices = []
  196. # Collect p-values
  197. for i in range(n_nodes):
  198. for j in range(i + 1, n_nodes):
  199. t_stat, p_value = ttest_ind(group1_data[:, i], group2_data[:, j]) # Pairwise comparison
  200. p_values.append(p_value)
  201. indices.append((i, j))
  204. # Apply FDR correction
  205. rejected, p_values_corrected, _, _ = multipletests(p_values, alpha=0.05, method="fdr_bh")
  207. # Update significance matrix
  208. sig_matrix = np.zeros((n_nodes, n_nodes))
  209. for idx, (i, j) in enumerate(indices):
  210. if rejected[idx]:
  211. sig_matrix[i, j] = sig_matrix[j, i] = 1 - p_values_corrected[idx]
  214. # %%
  215. # Perform pairwise t-tests with FDR correction
  216. n_nodes = group1_data.shape[1]
  217. p_values = []
  218. indices = []
  220. # Collect p-values
  221. for i in range(n_nodes):
  222. for j in range(i + 1, n_nodes):
  223. t_stat, p_value = ttest_ind(group1_data[:, i], group3_data[:, j])
  224. p_values.append(p_value)
  225. indices.append((i, j))
  227. # Apply FDR correction
  228. rejected, p_values_corrected, _, _ = multipletests(p_values, alpha=0.05, method="fdr_bh")
  230. # Update significance matrix
  231. sig_matrix_13 = np.zeros((n_nodes, n_nodes))
  232. for idx, (i, j) in enumerate(indices):
  233. if rejected[idx]:
  234. sig_matrix_13[i, j] = sig_matrix_13[j, i] = 1 - p_values_corrected[idx]
  236. # %%
  237. # Perform pairwise t-tests with FDR correction
  238. n_nodes = group1_data.shape[1]
  239. p_values = []
  240. indices = []
  242. # Collect p-values
  243. for i in range(n_nodes):
  244. for j in range(i + 1, n_nodes):
  245. t_stat, p_value = ttest_ind(group2_data[:, i], group3_data[:, j])
  246. p_values.append(p_value)
  247. indices.append((i, j))
  249. # Apply FDR correction
  250. rejected, p_values_corrected, _, _ = multipletests(p_values, alpha=0.05, method="fdr_bh")
  252. # Update significance matrix
  253. sig_matrix_23 = np.zeros((n_nodes, n_nodes))
  254. for idx, (i, j) in enumerate(indices):
  255. if rejected[idx]:
  256. sig_matrix_23[i, j] = sig_matrix_23[j, i] = 1 - p_values_corrected[idx]
  258. # %%
  259. def plot_combined_adjacency_matrices(adj_group1, adj_group2, diff_matrix, sig_matrix, filename, groupname_1, groupname_2):
  260. """
  261. Plot adjacency matrices for two groups, their difference, and the significant clusters in a single layout.
  262. """
  263. fig, ax = plt.subplots(1, 4, figsize=(24, 6))
  264. cmap = "RdBu_r"
  265. vmin, vmax = -1, 1 # Adjusted for correlation range
  267. ax[0].imshow(adj_group1, cmap=cmap, vmin=vmin, vmax=vmax)
  268. ax[0].set_title(groupname_1)
  269. ax[0].set_xlabel("Nodes")
  270. ax[0].set_ylabel("Nodes")
  272. ax[1].imshow(adj_group2, cmap=cmap, vmin=vmin, vmax=vmax)
  273. ax[1].set_title(groupname_2)
  274. ax[1].set_xlabel("Nodes")
  276. ax[2].imshow(diff_matrix, cmap="RdBu_r", vmin=-1, vmax=1)
  277. ax[2].set_title("Difference Matrix")
  278. ax[2].set_xlabel("Nodes")
  280. ax[3].imshow(sig_matrix, cmap="binary", interpolation="nearest")
  281. ax[3].set_title("Significant Differences")
  282. ax[3].set_xlabel("Nodes")
  284. plt.tight_layout()
  285. plt.savefig(filename, bbox_inches='tight', dpi=300)
  286. plt.savefig(filename.replace('.svg', '.png'), bbox_inches='tight', dpi=600)
  287. plt.show()
  289. # %%
  290. labels = 4*["anterior"]+8*['posterior']+4*["anterior"]+8*['posterior']
  292. # %%
  293. # Create combined adjacency matrix plot
  294. plot_combined_adjacency_matrices(
  295. adj_matrix_group1, adj_matrix_group2, diff_matrix, sig_matrix,
  296. "../results/Combined_Adjacency_Matrices_with_Significance_12.png",
  297. "Healthy Group (Median)", "anti-Yo PCD Group (Median)",
  298. )
  300. # %%
  301. from graspologic.plot import heatmap
  303. def plot_combined_adjacency_matrices(
  304. adj_group1, adj_group2, diff_matrix, sig_matrix, filename, groupname_1, groupname_2, labels
  305. ):
  306. """
  307. Plot adjacency matrices for two groups, their difference, and the significant clusters in a single layout using graspologic's heatmap.
  308. """
  309. fig, axes = plt.subplots(1, 4, figsize=(30, 10))
  310. font_scale = 1.5
  311. hier_label_fontsize = 20
  313. # Group 1
  314. heatmap(
  315. adj_group1,
  316. ax=axes[0],
  317. inner_hier_labels=labels,
  318. sort_nodes=True,
  319. cbar=False,
  320. title=groupname_1,
  321. font_scale=font_scale,
  322. hier_label_fontsize=hier_label_fontsize
  323. )
  324. axes[0].set_xlabel("Nodes")
  325. axes[0].set_ylabel("Nodes")
  327. # Group 2
  328. heatmap(
  329. adj_group2,
  330. ax=axes[1],
  331. inner_hier_labels=labels,
  332. sort_nodes=True,
  333. cbar=False,
  334. title=groupname_2,
  335. font_scale=font_scale,
  336. hier_label_fontsize=hier_label_fontsize
  337. )
  338. axes[1].set_xlabel("Nodes")
  340. # Difference Matrix
  341. heatmap(
  342. diff_matrix,
  343. ax=axes[2],
  344. inner_hier_labels=labels,
  345. sort_nodes=True,
  346. cbar=False,
  347. title="Difference Matrix",
  348. font_scale=font_scale,
  349. hier_label_fontsize=hier_label_fontsize
  350. )
  351. axes[2].set_xlabel("Nodes")
  353. # Significant Differences
  354. heatmap(
  355. sig_matrix,
  356. ax=axes[3],
  357. inner_hier_labels=labels,
  358. sort_nodes=True,
  359. cbar=False,
  360. title="Significant Differences",
  361. font_scale=font_scale,
  362. hier_label_fontsize=hier_label_fontsize
  363. )
  364. axes[3].set_xlabel("Nodes")
  366. plt.tight_layout()
  367. plt.savefig(filename, bbox_inches='tight', dpi=300)
  368. plt.savefig(filename.replace('.svg', '.png'), bbox_inches='tight', dpi=600)
  369. plt.show()
  372. # %%
  373. # Create combined adjacency matrix plot
  374. plot_combined_adjacency_matrices(
  375. adj_matrix_group1, adj_matrix_group2, diff_matrix, sig_matrix,
  376. "../results/Combined_Adjacency_Matrices_with_Significance_12.svg",
  377. "Control", "PCD",
  378. labels=labels
  379. )
  381. # %%
  382. # Create combined adjacency matrix plot
  383. plot_combined_adjacency_matrices(
  384. adj_matrix_group1, adj_matrix_group3, diff_matrix_13, sig_matrix_13,
  385. "../results/Combined_Adjacency_Matrices_with_Significance_13.svg", "Control", "SCA",
  386. labels
  387. )
  389. # %%
  390. # Create combined adjacency matrix plot
  391. plot_combined_adjacency_matrices(
  392. adj_matrix_group3, adj_matrix_group2, diff_matrix_23, sig_matrix_23, "../results/Combined_Adjacency_Matrices_with_Significance_23.svg",
  393. "SCA", "PCD",
  394. labels
  395. )
  397. # %% [markdown]
  398. # ### Network
  400. # %% [markdown]
  401. # ### Network analysis
  403. # %%
  404. import networkx as nx
  405. import matplotlib.patches as mpatches
  407. # Color mapping for labels
  408. color_dict = {
  409. 'posterior': '#aff8df',
  410. 'anterior': '#ffcbc1'
  411. }
  413. # Define the mapping for node labels
  414. lobule_mapping = {
  415. 0: 'Lobule I-II',
  416. 1: 'Lobule III',
  417. 2: 'Lobule IV',
  418. 3: 'Lobule V',
  419. 4: 'Lobule VI',
  420. 5: 'Lobule Crus I',
  421. 6: 'Lobule Crus II',
  422. 7: 'Lobule VIIB',
  423. 8: 'Lobule VIIIA',
  424. 9: 'Lobule VIIIB',
  425. 10: 'Lobule IX',
  426. 11: 'Lobule X',
  427. 12: 'Lobule I-II (R)',
  428. 13: 'Lobule III (R)',
  429. 14: 'Lobule IV (R)',
  430. 15: 'Lobule V (R)',
  431. 16: 'Lobule VI (R)',
  432. 17: 'Lobule Crus I (R)',
  433. 18: 'Lobule Crus II (R)',
  434. 19: 'Lobule VIIB (R)',
  435. 20: 'Lobule VIIIA (R)',
  436. 21: 'Lobule VIIIB (R)',
  437. 22: 'Lobule IX (R)',
  438. 23: 'Lobule X (R)'
  439. }
  441. collabels = 4*["anterior"]+8*['posterior']+4*["anterior"]+8*['posterior']
  443. # %%
  444. coords_2d = coords[:,[0,2]]
  446. def create_graph(adj_matrix, lobule_mapping, collabels):
  447. A = adj_matrix.copy()
  448. np.fill_diagonal(A, 0)
  449. g = nx.from_numpy_array(A)
  450. for i in range(len(g.nodes)):
  451. g.nodes[i]['lobule'] = lobule_mapping[i]
  452. g.nodes[i]['lobulenr'] = list(lobule_mapping.keys())[i]
  453. g.nodes[i]['color'] = collabels[i]
  454. return g
  457. # List of adjacency matrices
  459. threshold = 0.5
  460. adj_matrix_group1 = np.where(np.abs(corr_matrix_group1) > threshold, corr_matrix_group1, 0)
  461. adj_matrix_group2 = np.where(np.abs(corr_matrix_group2) > threshold, corr_matrix_group2, 0)
  462. adj_matrix_group3 = np.where(np.abs(corr_matrix_group3) > threshold, corr_matrix_group3, 0)
  464. adj_matrices = [adj_matrix_group1, adj_matrix_group2, adj_matrix_group3]
  465. titles = ["Control", "PCD", "SCA"]
  467. # Create the plot
  468. fig, axes = plt.subplots(1, 3, figsize=(15, 5))
  470. for idx, (adj_matrix, ax) in enumerate(zip(adj_matrices, axes)):
  471. g = create_graph(adj_matrix, lobule_mapping, collabels)
  473. # Get node colors directly from the graph
  474. node_colors = [color_dict[g.nodes[n]['color']] for n in g.nodes()]
  476. nx.draw_networkx(
  477. g,
  478. pos=coords_2d,
  479. labels=nx.get_node_attributes(g, 'lobulenr'),
  480. node_size=200,
  481. node_color=node_colors,
  482. with_labels=True,
  483. font_weight='bold',
  484. font_size=6,
  485. width=0.6,
  486. ax=ax
  487. )
  488. ax.set_title(titles[idx])
  489. ax.axis('off')
  491. # Create the main legend for posterior and anterior
  492. legend_tiles = [
  493. mpatches.Patch(color="#aff8df", label="posterior"),
  494. mpatches.Patch(color="#ffcbc1", label="anterior"),
  495. ]
  497. # Add the main legend to the first subplot
  498. axes[0].legend(handles=legend_tiles, loc="lower right")
  500. # Create the lobule legend
  501. lobule_legend_labels = [f"{key}: {value}" for key, value in lobule_mapping.items()]
  502. lobule_legend_patches = [mpatches.Patch(color='white', label=label) for label in lobule_legend_labels]
  504. # Add the lobule legend outside the plot
  505. fig.legend(handles=lobule_legend_patches, loc="upper left", bbox_to_anchor=(1, 0.95), fontsize=9)
  507. # Adjust layout to fit legends
  508. plt.tight_layout()
  509. plt.savefig('../results/network_graph.svg', bbox_inches='tight', dpi=300)
  510. plt.savefig('../results/network_graph.png', bbox_inches='tight', dpi=600)
  511. plt.show()
  513. # %%
  514. g1 = create_graph(adj_matrix_group1, lobule_mapping, collabels)
  515. g2 = create_graph(adj_matrix_group2, lobule_mapping, collabels)
  516. g3 = create_graph(adj_matrix_group3, lobule_mapping, collabels)
  518. # %%
  519. def calculate_graph_metrics(g):
  520. metrics = {}
  522. # Number of nodes and edges
  523. metrics['num_nodes'] = g.number_of_nodes()
  524. metrics['num_edges'] = g.number_of_edges()
  526. # Check if the graph is connected
  527. metrics['is_connected'] = nx.is_connected(g)
  528. metrics['num_components'] = nx.number_connected_components(g)
  530. # Global clustering coefficient
  531. metrics['global_clustering_coefficient'] = nx.average_clustering(g)
  533. # Global efficiency
  534. metrics['global_efficiency'] = nx.global_efficiency(g)
  536. # Small-worldness (if connected)
  537. if metrics['is_connected']:
  538. C = nx.average_clustering(g)
  539. L = nx.average_shortest_path_length(g)
  540. n = g.number_of_nodes()
  541. k = 2 * g.number_of_edges() / n
  542. C_rand = k / n
  543. L_rand = np.log(n) / np.log(k)
  544. metrics['small_worldness'] = (C / C_rand) / (L / L_rand)
  545. else:
  546. metrics['small_worldness'] = "Not applicable (disconnected graph)"
  548. # Node-level metrics
  549. metrics['node_strength'] = dict(g.degree(weight='weight'))
  550. metrics['betweenness_centrality'] = nx.betweenness_centrality(g)
  551. metrics['clustering_coefficient'] = nx.clustering(g)
  553. # Average shortest path length (for each component)
  554. component_path_lengths = []
  555. for component in nx.connected_components(g):
  556. subgraph = g.subgraph(component)
  557. if len(subgraph) > 1:
  558. component_path_lengths.append(nx.average_shortest_path_length(subgraph))
  559. metrics['avg_shortest_path_length'] = component_path_lengths
  561. # Participation coefficient (if the graph has communities)
  562. try:
  563. communities = list(nx.community.greedy_modularity_communities(g))
  564. metrics['participation_coefficient'] = nx.algorithms.participation_coefficient(g, communities)
  565. except:
  566. metrics['participation_coefficient'] = "Not calculated (requires community structure)"
  568. return metrics
  570. # Example usage
  571. # Assuming g is your NetworkX graph
  572. # g = nx.Graph() # Replace this with your actual graph
  574. # Calculate metrics
  575. metrics = calculate_graph_metrics(g)
  577. # Print results
  578. for metric, value in metrics.items():
  579. print(f"{metric}: {value}")
  582. # %%
  583. # Calculate metrics
  584. metrics1 = calculate_graph_metrics(g1)
  585. metrics2 = calculate_graph_metrics(g2)
  586. metrics3 = calculate_graph_metrics(g3)
  588. # %%
  589. def create_boxplot(data1, data2, data3, title, ax, name):
  590. df = pd.DataFrame({
  591. 'Control': data1,
  592. 'PCD': data2,
  593. 'SCA': data3
  594. })
  595. df_melted = df.melt(var_name='Group', value_name=name)
  597. custom_palette = {'PCD': 'cornflowerblue', 'Control': 'turquoise', 'SCA': 'orange'}
  598. sns.boxplot(
  599. x='Group', y=name, data=df_melted, palette=custom_palette, ax=ax,
  600. width=0.5, fliersize=0, linewidth=1.0, saturation=0.45,
  601. )
  602. sns.stripplot(
  603. x='Group', y=name, data=df_melted, palette=custom_palette, ax=ax,
  604. size=4.5, jitter=0.12, edgecolor='black', linewidth=0.4, alpha=0.9,
  605. )
  607. _, p12 = stats.ttest_ind(data1, data2, equal_var=False)
  608. _, p13 = stats.ttest_ind(data1, data3, equal_var=False)
  609. _, p23 = stats.ttest_ind(data2, data3, equal_var=False)
  611. y_max = df_melted[name].max()
  612. add_significance_bar(0, 1, y_max*1.05, p12, ax)
  613. add_significance_bar(1, 2, y_max*1.15, p23, ax)
  614. add_significance_bar(0, 2, y_max*1.25, p13, ax)
  616. ax.set_title(title, fontsize=14)
  617. ax.set_xlabel(None)
  618. ax.set_ylabel(None)
  619. ax.set_ylim(0, y_max*1.4)
  621. def format_pvalue(p_value):
  622. if p_value < 0.001:
  623. return "p < 0.001"
  624. elif p_value < 0.01:
  625. return f"p = {p_value:.3f}"
  626. else:
  627. return f"p = {p_value:.2f}"
  629. def add_significance_bar(start, end, height, p_value, ax):
  630. x1, x2 = start, end
  631. y, h = height, height * 0.05
  632. ax.plot([x1, x1, x2, x2], [y, y+h, y+h, y], lw=1.5, c='black')
  633. ax.text((x1+x2)*.5, y+h, format_pvalue(p_value), ha='center', va='bottom', fontsize=10)
  635. # Function to filter nodes based on color
  636. def filter_nodes(g, metrics, color, metric):
  637. return [metrics[metric][n] for n in g.nodes() if g.nodes[n]['color'] == color]
  640. # %%
  641. import seaborn as sns
  643. metric_to_plot = 'node_strength'
  645. # Create the main figure
  646. fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 4))
  647. plt.subplots_adjust(wspace=0.08)
  649. # All nodes
  650. create_boxplot(
  651. list(metrics1[metric_to_plot].values()),
  652. list(metrics2[metric_to_plot].values()),
  653. list(metrics3[metric_to_plot].values()),
  654. 'All Nodes', ax1, 'Node Strength'
  655. )
  657. # Anterior nodes
  658. create_boxplot(
  659. filter_nodes(g1, metrics1, 'anterior', metric_to_plot),
  660. filter_nodes(g2, metrics2, 'anterior', metric_to_plot),
  661. filter_nodes(g3, metrics3, 'anterior', metric_to_plot),
  662. 'Anterior Nodes', ax2, 'Node Strength'
  663. )
  665. # Posterior nodes
  666. create_boxplot(
  667. filter_nodes(g1, metrics1, 'posterior', metric_to_plot),
  668. filter_nodes(g2, metrics2, 'posterior', metric_to_plot),
  669. filter_nodes(g3, metrics3, 'posterior', metric_to_plot),
  670. 'Posterior Nodes', ax3, 'Node Strength'
  671. )
  673. # Share a single y-axis across all subplots, displayed on the far right only
  674. global_ymax = max(ax.get_ylim()[1] for ax in (ax1, ax2, ax3))
  675. for ax in (ax1, ax2, ax3):
  676. ax.set_ylim(0, global_ymax)
  677. ax.spines['top'].set_visible(False)
  679. for ax in (ax1, ax2):
  680. ax.spines['left'].set_visible(False)
  681. ax.spines['right'].set_visible(False)
  682. ax.tick_params(axis='y', which='both', left=False, right=False, labelleft=False)
  683. ax.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
  685. ax3.spines['left'].set_visible(False)
  686. ax3.spines['right'].set_visible(True)
  687. ax3.yaxis.tick_right()
  688. ax3.yaxis.set_label_position('right')
  689. ax3.set_ylabel('Node Strength', fontsize=14, labelpad=8)
  691. plt.tight_layout()
  692. plt.savefig('../results/node_strength.svg', bbox_inches='tight', dpi=300)
  693. plt.savefig('../results/node_strength.png', bbox_inches='tight', dpi=600)
  694. plt.show()
  697. # %%
  698. metric_to_plot = 'betweenness_centrality'
  700. fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 4))
  701. plt.subplots_adjust(wspace=0.08)
  703. def normalize(x):
  704. return (x - np.min(x)) / (np.max(x) - np.min(x))
  706. create_boxplot(
  707. np.log1p(list(metrics1[metric_to_plot].values())),
  708. np.log1p(list(metrics2[metric_to_plot].values())),
  709. np.log1p(list(metrics3[metric_to_plot].values())),
  710. 'All Nodes', ax1, 'Log Betweenness Centrality'
  711. )
  713. create_boxplot(
  714. np.log1p(filter_nodes(g1, metrics1, 'anterior', metric_to_plot)),
  715. np.log1p(filter_nodes(g2, metrics2, 'anterior', metric_to_plot)),
  716. np.log1p(filter_nodes(g3, metrics3, 'anterior', metric_to_plot)),
  717. 'Anterior Nodes', ax2, 'Log Betweenness Centrality'
  718. )
  720. create_boxplot(
  721. np.log1p(filter_nodes(g1, metrics1, 'posterior', metric_to_plot)),
  722. np.log1p(filter_nodes(g2, metrics2, 'posterior', metric_to_plot)),
  723. np.log1p(filter_nodes(g3, metrics3, 'posterior', metric_to_plot)),
  724. 'Posterior Nodes', ax3, 'Log Betweenness Centrality'
  725. )
  727. # Share a single y-axis across all subplots, displayed on the far right only
  728. global_ymax = max(ax.get_ylim()[1] for ax in (ax1, ax2, ax3))
  729. for ax in (ax1, ax2, ax3):
  730. ax.set_ylim(0, global_ymax)
  731. ax.spines['top'].set_visible(False)
  733. for ax in (ax1, ax2):
  734. ax.spines['left'].set_visible(False)
  735. ax.spines['right'].set_visible(False)
  736. ax.tick_params(axis='y', which='both', left=False, right=False, labelleft=False)
  737. ax.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
  739. ax3.spines['left'].set_visible(False)
  740. ax3.spines['right'].set_visible(True)
  741. ax3.yaxis.tick_right()
  742. ax3.yaxis.set_label_position('right')
  743. ax3.set_ylabel('Log Betweenness Centrality', fontsize=14, labelpad=8)
  745. plt.tight_layout()
  746. plt.savefig('../results/betweenness_centrality.svg', bbox_inches='tight', dpi=300)
  747. plt.savefig('../results/betweenness_centrality.png', bbox_inches='tight', dpi=600)
  748. plt.show()
  751. # %%
  752. metric_to_plot = 'clustering_coefficient'
  754. fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 4))
  755. plt.subplots_adjust(wspace=0.08)
  757. create_boxplot(
  758. list(metrics1[metric_to_plot].values()),
  759. list(metrics2[metric_to_plot].values()),
  760. list(metrics3[metric_to_plot].values()),
  761. 'All Nodes', ax1, 'Clustering Coefficient'
  762. )
  764. create_boxplot(
  765. filter_nodes(g1, metrics1, 'anterior', metric_to_plot),
  766. filter_nodes(g2, metrics2, 'anterior', metric_to_plot),
  767. filter_nodes(g3, metrics3, 'anterior', metric_to_plot),
  768. 'Anterior Nodes', ax2, 'Clustering Coefficient'
  769. )
  771. create_boxplot(
  772. filter_nodes(g1, metrics1, 'posterior', metric_to_plot),
  773. filter_nodes(g2, metrics2, 'posterior', metric_to_plot),
  774. filter_nodes(g3, metrics3, 'posterior', metric_to_plot),
  775. 'Posterior Nodes', ax3, 'Clustering Coefficient'
  776. )
  778. # Share a single y-axis across all subplots, displayed on the far right only
  779. global_ymax = max(ax.get_ylim()[1] for ax in (ax1, ax2, ax3))
  780. for ax in (ax1, ax2, ax3):
  781. ax.set_ylim(0, global_ymax)
  782. ax.spines['top'].set_visible(False)
  784. for ax in (ax1, ax2):
  785. ax.spines['left'].set_visible(False)
  786. ax.spines['right'].set_visible(False)
  787. ax.tick_params(axis='y', which='both', left=False, right=False, labelleft=False)
  788. ax.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
  790. ax3.spines['left'].set_visible(False)
  791. ax3.spines['right'].set_visible(True)
  792. ax3.yaxis.tick_right()
  793. ax3.yaxis.set_label_position('right')
  794. ax3.set_ylabel('Clustering Coefficient', fontsize=14, labelpad=8)
  796. plt.tight_layout()
  797. plt.savefig('../results/clustering_coefficient.svg', bbox_inches='tight', dpi=300)
  798. plt.savefig('../results/clustering_coefficient.png', bbox_inches='tight', dpi=600)
  799. plt.show()
  802. # %%
  803. def create_barplot(data1, data2, data3, title, ax, name):
  804. df = pd.DataFrame({
  805. 'Control': [data1],
  806. 'PCD': [data2],
  807. 'SCA': [data3]
  808. })
  809. df_melted = df.melt(var_name='Group', value_name=name)
  811. custom_palette = {'PCD': 'cornflowerblue', 'Control': 'turquoise', 'SCA': 'orange'}
  812. sns.barplot(
  813. x='Group', y=name, data=df_melted, palette=custom_palette, ax=ax,
  814. width=0.5, saturation=0.6,
  815. )
  817. ax.set_title(title, fontsize=14)
  818. ax.set_xlabel(None)
  819. ax.set_ylabel(None)
  820. ax.spines['top'].set_visible(False)
  821. ax.spines['right'].set_visible(False)
  824. fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 4))
  825. plt.subplots_adjust(wspace=0.35)
  827. metric_to_plot = 'num_edges'
  829. create_barplot(
  830. metrics1[metric_to_plot],
  831. metrics2[metric_to_plot],
  832. metrics3[metric_to_plot],
  833. 'Number of edges', ax1, 'Number of edges'
  834. )
  836. metric_to_plot = 'global_clustering_coefficient'
  840. create_barplot(
  841. metrics1[metric_to_plot],
  842. metrics2[metric_to_plot],
  843. metrics3[metric_to_plot],
  844. 'Global clustering coefficient', ax2, 'Global clustering coefficient'
  845. )
  847. metric_to_plot = 'global_efficiency'
  849. create_barplot(
  850. metrics1[metric_to_plot],
  851. metrics2[metric_to_plot],
  852. metrics3[metric_to_plot],
  853. 'Global efficiency', ax3, 'Global efficiency'
  854. )
  856. # Show x-axis group labels only on the rightmost subplot; keep all y-axes (different scales)
  857. for ax in (ax1, ax2):
  858. ax.tick_params(axis='x', which='both', bottom=False, labelbottom=False)
  860. plt.tight_layout()
  861. plt.savefig('../results/edges_clustering_coefficient_global_efficiency.svg', bbox_inches='tight', dpi=300)
  862. plt.savefig('../results/edges_clustering_coefficient_global_efficiency.png', bbox_inches='tight', dpi=600)
  863. plt.show()
  865. # %% [markdown]
  866. # ### Other
  868. # %%
  869. # ──────────────────────────────────────────────────────────────
  870. # SENSITIVITY ANALYSIS: effect of correlation threshold on
  871. # key network metrics (Reviewer Major Point 3)
  872. # ──────────────────────────────────────────────────────────────
  873. sensitivity_thresholds = [0.3, 0.4, 0.5, 0.6, 0.7]
  875. sensitivity_rows = []
  877. for thr in sensitivity_thresholds:
  878. adj_g1 = np.where(np.abs(corr_matrix_group1) > thr, corr_matrix_group1, 0)
  879. adj_g2 = np.where(np.abs(corr_matrix_group2) > thr, corr_matrix_group2, 0)
  880. adj_g3 = np.where(np.abs(corr_matrix_group3) > thr, corr_matrix_group3, 0)
  882. np.fill_diagonal(adj_g1, 0)
  883. np.fill_diagonal(adj_g2, 0)
  884. np.fill_diagonal(adj_g3, 0)
  886. _g1 = nx.from_numpy_array(adj_g1)
  887. _g2 = nx.from_numpy_array(adj_g2)
  888. _g3 = nx.from_numpy_array(adj_g3)
  890. for label, _g in [('Control', _g1), ('PCD', _g2), ('SCA1', _g3)]:
  891. n = _g.number_of_nodes()
  892. sensitivity_rows.append({
  893. 'Threshold': thr,
  894. 'Group': label,
  895. 'Edge Count': _g.number_of_edges(),
  896. 'Density': nx.density(_g),
  897. 'Global Clustering': nx.average_clustering(_g),
  898. 'Global Efficiency': nx.global_efficiency(_g),
  899. 'Avg Node Strength': sum(dict(_g.degree(weight='weight')).values()) / n,
  900. 'Avg Betweenness Centrality': float(np.mean(list(nx.betweenness_centrality(_g).values()))),
  901. })
  903. sensitivity_df = pd.DataFrame(sensitivity_rows)
  905. print("=== Sensitivity Analysis: Network Metrics Across Thresholds ===\n")
  906. for thr in sensitivity_thresholds:
  907. sub = sensitivity_df[sensitivity_df['Threshold'] == thr]
  908. print(f"\n--- Threshold |r| > {thr} ---")
  909. print(sub.to_string(index=False))
  910. print()
  912. sensitivity_df.to_csv('../results/sensitivity_threshold_analysis.csv', index=False)
  913. print("\nSaved to ../results/sensitivity_threshold_analysis.csv")
  915. # %%
  916. # ──────────────────────────────────────────────────────────────
  917. # PROPORTIONAL THRESHOLDING (Reviewer Major Point 3 supplement)
  918. # Keep the top X% strongest edges, compare with absolute thresholds.
  919. # ──────────────────────────────────────────────────────────────
  920. density_targets = [0.10, 0.20, 0.30, 0.40, 0.50]
  922. prop_rows = []
  923. for group_label, corr_mat in [('Control', corr_matrix_group1),
  924. ('PCD', corr_matrix_group2),
  925. ('SCA1', corr_matrix_group3)]:
  926. n = corr_mat.shape[0]
  927. upper = np.abs(corr_mat[np.triu_indices(n, k=1)])
  928. for target_density in density_targets:
  929. n_edges_target = int(target_density * len(upper))
  930. if n_edges_target == 0:
  931. continue
  932. sorted_vals = np.sort(upper)[::-1]
  933. cutoff = sorted_vals[min(n_edges_target - 1, len(sorted_vals) - 1)]
  935. adj = np.where(np.abs(corr_mat) >= cutoff, corr_mat, 0)
  936. np.fill_diagonal(adj, 0)
  937. g = nx.from_numpy_array(adj)
  939. prop_rows.append({
  940. 'Group': group_label,
  941. 'Target Density': target_density,
  942. 'Actual Density': nx.density(g),
  943. 'Edge Count': g.number_of_edges(),
  944. 'Global Clustering': nx.average_clustering(g),
  945. 'Global Efficiency': nx.global_efficiency(g),
  946. 'Avg Node Strength': sum(dict(g.degree(weight='weight')).values()) / n,
  947. })
  949. prop_df = pd.DataFrame(prop_rows)
  950. print("=== Proportional Thresholding: Network Metrics ===\n")
  951. for grp in ['Control', 'PCD', 'SCA1']:
  952. sub = prop_df[prop_df['Group'] == grp]
  953. print(f"\n--- {grp} ---")
  954. print(sub.to_string(index=False))
  956. prop_df.to_csv('../results/proportional_threshold_analysis.csv', index=False)
  957. print("\nSaved to ../results/proportional_threshold_analysis.csv")
  959. # %%
  960. # threshold sensitivity
  961. import seaborn as sns
  963. sens = pd.read_csv('../results/sensitivity_threshold_analysis.csv')
  965. custom_palette = {'PCD': 'cornflowerblue',
  966. 'Control': 'turquoise',
  967. 'SCA1': 'orange'}
  969. non_metric_cols = {'Threshold', 'Group'}
  970. metrics = [(col, col) for col in sens.columns if col not in non_metric_cols]
  972. n_metrics = len(metrics)
  973. ncols = 6
  974. nrows = int(np.ceil(n_metrics / ncols))
  976. fig, axes = plt.subplots(nrows, ncols, figsize=(2.8 * ncols, 3.0 * nrows), sharex=True)
  977. axes_flat = axes.ravel() if nrows > 1 else axes
  979. for ax, (col, label) in zip(axes_flat, metrics):
  980. for group, color in custom_palette.items():
  981. sub = sens[sens['Group'] == group].sort_values('Threshold')
  982. ax.plot(sub['Threshold'], sub[col], marker='o', markersize=5,
  983. linewidth=1.6, color=color, label=group)
  984. ax.axvline(0.5, color='gray', linestyle='--', lw=1, alpha=0.7)
  985. ax.set_ylabel(label)
  986. ax.grid(True, axis='y', alpha=0.25)
  987. ax.spines['top'].set_visible(False)
  988. ax.spines['right'].set_visible(False)
  990. for ax in axes_flat[n_metrics:]:
  991. ax.set_visible(False)
  993. axes_flat[0].set_xlabel('|r| threshold')
  995. axes_flat[0].legend(loc='best', fontsize=9, frameon=False)
  996. plt.tight_layout()
  997. plt.savefig('../results/sensitivity_threshold.svg', bbox_inches='tight', dpi=300)
  998. plt.savefig('../results/sensitivity_threshold.png', bbox_inches='tight', dpi=600)
  999. plt.show()
  1002. # %%
  1003. def compute_network_metrics(g):
  1004. node_count = len(g.nodes)
  1005. edge_count = len(g.edges)
  1006. avg_degree = sum(dict(g.degree()).values()) / node_count
  1008. density = nx.density(g)
  1010. clustering_coefficient = nx.average_clustering(g)
  1012. if nx.is_connected(g):
  1013. avg_path_length = nx.average_shortest_path_length(g)
  1014. else:
  1015. avg_path_length = float('inf') # If the graph is not connected
  1018. assortativity = nx.degree_assortativity_coefficient(g)
  1020. if nx.is_connected(g):
  1021. diameter = nx.diameter(g)
  1022. else:
  1023. diameter = float('inf') # If the graph is not connected
  1025. avg_node_strength = sum(dict(g.degree(weight='weight')).values()) / node_count
  1027. return {
  1028. 'Edge Count': edge_count,
  1029. 'Average Degree': avg_degree,
  1030. 'Density': density,
  1031. 'Clustering Coefficient': clustering_coefficient,
  1032. 'Average Path Length': avg_path_length,
  1033. 'Assortativity': assortativity,
  1034. 'Diameter': diameter,
  1035. 'Average Node Strength': avg_node_strength
  1036. }
  1038. control_metrics = compute_network_metrics(g1)
  1039. anti_yo_pcd_metrics = compute_network_metrics(g2)
  1040. sca_metrics = compute_network_metrics(g3)
  1043. # %%
  1044. metrics_dict = {
  1045. 'Control': control_metrics,
  1046. 'Anti-yo PCD': anti_yo_pcd_metrics,
  1047. 'SCA': sca_metrics
  1048. }
  1050. df = pd.DataFrame.from_dict(metrics_dict, orient='index')
  1052. # Convert the DataFrame to LaTeX format
  1053. latex_output = df.to_latex(index=True, float_format="%.2f")
  1055. # Display or save the LaTeX output
  1056. print(latex_output)
  1058. with open("../results/network_results.tex", "w") as f:
  1059. f.write(latex_output)

network_analysis.ipynb at commit 6b7297b, no license · at the source

Overview

Authors: Tamara Künzle1, Lucas Rincon de la Rosa1, Clément Vialatte de Pémille2,3, Alice Leprince-Laurenge1,4, Alberto Picca1,4, Giulia Coarelli1,4, Delphine Leclercq1,5, Alexandra Dürr6, Dimitri Psimaras1,4, Agusti Alentorn1,4
ORCID iDs: Agusti Alentorn
  1. ICM, INSERM U 1127, CNRS UMR 7225, UMRS 1127, Paris Brain Institute, Sorbonne University, Paris, France
  2. Neurological Department, Groupe Hospitalier Paris Saint-Joseph, Paris, France
  3. Université Paris Cité, Paris, France
  4. Charles Foix, DMU Neurosciences, Service de Neuro-Oncologie-Institut de Neurologie, AP-HP, Hôpitaux Universitaires La Pitié Salpêtrière, Paris, France
  5. Department of Neuroradiology, APHP, La Pitié-Salpêtrière Hospital, Sorbonne University, F-75013 Paris, France
  6. APHP-Salpêtrière Hospital, DMU BioGem, CNRS, INSERM, Paris Brain Institute, Sorbonne University, Paris, France
Institutions: Centre National de la Recherche Scientifique (France); Inserm (France); Sorbonne Université (France); Institut du Cerveau (France); Université Paris Cité (France); Hôpital Paris Saint-Joseph (France); Assistance Publique – Hôpitaux de Paris (France); Pitié-Salpêtrière Hospital (France)
Journal: Journal of neurology, volume 273, issue 8, article 493
Dates: received 1 March 2026; accepted 13 May 2026; published online 27 July 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1007/s00415-026-13884-0 · PMID 42509533 · PMCID PMC13407450 · OpenAlex W7171430825
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), other condition (population), clinical / translational (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, Machine learning, Preprocessing, Graphs
Keywords: Neurological paraneoplastic syndrome, Cerebellar ataxia, Cerebellar atrophy, Cortical thickness and connectivity
MeSH: Cerebellum*, Nerve Net*, Ovarian Neoplasms*, Paraneoplastic Cerebellar Degeneration*, Spinocerebellar Ataxias*, Adult, Aged, Ataxin-1, Atrophy, Autoantibodies, Female, Humans, Magnetic Resonance Imaging, Middle Aged (* major topic)
Topic: Autoimmune Neurological Disorders and Treatments (Neurology, Medicine), according to OpenAlex
Funding: Agence Nationale de la Recherche (2025-PEPR-121554, ANR-23-CE17-0027); Institut National Du Cancer (MultiPOLA-OSIRIS25)
Citations: not cited yet (Europe PMC); 44 references in the paper

Abstract

Background: Anti-Yo paraneoplastic cerebellar degeneration (PCD) is a rare autoimmune disorder linked to ovarian and breast cancers. Neurological symptoms often precede cancer diagnosis, yet conventional imaging techniques may fail to detect early cerebellar changes. This study quantitatively assessed cerebellar atrophy and network alterations in anti-Yo PCD patients compared to healthy controls and patients with spinocerebellar ataxia type 1 (SCA1).

Methods: We analyzed structural MRI data from 11 antiYo PCD patients, 17 healthy controls, and 17 SCA1 patients. Cerebellar lobular segmentation and cortical thickness measurements were conducted. Structural covariance networks were built using inter-lobular Pearson correlation coefficients (threshold |r| > 0.5), with graph theory metrics assessing connectivity. Univariate and age-adjusted multivariate analyses evaluated group differences, and machine learning assessed the discriminative power of regional morphometric measures.

Results: AntiYo PCD patients showed pronounced anterior cortical thinning, while SCA1 atrophy was milder and more posterior. Two PCD subtypes emerged: one with severe atrophy, another with nearnormal thickness. Network analysis revealed increased node strength and clustering coefficients, but reduced betweenness centrality in PCD, suggesting altered network hierarchy and widespread clustering that may reflect pathological reorganization. In cross-validated analysis, regional cerebellar features distinguished PCD, SCA1, and controls with promising AUC values.

Conclusions: Anti-Yo PCD is characterized by anterior cerebellar vulnerability and network reorganization distinct from SCA1. These morphometric and connectivity markers are candidate imaging biomarkers for early diagnosis and subgroup stratification in paraneoplastic cerebellar degeneration.

Supplementary Information: The online version contains supplementary material available at 10.1007/s00415-026-13884-0.

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

tamelenak/pcd-spatial-analysis

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6b7297ba30111482bd35ca183a4707d7f10175d4, 6 May 2026
Languages: Jupyter (5), Python (1)
Size: 14 files, 6 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (environment.yml, requirements.txt), 5 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: Matplotlib (5 files), NumPy (5 files), pandas (5 files), scikit-learn (5 files), SciPy (5 files), seaborn (5 files), NiBabel (3 files), Nilearn (3 files), statsmodels (3 files), Plotly (2 files), NetworkX (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/tamelenak/pcd-spatial-analysis

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

Datasets cited

Data availability

The dataset is available under 10.5281/zenodo.16094263. All code used for data analysis and figure generation is available at: https://github.com/tamelenak/pcd-spatial-analysis.

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 2, 28 September 2026

  • Publisher: n/a → Springer Science+Business Media

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 10 authors, 4 keywords, 14 MeSH terms, 2 funders, 27 references.

Cite

This paper

Künzle, T., Rincon de la Rosa, L., Vialatte de Pémille, C., Leprince-Laurenge, A., Picca, A., Coarelli, G., Leclercq, D., Dürr, A., Psimaras, D., & Alentorn, A. (2026). Spatial analysis of paraneoplastic cerebellar degeneration in ovarian cancer with anti-Yo syndrome and SCA1. Journal of neurology, 273(8), 493. https://doi.org/10.1007/s00415-026-13884-0

BibTeX

@article{kunzle2026spatial,
author = {Künzle, Tamara and Rincon de la Rosa, Lucas and Vialatte de Pémille, Clément and Leprince-Laurenge, Alice and Picca, Alberto and Coarelli, Giulia and Leclercq, Delphine and Dürr, Alexandra and Psimaras, Dimitri and Alentorn, Agusti},
title = {{Spatial analysis of paraneoplastic cerebellar degeneration in ovarian cancer with anti-Yo syndrome and SCA1}},
journal = {Journal of neurology},
year = {2026},
month = jul,
volume = {273},
number = {8},
pages = {493},
publisher = {Springer Science+Business Media},
issn = {0340-5354},
doi = {10.1007/s00415-026-13884-0},
url = {https://doi.org/10.1007/s00415-026-13884-0},
pmid = {42509533},
pmcid = {PMC13407450}
}

RIS

TY - JOUR
AU - Künzle, Tamara
AU - Rincon de la Rosa, Lucas
AU - Vialatte de Pémille, Clément
AU - Leprince-Laurenge, Alice
AU - Picca, Alberto
AU - Coarelli, Giulia
AU - Leclercq, Delphine
AU - Dürr, Alexandra
AU - Psimaras, Dimitri
AU - Alentorn, Agusti
TI - Spatial analysis of paraneoplastic cerebellar degeneration in ovarian cancer with anti-Yo syndrome and SCA1
T2 - Journal of neurology
J2 - J Neurol
PY - 2026
DA - 2026/07/27
VL - 273
IS - 8
SP - 493
SN - 0340-5354
PB - Springer Science+Business Media
DO - 10.1007/s00415-026-13884-0
UR - https://doi.org/10.1007/s00415-026-13884-0
LA - en
ER -

CSL-JSON

{
"id": "10.1007/s00415-026-13884-0",
"type": "article-journal",
"title": "Spatial analysis of paraneoplastic cerebellar degeneration in ovarian cancer with anti-Yo syndrome and SCA1",
"container-title": "Journal of neurology",
"author": [
{
"family": "Künzle",
"given": "Tamara"
},
{
"family": "Rincon de la Rosa",
"given": "Lucas"
},
{
"family": "Vialatte de Pémille",
"given": "Clément"
},
{
"family": "Leprince-Laurenge",
"given": "Alice"
},
{
"family": "Picca",
"given": "Alberto"
},
{
"family": "Coarelli",
"given": "Giulia"
},
{
"family": "Leclercq",
"given": "Delphine"
},
{
"family": "Dürr",
"given": "Alexandra"
},
{
"family": "Psimaras",
"given": "Dimitri"
},
{
"family": "Alentorn",
"given": "Agusti"
}
],
"container-title-short": "J Neurol",
"volume": "273",
"issue": "8",
"page": "493",
"DOI": "10.1007/s00415-026-13884-0",
"PMID": "42509533",
"PMCID": "PMC13407450",
"ISSN": "0340-5354",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1007/s00415-026-13884-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
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.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: Nilearn, Plotly, NiBabel, 7 other tools, structural MRI / diffusion, 1 reference
[2] doi:10.1073/pnas.2531706123 [code]
Metabolism-weighted brain connectome reveals synaptic integration and vulnerability to neurodegeneration.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: Nilearn, NetworkX, Plotly, 8 other tools, other condition
[3] doi:10.1038/s41467-026-71428-6 [code]
Binding items to contexts through conjunctive neural representations with the method of loci.
Journal: Nature communications
In common: Nilearn, Plotly, NiBabel, 7 other tools, 1 reference
[4] doi:10.1162/imag.a.1276 [code]
High-resolution whole-brain magnetic resonance spectroscopic imaging in youth at risk for psychosis.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, NetworkX, Plotly, 7 other tools, clinical / translational
[5] doi:10.1162/imag.a.1164 [code]
Bias and generalizability of brain age prediction models: A multi-cohort evaluation with anatomical and interpretability insights.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Nilearn, Plotly, NiBabel, 7 other tools, structural MRI / diffusion
[6] 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: Nilearn, NetworkX, Plotly, 7 other tools
[7] doi:10.1038/s41398-026-04157-5 [code]
Association of glymphatic function with 40-Hz neural oscillations, systemic metabolic markers, and cognitive performance in healthy aging adults: An EEG and MRI study.
Journal: Translational psychiatry
In common: Nilearn, NetworkX, NiBabel, 6 other tools, structural MRI / diffusion, clinical / translational
[8] doi:10.1212/wnl.0000000000218472 [code]
Lesion-Level Subtypes of White Matter Hyperintensity Evolution Beyond Spatial Location.
Journal: Neurology
In common: Nilearn, Plotly, NiBabel, 6 other tools, structural MRI / diffusion, clinical / translational
[9] doi:10.1038/s41467-026-72931-6 [code]
Three parsimonious spatiotemporal patterns in cerebellum reveal individual traits in function and behavior.
Journal: Nature communications
In common: Nilearn, NiBabel, statsmodels, 6 other tools, 1 reference
[10] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: Nilearn, NetworkX, NiBabel, 7 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.