OSCR

CT-based radiomic markers to predict late-onset seizures after traumatic brain injury.

Code ↔ Paper

3 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 3 matches
  1. [1] § Methods › Model training ↔ NIFTItraining.py, lines 1–81 · score 0.94 · nested cross validation, training folds, variance thresholding, SelectKBest, feature selection, Logistic Regression
  2. [2] § Methods › NCCT processing ↔ NIFTIprocessing.py, lines 22–33 · score 0.68 · dcm2niix, DICOM images, NIfTI
  3. [3] § Methods › Feature extraction ↔ NIFTItraining.py, lines 1113–1159 · score 0.52 · social determinant, integer, sex, encoded

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,552 lines · 64 KB · no license · 2 matches

  1. """
  2. NIFTItrainingNestedCV.py
  3. -----------------------
  5. This script implements a robust, modular machine learning pipeline for tabular data (e.g., radiomics features) with support for nested cross-validation (nested CV) for unbiased model selection and evaluation.
  7. Key Features:
  8. - Modular pipeline classes for Random Forest and Logistic Regression, easily extensible to other models.
  9. - Automatic feature selection (SelectKBest) and preprocessing (imputation, scaling, variance thresholding).
  10. - Hyperparameter tuning using GridSearchCV or RandomizedSearchCV.
  11. - Nested cross-validation: outer loop for unbiased test evaluation, inner loop for hyperparameter search.
  12. - Centralized saving and reporting of all metrics, including nested CV results.
  14. Usage:
  15. - Place your patient feature CSV in the expected location (see FEATURES_CSV).
  16. - Customize the models list in main() to add/remove models.
  17. - Run the script. Results and metrics will be saved in the trainingML/ subdirectory.
  19. Class/Function Documentation:
  20. -----------------------------
  22. BaseMLPipeline:
  23. - Base class for ML pipelines. Handles pipeline construction, feature selection, and search_fit (hyperparameter tuning).
  24. - Methods:
  25. - __init__: Sets up the pipeline steps and estimator.
  26. - search_fit: Runs GridSearchCV or RandomizedSearchCV for hyperparameter tuning. Stores best estimator and metrics.
  27. - save: Saves the trained pipeline and all metrics, including nested CV results if provided.
  29. RandomForestMLPipeline, LogisticRegressionMLPipeline:
  30. - Subclasses of BaseMLPipeline with default estimators and parameter grids for each model type.
  32. nested_cv_evaluate:
  33. - Runs nested cross-validation for a given pipeline and dataset.
  34. - Outer loop: splits data into train/test folds for unbiased evaluation.
  35. - Inner loop: runs hyperparameter search (search_fit) on the training fold.
  36. - Returns test accuracies and best parameters for each outer fold.
  38. main:
  39. - Loads data and defines models.
  40. - Runs nested CV for each model, prints and saves results using the pipeline's save method.
  42. Pipeline Steps:
  43. - Imputation (median), scaling (StandardScaler), variance thresholding, feature selection (SelectKBest), classifier (clf).
  44. - 'clf' is the final classifier step (e.g., RandomForestClassifier or LogisticRegression).
  46. Outputs:
  47. - For each model, saves a metrics file with:
  48. - Best parameters (if available)
  49. - Accuracy, confusion matrix, classification report, top features (if available)
  50. - Nested CV results: mean and per-fold test accuracy, best params per fold
  52. Best Practices:
  53. - Nested CV provides an unbiased estimate of model performance, especially important for small datasets.
  54. - All reporting and saving is centralized for reproducibility and clarity.
  56. """
  58. import os
  59. import numpy as np
  60. import pandas as pd
  61. import warnings
  62. import NIFTIpatient
  63. from sklearn.model_selection import (
  64. GridSearchCV,
  65. RandomizedSearchCV,
  66. StratifiedKFold,
  67. )
  68. from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
  69. from sklearn.pipeline import Pipeline
  70. from sklearn.impute import SimpleImputer
  71. from sklearn.preprocessing import StandardScaler
  72. from sklearn.compose import ColumnTransformer
  73. from sklearn.feature_selection import VarianceThreshold, SelectKBest, f_classif
  74. from sklearn.linear_model import LogisticRegression
  75. from sklearn.ensemble import RandomForestClassifier
  76. import joblib
  77. import random
  78. from collections import Counter, defaultdict
  80. import xgboost as xgb # For future use
  81. from xgboost import XGBClassifier, XGBRFClassifier
  83. # For ROC curve plotting
  84. from sklearn.metrics import roc_curve, auc
  85. from sklearn.model_selection import train_test_split
  86. import matplotlib.pyplot as plt
  88. from sklearn.metrics import (
  89. precision_score,
  90. recall_score,
  91. f1_score,
  92. roc_auc_score,
  93. )
  95. # Filter out expected warnings from scikit-learn
  96. # This occurs during feature selection when features have zero variance or cause numerical issues
  97. warnings.filterwarnings(
  98. "ignore", category=RuntimeWarning, message="invalid value encountered in divide"
  99. )
  100. # This was about the data format, which we fixed but the warning filters provide an extra safety net
  101. warnings.filterwarnings(
  102. "ignore", category=UserWarning, message=".*column-vector y was passed.*"
  103. )
  104. # This occurs when a class has no predicted samples, which is common in small datasets
  105. warnings.filterwarnings(
  106. "ignore", category=UserWarning, message=".*Precision is ill-defined.*"
  107. )
  110. # Standalone class for plotting ROC curve for binary classifiers
  111. class ROCCurvePlotter:
  112. """
  113. Utility class to plot ROC curve for binary classifiers.
  114. Usage:
  115. plotter = ROCCurvePlotter(y_true, y_score, title="ROC Curve")
  116. plotter.plot()
  117. Args:
  118. y_true: array-like of shape (n_samples,) - True binary labels (0 or 1)
  119. y_score: array-like of shape (n_samples,) - Target scores, can be probability estimates of the positive class
  120. title: str - Title for the plot
  121. """
  123. def __init__(self, y_true, y_score, title="ROC Curve"):
  124. """
  125. Initialize with true labels and predicted scores.
  127. Args:
  128. y_true (array-like of shape (n_samples,): True binary labels (0 or 1)
  129. y_score (array-like of shape (n_samples,): Target scores, can be probability estimates of the positive class
  130. title (str): Title for the plot
  131. Returns:
  132. None
  133. """
  134. self.y_true = y_true
  135. self.y_score = y_score
  136. self.title = title
  137. self.fpr = None
  138. self.tpr = None
  139. self.thresholds = None
  140. self.roc_auc = None
  142. def compute(self):
  143. """
  144. Computes FPR, TPR, thresholds, and AUC.
  146. Args:
  147. None
  149. Returns:
  150. None
  151. """
  152. self.fpr, self.tpr, self.thresholds = roc_curve(self.y_true, self.y_score)
  153. self.roc_auc = auc(self.fpr, self.tpr)
  155. def plot(self, show=True, save_path=None):
  156. """
  157. Plots the ROC curve.
  159. Args:
  160. show (bool): If True, display the plot interactively.
  161. save_path (str or None): If provided, save the plot to this path.
  163. Returns:
  164. None
  165. """
  166. self.compute()
  167. plt.figure()
  168. plt.plot(
  169. self.fpr,
  170. self.tpr,
  171. color="darkorange",
  172. lw=2,
  173. label=f"ROC curve (AUC = {self.roc_auc:.2f})",
  174. )
  175. plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--")
  176. plt.xlim([0.0, 1.0])
  177. plt.ylim([0.0, 1.05])
  178. plt.xlabel("False Positive Rate")
  179. plt.ylabel("True Positive Rate")
  180. plt.title(self.title)
  181. plt.legend(loc="lower right")
  182. if save_path:
  183. plt.savefig(save_path)
  184. if show:
  185. plt.show()
  186. plt.close()
  188. @staticmethod
  189. def plot_nested_cv_roc_curves(
  190. roc_data, save_path=None, title="Nested CV ROC Curves", csv_path=None
  191. ):
  192. """
  193. Plot all ROC curves from nested CV runs on the same graph.
  195. Args:
  196. roc_data (list of tuples): list of (fpr, tpr, auc, fold) tuples
  197. save_path (str or None): if provided, save the plot to this path
  198. title (str): plot title
  199. csv_path (str or None): if provided, save all ROC data to this CSV for reproducibility
  201. Returns:
  202. None
  203. """
  205. plt.figure(figsize=(8, 6))
  206. aucs = []
  207. # Optionally save all ROC data to CSV for reproducibility
  208. if csv_path is not None:
  209. # Flatten all ROC data into a DataFrame
  210. rows = []
  211. for fpr, tpr, roc_auc, fold in roc_data:
  212. for f, t in zip(fpr, tpr):
  213. rows.append({"fold": fold, "fpr": f, "tpr": t, "auc": roc_auc})
  214. pd.DataFrame(rows).to_csv(csv_path, index=False)
  215. for fpr, tpr, roc_auc, fold in roc_data:
  216. plt.plot(fpr, tpr, lw=2, label=f"Fold {fold} (AUC = {roc_auc:.2f})")
  217. aucs.append(roc_auc)
  218. mean_auc = np.mean(aucs)
  219. std_auc = np.std(aucs, ddof=1)
  220. n = len(aucs)
  221. # 95% CI for mean: mean ± 1.96 * (std / sqrt(n))
  222. if n > 1:
  223. ci95 = 1.96 * (std_auc / np.sqrt(n))
  224. ci_low = mean_auc - ci95
  225. ci_high = mean_auc + ci95
  226. ci_str = f"95% CI: [{ci_low:.3f}, {ci_high:.3f}]"
  227. else:
  228. ci_str = ""
  229. plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--", label="Chance")
  230. plt.xlim([0.0, 1.0])
  231. plt.ylim([0.0, 1.05])
  232. plt.xlabel("False Positive Rate")
  233. plt.ylabel("True Positive Rate")
  234. title_str = f"{title}\nMean AUC = {mean_auc:.3f} ± {std_auc:.3f}"
  235. if ci_str:
  236. title_str += f"\n{ci_str}"
  237. plt.title(title_str)
  238. plt.legend(loc="lower right")
  239. if save_path:
  240. plt.savefig(save_path)
  241. # Do not show the plot interactively
  242. plt.close()
  244. @staticmethod
  245. def plot_holdout_roc_curves_across_seeds(
  246. roc_data, save_path=None, title="Holdout ROC Curves Across Seeds", csv_path=None
  247. ):
  248. """
  249. Plot all holdout ROC curves from different seeds for a single model.
  251. Args:
  252. roc_data (list of tuples): list of (fpr, tpr, auc, seed) tuples
  253. save_path (str or None): if provided, save the plot to this path
  254. title (str): plot title
  255. csv_path (str or None): if provided, save all ROC data to this CSV for reproducibility
  257. Returns:
  258. None
  259. """
  260. plt.figure(figsize=(8, 6))
  261. aucs = []
  262. # Optionally save all ROC data to CSV for reproducibility
  263. if csv_path is not None:
  264. rows = []
  265. for fpr, tpr, roc_auc, seed in roc_data:
  266. for f, t in zip(fpr, tpr):
  267. rows.append({"seed": seed, "fpr": f, "tpr": t, "auc": roc_auc})
  268. pd.DataFrame(rows).to_csv(csv_path, index=False)
  269. for fpr, tpr, roc_auc, seed in roc_data:
  270. plt.plot(fpr, tpr, lw=2, label=f"Seed {seed} (AUC = {roc_auc:.2f})")
  271. aucs.append(roc_auc)
  272. mean_auc = np.mean(aucs)
  273. std_auc = np.std(aucs, ddof=1)
  274. n = len(aucs)
  275. # 95% CI for mean: mean ± 1.96 * (std / sqrt(n))
  276. if n > 1:
  277. ci95 = 1.96 * (std_auc / np.sqrt(n))
  278. ci_low = mean_auc - ci95
  279. ci_high = mean_auc + ci95
  280. ci_str = f"95% CI: [{ci_low:.3f}, {ci_high:.3f}]"
  281. else:
  282. ci_str = ""
  283. plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--", label="Chance")
  284. plt.xlim([0.0, 1.0])
  285. plt.ylim([0.0, 1.05])
  286. plt.xlabel("False Positive Rate")
  287. plt.ylabel("True Positive Rate")
  288. title_str = f"{title}\nMean AUC = {mean_auc:.3f} ± {std_auc:.3f}"
  289. if ci_str:
  290. title_str += f"\n{ci_str}"
  291. plt.title(title_str)
  292. plt.legend(loc="lower right")
  293. if save_path:
  294. plt.savefig(save_path)
  295. plt.close()
  298. class BaseMLPipeline:
  299. def get_preprocessed_feature_names(self, pipeline, X):
  300. """
  301. Retrieve feature names after preprocessing, with fallback and prefix stripping.
  303. Args:
  304. pipeline (skLearn Pipeline object): The fitted pipeline.
  305. X (pandas DataFrame): Original input features.
  306. Returns:
  307. feature_names (list of str): List of feature names after preprocessing.
  308. """
  310. if "preprocess" in pipeline.named_steps:
  311. try:
  312. X_preprocessed = pipeline.named_steps["preprocess"].transform(X)
  313. if hasattr(pipeline.named_steps["preprocess"], "get_feature_names_out"):
  314. feature_names = pipeline.named_steps[
  315. "preprocess"
  316. ].get_feature_names_out()
  317. else:
  318. feature_names = [f"f{i}" for i in range(X_preprocessed.shape[1])]
  319. except Exception:
  320. feature_names = X.columns
  321. else:
  322. feature_names = X.columns
  323. # Strip 'remainder__' prefix
  324. feature_names = [f.replace("remainder__", "") for f in feature_names]
  325. return feature_names
  327. """
  328. BaseMLPipeline: A flexible base class for building and running ML pipelines on tabular data.
  329. Customize the pipeline steps, estimator, and feature selection as needed for your use case.
  330. """
  332. def __init__(
  333. self,
  334. n_features=None,
  335. estimator=None,
  336. random_state=None,
  337. ord_categories=None,
  338. ):
  339. """
  340. Initialize the ML pipeline with preprocessing, feature selection, and estimator.
  342. Args:
  343. n_features (int or None): Number of top features to select (SelectKBest). If None, 'all' is used.
  344. estimator (sklearn estimator): The final estimator (classifier/regressor) to use.
  345. random_state (int or None): Random state for reproducibility.
  346. ord_categories (dict or None): Categorical feature categories for ordinal encoding (if needed).
  348. Returns:
  349. None
  350. """
  352. # If n_features is None, we'll let GridSearch tune select__k and default SelectKBest to 'all'
  353. self.n_features = n_features
  354. self.random_state = random_state
  355. # Define categorical columns for mhhcohort data (excluding target variable 'pts')
  356. self.ord_categories = ord_categories
  358. # Treat all features as numeric (already encoded). Single median imputation.
  359. # IF CATEGORICAL FEATURES ARE PRESENT, modify this step to include OrdinalEncoder
  360. preprocessor = SimpleImputer(strategy="median")
  362. pipeline_steps = [
  363. ("preprocess", preprocessor),
  364. ("scale", StandardScaler()),
  365. ("var_thresh", VarianceThreshold(threshold=0.01)),
  366. (
  367. "select",
  368. SelectKBest(
  369. score_func=f_classif,
  370. k=(self.n_features if self.n_features is not None else "all"),
  371. ),
  372. ),
  373. ]
  375. self.estimator = estimator
  376. pipeline_steps.append(("clf", estimator))
  377. self.pipeline = Pipeline(pipeline_steps)
  378. self.selected_features_ = None
  379. self.importances_ = None
  380. self.metrics_ = None
  382. def search_fit(
  383. self,
  384. X,
  385. y,
  386. random_state,
  387. search_type="grid",
  388. param_grid=None,
  389. n_iter=10,
  390. cv=5,
  391. scoring="accuracy",
  392. ):
  393. """
  394. Perform hyperparameter search (GridSearchCV or RandomizedSearchCV) and fit the pipeline.
  396. Args:
  397. X (array-like of shape (n_samples, n_features)): Input features.
  398. y (array-like of shape (n_samples,)): Target labels.
  399. random_state (int): Random state for reproducibility.
  400. search_type (str): "grid" for GridSearchCV, "random" for RandomizedSearchCV.
  401. param_grid (dict): Parameter grid or distributions for search.
  402. n_iter (int): Number of iterations for RandomizedSearchCV (ignored for GridSearchCV).
  403. cv (int): Number of cross-validation folds.
  404. scoring (str): Scoring metric for evaluation.
  406. Returns:
  407. search (sklearn GridSearchCV or RandomizedSearchCV object): Fitted search object.
  408. """
  410. if search_type == "grid":
  411. search = GridSearchCV(
  412. self.pipeline, param_grid, cv=cv, scoring=scoring, n_jobs=-1
  413. )
  414. elif search_type == "random":
  415. search = RandomizedSearchCV(
  416. self.pipeline,
  417. param_distributions=param_grid,
  418. n_iter=n_iter,
  419. cv=cv,
  420. scoring=scoring,
  421. random_state=random_state,
  422. n_jobs=-1,
  423. )
  424. else:
  425. raise ValueError("search_type must be 'grid' or 'random'")
  427. search.fit(X, y)
  428. best_pipeline = search.best_estimator_
  429. y_pred = best_pipeline.predict(X)
  431. cm = confusion_matrix(y, y_pred)
  432. # Specificity: TN / (TN + FP)
  433. if cm.shape == (2, 2):
  434. tn, fp, fn, tp = cm.ravel()
  435. specificity = tn / (tn + fp) if (tn + fp) > 0 else np.nan
  436. else:
  437. specificity = np.nan
  438. # AUC: only if y has both classes and proba/decision available
  439. try:
  440. if hasattr(best_pipeline.named_steps["clf"], "predict_proba"):
  441. y_score = best_pipeline.named_steps["clf"].predict_proba(X)[:, 1]
  442. else:
  443. y_score = best_pipeline.named_steps["clf"].decision_function(X)
  444. auc_val = roc_auc_score(y, y_score)
  445. except Exception:
  446. auc_val = np.nan
  447. metrics = {
  448. "best_params": search.best_params_,
  449. "accuracy": accuracy_score(y, y_pred),
  450. "precision": precision_score(y, y_pred, zero_division=0),
  451. "recall": recall_score(y, y_pred, zero_division=0),
  452. "specificity": specificity,
  453. "f1": f1_score(y, y_pred, zero_division=0),
  454. "auc": auc_val,
  455. "confusion_matrix": cm,
  456. "classification_report": classification_report(y, y_pred),
  457. }
  458. if (
  459. hasattr(best_pipeline.named_steps["clf"], "feature_importances_")
  460. and "select" in best_pipeline.named_steps
  461. ):
  462. # Get feature names after preprocessing
  463. preprocessed_feature_names = self.get_preprocessed_feature_names(
  464. best_pipeline, X
  465. )
  467. # Get the feature names after variance threshold but before selection
  468. if "var_thresh" in best_pipeline.named_steps:
  469. var_thresh_mask = best_pipeline.named_steps["var_thresh"].get_support()
  470. features_after_var_thresh = np.array(preprocessed_feature_names)[
  471. var_thresh_mask
  472. ]
  473. else:
  474. features_after_var_thresh = preprocessed_feature_names
  476. # Get the selection mask and apply it to the reduced feature set
  477. selected_mask = best_pipeline.named_steps["select"].get_support()
  478. selected_features = features_after_var_thresh[selected_mask]
  479. importances = best_pipeline.named_steps["clf"].feature_importances_
  480. importances_series = pd.Series(importances, index=selected_features)
  481. metrics["top_features"] = importances_series.sort_values(ascending=False)
  482. elif (
  483. hasattr(best_pipeline.named_steps["clf"], "coef_")
  484. and "select" in best_pipeline.named_steps
  485. ):
  486. # Get feature names after preprocessing
  487. preprocessed_feature_names = self.get_preprocessed_feature_names(
  488. best_pipeline, X
  489. )
  491. # Get the feature names after variance threshold but before selection
  492. if "var_thresh" in best_pipeline.named_steps:
  493. var_thresh_mask = best_pipeline.named_steps["var_thresh"].get_support()
  494. features_after_var_thresh = np.array(preprocessed_feature_names)[
  495. var_thresh_mask
  496. ]
  497. else:
  498. features_after_var_thresh = preprocessed_feature_names
  500. # Get the selection mask and apply it to the reduced feature set
  501. selected_mask = best_pipeline.named_steps["select"].get_support()
  502. selected_features = features_after_var_thresh[selected_mask]
  503. # Use absolute values of coefficients for importance
  504. coefs = np.abs(best_pipeline.named_steps["clf"].coef_[0])
  505. importances_series = pd.Series(coefs, index=selected_features)
  506. metrics["top_features"] = importances_series.sort_values(ascending=False)
  507. # Store signed coefficients for direction interpretation (positive = increases PTS odds, negative = decreases)
  508. signed_coefs = best_pipeline.named_steps["clf"].coef_[0]
  509. metrics["signed_coefficients"] = pd.Series(signed_coefs, index=selected_features)
  510. self.metrics_ = metrics
  511. self.pipeline = best_pipeline
  512. return search
  514. def save(self, model_path=None, metrics_path=None, nested_cv_results=None):
  515. """
  516. Save the trained pipeline and comprehensive metrics report.
  518. Args:
  519. model_path (str or None): If provided, save the trained pipeline to this path.
  520. metrics_path (str or None): If provided, save the comprehensive metrics report to this path.
  521. nested_cv_results (tuple or None): If provided, should be (test_scores, best_params_list, model_name)
  523. Returns:
  524. None
  525. """
  526. if model_path is not None:
  527. joblib.dump(self.pipeline, model_path)
  528. if metrics_path is not None:
  529. with open(metrics_path, "w") as f:
  530. f.write("ML Pipeline Comprehensive Report\n")
  531. f.write("=" * 50 + "\n\n")
  533. # Nested CV Results (Unbiased Performance Estimate)
  534. if nested_cv_results is not None:
  535. test_scores, best_params_list, model_name = nested_cv_results
  536. f.write("NESTED CROSS-VALIDATION RESULTS (Unbiased Performance)\n")
  537. f.write("-" * 55 + "\n")
  538. f.write(
  539. f"Mean test accuracy: {np.mean(test_scores):.3f} ± {np.std(test_scores):.3f}\n"
  540. )
  541. f.write(f"All test accuracies: {test_scores}\n")
  542. f.write(f"Best hyperparameters per fold:\n")
  543. for i, params in enumerate(best_params_list):
  544. f.write(f" Fold {i+1}: {params}\n")
  545. f.write("\n")
  547. # Final / Hold-out Results (Feature Interpretation)
  548. if self.metrics_ is not None:
  549. f.write("FINAL MODEL RESULTS\n")
  550. f.write("-" * 45 + "\n")
  552. if "best_params" in self.metrics_:
  553. f.write(
  554. f"Best hyperparameters: {self.metrics_['best_params']}\n"
  555. )
  557. # Training metrics (if provided)
  558. if any(k.startswith("train_") for k in self.metrics_.keys()):
  559. f.write("\nTRAINING SET PERFORMANCE\n")
  560. f.write("~" * 30 + "\n")
  561. if self.metrics_.get("train_accuracy") is not None:
  562. f.write(
  563. f"Accuracy: {self.metrics_['train_accuracy']:.3f}\n"
  564. )
  565. if self.metrics_.get("train_confusion_matrix") is not None:
  566. f.write("Confusion Matrix:\n")
  567. f.write(str(self.metrics_["train_confusion_matrix"]) + "\n")
  568. if self.metrics_.get("train_classification_report") is not None:
  569. f.write("Classification Report:\n")
  570. f.write(self.metrics_["train_classification_report"] + "\n")
  571. # Add extra metrics if available
  572. for k in [
  573. "train_precision",
  574. "train_recall",
  575. "train_specificity",
  576. "train_f1",
  577. "train_auc",
  578. ]:
  579. if self.metrics_.get(k) is not None:
  580. f.write(
  581. f"{k.replace('train_','').capitalize()}: {self.metrics_[k]:.3f}\n"
  582. )
  583. else:
  584. # Backward compatibility: older single-set metrics
  585. if self.metrics_.get("accuracy") is not None:
  586. f.write(
  587. f"Training accuracy: {self.metrics_.get('accuracy'):.3f}\n"
  588. )
  589. if self.metrics_.get("precision") is not None:
  590. f.write(
  591. f"Precision: {self.metrics_.get('precision'):.3f}\n"
  592. )
  593. if self.metrics_.get("recall") is not None:
  594. f.write(f"Recall: {self.metrics_.get('recall'):.3f}\n")
  595. if self.metrics_.get("specificity") is not None:
  596. f.write(
  597. f"Specificity: {self.metrics_.get('specificity'):.3f}\n"
  598. )
  599. if self.metrics_.get("f1") is not None:
  600. f.write(f"F1 score: {self.metrics_.get('f1'):.3f}\n")
  601. if self.metrics_.get("auc") is not None:
  602. f.write(f"AUC: {self.metrics_.get('auc'):.3f}\n")
  603. if self.metrics_.get("confusion_matrix") is not None:
  604. f.write("Confusion Matrix (Training Data):\n")
  605. f.write(str(self.metrics_.get("confusion_matrix")) + "\n")
  606. if self.metrics_.get("classification_report") is not None:
  607. f.write("Classification Report (Training Data):\n")
  608. f.write(self.metrics_.get("classification_report") + "\n")
  610. # Test metrics (hold-out set)
  611. if any(k.startswith("test_") for k in self.metrics_.keys()):
  612. f.write("\nHOLD-OUT TEST SET PERFORMANCE (20%)\n")
  613. f.write("~" * 45 + "\n")
  614. if self.metrics_.get("test_accuracy") is not None:
  615. f.write(f"Accuracy: {self.metrics_['test_accuracy']:.3f}\n")
  616. if self.metrics_.get("test_precision") is not None:
  617. f.write(
  618. f"Precision: {self.metrics_['test_precision']:.3f}\n"
  619. )
  620. if self.metrics_.get("test_recall") is not None:
  621. f.write(f"Recall: {self.metrics_['test_recall']:.3f}\n")
  622. if self.metrics_.get("test_specificity") is not None:
  623. f.write(
  624. f"Specificity: {self.metrics_['test_specificity']:.3f}\n"
  625. )
  626. if self.metrics_.get("test_f1") is not None:
  627. f.write(f"F1 score: {self.metrics_['test_f1']:.3f}\n")
  628. if self.metrics_.get("test_auc") is not None:
  629. f.write(f"ROC AUC: {self.metrics_['test_auc']:.3f}\n")
  630. if self.metrics_.get("test_confusion_matrix") is not None:
  631. f.write("Confusion Matrix:\n")
  632. f.write(str(self.metrics_["test_confusion_matrix"]) + "\n")
  633. if self.metrics_.get("test_classification_report") is not None:
  634. f.write("Classification Report:\n")
  635. f.write(self.metrics_["test_classification_report"] + "\n")
  637. # Feature importance / coefficients
  638. if self.metrics_.get("top_features", None) is not None:
  639. all_feats_series = self.metrics_["top_features"]
  640. signed_coefs = self.metrics_.get("signed_coefficients", None)
  641. # Preview
  642. f.write("\nTOP FEATURES PREVIEW (first 20 shown):\n")
  643. f.write("-" * 45 + "\n")
  644. preview = all_feats_series.head(20)
  645. f.write(preview.to_string() + "\n\n")
  646. # Full list with direction for signed coefficients
  647. f.write("FULL RANKED FEATURE LIST:\n")
  648. f.write("-" * 45 + "\n")
  649. if signed_coefs is not None:
  650. f.write("Feature, Importance (abs), Coefficient (signed), Direction\n")
  651. f.write("-" * 45 + "\n")
  652. for feature, importance in all_feats_series.items():
  653. coef = signed_coefs[feature]
  654. direction = "INCREASES PTS" if coef > 0 else "DECREASES PTS"
  655. f.write(f"{feature:60s} | {importance:10.6f} | {coef:10.6f} | {direction}\n")
  656. f.write("\n")
  657. else:
  658. f.write(all_feats_series.to_string() + "\n\n")
  659. selected_features = all_feats_series.index.tolist()
  660. f.write("ALL SELECTED FEATURES (ordered):\n")
  661. f.write("-" * 45 + "\n")
  662. for i, feature in enumerate(selected_features, 1):
  663. if signed_coefs is not None:
  664. coef = signed_coefs[feature]
  665. direction = "[+]" if coef > 0 else "[-]"
  666. f.write(f"{i:3d}. {feature:55s} {direction}\n")
  667. else:
  668. f.write(f"{i:3d}. {feature}\n")
  670. if model_path is not None:
  671. print(f"Final model saved to: {model_path}")
  672. if metrics_path is not None:
  673. print(f"Comprehensive metrics saved to: {metrics_path}")
  676. class RandomForestMLPipeline(BaseMLPipeline):
  677. def __init__(
  678. self, n_features=None, random_state=None, ord_categories=None, param_grid=None
  679. ):
  680. """
  681. Initialize RandomForestMLPipeline with default RandomForestClassifier and parameter grid.
  683. Args:
  684. n_features (int or None): Number of top features to select (SelectKBest). If None, 'all' is used.
  685. random_state (int or None): Random state for reproducibility.
  686. ord_categories (dict or None): Categorical feature categories for ordinal encoding (if needed).
  687. param_grid (dict or None): Parameter grid for hyperparameter search. If None, default grid is used.
  689. Returns:
  690. None
  691. """
  692. super().__init__(
  693. n_features=n_features,
  694. estimator=RandomForestClassifier(
  695. n_estimators=100, random_state=random_state, n_jobs=-1
  696. ),
  697. random_state=random_state,
  698. ord_categories=ord_categories,
  699. )
  700. # Default or user-supplied param grid for search
  701. self.param_grid = param_grid or {
  702. "select__k": [10, 20, 30, 40, 50, 60, 70, 80, 100],
  703. "clf__n_estimators": [100, 200],
  704. "clf__max_depth": [None, 5, 10],
  705. }
  708. class LogisticRegressionMLPipeline(BaseMLPipeline):
  709. def __init__(
  710. self, n_features=None, random_state=None, ord_categories=None, param_grid=None
  711. ):
  712. """
  713. Initialize LogisticRegressionMLPipeline with default LogisticRegression and parameter grid.
  715. Args:
  716. n_features (int or None): Number of top features to select (SelectKBest). If None, 'all' is used.
  717. random_state (int or None): Random state for reproducibility.
  718. ord_categories (dict or None): Categorical feature categories for ordinal encoding (if needed).
  719. param_grid (dict or None): Parameter grid for hyperparameter search. If None, default grid is used.
  721. Returns:
  722. None
  723. """
  724. super().__init__(
  725. n_features=n_features,
  726. estimator=LogisticRegression(max_iter=1000, random_state=random_state),
  727. random_state=random_state,
  728. ord_categories=ord_categories,
  729. )
  730. # Default or user-supplied param grid for search
  731. self.param_grid = param_grid or {
  732. "select__k": [10, 20, 30, 40],
  733. "clf__C": [0.1, 1, 10],
  734. "clf__penalty": ["l2"],
  735. }
  738. class XGBoostMLPipeline(BaseMLPipeline):
  739. def __init__(
  740. self, n_features=None, random_state=None, ord_categories=None, param_grid=None
  741. ):
  742. """
  743. Initialize XGBoostMLPipeline with default XGBClassifier and parameter grid.
  745. Args:
  746. n_features (int or None): Number of top features to select (SelectKBest). If None, 'all' is used.
  747. random_state (int or None): Random state for reproducibility.
  748. ord_categories (dict or None): Categorical feature categories for ordinal encoding (if needed).
  749. param_grid (dict or None): Parameter grid for hyperparameter search. If None, default grid is used.
  751. Returns:
  752. None
  754. """
  756. super().__init__(
  757. n_features=n_features,
  758. estimator=XGBClassifier(
  759. use_label_encoder=False,
  760. eval_metric="logloss",
  761. random_state=random_state,
  762. n_jobs=-1,
  763. ),
  764. random_state=random_state,
  765. ord_categories=ord_categories,
  766. )
  767. # Default or user-supplied param grid for search
  768. self.param_grid = param_grid or {
  769. "select__k": [10, 20, 30, 40, 50],
  770. "clf__max_depth": [3, 5, 7],
  771. "clf__n_estimators": [100, 200],
  772. "clf__learning_rate": [0.01, 0.1, 0.2],
  773. }
  776. class XGBoostRFMLPipeline(BaseMLPipeline):
  777. def __init__(
  778. self, n_features=None, random_state=None, ord_categories=None, param_grid=None
  779. ):
  780. """
  781. Initialize XGBoostRFMLPipeline with default XGBRFClassifier and parameter grid.
  783. Args:
  784. n_features (int or None): Number of top features to select (SelectKBest). If None, 'all' is used.
  785. random_state (int or None): Random state for reproducibility.
  786. ord_categories (dict or None): Categorical feature categories for ordinal encoding (if needed).
  787. param_grid (dict or None): Parameter grid for hyperparameter search. If None, default grid is used.
  789. Returns:
  790. None
  791. """
  793. super().__init__(
  794. n_features=n_features,
  795. estimator=XGBRFClassifier(
  796. use_label_encoder=False,
  797. eval_metric="logloss",
  798. random_state=random_state,
  799. n_jobs=-1,
  800. ),
  801. random_state=random_state,
  802. ord_categories=ord_categories,
  803. )
  804. # Default or user-supplied param grid for search
  805. self.param_grid = param_grid or {
  806. "select__k": [10, 20, 30, 40, 50],
  807. "clf__max_depth": [3, 5, 7],
  808. "clf__n_estimators": [100, 200],
  809. "clf__learning_rate": [0.01, 0.1, 0.2],
  810. "clf__subsample": [0.8, 1.0],
  811. }
  814. def nested_cv_evaluate(pipeline, X, y, outer_cv=3, inner_cv=3, search_type="random"):
  815. """
  816. Perform nested cross-validation for unbiased model selection and evaluation.
  817. Returns a list of test scores and best params for each outer fold.
  819. Args:
  820. pipeline (BaseMLPipeline instance): The ML pipeline to evaluate.
  821. X (pandas DataFrame): Input features.
  822. y (array-like): Target labels.
  823. outer_cv (int): Number of outer CV folds.
  824. inner_cv (int): Number of inner CV folds.
  825. search_type (str): "grid" or "random" for hyperparameter search.
  827. Returns:
  828. test_scores (list of floats): Test accuracies for each outer fold.
  829. best_params_list (list of dicts): Best hyperparameters for each outer fold.
  830. roc_data (list of tuples [fpr,tpr,auc,fold]): ROC curve data for each outer fold.
  831. """
  833. outer = StratifiedKFold(
  834. random_state=pipeline.random_state, n_splits=outer_cv, shuffle=True
  835. )
  836. test_scores = []
  837. best_params_list = []
  838. roc_data = [] # List of (fpr, tpr, auc, fold) for each fold
  839. fold = 1
  840. for train_idx, test_idx in outer.split(X, y):
  841. print(f"Indices are {train_idx}, {test_idx}")
  842. print(f"\n=== Outer Fold {fold} ===")
  843. X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
  844. y_train, y_test = y[train_idx], y[test_idx]
  845. # Recreate a fresh model of the same type; do not pass n_features so select__k is tuned via param_grid
  846. model = type(pipeline)(
  847. random_state=pipeline.random_state, ord_categories=pipeline.ord_categories
  848. )
  849. param_grid = getattr(model, "param_grid", None)
  850. model.search_fit(
  851. X_train,
  852. y_train,
  853. random_state=pipeline.random_state,
  854. search_type=search_type,
  855. param_grid=param_grid,
  856. cv=inner_cv,
  857. )
  858. y_pred = model.pipeline.predict(X_test)
  859. acc = accuracy_score(y_test, y_pred)
  860. print(f"Test accuracy (outer fold): {acc:.3f}")
  861. print(f"Best params (inner CV): {model.metrics_['best_params']}")
  862. print(f"Classification report:\n{classification_report(y_test, y_pred)}")
  863. test_scores.append(acc)
  864. best_params_list.append(model.metrics_["best_params"])
  866. # ROC curve for this fold
  867. if hasattr(model.pipeline.named_steps["clf"], "predict_proba"):
  868. y_score = model.pipeline.predict_proba(X_test)[:, 1]
  869. else:
  870. y_score = model.pipeline.decision_function(X_test)
  871. fpr, tpr, _ = roc_curve(y_test, y_score)
  872. roc_auc = auc(fpr, tpr)
  873. roc_data.append((fpr, tpr, roc_auc, fold))
  874. fold += 1
  875. return test_scores, best_params_list, roc_data
  878. def aggregate_seed_metrics(aggregate_records, ml_dir):
  879. """
  880. Aggregate per-seed performance across models and write raw + summary outputs.
  882. Artifacts written (if records exist):
  883. - aggregate_seed_metrics_raw.csv
  884. - aggregate_seed_metrics_summary.csv
  885. - aggregate_seed_metrics_summary.txt
  887. Uses sample standard deviation (ddof=1) for across-seed variability.
  889. Args:
  890. aggregate_records (list of dict):
  891. Each dict has keys:
  892. {'model': str, 'seed': int,
  893. 'nested_mean_acc': float,
  894. 'holdout_accuracy': float,
  895. 'holdout_auc': float}
  896. ml_dir (str): Base training output directory.
  898. Returns:
  899. summary_df (pandas.DataFrame or None): Summary dataframe or None if no records.
  900. """
  901. if not aggregate_records:
  902. print("No aggregate records to summarize.")
  903. return None
  905. agg_df = pd.DataFrame(aggregate_records)
  906. agg_csv = os.path.join(ml_dir, "aggregate_seed_metrics_raw.csv")
  907. agg_df.to_csv(agg_csv, index=False)
  909. # Compute summary stats for all metrics if present
  910. summary_rows = []
  911. for model_name, grp in agg_df.groupby("model"):
  912. n = len(grp)
  914. def ci95(mean, std, n):
  915. if n > 1:
  916. ci = 1.96 * (std / np.sqrt(n))
  917. return ci
  918. else:
  919. return np.nan
  921. # Helper to get mean, std, ci for a column if present
  922. def metric_stats(col):
  923. if col in grp:
  924. mean = grp[col].mean()
  925. std = grp[col].std(ddof=1)
  926. ci = ci95(mean, std, n)
  927. return mean, ci
  928. else:
  929. return np.nan, np.nan
  931. nested_mean_acc_mean, nested_mean_acc_ci = metric_stats("nested_mean_acc")
  932. holdout_acc_mean, holdout_acc_ci = metric_stats("holdout_accuracy")
  933. holdout_auc_mean, holdout_auc_ci = metric_stats("holdout_auc")
  934. holdout_precision_mean, holdout_precision_ci = metric_stats("holdout_precision")
  935. holdout_recall_mean, holdout_recall_ci = metric_stats("holdout_recall")
  936. holdout_specificity_mean, holdout_specificity_ci = metric_stats(
  937. "holdout_specificity"
  938. )
  939. holdout_f1_mean, holdout_f1_ci = metric_stats("holdout_f1")
  941. summary_rows.append(
  942. {
  943. "model": model_name,
  944. "seeds": grp.seed.tolist(),
  945. "n_seeds": n,
  946. "nested_mean_acc_mean": nested_mean_acc_mean,
  947. "nested_mean_acc_ci": nested_mean_acc_ci,
  948. "holdout_acc_mean": holdout_acc_mean,
  949. "holdout_acc_ci": holdout_acc_ci,
  950. "holdout_auc_mean": holdout_auc_mean,
  951. "holdout_auc_ci": holdout_auc_ci,
  952. "holdout_precision_mean": holdout_precision_mean,
  953. "holdout_precision_ci": holdout_precision_ci,
  954. "holdout_recall_mean": holdout_recall_mean,
  955. "holdout_recall_ci": holdout_recall_ci,
  956. "holdout_specificity_mean": holdout_specificity_mean,
  957. "holdout_specificity_ci": holdout_specificity_ci,
  958. "holdout_f1_mean": holdout_f1_mean,
  959. "holdout_f1_ci": holdout_f1_ci,
  960. }
  961. )
  962. summary_df = pd.DataFrame(summary_rows)
  963. summary_csv = os.path.join(ml_dir, "aggregate_seed_metrics_summary.csv")
  964. summary_df.to_csv(summary_csv, index=False)
  966. summary_txt = os.path.join(ml_dir, "aggregate_seed_metrics_summary.txt")
  967. with open(summary_txt, "w") as f:
  968. f.write("Aggregated Seed Performance Summary\n")
  969. f.write("=" * 40 + "\n\n")
  970. for _, row in summary_df.iterrows():
  971. f.write(f"Model: {row['model']}\n")
  972. f.write(f"Seeds: {row['seeds']}\n")
  973. # Nested CV accuracy
  974. if not np.isnan(row["nested_mean_acc_ci"]):
  975. f.write(
  976. f"Nested Mean Acc (mean, 95% CI): {row['nested_mean_acc_mean']:.3f} ± {row['nested_mean_acc_ci']:.3f} [{row['nested_mean_acc_mean']-row['nested_mean_acc_ci']:.3f}, {row['nested_mean_acc_mean']+row['nested_mean_acc_ci']:.3f}]\n"
  977. )
  978. else:
  979. f.write(f"Nested Mean Acc (mean): {row['nested_mean_acc_mean']:.3f}\n")
  981. # Holdout metrics
  982. def write_metric(label, mean, ci):
  983. if not np.isnan(ci):
  984. f.write(
  985. f"{label} (mean, 95% CI): {mean:.3f} ± {ci:.3f} [{mean-ci:.3f}, {mean+ci:.3f}]\n"
  986. )
  987. else:
  988. f.write(f"{label} (mean): {mean:.3f}\n")
  990. write_metric(
  991. "Hold-out Accuracy", row["holdout_acc_mean"], row["holdout_acc_ci"]
  992. )
  993. write_metric(
  994. "Hold-out Precision",
  995. row["holdout_precision_mean"],
  996. row["holdout_precision_ci"],
  997. )
  998. write_metric(
  999. "Hold-out Recall", row["holdout_recall_mean"], row["holdout_recall_ci"]
  1000. )
  1001. write_metric(
  1002. "Hold-out Specificity",
  1003. row["holdout_specificity_mean"],
  1004. row["holdout_specificity_ci"],
  1005. )
  1006. write_metric(
  1007. "Hold-out F1 Score", row["holdout_f1_mean"], row["holdout_f1_ci"]
  1008. )
  1009. write_metric("Hold-out AUC", row["holdout_auc_mean"], row["holdout_auc_ci"])
  1010. f.write("-" * 40 + "\n")
  1012. print(f"Aggregation raw CSV written to: {agg_csv}")
  1013. print(f"Aggregation summary CSV written to: {summary_csv}")
  1014. print(f"Aggregation summary TXT written to: {summary_txt}")
  1015. return summary_df
  1018. def aggregate_feature_usage(feature_usage, ml_dir, top_n=None):
  1019. """
  1020. Aggregate feature usage across seeds for each model.
  1022. Args:
  1023. feature_usage (dict):
  1024. Keys are model names (str).
  1025. Values are lists of dicts with keys:
  1026. {'seed': int, 'features': list of str (ordered by importance), 'signed_coefficients': dict (optional, for LR)}
  1027. ml_dir (str): Base training output directory.
  1028. top_n (int or None): If provided, only consider top N features from each seed
  1030. Returns
  1031. bool or None: True if aggregation done, None if no records.
  1032. """
  1034. if not feature_usage:
  1035. print("No feature usage records to aggregate.")
  1036. return None
  1038. report_lines = ["Aggregated Feature Usage Across Models", "=" * 50, ""]
  1040. for model_name, records in feature_usage.items():
  1041. if not records:
  1042. continue
  1043. model_dir = os.path.join(ml_dir, model_name)
  1044. os.makedirs(model_dir, exist_ok=True)
  1046. # Collect all features and ranks
  1047. rank_maps = [] # list of dict(feature -> rank index starting at 1)
  1048. coef_maps = [] # list of dict(feature -> signed coefficient) for LR models
  1049. has_coefs = False
  1050. for rec in records:
  1051. feats = rec["features"]
  1052. if top_n is not None:
  1053. feats = feats[:top_n]
  1054. rank_map = {f: i + 1 for i, f in enumerate(feats)}
  1055. rank_maps.append(rank_map)
  1056. if "signed_coefficients" in rec:
  1057. coef_maps.append(rec["signed_coefficients"])
  1058. has_coefs = True
  1060. # Count occurrences
  1061. all_features = [f for rm in rank_maps for f in rm.keys()]
  1062. counter = Counter(all_features)
  1063. n_seeds = len(rank_maps)
  1065. rows = []
  1066. for feat, cnt in counter.items():
  1067. ranks = [rm[feat] for rm in rank_maps if feat in rm]
  1068. row_dict = {
  1069. "feature": feat,
  1070. "count": cnt,
  1071. "proportion": cnt / n_seeds,
  1072. "in_all_seeds": cnt == n_seeds,
  1073. "mean_rank": float(np.mean(ranks)),
  1074. "median_rank": float(np.median(ranks)),
  1075. "best_rank": int(np.min(ranks)),
  1076. "worst_rank": int(np.max(ranks)),
  1077. }
  1078. # Add mean signed coefficient and direction if available (for LR)
  1079. if has_coefs:
  1080. coefs = [cm[feat] for cm in coef_maps if feat in cm]
  1081. if coefs:
  1082. row_dict["mean_signed_coef"] = float(np.mean(coefs))
  1083. row_dict["direction"] = "INCREASES_PTS" if np.mean(coefs) > 0 else "DECREASES_PTS"
  1084. rows.append(row_dict)
  1086. df = pd.DataFrame(rows).sort_values(
  1087. ["in_all_seeds", "count", "mean_rank"], ascending=[False, False, True]
  1088. )
  1089. out_csv = os.path.join(model_dir, "feature_usage_summary.csv")
  1090. df.to_csv(out_csv, index=False)
  1091. print(f"Feature usage summary written for model '{model_name}' -> {out_csv}")
  1093. # Append to report
  1094. report_lines.append(f"Model: {model_name}")
  1095. report_lines.append(f"Seeds analyzed: {n_seeds}")
  1096. report_lines.append("Top recurring features (first 15 shown):")
  1097. head_df = df.head(15)
  1098. # Format output with direction indicator if available
  1099. if has_coefs and "direction" in df.columns:
  1100. report_lines.append(head_df.to_string(index=False))
  1101. else:
  1102. report_lines.append(head_df.to_string(index=False))
  1103. report_lines.append("-" * 50)
  1105. # Write consolidated report
  1106. consolidated_path = os.path.join(ml_dir, "feature_usage_across_models.txt")
  1107. with open(consolidated_path, "w") as f:
  1108. f.write("\n".join(report_lines))
  1109. print(f"Consolidated feature usage report written to: {consolidated_path}")
  1110. return True
  1113. def main():
  1114. """
  1115. Main function to run and save multiple ML pipelines on patient features.
  1117. Args:
  1118. None
  1120. Returns:
  1121. None
  1122. """
  1124. BASE_FOLDER = os.path.dirname(os.path.abspath(__file__))
  1125. FEATURES_CSV = os.path.join(BASE_FOLDER, "trainingML", "patient_features.csv")
  1126. ML_DIR = os.path.join(BASE_FOLDER, "trainingML")
  1127. os.makedirs(ML_DIR, exist_ok=True)
  1129. exclude_col = ["subj_id", "mrn"]
  1130. ground_truth = ["pts"]
  1132. # Parameter Setup
  1133. # Option A: All social determinant columns (and sex) are assumed already numerically encoded.
  1134. # We therefore disable special categorical processing and treat them as numeric features.
  1135. ORD_CATEGORIES = None
  1137. # ------- CHANGE THIS FOR RUNS -------
  1138. EXCLUDE_COL_MATCH = []
  1139. # Can exclude columns that match any of these substrings
  1140. # e.g. EXCLUDE_COL_MATCH = ["RL_diff","RL_ratio", "RL_absdiff"]
  1141. # N_FEATURES removed: k will be tuned via param_grid select__k
  1143. # def generate_seeds(num_seeds=10, seed_min=1, seed_max=10000):
  1144. # """Generate a list of random integers for use as SEEDS."""
  1145. # return random.sample(range(seed_min, seed_max + 1), num_seeds)
  1146. # SEEDS = generate_seeds(num_seeds=25, seed_min=1, seed_max=10000)
  1147. SEEDS = [
  1148. # Seeds generated using Google RNG 1000-9999
  1149. 1292,
  1150. 4337,
  1151. 5590,
  1152. 3348,
  1153. 3930,
  1154. 2253,
  1155. 2400,
  1156. 7705,
  1157. 6993,
  1158. 7322,
  1159. ]
  1161. # param_grids for models
  1162. random_forest_params = {
  1163. "select__k": [10, 20, 30, 40, None],
  1164. "clf__n_estimators": [100, 200],
  1165. "clf__max_depth": [None, 5, 10],
  1166. }
  1168. logistic_regression_params = {
  1169. "select__k": [10, 20, 30, 40, None],
  1170. "clf__C": [0.1, 1, 10],
  1171. "clf__penalty": ["l2"],
  1172. }
  1174. xgboost_params = {
  1175. "select__k": [10, 20, 30, 40, 50],
  1176. "clf__max_depth": [3, 5, 7],
  1177. "clf__n_estimators": [100, 200],
  1178. "clf__learning_rate": [0.01, 0.1, 0.2],
  1179. }
  1181. xgboost_rf_params = {
  1182. "select__k": [10, 20, 30, 40, 50],
  1183. "clf__max_depth": [3, 5, 7],
  1184. "clf__n_estimators": [100, 200],
  1185. "clf__learning_rate": [0.01, 0.1, 0.2],
  1186. "clf__subsample": [0.8, 1.0],
  1187. }
  1189. OUTER_CV = 5
  1190. INNER_CV = 5
  1192. # ------------------------------------
  1194. X, y = NIFTIpatient.load_all_patients(
  1195. FEATURES_CSV,
  1196. exclude_col=exclude_col,
  1197. ground_truth=ground_truth,
  1198. exclude_col_match=EXCLUDE_COL_MATCH,
  1199. )
  1201. # Convert y to 1D array to avoid warnings
  1202. y = y.values.ravel()
  1204. # Replace sentinel -1 with NaN so median imputation can appropriately handle missingness.
  1205. # (Assumes -1 represents missing / not on file; adjust if you want to keep it as a separate value.)
  1206. X = X.replace(-1, np.nan)
  1208. # Aggregation container: list of dict records
  1209. aggregate_records = []
  1210. # Feature usage across seeds per model: model -> list of {seed, features}
  1211. feature_usage = defaultdict(list)
  1212. # Holdout ROC data for summary plot: model -> list of (fpr, tpr, auc, seed)
  1213. holdout_roc_data = defaultdict(list)
  1215. for seed in SEEDS:
  1216. # Define as many models as you want here
  1217. models = [
  1218. (
  1219. "rf",
  1220. RandomForestMLPipeline(
  1221. param_grid=random_forest_params,
  1222. random_state=seed,
  1223. ord_categories=ORD_CATEGORIES,
  1224. ),
  1225. ),
  1226. (
  1227. "lr",
  1228. LogisticRegressionMLPipeline(
  1229. param_grid=logistic_regression_params,
  1230. random_state=seed,
  1231. ord_categories=ORD_CATEGORIES,
  1232. ),
  1233. ),
  1234. (
  1235. "xgb",
  1236. XGBoostMLPipeline(
  1237. param_grid=xgboost_params,
  1238. random_state=seed,
  1239. ord_categories=ORD_CATEGORIES,
  1240. ),
  1241. ),
  1242. (
  1243. "xgbrf",
  1244. XGBoostRFMLPipeline(
  1245. param_grid=xgboost_rf_params,
  1246. random_state=seed,
  1247. ord_categories=ORD_CATEGORIES,
  1248. ),
  1249. ),
  1250. ]
  1252. # Save initial predictors (before pipeline steps) to each model folder
  1253. initial_predictors = list(X.columns)
  1254. exclude_str = "-".join(EXCLUDE_COL_MATCH)
  1256. for name, pipeline in models:
  1257. # New directory hierarchy: trainingML/{model}/seed{seed}_excl{exclude}/
  1258. model_base_dir = os.path.join(ML_DIR, name)
  1259. os.makedirs(model_base_dir, exist_ok=True)
  1260. exclude_segment = f"_excl{exclude_str}" if exclude_str else ""
  1261. run_dir = os.path.join(model_base_dir, f"seed{seed}{exclude_segment}")
  1262. nested_dir = os.path.join(run_dir, f"nested_outer{OUTER_CV}inner{INNER_CV}")
  1263. final_dir = os.path.join(run_dir, "final")
  1264. os.makedirs(nested_dir, exist_ok=True)
  1265. os.makedirs(final_dir, exist_ok=True)
  1267. # --- Nested CV artifacts ---
  1268. initial_predictors_csv = os.path.join(
  1269. nested_dir, f"{name}_initial_predictors.csv"
  1270. )
  1271. pd.Series(initial_predictors, name="predictor").to_csv(
  1272. initial_predictors_csv, index=False
  1273. )
  1274. print(f"Initial predictors saved to: {initial_predictors_csv}")
  1276. print(f"\nRunning nested CV for pipeline: {name}")
  1277. test_scores, best_params_list, cv_roc_data = nested_cv_evaluate(
  1278. pipeline, X, y, outer_cv=OUTER_CV, inner_cv=INNER_CV, search_type="grid"
  1279. )
  1280. print(
  1281. f"\n{name} mean test accuracy (nested CV): {np.mean(test_scores):.3f} ± {np.std(test_scores):.3f}"
  1282. )
  1284. nested_roc_plot_path = os.path.join(
  1285. nested_dir, f"{name}_nestedcv_roc_curves.png"
  1286. )
  1287. nested_roc_csv_path = os.path.join(
  1288. nested_dir, f"{name}_nestedcv_roc_data.csv"
  1289. )
  1290. ROCCurvePlotter.plot_nested_cv_roc_curves(
  1291. cv_roc_data,
  1292. save_path=nested_roc_plot_path,
  1293. title=f"Nested CV ROC Curves: {name}",
  1294. csv_path=nested_roc_csv_path,
  1295. )
  1296. print(f"Nested CV ROC curves saved to: {nested_roc_plot_path}")
  1297. print(f"Nested CV ROC data saved to: {nested_roc_csv_path}")
  1299. # --- Final model training with 80/20 hold-out using best hyperparameters from nested CV ---
  1300. print(
  1301. f"\nDeriving final hyperparameters for {name} from nested CV folds..."
  1302. )
  1303. # Strategy: choose the params from the fold with highest test score
  1304. best_fold_idx = int(np.argmax(test_scores))
  1305. chosen_params = best_params_list[best_fold_idx]
  1306. print(f"Selected params from fold {best_fold_idx+1}: {chosen_params}")
  1308. # 80/20 stratified split
  1309. X_train, X_test, y_train, y_test = train_test_split(
  1310. X,
  1311. y,
  1312. test_size=0.20,
  1313. random_state=seed,
  1314. stratify=y,
  1315. )
  1316. print(
  1317. f"Training final {name} model on 80% of data (hold-out 20% for unbiased evaluation)..."
  1318. )
  1320. # Instantiate clean pipeline of same type
  1321. final_model = type(pipeline)(
  1322. random_state=pipeline.random_state,
  1323. ord_categories=pipeline.ord_categories,
  1324. )
  1326. # Apply chosen hyperparameters directly (except select__k if None -> 'all')
  1327. final_model.pipeline.set_params(**chosen_params)
  1329. # Fit on training split only
  1330. final_model.pipeline.fit(X_train, y_train)
  1332. from sklearn.metrics import (
  1333. precision_score,
  1334. recall_score,
  1335. f1_score,
  1336. roc_auc_score,
  1337. )
  1339. # Compute train metrics
  1340. y_train_pred = final_model.pipeline.predict(X_train)
  1341. train_acc = accuracy_score(y_train, y_train_pred)
  1342. train_cm = confusion_matrix(y_train, y_train_pred)
  1343. train_cr = classification_report(y_train, y_train_pred)
  1344. # Train specificity
  1345. if train_cm.shape == (2, 2):
  1346. tn, fp, fn, tp = train_cm.ravel()
  1347. train_specificity = tn / (tn + fp) if (tn + fp) > 0 else np.nan
  1348. else:
  1349. train_specificity = np.nan
  1350. # Train AUC
  1351. try:
  1352. if hasattr(final_model.pipeline.named_steps["clf"], "predict_proba"):
  1353. y_train_score = final_model.pipeline.predict_proba(X_train)[:, 1]
  1354. else:
  1355. y_train_score = final_model.pipeline.decision_function(X_train)
  1356. train_auc_val = roc_auc_score(y_train, y_train_score)
  1357. except Exception:
  1358. train_auc_val = np.nan
  1360. # Compute test metrics
  1361. y_test_pred = final_model.pipeline.predict(X_test)
  1362. test_acc = accuracy_score(y_test, y_test_pred)
  1363. test_cm = confusion_matrix(y_test, y_test_pred)
  1364. test_cr = classification_report(y_test, y_test_pred)
  1365. # Test specificity
  1366. if test_cm.shape == (2, 2):
  1367. tn, fp, fn, tp = test_cm.ravel()
  1368. test_specificity = tn / (tn + fp) if (tn + fp) > 0 else np.nan
  1369. else:
  1370. test_specificity = np.nan
  1371. # Test AUC
  1372. if hasattr(final_model.pipeline.named_steps["clf"], "predict_proba"):
  1373. y_test_score = final_model.pipeline.predict_proba(X_test)[:, 1]
  1374. else:
  1375. y_test_score = final_model.pipeline.decision_function(X_test)
  1376. test_fpr, test_tpr, _ = roc_curve(y_test, y_test_score)
  1377. test_auc_val = auc(test_fpr, test_tpr)
  1379. # Store holdout ROC data for summary plot
  1380. holdout_roc_data[name].append((test_fpr, test_tpr, test_auc_val, seed))
  1382. # Feature importances/coefficients after fit
  1383. top_series = None
  1384. signed_coefs_series = None
  1385. if (
  1386. hasattr(final_model.pipeline.named_steps["clf"], "feature_importances_")
  1387. and "select" in final_model.pipeline.named_steps
  1388. ):
  1389. preprocessed_feature_names = final_model.get_preprocessed_feature_names(
  1390. final_model.pipeline, X_train
  1391. )
  1392. if "var_thresh" in final_model.pipeline.named_steps:
  1393. var_thresh_mask = final_model.pipeline.named_steps[
  1394. "var_thresh"
  1395. ].get_support()
  1396. features_after_var = np.array(preprocessed_feature_names)[
  1397. var_thresh_mask
  1398. ]
  1399. else:
  1400. features_after_var = preprocessed_feature_names
  1401. selected_mask = final_model.pipeline.named_steps["select"].get_support()
  1402. selected_features = features_after_var[selected_mask]
  1403. importances = final_model.pipeline.named_steps[
  1404. "clf"
  1405. ].feature_importances_
  1406. top_series = pd.Series(
  1407. importances, index=selected_features
  1408. ).sort_values(ascending=False)
  1409. elif (
  1410. hasattr(final_model.pipeline.named_steps["clf"], "coef_")
  1411. and "select" in final_model.pipeline.named_steps
  1412. ):
  1413. preprocessed_feature_names = final_model.get_preprocessed_feature_names(
  1414. final_model.pipeline, X_train
  1415. )
  1416. if "var_thresh" in final_model.pipeline.named_steps:
  1417. var_thresh_mask = final_model.pipeline.named_steps[
  1418. "var_thresh"
  1419. ].get_support()
  1420. features_after_var = np.array(preprocessed_feature_names)[
  1421. var_thresh_mask
  1422. ]
  1423. else:
  1424. features_after_var = preprocessed_feature_names
  1425. selected_mask = final_model.pipeline.named_steps["select"].get_support()
  1426. selected_features = features_after_var[selected_mask]
  1427. coefs = np.abs(final_model.pipeline.named_steps["clf"].coef_[0])
  1428. top_series = pd.Series(coefs, index=selected_features).sort_values(
  1429. ascending=False
  1430. )
  1431. # Store signed coefficients for direction interpretation
  1432. signed_coefs = final_model.pipeline.named_steps["clf"].coef_[0]
  1433. signed_coefs_series = pd.Series(signed_coefs, index=selected_features)
  1434. else:
  1435. top_series = None
  1436. signed_coefs_series = None
  1438. final_model.metrics_ = {
  1439. "best_params": chosen_params,
  1440. # Train
  1441. "train_accuracy": train_acc,
  1442. "train_precision": precision_score(
  1443. y_train, y_train_pred, zero_division=0
  1444. ),
  1445. "train_recall": recall_score(y_train, y_train_pred, zero_division=0),
  1446. "train_specificity": train_specificity,
  1447. "train_f1": f1_score(y_train, y_train_pred, zero_division=0),
  1448. "train_auc": train_auc_val,
  1449. "train_confusion_matrix": train_cm,
  1450. "train_classification_report": train_cr,
  1451. # Test
  1452. "test_accuracy": test_acc,
  1453. "test_precision": precision_score(y_test, y_test_pred, zero_division=0),
  1454. "test_recall": recall_score(y_test, y_test_pred, zero_division=0),
  1455. "test_specificity": test_specificity,
  1456. "test_f1": f1_score(y_test, y_test_pred, zero_division=0),
  1457. "test_auc": test_auc_val,
  1458. "test_confusion_matrix": test_cm,
  1459. "test_classification_report": test_cr,
  1460. }
  1461. if top_series is not None:
  1462. final_model.metrics_["top_features"] = top_series
  1463. # Record ordered list for feature usage aggregation (includes signed coefficients if LR)
  1464. feature_record = {"seed": seed, "features": top_series.index.tolist()}
  1465. if signed_coefs_series is not None:
  1466. feature_record["signed_coefficients"] = signed_coefs_series.to_dict()
  1467. feature_usage[name].append(feature_record)
  1468. else:
  1469. # Still record placeholder to keep seed count alignment (optional)
  1470. feature_usage[name].append({"seed": seed, "features": []})
  1472. print(
  1473. f"Hold-out test accuracy (20%): {test_acc:.3f} | AUC: {test_auc_val:.3f}"
  1474. )
  1476. # Save final model + metrics incorporating nested CV context (still reported in header)
  1477. model_path = os.path.join(final_dir, f"{name}_final_model.pkl")
  1478. metrics_path = os.path.join(final_dir, f"{name}_comprehensive_metrics.txt")
  1479. final_model.save(
  1480. model_path=model_path,
  1481. metrics_path=metrics_path,
  1482. nested_cv_results=(test_scores, best_params_list, name),
  1483. )
  1485. # Selected predictors after final training (top features if available else all)
  1486. predictors_csv = os.path.join(final_dir, f"{name}_predictors.csv")
  1487. if top_series is not None:
  1488. selected_features = top_series.index.tolist()
  1489. else:
  1490. selected_features = list(X.columns)
  1491. pd.Series(selected_features, name="predictor").to_csv(
  1492. predictors_csv, index=False
  1493. )
  1494. print(f"Predictors saved to: {predictors_csv}")
  1496. # Final ROC curve (hold-out test curve)
  1497. holdout_roc_plot_path = os.path.join(
  1498. final_dir, f"{name}_holdout_roc_curve.png"
  1499. )
  1500. plotter = ROCCurvePlotter(
  1501. y_true=y_test,
  1502. y_score=y_test_score,
  1503. title=f"Hold-out ROC Curve: {name} (seed={seed})",
  1504. )
  1505. plotter.plot(show=False, save_path=holdout_roc_plot_path)
  1506. print(f"Hold-out ROC curve saved to: {holdout_roc_plot_path}")
  1508. # Record aggregation metrics
  1509. aggregate_records.append(
  1510. {
  1511. "model": name,
  1512. "seed": seed,
  1513. "nested_mean_acc": float(np.mean(test_scores)),
  1514. "nested_std_acc": float(np.std(test_scores)),
  1515. "holdout_accuracy": float(test_acc),
  1516. "holdout_precision": float(final_model.metrics_.get("test_precision", np.nan)),
  1517. "holdout_recall": float(final_model.metrics_.get("test_recall", np.nan)),
  1518. "holdout_specificity": float(final_model.metrics_.get("test_specificity", np.nan)),
  1519. "holdout_f1": float(final_model.metrics_.get("test_f1", np.nan)),
  1520. "holdout_auc": float(test_auc_val),
  1521. "best_params": chosen_params,
  1522. "num_features_top": (
  1523. len(top_series) if top_series is not None else 0
  1524. ),
  1525. }
  1526. )
  1528. # After all seeds processed, plot summary ROC curves for each model
  1529. for name, roc_data in holdout_roc_data.items():
  1530. summary_roc_path = os.path.join(
  1531. ML_DIR, name, f"{name}_holdout_roc_curves_across_seeds.png"
  1532. )
  1533. summary_roc_csv = os.path.join(
  1534. ML_DIR, name, f"{name}_holdout_roc_data_across_seeds.csv"
  1535. )
  1536. ROCCurvePlotter.plot_holdout_roc_curves_across_seeds(
  1537. roc_data,
  1538. save_path=summary_roc_path,
  1539. title=f"Holdout ROC Curves Across Seeds: {name}",
  1540. csv_path=summary_roc_csv,
  1541. )
  1542. print(f"Summary holdout ROC curves saved to: {summary_roc_path}")
  1543. print(f"Summary holdout ROC data saved to: {summary_roc_csv}")
  1545. # Aggregate & write summaries
  1546. aggregate_seed_metrics(aggregate_records, ML_DIR)
  1547. # Aggregate feature usage across seeds per model
  1548. aggregate_feature_usage(feature_usage, ML_DIR, top_n=None)
  1551. if __name__ == "__main__":
  1552. main()

NIFTItraining.py at commit 550fe2e, no license · at the source

Overview

Authors: Mark Chao1, Monica Mallavarapu1, Matthew De Guzman1, Lauren Nguyen1, Nathan Nguyen1, Jerome Jeevarajan1
ORCID iDs: Mark Chao
  1. Department of Neurology, McGovern Medical School, The University of Texas Health Houston, 6431 Fannin St, MSB 7.005E, Houston, TX 77030 USA
Institutions: The University of Texas Health Science Center at Houston (United States)
Journal: Scientific reports, volume 16, issue 1, article 21655
Dates: received 31 December 2025; accepted 3 April 2026; published online 12 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-47942-4 · PMID 42120454 · PMCID PMC13357838 · OpenAlex W7160954675
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), human (organism), other condition (population), epilepsy (population), traumatic brain injury (population), clinical / translational (subfield)
Methods: Connectivity, Statistics, Machine learning
Keywords: Traumatic brain injury, Post-traumatic epilepsy, Computed tomography, Radiomics, Machine learning, Biomarkers, Medical research, Neurology, Neuroscience
MeSH: Brain Injuries, Traumatic*, Epilepsy, Post-Traumatic*, Seizures*, Tomography, X-Ray Computed*, Adult, Biomarkers, Female, Glasgow Coma Scale, Humans, Machine Learning, Male, Middle Aged, Pilot Projects, Radiomics (* major topic)
Topic: Traumatic Brain Injury and Neurovascular Disturbances (Neurology, Medicine), according to OpenAlex
Citations: not cited yet (Europe PMC); 19 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above, with 3 matches between paragraphs and lines of code.

makchow/NIFTIProcessing-Published

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 550fe2ee3a3c4da28b6727907de305a178306fdf, 23 February 2026
Languages: Python (3)
Size: 305 files, 3 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (3 files), pandas (3 files), NiBabel (2 files), dcm2niix (1 file), FSL (1 file), Matplotlib (1 file), PyRadiomics (1 file), scikit-learn (1 file), SciPy (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
4 files
At the source: github.com/makchow/NIFTIProcessing-Published

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

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-47942-4.

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

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 9 keywords, 14 MeSH terms, 17 references.

Cite

This paper

Chao, M., Mallavarapu, M., De Guzman, M., Nguyen, L., Nguyen, N., & Jeevarajan, J. (2026). CT-based radiomic markers to predict late-onset seizures after traumatic brain injury. Scientific reports, 16(1), 21655. https://doi.org/10.1038/s41598-026-47942-4

BibTeX

@article{chao2026ct,
author = {Chao, Mark and Mallavarapu, Monica and De Guzman, Matthew and Nguyen, Lauren and Nguyen, Nathan and Jeevarajan, Jerome},
title = {{CT-based radiomic markers to predict late-onset seizures after traumatic brain injury}},
journal = {Scientific reports},
year = {2026},
month = may,
volume = {16},
number = {1},
pages = {21655},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-47942-4},
url = {https://doi.org/10.1038/s41598-026-47942-4},
pmid = {42120454},
pmcid = {PMC13357838}
}

RIS

TY - JOUR
AU - Chao, Mark
AU - Mallavarapu, Monica
AU - De Guzman, Matthew
AU - Nguyen, Lauren
AU - Nguyen, Nathan
AU - Jeevarajan, Jerome
TI - CT-based radiomic markers to predict late-onset seizures after traumatic brain injury
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/05/12
VL - 16
IS - 1
SP - 21655
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-47942-4
UR - https://doi.org/10.1038/s41598-026-47942-4
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-47942-4",
"type": "article-journal",
"title": "CT-based radiomic markers to predict late-onset seizures after traumatic brain injury",
"container-title": "Scientific reports",
"author": [
{
"family": "Chao",
"given": "Mark"
},
{
"family": "Mallavarapu",
"given": "Monica"
},
{
"family": "De Guzman",
"given": "Matthew"
},
{
"family": "Nguyen",
"given": "Lauren"
},
{
"family": "Nguyen",
"given": "Nathan"
},
{
"family": "Jeevarajan",
"given": "Jerome"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "21655",
"DOI": "10.1038/s41598-026-47942-4",
"PMID": "42120454",
"PMCID": "PMC13357838",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-47942-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
12
]
]
}
}

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/s41598-026-56688-y [code]
On the value of radiomics in addition to clinical measures in emotional conflict fMRI for predicting sertraline response in major depressive disorder.
Journal: Scientific reports
In common: PyRadiomics, XGBoost, FSL, 6 other tools, 1 reference
[2] doi:10.1162/netn.a.547 [code]
An evaluation of the efficacy of single-echo and multi-echo fMRI denoising strategies.
Journal: Network neuroscience (Cambridge, Mass.)
In common: dcm2niix, FSL, NiBabel, 5 other tools, 1 reference
[3] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: PyRadiomics, XGBoost, NiBabel, 5 other tools, other
[4] doi:10.1186/s13244-026-02365-7 [code]
Super-resolution MRI and 2.5D deep learning for intratumoral-peritumoral radiomics in preoperative prediction of rectal cancer perineural invasion.
Journal: Insights into imaging
In common: PyRadiomics, XGBoost, NiBabel, 5 other tools, other condition
[5] doi:10.3390/cancers18162636 [code]
Exploring the Impact of T2-Weighted MRI Fat Saturation on Radiomics Stability for Brain Radionecrosis Prediction After Skull-Base Proton Therapy: A Pilot Study.
Journal: Cancers
In common: PyRadiomics, FSL, scikit-learn, 4 other tools, clinical / translational, 1 reference
[6] 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: XGBoost, FSL, NiBabel, 5 other tools, epilepsy, clinical / translational
[7] doi:10.1371/journal.pone.0356382 [code]
Evaluating the impact of segmentation strategies on radiomic feature stability for paediatric brain tumour diagnosis using diffusion weighted imaging.
Journal: PloS one
In common: PyRadiomics, NiBabel, scikit-learn, 3 other tools, clinical / translational, other condition, 1 reference
[8] doi:10.1038/s41467-026-71918-7 [code]
Developmental disinhibition gates language lateralization in childhood.
Journal: Nature communications
In common: dcm2niix, FSL, NiBabel, 5 other tools
[9] doi:10.1038/s41597-026-07248-6 [code]
A large-scale fMRI dataset for vision-language semantic association.
Journal: Scientific data
In common: dcm2niix, FSL, NiBabel, 5 other tools
[10] doi:10.1038/s41467-026-71719-y [code]
Brain functional-structural gradient coupling reflects development, behavior and genetic influences.
Journal: Nature communications
In common: dcm2niix, FSL, NiBabel, 5 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.