Fine-scale individualized gyral folding-based cortical similarity networks reveal distinct organizational patterns in Alzheimer's disease and Lewy body dementia.

Code ↔ Paper

9 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 9 matches

[1] § Methods › Cortical thickness-constrained arealization ↔ src/landmark_mind_from_vtk_mdkde_adaptive.py, lines 1–42 · score 0.91 · Newly added vertices, morphological closing, post processing, geodesic distance, propagation, components
[2] § Methods › Cortical thickness-constrained arealization ↔ src/landmark_mind_from_vtk_mdkde_adaptive.py, lines 1–42 · score 0.80 · multiple gating, geodesic distance, multiple seeds, reachable, Smaller, propagation
[3] § Methods › Network metrics › Controlling for network size ↔ src/compare_node_number_effect_full.py, lines 4–56 · score 0.65 · clustering coefficient, topological metrics, global efficiency, sex, age, covariate
[4] § Results › Group differences in graph theoretical metrics ↔ src/compare_node_number_effect_full.py, lines 4–56 · score 0.63 · small worldness, degree assortativity, global efficiency, GLM, transitivity, clustering
[5] § Results › Classification performance of topology and node-count features ↔ src/classification_nestedcv_residN.py, lines 1–32 · score 0.61 · ROC curves, linear SVM, topology residualized, classification, nested
[6] § Methods › Network metrics › Distribution-level metrics ↔ src/compare_node_number_effect_full.py, lines 58–97 · score 0.60 · nodal efficiency inequality, degree hubness ratio, Gini, coefficient, node
[7] § Results › Group differences in graph theoretical metrics ↔ src/compare_node_number_effect_full.py, lines 58–97 · score 0.57 · nodal efficiency inequality, degree hubness ratio, degree inequality, node, graph
[8] § Methods › Landmark-based cortical similarity network construction ↔ src/compare_node_number_effect_full.py, lines 145–221 · score 0.55 · minimum spanning tree, MST, weighted, thresholding, edges, matrix
[9] § Results › Classification performance of topology and node-count features ↔ src/classification_nestedcv_residN.py, lines 477–552 · score 0.54 · residualized topological, bootstrap, inner, CI, outer, permutation

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 paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 842 lines · 26 KB · MIT · 5 matches

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Compare GLM results with and without node-number adjustment
for both:
1) global topology metrics
2) local-distribution summary metrics
Main outputs:
- global_metrics_per_subject.tsv
- local_metrics_per_subject.tsv
- global_glm_compare_node.tsv
- local_glm_compare_node.tsv
- combined_glm_compare_node.tsv
- combined_glm_compare_node_pretty.tsv
Example:
python compare_node_number_effect_full.py \
--in-npy all_subjects.npy \
--outdir compare_node_effect_out \
--threshold-mode mst_top \
--top-percent 10 \
--covar-file covars.tsv \
--covar-cols tiv
Notes:
- labels: 2=AD, 3=LBD
- GLM coding: dx_AD = 1 for AD, 0 for LBD
- Default base covariates: age + sex
- Optional extra covariates from covar file, e.g. TIV
- density is included by default in GLM comparison to match graph-level adjustment
- Node-number effect is specifically compared by adding/removing N
"""
import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import networkx as nx
LABEL_NAME = {0: "NC", 1: "MCI", 2: "AD", 3: "LBD"}
PRETTY_LABELS = {
# ---- global ----
"global_efficiency": "Global efficiency",
"char_path_length": "Characteristic path length",
"clustering": "Average clustering coefficient",
"transitivity": "Transitivity",
"modularity": "Modularity",
"assortativity": "Degree assortativity",
"smallworld_sigma": "Small-worldness (σ)",
"richclub_mean": "Rich-club coefficient (mean)",
"richclub_max": "Rich-club coefficient (max)",
"local_eff_mean": "Local efficiency (mean across nodes)",
"local_eff_std": "Local efficiency (SD across nodes)",
# ---- local summary ----
"eff_mean": "Nodal efficiency (mean)",
"eff_std": "Nodal efficiency (SD)",
"eff_q10": "Nodal efficiency (10th percentile)",
"eff_q50": "Nodal efficiency (median)",
"eff_q90": "Nodal efficiency (90th percentile)",
"eff_gini": "Nodal efficiency inequality (Gini)",
"eff_top10_mean": "Nodal efficiency (top 10% mean)",
"clust_mean": "Clustering coefficient (mean)",
"clust_std": "Clustering coefficient (SD)",
"clust_q10": "Clustering coefficient (10th percentile)",
"clust_q50": "Clustering coefficient (median)",
"clust_q90": "Clustering coefficient (90th percentile)",
"clust_gini": "Clustering inequality (Gini)",
"clust_top10_mean": "Clustering (top 10% mean)",
"btw_mean": "Betweenness centrality (mean)",
"btw_std": "Betweenness centrality (SD)",
"btw_q10": "Betweenness centrality (10th percentile)",
"btw_q50": "Betweenness centrality (median)",
"btw_q90": "Betweenness centrality (90th percentile)",
"btw_gini": "Betweenness inequality (Gini)",
"btw_top10_mean": "Betweenness (top 10% mean)",
"deg_mean": "Degree (mean)",
"deg_std": "Degree (SD)",
"deg_q10": "Degree (10th percentile)",
"deg_q50": "Degree (median)",
"deg_q90": "Degree (90th percentile)",
"deg_gini": "Degree inequality (Gini)",
"deg_top10_mean": "Degree (top 10% mean)",
"deg_top10_mean_ratio": "Degree hubness ratio (top 10% / mean)",
# ---- generic ----
"density": "Graph density",
"N": "Number of nodes",
"E": "Number of edges",
"avg_degree": "Average degree",
}
# =========================================================
# Utils
# =========================================================
def _safe_float(x):
try:
if x is None:
return np.nan
v = float(x)
return v if np.isfinite(v) else np.nan
except Exception:
return np.nan
def fmt_num(x, nd=4):
if x is None or not np.isfinite(x):
return "NA"
return f"{x:.{nd}f}"
def fmt_p(x):
if x is None or not np.isfinite(x):
return "NA"
if x < 1e-4:
return "<1e-4"
if x < 1e-3:
return f"{x:.1e}"
return f"{x:.4f}"
def significance_flag(p, q, alpha=0.05):
if not np.isfinite(q):
return "NA"
return "Yes" if q <= alpha else "No"
# =========================================================
# Thresholding
# =========================================================
def _upper_tri_edges(W: np.ndarray):
iu = np.triu_indices(W.shape[0], k=1)
return iu[0], iu[1], W[iu]
def build_graph(W: np.ndarray, mode: str, top_percent: float, abs_thr: float | None) -> nx.Graph:
W = np.asarray(W, dtype=np.float64)
if W.ndim != 2 or W.shape[0] != W.shape[1]:
raise ValueError(f"Matrix must be square, got {W.shape}")
W = (W + W.T) / 2.0
np.fill_diagonal(W, 0.0)
W[~np.isfinite(W)] = 0.0
n = W.shape[0]
G = nx.Graph()
G.add_nodes_from(range(n))
ii, jj, ww = _upper_tri_edges(W)
if mode == "none":
keep = ww > 0
for a, b, w in zip(ii[keep], jj[keep], ww[keep]):
G.add_edge(int(a), int(b), weight=float(w))
return G
if mode == "abs":
if abs_thr is None:
raise ValueError("--abs-thr required for abs mode")
keep = ww >= float(abs_thr)
for a, b, w in zip(ii[keep], jj[keep], ww[keep]):
if w > 0:
G.add_edge(int(a), int(b), weight=float(w))
return G
if top_percent <= 0 or top_percent > 100:
raise ValueError("--top-percent must be in (0,100].")
p = top_percent / 100.0
m_total = ww.size
k_keep = max(int(np.ceil(p * m_total)), 1)
order = np.argsort(-ww)
top_idx = order[:k_keep]
if mode == "top":
for idx in top_idx:
a, b, w = int(ii[idx]), int(jj[idx]), float(ww[idx])
if w > 0:
G.add_edge(a, b, weight=w)
return G
if mode == "mst_top":
H = nx.Graph()
H.add_nodes_from(range(n))
for a, b, w in zip(ii, jj, ww):
if w <= 0:
continue
dist = float(1.0 - w)
H.add_edge(int(a), int(b), dist=dist, sim=float(w))
if H.number_of_edges() == 0:
return G
T = nx.minimum_spanning_tree(H, weight="dist", algorithm="kruskal")
for a, b, data in T.edges(data=True):
G.add_edge(int(a), int(b), weight=float(data.get("sim", 0.0)))
have = set((min(u, v), max(u, v)) for u, v in G.edges())
for idx in top_idx:
a, b = int(ii[idx]), int(jj[idx])
key = (min(a, b), max(a, b))
if key in have:
continue
w = float(ww[idx])
if w <= 0:
continue
G.add_edge(a, b, weight=w)
have.add(key)
return G
raise ValueError(f"Unknown threshold mode: {mode}")
# =========================================================
# Graph helpers
# =========================================================
def largest_connected_subgraph(G: nx.Graph) -> nx.Graph:
if G.number_of_nodes() <= 1:
return G.copy()
if nx.is_connected(G):
return G.copy()
comps = list(nx.connected_components(G))
if not comps:
return G.copy()
lcc = max(comps, key=len)
return G.subgraph(lcc).copy()
def nodal_efficiency(H: nx.Graph) -> np.ndarray:
n = H.number_of_nodes()
if n <= 1:
return np.array([0.0], dtype=np.float64)
nodes = list(H.nodes())
idx = {v: i for i, v in enumerate(nodes)}
eff = np.zeros(n, dtype=np.float64)
for v in nodes:
lengths = nx.single_source_shortest_path_length(H, v)
inv = []
for u, d in lengths.items():
if u == v:
continue
if d > 0:
inv.append(1.0 / float(d))
eff[idx[v]] = float(np.mean(inv)) if inv else 0.0
return eff
def gini(x: np.ndarray) -> float:
x = np.asarray(x, dtype=np.float64)
x = x[np.isfinite(x)]
if x.size == 0:
return np.nan
mn = x.min()
if mn < 0:
x = x - mn
s = x.sum()
if s <= 0:
return 0.0
x = np.sort(x)
n = x.size
i = np.arange(1, n + 1, dtype=np.float64)
return float((2.0 * np.sum(i * x)) / (n * s) - (n + 1.0) / n)
def summarize_distribution(x: np.ndarray, prefix: str, top_frac: float = 0.10) -> dict:
x = np.asarray(x, dtype=np.float64)
x = x[np.isfinite(x)]
if x.size == 0:
return {f"{prefix}_{k}": np.nan for k in ["mean", "std", "q10", "q50", "q90", "gini", "top10_mean"]}
q10, q50, q90 = np.percentile(x, [10, 50, 90])
topk = max(1, int(np.ceil(top_frac * x.size)))
top_mean = float(np.mean(np.sort(x)[-topk:]))
return {
f"{prefix}_mean": float(np.mean(x)),
f"{prefix}_std": float(np.std(x, ddof=0)),
f"{prefix}_q10": float(q10),
f"{prefix}_q50": float(q50),
f"{prefix}_q90": float(q90),
f"{prefix}_gini": float(gini(x)),
f"{prefix}_top10_mean": float(top_mean),
}
# =========================================================
# Global metrics
# =========================================================
def compute_global_metrics(G: nx.Graph, n_random: int = 20, seed: int = 0) -> dict:
n = G.number_of_nodes()
e = G.number_of_edges()
density = (2.0 * e / (n * (n - 1))) if n >= 2 else 0.0
avg_degree = (2.0 * e / n) if n > 0 else 0.0
H = largest_connected_subgraph(G)
n_lcc = H.number_of_nodes()
geff = np.nan
if n_lcc >= 2:
geff = float(nx.global_efficiency(H))
cpl = np.nan
if n_lcc >= 2:
try:
cpl = float(nx.average_shortest_path_length(H))
except Exception:
cpl = np.nan
try:
clust = float(nx.average_clustering(G)) if n >= 2 else np.nan
except Exception:
clust = np.nan
try:
trans = float(nx.transitivity(G)) if n >= 3 else np.nan
except Exception:
trans = np.nan
assort = np.nan
if e > 0 and n >= 3:
try:
assort = float(nx.degree_assortativity_coefficient(G))
except Exception:
assort = np.nan
modularity = np.nan
if e > 0 and n >= 4:
try:
comms = nx.algorithms.community.greedy_modularity_communities(G)
modularity = float(nx.algorithms.community.modularity(G, comms))
except Exception:
modularity = np.nan
leff_mean = np.nan
leff_std = np.nan
if n >= 3:
try:
vals = []
for v in G.nodes():
nbrs = list(G.neighbors(v))
if len(nbrs) < 2:
vals.append(0.0)
continue
sub = G.subgraph(nbrs)
vals.append(nx.global_efficiency(sub))
vals = np.asarray(vals, dtype=np.float64)
leff_mean = float(np.mean(vals))
leff_std = float(np.std(vals, ddof=0))
except Exception:
leff_mean = np.nan
leff_std = np.nan
rc_mean = np.nan
rc_max = np.nan
if e > 0 and n >= 5:
try:
rc = nx.rich_club_coefficient(G, normalized=False, Q=100)
vals = np.array([v for v in rc.values() if np.isfinite(v)], dtype=np.float64)
if vals.size > 0:
rc_mean = float(vals.mean())
rc_max = float(vals.max())
except Exception:
rc_mean = np.nan
rc_max = np.nan
sw_sigma = np.nan
if n_lcc >= 10 and H.number_of_edges() > 0:
try:
C = float(nx.average_clustering(H))
L = float(nx.average_shortest_path_length(H))
rng = np.random.default_rng(seed)
deg_seq = [d for _, d in H.degree()]
Cr, Lr = [], []
for _ in range(n_random):
CM = nx.configuration_model(deg_seq, seed=int(rng.integers(0, 1_000_000)))
R = nx.Graph(CM)
R.remove_edges_from(nx.selfloop_edges(R))
R = largest_connected_subgraph(R)
if R.number_of_nodes() < 10 or R.number_of_edges() == 0:
continue
Cr.append(nx.average_clustering(R))
try:
Lr.append(nx.average_shortest_path_length(R))
except Exception:
continue
if len(Cr) >= max(5, n_random // 3) and len(Lr) >= max(5, n_random // 3):
C_rand = float(np.mean(Cr))
L_rand = float(np.mean(Lr))
if C_rand > 0 and L_rand > 0:
sw_sigma = float((C / C_rand) / (L / L_rand))
except Exception:
sw_sigma = np.nan
return {
"N": int(n),
"E": int(e),
"density": float(density),
"avg_degree": float(avg_degree),
"global_efficiency": geff,
"char_path_length": cpl,
"clustering": clust,
"transitivity": trans,
"modularity": modularity,
"assortativity": assort,
"local_eff_mean": leff_mean,
"local_eff_std": leff_std,
"richclub_mean": rc_mean,
"richclub_max": rc_max,
"smallworld_sigma": sw_sigma,
}
# =========================================================
# Local summary metrics
# =========================================================
def compute_local_summary_metrics(G: nx.Graph) -> dict:
n = G.number_of_nodes()
ecount = G.number_of_edges()
density = (2.0 * ecount / (n * (n - 1))) if n >= 2 else 0.0
H = largest_connected_subgraph(G)
deg = np.array([d for _, d in G.degree()], dtype=np.float64)
clust = np.array(list(nx.clustering(G).values()), dtype=np.float64) if n >= 2 else np.zeros(n)
btw = np.array(list(nx.betweenness_centrality(G, normalized=True).values()), dtype=np.float64) if n >= 3 else np.zeros(n)
eff = nodal_efficiency(H)
s_eff = summarize_distribution(eff, "eff")
s_clu = summarize_distribution(clust, "clust")
s_btw = summarize_distribution(btw, "btw")
s_deg = summarize_distribution(deg, "deg")
deg_mean = s_deg["deg_mean"]
deg_top10_ratio = (s_deg["deg_top10_mean"] / deg_mean) if np.isfinite(deg_mean) and deg_mean != 0 else np.nan
return {
"N": int(n),
"E": int(ecount),
"density": float(density),
**s_eff, **s_clu, **s_btw, **s_deg,
"deg_top10_mean_ratio": float(deg_top10_ratio),
}
# =========================================================
# Stats
# =========================================================
def bh_fdr(pvals: np.ndarray) -> np.ndarray:
p = np.asarray(pvals, dtype=np.float64)
q = np.full_like(p, np.nan)
ok = np.isfinite(p)
pv = p[ok]
m = pv.size
if m == 0:
return q
order = np.argsort(pv)
ranked = pv[order]
q_ranked = ranked * m / (np.arange(1, m + 1))
q_ranked = np.minimum.accumulate(q_ranked[::-1])[::-1]
q_ok = np.empty_like(pv)
q_ok[order] = q_ranked
q[ok] = np.clip(q_ok, 0, 1)
return q
def ols_fit(X: np.ndarray, y: np.ndarray):
ok = np.isfinite(y) & np.isfinite(X).all(axis=1)
X2 = X[ok]
y2 = y[ok]
n, k = X2.shape
if n <= k + 1:
raise ValueError(f"Too few samples after NaN drop: n={n}, k={k}")
beta, *_ = np.linalg.lstsq(X2, y2, rcond=None)
resid = y2 - X2 @ beta
dof = n - k
s2 = (resid @ resid) / dof
XtX_inv = np.linalg.inv(X2.T @ X2)
se = np.sqrt(np.diag(XtX_inv) * s2)
t = beta / se
try:
from scipy import stats
p = 2 * stats.t.sf(np.abs(t), dof)
except Exception:
from math import erf, sqrt
def norm_sf(z):
return 0.5 * (1 - erf(z / sqrt(2)))
p = np.array([2 * norm_sf(abs(z)) for z in t], dtype=np.float64)
return beta, se, t, p, dof, int(ok.sum())
def run_glm_compare(df: pd.DataFrame, metric_cols: list[str], extra_covars: list[str], include_density: bool,
fdr_alpha: float, analysis_name: str) -> pd.DataFrame:
def _run_one(include_nodes: bool, model_name: str) -> pd.DataFrame:
covars = ["dx_AD", "age", "sex"]
for c in extra_covars:
if c in df.columns and c not in covars:
covars.append(c)
if include_density and "density" in df.columns and "density" not in covars:
covars.append("density")
if include_nodes and "N" in df.columns and "N" not in covars:
covars.append("N")
X = df[covars].copy()
X.insert(0, "intercept", 1.0)
Xmat = X.to_numpy(dtype=np.float64)
idx_dx = list(X.columns).index("dx_AD")
rows = []
for m in metric_cols:
y = df[m].to_numpy(dtype=np.float64)
try:
beta, se, t, p, dof, n_used = ols_fit(Xmat, y)
rows.append({
"analysis": analysis_name,
"metric": m,
"pretty_metric": PRETTY_LABELS.get(m, m),
"model": model_name,
"include_N": int(include_nodes),
"beta_dx_AD": float(beta[idx_dx]),
"se_dx_AD": float(se[idx_dx]),
"t_dx_AD": float(t[idx_dx]),
"p_dx_AD": float(p[idx_dx]),
"dof": int(dof),
"n_used": int(n_used),
"model_covars": ",".join(X.columns.tolist()),
})
except Exception as ex:
rows.append({
"analysis": analysis_name,
"metric": m,
"pretty_metric": PRETTY_LABELS.get(m, m),
"model": model_name,
"include_N": int(include_nodes),
"beta_dx_AD": np.nan,
"se_dx_AD": np.nan,
"t_dx_AD": np.nan,
"p_dx_AD": np.nan,
"dof": np.nan,
"n_used": np.nan,
"model_covars": ",".join(X.columns.tolist()),
"error": str(ex),
})
out = pd.DataFrame(rows)
out["q_dx_AD"] = bh_fdr(out["p_dx_AD"].to_numpy(dtype=np.float64))
out["sig_fdr"] = out["q_dx_AD"].apply(lambda x: significance_flag(np.nan, x, alpha=fdr_alpha))
return out
noN = _run_one(include_nodes=False, model_name="No_N")
withN = _run_one(include_nodes=True, model_name="With_N")
wide = noN.merge(
withN,
on=["analysis", "metric", "pretty_metric"],
how="outer",
suffixes=("_NoN", "_WithN")
)
wide["delta_beta"] = wide["beta_dx_AD_WithN"] - wide["beta_dx_AD_NoN"]
wide["delta_p"] = wide["p_dx_AD_WithN"] - wide["p_dx_AD_NoN"]
wide["delta_q"] = wide["q_dx_AD_WithN"] - wide["q_dx_AD_NoN"]
def _change(row):
a = row.get("sig_fdr_NoN", "NA")
b = row.get("sig_fdr_WithN", "NA")
if a == "Yes" and b == "Yes":
return "Stable significant"
if a == "Yes" and b == "No":
return "Lost after N adjustment"
if a == "No" and b == "Yes":
return "Gained after N adjustment"
if a == "No" and b == "No":
return "Stable non-significant"
return "NA"
wide["significance_change"] = wide.apply(_change, axis=1)
wide = wide.sort_values(["analysis", "p_dx_AD_NoN", "p_dx_AD_WithN"], na_position="last").reset_index(drop=True)
return wide
def make_pretty_table(df: pd.DataFrame) -> pd.DataFrame:
out = df.copy()
out["beta (No N)"] = out["beta_dx_AD_NoN"].map(lambda x: fmt_num(x, 4))
out["p (No N)"] = out["p_dx_AD_NoN"].map(fmt_p)
out["q (No N)"] = out["q_dx_AD_NoN"].map(fmt_p)
out["beta (With N)"] = out["beta_dx_AD_WithN"].map(lambda x: fmt_num(x, 4))
out["p (With N)"] = out["p_dx_AD_WithN"].map(fmt_p)
out["q (With N)"] = out["q_dx_AD_WithN"].map(fmt_p)
out["Δbeta"] = out["delta_beta"].map(lambda x: fmt_num(x, 4))
out["Δq"] = out["delta_q"].map(lambda x: fmt_num(x, 4))
keep_cols = [
"analysis",
"metric",
"pretty_metric",
"beta (No N)",
"p (No N)",
"q (No N)",
"beta (With N)",
"p (With N)",
"q (With N)",
"Δbeta",
"Δq",
"sig_fdr_NoN",
"sig_fdr_WithN",
"significance_change",
"model_covars_NoN",
"model_covars_WithN",
]
rename_map = {
"analysis": "Analysis",
"metric": "Metric_code",
"pretty_metric": "Metric",
"sig_fdr_NoN": "FDR sig (No N)",
"sig_fdr_WithN": "FDR sig (With N)",
"model_covars_NoN": "Covariates (No N)",
"model_covars_WithN": "Covariates (With N)",
}
return out[keep_cols].rename(columns=rename_map)
# =========================================================
# Subject-level extraction
# =========================================================
def load_subject_level_tables(entries, threshold_mode, top_percent, abs_thr, n_random, seed):
global_rows = []
local_rows = []
for e in entries:
label = int(e.get("label"))
if label not in (2, 3):
continue
sid = str(e.get("subject_id"))
site = str(e.get("site", ""))
age = _safe_float(e.get("age", np.nan))
sex = _safe_float(e.get("gender", np.nan))
mat = e.get("matrix", None)
if mat is None:
continue
G = build_graph(mat, threshold_mode, top_percent, abs_thr)
base_info = {
"subject_id": sid,
"site": site,
"label": label,
"label_name": LABEL_NAME[label],
"dx_AD": 1 if label == 2 else 0,
"age": age,
"sex": sex,
}
gmet = compute_global_metrics(G, n_random=n_random, seed=seed)
lmet = compute_local_summary_metrics(G)
global_rows.append({**base_info, **gmet})
local_rows.append({**base_info, **lmet})
global_df = pd.DataFrame(global_rows)
local_df = pd.DataFrame(local_rows)
if global_df.empty or local_df.empty:
raise RuntimeError("No AD/LBD subjects found in input.")
return global_df, local_df
def merge_optional_covars(df: pd.DataFrame, covar_file: str | None, covar_cols: list[str]) -> pd.DataFrame:
if covar_file is None:
return df
covp = Path(covar_file)
if not covp.exists():
raise FileNotFoundError(f"covar-file not found: {covp}")
if covp.suffix.lower() == ".csv":
cov = pd.read_csv(covp)
else:
cov = pd.read_csv(covp, sep="\t")
if "subject_id" not in cov.columns:
raise ValueError("covar-file must contain subject_id column.")
keep = ["subject_id"] + [c for c in covar_cols if c in cov.columns]
return df.merge(cov[keep], on="subject_id", how="left")
# =========================================================
# CLI
# =========================================================
def parse_args():
ap = argparse.ArgumentParser("Compare GLM p/q with and without node-number adjustment")
ap.add_argument("--in-npy", required=True, help="all_subjects.npy")
ap.add_argument("--outdir", default="compare_node_effect_out")
ap.add_argument("--threshold-mode", choices=["mst_top", "top", "abs", "none"], default="mst_top")
ap.add_argument("--top-percent", type=float, default=10.0)
ap.add_argument("--abs-thr", type=float, default=None)
ap.add_argument("--n-random", type=int, default=20)
ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--covar-file", default=None, help="Optional TSV/CSV with subject_id column")
ap.add_argument("--covar-cols", nargs="*", default=["tiv"], help="Extra covariate columns, e.g. tiv")
ap.add_argument("--fdr-alpha", type=float, default=0.05)
ap.add_argument("--no-density", action="store_true",
help="Do NOT include density as a covariate in the comparison models")
return ap.parse_args()
# =========================================================
# Main
# =========================================================
def main():
args = parse_args()
outdir = Path(args.outdir)
outdir.mkdir(parents=True, exist_ok=True)
entries = np.load(args.in_npy, allow_pickle=True)
global_df, local_df = load_subject_level_tables(
entries=entries,
threshold_mode=args.threshold_mode,
top_percent=args.top_percent,
abs_thr=args.abs_thr,
n_random=args.n_random,
seed=args.seed
)
global_df = merge_optional_covars(global_df, args.covar_file, args.covar_cols)
local_df = merge_optional_covars(local_df, args.covar_file, args.covar_cols)
global_metrics_path = outdir / "global_metrics_per_subject.tsv"
local_metrics_path = outdir / "local_metrics_per_subject.tsv"
global_df.to_csv(global_metrics_path, sep="\t", index=False)
local_df.to_csv(local_metrics_path, sep="\t", index=False)
global_metric_cols = [
"global_efficiency",
"char_path_length",
"clustering",
"transitivity",
"modularity",
"assortativity",
"smallworld_sigma",
"richclub_mean",
"local_eff_mean",
"local_eff_std",
]
local_metric_cols = [
"eff_q90", "eff_gini", "eff_std",
"clust_q90", "clust_gini", "clust_std",
"btw_q90", "btw_gini",
"deg_gini", "deg_top10_mean_ratio",
]
include_density = not args.no_density
global_compare = run_glm_compare(
df=global_df,
metric_cols=global_metric_cols,
extra_covars=args.covar_cols,
include_density=include_density,
fdr_alpha=args.fdr_alpha,
analysis_name="global"
)
local_compare = run_glm_compare(
df=local_df,
metric_cols=local_metric_cols,
extra_covars=args.covar_cols,
include_density=include_density,
fdr_alpha=args.fdr_alpha,
analysis_name="local"
)
combined = pd.concat([global_compare, local_compare], axis=0, ignore_index=True)
pretty = make_pretty_table(combined)
global_compare_path = outdir / "global_glm_compare_node.tsv"
local_compare_path = outdir / "local_glm_compare_node.tsv"
combined_path = outdir / "combined_glm_compare_node.tsv"
pretty_path = outdir / "combined_glm_compare_node_pretty.tsv"
global_compare.to_csv(global_compare_path, sep="\t", index=False)
local_compare.to_csv(local_compare_path, sep="\t", index=False)
combined.to_csv(combined_path, sep="\t", index=False)
pretty.to_csv(pretty_path, sep="\t", index=False)
print("[OK] Saved:")
print(" -", global_metrics_path)
print(" -", local_metrics_path)
print(" -", global_compare_path)
print(" -", local_compare_path)
print(" -", combined_path)
print(" -", pretty_path)
print()
print("Settings:")
print(" threshold_mode =", args.threshold_mode)
print(" top_percent =", args.top_percent)
print(" include_density=", include_density)
print(" extra_covars =", args.covar_cols)
print(" fdr_alpha =", args.fdr_alpha)
if __name__ == "__main__":
main()

compare_node_number_effect_full.py at commit dabd756, under MIT · at the source

Overview

Authors: Minheng Chen¹, Chao Cao¹, Tong Chen¹, Dunia Alhamad^2,3, Tianming Liu⁴, Li Su^2,5, Dajiang Zhu¹

ORCID iDs: Minheng Chen

Institutions: The University of Texas at Arlington (United States); King Saud bin Abdulaziz University for Health Sciences (Saudi Arabia); National Guard Health Affairs (Saudi Arabia); University of Sheffield (United Kingdom); University of Georgia (United States); University of Cambridge (United Kingdom)

Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1322

Dates: received 12 April 2026; accepted 1 July 2026; published online 6 August 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1162/imag.a.1322 · PMID 42569517 · PMCID PMC13449931 · OpenAlex W7167901362

Open access: diamond, a free copy (OpenAlex)

Status: code verified

Categories: structural MRI / diffusion (modality), Alzheimer's / dementia (population), systems (subfield)

Methods: Connectivity, Preprocessing, Graphs, Machine learning

Keywords: Alzheimer’s disease, Lewy body dementia, morphometric similarity networks, cortical folding, individualized brain networks

Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Funding: National Institute on Aging (R01AG075582); NINDS (R01NS128534); Sir Jules Thorn Charitable Trust (05/JTA); Alzheimer’s Research UK Senior Research Fellowship (ARUK-SRF2017B-1); Lewy Body Society (LBS/002/2019); Engineering and Physical Sciences Research Council of the UK (EP/K026992/1); Wellcome Trust (WT088441MA)

Citations: not cited yet (Europe PMC); 70 references in the paper

Abstract

Alzheimer’s disease (AD) and Lewy body dementia (LBD) are common neurodegenerative dementias with overlapping clinical presentations, making differential diagnosis challenging. While structural magnetic resonance imaging (MRI) has revealed characteristic regional atrophy patterns, regional morphometric measures alone may not fully capture distributed cortical alterations. Morphometric similarity networks (MSNs) offer a systems-level framework to characterize coordinated structural organization, but existing approaches typically rely on atlas-based parcellations that may obscure individual-specific cortical folding geometry. Here, we propose a fine-scale, folding-informed cortical similarity network framework based on automatically detected three-hinge gyral (3HG) landmarks. Using a thickness-constrained arealization strategy in native surface space, we define individualized cortical regions and construct subject-specific MSNs without cross-subject registration. We then investigate how network topology relates to landmark-defined node count and how these properties differ between AD and LBD. We find that several graph theoretical metrics, particularly global efficiency and characteristic path length, exhibit clear associations with the number of detected landmarks, indicating that topology in individualized networks is partly shaped by node availability. When accounting for landmark count, several apparent group differences in global topology are attenuated, whereas multiple heterogeneity-related metrics remain significant, indicating that node-count scaling substantially influences the interpretation of individualized network topology. Nevertheless, multivariate topological patterns remain informative for AD/LBD classification after residualizing for node count, and landmark count itself provides modest diagnostic information. These findings highlight node-count scaling as a key methodological consideration in individualized structural networks and suggest that folding-based MSNs capture disease-related variation in cortical network organization between AD and LBD.

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

m1nhengChen/Gyral-Folding-Network

License: MIT

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: dabd756dfc4af96b135ab8a16984595353277a37, 10 July 2026

Languages: Python (4)

Size: 10 files, 4 scripts

Software Heritage: not archived

Found in: “Data and Code Availability”

Holds: README, license file

Not found: CITATION.cff, environment file, tests, continuous integration, documentation

Tools: NumPy (4 files), pandas (4 files), Matplotlib (2 files), SciPy (2 files), NetworkX (1 file), scikit-learn (1 file), statsmodels (1 file)

Availability: 1 check, the latest on 27 September 2026: the link answers

27 September 2026: the link answers

6 files

src/classification_nestedcv_residN.py, Python, 639 lines, 2 matches
src/compare_node_number_effect_full.py, Python, 842 lines, 5 matches
src/landmark_mind_from_vtk_mdkde_adaptive.py, Python, 1,030 lines, 2 matches
src/reg_N_scaling.py, Python, 259 lines
LICENSE, License, 21 lines
README.md, Text, 33 lines

At the source: github.com/m1nhengChen/Gyral-Folding-Network

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;
4 scripts, each with its path and the digest of its content;
9 matches between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and Code Availability

The data used in this study are not publicly available due to ethical and privacy restrictions but are available from the corresponding author upon reasonable request and with permission from the data providers. The code used to generate the results in this study is publicly available at https://github.com/m1nhengChen/Gyral-Folding-Network.

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

Recorded: type, language, journal, volume, pages, dates, 7 authors, 5 keywords, 7 funders, 70 references.

Cite

This paper

Chen, M., Cao, C., Chen, T., Alhamad, D., Liu, T., Su, L., & Zhu, D. (2026). Fine-scale individualized gyral folding-based cortical similarity networks reveal distinct organizational patterns in Alzheimer's disease and Lewy body dementia. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1322. https://doi.org/10.1162/imag.a.1322

BibTeX

@article{chen2026fine, author = {Chen, Minheng and Cao, Chao and Chen, Tong and Alhamad, Dunia and Liu, Tianming and Su, Li and Zhu, Dajiang}, title = {{Fine-scale individualized gyral folding-based cortical similarity networks reveal distinct organizational patterns in Alzheimer's disease and Lewy body dementia}}, journal = {Imaging neuroscience (Cambridge, Mass.)}, year = {2026}, month = aug, volume = {4}, pages = {IMAG.a.1322}, publisher = {MIT Press}, issn = {2837-6056}, doi = {10.1162/imag.a.1322}, url = {https://doi.org/10.1162/imag.a.1322}, pmid = {42569517}, pmcid = {PMC13449931} }

RIS

TY - JOUR AU - Chen, Minheng AU - Cao, Chao AU - Chen, Tong AU - Alhamad, Dunia AU - Liu, Tianming AU - Su, Li AU - Zhu, Dajiang TI - Fine-scale individualized gyral folding-based cortical similarity networks reveal distinct organizational patterns in Alzheimer's disease and Lewy body dementia T2 - Imaging neuroscience (Cambridge, Mass.) J2 - Imaging Neurosci (Camb) PY - 2026 DA - 2026/08/06 VL - 4 SP - IMAG.a.1322 SN - 2837-6056 PB - MIT Press DO - 10.1162/imag.a.1322 UR - https://doi.org/10.1162/imag.a.1322 LA - en ER -

CSL-JSON

{ "id": "10.1162/imag.a.1322", "type": "article-journal", "title": "Fine-scale individualized gyral folding-based cortical similarity networks reveal distinct organizational patterns in Alzheimer's disease and Lewy body dementia", "container-title": "Imaging neuroscience (Cambridge, Mass.)", "author": [ { "family": "Chen", "given": "Minheng" }, { "family": "Cao", "given": "Chao" }, { "family": "Chen", "given": "Tong" }, { "family": "Alhamad", "given": "Dunia" }, { "family": "Liu", "given": "Tianming" }, { "family": "Su", "given": "Li" }, { "family": "Zhu", "given": "Dajiang" } ], "container-title-short": "Imaging Neurosci (Camb)", "volume": "4", "page": "IMAG.a.1322", "DOI": "10.1162/imag.a.1322", "PMID": "42569517", "PMCID": "PMC13449931", "ISSN": "2837-6056", "publisher": "MIT Press", "URL": "https://doi.org/10.1162/imag.a.1322", "language": "en", "issued": { "date-parts": [ [ 2026, 8, 6 ] ] } }

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/s42003-026-09956-6 [code]: Linking changes in sulcal morphometry to cognitive development from childhood to adolescence.
Journal: Communications biology
In common: statsmodels, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, 6 references
[2] doi:10.1038/s42003-026-10276-y [code]: The cellular correlates and adolescent reorganisation of cortical myelination networks in the common marmoset.
Journal: Communications biology
In common: statsmodels, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, 6 references
[3] doi:10.1038/s41467-026-74153-2 [code]: Regional, functional and transcriptomic decoding of multidimensional brain structure alterations in obsessive-compulsive disorder.
Journal: Nature communications
In common: statsmodels, scikit-learn, pandas, 3 other tools, 6 references
[4] doi:10.1038/s41467-026-73714-9 [code]: The genetic architecture of cortical similarity networks.
Journal: Nature communications
In common: pandas, SciPy, Matplotlib, 1 other tool, structural MRI / diffusion, 6 references
[5] doi:10.1162/netn.a.553 [code]: MIND versus MSN: A systematic evaluation of test-retest reliability and age sensitivity for T1-weighted structural similarity networks.
Journal: Network neuroscience (Cambridge, Mass.)
In common: structural MRI / diffusion, 8 references
[6] doi:10.1162/imag.a.1208 [code]: Brain network analysis in Alzheimer's disease and mild cognitive impairment using high-density diffuse optical tomography.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NetworkX, statsmodels, scikit-learn, 4 other tools, systems, Alzheimer's / dementia, 2 references
[7] doi:10.1162/imag.a.1325 [code]: Decoding everyday levels of musical training from subcortical white-matter architecture.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: statsmodels, pandas, SciPy, 2 other tools, systems, structural MRI / diffusion, 4 references
[8] 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: statsmodels, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, 3 references
[9] doi:10.1162/netn.a.546 [code]: Cortical similarity networks in the rat brain: Postnatal development and sensitivity to early life stress.
Journal: Network neuroscience (Cambridge, Mass.)
In common: pandas, SciPy, NumPy, structural MRI / diffusion, 5 references
[10] doi:10.1186/s40708-026-00316-y [code]: Generalizable and explainable deep learning for brain MRI: a multi-cohort evaluation of 3D architectures for age and sex prediction.
Journal: Brain informatics
In common: scikit-learn, pandas, SciPy, 2 other tools, structural MRI / diffusion, 3 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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