OSCR

Advancing fair and explainable machine learning for neuroimaging dementia pattern classification in multi-racial and multi-ethnic populations.

Code ↔ Paper

8 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 8 matches
  1. [1] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/models/models.py, lines 644–740 · score 0.63 · target domain, RegAlign, binary, shot, entropy, alignment
  2. [2] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/models/objectives.py, lines 458–592 · score 0.60 · entropy minimization, unlabeled, shot, supervision, objective, alignment
  3. [3] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/core/ops.py, lines 297–428 · score 0.59 · upper bound, sample weights, sum, RBF, kernel
  4. [4] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/core/ops.py, lines 438–485 · score 0.58 · Correlation Remover, sensitive feature, vector, transformation, CR
  5. [5] § Results › Performance discrepancies across multi-racial and multi-ethnic groups ↔ dementia_ai/cli/main.py, lines 210–271 · score 0.56 · Pairwise gap, FPR gap, FNR gap
  6. [6] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/models/objectives.py, lines 458–592 · score 0.53 · entropy minimization, unlabeled, supervised, probabilities, alignment, SSDA
  7. [7] § Methods ↔ dementia_ai/explainer/shap_utils.py, lines 5–30 · score 0.53 · XGBoost, scikit-learn, tree, boosted, NumPy, model
  8. [8] § Methods › ML classifier and discrepancy mitigation methods ↔ dementia_ai/models/models.py, lines 644–740 · score 0.51 · RegAlign, unlabeled, shot, entropy, alignment, SSDA

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,011 lines · 41 KB · no license · 2 matches

  1. import sys
  2. import json
  3. import traceback
  6. import numpy as np
  7. from tqdm import tqdm
  8. import xgboost as xgb
  9. from sklearn.model_selection import StratifiedKFold, ParameterGrid, GridSearchCV
  10. from sklearn.neural_network import MLPClassifier
  11. from sklearn.ensemble import RandomForestClassifier
  12. from sklearn.svm import SVC
  13. from joblib import parallel_backend
  14. from sklearn.base import clone, BaseEstimator, ClassifierMixin
  15. from sklearn.metrics import check_scoring
  16. from sklearn.base import BaseEstimator
  17. from sklearn.metrics import make_scorer, f1_score, balanced_accuracy_score
  18. from sklearn.utils import check_array
  19. from sklearn.metrics import pairwise
  20. from sklearn.metrics.pairwise import KERNEL_PARAMS
  21. from sklearn.preprocessing import StandardScaler
  22. from sklearn.utils.validation import check_is_fitted
  24. from typing import Optional, Dict, List, Tuple, Any
  25. from cvxopt import matrix, solvers
  27. # Reuse shared preprocessing / KMM routines
  28. from dementia_ai.core import ops
  29. #import custom_objectives as CO
  30. from . import objectives as CO
  32. class _IdentityScaler:
  33. def transform(self, X):
  34. import numpy as np
  35. return np.asarray(X, dtype=np.float32)
  37. def _ba_optimal_threshold(y_true, p1, grid=None) -> float:
  38. """Return the threshold that maximizes Balanced Accuracy on y_true."""
  39. import numpy as np
  40. from sklearn.metrics import balanced_accuracy_score
  41. if grid is None:
  42. # dense grid around the middle; robust for imbalanced sets
  43. grid = np.unique(np.clip(np.r_[np.linspace(0.05,0.95,181), p1], 0, 1))
  44. best, thr = -1.0, 0.5
  45. for t in grid:
  46. yhat = (p1 >= t).astype(int)
  47. ba = balanced_accuracy_score(y_true, yhat)
  48. if ba > best:
  49. best, thr = ba, t
  50. return float(thr)
  52. def _split_xgb_custom_objs(paras: dict):
  53. """Split custom-objective keys from plain XGB params."""
  54. p = dict(paras or {})
  55. focal = {
  56. "use": bool(p.pop("use_focal_obj", False)),
  57. "alpha": float(p.pop("focal_alpha", 0.90)),
  58. "gamma": float(p.pop("focal_gamma", 2.0)),
  59. }
  60. cs = {
  61. "use": bool(p.pop("use_cost_sensitive_obj", False)),
  62. "cost_fn": float(p.pop("cs_cost_fn", 5.0)),
  63. "cost_fp": float(p.pop("cs_cost_fp", 1.0)),
  64. }
  65. return p, focal, cs
  67. # def ba_cost_scorer(est, X, y):
  68. # """Scorer used in grid search. Uses t_cost from est params if available."""
  69. # from sklearn.metrics import balanced_accuracy_score
  70. # proba = est.predict_proba(X)[:, 1]
  71. # # Parameters can be in est.paras (CustomML) or in get_params()
  72. # cs_fn = None
  73. # cs_fp = None
  74. # if hasattr(est, "paras"):
  75. # cs_fn = est.paras.get("cs_cost_fn", None)
  76. # cs_fp = est.paras.get("cs_cost_fp", None)
  77. # if (cs_fn is None or cs_fp is None) and hasattr(est, "get_params"):
  78. # p = est.get_params()
  79. # cs_fn = p.get("cs_cost_fn", cs_fn)
  80. # cs_fp = p.get("cs_cost_fp", cs_fp)
  81. # if cs_fn is not None and cs_fp is not None and (cs_fn + cs_fp) > 0:
  82. # t_cost = cs_fp / (cs_fp + cs_fn)
  83. # else:
  84. # t_cost = 0.5
  85. # yhat = (proba >= t_cost).astype(int)
  86. # return balanced_accuracy_score(y, yhat)
  88. class BACostScorer:
  89. def __init__(self, default_threshold: float = 0.5):
  90. self._sign = 1 # sklearn-compatible
  91. self.default_threshold = float(default_threshold)
  93. def _threshold_from_params(self, est):
  94. # Look in both get_params() and .paras, if present
  95. cf = cp = None
  96. if hasattr(est, "get_params"):
  97. try:
  98. p = est.get_params()
  99. cf = p.get("cs_cost_fn", None)
  100. cp = p.get("cs_cost_fp", None)
  101. except Exception:
  102. pass
  103. if (cf is None or cp is None) and hasattr(est, "paras"):
  104. cf = est.paras.get("cs_cost_fn", cf)
  105. cp = est.paras.get("cs_cost_fp", cp)
  106. if cf is not None and cp is not None and (cf + cp) > 0:
  107. return float(cp) / float(cp + cf)
  108. return self.default_threshold
  110. def __call__(self, estimator, X, y):
  111. thr = self._threshold_from_params(estimator)
  113. # 1) Fast path for our custom XGB class that exposes .booster_ & .scaler_
  114. booster = getattr(estimator, "booster_", None)
  115. scaler = getattr(estimator, "scaler_", None)
  116. if booster is not None and scaler is not None:
  117. try:
  118. Xs = scaler.transform(np.asarray(X, dtype=np.float32))
  119. proba = booster.predict(xgb.DMatrix(Xs))
  120. yhat = (proba >= thr).astype(int)
  121. return balanced_accuracy_score(y, yhat)
  122. except Exception:
  123. pass # fall through
  125. # 2) Fallback to predict_proba if available
  126. if hasattr(estimator, "predict_proba"):
  127. try:
  128. proba = estimator.predict_proba(X)[:, 1]
  129. yhat = (proba >= thr).astype(int)
  130. return balanced_accuracy_score(y, yhat)
  131. except Exception:
  132. pass
  134. # 3) Fallback to predict if available (already hard labels)
  135. if hasattr(estimator, "predict"):
  136. try:
  137. yhat = estimator.predict(X)
  138. # If predict returns floats, threshold them
  139. if yhat.dtype != np.int_ and yhat.dtype != np.bool_:
  140. yhat = (np.asarray(yhat, dtype=float) >= thr).astype(int)
  141. return balanced_accuracy_score(y, yhat)
  142. except Exception:
  143. pass
  145. # 4) Last resort: return the worst possible score for this split
  146. # so this candidate is ignored, but we don't crash the whole search
  147. return -np.inf
  149. ba_cost_scorer = BACostScorer()
  151. def custom_f1_score(y_true, y_pred):
  152. # Example: You can modify this function to compute any custom metric
  153. return f1_score(y_true, y_pred, average='weighted')
  155. def custom_ba_score(y_true, y_pred):
  156. # Example: You can modify this function to compute any custom metric
  157. return balanced_accuracy_score(y_true, y_pred)
  159. # def compute_sample_weight_kmm(Xs, Xt):
  160. # def _fit_weights(Xs, Xt, epsilon):
  161. # n_s = len(Xs)
  162. # n_t = len(Xt)
  164. # if epsilon is None:
  165. # epsilon = (np.sqrt(n_s) - 1)/np.sqrt(n_s)
  167. # kernel_params = {'gamma': 1.0}
  169. # # Compute Kernel Matrix
  170. # K = pairwise.pairwise_kernels(Xs, Xs, metric=kernel,
  171. # **kernel_params)
  172. # K = (1/2) * (K + K.transpose())
  174. # # Compute q
  175. # kappa = pairwise.pairwise_kernels(Xs, Xt,
  176. # metric=kernel,
  177. # **kernel_params)
  178. # kappa = (n_s/n_t) * np.dot(kappa, np.ones((n_t, 1)))
  180. # K = np.ascontiguousarray(K, dtype=np.float64)
  181. # kappa = np.ascontiguousarray(kappa, dtype=np.float64)
  183. # P = matrix(K)
  184. # q = -matrix(kappa)
  186. # # Define constraints
  187. # G = np.ones((2*n_s+2, n_s))
  188. # G[1] = -G[1]
  189. # G[2:n_s+2] = np.eye(n_s)
  190. # G[n_s+2:n_s*2+2] = -np.eye(n_s)
  191. # h = np.ones(2*n_s+2)
  192. # h[0] = n_s*(1+epsilon)
  193. # h[1] = n_s*(epsilon-1)
  194. # h[2:n_s+2] = B
  195. # h[n_s+2:] = 0
  197. # G = matrix(G)
  198. # h = matrix(h)
  200. # solvers.options["show_progress"] = bool(verbose)
  201. # solvers.options["maxiters"] = max_iter
  202. # if tol is not None:
  203. # solvers.options['abstol'] = tol
  204. # solvers.options['reltol'] = tol
  205. # solvers.options['feastol'] = tol
  206. # else:
  207. # solvers.options['abstol'] = 1e-7
  208. # solvers.options['reltol'] = 1e-6
  209. # solvers.options['feastol'] = 1e-7
  211. # weights = solvers.qp(P, q, G, h)['x']
  212. # return np.array(weights).ravel()
  214. # kernel = "rbf"
  215. # B = 1000
  216. # epsilon = None
  217. # max_size = 1000
  218. # tol = None
  219. # verbose = 0
  220. # max_iter = 100
  221. # random_state = 777
  223. # Xs = np.ascontiguousarray(check_array(Xs), dtype=np.float64)
  224. # Xt = np.ascontiguousarray(check_array(Xt), dtype=np.float64)
  225. # np.random.seed(random_state)
  227. # if len(Xs) > max_size:
  228. # size = len(Xs)
  229. # power = 0
  230. # while size > max_size:
  231. # size = size / 2
  232. # power += 1
  233. # split = int(len(Xs) / 2**power)
  234. # shuffled_index = np.random.choice(len(Xs), len(Xs), replace=False)
  235. # weights = np.zeros(len(Xs))
  236. # for i in range(2**power):
  237. # index = shuffled_index[split*i:split*(i+1)]
  238. # weights[index] = _fit_weights(Xs[index], Xt, epsilon)
  239. # else:
  240. # weights = _fit_weights(Xs, Xt, epsilon)
  242. # return weights
  244. class CustomML(BaseEstimator):
  245. def __init__(self, model_name, paras=None, sample_weight=None, **kwargs):
  246. self.model_name = model_name
  247. self.paras = paras if paras is not None else {}
  248. #print("Init:", self.paras)
  249. self.sample_weight = sample_weight
  250. self.kwargs = kwargs
  251. self._initialize_predictor()
  253. def _initialize_predictor(self):
  254. import inspect
  255. def _filter_params(params, cls):
  256. if params is None:
  257. return {}
  258. valid = set(inspect.signature(cls.__init__).parameters.keys())
  259. # always ignore our internal dummy knob if present
  260. params = dict(params)
  261. params.pop("__dummy__", None)
  262. return {k: v for k, v in params.items() if k in valid}
  263. if self.model_name == 'svm':
  264. p = _filter_params(self.paras, SVC)
  265. k = _filter_params(self.kwargs, SVC)
  266. # guarantee probabilities unless explicitly overridden
  267. if 'probability' not in p and 'probability' not in k:
  268. p['probability'] = True
  269. self.predictor = SVC(**p, **k)
  270. elif self.model_name == 'xgboost_vanilla':
  271. # Pure, dependable XGB — no custom objective, no fancy knobs
  272. p = dict(self.paras or {})
  273. # normalize param aliases
  274. if 'lambda' in p and 'reg_lambda' not in p: p['reg_lambda'] = p.pop('lambda')
  275. if 'alpha' in p and 'reg_alpha' not in p: p['reg_alpha'] = p.pop('alpha')
  276. if 'eta' not in p and 'learning_rate' in p: p['eta'] = p.pop('learning_rate')
  278. # safe defaults if not provided
  279. p.setdefault('objective', 'binary:logistic')
  280. p.setdefault('eval_metric', 'aucpr')
  281. p.setdefault('tree_method', 'hist')
  282. p.setdefault('device', self.kwargs.get('device', 'cuda'))
  283. p.setdefault('max_depth', 4)
  284. p.setdefault('eta', 0.1)
  285. p.setdefault('subsample', 0.9)
  286. p.setdefault('colsample_bytree', 0.9)
  287. p.setdefault('reg_lambda', 1.0)
  288. p.setdefault('reg_alpha', 0.0)
  289. p.setdefault('n_estimators', self.kwargs.get('total_steps', 300))
  290. p.setdefault('verbosity', 0)
  291. p.setdefault('nthread', 8)
  293. self.predictor = xgb.XGBClassifier(**p)
  295. # vanilla keeps a fold-tuned BA threshold (optional; default 0.5)
  296. self.best_threshold_ = 0.5
  298. # wrap .fit to optionally accept (X_val, y_val) for early-stopping & BA threshold
  299. self._xgb_orig_fit = self.predictor.fit
  300. self._fit_with_es = self._xgb_vanilla_fit_with_es
  302. # helper: class predictions at tuned threshold
  303. self._xgb_predict_proba_fn = self._xgb_vanilla_predict_proba
  304. elif self.model_name == 'random_forest':
  305. self.predictor = RandomForestClassifier(
  306. **_filter_params(self.paras, RandomForestClassifier),
  307. **_filter_params(self.kwargs, RandomForestClassifier)
  308. )
  309. elif self.model_name == 'mlp':
  310. self.predictor = MLPClassifier(
  311. **_filter_params(self.paras, MLPClassifier),
  312. **_filter_params(self.kwargs, MLPClassifier)
  313. )
  315. def set_params(self, **params):
  316. p = dict(params or {})
  317. p.pop("__dummy__", None)
  318. # Preserve/override sample_weight explicitly
  319. if "sample_weight" in p:
  320. self.sample_weight = p.pop("sample_weight")
  321. # keep existing sample_weight if not provided
  322. # Normalize some xgboost aliases so grid params actually change the model
  323. if self.model_name == "xgboost_vanilla":
  324. if "lambda" in p and "reg_lambda" not in p:
  325. p["reg_lambda"] = p.pop("lambda")
  326. if "alpha" in p and "reg_alpha" not in p:
  327. p["reg_alpha"] = p.pop("alpha")
  328. if "learning_rate" in p and "eta" not in p:
  329. p["eta"] = p.pop("learning_rate")
  330. self.paras = p
  331. self._initialize_predictor()
  332. return self
  334. def fit(self, X, y, sample_weight=None):
  335. # ---------------- models (svm / rf / mlp / xgboost_vanilla) ----------------
  336. if sample_weight is not None:
  337. self.predictor.fit(X, y, sample_weight=sample_weight)
  338. else:
  339. self.predictor.fit(X, y)
  340. return self
  342. def _xgb_vanilla_fit_with_es(self, X, y, X_val=None, y_val=None, early_stopping_rounds=50, sample_weight=None):
  343. _orig_fit = getattr(self, "_xgb_orig_fit", None)
  344. if _orig_fit is None:
  345. raise AttributeError("_xgb_orig_fit not set; ensure xgboost_vanilla predictor initialized")
  347. fit_kwargs = {}
  348. if (X_val is not None) and (y_val is not None) and (early_stopping_rounds is not None):
  349. try:
  350. self.predictor.set_params(early_stopping_rounds=int(early_stopping_rounds))
  351. except Exception:
  352. pass
  353. fit_kwargs['eval_set'] = [(X, y), (X_val, y_val)]
  355. if sample_weight is not None:
  356. fit_kwargs["sample_weight"] = sample_weight
  358. _orig_fit(X, y, **fit_kwargs)
  360. if X_val is not None and y_val is not None:
  361. p1_val = self.predictor.predict_proba(X_val)[:, 1]
  362. self.best_threshold_ = _ba_optimal_threshold(y_val, p1_val)
  363. return self
  365. def _xgb_vanilla_predict_proba(self, X):
  366. if hasattr(self.predictor, "predict_proba"):
  367. return self.predictor.predict_proba(X)
  368. import numpy as np
  369. if hasattr(self.predictor, "decision_function"):
  370. s = self.predictor.decision_function(X)
  371. s = np.asarray(s)
  372. if s.ndim == 1:
  373. p1 = 1.0 / (1.0 + np.exp(-s))
  374. return np.vstack([1.0 - p1, p1]).T
  375. else:
  376. e = np.exp(s - s.max(axis=1, keepdims=True))
  377. p = e / e.sum(axis=1, keepdims=True)
  378. return p
  379. raise AttributeError("No predict_proba/decision_function available.")
  382. def predict(self, X):
  383. if self.model_name == 'xgboost_vanilla' and hasattr(self, "best_threshold_"):
  384. p1 = self._xgb_vanilla_predict_proba(X)[:, 1]
  385. thr = getattr(self, "best_threshold_", 0.5)
  386. return (p1 >= thr).astype(int)
  387. return self.predictor.predict(X)
  389. def predict_proba(self, X):
  390. if self.model_name == 'xgboost_vanilla':
  391. return self._xgb_vanilla_predict_proba(X)
  392. # Native path if available
  393. if hasattr(self.predictor, "predict_proba"):
  394. return self.predictor.predict_proba(X)
  396. # Fallback: convert decision scores to [p0, p1] via logistic
  397. import numpy as np
  398. if hasattr(self.predictor, "decision_function"):
  399. s = self.predictor.decision_function(X)
  400. s = np.asarray(s)
  401. if s.ndim == 1:
  402. # binary: map to 2-column probs
  403. p1 = 1.0 / (1.0 + np.exp(-s))
  404. return np.vstack([1.0 - p1, p1]).T
  405. else:
  406. # multiclass one-vs-rest scores -> softmax
  407. e = np.exp(s - s.max(axis=1, keepdims=True))
  408. p = e / e.sum(axis=1, keepdims=True)
  409. return p
  411. # Last resort: hard predictions -> degenerate probabilities
  412. y = self.predictor.predict(X)
  413. y = np.asarray(y)
  414. classes = np.unique(y)
  415. if classes.size == 2:
  416. p1 = (y == classes.max()).astype(float)
  417. return np.vstack([1.0 - p1, p1]).T
  418. else:
  419. # multiclass: one-hot
  420. K = classes.size
  421. idx = {c: i for i, c in enumerate(classes)}
  422. probs = np.zeros((y.shape[0], K), dtype=float)
  423. for i, yy in enumerate(y):
  424. probs[i, idx[yy]] = 1.0
  425. return probs
  427. def compute_shap_values(self, X_train, X_test, K=None):
  428. try:
  429. import shap
  430. except Exception:
  431. print("[SHAP] shap not installed; skipping SHAP explanation.", flush=True)
  432. return None
  434. def model_predict(X):
  435. return self.predict_proba(X)[:, 1]
  437. if K:
  438. X_train_summary = shap.sample(X_train, K)
  439. else:
  440. X_train_summary = X_train
  442. explainer = shap.KernelExplainer(model_predict, X_train_summary)
  443. shap_values = explainer.shap_values(X_test)
  445. return explainer, shap_values
  447. @staticmethod
  448. def hyperparameter_optimization(X_train, y_train, model_name, X_test=None, y_test=None, cv=None,
  449. init_paras=None, sample_weight=None, param_grid=None, n_jobs=-1):
  451. custom_scorer = make_scorer(custom_ba_score, greater_is_better=True)
  453. opt = MyGridSearchCV(estimator=CustomML(model_name, paras=init_paras, sample_weight=sample_weight),
  454. param_grid=param_grid,
  455. scoring=custom_scorer,
  456. n_jobs=n_jobs,
  457. cv=cv,
  458. verbose=0,
  459. refit=True)
  460. #opt.set_separated_test(X_test, y_test)
  461. with parallel_backend('loky', n_jobs=n_jobs):
  462. opt.fit(X_train, y_train)
  463. #print("Best Hyperparameters: ", opt.best_params_)
  465. return opt
  467. def fit_and_score(estimator, X, y, train, test, parameters, scorer, X_test=None, y_test=None):
  468. #est = clone(estimator).set_params(**parameters)
  469. est = clone(estimator)
  470. # preserve sample_weight attribute across clone if present
  471. if hasattr(estimator, "sample_weight"):
  472. try:
  473. est.sample_weight = getattr(estimator, "sample_weight")
  474. except Exception:
  475. pass
  476. if parameters:
  477. # Pass all grid parameters through; CustomML.set_params will normalize/ignore as needed.
  478. try:
  479. est.set_params(**parameters)
  480. except Exception:
  481. # Fallback to legal subset if something goes wrong
  482. legal = est.get_params(deep=True).keys()
  483. clean = {k: v for k, v in parameters.items() if k in legal}
  484. if clean:
  485. est.set_params(**clean)
  487. # slice
  488. X_tr = X.iloc[train] if hasattr(X, "iloc") else X[train]
  489. y_tr = y.iloc[train] if hasattr(y, "iloc") else y[train]
  491. # pass group ids / sample_weight when present (kept from your version)
  492. if hasattr(est, "group_ids_source") and est.group_ids_source is not None:
  493. est.group_ids_source = np.asarray(est.group_ids_source)[train]
  494. sw = getattr(est, "sample_weight", None)
  495. if sw is not None:
  496. sw_tr = sw[train]
  497. est.fit(X_tr, y_tr, sample_weight=sw_tr)
  498. else:
  499. est.fit(X_tr, y_tr)
  501. # --- robust scoring ---
  502. try:
  503. if X_test is not None and y_test is not None:
  504. score_list = [scorer(est, xt, yt) for xt, yt in zip(X_test, y_test)]
  505. score = sum(score_list) / len(score_list)
  506. else:
  507. X_te = X.iloc[test] if hasattr(X, "iloc") else X[test]
  508. y_te = y.iloc[test] if hasattr(y, "iloc") else y[test]
  509. score = scorer(est, X_te, y_te)
  510. except Exception:
  511. # If anything blows up, give this parameter set a terrible score
  512. score = -np.inf
  514. return parameters, score, est
  516. class MyGridSearchCV(GridSearchCV):
  517. def __init__(self, *args, **kwargs):
  518. super(MyGridSearchCV, self).__init__(*args, **kwargs)
  519. self.all_best_parameters_ = {}
  520. self.split_indices = {
  521. 'train': [],
  522. 'test': []
  523. }
  524. self.test_score_fold = []
  525. self.best_test_scores = []
  526. self.X_test = None
  527. self.y_test = None
  529. @staticmethod
  530. def _param_key(params: dict):
  531. return tuple(sorted(params.items()))
  533. def set_separated_test(self, X_test, y_test):
  534. self.X_test = X_test
  535. self.y_test = y_test
  537. def scorer_single(self, estimator, X, y_true):
  538. y_pred = estimator.predict(X)
  539. return balanced_accuracy_score(y_true, y_pred)
  541. def fit(self, X, y=None):
  542. self.scorer_ = self.scoring
  543. # Wrap integer cv into StratifiedKFold
  544. cv = self.cv if not isinstance(self.cv, int) else StratifiedKFold(
  545. n_splits=self.cv, shuffle=True, random_state=42
  546. )
  548. if self.verbose > 0:
  549. print(f"Fitting {len(cv)} folds for each of {len(self.param_grid)} candidates, "
  550. f"totalling {len(cv) * len(self.param_grid)} fits")
  552. # materialize the full list of parameter settings
  553. if not self.param_grid:
  554. self.param_iter = [dict()]
  555. else:
  556. self.param_iter = list(ParameterGrid(self.param_grid))
  558. # for sensitivity: collect scores per param set
  559. score_map = {self._param_key(p): [] for p in self.param_iter}
  560. param_map = {self._param_key(p): p for p in self.param_iter}
  562. for split_idx, (train, test) in enumerate(cv.split(X, y)):
  563. n_tr = len(train)
  564. n_va = len(test)
  565. print(f" =========== Training Split {split_idx} - train {n_tr} samples - val {n_va} samples =========== ")
  566. # reset per-fold best trackers
  567. self.best_score_fold = -np.inf if self.scorer_._sign > 0 else np.inf
  568. self.best_params_fold = None
  570. # grid search with progress bar
  571. with tqdm(total=len(self.param_iter),
  572. desc="Grid Search Progress",
  573. bar_format='{desc:<10}{percentage:3.0f}%|{bar:30}{r_bar}') as pbar:
  575. # sequential evaluation of each parameter setting
  576. for parameters in self.param_iter:
  577. parameters, score, est = fit_and_score(
  578. self.estimator, X, y, train, test,
  579. parameters, self.scorer_, self.X_test, self.y_test
  580. )
  582. # update global best if refit=True
  583. if self.refit and score > getattr(self, 'best_score_', -np.inf):
  584. self.best_score_ = score
  585. self.best_params_ = parameters
  586. self.best_estimator_ = est
  588. # update this fold’s best
  589. if score > self.best_score_fold:
  590. self.best_score_fold = score
  591. self.best_params_fold = parameters
  593. # record fold‐test score & advance bar
  594. score_map[self._param_key(parameters)].append(score)
  595. self.test_score_fold.append(score)
  596. try:
  597. pbar.set_postfix_str(f"val_score:{score:.4f}")
  598. except Exception:
  599. pass
  600. pbar.update(1)
  602. # after finishing this fold
  603. self.best_test_scores.append(self.best_score_fold)
  604. self.all_best_parameters_[f'split{split_idx}_params'] = self.best_params_fold
  605. self.split_indices['train'].append(train)
  606. self.split_indices['test'].append(test)
  608. # Build cv_results_ summary (mean/std per param set)
  609. param_keys = list(score_map.keys())
  610. param_names = sorted({k for p in param_map.values() for k in p.keys()})
  611. self.cv_results_ = {
  612. "mean_test_score": [np.mean(score_map[k]) if score_map[k] else -np.inf for k in param_keys],
  613. "std_test_score": [np.std(score_map[k], ddof=1) if len(score_map[k]) > 1 else 0.0 for k in param_keys],
  614. }
  615. for name in param_names:
  616. self.cv_results_[f"param_{name}"] = [param_map[k].get(name) for k in param_keys]
  618. return self
  620. def predict(self, X):
  621. if hasattr(self.best_estimator_, "predict"):
  622. self._check_is_fitted('predict')
  623. return self.best_estimator_.predict(X)
  624. else:
  625. raise AttributeError("The best estimator does not have a 'predict' method.")
  627. def predict_proba(self, X):
  628. if hasattr(self.best_estimator_, "predict_proba"):
  629. self._check_is_fitted('predict_proba')
  630. return self.best_estimator_.predict_proba(X)
  631. else:
  632. raise AttributeError("The best estimator does not have a 'predict_proba' method.")
  634. def score(self, X, y=None):
  635. if hasattr(self.best_estimator_, "score"):
  636. self._check_is_fitted('score')
  637. return self.best_estimator_.score(X, y)
  638. else:
  639. raise AttributeError("The best estimator does not have a 'score' method.")
  643. class XGBCustomObjectiveEstimator(BaseEstimator, ClassifierMixin):
  644. def __init__(self,
  645. # Custom objective selection
  646. objective_version: str = 'v3',
  647. objective_subtype: str = '1C', # '1C' (RegAlign) or '2B' (SSDA)
  648. total_steps: int = 500,
  649. eval_metric: str = 'auc',
  650. loss_mode: str = None, # 'ce','align','ce+align' (1C) | 'entropy','align','entropy+align' (2B)
  651. # target domain (few-shot/regalign or unlabeled/ssda)
  652. target_X: Optional[np.ndarray] = None,
  653. target_y: Optional[np.ndarray] = None,
  654. # validation for logging
  655. X_valid: Optional[np.ndarray] = None,
  656. y_valid: Optional[np.ndarray] = None,
  657. callbacks: Optional[list] = None,
  658. # --- method hyper-params (tuned by grid) ---
  659. tau: float = 1.0, # target CE / entropy weight
  660. eps: float = 1.0, # alignment/GBA weight
  661. source_focal_gamma: float = 0.0,
  662. target_pos_weight: float = 1.0,
  663. update_every: int = 25,
  664. fair_grad_alpha: float = 0.0, fair_grad_ema: float = 0.9, eq_lambda: float = 0.25, cal_lambda: float = 0.2,
  665. gap_kind: str = 'ba',
  666. class1_boost: float = 1.0,
  667. lambda_align: float = 0.1,
  668. # ----- NEW knobs for V3 -----
  669. target_focal_gamma: float = 0.0,
  670. use_target_reg: bool = False,
  671. target_weight: float = 1.0,
  672. # (ALL-groups homogenization)
  673. bary_align: bool = False,
  674. var_align: bool = False,
  675. center_on: str = 'barycenter', # or 'source'|'target'
  676. group_ids_source: Optional[np.ndarray] = None,
  677. group_ids_target: Optional[np.ndarray] = None,
  678. # --- plain xgb params (also tuned by grid) ---
  679. **xgb_params):
  680. self.objective_version = objective_version
  681. self.objective_subtype = objective_subtype
  682. self.total_steps = total_steps
  683. self.eval_metric = eval_metric
  684. self.target_X = target_X
  685. self.target_y = target_y
  686. self.X_valid = X_valid
  687. self.y_valid = y_valid
  688. self.callbacks = callbacks
  689. self.loss_mode = loss_mode
  691. # method HPs
  692. self.tau = tau
  693. self.eps = eps
  694. self.source_focal_gamma = source_focal_gamma
  695. self.target_pos_weight = target_pos_weight
  696. self.update_every = update_every
  697. self.class1_boost = class1_boost
  698. self.lambda_align = float(lambda_align)
  700. # ---- NEW: V3 knobs ----
  701. self.target_focal_gamma = target_focal_gamma
  702. self.use_target_reg = use_target_reg
  703. self.target_weight = target_weight
  705. self.bary_align = bary_align
  706. self.var_align = var_align
  707. self.center_on = center_on
  708. self.group_ids_source = group_ids_source
  709. self.group_ids_target = group_ids_target
  711. self.fair_grad_alpha = fair_grad_alpha
  712. self.fair_grad_ema = fair_grad_ema
  713. self.eq_lambda = eq_lambda
  714. self.cal_lambda = cal_lambda
  715. self.gap_kind = gap_kind
  717. # defaults + alias normalization (unchanged)
  718. defaults = dict(
  719. max_depth=3, eta=0.3, reg_lambda=1.0, reg_alpha=0.0,
  720. subsample=1.0, colsample_bytree=1.0,
  721. tree_method="hist", device=xgb_params.get("device", "cuda"),
  722. objective="binary:logistic",
  723. scale_pos_weight=1.0, nthread=8, verbosity=0,
  724. eval_metric=self.eval_metric
  725. )
  726. defaults.update(xgb_params)
  727. if 'lambda' in defaults and 'reg_lambda' not in defaults:
  728. defaults['reg_lambda'] = defaults.pop('lambda')
  729. if 'alpha' in defaults and 'reg_alpha' not in defaults:
  730. defaults['reg_alpha'] = defaults.pop('alpha')
  731. if 'eta' not in defaults and 'learning_rate' in defaults:
  732. defaults['eta'] = defaults.pop('learning_rate')
  733. defaults['objective'] = 'binary:logistic'
  734. defaults.setdefault('eval_metric', self.eval_metric)
  735. defaults.setdefault('max_delta_step', 1)
  736. self.xgb_params: Dict = defaults
  738. # fitted state
  739. self.booster_ = None
  740. self.classes_ = np.array([0, 1])
  742. def get_params(self, deep=True):
  743. p = dict(self.xgb_params)
  744. p.update(dict(
  745. objective_version=self.objective_version,
  746. objective_subtype=self.objective_subtype,
  747. total_steps=self.total_steps,
  748. eval_metric=self.eval_metric,
  749. target_X=self.target_X,
  750. target_y=self.target_y,
  751. X_valid=self.X_valid,
  752. y_valid=self.y_valid,
  753. callbacks=self.callbacks,
  754. # method HPs
  755. tau=self.tau, eps=self.eps,
  756. source_focal_gamma=self.source_focal_gamma,
  757. target_pos_weight=self.target_pos_weight,
  758. update_every=self.update_every,
  759. class1_boost=self.class1_boost,
  760. loss_mode=self.loss_mode,
  761. # NEW V3 knobs
  762. target_focal_gamma=self.target_focal_gamma,
  763. use_target_reg=self.use_target_reg,
  764. target_weight=self.target_weight,
  765. lambda_align=self.lambda_align,
  766. bary_align=self.bary_align,
  767. var_align=self.var_align,
  768. center_on=self.center_on,
  769. group_ids_source=self.group_ids_source,
  770. group_ids_target=self.group_ids_target,
  771. gap_lambda=float(getattr(self, "gap_lambda", 1.0)),
  772. ba_tau=float(getattr(self, "ba_tau", 2.0)),
  773. fair_grad_alpha=self.fair_grad_alpha,
  774. fair_grad_ema=self.fair_grad_ema,
  775. eq_lambda=self.eq_lambda,
  776. cal_lambda=self.cal_lambda,
  777. gap_kind=self.gap_kind
  778. ))
  779. return p
  781. def set_params(self, **params):
  782. known = {
  783. 'objective_version','objective_subtype','total_steps','eval_metric',
  784. 'target_X','target_y','X_valid','y_valid','callbacks',
  785. 'tau','eps','source_focal_gamma','target_pos_weight','update_every',
  786. 'class1_boost','loss_mode','target_focal_gamma','use_target_reg','lambda_align',
  787. 'target_weight','bary_align','var_align','center_on',
  788. 'group_ids_source','group_ids_target','gap_lambda','ba_tau','fair_grad_alpha',
  789. 'fair_grad_ema','eq_lambda','cal_lambda','gap_kind'
  790. }
  791. for k, v in params.items():
  792. if k in known:
  793. setattr(self, k, v)
  794. else:
  795. self.xgb_params[k] = v
  796. return self
  798. def _build_custom_obj(self, X_src, y_src, X_tgt, y_tgt):
  799. n_source = X_src.shape[0]
  800. m_target = 0 if X_tgt is None else X_tgt.shape[0]
  801. X_comb = X_src if m_target == 0 else np.vstack([X_src, X_tgt])
  803. kwargs = dict(
  804. total_steps=self.total_steps,
  805. n_source=n_source,
  806. m_target=m_target,
  807. tau=float(self.tau),
  808. eps=float(self.eps),
  809. approach=self.objective_subtype, # '1C' or '2B'
  810. loss_mode=self.loss_mode, # same modes as v2
  811. source_focal_gamma=float(self.source_focal_gamma),
  812. target_pos_weight=float(self.target_pos_weight),
  813. update_every=int(self.update_every),
  814. gap_kind=self.gap_kind,
  815. fair_grad_alpha=float(self.fair_grad_alpha),
  816. fair_grad_ema=float(self.fair_grad_ema),
  817. eq_lambda=float(self.eq_lambda),
  818. cal_lambda=float(self.cal_lambda),
  819. class1_boost=float(self.class1_boost),
  820. lambda_align=float(self.lambda_align),
  821. # v1-style options (restored)
  822. target_focal_gamma=float(self.target_focal_gamma),
  823. use_target_reg=bool(self.use_target_reg),
  824. target_weight=float(self.target_weight),
  825. # ALL-groups homogenization
  826. bary_align=bool(self.bary_align),
  827. var_align=bool(self.var_align),
  828. center_on=str(self.center_on),
  829. group_ids_source=self.group_ids_source,
  830. group_ids_target=self.group_ids_target,
  831. gap_lambda=float(getattr(self, "gap_lambda", 1.0)),
  832. ba_tau=float(getattr(self, "ba_tau", 2.0)),
  833. X_combined=X_comb,
  834. y_source=y_src
  835. )
  836. try:
  837. method_keys = [
  838. #"tau","eps","source_focal_gamma","target_focal_gamma","target_pos_weight",
  839. #"class1_boost","lambda_align",
  840. #"target_weight","eq_lambda","cal_lambda",
  841. "fair_grad_alpha","fair_grad_ema","gap_lambda","ba_tau","update_every",
  842. #"bary_align","var_align","center_on"
  843. ]
  844. meth = {k: kwargs.get(k) for k in method_keys if k in kwargs}
  845. #print("[DEBUG][CustomObjV3] method_params:", json.dumps(meth, default=str))
  846. #print("[DEBUG][CustomObjV3] xgb_params:", json.dumps(self.xgb_params, default=str))
  847. except Exception:
  848. pass
  849. # ---- V3 objective with GBA + smooth BA-gap + v1/v2-compat knobs ----
  850. return CO.CustomObjectiveV3(**kwargs)
  852. def fit(self, X, y):
  853. X_src = np.asarray(X, dtype=np.float32)
  854. y = np.asarray(y, dtype=np.float32).ravel()
  855. self.pos_rate_ = float(np.mean(y)) if y.size else 0.5
  857. X_tgt = None if self.target_X is None else np.asarray(self.target_X, dtype=np.float32)
  858. y_tgt = None if self.target_y is None else np.asarray(self.target_y, dtype=np.float32).ravel()
  860. # Align group ids lengths with source/target
  861. gid_src = None
  862. if getattr(self, "group_ids_source", None) is not None:
  863. gid_src = np.asarray(self.group_ids_source).astype(int)
  864. if gid_src.shape[0] != X_src.shape[0]:
  865. print(f"[XGB-CUSTOM] WARN: group_ids_source len {len(gid_src)} != X_src len {len(X_src)}; resizing.")
  866. if gid_src.shape[0] == 0:
  867. gid_src = np.zeros(X_src.shape[0], dtype=int)
  868. elif gid_src.shape[0] > X_src.shape[0]:
  869. gid_src = gid_src[:X_src.shape[0]]
  870. else:
  871. gid_src = np.resize(gid_src, X_src.shape[0])
  872. gid_tgt = None
  873. if X_tgt is not None and getattr(self, "group_ids_target", None) is not None:
  874. gid_tgt = np.asarray(self.group_ids_target).astype(int)
  875. if gid_tgt.shape[0] != X_tgt.shape[0]:
  876. print(f"[XGB-CUSTOM] WARN: group_ids_target len {len(gid_tgt)} != X_tgt len {len(X_tgt)}; resizing.")
  877. if gid_tgt.shape[0] == 0:
  878. gid_tgt = np.zeros(X_tgt.shape[0], dtype=int)
  879. elif gid_tgt.shape[0] > X_tgt.shape[0]:
  880. gid_tgt = gid_tgt[:X_tgt.shape[0]]
  881. else:
  882. gid_tgt = np.resize(gid_tgt, X_tgt.shape[0])
  884. if X_tgt is None:
  885. dtrain = xgb.DMatrix(X_src, label=y)
  886. else:
  887. if y_tgt is None:
  888. y_comb = np.concatenate([y, np.zeros(X_tgt.shape[0], dtype=np.float32)], axis=0)
  889. else:
  890. y_comb = np.concatenate([y, y_tgt], axis=0)
  891. dtrain = xgb.DMatrix(np.vstack([X_src, X_tgt]), label=y_comb.ravel())
  893. # optional validation for logging
  894. evals = [(dtrain, 'train')]
  895. if self.X_valid is not None and self.y_valid is not None:
  896. Xv = np.asarray(self.X_valid, dtype=np.float32)
  897. yv = np.asarray(self.y_valid, dtype=np.float32).ravel()
  898. dvalid = xgb.DMatrix(Xv, label=yv)
  899. evals.append((dvalid, 'valid'))
  901. # Override gids for this fit
  902. if gid_src is not None:
  903. self.group_ids_source = gid_src
  904. if gid_tgt is not None:
  905. self.group_ids_target = gid_tgt
  907. custom_obj = self._build_custom_obj(X_src, y, X_tgt, y_tgt)
  909. try:
  910. # # Collect eval names safely
  911. # eval_names = [name for (_, name) in (evals or [])]
  913. # # Method HPs we care to see (only include those present on self)
  914. # hp_keys = [
  915. # "tau", "eps", "target_weight",
  916. # "source_focal_gamma", "target_focal_gamma",
  917. # "target_pos_weight", "class1_boost",
  918. # "gap_lambda", "ba_tau", "update_every"
  919. # ]
  920. # method_hparams = {k: getattr(self, k) for k in hp_keys if hasattr(self, k)}
  922. # debug_info = {
  923. # "branch": "custom-xgboost-train",
  924. # "loss_mode": getattr(self, "loss_mode", None),
  925. # "approach": getattr(self, "approach", None),
  926. # "total_steps": int(self.total_steps),
  927. # "xgb_params": self.xgb_params,
  928. # "method_hparams": method_hparams,
  929. # "train_rows": getattr(dtrain, "num_row", lambda: None)(),
  930. # "train_cols": getattr(dtrain, "num_col", lambda: None)(),
  931. # "evals": eval_names,
  932. # "callbacks": [type(cb).__name__ for cb in (self.callbacks or [])],
  933. # }
  934. # print("[XGB-CUSTOM] Starting training with:", flush=True)
  935. # print(json.dumps(debug_info, indent=2, default=str), flush=True)
  937. for bad in ("n_jobs", "n_estimators"):
  938. if bad in self.xgb_params:
  939. self.xgb_params.pop(bad, None)
  941. self.booster_ = xgb.train(
  942. params=self.xgb_params,
  943. dtrain=dtrain,
  944. num_boost_round=int(self.total_steps),
  945. obj=custom_obj,
  946. evals=evals,
  947. callbacks=(self.callbacks if self.callbacks is not None else []),
  948. verbose_eval=False
  949. )
  950. # # Success log
  951. # btype = type(self.booster_).__name__
  952. # try:
  953. # attrs = self.booster_.attributes()
  954. # except Exception:
  955. # attrs = {}
  956. # print(f"[XGB-CUSTOM] Training finished. booster={btype}, attrs_keys={list(attrs.keys())}", flush=True)
  957. except Exception as e:
  958. # Failure path → DummyBooster
  959. print("[XGB-CUSTOM] TRAINING FAILED — falling back to _DummyBooster.", flush=True)
  960. print("[XGB-CUSTOM] Exception:", repr(e), flush=True)
  961. traceback.print_exc()
  962. class _DummyBooster:
  963. def predict(self, dm):
  964. n = dm.num_row()
  965. p = np.full(n, fill_value=max(1e-6, min(1-1e-6, getattr(self, "p_", 0.5))), dtype=np.float32)
  966. return p
  967. db = _DummyBooster()
  968. db.p_ = self.pos_rate_
  969. self.booster_ = db
  970. self.used_dummy_booster_ = True
  971. print(f"[XGB-CUSTOM] Using _DummyBooster with constant p_={self.pos_rate_:.6f}", flush=True)
  973. return self
  975. def predict_proba(self, X):
  976. if getattr(self, "used_dummy_booster_", False) and not getattr(self, "_warned_dummy_", False):
  977. print("[XGB-CUSTOM] WARNING: predictions come from _DummyBooster (constant probs).", flush=True)
  978. self._warned_dummy_ = True
  980. if self.booster_ is None:
  981. # constant fallback
  982. n = len(X)
  983. p = np.full(n, fill_value=max(1e-6, min(1-1e-6, getattr(self, "pos_rate_", 0.5))), dtype=np.float32)
  984. return np.vstack([1 - p, p]).T
  985. Xs = np.asarray(X, dtype=np.float32)
  986. p = self.booster_.predict(xgb.DMatrix(Xs))
  987. p = np.clip(p, 1e-6, 1 - 1e-6)
  988. return np.vstack([1 - p, p]).T
  990. def predict(self, X):
  991. if getattr(self, "used_dummy_booster_", False) and not getattr(self, "_warned_dummy_", False):
  992. print("[XGB-CUSTOM] WARNING: predictions come from _DummyBooster (constant probs).", flush=True)
  993. self._warned_dummy_ = True
  994. return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)
  997. def _xgb_vanilla_predict_proba(self, X):
  998. if hasattr(self.predictor, "predict_proba"):
  999. return self.predictor.predict_proba(X)
  1000. import numpy as np
  1001. if hasattr(self.predictor, "decision_function"):
  1002. s = np.asarray(self.predictor.decision_function(X))
  1003. if s.ndim == 1:
  1004. p1 = 1.0 / (1.0 + np.exp(-s))
  1005. return np.vstack([1.0 - p1, p1]).T
  1006. raise AttributeError("No predict_proba/decision_function available.")
  1008. def predict(self, X):
  1009. p1 = self.predict_proba(X)[:, 1]
  1010. thr = getattr(self, "best_threshold_", 0.5)
  1011. return (p1 >= thr).astype(int)

models.py at commit 6263968, no license · at the source

Overview

Authors: Ngoc-Huynh Ho1, Sokratis Charisis1, Nicolas Honnorat1, Sachintha Ransara Brandigampala1, Di Wang1, Susan R Heckbert2, Peter T Fox3, David Martinez1, David H Wang1, Timothy M Hughes4, Derek B Archer5, Timothy J Hohman5, Sudha Seshadri1, Christos Davatzikos6, Mohamad Habes1
ORCID iDs: Ngoc-Huynh Ho, Sokratis Charisis, Susan R Heckbert, Peter T Fox, David H Wang, Derek B Archer, Timothy J Hohman, Sudha Seshadri, Christos Davatzikos, Mohamad Habes
  1. Glenn Biggs Institute for Neurodegenerative Disorders, Neuroimage Analytics Laboratory and Biggs Institute Neuroimaging Core, University of Texas Health Science Center at San Antonio, San Antonio, TX USA
  2. Department of Epidemiology, University of Washington, Seattle, WA USA
  3. Research Imaging Institute, University of Texas Health Science Center at San Antonio, San Antonio, TX USA
  4. Gerontology and Geriatric Medicine, Wake Forest University School of Medicine, Winston-Salem, NC USA
  5. Vanderbilt Memory and Alzheimer’s Center, Vanderbilt University Medical Center, Nashville, TN USA
  6. Department of Radiology, University of Pennsylvania, Philadelphia, PA USA
Institutions: The University of Texas at San Antonio Health Science Center (United States); University of Washington (United States); Wake Forest University Health Sciences (United States); Wake Forest University (United States); Vanderbilt University Medical Center (United States); University of Pennsylvania (United States)
Journal: Nature communications, volume 17, issue 1, article 8026
Dates: received 30 May 2025; accepted 4 June 2026; published online 26 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-74515-w · PMID 42362543 · PMCID PMC13454470 · OpenAlex W7166086908
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), Alzheimer's / dementia (population)
Methods: Statistics, Machine learning, Spectral & time-frequency, fMRI & imaging
Keywords: Alzheimer's disease, Learning algorithms, Computational models
MeSH: Dementia*, Machine Learning*, Neuroimaging*, Black or African American, Classification Algorithms, Ethnicity, Hispanic or Latino, Humans, Magnetic Resonance Imaging, Reproducibility of Results, White (* major topic)
Topic: Dementia and Cognitive Impairment Research (Psychiatry and Mental health, Medicine), according to OpenAlex
Funding: NIA NIH HHS (P20 AG068082, P30 AG062422, P30 AG062429, P30 AG066462, P30 AG066546, P30 AG072975, P20 AG068024, P30 AG072959, P30 AG072972, P30 AG072973, P30 AG072976, P30 AG072979, R01 AG080821, P20 AG068077, P30 AG062715, P30 AG066444, R01 AG079280, U24 AG074855, P30 AG062677, P30 AG066468, P30 AG066507, P30 AG066508, P30 AG066511, P30 AG066518, P30 AG066530, R01 AG083865, U24 AG072122, P30 AG062421, P30 AG066506, P30 AG066512, P30 AG072931, P30 AG072958, P20 AG068053, P30 AG066509, P30 AG066514, P30 AG066515, P30 AG066519, P30 AG072977, P30 AG072978, P30 AG072946, P30 AG072947, R01 AG085571); NIMH NIH HHS (R56 MH074457, R01 MH074457)
Citations: not cited yet (Europe PMC); 56 references in the paper

Abstract

Dementia, a degenerative disease affecting millions globally, is projected to triple by 2050. Early and precise diagnosis is essential for effective treatment and improved quality of life. However, current diagnostic approaches often show inconsistent performance across multi-racial and multi-ethnic groups, raising concerns about fairness and clinical reliability. This study investigates performance discrepancies in dementia classification among 6584 Non-Hispanic White, 1263 Non-Hispanic African American, and 713 Hispanic White populations. We observed significant cross-group bias, particularly when models trained on one group are tested on another. To address this, we evaluated RegAlign, a few-shot domain adaptation objective that combines source-side focal learning, target-side class-weighted supervision, and class-conditional alignment to improve adaptation to underrepresented populations. Our results show that this approach substantially reduces inter-group performance gaps, especially between Non-Hispanic White and Hispanic populations. Here, we show the importance of fairness-aware learning strategies and diverse training data for improving the accuracy and equity of MRI-based dementia classification.

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

UTHSCSA-NAL/explainable_and_fair_ML_for_ADRD

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6263968edb231adf6d1ec76f65605617727fa923, 21 January 2026
Languages: Python (14), Shell (1)
Size: 24 files, 15 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (pyproject.toml)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), pandas (7 files), scikit-learn (7 files), XGBoost (3 files), SHAP (2 files), PyTorch (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
16 files
At the source: github.com/UTHSCSA-NAL/explainable_and_fair_ML_for_ADRD

Code availability

The code supporting this study is available at: https://github.com/UTHSCSA-NAL/explainable_and_fair_ML_for_ADRD.

Reproduced under the paper's license (CC BY), from the paper cited above.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 15 scripts, each with its path and the digest of its content;
  • 8 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 availability

The minimum dataset used in this study was obtained from four third-party clinical research resources: the National Alzheimer’s Coordinating Center (NACC), the Standardized Centralized Alzheimer’s & Related Dementias Neuroimaging initiative (SCAN), the Alzheimer’s Disease Neuroimaging Initiative (ADNI), and the South Texas Alzheimer’s Disease Research Center (STAC). Because these are human-participant datasets, access is restricted to protect participant privacy and is governed by each resource’s data-use procedures and agreements. NACC clinical and related research data are available to qualified researchers worldwide through the NACC Data Request Process (https://www.naccdata.org/data-request-process). Investigators must submit a data request describing the proposed project and accept the NACC Data Use Agreement. It will acknowledge requests within three business days and may request clarification if needed. Approved datasets are provided through secure download mechanisms maintained by NACC. SCAN harmonized neuroimaging-derived data, including summary, quality-control, and analysis variables, and defaced SCAN images are available through NACC’s data request system (https://scan.naccdata.org/; see also NACC Data Request Process at https://www.naccdata.org/data-request-process). Access is restricted because the resource contains human neuroimaging data and is subject to de-identification, quality-control, and data-use requirements. All submitted image data may be immediately available because additional processing steps, including defacing and QC, may be required. ADNI data are available to qualified investigators through the Laboratory of Neuro Imaging (LONI) Image and Data Archive (IDA) after acceptance of the ADNI Data Use Agreement and submission of an online application describing the investigator’s institutional affiliation and proposed data use (https://adni.loni.usc.edu/data-samples/adni-data/). Applications are generally reviewed within approximately two weeks. Approved users receive login credentials to access and download the requested data through IDA. To access STAC data, investigators and research groups may request patients, control subjects, biospecimens, and data, including through its Population Neuroscience request process (https://stxadrc.org/for-scientists/). Access is therefore restricted and managed directly by STAC. Researchers seeking access should submit a request through the STAC scientist portal. The authors do not have permission to redistribute these third-party datasets. Researchers must obtain access directly from the corresponding data custodians under the conditions described above. Source data are provided with this paper.

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, issue, pages, dates, 15 authors, 3 keywords, 11 MeSH terms, 2 funders, 41 references.

Cite

This paper

Ho, N.-H., Charisis, S., Honnorat, N., Brandigampala, S. R., Wang, D., Heckbert, S. R., Fox, P. T., Martinez, D., Wang, D. H., Hughes, T. M., Archer, D. B., Hohman, T. J., Seshadri, S., Davatzikos, C., & Habes, M. (2026). Advancing fair and explainable machine learning for neuroimaging dementia pattern classification in multi-racial and multi-ethnic populations. Nature communications, 17(1), 8026. https://doi.org/10.1038/s41467-026-74515-w

BibTeX

@article{ho2026advancing,
author = {Ho, Ngoc-Huynh and Charisis, Sokratis and Honnorat, Nicolas and Brandigampala, Sachintha Ransara and Wang, Di and Heckbert, Susan R and Fox, Peter T and Martinez, David and Wang, David H and Hughes, Timothy M and Archer, Derek B and Hohman, Timothy J and Seshadri, Sudha and Davatzikos, Christos and Habes, Mohamad},
title = {{Advancing fair and explainable machine learning for neuroimaging dementia pattern classification in multi-racial and multi-ethnic populations}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {8026},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74515-w},
url = {https://doi.org/10.1038/s41467-026-74515-w},
pmid = {42362543},
pmcid = {PMC13454470}
}

RIS

TY - JOUR
AU - Ho, Ngoc-Huynh
AU - Charisis, Sokratis
AU - Honnorat, Nicolas
AU - Brandigampala, Sachintha Ransara
AU - Wang, Di
AU - Heckbert, Susan R
AU - Fox, Peter T
AU - Martinez, David
AU - Wang, David H
AU - Hughes, Timothy M
AU - Archer, Derek B
AU - Hohman, Timothy J
AU - Seshadri, Sudha
AU - Davatzikos, Christos
AU - Habes, Mohamad
TI - Advancing fair and explainable machine learning for neuroimaging dementia pattern classification in multi-racial and multi-ethnic populations
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/26
VL - 17
IS - 1
SP - 8026
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74515-w
UR - https://doi.org/10.1038/s41467-026-74515-w
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74515-w",
"type": "article-journal",
"title": "Advancing fair and explainable machine learning for neuroimaging dementia pattern classification in multi-racial and multi-ethnic populations",
"container-title": "Nature communications",
"author": [
{
"family": "Ho",
"given": "Ngoc-Huynh"
},
{
"family": "Charisis",
"given": "Sokratis"
},
{
"family": "Honnorat",
"given": "Nicolas"
},
{
"family": "Brandigampala",
"given": "Sachintha Ransara"
},
{
"family": "Wang",
"given": "Di"
},
{
"family": "Heckbert",
"given": "Susan R"
},
{
"family": "Fox",
"given": "Peter T"
},
{
"family": "Martinez",
"given": "David"
},
{
"family": "Wang",
"given": "David H"
},
{
"family": "Hughes",
"given": "Timothy M"
},
{
"family": "Archer",
"given": "Derek B"
},
{
"family": "Hohman",
"given": "Timothy J"
},
{
"family": "Seshadri",
"given": "Sudha"
},
{
"family": "Davatzikos",
"given": "Christos"
},
{
"family": "Habes",
"given": "Mohamad"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "8026",
"DOI": "10.1038/s41467-026-74515-w",
"PMID": "42362543",
"PMCID": "PMC13454470",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74515-w",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
26
]
]
}
}

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.1016/j.eclinm.2026.104143 [code]
Intensive versus standard blood pressure control and overall brain small vessel disease burden: a post-hoc analysis of the SPRINT randomized clinical trial.
Journal: EClinicalMedicine
In common: structural MRI / diffusion, 2 references, 2 authors
[2] doi:10.1038/s41467-026-72091-7 [code]
Coupled cross-sectional and longitudinal non-negative matrix factorization reveals dominant brain aging trajectories in 48,949 individuals.
Journal: Nature communications
In common: scikit-learn, pandas, NumPy, Alzheimer's / dementia, structural MRI / diffusion, 3 references, author Christos Davatzikos
[3] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: SHAP, XGBoost, PyTorch, 3 other tools, structural MRI / diffusion, 1 reference
[4] doi:10.1038/s41467-026-71682-8 [code]
GWAS meta-analysis of cerebrospinal fluid Alzheimer's biomarkers reveals loci regulating lipids, brain volume and autophagy.
Journal: Nature communications
In common: scikit-learn, pandas, NumPy, Alzheimer's / dementia, structural MRI / diffusion, author Timothy Hohman
[5] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: SHAP, XGBoost, PyTorch, 3 other tools, Alzheimer's / dementia
[6] doi:10.21203/rs.3.rs-9914920/v1 [code]
Prediction of cognitive performance by demographics, sleep, and brain morphometry: machine learning findings from ENIGMA-Sleep Working Group
Journal: Research Square (preprint)
In common: SHAP, XGBoost, scikit-learn, 2 other tools, structural MRI / diffusion, 1 reference
[7] doi:10.1038/s41586-026-10454-2 [code]
White matter micro- and macrostructure brain charts for the human lifespan.
Journal: Nature
In common: pandas, NumPy, 1 reference, author Timothy Hohman
[8] doi:10.1038/s41591-026-04485-5 [code]
Blood-based circular RNAs for early diagnosis of Alzheimer's disease.
Journal: Nature medicine
In common: NumPy, Alzheimer's / dementia, 1 reference, author Timothy Hohman
[9] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: SHAP, XGBoost, PyTorch, 3 other tools
[10] doi:10.1371/journal.pcbi.1014615 [code]
Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains.
Journal: PLoS computational biology
In common: SHAP, XGBoost, PyTorch, 3 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.